Changeset 4200


Ignore:
Timestamp:
07/15/08 10:51:58 (12 years ago)
Author:
melissa
Message:
  • Minor code cleanup.
  • Added MinimalTiffReader - this is extended by BaseTiffReader, and provides a way to read just the pixels from a TIFF file.
Location:
trunk/loci/formats
Files:
1 added
43 edited

Legend:

Unmodified
Added
Removed
  • trunk/loci/formats/DataTools.java

    r4103 r4200  
    697697  } 
    698698 
     699  public static byte[] readPlane(RandomAccessStream in, int x, int y, int w, 
     700    int h, IFormatReader r, byte[] buf) throws IOException 
     701  { 
     702    int c = r.getSizeC(); 
     703    int bpp = FormatTools.getBytesPerPixel(r.getPixelType()); 
     704    if (x == 0 && y == 0 && w == r.getSizeX() && h == r.getSizeY()) { 
     705      in.read(buf); 
     706    } 
     707    else if (x == 0 && w == r.getSizeX()) { 
     708      if (r.isInterleaved()) { 
     709        in.skipBytes(y * w * bpp * c); 
     710        in.read(buf, 0, h * w * bpp * c); 
     711      } 
     712      else { 
     713        int rowLen = w * bpp; 
     714        for (int channel=0; channel<c; channel++) { 
     715          in.skipBytes(y * rowLen); 
     716          in.read(buf, channel * h * rowLen, h * rowLen); 
     717          in.skipBytes((r.getSizeY() - y - h) * rowLen); 
     718        } 
     719      } 
     720    } 
     721    else { 
     722      if (r.isInterleaved()) { 
     723        in.skipBytes(y * r.getSizeX() * bpp * c); 
     724        for (int row=0; row<h; row++) { 
     725          in.skipBytes(x * bpp * c); 
     726          in.read(buf, row * w * bpp * c, w * bpp * c); 
     727          in.skipBytes(bpp * c * (r.getSizeX() - w - x)); 
     728        } 
     729      } 
     730      else { 
     731        for (int channel=0; channel<c; channel++) { 
     732          in.skipBytes(y * r.getSizeX() * bpp); 
     733          for (int row=0; row<h; row++) { 
     734            in.skipBytes(x * bpp); 
     735            in.read(buf, channel * w * h * bpp + row * w * bpp, w * bpp); 
     736            in.skipBytes(bpp * (r.getSizeX() - w - x)); 
     737          } 
     738          in.skipBytes(r.getSizeX() * bpp * (r.getSizeY() - y - h)); 
     739        } 
     740      } 
     741    } 
     742 
     743    return buf; 
     744  } 
     745 
    699746  // -- Date handling -- 
    700747 
  • trunk/loci/formats/in/APLReader.java

    r4177 r4200  
    4343  private String[] tiffFiles; 
    4444  private String[] xmlFiles; 
    45   private TiffReader[] tiffReaders; 
     45  private MinimalTiffReader[] tiffReaders; 
    4646  private Vector used; 
    4747 
     
    144144    tiffFiles = new String[seriesCount]; 
    145145    xmlFiles = new String[seriesCount]; 
    146     tiffReaders = new TiffReader[seriesCount]; 
     146    tiffReaders = new MinimalTiffReader[seriesCount]; 
    147147 
    148148    MetadataStore store = 
     
    187187      used.add(tiffFiles[i]); 
    188188 
    189       tiffReaders[i] = new TiffReader(); 
     189      tiffReaders[i] = new MinimalTiffReader(); 
    190190      tiffReaders[i].setId(tiffFiles[i]); 
    191191 
  • trunk/loci/formats/in/APNGReader.java

    r4147 r4200  
    129129        !block.type.equals("acTL") && !block.type.equals("fcTL")) 
    130130      { 
    131         DataTools.unpackBytes(block.length, len, 0, 4, core.littleEndian[0]); 
     131        DataTools.unpackBytes(block.length, len, 0, 4, isLittleEndian()); 
    132132        stream.add(len); 
    133133        byte[] b = new byte[block.length + 8]; 
     
    137137        in.read(b, 4, b.length - 8); 
    138138        if (block.type.equals("IHDR")) { 
    139           DataTools.unpackBytes(coords[2], b, 4, 4, core.littleEndian[0]); 
    140           DataTools.unpackBytes(coords[3], b, 8, 4, core.littleEndian[0]); 
     139          DataTools.unpackBytes(coords[2], b, 4, 4, isLittleEndian()); 
     140          DataTools.unpackBytes(coords[3], b, 8, 4, isLittleEndian()); 
    141141        } 
    142142        int crc = (int) computeCRC(b, b.length - 4); 
     
    172172    BufferedImage b = ImageIO.read(dis); 
    173173    dis.close(); 
    174     BufferedImage first = openImage(0, 0, 0, core.sizeX[0], core.sizeY[0]); 
     174    BufferedImage first = openImage(0, 0, 0, getSizeX(), getSizeY()); 
    175175 
    176176    // paste current image onto first image 
     
    260260    core.sizeY[0] = img.getHeight(); 
    261261    core.rgb[0] = img.getRaster().getNumBands() > 1; 
    262     core.sizeC[0] = core.rgb[0] ? 3 : 1; 
     262    core.sizeC[0] = isRGB() ? 3 : 1; 
    263263    core.pixelType[0] = ImageTools.getPixelType(img); 
    264264 
  • trunk/loci/formats/in/AVIReader.java

    r4132 r4200  
    101101    FormatTools.checkBufferSize(this, buf.length, w, h); 
    102102 
    103     int bytes = FormatTools.getBytesPerPixel(core.pixelType[0]); 
     103    int bytes = FormatTools.getBytesPerPixel(getPixelType()); 
    104104    double p = ((double) bmpScanLineSize) / bmpBitsPerPixel; 
    105105    int effectiveWidth = (int) (bmpScanLineSize / p); 
    106     if (effectiveWidth == 0 || effectiveWidth < core.sizeX[0]) { 
    107       effectiveWidth = core.sizeX[0]; 
     106    if (effectiveWidth == 0 || effectiveWidth < getSizeX()) { 
     107      effectiveWidth = getSizeX(); 
    108108    } 
    109109 
     
    113113    if (bmpCompression != 0) { 
    114114      byte[] b = uncompress(no, buf); 
    115       int rowLen = w * bytes * core.sizeC[0]; 
     115      int rowLen = w * bytes * getSizeC(); 
    116116      for (int row=0; row<h; row++) { 
    117         System.arraycopy(b, (row + y) * core.sizeX[0] * bytes * core.sizeC[0], 
     117        System.arraycopy(b, (row + y) * getSizeX() * bytes * getSizeC(), 
    118118          buf, row * rowLen, rowLen); 
    119119      } 
     
    123123 
    124124    if (bmpBitsPerPixel < 8) { 
    125       int rawSize = bytes * core.sizeY[0] * effectiveWidth * core.sizeC[0]; 
     125      int rawSize = bytes * getSizeY() * effectiveWidth * getSizeC(); 
    126126      rawSize /= (8 / bmpBitsPerPixel); 
    127127 
    128128      byte[] b = new byte[rawSize]; 
    129129 
    130       int len = rawSize / core.sizeY[0]; 
     130      int len = rawSize / getSizeY(); 
    131131      in.read(b); 
    132132 
    133133      BitBuffer bb = new BitBuffer(b); 
    134       bb.skipBits(bmpBitsPerPixel * len * (core.sizeY[0] - h - y)); 
     134      bb.skipBits(bmpBitsPerPixel * len * (getSizeY() - h - y)); 
    135135 
    136136      for (int row=h; row>=y; row--) { 
     
    139139          buf[(row - y) * len + col] = (byte) bb.getBits(bmpBitsPerPixel); 
    140140        } 
    141         bb.skipBits(bmpBitsPerPixel * (core.sizeX[0] - w - x)); 
     141        bb.skipBits(bmpBitsPerPixel * (getSizeX() - w - x)); 
    142142      } 
    143143 
     
    145145    } 
    146146 
    147     int pad = bmpScanLineSize - core.sizeX[0]*(bmpBitsPerPixel / 8); 
    148     int scanline = w * (bmpBitsPerPixel / 8); 
    149  
    150     in.skipBytes(scanline * (core.sizeY[0] - h - y)); 
    151  
    152     if (core.sizeX[0] == w) { 
     147    int pad = bmpScanLineSize - getSizeX()*bytes; 
     148    int scanline = w * bytes; 
     149 
     150    in.skipBytes(scanline * (getSizeY() - h - y)); 
     151 
     152    if (getSizeX() == w) { 
    153153      in.read(buf); 
    154154    } 
     
    158158        in.read(buf, (i - y)*scanline, scanline); 
    159159        if (bmpBitsPerPixel == 24) { 
    160           for (int j=0; j<core.sizeX[0]; j++) { 
     160          for (int j=0; j<getSizeX(); j++) { 
    161161            byte r = buf[i*scanline + j*3 + 2]; 
    162162            buf[i*scanline + j*3 + 2] = buf[i*scanline + j*3]; 
     
    164164          } 
    165165        } 
    166         in.skipBytes((bmpBitsPerPixel / 8) * (core.sizeX[0] - w - x + pad)); 
     166        in.skipBytes(bytes * (getSizeX() - w - x + pad)); 
    167167      } 
    168168    } 
     
    170170    if (bmpBitsPerPixel == 16) { 
    171171      // channels are separated, need to swap them 
    172       byte[] r = new byte[core.sizeX[0] * core.sizeY[0] * 2]; 
     172      byte[] r = new byte[getSizeX() * getSizeY() * 2]; 
    173173      System.arraycopy(buf, 2 * (buf.length / 3), r, 0, r.length); 
    174174      System.arraycopy(buf, 0, buf, 2 * (buf.length / 3), r.length); 
     
    282282                addMeta("Length", new Integer(in.readInt())); 
    283283 
    284                 addMeta("Frame width", new Integer(core.sizeX[0])); 
     284                addMeta("Frame width", new Integer(getSizeX())); 
    285285 
    286286                if (spos + size <= in.length()) { 
     
    495495    core.indexed[0] = false; 
    496496    core.sizeZ[0] = 1; 
    497     core.sizeT[0] = core.imageCount[0]; 
     497    core.sizeT[0] = getImageCount(); 
    498498    core.littleEndian[0] = true; 
    499499    core.interleaved[0] = bmpBitsPerPixel != 16; 
    500     core.sizeC[0] = core.rgb[0] ? 3 : 1; 
    501     core.currentOrder[0] = core.sizeC[0] == 3 ? "XYCTZ" : "XYTCZ"; 
     500    core.sizeC[0] = isRGB() ? 3 : 1; 
     501    core.currentOrder[0] = getSizeC() == 3 ? "XYCTZ" : "XYTCZ"; 
    502502    core.falseColor[0] = false; 
    503503    core.metadataComplete[0] = true; 
     
    538538      Object[] options = new Object[2]; 
    539539      options[1] = (lastImageNo == no - 1) ? lastImage : null; 
    540       options[0] = new int[] {core.sizeX[0], core.sizeY[0]}; 
     540      options[0] = new int[] {getSizeX(), getSizeY()}; 
    541541      MSRLECodec codec = new MSRLECodec(); 
    542542      buf = codec.decompress(b, options); 
     
    547547      Object[] options = new Object[4]; 
    548548      options[0] = new Integer(bmpBitsPerPixel); 
    549       options[1] = new Integer(core.sizeX[0]); 
    550       options[2] = new Integer(core.sizeY[0]); 
     549      options[1] = new Integer(getSizeX()); 
     550      options[2] = new Integer(getSizeY()); 
    551551      options[3] = (lastImageNo == no - 1) ? lastImage : null; 
    552552 
     
    574574    if (lut != null) { 
    575575      b = buf; 
    576       buf = new byte[b.length * core.sizeC[0]]; 
     576      buf = new byte[b.length * getSizeC()]; 
    577577      for (int i=0; i<b.length; i++) { 
    578         buf[i*core.sizeC[0]] = lut[0][b[i] & 0xff]; 
    579         buf[i*core.sizeC[0] + 1] = lut[1][b[i] & 0xff]; 
    580         buf[i*core.sizeC[0] + 2] = lut[2][b[i] & 0xff]; 
     578        buf[i*getSizeC()] = lut[0][b[i] & 0xff]; 
     579        buf[i*getSizeC() + 1] = lut[1][b[i] & 0xff]; 
     580        buf[i*getSizeC() + 2] = lut[2][b[i] & 0xff]; 
    581581      } 
    582582    } 
  • trunk/loci/formats/in/AliconaReader.java

    r4132 r4200  
    7272    FormatTools.checkBufferSize(this, buf.length, w, h); 
    7373 
    74     int pad = (8 - (core.sizeX[0] % 8)) % 8; 
    75  
    76     int planeSize = (core.sizeX[0] + pad) * core.sizeY[0]; 
     74    int pad = (8 - (getSizeX() % 8)) % 8; 
     75 
     76    int planeSize = (getSizeX() + pad) * getSizeY(); 
    7777 
    7878    // 16-bit images are stored in a non-standard format: 
     
    8181    for (int i=0; i<numBytes; i++) { 
    8282      in.seek(textureOffset + (no * planeSize * (i + 1))); 
    83       if (core.sizeX[0] == w) { 
     83      if (getSizeX() == w) { 
    8484        in.read(buf, i * w * h, w * h); 
    8585      } 
     
    8888          in.skipBytes(x); 
    8989          in.read(buf, i * w * h + row * w, w); 
    90           in.skipBytes(core.sizeX[0] + pad - x - w); 
     90          in.skipBytes(getSizeX() + pad - x - w); 
    9191        } 
    9292      } 
     
    169169 
    170170    numBytes = (int) (in.length() - textureOffset) / 
    171       (core.sizeX[0] * core.sizeY[0] * core.imageCount[0]); 
     171      (getSizeX() * getSizeY() * getImageCount()); 
    172172 
    173173    core.sizeC[0] = hasC ? 3 : 1; 
    174174    core.sizeZ[0] = 1; 
    175     core.sizeT[0] = core.imageCount[0] / core.sizeC[0]; 
     175    core.sizeT[0] = getImageCount() / getSizeC(); 
    176176    core.rgb[0] = false; 
    177177    core.interleaved[0] = false; 
  • trunk/loci/formats/in/BMPReader.java

    r4132 r4200  
    105105    } 
    106106 
    107     int rowsToSkip = core.sizeY[0] - (h + y); 
    108     int rowLength = core.sizeX[0] * (isIndexed() ? 1 : core.sizeC[0]); 
     107    int rowsToSkip = getSizeY() - (h + y); 
     108    int rowLength = getSizeX() * (isIndexed() ? 1 : getSizeC()); 
    109109    in.seek(global + rowsToSkip * rowLength); 
    110110 
    111     int planeSize = core.sizeX[0] * core.sizeY[0] * core.sizeC[0]; 
     111    int planeSize = getSizeX() * getSizeY() * getSizeC(); 
    112112    if (bpp >= 8) planeSize *= (bpp / 8); 
    113113    else planeSize /= (8 / bpp); 
     
    117117    BitBuffer bb = new BitBuffer(rawPlane); 
    118118 
    119     if ((palette != null && palette[0].length > 0) || core.sizeC[0] == 1) { 
     119    if ((palette != null && palette[0].length > 0) || getSizeC() == 1) { 
    120120      for (int row=h-1; row>=0; row--) { 
    121121        bb.skipBits(x * bpp); 
     
    123123          buf[row*w + i] = (byte) (bb.getBits(bpp) & 0xff); 
    124124        } 
    125         bb.skipBits((core.sizeX[0] - w - x) * bpp); 
     125        bb.skipBits((getSizeX() - w - x) * bpp); 
    126126      } 
    127127    } 
    128128    else { 
    129       int len = core.sizeX[0] * core.sizeC[0]; 
     129      int len = getSizeX() * getSizeC(); 
    130130      for (int row=h-1; row>=y; row--) { 
    131         bb.skipBits(x * core.sizeC[0] * bpp); 
    132         for (int i=0; i<w*core.sizeC[0]; i++) { 
    133           buf[row*w*core.sizeC[0] + i] = (byte) (bb.getBits(bpp) & 0xff); 
     131        bb.skipBits(x * getSizeC() * bpp); 
     132        for (int i=0; i<w*getSizeC(); i++) { 
     133          buf[row*w*getSizeC() + i] = (byte) (bb.getBits(bpp) & 0xff); 
    134134        } 
    135         bb.skipBits(core.sizeC[0] * (core.sizeX[0] - w - x) * bpp); 
    136       } 
    137       for (int i=0; i<buf.length/core.sizeC[0]; i++) { 
    138         byte tmp = buf[i*core.sizeC[0] + 2]; 
    139         buf[i*core.sizeC[0] + 2] = buf[i*core.sizeC[0]]; 
    140         buf[i*core.sizeC[0]] = tmp; 
     135        bb.skipBits(getSizeC() * (getSizeX() - w - x) * bpp); 
     136      } 
     137      for (int i=0; i<buf.length/getSizeC(); i++) { 
     138        byte tmp = buf[i*getSizeC() + 2]; 
     139        buf[i*getSizeC() + 2] = buf[i*getSizeC()]; 
     140        buf[i*getSizeC()] = tmp; 
    141141      } 
    142142    } 
     
    186186    core.sizeY[0] = in.readInt(); 
    187187 
    188     if (core.sizeX[0] < 1 || core.sizeY[0] < 1) { 
     188    if (getSizeX() < 1 || getSizeY() < 1) { 
    189189      throw new FormatException("Invalid image dimensions: " + 
    190         core.sizeX[0] + " x " + core.sizeY[0]); 
    191     } 
    192     addMeta("Image width", "" + core.sizeX[0]); 
    193     addMeta("Image height", "" + core.sizeY[0]); 
    194  
    195     addMeta("Color planes", "" + in.readShort()); 
     190        getSizeX() + " x " + getSizeY()); 
     191    } 
     192    addMeta("Image width", String.valueOf(getSizeX())); 
     193    addMeta("Image height", String.valueOf(getSizeY())); 
     194 
     195    addMeta("Color planes", String.valueOf(in.readShort())); 
    196196    bpp = in.readShort(); 
    197     addMeta("Bits per pixel", "" + bpp); 
     197    addMeta("Bits per pixel", String.valueOf(bpp)); 
    198198 
    199199    compression = in.readInt(); 
     
    220220    float pixelSizeX = (float) in.readInt(); 
    221221    float pixelSizeY = (float) in.readInt(); 
    222     addMeta("X resolution", "" + pixelSizeX); 
    223     addMeta("Y resolution", "" + pixelSizeY); 
     222    addMeta("X resolution", String.valueOf(pixelSizeX)); 
     223    addMeta("Y resolution", String.valueOf(pixelSizeY)); 
    224224    int nColors = in.readInt(); 
    225225    if (nColors == 0 && bpp != 32 && bpp != 24) { 
     
    250250    core.sizeC[0] = bpp != 24 ? 1 : 3; 
    251251    if (bpp == 32) core.sizeC[0] = 4; 
    252     if (bpp > 8) bpp /= core.sizeC[0]; 
    253     //while (bpp % 8 != 0) bpp++; 
     252    if (bpp > 8) bpp /= getSizeC(); 
    254253 
    255254    switch (bpp) { 
     
    264263    } 
    265264 
    266     core.rgb[0] = core.sizeC[0] > 1; 
     265    core.rgb[0] = getSizeC() > 1; 
    267266    core.littleEndian[0] = true; 
    268267    core.interleaved[0] = true; 
     
    273272    core.metadataComplete[0] = true; 
    274273    core.indexed[0] = palette != null; 
    275     if (core.indexed[0]) { 
     274    if (isIndexed()) { 
    276275      core.sizeC[0] = 1; 
    277276      core.rgb[0] = false; 
  • trunk/loci/formats/in/BaseTiffReader.java

    r4168 r4200  
    4242 * @author Melissa Linkert linkert at wisc.edu 
    4343 */ 
    44 public abstract class BaseTiffReader extends FormatReader { 
     44public abstract class BaseTiffReader extends MinimalTiffReader { 
    4545 
    4646  // -- Constants -- 
     
    9090  private static final int CFA_PATTERN = 41730; 
    9191 
    92   // -- Fields -- 
    93  
    94   /** List of IFDs for the current TIFF. */ 
    95   protected Hashtable[] ifds; 
    96  
    9792  // -- Constructors -- 
    9893 
     
    10398  public BaseTiffReader(String name, String[] suffixes) { 
    10499    super(name, suffixes); 
    105   } 
    106  
    107   // -- IFormatReader API methods -- 
    108  
    109   /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
    110   public boolean isThisType(byte[] block) { 
    111     return TiffTools.isValidHeader(block); 
    112   } 
    113  
    114   /* @see loci.formats.IFormatReader#get8BitLookupTable() */ 
    115   public byte[][] get8BitLookupTable() throws FormatException, IOException { 
    116     FormatTools.assertId(currentId, true, 1); 
    117     int[] bits = TiffTools.getBitsPerSample(ifds[0]); 
    118     if (bits[0] <= 8) { 
    119       int[] colorMap = 
    120         TiffTools.getIFDIntArray(ifds[0], TiffTools.COLOR_MAP, false); 
    121       if (colorMap == null) return null; 
    122  
    123       byte[][] table = new byte[3][colorMap.length / 3]; 
    124       int next = 0; 
    125       for (int j=0; j<table.length; j++) { 
    126         for (int i=0; i<table[0].length; i++) { 
    127           table[j][i] = (byte) ((colorMap[next++] >> 8) & 0xff); 
    128         } 
    129       } 
    130  
    131       return table; 
    132     } 
    133     return null; 
    134   } 
    135  
    136   /* @see loci.formats.IFormatReader#get16BitLookupTable() */ 
    137   public short[][] get16BitLookupTable() throws FormatException, IOException { 
    138     FormatTools.assertId(currentId, true, 1); 
    139     int[] bits = TiffTools.getBitsPerSample(ifds[0]); 
    140     if (bits[0] <= 16 && bits[0] > 8) { 
    141       int[] colorMap = 
    142         TiffTools.getIFDIntArray(ifds[0], TiffTools.COLOR_MAP, false); 
    143       if (colorMap == null || colorMap.length < 65536 * 3) return null; 
    144       short[][] table = new short[3][colorMap.length / 3]; 
    145       int next = 0; 
    146       for (int i=0; i<table.length; i++) { 
    147         for (int j=0; j<table[0].length; j++) { 
    148           if (core.littleEndian[0]) { 
    149             table[i][j] = (short) (colorMap[next++] & 0xffff); 
    150           } 
    151           else { 
    152             int n = colorMap[next++]; 
    153             table[i][j] = 
    154               (short) (((n & 0xff0000) >> 8) | ((n & 0xff000000) >> 24)); 
    155           } 
    156         } 
    157       } 
    158       return table; 
    159     } 
    160     return null; 
    161   } 
    162  
    163   /** 
    164    * @see loci.formats.FormatReader#openBytes(int, byte[], int, int, int, int) 
    165    */ 
    166   public byte[] openBytes(int no, byte[] buf, int x, int y, int width, 
    167     int height) throws FormatException, IOException 
    168   { 
    169     FormatTools.assertId(currentId, true, 1); 
    170     FormatTools.checkPlaneNumber(this, no); 
    171     FormatTools.checkBufferSize(this, buf.length, width, height); 
    172  
    173     TiffTools.getSamples(ifds[no], in, buf, x, y, width, height); 
    174     return buf; 
    175   } 
    176  
    177   // -- IFormatHandler API methods -- 
    178  
    179   /* @see loci.formats.IFormatHandler#close() */ 
    180   public void close() throws IOException { 
    181     super.close(); 
    182     ifds = null; 
    183100  } 
    184101 
     
    556473    core.sizeY[0] = (int) TiffTools.getImageLength(ifds[0]); 
    557474    core.sizeZ[0] = 1; 
    558     core.sizeC[0] = core.rgb[0] ? samples : 1; 
     475    core.sizeC[0] = isRGB() ? samples : 1; 
    559476    core.sizeT[0] = ifds.length; 
    560477    core.metadataComplete[0] = true; 
    561478    core.indexed[0] = photo == TiffTools.RGB_PALETTE && 
    562479      (get8BitLookupTable() != null || get16BitLookupTable() != null); 
    563     if (core.indexed[0]) { 
     480    if (isIndexed()) { 
    564481      core.sizeC[0] = 1; 
    565482      core.rgb[0] = false; 
    566483    } 
    567     if (core.sizeC[0] == 1 && !core.indexed[0]) core.rgb[0] = false; 
     484    if (getSizeC() == 1 && !isIndexed()) core.rgb[0] = false; 
    568485    core.falseColor[0] = false; 
    569486    core.currentOrder[0] = "XYCZT"; 
     
    720637    if (debug) debug("BaseTiffReader.initFile(" + id + ")"); 
    721638    super.initFile(id); 
    722     in = new RandomAccessStream(id); 
    723     in.order(in.readShort() == 0x4949); 
    724  
    725     status("Reading IFDs"); 
    726  
    727     ifds = TiffTools.getIFDs(in); 
    728     if (ifds == null) throw new FormatException("No IFDs found"); 
    729  
    730     status("Populating metadata"); 
    731  
    732     core.imageCount[0] = ifds.length; 
    733639    initMetadata(); 
    734640  } 
    735641 
    736642  // -- Helper methods -- 
    737  
    738   protected int getPixelType(Hashtable ifd) throws FormatException { 
    739     int bps = TiffTools.getBitsPerSample(ifd)[0]; 
    740     int bitFormat = TiffTools.getIFDIntValue(ifd, TiffTools.SAMPLE_FORMAT); 
    741  
    742     while (bps % 8 != 0) bps++; 
    743     if (bps == 24) bps = 32; 
    744  
    745     if (bitFormat == 3) return FormatTools.FLOAT; 
    746     else if (bitFormat == 2) { 
    747       switch (bps) { 
    748         case 16: 
    749           return FormatTools.INT16; 
    750         case 32: 
    751           return FormatTools.INT32; 
    752         default: 
    753           return FormatTools.INT8; 
    754       } 
    755     } 
    756     else { 
    757       switch (bps) { 
    758         case 16: 
    759           return FormatTools.UINT16; 
    760         case 32: 
    761           return FormatTools.UINT32; 
    762         default: 
    763           return FormatTools.UINT8; 
    764       } 
    765     } 
    766   } 
    767643 
    768644  private static String getExifTagName(int tag) { 
  • trunk/loci/formats/in/BioRadReader.java

    r4141 r4200  
    231231    lastChannel = getZCTCoords(no)[1]; 
    232232 
    233     int bytes = FormatTools.getBytesPerPixel(core.pixelType[0]); 
     233    int bytes = FormatTools.getBytesPerPixel(getPixelType()); 
    234234 
    235235    if (picFiles != null) { 
    236236      int file = no % picFiles.length; 
    237237      RandomAccessStream ras = new RandomAccessStream(picFiles[file]); 
    238       long offset = (no / picFiles.length) * 
    239         core.sizeX[0] * core.sizeY[0] * bytes; 
     238      long offset = (no / picFiles.length) * getSizeX() * getSizeY() * bytes; 
    240239      ras.seek(offset + 76); 
    241240 
    242       ras.skipBytes(y * core.sizeX[0] * bytes); 
    243       for (int row=0; row<h; row++) { 
    244         ras.skipBytes(x * bytes); 
    245         ras.read(buf, row * w * bytes, w * bytes); 
    246         ras.skipBytes(bytes * (core.sizeX[0] - w - x)); 
    247       } 
    248  
     241      DataTools.readPlane(ras, x, y, w, h, this, buf); 
    249242      ras.close(); 
    250243    } 
    251244    else { 
    252       in.seek(no * core.sizeX[0] * core.sizeY[0] * bytes + 76); 
    253       in.skipBytes(y * core.sizeX[0] * bytes); 
    254       if (core.sizeX[0] == w) { 
    255         in.read(buf); 
    256       } 
    257       else { 
    258         for (int row=0; row<h; row++) { 
    259           in.skipBytes(x * bytes); 
    260           in.read(buf, row * w * bytes, w * bytes); 
    261           in.skipBytes(bytes * (core.sizeX[0] - w - x)); 
    262         } 
    263       } 
     245      in.seek(no * getSizeX() * getSizeY() * bytes + 76); 
     246      DataTools.readPlane(in, x, y, w, h, this, buf); 
    264247    } 
    265248    return buf; 
     
    336319 
    337320    // populate metadata fields 
    338     addMeta("nx", new Integer(core.sizeX[0])); 
    339     addMeta("ny", new Integer(core.sizeY[0])); 
    340     addMeta("npic", new Integer(core.imageCount[0])); 
     321    addMeta("nx", new Integer(getSizeX())); 
     322    addMeta("ny", new Integer(getSizeY())); 
     323    addMeta("npic", new Integer(getImageCount())); 
    341324    addMeta("ramp1_min", new Integer(ramp1min)); 
    342325    addMeta("ramp1_max", new Integer(ramp1max)); 
     
    355338 
    356339    // skip image data 
    357     int imageLen = core.sizeX[0] * core.sizeY[0]; 
    358     int bpp = FormatTools.getBytesPerPixel(core.pixelType[0]); 
    359     in.skipBytes(bpp * core.imageCount[0] * imageLen + 6); 
     340    int imageLen = getSizeX() * getSizeY(); 
     341    int bpp = FormatTools.getBytesPerPixel(getPixelType()); 
     342    in.skipBytes(bpp * getImageCount() * imageLen + 6); 
    360343 
    361344    Vector pixelSize = new Vector(); 
    362345 
    363     core.sizeZ[0] = core.imageCount[0]; 
     346    core.sizeZ[0] = getImageCount(); 
    364347    core.sizeC[0] = 1; 
    365348    core.sizeT[0] = 1; 
     
    543526                addMeta(key + " time (Y) in seconds", params.get(1)); 
    544527                core.sizeZ[0] = 1; 
    545                 core.sizeT[0] = core.imageCount[0]; 
     528                core.sizeT[0] = getImageCount(); 
    546529                core.orderCertain[0] = true; 
    547530              } 
     
    692675 
    693676    // populate Pixels 
    694     in.seek(14); 
    695     core.pixelType[0] = in.readShort() == 1 ? FormatTools.UINT8 : 
    696       FormatTools.UINT16; 
    697677 
    698678    core.currentOrder[0] = "XYCTZ"; 
     
    700680    if (picFiles.length > 0) { 
    701681      core.imageCount[0] = npic * picFiles.length; 
    702       core.sizeC[0] = core.imageCount[0] / (core.sizeZ[0] * core.sizeT[0]); 
     682      core.sizeC[0] = getImageCount() / (getSizeZ() * getSizeT()); 
    703683    } 
    704684    else picFiles = null; 
     
    796776        int c = sizeC == null ? 1 : Integer.parseInt(sizeC); 
    797777        int t = sizeT == null ? 1 : Integer.parseInt(sizeT); 
    798         int count = core.sizeZ[0] * core.sizeC[0] * core.sizeT[0]; 
     778        int count = getSizeZ() * getSizeC() * getSizeT(); 
    799779        core.sizeZ[0] = z; 
    800780        core.sizeC[0] = c; 
    801781        core.sizeT[0] = t; 
    802         if (count >= core.imageCount[0]) core.imageCount[0] = count; 
    803         else core.sizeC[0] = core.imageCount[0] / count; 
     782        if (count >= getImageCount()) core.imageCount[0] = count; 
     783        else core.sizeC[0] = getImageCount() / count; 
    804784      } 
    805785      else if (qName.equals("Z") || qName.equals("C") || qName.equals("T")) { 
  • trunk/loci/formats/in/DeltavisionReader.java

    r4196 r4200  
    9393    FormatTools.checkBufferSize(this, buf.length, w, h); 
    9494 
    95  
    9695    // read the image plane's pixel data 
    97     int bytesPerPixel = FormatTools.getBytesPerPixel(core.pixelType[0]); 
     96    int bytesPerPixel = FormatTools.getBytesPerPixel(getPixelType()); 
    9897    long offset = HEADER_LENGTH + extSize; 
    99     long bytes = core.sizeX[0] * core.sizeY[0] * bytesPerPixel; 
    100     in.seek(offset + bytes*no + y * core.sizeX[0] * bytesPerPixel); 
    101  
    102     if (w == core.sizeX[0]) { 
    103       in.read(buf); 
    104     } 
    105     else { 
    106       for (int row=0; row<h; row++) { 
    107         in.skipBytes(x * bytesPerPixel); 
    108         in.read(buf, w * bytesPerPixel * (h - row - 1), w * bytesPerPixel); 
    109         in.skipBytes(bytesPerPixel * (core.sizeX[0] - w - x)); 
    110       } 
    111     } 
     98    in.seek(offset + getSizeX() * getSizeY() * bytesPerPixel * no); 
     99    DataTools.readPlane(in, x, y, w, h, this, buf); 
    112100 
    113101    return buf; 
     
    140128    core.littleEndian[0] = in.readShort() == LITTLE_ENDIAN; 
    141129 
    142     in.order(core.littleEndian[0]); 
     130    in.order(isLittleEndian()); 
    143131    in.seek(8); 
    144132 
     
    152140    core.sizeY[0] = in.readInt(); 
    153141 
    154     addMeta("ImageWidth", new Integer(core.sizeX[0])); 
    155     addMeta("ImageHeight", new Integer(core.sizeY[0])); 
     142    addMeta("ImageWidth", new Integer(getSizeX())); 
     143    addMeta("ImageHeight", new Integer(getSizeY())); 
    156144    addMeta("NumberOfImages", new Integer(in.readInt())); 
    157145    int filePixelType = in.readInt(); 
     
    269257 
    270258    core.sizeT[0] = in.readShort(); 
    271     addMeta("Number of timepoints", new Integer(core.sizeT[0])); 
     259    addMeta("Number of timepoints", new Integer(getSizeT())); 
    272260 
    273261    int sequence = in.readShort(); 
     
    297285 
    298286    core.sizeC[0] = in.readShort(); 
    299     addMeta("Number of wavelengths", new Integer(core.sizeC[0])); 
    300     if (core.sizeC[0] == 0) core.sizeC[0] = 1; 
    301     if (core.sizeT[0] == 0) core.sizeT[0] = 1; 
    302     core.sizeZ[0] = core.imageCount[0] / (core.sizeC[0] * core.sizeT[0]); 
    303     addMeta("Number of focal planes", new Integer(core.sizeZ[0])); 
     287    addMeta("Number of wavelengths", new Integer(getSizeC())); 
     288    if (getSizeC() == 0) core.sizeC[0] = 1; 
     289    if (getSizeT() == 0) core.sizeT[0] = 1; 
     290    core.sizeZ[0] = getImageCount() / (getSizeC() * getSizeT()); 
     291    addMeta("Number of focal planes", new Integer(getSizeZ())); 
    304292 
    305293    core.rgb[0] = false; 
     
    343331    numIntsPerSection = in.readShort(); 
    344332    numFloatsPerSection = in.readShort(); 
    345     setOffsetInfo(sequence, core.sizeZ[0], core.sizeC[0], core.sizeT[0]); 
    346     extHdrFields = 
    347       new DVExtHdrFields[core.sizeZ[0]][core.sizeC[0]][core.sizeT[0]]; 
     333    setOffsetInfo(sequence, getSizeZ(), getSizeC(), getSizeT()); 
     334    extHdrFields = new DVExtHdrFields[getSizeZ()][getSizeC()][getSizeT()]; 
    348335 
    349336    MetadataTools.populatePixels(store, this); 
     
    361348    int p = 0; 
    362349    int offset = HEADER_LENGTH + numIntsPerSection * 4; 
    363     for (int i=0; i<core.imageCount[0]; i++) { 
     350    for (int i=0; i<getImageCount(); i++) { 
    364351      int[] coords = getZCTCoords(i); 
    365352      int z = coords[0]; 
     
    391378    status("Populating metadata"); 
    392379 
    393     for (int w=0; w<core.sizeC[0]; w++) { 
     380    for (int w=0; w<getSizeC(); w++) { 
    394381      store.setLogicalChannelEmWave(new Integer(waves[w]), 0, w); 
    395382      store.setLogicalChannelExWave( 
  • trunk/loci/formats/in/DicomReader.java

    r4166 r4200  
    159159    FormatTools.checkBufferSize(this, buf.length, w, h); 
    160160 
    161     int bpp = FormatTools.getBytesPerPixel(core.pixelType[0]); 
    162     int bytes = core.sizeX[0] * core.sizeY[0] * bpp * 
    163       (isIndexed() ? 1 : core.sizeC[0]); 
     161    int bpp = FormatTools.getBytesPerPixel(getPixelType()); 
     162    int bytes = getSizeX() * getSizeY() * bpp * (isIndexed() ? 1 : getSizeC()); 
    164163    in.seek(offsets[no]); 
    165164 
     
    184183        for (int i=0; i<plane; i++) { 
    185184          for (int j=0; j<bpp; j++) { 
    186             t[i*bpp + j] = 
    187               core.littleEndian[0] ? tmp[bpp - j - 1][i] : tmp[j][i]; 
     185            t[i*bpp + j] = isLittleEndian() ? tmp[bpp - j - 1][i] : tmp[j][i]; 
    188186          } 
    189187        } 
     
    191189 
    192190      int rowLen = w * bpp; 
    193       int srcRowLen = core.sizeX[0] * bpp; 
    194  
    195       int ec = isIndexed() ? 1 : core.sizeC[0]; 
    196       int srcPlane = core.sizeY[0] * srcRowLen; 
     191      int srcRowLen = getSizeX() * bpp; 
     192 
     193      int ec = isIndexed() ? 1 : getSizeC(); 
     194      int srcPlane = getSizeY() * srcRowLen; 
    197195 
    198196      for (int c=0; c<ec; c++) { 
     
    221219      if (isJPEG) codec = new JPEGCodec(); 
    222220      else codec = new JPEG2000Codec(); 
    223       b = codec.decompress(b, new Object[] {new Boolean(core.littleEndian[0]), 
    224         new Boolean(core.interleaved[0])}); 
     221      b = codec.decompress(b, new Object[] {new Boolean(isLittleEndian()), 
     222        new Boolean(isInterleaved())}); 
    225223 
    226224      int rowLen = w * bpp; 
    227       int srcRowLen = core.sizeX[0] * bpp; 
    228  
    229       int ec = isIndexed() ? 1 : core.sizeC[0]; 
    230       int srcPlane = core.sizeY[0] * srcRowLen; 
     225      int srcRowLen = getSizeX() * bpp; 
     226 
     227      int ec = isIndexed() ? 1 : getSizeC(); 
     228      int srcPlane = getSizeY() * srcRowLen; 
    231229 
    232230      for (int c=0; c<ec; c++) { 
     
    252250      else in.seek(in.getFilePointer() - 6); 
    253251 
    254       int c = isIndexed() ? 1 : core.sizeC[0]; 
    255       in.skipBytes(y * c * bpp * core.sizeX[0]); 
    256  
    257       if (core.sizeX[0] == w) { 
     252      int c = isIndexed() ? 1 : getSizeC(); 
     253      in.skipBytes(y * c * bpp * getSizeX()); 
     254 
     255      if (getSizeX() == w) { 
    258256        in.read(buf); 
    259257      } 
     
    262260          in.skipBytes(x * c * bpp); 
    263261          in.read(buf, row * w * c * bpp, w * c * bpp); 
    264           in.skipBytes(c * bpp * (core.sizeX[0] - w - x)); 
    265         } 
    266       } 
    267     } 
    268  
    269     if (bgr && core.rgb[0]) { 
     262          in.skipBytes(c * bpp * (getSizeX() - w - x)); 
     263        } 
     264      } 
     265    } 
     266 
     267    if (bgr && isRGB()) { 
    270268      int stride = bpp * getRGBChannelCount(); 
    271269      for (int i=0; i<buf.length; i+=stride) { 
     
    289287        if (maxPixelValue == -1) maxPixelValue = 65535; 
    290288        for (int i=0; i<buf.length; i+=2) { 
    291           short s = DataTools.bytesToShort(buf, i, 2, core.littleEndian[0]); 
     289          short s = DataTools.bytesToShort(buf, i, 2, isLittleEndian()); 
    292290          s = (short) (maxPixelValue - s); 
    293           if (core.littleEndian[0]) { 
    294             buf[i + 1] = (byte) (s >> 8); 
    295             buf[i] = (byte) (s & 0xff); 
    296           } 
    297           else { 
    298             buf[i] = (byte) (s >> 8); 
    299             buf[i + 1] = (byte) (s & 0xff); 
    300           } 
     291          DataTools.unpackShort(s, buf, i, isLittleEndian()); 
    301292        } 
    302293      } 
     
    408399          break; 
    409400        case ROWS: 
    410           if (core.sizeY[0] == 0) core.sizeY[0] = in.readShort(); 
     401          if (getSizeY() == 0) core.sizeY[0] = in.readShort(); 
    411402          else in.skipBytes(2); 
    412           addInfo(tag, core.sizeY[0]); 
     403          addInfo(tag, getSizeY()); 
    413404          break; 
    414405        case COLUMNS: 
    415           if (core.sizeX[0] == 0) core.sizeX[0] = in.readShort(); 
     406          if (getSizeX() == 0) core.sizeX[0] = in.readShort(); 
    416407          else in.skipBytes(2); 
    417           addInfo(tag, core.sizeX[0]); 
     408          addInfo(tag, getSizeX()); 
    418409          break; 
    419410        case PIXEL_SPACING: 
     
    478469      } 
    479470    } 
    480     if (core.imageCount[0] == 0) core.imageCount[0] = 1; 
     471    if (getImageCount() == 0) core.imageCount[0] = 1; 
    481472 
    482473    while (bitsPerPixel % 8 != 0) bitsPerPixel++; 
     
    495486    } 
    496487 
    497     int plane = core.sizeX[0] * core.sizeY[0] * 
    498       (lut == null ? core.sizeC[0] : 1) * 
    499       FormatTools.getBytesPerPixel(core.pixelType[0]); 
     488    int plane = getSizeX() * getSizeY() * (lut == null ? getSizeC() : 1) * 
     489      FormatTools.getBytesPerPixel(getPixelType()); 
    500490 
    501491    status("Calculating image offsets"); 
     
    503493    // calculate the offset to each plane 
    504494 
    505     offsets = new long[core.imageCount[0]]; 
    506     for (int i=0; i<core.imageCount[0]; i++) { 
     495    offsets = new long[getImageCount()]; 
     496    for (int i=0; i<getImageCount(); i++) { 
    507497      if (isRLE) { 
    508498        if (i == 0) in.seek(baseOffset); 
     
    551541    status("Populating metadata"); 
    552542 
    553     core.sizeZ[0] = core.imageCount[0]; 
    554     if (core.sizeC[0] == 0) core.sizeC[0] = 1; 
    555     core.rgb[0] = core.sizeC[0] > 1; 
     543    core.sizeZ[0] = getImageCount(); 
     544    if (getSizeC() == 0) core.sizeC[0] = 1; 
     545    core.rgb[0] = getSizeC() > 1; 
    556546    core.sizeT[0] = 1; 
    557547    core.currentOrder[0] = "XYCZT"; 
     
    613603      if (key.equals("Samples per pixel")) { 
    614604        core.sizeC[0] = Integer.parseInt(info.trim()); 
    615         if (core.sizeC[0] > 1) core.rgb[0] = true; 
     605        if (getSizeC() > 1) core.rgb[0] = true; 
    616606      } 
    617607      else if (key.equals("Photometric Interpretation")) { 
     
    751741        } 
    752742        vr = IMPLICIT_VR; 
    753         return DataTools.bytesToInt(b, core.littleEndian[0]); 
     743        return DataTools.bytesToInt(b, isLittleEndian()); 
    754744      case AE: 
    755745      case AS: 
     
    777767        // Explicit VR with 16-bit length 
    778768        if (tag == 0x00283006) { 
    779                   return DataTools.bytesToInt(b, 2, 2, core.littleEndian[0]); 
    780         } 
    781         int n1 = DataTools.bytesToShort(b, 2, 2, core.littleEndian[0]); 
    782         int n2 = DataTools.bytesToShort(b, 2, 2, !core.littleEndian[0]); 
     769                  return DataTools.bytesToInt(b, 2, 2, isLittleEndian()); 
     770        } 
     771        int n1 = DataTools.bytesToShort(b, 2, 2, isLittleEndian()); 
     772        int n2 = DataTools.bytesToShort(b, 2, 2, !isLittleEndian()); 
    783773        if (n1 < 0) return n2; 
    784774        if (n2 < 0) return n1; 
     
    786776      default: 
    787777        vr = IMPLICIT_VR; 
    788         return DataTools.bytesToInt(b, core.littleEndian[0]); 
     778        return DataTools.bytesToInt(b, isLittleEndian()); 
    789779    } 
    790780  } 
  • trunk/loci/formats/in/EPSReader.java

    r4132 r4200  
    8787      int[] map = TiffTools.getIFDIntArray(ifds[0], TiffTools.COLOR_MAP, false); 
    8888      if (map == null) { 
    89         int bpp = FormatTools.getBytesPerPixel(core.pixelType[0]); 
    90         in.skipBytes(y * core.sizeX[0] * bpp * core.sizeC[0]); 
    91         if (core.sizeX[0] == w) { 
    92           in.read(buf); 
    93         } 
    94         else { 
    95           int nBytes = bpp * core.sizeC[0]; 
    96           for (int row=0; row<h; row++) { 
    97             in.skipBytes(x * nBytes); 
    98             in.read(buf, row * w * nBytes, w * nBytes); 
    99             in.skipBytes(nBytes * (core.sizeX[0] - w - x)); 
    100           } 
    101         } 
     89        DataTools.readPlane(in, x, y, w, h, this, buf); 
    10290        return buf; 
    10391      } 
    10492 
    10593      byte[] b = new byte[w * h]; 
    106       in.skipBytes(2 * y * core.sizeX[0]); 
     94      in.skipBytes(2 * y * getSizeX()); 
    10795      for (int row=0; row<h; row++) { 
    10896        in.skipBytes(x * 2); 
     
    11098          b[row * w + col] = (byte) (in.readShort() & 0xff); 
    11199        } 
    112         in.skipBytes(2 * (core.sizeX[0] - w - x)); 
     100        in.skipBytes(2 * (getSizeX() - w - x)); 
    113101      } 
    114102 
    115103      for (int i=0; i<b.length; i++) { 
    116104        int ndx = b[i] & 0xff; 
    117         for (int j=0; j<core.sizeC[0]; j++) { 
    118           buf[i*core.sizeC[0] + j] = (byte) map[ndx + j*256]; 
     105        for (int j=0; j<getSizeC(); j++) { 
     106          buf[i*getSizeC() + j] = (byte) map[ndx + j*256]; 
    119107        } 
    120108      } 
     
    128116    } 
    129117 
    130     int bytes = FormatTools.getBytesPerPixel(core.pixelType[0]); 
     118    int bytes = FormatTools.getBytesPerPixel(getPixelType()); 
    131119    if (binary) { 
    132120      // pixels are stored as raw bytes 
    133       in.skipBytes(y * core.sizeX[0] * bytes * core.sizeC[0]); 
    134       if (core.sizeX[0] == w) { 
    135         in.read(buf); 
    136       } 
    137       else { 
    138         for (int row=0; row<h; row++) { 
    139           in.skipBytes(x * bytes * core.sizeC[0]); 
    140           in.read(buf, row*w*bytes*core.sizeC[0], w * bytes * core.sizeC[0]); 
    141           in.skipBytes(bytes * core.sizeC[0] * (core.sizeX[0] - w - h)); 
    142         } 
    143       } 
     121      DataTools.readPlane(in, x, y, w, h, this, buf); 
    144122    } 
    145123    else { 
     
    149127      pix = pix.replaceAll("\r", ""); 
    150128 
    151       int ndx = core.sizeC[0] * y * bytes * core.sizeX[0]; 
     129      int ndx = getSizeC() * y * bytes * getSizeX(); 
    152130      int destNdx = 0; 
    153131 
    154132      for (int row=0; row<h; row++) { 
    155         ndx += x * core.sizeC[0] * bytes; 
    156         for (int col=0; col<w*core.sizeC[0]*bytes; col++) { 
     133        ndx += x * getSizeC() * bytes; 
     134        for (int col=0; col<w*getSizeC()*bytes; col++) { 
    157135          buf[destNdx++] = 
    158136            (byte) Integer.parseInt(pix.substring(2*ndx, 2*(ndx+1)), 16); 
    159137          ndx++; 
    160138        } 
    161         ndx += core.sizeC[0] * bytes * (core.sizeX[0] - w - x); 
     139        ndx += getSizeC() * bytes * (getSizeX() - w - x); 
    162140      } 
    163141    } 
     
    210188      core.littleEndian[0] = TiffTools.isLittleEndian(ifds[0]); 
    211189      core.interleaved[0] = true; 
    212       core.rgb[0] = core.sizeC[0] > 1; 
     190      core.rgb[0] = getSizeC() > 1; 
    213191 
    214192      bps = TiffTools.getBitsPerSample(ifds[0])[0]; 
     
    309287    if (bps == 0) bps = 8; 
    310288 
    311     if (core.sizeC[0] == 0) core.sizeC[0] = 1; 
     289    if (getSizeC() == 0) core.sizeC[0] = 1; 
    312290 
    313291    core.sizeZ[0] = 1; 
     
    315293    core.currentOrder[0] = "XYCZT"; 
    316294    core.pixelType[0] = FormatTools.UINT8; 
    317     core.rgb[0] = core.sizeC[0] == 3; 
     295    core.rgb[0] = getSizeC() == 3; 
    318296    core.interleaved[0] = true; 
    319297    core.littleEndian[0] = true; 
  • trunk/loci/formats/in/FEIReader.java

    r4132 r4200  
    55/* 
    66OME Bio-Formats package for reading and converting biological file formats. 
    7 Copyright (C) 2005-@year@ UW-Madison LOCI and Glencoe Software, Inc.  
     7Copyright (C) 2005-@year@ UW-Madison LOCI and Glencoe Software, Inc. 
    88 
    99This program is free software; you can redistribute it and/or modify 
     
    6868 
    6969    in.seek(1536); 
    70     byte[] segment = new byte[core.sizeX[0] / 2]; 
    71     int skip = (originalWidth / 2) - (core.sizeX[0] / 2); 
     70    byte[] segment = new byte[getSizeX() / 2]; 
     71    int skip = (originalWidth / 2) - (getSizeX() / 2); 
    7272    // interlace frames - there are four rows of two columns 
    73     int halfRow = core.sizeX[0] / 2; 
     73    int halfRow = getSizeX() / 2; 
    7474    for (int q=0; q<4; q++) { 
    7575      for (int row=q; row<h; row+=4) { 
     
    102102    core.sizeY[0] = in.readShort(); 
    103103 
    104     originalWidth = core.sizeX[0]; 
     104    originalWidth = getSizeX(); 
    105105 
    106106    // FEI files can only be 1424x968 or 712x484 
    107107 
    108     if (1424 < core.sizeX[0]) { 
     108    if (1424 < getSizeX()) { 
    109109      core.sizeX[0] = 1424; 
    110110      core.sizeY[0] = 968; 
  • trunk/loci/formats/in/FV1000Reader.java

    r4198 r4200  
    151151      coords[1], coords[2]); 
    152152 
    153     String file = 
    154       (String) (series == 0 ? tiffs.get(planeNum) : previewNames.get(planeNum)); 
    155     RandomAccessStream plane = getFile(file); 
    156     Hashtable[] ifds = TiffTools.getIFDs(plane); 
    157     TiffTools.getSamples(ifds[0], plane, buf, x, y, w, h); 
    158     plane.close(); 
    159     ifds = null; 
    160     plane = null; 
    161     System.gc(); 
     153    MinimalTiffReader reader = new MinimalTiffReader(); 
     154    if (series == 0) reader.setId((String) tiffs.get(planeNum)); 
     155    else reader.setId((String) previewNames.get(planeNum)); 
     156 
     157    reader.openBytes(0, buf, x, y, w, h); 
     158    reader.close(); 
    162159    return buf; 
    163160  } 
  • trunk/loci/formats/in/FitsReader.java

    r4132 r4200  
    6969 
    7070    in.seek(2880 * ((((count * 80) - 1) / 2880) + 1)); 
    71     int bytes = FormatTools.getBytesPerPixel(core.pixelType[0]); 
    72     int line = core.sizeX[0] * bytes; 
    73     in.skipBytes(line * y); 
    74     for (int row=h-1; row>=0; row--) { 
    75       in.skipBytes(x * bytes); 
    76       in.read(buf, row*w*bytes, w*bytes); 
    77       in.skipBytes(bytes * (core.sizeX[0] - w - x)); 
    78     } 
     71    DataTools.readPlane(in, x, y, w, h, this, buf); 
    7972    return buf; 
    8073  } 
     
    138131    core.sizeC[0] = 1; 
    139132    core.sizeT[0] = 1; 
    140     if (core.sizeZ[0] == 0) core.sizeZ[0] = 1; 
     133    if (getSizeZ() == 0) core.sizeZ[0] = 1; 
    141134    core.imageCount[0] = core.sizeZ[0]; 
    142135    core.rgb[0] = false; 
  • trunk/loci/formats/in/FlexReader.java

    r4146 r4200  
    9090      System.arraycopy(bytes, 0, t, 0, t.length); 
    9191      Arrays.fill(bytes, (byte) 0); 
    92       int bpp = FormatTools.getBytesPerPixel(core.pixelType[0]); 
     92      int bpp = FormatTools.getBytesPerPixel(getPixelType()); 
    9393      for (int i=num-1; i>=0; i--) { 
    9494        int q = (int) ((t[i] & 0xff) * factors[no]); 
    95         DataTools.unpackBytes(q, bytes, i * bpp, bpp, core.littleEndian[0]); 
     95        DataTools.unpackBytes(q, bytes, i * bpp, bpp, isLittleEndian()); 
    9696      } 
    9797    } 
    9898    else { 
    99       if (core.pixelType[0] == FormatTools.UINT8) { 
     99      if (getPixelType() == FormatTools.UINT8) { 
    100100        int num = bytes.length; 
    101101        for (int i=num-1; i>=0; i--) { 
     
    104104        } 
    105105      } 
    106       else if (core.pixelType[0] == FormatTools.UINT16) { 
     106      else if (getPixelType() == FormatTools.UINT16) { 
    107107        int num = bytes.length / 2; 
    108108        for (int i=num-1; i>=0; i--) { 
    109109          int q = nBytes == 1 ? (int) ((bytes[i] & 0xff) * factors[no]) : 
    110             (int) (DataTools.bytesToInt(bytes, i*2, 2, core.littleEndian[0]) * 
     110            (int) (DataTools.bytesToInt(bytes, i*2, 2, isLittleEndian()) * 
    111111            factors[no]); 
    112           DataTools.unpackBytes(q, bytes, i * 2, 2, core.littleEndian[0]); 
    113         } 
    114       } 
    115       else if (core.pixelType[0] == FormatTools.UINT32) { 
     112          DataTools.unpackBytes(q, bytes, i * 2, 2, isLittleEndian()); 
     113        } 
     114      } 
     115      else if (getPixelType() == FormatTools.UINT32) { 
    116116        int num = bytes.length / 4; 
    117117        for (int i=num-1; i>=0; i--) { 
    118118          int q = nBytes == 1 ? (int) ((bytes[i] & 0xff) * factors[no]) : 
    119119            (int) (DataTools.bytesToInt(bytes, i*4, nBytes, 
    120             core.littleEndian[0]) * factors[no]); 
    121           DataTools.unpackBytes(q, bytes, i * 4, 4, core.littleEndian[0]); 
     120            isLittleEndian()) * factors[no]); 
     121          DataTools.unpackBytes(q, bytes, i * 4, 4, isLittleEndian()); 
    122122        } 
    123123      } 
     
    174174    int nsize = n.size(); 
    175175    int fsize = f.size(); 
    176     if (debug && (nsize != fsize || nsize != core.imageCount[0])) { 
     176    if (debug && (nsize != fsize || nsize != getImageCount())) { 
    177177      LogTools.println("Warning: mismatch between image count, " + 
    178         "names and factors (count=" + core.imageCount[0] + 
     178        "names and factors (count=" + getImageCount() + 
    179179        ", names=" + nsize + ", factors=" + fsize + ")"); 
    180180    } 
     
    183183 
    184184    // parse factor values 
    185     factors = new double[core.imageCount[0]]; 
     185    factors = new double[getImageCount()]; 
    186186    int max = 0; 
    187187    for (int i=0; i<fsize; i++) { 
  • trunk/loci/formats/in/FluoviewReader.java

    r4132 r4200  
    116116    throws FormatException, IOException 
    117117  { 
    118     if (core.sizeY[0] == TiffTools.getImageLength(ifds[0])) { 
     118    if (getSizeY() == TiffTools.getImageLength(ifds[0])) { 
    119119      return super.openBytes(no, buf, x, y, w, h); 
    120120    } 
     
    123123    FormatTools.checkBufferSize(this, buf.length, w, h); 
    124124 
    125     byte[] b = new byte[w * h * 
    126       getRGBChannelCount() * FormatTools.getBytesPerPixel(core.pixelType[0])]; 
    127     super.openBytes(0, buf, x, y, w, h); 
    128     System.arraycopy(b, no*b.length, buf, 0, b.length); 
     125    super.openBytes(0, buf, x, no, w, h); 
    129126    return buf; 
    130127  } 
     
    249246 
    250247      if (name.equals("x")) { 
    251         if (core.sizeX[0] == 0) core.sizeX[0] = size; 
     248        if (getSizeX() == 0) core.sizeX[0] = size; 
    252249        voxelX = voxel; 
    253250      } 
    254251      else if (name.equals("y")) { 
    255         if (core.sizeY[0] == 0) core.sizeY[0] = size; 
     252        if (getSizeY() == 0) core.sizeY[0] = size; 
    256253        voxelY = voxel; 
    257254      } 
    258255      else if (name.equals("z") || name.equals("event")) { 
    259256        core.sizeZ[0] *= size; 
    260         if (core.currentOrder[0].indexOf("Z") == -1) { 
     257        if (getDimensionOrder().indexOf("Z") == -1) { 
    261258          core.currentOrder[0] += "Z"; 
    262259        } 
     
    265262      else if (name.equals("ch") || name.equals("wavelength")) { 
    266263        core.sizeC[0] *= size; 
    267         if (core.currentOrder[0].indexOf("C") == -1) { 
     264        if (getDimensionOrder().indexOf("C") == -1) { 
    268265          core.currentOrder[0] += "C"; 
    269266        } 
     
    272269      else { 
    273270        core.sizeT[0] *= size; 
    274         if (core.currentOrder[0].indexOf("T") == -1) { 
     271        if (getDimensionOrder().indexOf("T") == -1) { 
    275272          core.currentOrder[0] += "T"; 
    276273        } 
     
    279276    } 
    280277 
    281     if (core.currentOrder[0].indexOf("Z") == -1) core.currentOrder[0] += "Z"; 
    282     if (core.currentOrder[0].indexOf("T") == -1) core.currentOrder[0] += "T"; 
    283     if (core.currentOrder[0].indexOf("C") == -1) core.currentOrder[0] += "C"; 
     278    if (getDimensionOrder().indexOf("Z") == -1) core.currentOrder[0] += "Z"; 
     279    if (getDimensionOrder().indexOf("T") == -1) core.currentOrder[0] += "T"; 
     280    if (getDimensionOrder().indexOf("C") == -1) core.currentOrder[0] += "C"; 
    284281 
    285282    core.imageCount[0] = ifds.length; 
    286     if (core.sizeZ[0] > ifds.length) core.sizeZ[0] = ifds.length; 
    287     if (core.sizeT[0] > ifds.length) core.sizeT[0] = ifds.length; 
    288  
    289     if (core.imageCount[0] == 1 && (core.sizeT[0] == core.sizeY[0] || 
    290       core.sizeZ[0] == core.sizeY[0]) && (core.sizeT[0] > core.imageCount[0] || 
    291       core.sizeZ[0] > core.imageCount[0])) 
     283    if (getSizeZ() > ifds.length) core.sizeZ[0] = ifds.length; 
     284    if (getSizeT() > ifds.length) core.sizeT[0] = ifds.length; 
     285 
     286    if (getImageCount() == 1 && (getSizeT() == getSizeY() || 
     287      getSizeZ() == getSizeY()) && (getSizeT() > getImageCount() || 
     288      getSizeZ() > getImageCount())) 
    292289    { 
    293290      core.sizeY[0] = 1; 
    294       core.imageCount[0] = core.sizeZ[0] * core.sizeT[0] * core.sizeC[0]; 
     291      core.imageCount[0] = getSizeZ() * getSizeC() * getSizeT(); 
    295292    } 
    296293 
     
    298295    comment = TiffTools.getComment(ifds[0]); 
    299296 
    300     gains = new String[core.sizeC[0]]; 
    301     offsets = new String[core.sizeC[0]]; 
    302     voltages = new String[core.sizeC[0]]; 
    303     channelNames = new String[core.sizeC[0]]; 
    304     lensNA = new String[core.sizeC[0]]; 
     297    gains = new String[getSizeC()]; 
     298    offsets = new String[getSizeC()]; 
     299    voltages = new String[getSizeC()]; 
     300    channelNames = new String[getSizeC()]; 
     301    lensNA = new String[getSizeC()]; 
    305302 
    306303    if (comment != null && comment.startsWith("[")) { 
     
    400397    } 
    401398 
    402     for (int i=0; i<core.sizeC[0]; i++) { 
     399    for (int i=0; i<getSizeC(); i++) { 
    403400      if (channelNames[i] != null) { 
    404401        store.setLogicalChannelName(channelNames[i].trim(), 0, i); 
  • trunk/loci/formats/in/GIFReader.java

    r4132 r4200  
    153153 
    154154    for (int row=0; row<h; row++) { 
    155       System.arraycopy(b, (row + y) * core.sizeX[0] + x, buf, row*w, w); 
     155      System.arraycopy(b, (row + y) * getSizeX() + x, buf, row*w, w); 
    156156    } 
    157157 
     
    337337    core.sizeZ[0] = 1; 
    338338    core.sizeC[0] = 1; 
    339     core.sizeT[0] = core.imageCount[0]; 
     339    core.sizeT[0] = getImageCount(); 
    340340    core.currentOrder[0] = "XYCTZ"; 
    341341    core.rgb[0] = false; 
     
    487487  private void setPixels() { 
    488488    // expose destination image's pixels as an int array 
    489     byte[] dest = new byte[core.sizeX[0] * core.sizeY[0]]; 
     489    byte[] dest = new byte[getSizeX() * getSizeY()]; 
    490490    int lastImage = -1; 
    491491 
     
    493493    if (lastDispose > 0) { 
    494494      if (lastDispose == 3) { // use image before last 
    495         int n = core.imageCount[0] - 2; 
     495        int n = getImageCount() - 2; 
    496496        if (n > 0) lastImage = n - 1; 
    497497      } 
     
    499499      if (lastImage != -1) { 
    500500        byte[] prev = (byte[]) images.get(lastImage); 
    501         System.arraycopy(prev, 0, dest, 0, core.sizeX[0] * core.sizeY[0]); 
     501        System.arraycopy(prev, 0, dest, 0, getSizeX() * getSizeY()); 
    502502      } 
    503503    } 
     
    531531      } 
    532532      line += iy; 
    533       if (line < core.sizeY[0]) { 
    534         int k = line * core.sizeX[0]; 
     533      if (line < getSizeY()) { 
     534        int k = line * getSizeX(); 
    535535        int dx = k + ix; // start of line in dest 
    536536        int dlim = dx + iw; // end of dest line 
    537         if ((k + core.sizeX[0]) < dlim) dlim = k + core.sizeX[0]; 
     537        if ((k + getSizeX()) < dlim) dlim = k + getSizeX(); 
    538538        int sx = i * iw; // start of line in source 
    539539        while (dx < dlim) { 
  • trunk/loci/formats/in/GatanReader.java

    r4132 r4200  
    100100    FormatTools.checkBufferSize(this, buf.length, w, h); 
    101101 
    102     int bpp = FormatTools.getBytesPerPixel(core.pixelType[0]); 
    103     in.seek(pixelOffset + y * core.sizeX[0] * bpp); 
    104  
    105     if (core.sizeX[0] == w) { 
    106       in.read(buf); 
    107     } 
    108     else { 
    109       for (int row=0; row<h; row++) { 
    110         in.skipBytes(x * bpp); 
    111         in.read(buf, row * w * bpp, w * bpp); 
    112         in.skipBytes(bpp * (core.sizeX[0] - w - x)); 
    113       } 
    114     } 
     102    in.seek(pixelOffset); 
     103    DataTools.readPlane(in, x, y, w, h, this, buf); 
    115104 
    116105    return buf; 
     
    152141    in.skipBytes(4); 
    153142    core.littleEndian[0] = in.readInt() == 1; 
    154     in.order(!core.littleEndian[0]); 
     143    in.order(!isLittleEndian()); 
    155144 
    156145    // TagGroup instance 
     
    166155    core.littleEndian[0] = true; 
    167156 
    168     if (core.sizeX[0] == 0 || core.sizeY[0] == 0) { 
     157    if (getSizeX() == 0 || getSizeY() == 0) { 
    169158      throw new FormatException("Dimensions information not found"); 
    170159    } 
    171     int bytes = numPixelBytes / (core.sizeX[0] * core.sizeY[0]); 
     160    int bytes = numPixelBytes / (getSizeX() * getSizeY()); 
    172161 
    173162    switch (bytes) { 
     
    223212    store.setDimensionsPhysicalSizeZ(pixZ, 0, 0); 
    224213 
    225     for (int i=0; i<core.sizeC[0]; i++) { 
     214    for (int i=0; i<getSizeC(); i++) { 
    226215      // CTR CHECK 
    227216//      store.setDisplayChannel(new Integer(i), null, null, 
  • trunk/loci/formats/in/GelReader.java

    r4147 r4200  
    8989      for (int i=0; i<tmp.length/4; i++) { 
    9090        long value = DataTools.bytesToShort(tmp, i*originalBytes, 
    91           originalBytes, core.littleEndian[0]); 
     91          originalBytes, isLittleEndian()); 
    9292        long square = value * value; 
    9393        float pixel = square * scale; 
    9494        DataTools.unpackBytes(Float.floatToIntBits(pixel), buf, i*4, 4, 
    95           core.littleEndian[0]); 
     95          isLittleEndian()); 
    9696      } 
    9797    } 
     
    142142    addMeta("File units", units); 
    143143 
    144     core.imageCount[series] = ifds.length; 
    145     core.sizeT[series] = core.imageCount[series]; 
     144    core.imageCount[0] = ifds.length; 
     145    core.sizeT[0] = getImageCount(); 
    146146 
    147147    MetadataStore store = 
  • trunk/loci/formats/in/ICSReader.java

    r4132 r4200  
    133133 
    134134    int bpp = bitsPerPixel / 8; 
    135     int len = core.sizeX[0] * core.sizeY[0] * bpp * getRGBChannelCount(); 
     135    int len = getSizeX() * getSizeY() * bpp * getRGBChannelCount(); 
    136136    int pixel = bpp * getRGBChannelCount(); 
    137137    int rowLen = w * pixel; 
     
    139139    in.seek(offset + no * len); 
    140140 
    141     if (!core.rgb[0] && core.sizeC[0] > 4) { 
     141    if (!isRGB() && getSizeC() > 4) { 
    142142      // channels are stored interleaved, but because there are more than we 
    143143      // can display as RGB, we need to separate them 
    144144      if (!gzip && data == null) { 
    145         data = new byte[len * core.sizeC[0]]; 
     145        data = new byte[len * getSizeC()]; 
    146146        in.read(data); 
    147147      } 
     
    149149      for (int row=y; row<h + y; row++) { 
    150150        for (int col=x; col<w + x; col++) { 
    151           System.arraycopy(data, bpp * (no + core.sizeC[0]* 
    152             (row * core.sizeX[0] + col)), buf, bpp * (row * w + col), bpp); 
    153         } 
    154       } 
    155     } 
    156     else { 
    157       if (!gzip) in.skipBytes(y * rowLen); 
    158  
    159       if (x == 0 && core.sizeX[0] == w) { 
    160         if (gzip) { 
    161           System.arraycopy(data, len * no + y * rowLen, buf, 0, h * rowLen); 
    162         } 
    163         else { 
    164           in.read(buf, 0, h * rowLen); 
    165         } 
     151          System.arraycopy(data, bpp * (no + getSizeC() * 
     152            (row * getSizeX() + col)), buf, bpp * (row * w + col), bpp); 
     153        } 
     154      } 
     155    } 
     156    else if (gzip) { 
     157      if (x == 0 && getSizeX() == w) { 
     158        System.arraycopy(data, len * no + y * rowLen, buf, 0, h * rowLen); 
    166159      } 
    167160      else { 
    168161        for (int row=y; row<h + y; row++) { 
    169           if (gzip) { 
    170             System.arraycopy(data, 
    171               len*no + row * core.sizeX[0] * pixel + x * pixel, buf, 
    172               row * rowLen, rowLen); 
    173           } 
    174           else { 
    175             in.skipBytes(x * pixel); 
    176             in.read(buf, row * rowLen, rowLen); 
    177             in.skipBytes(pixel * (core.sizeX[0] - w - x)); 
    178           } 
    179         } 
    180       } 
     162          System.arraycopy(data, len * no + row * getSizeX() * pixel + 
     163            x * pixel, buf, row * rowLen, rowLen); 
     164        } 
     165      } 
     166    } 
     167    else { 
     168      DataTools.readPlane(in, x, y, w, h, this, buf); 
    181169    } 
    182170 
     
    366354      else if (orderToken.equals("ch")) { 
    367355        core.sizeC[0] = Integer.parseInt(imageToken); 
    368         if (core.sizeC[0] > 4) core.rgb[0] = false; 
     356        if (getSizeC() > 4) core.rgb[0] = false; 
    369357        core.currentOrder[0] += "C"; 
    370358      } 
     
    375363    } 
    376364 
    377     if (core.currentOrder[0].indexOf("Z") == -1) { 
     365    if (getDimensionOrder().indexOf("Z") == -1) { 
    378366      core.currentOrder[0] += "Z"; 
    379367    } 
    380     if (core.currentOrder[0].indexOf("T") == -1) { 
     368    if (getDimensionOrder().indexOf("T") == -1) { 
    381369      core.currentOrder[0] += "T"; 
    382370    } 
    383     if (core.currentOrder[0].indexOf("C") == -1) { 
     371    if (getDimensionOrder().indexOf("C") == -1) { 
    384372      core.currentOrder[0] += "C"; 
    385373    } 
    386374 
    387     if (core.sizeZ[0] == 0) core.sizeZ[0] = 1; 
    388     if (core.sizeC[0] == 0) core.sizeC[0] = 1; 
    389     if (core.sizeT[0] == 0) core.sizeT[0] = 1; 
    390  
    391     if (core.imageCount[0] == 0) core.imageCount[0] = 1; 
    392     core.rgb[0] = core.rgb[0] && core.sizeC[0] > 1; 
    393     core.interleaved[0] = core.rgb[0]; 
    394     core.imageCount[0] = core.sizeZ[0] * core.sizeT[0]; 
    395     if (!core.rgb[0]) core.imageCount[0] *= core.sizeC[0]; 
     375    if (getSizeZ() == 0) core.sizeZ[0] = 1; 
     376    if (getSizeC() == 0) core.sizeC[0] = 1; 
     377    if (getSizeT() == 0) core.sizeT[0] = 1; 
     378 
     379    if (getImageCount() == 0) core.imageCount[0] = 1; 
     380    core.rgb[0] = isRGB() && getSizeC() > 1; 
     381    core.interleaved[0] = isRGB(); 
     382    core.imageCount[0] = getSizeZ() * getSizeT(); 
     383    if (!isRGB()) core.imageCount[0] *= getSizeC(); 
    396384    core.indexed[0] = false; 
    397385    core.falseColor[0] = false; 
     
    420408    // extra check is because some of our datasets are labeled as 'gzip', and 
    421409    // have a valid GZIP header, but are actually uncompressed 
    422     if (gzip && (((in.length() - in.getFilePointer()) / (core.imageCount[0]) < 
    423       (core.sizeX[0] * core.sizeY[0] * bitsPerPixel / 8)))) 
     410    if (gzip && (((in.length() - in.getFilePointer()) / (getImageCount()) < 
     411      (getSizeX() * getSizeY() * bitsPerPixel / 8)))) 
    424412    { 
    425413      data = new byte[(int) (in.length() - in.getFilePointer())]; 
     
    458446    String fmt = rFormat; 
    459447 
    460     if (bitsPerPixel < 32) core.littleEndian[0] = !core.littleEndian[0]; 
     448    if (bitsPerPixel < 32) core.littleEndian[0] = !isLittleEndian(); 
    461449 
    462450    if (fmt.equals("real")) core.pixelType[0] = FormatTools.FLOAT; 
     
    510498    } 
    511499 
    512     int[] emWave = new int[core.sizeC[0]]; 
    513     int[] exWave = new int[core.sizeC[0]]; 
     500    int[] emWave = new int[getSizeC()]; 
     501    int[] exWave = new int[getSizeC()]; 
    514502    if (em != null) { 
    515503      StringTokenizer emTokens = new StringTokenizer(em); 
    516       for (int i=0; i<core.sizeC[0]; i++) { 
     504      for (int i=0; i<getSizeC(); i++) { 
    517505        emWave[i] = (int) Float.parseFloat(emTokens.nextToken().trim()); 
    518506      } 
     
    520508    if (ex != null) { 
    521509      StringTokenizer exTokens = new StringTokenizer(ex); 
    522       for (int i=0; i<core.sizeC[0]; i++) { 
     510      for (int i=0; i<getSizeC(); i++) { 
    523511        exWave[i] = (int) Float.parseFloat(exTokens.nextToken().trim()); 
    524512      } 
  • trunk/loci/formats/in/IPLabReader.java

    r4196 r4200  
    8383    FormatTools.checkBufferSize(this, buf.length, w, h); 
    8484 
    85     int numPixels = core.sizeX[0] * core.sizeY[0] * core.sizeC[0] * bps; 
    86     in.seek(numPixels * (no / core.sizeC[0]) + 44); 
    87  
    88     for (int c=0; c<core.sizeC[0]; c++) { 
    89       in.skipBytes(y * core.sizeX[0] * bps); 
    90  
    91       if (core.sizeX[0] == w) { 
    92         in.read(buf, c * w * h * bps, w * h * bps); 
    93       } 
    94       else { 
    95         for (int row=0; row<h; row++) { 
    96           in.skipBytes(x * bps); 
    97           in.read(buf, c * h * w * bps + row * w * bps, w * bps); 
    98           in.skipBytes(bps * (core.sizeX[0] - w - x)); 
    99         } 
    100       } 
    101       in.skipBytes((core.sizeY[0] - h - y) * core.sizeX[0] * bps); 
    102     } 
    103  
     85    int numPixels = getSizeX() * getSizeY() * getSizeC() * bps; 
     86    in.seek(numPixels * (no / getSizeC()) + 44); 
     87 
     88    DataTools.readPlane(in, x, y, w, h, this, buf); 
    10489    return buf; 
    10590  } 
     
    125110    core.littleEndian[0] = in.readString(4).equals("iiii"); 
    126111 
    127     in.order(core.littleEndian[0]); 
     112    in.order(isLittleEndian()); 
    128113 
    129114    in.skipBytes(12); 
     
    139124    int filePixelType = in.readInt(); 
    140125 
    141     core.imageCount[0] = core.sizeZ[0] * core.sizeT[0]; 
    142  
    143     addMeta("Width", new Long(core.sizeX[0])); 
    144     addMeta("Height", new Long(core.sizeY[0])); 
    145     addMeta("Channels", new Long(core.sizeC[0])); 
    146     addMeta("ZDepth", new Long(core.sizeZ[0])); 
    147     addMeta("TDepth", new Long(core.sizeT[0])); 
     126    core.imageCount[0] = getSizeZ() * getSizeT(); 
     127 
     128    addMeta("Width", new Long(getSizeX())); 
     129    addMeta("Height", new Long(getSizeY())); 
     130    addMeta("Channels", new Long(getSizeC())); 
     131    addMeta("ZDepth", new Long(getSizeZ())); 
     132    addMeta("TDepth", new Long(getSizeT())); 
    148133 
    149134    String ptype; 
     
    185170    } 
    186171 
    187     bps = FormatTools.getBytesPerPixel(core.pixelType[0]); 
     172    bps = FormatTools.getBytesPerPixel(getPixelType()); 
    188173 
    189174    addMeta("PixelType", ptype); 
     
    191176 
    192177    core.currentOrder[0] = "XY"; 
    193     if (core.sizeC[0] > 1) core.currentOrder[0] += "CZT"; 
     178    if (getSizeC() > 1) core.currentOrder[0] += "CZT"; 
    194179    else core.currentOrder[0] += "ZTC"; 
    195180 
    196     core.rgb[0] = core.sizeC[0] > 1; 
     181    core.rgb[0] = getSizeC() > 1; 
    197182    core.interleaved[0] = false; 
    198183    core.indexed[0] = false; 
     
    240225        // error checking 
    241226 
    242         if (size != (44 * core.sizeC[0])) { 
     227        if (size != (44 * getSizeC())) { 
    243228          throw new FormatException("Bad normalization settings"); 
    244229        } 
     
    249234        }; 
    250235 
    251         for (int i=0; i<core.sizeC[0]; i++) { 
     236        for (int i=0; i<getSizeC(); i++) { 
    252237          int source = in.readInt(); 
    253238 
  • trunk/loci/formats/in/IPWReader.java

    r4132 r4200  
    119119  protected void initFile(String id) throws FormatException, IOException { 
    120120    if (debug) debug("IPWReader.initFile(" + id + ")"); 
    121  
    122     currentId = id; 
    123     metadata = new Hashtable(); 
    124     core = new CoreMetadata(1); 
    125     Arrays.fill(core.orderCertain, true); 
    126     getMetadataStore().createRoot(); 
     121    super.initFile(id); 
    127122 
    128123    in = new RandomAccessStream(id); 
     
    234229      TiffTools.SAMPLES_PER_PIXEL, false, 1) > 1); 
    235230 
    236     if (!core.rgb[0]) { 
     231    if (!isRGB()) { 
    237232      core.indexed[0] = TiffTools.getIFDIntValue(ifds[0], 
    238233        TiffTools.PHOTOMETRIC_INTERPRETATION, false, 1) == 
    239234        TiffTools.RGB_PALETTE; 
    240235    } 
    241     if (core.indexed[0]) { 
     236    if (isIndexed()) { 
    242237      core.sizeC[0] = 1; 
    243238      core.rgb[0] = false; 
     
    255250    core.sizeX[0] = TiffTools.getIFDIntValue(h, TiffTools.IMAGE_WIDTH); 
    256251    core.sizeY[0] = TiffTools.getIFDIntValue(h, TiffTools.IMAGE_LENGTH); 
    257     core.currentOrder[0] = core.rgb[0] ? "XYCTZ" : "XYTCZ"; 
    258  
    259     if (core.sizeZ[0] == 0) core.sizeZ[0] = 1; 
    260     if (core.sizeC[0] == 0) core.sizeC[0] = 1; 
    261     if (core.sizeT[0] == 0) core.sizeT[0] = 1; 
    262  
    263     if (core.sizeZ[0] * core.sizeC[0] * core.sizeT[0] == 1 && 
    264       core.imageCount[0] != 1) 
    265     { 
    266       core.sizeZ[0] = core.imageCount[0]; 
    267     } 
    268  
    269     if (core.rgb[0]) core.sizeC[0] *= 3; 
     252    core.currentOrder[0] = isRGB() ? "XYCTZ" : "XYTCZ"; 
     253 
     254    if (getSizeZ() == 0) core.sizeZ[0] = 1; 
     255    if (getSizeC() == 0) core.sizeC[0] = 1; 
     256    if (getSizeT() == 0) core.sizeT[0] = 1; 
     257 
     258    if (getSizeZ() * getSizeC() * getSizeT() == 1 && getImageCount() != 1) { 
     259      core.sizeZ[0] = getImageCount(); 
     260    } 
     261 
     262    if (isRGB()) core.sizeC[0] *= 3; 
    270263 
    271264    int bitsPerSample = TiffTools.getIFDIntValue(ifds[0], 
  • trunk/loci/formats/in/ImageIOReader.java

    r4162 r4200  
    112112 
    113113    core.sizeZ[0] = 1; 
    114     core.sizeC[0] = core.rgb[0] ? 3 : 1; 
     114    core.sizeC[0] = isRGB() ? 3 : 1; 
    115115    core.sizeT[0] = 1; 
    116116    core.currentOrder[0] = "XYCZT"; 
  • trunk/loci/formats/in/ImarisHDFReader.java

    r4196 r4200  
    103103          DataTools.unpackShort( 
    104104            ((short[][][]) previousImage)[zct[0]][row + y][x + i], buf, 
    105             2 * (row * w + i), !core.littleEndian[0]); 
     105            2 * (row * w + i), !isLittleEndian()); 
    106106        } 
    107107      } 
     
    110110          DataTools.unpackBytes( 
    111111            ((int[][][]) previousImage)[zct[0]][row + y][x + i], buf, 
    112             4 * (row * w + i), 4, !core.littleEndian[0]); 
     112            4 * (row * w + i), 4, !isLittleEndian()); 
    113113        } 
    114114      } 
     
    118118        for (int i=0; i<w; i++) { 
    119119          int v = Float.floatToIntBits(s[x + i]); 
    120           DataTools.unpackBytes(v, buf, base + i*4, 4, !core.littleEndian[0]); 
     120          DataTools.unpackBytes(v, buf, base + i*4, 4, !isLittleEndian()); 
    121121        } 
    122122      } 
     
    227227        int cIndex = Integer.parseInt(attr.substring(underscore, 
    228228          attr.indexOf("/", underscore))); 
    229         if (cIndex == core.sizeC[0]) core.sizeC[0]++; 
     229        if (cIndex == getSizeC()) core.sizeC[0]++; 
    230230 
    231231        if (name.equals("Gain")) gain.add(value); 
     
    264264        core.sizeZ[i] = 
    265265          Integer.parseInt(netcdf.getAttributeValue(group + "/ImageSizeZ")); 
    266         core.imageCount[i] = core.sizeZ[i] * core.sizeC[0] * core.sizeT[0]; 
    267       } 
    268     } 
    269     core.imageCount[0] = core.sizeZ[0] * core.sizeC[0] * core.sizeT[0]; 
     266        core.imageCount[i] = core.sizeZ[i] * getSizeC() * getSizeT(); 
     267      } 
     268    } 
     269    core.imageCount[0] = getSizeZ() * getSizeC() * getSizeT(); 
    270270 
    271271    // determine pixel type - this isn't stored in the metadata, so we need 
  • trunk/loci/formats/in/ImarisReader.java

    r4132 r4200  
    146146    status("Calculating image offsets"); 
    147147 
    148     core.imageCount[0] = core.sizeZ[0] * core.sizeC[0]; 
    149     offsets = new int[core.imageCount[0]]; 
    150  
    151     float[] gains = new float[core.sizeC[0]]; 
    152     float[] detectorOffsets = new float[core.sizeC[0]]; 
    153     float[] pinholes = new float[core.sizeC[0]]; 
    154  
    155     for (int i=0; i<core.sizeC[0]; i++) { 
     148    core.imageCount[0] = getSizeZ() * getSizeC(); 
     149    offsets = new int[getImageCount()]; 
     150 
     151    float[] gains = new float[getSizeC()]; 
     152    float[] detectorOffsets = new float[getSizeC()]; 
     153    float[] pinholes = new float[getSizeC()]; 
     154 
     155    for (int i=0; i<getSizeC(); i++) { 
    156156      addMeta("Channel #" + i + " Comment", in.readString(128)); 
    157157      gains[i] = in.readFloat(); 
     
    159159      pinholes[i] = in.readFloat(); 
    160160      in.skipBytes(24); 
    161       int offset = 336 + (164 * core.sizeC[0]) + 
    162         (i * core.sizeX[0] * core.sizeY[0] * core.sizeZ[0]); 
    163       for (int j=0; j<core.sizeZ[0]; j++) { 
    164         offsets[i*core.sizeZ[0] + j] = 
    165           offset + (j * core.sizeX[0] * core.sizeY[0]); 
     161      int offset = 336 + (164 * getSizeC()) + 
     162        (i * getSizeX() * getSizeY() * getSizeZ()); 
     163      for (int j=0; j<getSizeZ(); j++) { 
     164        offsets[i*getSizeZ() + j] = offset + (j * getSizeX() * getSizeY()); 
    166165      } 
    167166    } 
     
    169168    status("Populating metadata"); 
    170169 
    171     core.sizeT[0] = core.imageCount[0] / (core.sizeC[0] * core.sizeZ[0]); 
     170    core.sizeT[0] = getImageCount() / (getSizeC() * getSizeZ()); 
    172171    core.currentOrder[0] = "XYZCT"; 
    173172    core.rgb[0] = false; 
     
    193192 
    194193    // CTR CHECK 
    195     for (int i=0; i<core.sizeC[0]; i++) { 
    196       if ((int) pinholes[i] > 0) { 
     194    for (int i=0; i<getSizeC(); i++) { 
     195      if (pinholes[i] > 0) { 
    197196        store.setLogicalChannelPinholeSize(new Integer((int) pinholes[i]), 
    198197          0, i); 
  • trunk/loci/formats/in/ImarisTiffReader.java

    r4058 r4200  
    9292 
    9393    core.sizeC[0] = ifds.length - 1; 
    94     core.sizeZ[0] = tmp.size() / core.sizeC[0]; 
     94    core.sizeZ[0] = tmp.size() / getSizeC(); 
    9595    core.sizeT[0] = 1; 
    9696    core.sizeX[0] = (int) TiffTools.getImageWidth(ifds[1]); 
     
    9898 
    9999    ifds = (Hashtable[]) tmp.toArray(new Hashtable[0]); 
    100     core.imageCount[0] = core.sizeC[0] * core.sizeZ[0]; 
     100    core.imageCount[0] = getSizeC() * getSizeZ(); 
    101101    core.currentOrder[0] = "XYZCT"; 
    102102    core.interleaved[0] = false; 
    103     core.rgb[0] = 
    104       core.imageCount[0] != core.sizeZ[0] * core.sizeC[0] * core.sizeT[0]; 
    105  
     103    core.rgb[0] = getImageCount() != getSizeZ() * getSizeC() * getSizeT(); 
    106104    core.pixelType[0] = getPixelType(ifds[0]); 
    107105 
     
    129127        } 
    130128        else if (key.equals("LSMEmissionWavelength") && !value.equals("0")) { 
    131           if (channelIndexes[1] < core.sizeC[0]) { 
     129          if (channelIndexes[1] < getSizeC()) { 
    132130            store.setLogicalChannelEmWave(new Integer(value), 0, 
    133131              channelIndexes[1]++); 
     
    135133        } 
    136134        else if (key.equals("LSMExcitationWavelength") && !value.equals("0")) { 
    137           if (channelIndexes[2] < core.sizeC[0]) { 
     135          if (channelIndexes[2] < getSizeC()) { 
    138136            store.setLogicalChannelExWave(new Integer(value), 0, 
    139137              channelIndexes[2]++); 
     
    141139        } 
    142140        else if (key.equals("Name") && !currentId.endsWith(value)) { 
    143           if (channelIndexes[0] < core.sizeC[0]) { 
     141          if (channelIndexes[0] < getSizeC()) { 
    144142            store.setLogicalChannelName(value, 0, channelIndexes[0]++); 
    145143          } 
  • trunk/loci/formats/in/ImprovisionTiffReader.java

    r4132 r4200  
    137137    core.sizeT[0] = Integer.parseInt(tt); 
    138138 
    139     if (core.sizeZ[0] * core.sizeC[0] * core.sizeT[0] < core.imageCount[0]) { 
    140       core.sizeC[0] = core.imageCount[0]; 
     139    if (getSizeZ() * getSizeC() * getSizeT() < getImageCount()) { 
     140      core.sizeC[0] = getImageCount(); 
    141141    } 
    142142 
     
    146146    int[][] coords = new int[ifds.length][3]; 
    147147 
    148     cNames = new String[core.sizeC[0]]; 
     148    cNames = new String[getSizeC()]; 
    149149 
    150150    for (int i=0; i<ifds.length; i++) { 
     
    187187      if (diff > 0) sum += diff; 
    188188    } 
    189     pixelSizeT = (int) (sum / core.sizeT[0]); 
     189    pixelSizeT = (int) (sum / getSizeT()); 
    190190 
    191191    // determine dimension order 
     
    197197      int tDiff = coords[i][2] - coords[i - 1][2]; 
    198198 
    199       if (zDiff > 0 && core.currentOrder[0].indexOf("Z") < 0) { 
     199      if (zDiff > 0 && getDimensionOrder().indexOf("Z") < 0) { 
    200200        core.currentOrder[0] += "Z"; 
    201201      } 
    202       if (cDiff > 0 && core.currentOrder[0].indexOf("C") < 0) { 
     202      if (cDiff > 0 && getDimensionOrder().indexOf("C") < 0) { 
    203203        core.currentOrder[0] += "C"; 
    204204      } 
    205       if (tDiff > 0 && core.currentOrder[0].indexOf("T") < 0) { 
     205      if (tDiff > 0 && getDimensionOrder().indexOf("T") < 0) { 
    206206        core.currentOrder[0] += "T"; 
    207207      } 
     
    209209    } 
    210210 
    211     if (core.currentOrder[0].indexOf("Z") < 0) core.currentOrder[0] += "Z"; 
    212     if (core.currentOrder[0].indexOf("C") < 0) core.currentOrder[0] += "C"; 
    213     if (core.currentOrder[0].indexOf("T") < 0) core.currentOrder[0] += "T"; 
     211    if (getDimensionOrder().indexOf("Z") < 0) core.currentOrder[0] += "Z"; 
     212    if (getDimensionOrder().indexOf("C") < 0) core.currentOrder[0] += "C"; 
     213    if (getDimensionOrder().indexOf("T") < 0) core.currentOrder[0] += "T"; 
    214214  } 
    215215 
  • trunk/loci/formats/in/InCellReader.java

    r4190 r4200  
    5555 
    5656  private Vector tiffs; 
    57   private TiffReader[][] tiffReaders; 
     57  private MinimalTiffReader tiffReader; 
    5858  private int seriesCount; 
    5959  private Vector emWaves, exWaves; 
     
    8686  public byte[][] get8BitLookupTable() throws FormatException, IOException { 
    8787    FormatTools.assertId(currentId, true, 1); 
    88     return tiffReaders[series][0].get8BitLookupTable(); 
     88    return tiffReader.get8BitLookupTable(); 
    8989  } 
    9090 
     
    9292  public short[][] get16BitLookupTable() throws FormatException, IOException { 
    9393    FormatTools.assertId(currentId, true, 1); 
    94     return tiffReaders[series][0].get16BitLookupTable(); 
     94    return tiffReader.get16BitLookupTable(); 
    9595  } 
    9696 
     
    104104    FormatTools.checkPlaneNumber(this, no); 
    105105    FormatTools.checkBufferSize(this, buf.length, w, h); 
    106     tiffReaders[series][no].setId( 
    107       (String) tiffs.get(series * tiffReaders[0].length + no)); 
    108     return tiffReaders[series][no].openBytes(0, buf, x, y, w, h); 
     106    tiffReader.setId((String) tiffs.get(series * getImageCount() + no)); 
     107    return tiffReader.openBytes(0, buf, x, y, w, h); 
    109108  } 
    110109 
     
    126125    super.close(); 
    127126    tiffs = null; 
    128     if (tiffReaders != null) { 
    129       for (int i=0; i<tiffReaders.length; i++) { 
    130         for (int j=0; j<tiffReaders[i].length; j++) { 
    131           tiffReaders[i][j].close(); 
    132         } 
    133       } 
    134       tiffReaders = null; 
    135     } 
     127    if (tiffReader != null) tiffReader.close(); 
     128    tiffReader = null; 
    136129    seriesCount = 0; 
    137130    totalImages = 0; 
     
    166159    InCellHandler handler = new InCellHandler(store); 
    167160 
     161    status("starting xml parse"); 
     162    long t1 = System.currentTimeMillis();  
    168163    try { 
    169164      SAXParser parser = SAX_FACTORY.newSAXParser(); 
     
    176171      throw new FormatException(exc); 
    177172    } 
    178  
    179     seriesCount = totalImages / (core.sizeZ[0] * core.sizeC[0] * core.sizeT[0]); 
    180     tiffReaders = new TiffReader[seriesCount][tiffs.size() / seriesCount]; 
    181     for (int i=0; i<tiffReaders.length; i++) { 
    182       for (int j=0; j<tiffReaders[0].length; j++) { 
    183         tiffReaders[i][j] = new TiffReader(); 
    184       } 
    185       tiffReaders[i][0].setId((String) tiffs.get(i * tiffReaders[0].length)); 
    186     } 
    187  
    188     int z = core.sizeZ[0]; 
    189     int c = core.sizeC[0]; 
    190     int t = core.sizeT[0]; 
     173    long t2 = System.currentTimeMillis(); 
     174    status("finished xml parse (" + (t2 - t1) + ")"); 
     175 
     176    seriesCount = totalImages / (getSizeZ() * getSizeC() * getSizeT()); 
     177 
     178    int z = getSizeZ(); 
     179    int c = getSizeC(); 
     180    int t = getSizeT(); 
    191181 
    192182    core = new CoreMetadata(seriesCount); 
     
    204194    } 
    205195 
     196    tiffReader = new MinimalTiffReader(); 
     197 
    206198    int nextTiming = 0; 
    207199    for (int i=0; i<seriesCount; i++) { 
    208       core.sizeX[i] = tiffReaders[i][0].getSizeX(); 
    209       core.sizeY[i] = tiffReaders[i][0].getSizeY(); 
    210       core.interleaved[i] = tiffReaders[i][0].isInterleaved(); 
    211       core.indexed[i] = tiffReaders[i][0].isIndexed(); 
    212       core.rgb[i] = tiffReaders[i][0].isRGB(); 
    213       core.pixelType[i] = tiffReaders[i][0].getPixelType(); 
    214       core.littleEndian[i] = tiffReaders[i][0].isLittleEndian(); 
     200      tiffReader.setId((String) tiffs.get(i * (tiffs.size() / seriesCount))); 
     201      core.sizeX[i] = tiffReader.getSizeX(); 
     202      core.sizeY[i] = tiffReader.getSizeY(); 
     203      core.interleaved[i] = tiffReader.isInterleaved(); 
     204      core.indexed[i] = tiffReader.isIndexed(); 
     205      core.rgb[i] = tiffReader.isRGB(); 
     206      core.pixelType[i] = tiffReader.getPixelType(); 
     207      core.littleEndian[i] = tiffReader.isLittleEndian(); 
    215208      store.setImageName("", i); 
    216209      store.setImageCreationDate(creationDate, i); 
     
    291284        int c = Integer.parseInt(attributes.getValue("wave_index")) + 1; 
    292285        int t = Integer.parseInt(attributes.getValue("time_index")) + 1; 
    293         core.sizeZ[0] = (int) Math.max(core.sizeZ[0], z); 
    294         core.sizeC[0] = (int) Math.max(core.sizeC[0], c); 
    295         core.sizeT[0] = (int) Math.max(core.sizeT[0], t); 
     286        core.sizeZ[0] = (int) Math.max(getSizeZ(), z); 
     287        core.sizeC[0] = (int) Math.max(getSizeC(), c); 
     288        core.sizeT[0] = (int) Math.max(getSizeT(), t); 
    296289      } 
    297290      else if (qName.equals("Creation")) { 
  • trunk/loci/formats/in/KhorosReader.java

    r4132 r4200  
    8282    FormatTools.checkBufferSize(this, buf.length, w, h); 
    8383 
    84     int bytes = FormatTools.getBytesPerPixel(core.pixelType[0]); 
    85     int bufSize = core.sizeX[0] * core.sizeY[0] * bytes; 
    86  
    87     in.seek(offset + no * bufSize + y * core.sizeX[0] * bytes); 
    88  
    89     if (core.sizeX[0] == w) { 
    90       in.read(buf); 
    91     } 
    92     else { 
    93       for (int row=0; row<h; row++) { 
    94         in.skipBytes(x * bytes); 
    95         in.read(buf, row * w * bytes, w * bytes); 
    96         in.skipBytes(bytes * (core.sizeX[0] - w - x)); 
    97       } 
    98     } 
     84    int bytes = FormatTools.getBytesPerPixel(getPixelType()); 
     85    int bufSize = getSizeX() * getSizeY() * bytes; 
     86    in.seek(offset + no * bufSize); 
     87    DataTools.readPlane(in, x, y, w, h, this, buf); 
    9988 
    10089    return buf; 
     
    129118    in.skipBytes(28); 
    130119    core.imageCount[0] = in.readInt(); 
    131     if (core.imageCount[0] == 0) core.imageCount[0] = 1; 
     120    if (getImageCount() == 0) core.imageCount[0] = 1; 
    132121    core.sizeC[0] = in.readInt(); 
    133122 
     
    184173    offset = in.getFilePointer(); 
    185174 
    186     core.sizeZ[0] = core.imageCount[0]; 
     175    core.sizeZ[0] = getImageCount(); 
    187176    core.sizeT[0] = 1; 
    188     core.rgb[0] = core.sizeC[0] > 1; 
     177    core.rgb[0] = getSizeC() > 1; 
    189178    core.interleaved[0] = false; 
    190179    core.littleEndian[0] = dependency == 4 || dependency == 8; 
     
    194183    core.metadataComplete[0] = true; 
    195184 
    196     if (core.indexed[0]) { 
     185    if (isIndexed()) { 
    197186      core.sizeC[0] = 1; 
    198187      core.rgb[0] = false; 
  • trunk/loci/formats/in/L2DReader.java

    r4132 r4200  
    4747  private Vector used; 
    4848 
    49   private TiffReader[][] readers; 
     49  private MinimalTiffReader reader; 
    5050 
    5151  // -- Constructor -- 
     
    7373    FormatTools.checkBufferSize(this, buf.length, w, h); 
    7474 
    75     return readers[series][no].openBytes(0, buf, x, y, w, h); 
     75    reader.setId((String) tiffs[series].get(no)); 
     76    return reader.openBytes(0, buf, x, y, w, h); 
    7677  } 
    7778 
     
    9394    super.close(); 
    9495    tiffs = null; 
    95     readers = null; 
     96    if (reader != null) reader.close(); 
     97    reader = null; 
    9698    used = null; 
    9799  } 
     
    191193    } 
    192194 
    193     readers = new TiffReader[scans.size()][]; 
     195    reader = new MinimalTiffReader(); 
    194196 
    195197    MetadataStore store = 
     
    203205      core.currentOrder[i] = "XYCZT"; 
    204206 
    205       readers[i] = new TiffReader[tiffs[i].size()]; 
    206  
    207207      for (int t=0; t<tiffs[i].size(); t++) { 
    208         readers[i][t] = new TiffReader(); 
    209         readers[i][t].setId((String) tiffs[i].get(t)); 
     208        reader.setId((String) tiffs[i].get(t)); 
    210209        if (t == 0) { 
    211           core.sizeX[i] = readers[i][t].getSizeX(); 
    212           core.sizeY[i] = readers[i][t].getSizeY(); 
    213           core.sizeC[i] *= readers[i][t].getSizeC(); 
    214           core.rgb[i] = readers[i][t].isRGB(); 
    215           core.indexed[i] = readers[i][t].isIndexed(); 
    216           core.littleEndian[i] = readers[i][t].isLittleEndian(); 
    217           core.pixelType[i] = readers[i][t].getPixelType(); 
     210          core.sizeX[i] = reader.getSizeX(); 
     211          core.sizeY[i] = reader.getSizeY(); 
     212          core.sizeC[i] *= reader.getSizeC(); 
     213          core.rgb[i] = reader.isRGB(); 
     214          core.indexed[i] = reader.isIndexed(); 
     215          core.littleEndian[i] = reader.isLittleEndian(); 
     216          core.pixelType[i] = reader.getPixelType(); 
    218217        } 
    219218      } 
  • trunk/loci/formats/in/LIFReader.java

    r4142 r4200  
    101101 
    102102    long offset = ((Long) offsets.get(series)).longValue(); 
    103     int bytes = FormatTools.getBytesPerPixel(core.pixelType[series]); 
     103    int bytes = FormatTools.getBytesPerPixel(getPixelType()); 
    104104    int bpp = bytes * getRGBChannelCount(); 
    105     in.seek(offset + core.sizeX[series] * core.sizeY[series] * (long) no * bpp); 
    106  
    107     in.skipBytes(y * core.sizeX[series] * bpp); 
    108  
    109     int line = w * bpp; 
    110     if (core.sizeX[series] == w) { 
    111       in.read(buf); 
    112     } 
    113     else { 
    114       for (int row=0; row<h; row++) { 
    115         in.skipBytes(x * bpp); 
    116         in.read(buf, row * line, line); 
    117         in.skipBytes(bpp * (core.sizeX[series] - w - x)); 
    118       } 
    119     } 
     105    in.seek(offset + getSizeX() * getSizeY() * (long) no * bpp); 
     106    DataTools.readPlane(in, x, y, w, h, this, buf); 
    120107 
    121108    return buf; 
     
    142129 
    143130    core.littleEndian[0] = true; 
    144     in.order(core.littleEndian[0]); 
     131    in.order(isLittleEndian()); 
    145132 
    146133    xcal = new Vector(); 
  • trunk/loci/formats/in/LIMReader.java

    r4132 r4200  
    6464    FormatTools.checkBufferSize(this, buf.length, w, h); 
    6565 
    66     in.seek(0x94b + y * core.sizeX[0] * core.sizeC[0]); 
    67  
    68     if (core.sizeX[series] == w) { 
    69       in.read(buf); 
    70     } 
    71     else { 
    72       for (int row=0; row<h; row++) { 
    73         in.skipBytes(x * core.sizeC[0]); 
    74         in.read(buf, row * w * core.sizeC[0], w * core.sizeC[0]); 
    75         in.skipBytes(core.sizeC[0] * (core.sizeX[0] - w - x)); 
    76       } 
    77     } 
     66    in.seek(0x94b); 
     67    DataTools.readPlane(in, x, y, w, h, this, buf); 
    7868 
    7969    // swap red and blue channels 
    80     if (core.rgb[0]) { 
     70    if (isRGB()) { 
    8171      for (int i=0; i<buf.length/3; i++) { 
    8272        byte tmp = buf[i*3]; 
     
    10696 
    10797    core.littleEndian[0] = true; 
    108     in.order(core.littleEndian[0]); 
     98    in.order(isLittleEndian()); 
    10999 
    110100    core.sizeX[0] = in.readShort() & 0x7fff; 
     
    143133    core.sizeZ[0] = 1; 
    144134    core.sizeT[0] = 1; 
    145     if (core.sizeC[0] == 0) core.sizeC[0] = 1; 
    146     core.rgb[0] = core.sizeC[0] > 1; 
     135    if (getSizeC() == 0) core.sizeC[0] = 1; 
     136    core.rgb[0] = getSizeC() > 1; 
    147137    core.currentOrder[0] = "XYZCT"; 
    148138    core.indexed[0] = false; 
  • trunk/loci/formats/in/LegacyND2Reader.java

    r4132 r4200  
    9797 
    9898    int[] zct = FormatTools.getZCTCoords(this, no); 
    99     int bpc = FormatTools.getBytesPerPixel(core.pixelType[series]); 
    100     byte[] b = new byte[core.sizeX[series] * core.sizeY[series] * bpc * 
    101       getRGBChannelCount()]; 
     99    int bpc = FormatTools.getBytesPerPixel(getPixelType()); 
     100    byte[] b = new byte[getSizeX() * getSizeY() * bpc * getRGBChannelCount()]; 
    102101 
    103102    getImage(b, getSeries(), zct[0], zct[1], zct[2]); 
     
    106105    int rowLen = w * pixel; 
    107106    for (int row=0; row<h; row++) { 
    108       System.arraycopy(b, (row + y) * core.sizeX[series] * pixel + x * pixel, 
     107      System.arraycopy(b, (row + y) * getSizeX() * pixel + x * pixel, 
    109108        buf, row * rowLen, rowLen); 
    110109    } 
    111110 
    112     if (core.rgb[series]) { 
    113       int bpp = core.sizeC[series] * bpc; 
     111    if (isRGB()) { 
     112      int bpp = getSizeC() * bpc; 
    114113      int line = w * bpp; 
    115114      for (int row=0; row<h; row++) { 
    116115        for (int col=0; col<w; col++) { 
     116          int base = row * line + col * bpp; 
    117117          for (int bb=0; bb<bpc; bb++) { 
    118             byte blue = 
    119               buf[row*line + col*bpp + bpc*(core.sizeC[series] - 1) + bb]; 
    120             buf[row*line + col*bpp + bpc*(core.sizeC[series] - 1) + bb] = 
    121               buf[row*line + col*bpp + bb]; 
    122             buf[row*line + col*bpp + bb] = blue; 
     118            byte blue = buf[base + bpc*(getSizeC() - 1) + bb]; 
     119            buf[base + bpc*(getSizeC() - 1) + bb] = buf[base + bb]; 
     120            buf[base + bb] = blue; 
    123121          } 
    124122        } 
  • trunk/loci/formats/in/LegacyQTReader.java

    r4132 r4200  
    209209      while (time >= 0); 
    210210      core.imageCount[0] = v.size(); 
    211       times = new int[core.imageCount[0]]; 
     211      times = new int[getImageCount()]; 
    212212      for (int i=0; i<times.length; i++) { 
    213213        q = (Integer) v.elementAt(i); 
     
    223223      core.sizeZ[0] = 1; 
    224224      core.sizeC[0] = img.getRaster().getNumBands(); 
    225       core.sizeT[0] = core.imageCount[0]; 
     225      core.sizeT[0] = getImageCount(); 
    226226      core.pixelType[0] = ImageTools.getPixelType(img); 
    227227      core.currentOrder[0] = "XYCTZ"; 
  • trunk/loci/formats/in/LeicaReader.java

    r4132 r4200  
    5959  private static final int LUTDESC = 70; 
    6060 
     61  // -- Static fields -- 
     62 
     63  private Hashtable dimensionNames = makeDimensionTable(); 
     64 
    6165  // -- Fields -- 
    6266 
     
    6771 
    6872  /** Helper readers. */ 
    69   protected TiffReader[][] tiff; 
     73  protected MinimalTiffReader tiff; 
    7074 
    7175  /** Array of image file names. */ 
     
    131135  public byte[][] get8BitLookupTable() throws FormatException, IOException { 
    132136    FormatTools.assertId(currentId, true, 1); 
    133     tiff[series][0].setId((String) files[series].get(0)); 
    134     return tiff[series][0].get8BitLookupTable(); 
     137    tiff.setId((String) files[series].get(0)); 
     138    return tiff.get8BitLookupTable(); 
    135139  } 
    136140 
     
    138142  public short[][] get16BitLookupTable() throws FormatException, IOException { 
    139143    FormatTools.assertId(currentId, true, 1); 
    140     tiff[series][0].setId((String) files[series].get(0)); 
    141     return tiff[series][0].get16BitLookupTable(); 
     144    tiff.setId((String) files[series].get(0)); 
     145    return tiff.get16BitLookupTable(); 
    142146  } 
    143147 
     
    155159    FormatTools.assertId(currentId, true, 1); 
    156160    FormatTools.checkPlaneNumber(this, no); 
    157     tiff[series][no].setId((String) files[series].get(no)); 
    158     return tiff[series][no].openBytes(0, buf, x, y, w, h); 
     161    tiff.setId((String) files[series].get(no)); 
     162    return tiff.openBytes(0, buf, x, y, w, h); 
    159163  } 
    160164 
     
    175179  public void close(boolean fileOnly) throws IOException { 
    176180    if (in != null) in.close(); 
    177     if (tiff != null) { 
    178       for (int i=0; i<tiff.length; i++) { 
    179         if (tiff[i] != null) { 
    180           for (int j=0; j<tiff[i].length; j++) { 
    181             if (tiff[i][j] != null) tiff[i][j].close(fileOnly); 
    182           } 
    183         } 
    184       } 
    185     } 
     181    if (tiff != null) tiff.close(); 
     182    tiff = null; 
    186183    if (!fileOnly) { 
    187184      super.close(); 
     
    278275      fourBytes[3] == TiffTools.LITTLE); 
    279276 
    280     in.order(core.littleEndian[0]); 
     277    in.order(isLittleEndian()); 
    281278 
    282279    status("Reading metadata blocks"); 
     
    303300        byte[] data = new byte[size]; 
    304301        in.read(data); 
    305         ifd.put(new Integer(tag), (Object) data); 
     302        ifd.put(new Integer(tag), data); 
    306303        in.seek(pos); 
    307304        tag = in.readInt(); 
     
    325322    status("Parsing metadata blocks"); 
    326323 
    327     core.littleEndian[0] = !core.littleEndian[0]; 
     324    core.littleEndian[0] = !isLittleEndian(); 
    328325 
    329326    int seriesIndex = 0; 
     
    333330      if (headerIFDs[i].get(new Integer(SERIES)) != null) { 
    334331        byte[] temp = (byte[]) headerIFDs[i].get(new Integer(SERIES)); 
    335         nameLength = DataTools.bytesToInt(temp, 8, core.littleEndian[0]) * 2; 
     332        nameLength = DataTools.bytesToInt(temp, 8, isLittleEndian()) * 2; 
    336333      } 
    337334 
    338335      Vector f = new Vector(); 
    339336      byte[] tempData = (byte[]) headerIFDs[i].get(new Integer(IMAGES)); 
    340       int tempImages = DataTools.bytesToInt(tempData, 0, core.littleEndian[0]); 
    341  
    342       if (((long) tempImages * nameLength) > tempData.length) { 
    343         tempImages = DataTools.bytesToInt(tempData, 0, !core.littleEndian[0]); 
     337      RandomAccessStream data = new RandomAccessStream(tempData); 
     338      data.order(isLittleEndian()); 
     339      int tempImages = data.readInt(); 
     340 
     341      if (((long) tempImages * nameLength) > data.length()) { 
     342        data.order(!isLittleEndian()); 
     343        tempImages = data.readInt(); 
     344        data.order(isLittleEndian()); 
    344345      } 
    345346 
     
    367368      boolean tiffsExist = true; 
    368369 
     370      data.seek(20); 
     371 
    369372      String prefix = ""; 
    370373      for (int j=0; j<tempImages; j++) { 
    371374        // read in each filename 
    372         prefix = DataTools.stripString(new String(tempData, 
    373           20 + j*nameLength, nameLength)); 
     375        prefix = getString(data, nameLength); 
    374376        f.add(dirPrefix + prefix); 
    375377        // test to make sure the path is valid 
     
    378380        if (tiffsExist) tiffsExist = test.exists(); 
    379381      } 
     382      data.close(); 
     383      tempData = null; 
    380384 
    381385      // at least one of the TIFF files was renamed 
     
    472476    } 
    473477 
    474     tiff = new TiffReader[numSeries][maxPlanes]; 
    475  
    476     for (int i=0; i<tiff.length; i++) { 
    477       for (int j=0; j<tiff[i].length; j++) { 
    478         tiff[i][j] = new TiffReader(); 
    479         if (j > 0) tiff[i][j].setMetadataCollected(false); 
    480       } 
    481     } 
     478    tiff = new MinimalTiffReader(); 
    482479 
    483480    status("Populating metadata"); 
     
    497494        // ID_SERIES 
    498495        RandomAccessStream stream = new RandomAccessStream(temp); 
    499         stream.order(core.littleEndian[0]); 
     496        stream.order(isLittleEndian()); 
    500497        addMeta("Version", new Integer(stream.readInt())); 
    501498        addMeta("Number of Series", new Integer(stream.readInt())); 
    502499        fileLength = stream.readInt(); 
    503500        addMeta("Length of filename", new Integer(fileLength)); 
    504         Integer fileExtLen = new Integer(stream.readInt()); 
    505         if (fileExtLen.intValue() > fileLength) { 
     501        Integer extLen = new Integer(stream.readInt()); 
     502        if (extLen.intValue() > fileLength) { 
    506503          stream.seek(0); 
    507           core.littleEndian[0] = !core.littleEndian[0]; 
    508           stream.order(core.littleEndian[0]); 
     504          core.littleEndian[0] = !isLittleEndian(); 
     505          stream.order(isLittleEndian()); 
    509506          fileLength = stream.readInt(); 
    510           fileExtLen = new Integer(stream.readInt()); 
    511         } 
    512         addMeta("Length of file extension", fileExtLen); 
    513         addMeta("Image file extension", 
    514           DataTools.stripString(stream.readString(fileExtLen.intValue()))); 
     507          extLen = new Integer(stream.readInt()); 
     508        } 
     509        addMeta("Length of file extension", extLen); 
     510        addMeta("Image file extension", getString(stream, extLen.intValue())); 
    515511        stream.close(); 
    516512      } 
     
    521517        // ID_IMAGES 
    522518        RandomAccessStream s = new RandomAccessStream(temp); 
    523         s.order(core.littleEndian[0]); 
     519        s.order(isLittleEndian()); 
    524520 
    525521        core.imageCount[i] = s.readInt(); 
     
    533529        addMeta("Samples per pixel", new Integer(s.readInt())); 
    534530 
    535         String prefix = DataTools.stripString(s.readString(fileLength * 2)); 
     531        String prefix = getString(s, fileLength * 2); 
    536532        s.close(); 
    537533 
     
    559555 
    560556        RandomAccessStream stream = new RandomAccessStream(temp); 
    561         stream.order(core.littleEndian[0]); 
     557        stream.order(isLittleEndian()); 
    562558 
    563559        addMeta("Voxel Version", new Integer(stream.readInt())); 
     
    592588        addMeta("Real world resolution", new Integer(resolution)); 
    593589        int length = stream.readInt(); 
    594         addMeta("Maximum voxel intensity", 
    595           DataTools.stripString(stream.readString(length * 2))); 
     590        addMeta("Maximum voxel intensity", getString(stream, length * 2)); 
    596591        length = stream.readInt(); 
    597         addMeta("Minimum voxel intensity", 
    598           DataTools.stripString(stream.readString(length * 2))); 
     592        addMeta("Minimum voxel intensity", getString(stream, length * 2)); 
    599593        length = stream.readInt(); 
    600594        stream.skipBytes(length * 2); 
     
    603597        for (int j=0; j<length; j++) { 
    604598          int dimId = stream.readInt(); 
    605           String dimType = ""; 
    606           switch (dimId) { 
    607             case 0: 
    608               dimType = "undefined"; 
    609               break; 
    610             case 120: 
    611               dimType = "x"; 
    612               break; 
    613             case 121: 
    614               dimType = "y"; 
    615               break; 
    616             case 122: 
    617               dimType = "z"; 
    618               break; 
    619             case 116: 
    620               dimType = "t"; 
    621               break; 
    622             case 6815843: 
    623               dimType = "channel"; 
    624               break; 
    625             case 6357100: 
    626               dimType = "wave length"; 
    627               break; 
    628             case 7602290: 
    629               dimType = "rotation"; 
    630               break; 
    631             case 7798904: 
    632               dimType = "x-wide for the motorized xy-stage"; 
    633               break; 
    634             case 7798905: 
    635               dimType = "y-wide for the motorized xy-stage"; 
    636               break; 
    637             case 7798906: 
    638               dimType = "z-wide for the z-stage-drive"; 
    639               break; 
    640             case 4259957: 
    641               dimType = "user1 - unspecified"; 
    642               break; 
    643             case 4325493: 
    644               dimType = "user2 - unspecified"; 
    645               break; 
    646             case 4391029: 
    647               dimType = "user3 - unspecified"; 
    648               break; 
    649             case 6357095: 
    650               dimType = "graylevel"; 
    651               break; 
    652             case 6422631: 
    653               dimType = "graylevel1"; 
    654               break; 
    655             case 6488167: 
    656               dimType = "graylevel2"; 
    657               break; 
    658             case 6553703: 
    659               dimType = "graylevel3"; 
    660               break; 
    661             case 7864398: 
    662               dimType = "logical x"; 
    663               break; 
    664             case 7929934: 
    665               dimType = "logical y"; 
    666               break; 
    667             case 7995470: 
    668               dimType = "logical z"; 
    669               break; 
    670             case 7602254: 
    671               dimType = "logical t"; 
    672               break; 
    673             case 7077966: 
    674               dimType = "logical lambda"; 
    675               break; 
    676             case 7471182: 
    677               dimType = "logical rotation"; 
    678               break; 
    679             case 5767246: 
    680               dimType = "logical x-wide"; 
    681               break; 
    682             case 5832782: 
    683               dimType = "logical y-wide"; 
    684               break; 
    685             case 5898318: 
    686               dimType = "logical z-wide"; 
    687               break; 
    688           } 
     599          String dimType = (String) dimensionNames.get(new Integer(dimId)); 
    689600 
    690601          int size = stream.readInt(); 
     
    717628 
    718629          int len = stream.readInt(); 
    719           addMeta("Dim" + j + " physical length", 
    720             DataTools.stripString(stream.readString(len * 2))); 
     630          addMeta("Dim" + j + " physical length", getString(stream, len * 2)); 
    721631 
    722632          len = stream.readInt(); 
    723           addMeta("Dim" + j + " physical origin", 
    724             DataTools.stripString(stream.readString(len * 2))); 
     633          addMeta("Dim" + j + " physical origin", getString(stream, len * 2)); 
    725634        } 
    726635        int len = stream.readInt(); 
    727         addMeta("Series name", DataTools.stripString(stream.readString(len))); 
     636        addMeta("Series name", getString(stream, len)); 
    728637 
    729638        len = stream.readInt(); 
    730         addMeta("Series description", 
    731           DataTools.stripString(stream.readString(len))); 
     639        addMeta("Series description", getString(stream, len)); 
    732640        stream.close(); 
    733641      } 
     
    748656 
    749657        RandomAccessStream stream = new RandomAccessStream(temp); 
    750         stream.order(core.littleEndian[0]); 
     658        stream.order(isLittleEndian()); 
    751659        stream.seek(0); 
    752660 
     
    766674        timestamps = new String[numStamps]; 
    767675        for (int j=0; j<numStamps; j++) { 
    768           timestamps[j] = DataTools.stripString(stream.readString(64)); 
     676          timestamps[j] = getString(stream, 64); 
    769677          addMeta("Timestamp " + j, timestamps[j]); 
    770678        } 
     
    781689                " Dimension " + k + " coordinate", new Integer(value)); 
    782690            } 
    783             addMeta("Time-marker " + j, 
    784               DataTools.stripString(stream.readString(64))); 
     691            addMeta("Time-marker " + j, getString(stream, 64)); 
    785692          } 
    786693        } 
     
    802709 
    803710        RandomAccessStream stream = new RandomAccessStream(temp); 
    804         stream.order(core.littleEndian[0]); 
     711        stream.order(isLittleEndian()); 
    805712        stream.seek(8); 
    806713 
    807714        int len = stream.readInt(); 
    808         description = DataTools.stripString(stream.readString(len * 2)); 
     715        description = getString(stream, len * 2); 
    809716        addMeta("Image Description", description); 
    810717        len = stream.readInt(); 
    811718 
    812         addMeta("Main file extension", 
    813           DataTools.stripString(stream.readString(len * 2))); 
     719        addMeta("Main file extension", getString(stream, len * 2)); 
    814720 
    815721        len = stream.readInt(); 
    816         addMeta("Single image format identifier", 
    817           DataTools.stripString(stream.readString(len * 2))); 
     722        addMeta("Single image format identifier", getString(stream, len * 2)); 
    818723 
    819724        len = stream.readInt(); 
    820         addMeta("Single image extension", 
    821           DataTools.stripString(stream.readString(len * 2))); 
     725        addMeta("Single image extension", getString(stream, len * 2)); 
    822726        stream.close(); 
    823727      } 
     
    829733 
    830734        RandomAccessStream stream = new RandomAccessStream(temp); 
    831         stream.order(core.littleEndian[0]); 
     735        stream.order(isLittleEndian()); 
    832736 
    833737        int nChannels = stream.readInt(); 
     
    838742        for (int j=0; j<nChannels; j++) { 
    839743          int value = stream.readInt(); 
    840           addMeta("LUT Channel " + j + " version", new Integer(value)); 
     744          String prefix = "LUT Channel " + j; 
     745          addMeta(prefix + " version", new Integer(value)); 
    841746 
    842747          int invert = stream.read(); 
    843748          boolean inverted = invert == 1; 
    844           addMeta("LUT Channel " + j + " inverted?", new Boolean(inverted)); 
     749          addMeta(prefix + " inverted?", new Boolean(inverted)); 
    845750 
    846751          int length = stream.readInt(); 
    847           addMeta("LUT Channel " + j + " description", 
    848             DataTools.stripString(stream.readString(length))); 
     752          addMeta(prefix + " description", getString(stream, length)); 
    849753 
    850754          length = stream.readInt(); 
    851           addMeta("LUT Channel " + j + " filename", 
    852             DataTools.stripString(stream.readString(length))); 
     755          addMeta(prefix + " filename", getString(stream, length)); 
    853756          length = stream.readInt(); 
    854757 
    855           String name = DataTools.stripString(stream.readString(length)); 
    856  
    857           addMeta("LUT Channel " + j + " name", name); 
     758          addMeta(prefix + " name", getString(stream, length)); 
    858759          stream.skipBytes(8); 
    859760        } 
     
    863764 
    864765    Arrays.fill(core.orderCertain, true); 
    865     Arrays.fill(core.littleEndian, core.littleEndian[0]); 
     766    Arrays.fill(core.littleEndian, isLittleEndian()); 
    866767    Arrays.fill(core.falseColor, true); 
    867768    Arrays.fill(core.metadataComplete, true); 
     
    883784        core.sizeT[i] = 1; 
    884785      } 
    885       tiff[i][0].setId((String) files[i].get(0)); 
    886       core.sizeX[i] = tiff[i][0].getSizeX(); 
    887       core.sizeY[i] = tiff[i][0].getSizeY(); 
    888       core.rgb[i] = tiff[i][0].isRGB(); 
    889       core.indexed[i] = tiff[i][0].isIndexed(); 
    890       core.sizeC[i] *= tiff[i][0].getSizeC(); 
     786      tiff.setId((String) files[i].get(0)); 
     787      core.sizeX[i] = tiff.getSizeX(); 
     788      core.sizeY[i] = tiff.getSizeY(); 
     789      core.rgb[i] = tiff.isRGB(); 
     790      core.indexed[i] = tiff.isIndexed(); 
     791      core.sizeC[i] *= tiff.getSizeC(); 
    891792 
    892793      if (core.currentOrder[i].indexOf("C") == -1) { 
     
    932833  } 
    933834 
     835  private String getString(RandomAccessStream stream, int len) 
     836    throws IOException 
     837  { 
     838    return DataTools.stripString(stream.readString(len)); 
     839  } 
     840 
     841  private static Hashtable makeDimensionTable() { 
     842    Hashtable table = new Hashtable(); 
     843    table.put(new Integer(0), "undefined"); 
     844    table.put(new Integer(120), "x"); 
     845    table.put(new Integer(121), "y"); 
     846    table.put(new Integer(122), "z"); 
     847    table.put(new Integer(116), "t"); 
     848    table.put(new Integer(6815843), "channel"); 
     849    table.put(new Integer(6357100), "wave length"); 
     850    table.put(new Integer(7602290), "rotation"); 
     851    table.put(new Integer(7798904), "x-wide for the motorized xy-stage"); 
     852    table.put(new Integer(7798905), "y-wide for the motorized xy-stage"); 
     853    table.put(new Integer(7798906), "z-wide for the z-stage-drive"); 
     854    table.put(new Integer(4259957), "user1 - unspecified"); 
     855    table.put(new Integer(4325493), "user2 - unspecified"); 
     856    table.put(new Integer(4391029), "user3 - unspecified"); 
     857    table.put(new Integer(6357095), "graylevel"); 
     858    table.put(new Integer(6422631), "graylevel1"); 
     859    table.put(new Integer(6488167), "graylevel2"); 
     860    table.put(new Integer(6553703), "graylevel3"); 
     861    table.put(new Integer(7864398), "logical x"); 
     862    table.put(new Integer(7929934), "logical y"); 
     863    table.put(new Integer(7995470), "logical z"); 
     864    table.put(new Integer(7602254), "logical t"); 
     865    table.put(new Integer(7077966), "logical lambda"); 
     866    table.put(new Integer(7471182), "logical rotation"); 
     867    table.put(new Integer(5767246), "logical x-wide"); 
     868    table.put(new Integer(5832782), "logical y-wide"); 
     869    table.put(new Integer(5898318), "logical z-wide"); 
     870    return table; 
     871  } 
     872 
    934873} 
  • trunk/loci/formats/in/MRCReader.java

    r4147 r4200  
    7474    FormatTools.checkPlaneNumber(this, no); 
    7575    FormatTools.checkBufferSize(this, buf.length, w, h); 
    76     in.seek(1024 + (no * core.sizeX[0] * core.sizeY[0] * bpp)); 
    77  
    78     in.skipBytes(y * core.sizeX[0] * bpp); 
    79     if (core.sizeX[series] == w) { 
    80       in.read(buf); 
    81     } 
    82     else { 
    83       for (int row=0; row<h; row++) { 
    84         in.skipBytes(x * bpp); 
    85         in.read(buf, row * w * bpp, w * bpp); 
    86         in.skipBytes(bpp * (core.sizeX[0] - w - x)); 
    87       } 
    88     } 
     76 
     77    in.seek(1024 + (no * getSizeX() *  getSizeY() * bpp)); 
     78    DataTools.readPlane(in, x, y, w, h, this, buf); 
    8979 
    9080    return buf; 
     
    154144    } 
    155145 
    156     bpp = FormatTools.getBytesPerPixel(core.pixelType[0]); 
     146    bpp = FormatTools.getBytesPerPixel(getPixelType()); 
    157147 
    158148    // pixel size = xlen / mx 
     
    203193    for (int i=0; i<angles.length; i++) { 
    204194      angles[i] = in.readFloat(); 
    205       addMeta("Angle " + (i+1), "" + angles[i]); 
     195      addMeta("Angle " + (i+1), String.valueOf(angles[i])); 
    206196    } 
    207197 
     
    209199 
    210200    int nUsefulLabels = in.readInt(); 
    211     addMeta("Number of useful labels", "" + nUsefulLabels); 
     201    addMeta("Number of useful labels", String.valueOf(nUsefulLabels)); 
    212202 
    213203    for (int i=0; i<10; i++) { 
     
    221211    core.sizeT[0] = 1; 
    222212    core.currentOrder[0] = "XYZTC"; 
    223     core.imageCount[0] = core.sizeZ[0]; 
     213    core.imageCount[0] = getSizeZ(); 
    224214    core.rgb[0] = false; 
    225215    core.interleaved[0] = true; 
     
    234224    MetadataTools.populatePixels(store, this); 
    235225 
    236     Float x = new Float(xlen / mx); 
    237     Float y = new Float(ylen / my); 
    238     Float z = new Float(zlen / mz); 
    239     if (x.floatValue() == Float.POSITIVE_INFINITY) x = new Float(1.0); 
    240     if (y.floatValue() == Float.POSITIVE_INFINITY) y = new Float(1.0); 
    241     if (z.floatValue() == Float.POSITIVE_INFINITY) z = new Float(1.0); 
    242  
    243     store.setDimensionsPhysicalSizeX(x, 0, 0); 
    244     store.setDimensionsPhysicalSizeY(y, 0, 0); 
    245     store.setDimensionsPhysicalSizeZ(z, 0, 0); 
     226    float x = (xlen / mx) == Float.POSITIVE_INFINITY ? 1f : (xlen / mx); 
     227    float y = (ylen / my) == Float.POSITIVE_INFINITY ? 1f : (ylen / my); 
     228    float z = (zlen / mz) == Float.POSITIVE_INFINITY ? 1f : (zlen / mz); 
     229 
     230    store.setDimensionsPhysicalSizeX(new Float(x), 0, 0); 
     231    store.setDimensionsPhysicalSizeY(new Float(y), 0, 0); 
     232    store.setDimensionsPhysicalSizeZ(new Float(z), 0, 0); 
    246233  } 
    247234 
  • trunk/loci/formats/in/MetamorphReader.java

    r4048 r4200  
    157157  protected void initFile(String id) throws FormatException, IOException { 
    158158    if (checkSuffix(id, ND_SUFFIX)) { 
    159       if (currentId != null) { 
    160         String[] s = getUsedFiles(); 
    161         for (int i=0; i<s.length; i++) { 
    162           if (id.equals(s[i])) return; 
    163         } 
    164       } 
    165  
    166       close(); 
    167       currentId = id; 
    168       metadata = new Hashtable(); 
    169  
    170       core = new CoreMetadata(1); 
    171       Arrays.fill(core.orderCertain, true); 
    172  
    173       // reinitialize the MetadataStore 
    174       getMetadataStore().createRoot(); 
     159      super.initFile(id); 
    175160 
    176161      // find an associated STK file 
     
    206191      ndFilename = ndfile.getAbsolutePath(); 
    207192 
    208       RandomAccessStream ndStream = 
    209         new RandomAccessStream(ndfile.getAbsolutePath()); 
     193      RandomAccessStream ndStream = new RandomAccessStream(ndFilename); 
    210194      String line = ndStream.readLine().trim(); 
    211195 
    212       int zc = core.sizeZ[0], cc = core.sizeC[0], tc = core.sizeT[0]; 
     196      int zc = getSizeZ(), cc = getSizeC(), tc = getSizeT(); 
    213197      String z = null, c = null, t = null; 
    214198      Vector hasZ = new Vector(); 
     
    246230      for (int i=0; i<cc; i++) { 
    247231        boolean hasZ1 = ((Boolean) hasZ.get(i)).booleanValue(); 
    248         boolean hasZ2 = 
    249           i == 0 ? false : ((Boolean) hasZ.get(i - 1)).booleanValue(); 
     232        boolean hasZ2 = i != 0 && ((Boolean) hasZ.get(i - 1)).booleanValue(); 
    250233        if (i > 0 && hasZ1 != hasZ2) seriesCount = 2; 
    251234      } 
     
    282265      for (int i=0; i<tc; i++) { 
    283266        for (int j=0; j<cc; j++) { 
    284           int seriesNdx = seriesCount == 1 ? 0 : 
    285             (((Boolean) hasZ.get(j)).booleanValue() ? 0 : 1); 
     267          boolean validZ = ((Boolean) hasZ.get(j)).booleanValue(); 
     268          int seriesNdx = (seriesCount == 1 || validZ) ? 0 : 1; 
    286269          stks[seriesNdx][pt[seriesNdx]] = prefix; 
    287270          if (waveNames.get(j) != null) { 
     
    341324        CoreMetadata newCore = new CoreMetadata(stks.length); 
    342325        for (int i=0; i<stks.length; i++) { 
    343           newCore.sizeX[i] = core.sizeX[0]; 
    344           newCore.sizeY[i] = core.sizeY[0]; 
    345           newCore.sizeZ[i] = core.sizeZ[0]; 
    346           newCore.sizeC[i] = core.sizeC[0]; 
    347           newCore.sizeT[i] = core.sizeT[0]; 
    348           newCore.pixelType[i] = core.pixelType[0]; 
    349           newCore.imageCount[i] = core.imageCount[0]; 
    350           newCore.currentOrder[i] = core.currentOrder[0]; 
    351           newCore.rgb[i] = core.rgb[0]; 
    352           newCore.littleEndian[i] = core.littleEndian[0]; 
    353           newCore.interleaved[i] = core.interleaved[0]; 
     326          newCore.sizeX[i] = getSizeX(); 
     327          newCore.sizeY[i] = getSizeY(); 
     328          newCore.sizeZ[i] = getSizeZ(); 
     329          newCore.sizeC[i] = getSizeC(); 
     330          newCore.sizeT[i] = getSizeT(); 
     331          newCore.pixelType[i] = getPixelType(); 
     332          newCore.imageCount[i] = getImageCount(); 
     333          newCore.currentOrder[i] = getDimensionOrder(); 
     334          newCore.rgb[i] = isRGB(); 
     335          newCore.littleEndian[i] = isLittleEndian(); 
     336          newCore.interleaved[i] = isInterleaved(); 
    354337          newCore.orderCertain[i] = true; 
    355338        } 
     
    397380      } 
    398381 
    399       Hashtable[] tempIFDs = new Hashtable[core.imageCount[0]]; 
     382      Hashtable[] tempIFDs = new Hashtable[getImageCount()]; 
    400383 
    401384      long[] oldOffsets = TiffTools.getIFDLongArray(ifds[0], 
     
    421404 
    422405      Hashtable temp; 
    423       for(int i=0; i<core.imageCount[0]; i++) { 
     406      for(int i=0; i<getImageCount(); i++) { 
    424407        // copy data from the first IFD 
    425408        temp = new Hashtable(ifds[0]); 
     
    507490    } 
    508491    try { 
    509       if (core.sizeZ[0] == 0) { 
     492      if (getSizeZ() == 0) { 
    510493        core.sizeZ[0] = 
    511494          TiffTools.getIFDLongArray(ifds[0], UIC2TAG, true).length; 
    512495      } 
    513       if (core.sizeT[0] == 0) core.sizeT[0] = getImageCount() / core.sizeZ[0]; 
     496      if (getSizeT() == 0) core.sizeT[0] = getImageCount() / getSizeZ(); 
    514497    } 
    515498    catch (FormatException exc) { 
     
    531514   */ 
    532515  void parseUIC2Tags(long uic2offset) throws IOException { 
    533  
    534516    long saveLoc = in.getFilePointer(); 
    535517    in.seek(uic2offset); 
     
    574556    long saveLoc = in.getFilePointer(); 
    575557    in.seek(uic4offset); 
    576     boolean end=false; 
     558    boolean end = false; 
    577559    short id; 
    578560    while (!end) { 
     
    581563      switch (id) { 
    582564        case 0: 
    583           end=true; 
     565          end = true; 
    584566          break; 
    585567        case 28: 
     
    601583          //unknown tags: do nothing 
    602584          break; 
    603         //28->stagePositions 
    604         //29->cameraChipOffsets 
    605         //30->stageLabel 
    606         //40->AbsoluteZ 
    607         //41AbsoluteZValid 
    608         //0->end 
    609585      } 
    610586    } 
     
    698674    String thedate, thetime; 
    699675    long lastOffset; 
    700     byte[] toread; 
    701676    for (int i=0; i<uic1count; i++) { 
    702677      currentID = in.readInt(); 
    703678      valOrOffset = in.readInt(); 
     679      lastOffset = in.getFilePointer(); 
    704680 
    705681      switch (currentID) { 
     
    716692          break; 
    717693        case 4: 
    718           lastOffset = in.getFilePointer(); 
     694          put("XCalibration", readRational(in, valOrOffset)); 
     695          in.seek(lastOffset); 
     696          break; 
     697        case 5: 
     698          put("YCalibration", readRational(in, valOrOffset)); 
     699          in.seek(lastOffset); 
     700          break; 
     701        case 6: 
    719702          in.seek(valOrOffset); 
    720703          num = in.readInt(); 
    721           denom = in.readInt(); 
    722           put("XCalibration", new TiffRational(num, denom)); 
    723           in.seek(lastOffset); 
    724           break; 
    725         case 5: 
    726           lastOffset = in.getFilePointer(); 
     704          put("CalibrationUnits", in.readString(num)); 
     705          in.seek(lastOffset); 
     706          break; 
     707        case 7: 
    727708          in.seek(valOrOffset); 
    728709          num = in.readInt(); 
    729           denom = in.readInt(); 
    730           put("YCalibration", new TiffRational(num, denom)); 
    731           in.seek(lastOffset); 
    732           break; 
    733         case 6: 
    734           lastOffset = in.getFilePointer(); 
    735           in.seek(valOrOffset); 
    736           num = in.readInt(); 
    737           toread = new byte[num]; 
    738           in.read(toread); 
    739           put("CalibrationUnits", new String(toread)); 
    740           in.seek(lastOffset); 
    741           break; 
    742         case 7: 
    743           lastOffset = in.getFilePointer(); 
    744           in.seek(valOrOffset); 
    745           num = in.readInt(); 
    746           toread = new byte[num]; 
    747           in.read(toread); 
    748           String name = new String(toread); 
    749           put("Name", name); 
    750           imageName = name; 
     710          imageName = in.readString(num); 
     711          put("Name", imageName); 
    751712          in.seek(lastOffset); 
    752713          break; 
     
    776737          break; 
    777738        case 15: 
    778           int zoom = valOrOffset; 
    779           put("Zoom", zoom); 
     739          put("Zoom", valOrOffset); 
    780740          break; 
    781741        case 16: // oh how we hate you Julian format... 
    782           lastOffset = in.getFilePointer(); 
    783742          in.seek(valOrOffset); 
    784743          thedate = decodeDate(in.readInt()); 
    785744          thetime = decodeTime(in.readInt()); 
    786           put("DateTime", thedate + " " + thetime); 
    787745          imageCreationDate = thedate + " " + thetime; 
     746          put("DateTime", imageCreationDate); 
    788747          in.seek(lastOffset); 
    789748          break; 
    790749        case 17: 
    791           lastOffset = in.getFilePointer(); 
    792750          in.seek(valOrOffset); 
    793751          thedate = decodeDate(in.readInt()); 
     
    806764          break; 
    807765        case 21: 
    808           lastOffset = in.getFilePointer(); 
     766          put("grayX", readRational(in, valOrOffset)); 
     767          in.seek(lastOffset); 
     768          break; 
     769        case 22: 
     770          put("gray", readRational(in, valOrOffset)); 
     771          in.seek(lastOffset); 
     772          break; 
     773        case 23: 
     774          put("grayMin", readRational(in, valOrOffset)); 
     775          in.seek(lastOffset); 
     776          break; 
     777        case 24: 
     778          put("grayMax", readRational(in, valOrOffset)); 
     779          in.seek(lastOffset); 
     780          break; 
     781        case 25: 
    809782          in.seek(valOrOffset); 
    810783          num = in.readInt(); 
    811           denom = in.readInt(); 
    812           put("grayX", new TiffRational(num, denom)); 
    813           in.seek(lastOffset); 
    814           break; 
    815         case 22: 
    816           lastOffset = in.getFilePointer(); 
    817           in.seek(valOrOffset); 
    818           num = in.readInt(); 
    819           denom = in.readInt(); 
    820           put("gray", new TiffRational(num, denom)); 
    821           in.seek(lastOffset); 
    822           break; 
    823         case 23: 
    824           lastOffset = in.getFilePointer(); 
    825           in.seek(valOrOffset); 
    826           num = in.readInt(); 
    827           denom = in.readInt(); 
    828           put("grayMin", new TiffRational(num, denom)); 
    829           in.seek(lastOffset); 
    830           break; 
    831         case 24: 
    832           lastOffset = in.getFilePointer(); 
    833           in.seek(valOrOffset); 
    834           num = in.readInt(); 
    835           denom = in.readInt(); 
    836           put("grayMax", new TiffRational(num, denom)); 
    837           in.seek(lastOffset); 
    838           break; 
    839         case 25: 
    840           lastOffset = in.getFilePointer(); 
    841           in.seek(valOrOffset); 
    842           num = in.readInt(); 
    843           toread = new byte[num]; 
    844           in.read(toread); 
    845           put("grayUnitName", new String(toread)); 
     784          put("grayUnitName", in.readString(num)); 
    846785          in.seek(lastOffset); 
    847786          break; 
    848787        case 26: 
    849           lastOffset = in.getFilePointer(); 
    850788          in.seek(valOrOffset); 
    851789          int standardLUT = in.readInt(); 
     
    901839          break; 
    902840        case 38: 
    903           lastOffset = in.getFilePointer(); 
    904           in.seek(valOrOffset); 
    905           num = in.readInt(); 
    906           denom = in.readInt(); 
    907           put("AutoScaleLoInfo", new TiffRational(num, denom)); 
     841          put("AutoScaleLoInfo", readRational(in, valOrOffset)); 
    908842          in.seek(lastOffset); 
    909843          break; 
    910844        case 39: 
    911           lastOffset = in.getFilePointer(); 
    912           in.seek(valOrOffset); 
    913           num = in.readInt(); 
    914           denom = in.readInt(); 
    915           put("AutoScaleHiInfo", new TiffRational(num, denom)); 
     845          put("AutoScaleHiInfo", readRational(in, valOrOffset)); 
    916846          in.seek(lastOffset); 
    917847          break; 
     
    929859          break; 
    930860        case 46: 
    931           lastOffset = in.getFilePointer(); 
    932861          in.seek(valOrOffset); 
    933           int xBin, yBin; 
    934           xBin = in.readInt(); 
    935           yBin = in.readInt(); 
     862          int xBin = in.readInt(); 
     863          int yBin = in.readInt(); 
    936864          put("CameraBin", new String("(" + xBin + "," + yBin + ")")); 
    937865          in.seek(lastOffset); 
    938           break; 
    939         default: 
    940866          break; 
    941867      } 
     
    974900  /** Converts a time value in milliseconds into a human-readable string. */ 
    975901  public static String decodeTime(int millis) { 
    976     int ms, seconds, minutes, hours; 
    977  
    978     ms = millis % 1000; 
     902    int ms = millis % 1000; 
    979903    millis -= ms; 
    980904    millis /= 1000; 
    981     seconds = millis % 60; 
     905    int seconds = millis % 60; 
    982906    millis -= seconds; 
    983907    millis /= 60; 
    984     minutes = millis % 60; 
     908    int minutes = millis % 60; 
    985909    millis -= minutes; 
    986910    millis /= 60; 
    987     hours = millis; 
     911    int hours = millis; 
    988912    return intFormat(hours, 2) + ":" + intFormat(minutes, 2) + ":" + 
    989913      intFormat(seconds, 2) + "." + intFormat(ms, 3); 
     
    1011935  } 
    1012936 
     937  private TiffRational readRational(RandomAccessStream s, long offset) 
     938    throws IOException 
     939  { 
     940    s.seek(offset); 
     941    int num = s.readInt(); 
     942    int denom = s.readInt(); 
     943    return new TiffRational(num, denom); 
     944  } 
     945 
    1013946} 
  • trunk/loci/formats/in/MetamorphTiffReader.java

    r4092 r4200  
    149149    } 
    150150 
    151     core.sizeT[0] = ifds.length / (core.sizeZ[0] * core.sizeC[0]); 
     151    core.sizeT[0] = ifds.length / (getSizeZ() * getSizeC()); 
    152152 
    153153    MetadataStore store = 
  • trunk/loci/formats/in/MicromanagerReader.java

    r4196 r4200  
    4747 
    4848  /** Helper reader for TIFF files. */ 
    49   private TiffReader tiffReader; 
     49  private MinimalTiffReader tiffReader; 
    5050 
    5151  /** List of TIFF files to open. */ 
     
    128128  public void initFile(String id) throws FormatException, IOException { 
    129129    super.initFile(id); 
    130     tiffReader = new TiffReader(); 
     130    tiffReader = new MinimalTiffReader(); 
    131131 
    132132    status("Reading metadata file"); 
     
    134134    // find metadata.txt 
    135135 
    136     File file = new File(currentId).getAbsoluteFile(); 
    137     metadataFile =  file.exists() ? new File(file.getParentFile(), 
     136    Location file = new Location(currentId).getAbsoluteFile(); 
     137    metadataFile = file.exists() ? new Location(file.getParentFile(), 
    138138      METADATA).getAbsolutePath() : METADATA; 
    139139    in = new RandomAccessStream(metadataFile); 
     
    195195        int quote = token.indexOf("\"") + 1; 
    196196        String key = token.substring(quote, token.indexOf("\"", quote)); 
     197        String value = null; 
    197198 
    198199        if (!open && !closed) { 
    199           String value = token.substring(token.indexOf(":") + 1).trim(); 
    200           value = value.substring(0, value.length() - 1); 
    201           addMeta(key, value); 
    202           if (key.equals("Channels")) core.sizeC[0] = Integer.parseInt(value); 
     200          value = token.substring(token.indexOf(":") + 1); 
    203201        } 
    204202        else if (!closed){ 
     
    209207            valueBuffer.append(token); 
    210208          } 
    211           String value = valueBuffer.toString(); 
    212           value.replaceAll("\n", "").trim(); 
    213           value = value.substring(0, value.length() - 1); 
    214           addMeta(key, value); 
    215           if (key.equals("Channels")) core.sizeC[0] = Integer.parseInt(value); 
     209          value = valueBuffer.toString(); 
     210          value = value.replaceAll("\n", ""); 
    216211        } 
    217212        else { 
    218           String value = 
    219             token.substring(token.indexOf("[") + 1, token.indexOf("]")).trim(); 
    220           value = value.substring(0, value.length() - 1); 
    221           addMeta(key, value); 
    222           if (key.equals("Channels")) core.sizeC[0] = Integer.parseInt(value); 
    223         } 
     213          value = token.substring(token.indexOf("[") + 1, token.indexOf("]")); 
     214        } 
     215        value = value.trim().substring(0, value.length() - 1); 
     216        addMeta(key, value); 
     217        if (key.equals("Channels")) core.sizeC[0] = Integer.parseInt(value); 
    224218      } 
    225219 
     
    238232        String key = "", value = ""; 
    239233        while (!token.startsWith("}")) { 
    240           key = token.substring(1, token.indexOf(":")).trim(); 
    241           value = 
    242             token.substring(token.indexOf(":") + 1, token.length() - 1).trim(); 
     234          int colon = token.indexOf(":"); 
     235          key = token.substring(1, colon).trim(); 
     236          value = token.substring(colon + 1, token.length() - 1).trim(); 
    243237 
    244238          addMeta(key, value); 
    245  
    246239          token = st.nextToken().trim(); 
    247240        } 
     
    261254      core.sizeT[0] = Integer.parseInt(t); 
    262255    } 
    263     else core.sizeT[0] = tiffs.size() / core.sizeC[0]; 
     256    else core.sizeT[0] = tiffs.size() / getSizeC(); 
    264257 
    265258    core.sizeX[0] = tiffReader.getSizeX(); 
  • trunk/loci/formats/in/NAFReader.java

    r4147 r4200  
    7272    FormatTools.checkBufferSize(this, buf.length, w, h); 
    7373 
    74     int bpp = FormatTools.getBytesPerPixel(core.pixelType[series]); 
    75     int plane = core.sizeX[series] * core.sizeY[series] * bpp; 
    76     in.seek(offsets[series] + no * plane); 
    77     in.skipBytes(core.sizeX[series] * bpp * y); 
    78  
    7974    if (in.getFilePointer() + buf.length > in.length()) { 
    8075      throw new FormatException("Sorry, compressed data is not supported."); 
    8176    } 
    8277 
    83     if (core.sizeX[series] == w) { 
    84       in.read(buf); 
    85     } 
    86     else { 
    87       for (int row=0; row<h; row++) { 
    88         in.skipBytes(x * bpp); 
    89         in.read(buf, row * w * bpp, w * bpp); 
    90         in.skipBytes((core.sizeX[series] - w) * bpp); 
    91       } 
    92     } 
    93  
     78    int bpp = FormatTools.getBytesPerPixel(getPixelType()); 
     79    int plane = getSizeX() * getSizeY() * bpp; 
     80    in.seek(offsets[series] + no * plane); 
     81 
     82    DataTools.readPlane(in, x, y, w, h, this, buf); 
    9483    return buf; 
    95   } 
    96  
    97   // -- IFormatHandler API Methods -- 
    98  
    99   /* @see loci.formats.IFormatHandler#close() */ 
    100   public void close() throws IOException { 
    101     super.close(); 
    10284  } 
    10385 
  • trunk/loci/formats/in/PerkinElmerReader.java

    r4159 r4200  
    5757 
    5858  /** Helper reader. */ 
    59   protected TiffReader[] tiff; 
     59  protected MinimalTiffReader tiff; 
    6060 
    6161  /** Tiff files to open. */ 
     
    6969 
    7070  private String details, sliceSpace; 
     71 
     72  private float pixelSizeX = 1f, pixelSizeY = 1f; 
     73  private String finishTime = null, startTime = null; 
     74  private float originX = 0f, originY = 0f, originZ = 0f; 
    7175 
    7276  // -- Constructor -- 
     
    135139    FormatTools.checkPlaneNumber(this, no); 
    136140    if (isTiff) { 
    137       tiff[no / core.sizeC[0]].setId(files[no / core.sizeC[0]]); 
    138       return tiff[no / core.sizeC[0]].openBytes(0, buf, x, y, w, h); 
     141      tiff.setId(files[no / core.sizeC[0]]); 
     142      return tiff.openBytes(0, buf, x, y, w, h); 
    139143    } 
    140144 
     
    166170  public void close(boolean fileOnly) throws IOException { 
    167171    if (fileOnly) { 
    168       if (tiff != null) { 
    169         for (int i=0; i<tiff.length; i++) { 
    170           if (tiff[i] != null) tiff[i].close(fileOnly); 
    171         } 
    172       } 
     172      if (tiff != null) tiff.close(); 
    173173    } 
    174174    else close(); 
     
    180180  public void close() throws IOException { 
    181181    currentId = null; 
    182     if (tiff != null) { 
    183       for (int i=0; i<tiff.length; i++) { 
    184         if (tiff[i] != null) tiff[i].close(); 
    185       } 
    186     } 
     182    if (tiff != null) tiff.close(); 
    187183    tiff = null; 
    188184    allFiles = null; 
     
    230226      workingDirPath = ""; 
    231227    } 
    232  
    233     float pixelSizeX = 1f, pixelSizeY = 1f; 
    234     String finishTime = null, startTime = null; 
    235     float originX = 0f, originY = 0f, originZ = 0f; 
    236228 
    237229    status("Searching for all metadata companion files"); 
     
    399391    StringTokenizer t; 
    400392 
    401     tiff = new TiffReader[core.imageCount[0]]; 
    402     for (int i=0; i<tiff.length; i++) { 
    403       tiff[i] = new TiffReader(); 
    404       if (i > 0) tiff[i].setMetadataCollected(false); 
    405     } 
     393    tiff = new MinimalTiffReader(); 
    406394 
    407395    // we always parse the .tim and .htm files if they exist, along with 
     
    454442          catch (NumberFormatException e) { tNum++; } 
    455443        } 
    456         addMeta(hashKeys[tNum], token); 
    457         if (hashKeys[tNum].equals("Image Width")) { 
    458           try { 
    459             core.sizeX[0] = Integer.parseInt(token); 
    460           } 
    461           catch (NumberFormatException e) { 
    462             if (debug) LogTools.trace(e); 
    463           } 
    464         } 
    465         else if (hashKeys[tNum].equals("Image Length")) { 
    466           try { 
    467             core.sizeY[0] = Integer.parseInt(token); 
    468           } 
    469           catch (NumberFormatException e) { 
    470             if (debug) LogTools.trace(e); 
    471           } 
    472         } 
    473         else if (hashKeys[tNum].equals("Number of slices")) { 
    474           try { 
    475             core.sizeZ[0] = Integer.parseInt(token); 
    476           } 
    477           catch (NumberFormatException e) { 
    478             if (debug) LogTools.trace(e); 
    479           } 
    480         } 
    481         else if (hashKeys[tNum].equals("Experiment details:")) details = token; 
    482         else if (hashKeys[tNum].equals("Z slice space")) sliceSpace = token; 
    483         else if (hashKeys[tNum].equals("Pixel Size X")) { 
    484           pixelSizeX = Float.parseFloat(token); 
    485         } 
    486         else if (hashKeys[tNum].equals("Pixel Size Y")) { 
    487           pixelSizeY = Float.parseFloat(token); 
    488         } 
    489         else if (hashKeys[tNum].equals("Finish Time:")) finishTime = token; 
    490         else if (hashKeys[tNum].equals("Start Time:")) startTime = token; 
    491         else if (hashKeys[tNum].equals("Origin X")) { 
    492           try { 
    493             originX = Float.parseFloat(token); 
    494           } 
    495           catch (NumberFormatException e) { } 
    496         } 
    497         else if (hashKeys[tNum].equals("Origin Y")) { 
    498           try { 
    499             originY = Float.parseFloat(token); 
    500           } 
    501           catch (NumberFormatException e) { } 
    502         } 
    503         else if (hashKeys[tNum].equals("Origin Z")) { 
    504           try { 
    505             originZ = Float.parseFloat(token); 
    506           } 
    507           catch (NumberFormatException e) { } 
    508         } 
    509         tNum++; 
     444        parseKeyValue(hashKeys[tNum++], token); 
    510445      } 
    511446      read.close(); 
     
    523458      int pt = 0; 
    524459      while (t.hasMoreTokens()) { 
     460        String key = null, value = null; 
    525461        if (tNum < 7) { t.nextToken(); } 
    526462        else if ((tNum > 7 && tNum < 12) || 
     
    530466        } 
    531467        else if (pt < hashKeys.length) { 
    532           String token = t.nextToken(); 
    533           addMeta(hashKeys[pt], token); 
    534           if (hashKeys[pt].equals("Image Width")) { 
    535             core.sizeX[0] = Integer.parseInt(token); 
    536           } 
    537           else if (hashKeys[pt].equals("Image Length")) { 
    538             core.sizeY[0] = Integer.parseInt(token); 
    539           } 
    540           else if (hashKeys[pt].equals("Number of slices")) { 
    541             core.sizeZ[0] = Integer.parseInt(token); 
    542           } 
    543           else if (hashKeys[pt].equals("Experiment details:")) details = token; 
    544           else if (hashKeys[pt].equals("Z slice space")) sliceSpace = token; 
    545           else if (hashKeys[pt].equals("Pixel Size X")) { 
    546             pixelSizeX = Float.parseFloat(token); 
    547           } 
    548           else if (hashKeys[pt].equals("Pixel Size Y")) { 
    549             pixelSizeY = Float.parseFloat(token); 
    550           } 
    551           else if (hashKeys[pt].equals("Finish Time:")) finishTime = token; 
    552           else if (hashKeys[pt].equals("Start Time:")) startTime = token; 
    553           else if (hashKeys[pt].equals("Origin X")) { 
    554             originX = Float.parseFloat(token); 
    555           } 
    556           else if (hashKeys[pt].equals("Origin Y")) { 
    557             originY = Float.parseFloat(token); 
    558           } 
    559           else if (hashKeys[pt].equals("Origin Z")) { 
    560             originZ = Float.parseFloat(token); 
    561           } 
     468          key = hashKeys[pt]; 
     469          value = t.nextToken(); 
    562470          pt++; 
    563471        } 
    564472        else { 
    565           String key = t.nextToken() + t.nextToken(); 
    566           String value = t.nextToken(); 
    567           addMeta(key, value); 
    568           if (key.equals("Image Width")) { 
    569             core.sizeX[0] = Integer.parseInt(value); 
    570           } 
    571           else if (key.equals("Image Length")) { 
    572             core.sizeY[0] = Integer.parseInt(value); 
    573           } 
    574           else if (key.equals("Number of slices")) { 
    575             core.sizeZ[0] = Integer.parseInt(value); 
    576           } 
    577           else if (key.equals("Experiment details:")) details = value; 
    578           else if (key.equals("Z slice space")) sliceSpace = value; 
    579           else if (key.equals("Pixel Size X")) { 
    580             pixelSizeX = Float.parseFloat(value); 
    581           } 
    582           else if (key.equals("Pixel Size Y")) { 
    583             pixelSizeY = Float.parseFloat(value); 
    584           } 
    585           else if (key.equals("Finish Time:")) finishTime = value; 
    586           else if (key.equals("Start Time:")) startTime = value; 
    587           else if (key.equals("Origin X")) originX = Float.parseFloat(value); 
    588           else if (key.equals("Origin Y")) originY = Float.parseFloat(value); 
    589           else if (key.equals("Origin Z")) originZ = Float.parseFloat(value); 
    590         } 
     473          key = t.nextToken() + t.nextToken(); 
     474          value = t.nextToken(); 
     475        } 
     476 
     477        parseKeyValue(key, value); 
     478 
    591479        tNum++; 
    592480      } 
     
    688576          tokens[j] = tokens[j].trim(); 
    689577          tokens[j + 1] = tokens[j + 1].trim(); 
    690           addMeta(tokens[j], tokens[j + 1]); 
    691           if (tokens[j].equals("Image Width")) { 
    692             core.sizeX[0] = Integer.parseInt(tokens[j + 1]); 
    693           } 
    694           else if (tokens[j].equals("Image Length")) { 
    695             core.sizeY[0] = Integer.parseInt(tokens[j + 1]); 
    696           } 
    697           else if (tokens[j].equals("Number of slices")) { 
    698             core.sizeZ[0] = Integer.parseInt(tokens[j + 1]); 
    699           } 
    700           else if (tokens[j].equals("Experiment details:")) { 
    701             details = tokens[j + 1]; 
    702           } 
    703           else if (tokens[j].equals("Z slice space")) { 
    704             sliceSpace = tokens[j + 1]; 
    705           } 
    706           else if (tokens[j].equals("Pixel Size X")) { 
    707             pixelSizeX = Float.parseFloat(tokens[j + 1]); 
    708           } 
    709           else if (tokens[j].equals("Pixel Size Y")) { 
    710             pixelSizeY = Float.parseFloat(tokens[j + 1]); 
    711           } 
    712           else if (tokens[j].equals("Finish Time:")) finishTime = tokens[j + 1]; 
    713           else if (tokens[j].equals("Start Time:")) startTime = tokens[j + 1]; 
    714           else if (tokens[j].equals("Origin X")) { 
    715             originX = Float.parseFloat(tokens[j + 1]); 
    716           } 
    717           else if (tokens[j].equals("Origin Y")) { 
    718             originY = Float.parseFloat(tokens[j + 1]); 
    719           } 
    720           else if (tokens[j].equals("Origin Z")) { 
    721             originZ = Float.parseFloat(tokens[j + 1]); 
    722           } 
     578          parseKeyValue(tokens[j], tokens[j + 1]); 
    723579        } 
    724580      } 
     
    754610 
    755611    if (isTiff) { 
    756       tiff[0].setId(files[0]); 
    757       core.pixelType[0] = tiff[0].getPixelType(); 
     612      tiff.setId(files[0]); 
     613      core.pixelType[0] = tiff.getPixelType(); 
    758614    } 
    759615    else { 
     
    814670      for (int i=0; i<keys.length; i++) { 
    815671        int oldCount = ((Integer) zSections.get(keys[i])).intValue(); 
    816         int nPlanes = (isTiff ? tiff[0].getEffectiveSizeC() : core.sizeC[0]) * 
     672        int nPlanes = (isTiff ? tiff.getEffectiveSizeC() : core.sizeC[0]) * 
    817673          core.sizeT[0]; 
    818674        int count = (int) Math.min(oldCount, nPlanes); 
     
    827683    core.currentOrder[0] = "XYCTZ"; 
    828684 
    829     core.rgb[0] = isTiff ? tiff[0].isRGB() : false; 
     685    core.rgb[0] = isTiff ? tiff.isRGB() : false; 
    830686    core.interleaved[0] = false; 
    831     core.littleEndian[0] = isTiff ? tiff[0].isLittleEndian() : true; 
     687    core.littleEndian[0] = isTiff ? tiff.isLittleEndian() : true; 
    832688    core.metadataComplete[0] = true; 
    833     core.indexed[0] = isTiff ? tiff[0].isIndexed() : false; 
     689    core.indexed[0] = isTiff ? tiff.isIndexed() : false; 
    834690    core.falseColor[0] = false; 
    835691 
     
    915771  } 
    916772 
     773  // -- Helper methods -- 
     774 
     775  private void parseKeyValue(String key, String value) { 
     776    addMeta(key, value); 
     777    if (key.equals("Image Width")) { 
     778      try { 
     779        core.sizeX[0] = Integer.parseInt(value); 
     780      } 
     781      catch (NumberFormatException e) { 
     782        if (debug) LogTools.trace(e); 
     783      } 
     784    } 
     785    else if (key.equals("Image Length")) { 
     786      try { 
     787        core.sizeY[0] = Integer.parseInt(value); 
     788      } 
     789      catch (NumberFormatException e) { 
     790        if (debug) LogTools.trace(e); 
     791      } 
     792    } 
     793    else if (key.equals("Number of slices")) { 
     794      try { 
     795        core.sizeZ[0] = Integer.parseInt(value); 
     796      } 
     797      catch (NumberFormatException e) { 
     798        if (debug) LogTools.trace(e); 
     799      } 
     800    } 
     801    else if (key.equals("Experiment details:")) details = value; 
     802    else if (key.equals("Z slice space")) sliceSpace = value; 
     803    else if (key.equals("Pixel Size X")) { 
     804      try { 
     805        pixelSizeX = Float.parseFloat(value); 
     806      } 
     807      catch (NumberFormatException e) { 
     808        if (debug) LogTools.trace(e); 
     809      } 
     810    } 
     811    else if (key.equals("Pixel Size Y")) { 
     812      try { 
     813        pixelSizeY = Float.parseFloat(value); 
     814      } 
     815      catch (NumberFormatException e) { 
     816        if (debug) LogTools.trace(e); 
     817      } 
     818    } 
     819    else if (key.equals("Finish Time:")) finishTime = value; 
     820    else if (key.equals("Start Time:")) startTime = value; 
     821    else if (key.equals("Origin X")) { 
     822      try { 
     823        originX = Float.parseFloat(value); 
     824      } 
     825      catch (NumberFormatException e) { 
     826        if (debug) LogTools.trace(e); 
     827      } 
     828    } 
     829    else if (key.equals("Origin Y")) { 
     830      try { 
     831        originY = Float.parseFloat(value); 
     832      } 
     833      catch (NumberFormatException e) { 
     834        if (debug) LogTools.trace(e); 
     835      } 
     836    } 
     837    else if (key.equals("Origin Z")) { 
     838      try { 
     839        originZ = Float.parseFloat(value); 
     840      } 
     841      catch (NumberFormatException e) { 
     842        if (debug) LogTools.trace(e); 
     843      } 
     844    } 
     845  } 
     846 
    917847  // -- Helper class -- 
    918848 
  • trunk/loci/formats/in/PrairieReader.java

    r4147 r4200  
    6969 
    7070  /** Helper reader for opening images */ 
    71   private TiffReader tiff; 
     71  private MinimalTiffReader tiff; 
    7272 
    7373  /** Names of the associated XML files */ 
     
    205205      if (checkSuffix(id, XML_SUFFIX)) { 
    206206        super.initFile(id); 
    207         tiff = new TiffReader(); 
     207        tiff = new MinimalTiffReader(); 
    208208        xmlFile = id; 
    209209        readXML = true; 
  • trunk/loci/formats/in/TillVisionReader.java

    r4180 r4200  
    2525 
    2626import java.io.*; 
    27 import java.util.StringTokenizer; 
     27import java.util.*; 
    2828import loci.formats.*; 
    2929import loci.formats.meta.FilterMetadata; 
     
    4747  /** Constructs a new TillVision reader. */ 
    4848  public TillVisionReader() { 
    49     super("TillVision", new String[] {"inf", "pst"}); 
     49    super("TillVision", "vws"); 
    5050  } 
    5151 
     
    100100    if (debug) debug("AliconaReader.initFile(" + id + ")"); 
    101101    super.initFile(id); 
    102     in = new RandomAccessStream(id); 
    103102 
    104     if (id.toLowerCase().endsWith(".inf")) { 
    105       // find the .pst file 
    106       String base = new Location(id).getAbsolutePath(); 
    107       base = base.substring(0, base.lastIndexOf(".") + 1); 
    108       pixelsFile = new RandomAccessStream(base + "pst"); 
    109       pixelsFile.order(true); 
     103    POITools poi = new POITools(id); 
     104    Vector documents = poi.getDocumentList(); 
     105 
     106    for (int i=0; i<documents.size(); i++) { 
     107      String name = (String) documents.get(i); 
     108      System.out.println(name + " (" + poi.getFileSize(name) + ")"); 
     109      byte[] data = poi.getDocumentBytes(name); 
     110      name = name.replaceAll("/", "-"); 
     111      RandomAccessFile out = new RandomAccessFile(name, "rw"); 
     112      out.write(data); 
     113      out.close(); 
    110114    } 
    111     else if (id.toLowerCase().endsWith(".pst")) { 
    112       pixelsFile = new RandomAccessStream(id); 
    113       pixelsFile.order(true); 
    114115 
    115       // find the .inf file 
    116       String base = new Location(id).getAbsolutePath(); 
    117       base = base.substring(0, base.lastIndexOf(".") + 1); 
    118       setId(base + "inf"); 
    119       return; 
    120     } 
     116    if (true) return; 
    121117 
    122118    // read key/value pairs from .inf file 
Note: See TracChangeset for help on using the changeset viewer.