Changeset 4202


Ignore:
Timestamp:
07/15/08 15:47:41 (12 years ago)
Author:
melissa
Message:

More cleanup.

Location:
trunk/loci/formats/in
Files:
1 added
23 edited

Legend:

Unmodified
Added
Removed
  • trunk/loci/formats/in/LIFReader.java

    r4200 r4202  
    6262  private int[] extraDimensions; 
    6363 
    64   private Vector xcal; 
    65   private Vector ycal; 
    66   private Vector zcal; 
    67   private Vector seriesNames; 
    68   private Vector containerNames; 
    69   private Vector containerCounts; 
    70   private Vector widths; 
    71   private Vector heights; 
    72   private Vector zs; 
    73   private Vector ts; 
    74   private Vector channels; 
    75   private Vector bps; 
    76   private Vector extraDims; 
    77  
    7864  private int numDatasets; 
    7965 
     
    114100  public void close() throws IOException { 
    115101    super.close(); 
    116     bitsPerPixel = extraDimensions = null; 
    117     offsets = xcal = ycal = zcal = null; 
    118     containerNames = containerCounts = null; 
    119102  } 
    120103 
     
    130113    core.littleEndian[0] = true; 
    131114    in.order(isLittleEndian()); 
    132  
    133     xcal = new Vector(); 
    134     ycal = new Vector(); 
    135     zcal = new Vector(); 
    136115 
    137116    // read the header 
     
    202181  /** Parses a string of XML and puts the values in a Hashtable. */ 
    203182  private void initMetadata(String xml) throws FormatException, IOException { 
    204     containerNames = new Vector(); 
    205     containerCounts = new Vector(); 
    206     seriesNames = new Vector(); 
    207  
    208     numDatasets = 0; 
    209     widths = new Vector(); 
    210     heights = new Vector(); 
    211     zs = new Vector(); 
    212     ts = new Vector(); 
    213     channels = new Vector(); 
    214     bps = new Vector(); 
    215     extraDims = new Vector(); 
    216  
    217     LIFHandler handler = new LIFHandler(); 
     183    LeicaHandler handler = new LeicaHandler(); 
    218184 
    219185    // the XML blocks stored in a LIF file are invalid, 
     
    235201      throw new FormatException(exc); 
    236202    } 
     203 
     204    Vector widths = handler.getWidths(); 
     205    Vector heights = handler.getHeights(); 
     206    Vector zs = handler.getZs(); 
     207    Vector ts = handler.getTs(); 
     208    Vector channels = handler.getChannels(); 
     209    Vector bps = handler.getBPS(); 
     210    Vector extraDims = handler.getExtraDims(); 
     211    metadata = handler.getMetadata(); 
     212    Vector containerNames = handler.getContainerNames(); 
     213    Vector containerCounts = handler.getContainerCounts(); 
     214    Vector seriesNames = handler.getSeriesNames(); 
     215    Vector xcal = handler.getXCal(); 
     216    Vector ycal = handler.getYCal(); 
     217    Vector zcal = handler.getZCal(); 
    237218 
    238219    numDatasets = widths.size(); 
     
    325306  } 
    326307 
    327   // -- Helper class -- 
    328  
    329   /** SAX handler for parsing XML. */ 
    330   class LIFHandler extends DefaultHandler { 
    331     private String series; 
    332     private String fullSeries; 
    333     private int count = 0; 
    334     private boolean firstElement = true; 
    335     private boolean dcroiOpen = false; 
    336     private int numChannels, extras; 
    337  
    338     public void endElement(String uri, String localName, String qName) { 
    339       if (qName.equals("Element")) { 
    340         if (dcroiOpen) { 
    341           dcroiOpen = false; 
    342           return; 
    343         } 
    344         if (fullSeries.indexOf("/") != -1) { 
    345           fullSeries = fullSeries.substring(0, fullSeries.lastIndexOf("/")); 
    346         } 
    347         else fullSeries = ""; 
    348  
    349         extraDims.add(new Integer(extras)); 
    350         if (numChannels == 0) numChannels++; 
    351         channels.add(new Integer(numChannels)); 
    352  
    353         if (widths.size() < numDatasets && heights.size() < numDatasets) { 
    354           numDatasets--; 
    355         } 
    356         else if (widths.size() > numDatasets && heights.size() > numDatasets) { 
    357           numDatasets = widths.size(); 
    358         } 
    359         if (widths.size() < numDatasets) widths.add(new Integer(1)); 
    360         if (heights.size() < numDatasets) heights.add(new Integer(1)); 
    361         if (zs.size() < numDatasets) zs.add(new Integer(1)); 
    362         if (ts.size() < numDatasets) ts.add(new Integer(1)); 
    363         if (bps.size() < numDatasets) bps.add(new Integer(8)); 
    364         numChannels = 0; 
    365       } 
    366     } 
    367  
    368     public void startElement(String uri, String localName, String qName, 
    369       Attributes attributes) 
    370     { 
    371       if (qName.equals("Element")) { 
    372         if (!attributes.getValue("Name").equals("DCROISet") && !firstElement) { 
    373           series = attributes.getValue("Name"); 
    374           containerNames.add(series); 
    375           if (fullSeries == null || fullSeries.equals("")) fullSeries = series; 
    376           else fullSeries += "/" + series; 
    377         } 
    378         else if (firstElement) firstElement = false; 
    379  
    380         if (attributes.getValue("Name").equals("DCROISet")) { 
    381           dcroiOpen = true; 
    382         } 
    383  
    384         numDatasets++; 
    385         int idx = numDatasets - 1; 
    386         if (idx >= seriesNames.size()) { 
    387           numDatasets = seriesNames.size(); 
    388         } 
    389  
    390         if (!dcroiOpen) { 
    391           numChannels = 0; 
    392           extras = 1; 
    393         } 
    394       } 
    395       else if (qName.equals("Experiment")) { 
    396         for (int i=0; i<attributes.getLength(); i++) { 
    397           addMeta(attributes.getQName(i), attributes.getValue(i)); 
    398         } 
    399       } 
    400       else if (qName.equals("Image")) { 
    401         containerNames.remove(series); 
    402         if (containerCounts.size() < containerNames.size()) { 
    403           containerCounts.add(new Integer(1)); 
    404         } 
    405         else if (containerCounts.size() > 0) { 
    406           int ndx = containerCounts.size() - 1; 
    407           int n = ((Integer) containerCounts.get(ndx)).intValue(); 
    408           containerCounts.setElementAt(new Integer(n + 1), ndx); 
    409         } 
    410         if (fullSeries == null || fullSeries.equals("")) fullSeries = series; 
    411         seriesNames.add(fullSeries); 
    412       } 
    413       else if (qName.equals("ChannelDescription")) { 
    414         String prefix = fullSeries + " - Channel " + count + " - "; 
    415         for (int i=0; i<attributes.getLength(); i++) { 
    416           String name = attributes.getQName(i); 
    417           addMeta(prefix + name, attributes.getValue(name)); 
    418         } 
    419         count++; 
    420         numChannels++; 
    421         if (numChannels == 1) { 
    422           bps.add(new Integer(attributes.getValue("Resolution"))); 
    423         } 
    424       } 
    425       else if (qName.equals("DimensionDescription")) { 
    426         String prefix = fullSeries + " - Dimension " + count + " - "; 
    427         for (int i=0; i<attributes.getLength(); i++) { 
    428           String name = attributes.getQName(i); 
    429           addMeta(prefix + name, attributes.getValue(name)); 
    430         } 
    431         Integer w = new Integer(attributes.getValue("NumberOfElements")); 
    432         int id = Integer.parseInt(attributes.getValue("DimID")); 
    433  
    434         switch (id) { 
    435           case 1: 
    436             widths.add(w); 
    437             break; 
    438           case 2: 
    439             heights.add(w); 
    440             break; 
    441           case 3: 
    442             zs.add(w); 
    443             break; 
    444           case 4: 
    445             ts.add(w); 
    446             break; 
    447           default: 
    448             extras *= w.intValue(); 
    449         } 
    450       } 
    451       else if (qName.equals("ScannerSettingRecord")) { 
    452         String key = attributes.getValue("Identifier") + " - " + 
    453           attributes.getValue("Description"); 
    454         addMeta(fullSeries + " - " + key, attributes.getValue("Variant")); 
    455         String identifier = attributes.getValue("Identifier"); 
    456         if ("csScanMode".equals(identifier)) { 
    457           String ordering = attributes.getValue("Variant").toLowerCase(); 
    458  
    459           if (ordering.indexOf("x") == -1 || ordering.indexOf("y") == -1 || 
    460             ordering.indexOf("xy") == -1) 
    461           { 
    462             // switch the axis sizes around, depending on the 
    463             // stored dimension order 
    464  
    465             int xPos = ordering.indexOf("x"); 
    466             int yPos = ordering.indexOf("y"); 
    467             int zPos = ordering.indexOf("z"); 
    468             int tPos = ordering.indexOf("t"); 
    469  
    470             if (xPos < 0) xPos = 0; 
    471             if (yPos < 0) yPos = 1; 
    472             if (zPos < 0) zPos = 2; 
    473             if (tPos < 0) tPos = 3; 
    474  
    475             int index = widths.size() - 1; 
    476  
    477             int x = ((Integer) widths.get(index)).intValue(); 
    478             int y = index < heights.size() ? 
    479               ((Integer) heights.get(index)).intValue() : 1; 
    480             int z = 
    481               index < zs.size() ? ((Integer) zs.get(index)).intValue() : 1; 
    482             int t = 
    483               index < ts.size() ? ((Integer) ts.get(index)).intValue() : 1; 
    484  
    485             int[] dimensions = {x, y, z, t}; 
    486  
    487             x = dimensions[xPos]; 
    488             y = dimensions[yPos]; 
    489             z = dimensions[zPos]; 
    490             t = dimensions[tPos]; 
    491  
    492             widths.setElementAt(new Integer(x), widths.size() - 1); 
    493             if (index < heights.size()) { 
    494               heights.setElementAt(new Integer(y), heights.size() - 1); 
    495             } 
    496             else heights.add(new Integer(y)); 
    497             if (index < zs.size()) { 
    498               zs.setElementAt(new Integer(z), zs.size() - 1); 
    499             } 
    500             else zs.add(new Integer(z)); 
    501             if (index < ts.size()) { 
    502               ts.setElementAt(new Integer(t), ts.size() - 1); 
    503             } 
    504             else ts.add(new Integer(t)); 
    505           } 
    506         } 
    507         else if (identifier.startsWith("dblVoxel")) { 
    508           String size = attributes.getValue("Variant"); 
    509           float cal = Float.parseFloat(size) * 1000000; 
    510           if (identifier.endsWith("X")) xcal.add(new Float(cal)); 
    511           else if (identifier.endsWith("Y")) ycal.add(new Float(cal)); 
    512           else if (identifier.endsWith("Z")) zcal.add(new Float(cal)); 
    513         } 
    514       } 
    515       else if (qName.equals("FilterSettingRecord")) { 
    516         String key = attributes.getValue("ObjectName") + " - " + 
    517           attributes.getValue("Description") + " - " + 
    518           attributes.getValue("Attribute"); 
    519         addMeta(fullSeries + " - " + key, attributes.getValue("Variant")); 
    520       } 
    521       else if (qName.equals("ATLConfocalSettingDefinition")) { 
    522         if (fullSeries.endsWith(" - Master sequential setting")) { 
    523           fullSeries = fullSeries.replaceAll(" - Master sequential setting", 
    524             " - Sequential Setting 0"); 
    525         } 
    526  
    527         if (fullSeries.indexOf("- Sequential Setting ") == -1) { 
    528           fullSeries += " - Master sequential setting"; 
    529         } 
    530         else { 
    531           int ndx = fullSeries.indexOf(" - Sequential Setting ") + 22; 
    532           int n = Integer.parseInt(fullSeries.substring(ndx)) + 1; 
    533           fullSeries = fullSeries.substring(0, ndx) + String.valueOf(n); 
    534         } 
    535  
    536         for (int i=0; i<attributes.getLength(); i++) { 
    537           addMeta(fullSeries + " - " + attributes.getQName(i), 
    538             attributes.getValue(i)); 
    539         } 
    540       } 
    541       else if (qName.equals("Wheel")) { 
    542         String prefix = fullSeries + " - Wheel " + count + " - "; 
    543         for (int i=0; i<attributes.getLength(); i++) { 
    544           String name = attributes.getQName(i); 
    545           addMeta(prefix + name, attributes.getValue(name)); 
    546         } 
    547         count++; 
    548       } 
    549       else if (qName.equals("WheelName")) { 
    550         String prefix = 
    551           fullSeries + " - Wheel " + (count - 1) + " - WheelName "; 
    552         int ndx = 0; 
    553         while (getMeta(prefix + ndx) != null) ndx++; 
    554  
    555         addMeta(prefix + ndx, attributes.getValue("FilterName")); 
    556       } 
    557       else if (qName.equals("MultiBand")) { 
    558         String prefix = fullSeries + " - MultiBand Channel " + 
    559           attributes.getValue("Channel") + " - "; 
    560         addMeta(prefix + "LeftWorld", attributes.getValue("LeftWorld")); 
    561         addMeta(prefix + "RightWorld", attributes.getValue("RightWorld")); 
    562         addMeta(prefix + "DyeName", attributes.getValue("DyeName")); 
    563       } 
    564       else if (qName.equals("LaserLineSetting")) { 
    565         String prefix = fullSeries + " - LaserLine " + 
    566           attributes.getValue("LaserLine") + " - "; 
    567         for (int i=0; i<attributes.getLength(); i++) { 
    568           String name = attributes.getQName(i); 
    569           if (!name.equals("LaserLine")) { 
    570             addMeta(prefix + name, attributes.getValue(name)); 
    571           } 
    572         } 
    573       } 
    574       else if (qName.equals("Detector")) { 
    575         String prefix = fullSeries + " - Detector Channel " + 
    576           attributes.getValue("Channel") + " - "; 
    577         for (int i=0; i<attributes.getLength(); i++) { 
    578           String name = attributes.getQName(i); 
    579           if (!name.equals("Channel")) { 
    580             addMeta(prefix + name, attributes.getValue(name)); 
    581           } 
    582         } 
    583       } 
    584       else if (qName.equals("Laser")) { 
    585         String prefix = fullSeries + " Laser " + 
    586           attributes.getValue("LaserName") + " - "; 
    587         for (int i=0; i<attributes.getLength(); i++) { 
    588           String name = attributes.getQName(i); 
    589           if (!name.equals("LaserName")) { 
    590             addMeta(prefix + name, attributes.getValue(name)); 
    591           } 
    592         } 
    593       } 
    594       else if (qName.equals("TimeStamp")) { 
    595         // parse the time stamp 
    596         // we're not 100% sure of how time stamps should be stored, but this 
    597         // seems to work 
    598         long high = Long.parseLong(attributes.getValue("HighInteger")); 
    599         long low = Long.parseLong(attributes.getValue("LowInteger")); 
    600  
    601         long stamp = 0; 
    602         high <<= 32; 
    603         if ((int) low < 0) { 
    604           low &= 0xffffffffL; 
    605         } 
    606         stamp = high + low; 
    607  
    608         long ms = stamp / 10000; 
    609  
    610         String n = String.valueOf(count); 
    611         while (n.length() < 4) n = "0" + n; 
    612         addMeta(fullSeries + " - TimeStamp " + n, 
    613           DataTools.convertDate(ms, DataTools.COBOL)); 
    614         count++; 
    615       } 
    616       else if (qName.equals("ChannelScalingInfo")) { 
    617         String prefix = fullSeries + " - ChannelScalingInfo " + count + " - "; 
    618         for (int i=0; i<attributes.getLength(); i++) { 
    619           String name = attributes.getQName(i); 
    620           addMeta(prefix + name, attributes.getValue(name)); 
    621         } 
    622       } 
    623       else if (qName.equals("RelTimeStamp")) { 
    624         addMeta(fullSeries + " RelTimeStamp " + attributes.getValue("Frame"), 
    625           attributes.getValue("Time")); 
    626       } 
    627       else count = 0; 
    628     } 
    629   } 
    630  
    631308} 
  • trunk/loci/formats/in/ND2Reader.java

    r4148 r4202  
    126126    in.seek(offsets[series][no]); 
    127127 
    128     int bpp = FormatTools.getBytesPerPixel(core.pixelType[series]); 
     128    int bpp = FormatTools.getBytesPerPixel(getPixelType()); 
    129129    int pixel = bpp * getRGBChannelCount(); 
    130130 
     
    133133 
    134134    if (isJPEG) { 
    135       in.seek(offsets[series][no]); 
    136135      byte[] tmp = new JPEG2000Codec().decompress(in, new Object[] { 
    137         new Boolean(core.littleEndian[series]), 
    138         new Boolean(core.interleaved[series]), new Long(maxFP)}); 
     136        new Boolean(isLittleEndian()), 
     137        new Boolean(isInterleaved()), new Long(maxFP)}); 
    139138      System.arraycopy(tmp, 0, buf, 0, (int) Math.min(tmp.length, buf.length)); 
    140139      tmp = null; 
     
    142141    else if (isLossless) { 
    143142      // plane is compressed using ZLIB 
    144       int plane = core.sizeX[series] * core.sizeY[series] * pixel; 
     143      int plane = getSizeX() * getSizeY() * pixel; 
    145144      byte[] b = new byte[plane]; 
    146145      in.read(b); 
    147146 
    148       byte[] t = null; 
    149       if ((core.sizeX[series] % 2) != 0) { 
    150         t = new byte[(core.sizeX[series] + 1) * core.sizeY[series] * pixel]; 
    151       } 
    152       else t = new byte[plane]; 
     147      int effectiveX = getSizeX(); 
     148      if ((getSizeX() % 2) != 0) effectiveX++; 
     149      byte[] t = new byte[effectiveX * getSizeY() * pixel]; 
    153150 
    154151      Inflater decompresser = new Inflater(); 
     
    158155      decompresser.end(); 
    159156 
    160       int width = core.sizeX[series]; 
    161       if ((width % 2) != 0) width++; 
    162  
    163157      for (int row=0; row<h; row++) { 
    164         System.arraycopy(t, (row + y) * width * pixel + x * pixel, 
     158        System.arraycopy(t, (row + y) * effectiveX * pixel + x * pixel, 
    165159          buf, row * w * pixel, w * pixel); 
    166160      } 
     
    168162    else { 
    169163      // plane is not compressed 
    170       in.skipBytes(y * core.sizeX[series] * pixel); 
    171       if (core.sizeX[series] == w) { 
    172         in.read(buf); 
    173       } 
    174       else { 
    175         for (int row=0; row<h; row++) { 
    176           in.skipBytes(x * pixel); 
    177           in.read(buf, row * w * pixel, w * pixel); 
    178           in.skipBytes(pixel * (core.sizeX[series] - w - x)); 
    179         } 
    180       } 
     164      DataTools.readPlane(in, x, y, w, h, this, buf); 
    181165    } 
    182166    return buf; 
     
    348332 
    349333      // adjust SizeT, if necessary 
    350       long planeSize = core.sizeX[0] * core.sizeY[0] * 
    351         FormatTools.getBytesPerPixel(core.pixelType[0]) * core.sizeC[0]; 
    352       if (planeSize*core.imageCount[0]*core.imageCount.length >= 
     334      long planeSize = getSizeX() * getSizeY() * 
     335        FormatTools.getBytesPerPixel(getPixelType()) * getSizeC(); 
     336      if (planeSize * getImageCount() * core.imageCount.length >= 
    353337        in.length() && !isLossless) 
    354338      { 
    355339        int approxPlanes = (int) (in.length() / planeSize); 
    356340        core.sizeT[0] = approxPlanes / core.imageCount.length; 
    357         if (core.sizeT[0] * core.imageCount.length < approxPlanes) { 
     341        if (getSizeT() * core.imageCount.length < approxPlanes) { 
    358342          core.sizeT[0]++; 
    359343        } 
    360         core.imageCount[0] = core.sizeT[0]; 
     344        core.imageCount[0] = getSizeT(); 
    361345        core.sizeZ[0] = 1; 
    362346      } 
     
    389373      if (numSeries == 0) numSeries = 1; 
    390374 
    391       offsets = new long[numSeries][core.imageCount[0]]; 
    392  
    393       if (core.sizeZ[0] == 0) Arrays.fill(core.sizeZ, 1); 
    394       if (core.sizeT[0] == 0) Arrays.fill(core.sizeT, 1); 
     375      offsets = new long[numSeries][getImageCount()]; 
     376 
     377      if (getSizeZ() == 0) Arrays.fill(core.sizeZ, 1); 
     378      if (getSizeT() == 0) Arrays.fill(core.sizeT, 1); 
    395379 
    396380      for (int i=0; i<imageOffsets.size(); i++) { 
     
    410394        int ndx = Integer.parseInt(sb.toString()); 
    411395 
    412         if (core.sizeC[0] == 0) { 
    413           Arrays.fill(core.sizeC, length / (core.sizeX[0] * core.sizeY[0] * 
    414             FormatTools.getBytesPerPixel(core.pixelType[0]))); 
    415         } 
    416  
    417         int seriesIndex = ndx / (core.sizeT[0] * core.sizeZ[0]); 
    418         int plane = ndx % (core.sizeT[0] * core.sizeZ[0]); 
     396        if (getSizeC() == 0) { 
     397          Arrays.fill(core.sizeC, length / (getSizeX() * getSizeY() * 
     398            FormatTools.getBytesPerPixel(getPixelType()))); 
     399        } 
     400 
     401        int seriesIndex = ndx / (getSizeT() * getSizeZ()); 
     402        int plane = ndx % (getSizeT() * getSizeZ()); 
    419403 
    420404        offsets[seriesIndex][plane] = offset + p.x + 8; 
    421  
    422405        b = null; 
    423406      } 
    424407 
    425408      if (offsets.length != core.imageCount.length) { 
    426         int x = core.sizeX[0]; 
    427         int y = core.sizeY[0]; 
    428         int c = core.sizeC[0]; 
    429         int pixelType = core.pixelType[0]; 
    430         boolean rgb = core.rgb[0]; 
     409        int x = getSizeX(); 
     410        int y = getSizeY(); 
     411        int c = getSizeC(); 
     412        int pixelType = getPixelType(); 
     413        boolean rgb = isRGB(); 
    431414        core = new CoreMetadata(offsets.length); 
    432415        Arrays.fill(core.sizeX, x); 
     
    447430      } 
    448431      else { 
    449         Arrays.fill(core.sizeX, core.sizeX[0]); 
    450         Arrays.fill(core.sizeY, core.sizeY[0]); 
    451         Arrays.fill(core.sizeC, core.sizeC[0] == 0 ? 1 : core.sizeC[0]); 
    452         Arrays.fill(core.sizeZ, core.sizeZ[0] == 0 ? 1 : core.sizeZ[0]); 
    453         Arrays.fill(core.sizeT, core.sizeT[0] == 0 ? 1 : core.sizeT[0]); 
    454         Arrays.fill(core.imageCount, core.imageCount[0]); 
    455         Arrays.fill(core.pixelType, core.pixelType[0]); 
     432        Arrays.fill(core.sizeX, getSizeX()); 
     433        Arrays.fill(core.sizeY, getSizeY()); 
     434        Arrays.fill(core.sizeC, getSizeC() == 0 ? 1 : getSizeC()); 
     435        Arrays.fill(core.sizeZ, getSizeZ() == 0 ? 1 : getSizeZ()); 
     436        Arrays.fill(core.sizeT, getSizeT() == 0 ? 1 : getSizeT()); 
     437        Arrays.fill(core.imageCount, getImageCount()); 
     438        Arrays.fill(core.pixelType, getPixelType()); 
    456439      } 
    457440 
    458441      Arrays.fill(core.currentOrder, "XYCZT"); 
    459       Arrays.fill(core.rgb, core.sizeC[0] > 1); 
     442      Arrays.fill(core.rgb, getSizeC() > 1); 
    460443 
    461444      adjustImageCount = false; 
     
    470453      } 
    471454 
    472       if (core.sizeC[0] > 1) { 
     455      if (getSizeC() > 1) { 
    473456        if (adjustImageCount) { 
    474457          int n = imageOffsets.size() / core.sizeT.length; 
    475458          Arrays.fill(core.sizeT, n == 0 ? 1 : n); 
    476459        } 
    477         Arrays.fill(core.imageCount, core.sizeT[0] * core.sizeZ[0]); 
     460        Arrays.fill(core.imageCount, getSizeT() * getSizeZ()); 
    478461      } 
    479462      Arrays.fill(core.littleEndian, true); 
     
    492475        if (tsT.size() > 0) { 
    493476          setSeries(i); 
    494           for (int n=0; n<core.imageCount[i]; n++) { 
     477          for (int n=0; n<getImageCount(); n++) { 
    495478            int[] coords = getZCTCoords(n); 
    496479            store.setPlaneTheZ(new Integer(coords[0]), i, 0, n); 
     
    643626 
    644627    status("Populating metadata"); 
    645     if (core.imageCount[0] == 0) { 
     628    if (getImageCount() == 0) { 
    646629      core.sizeZ[0] = zs.size() == 0 ? vs.size() : zs.size(); 
    647630      core.sizeT[0] = ts.size() == 0 ? 1 : ts.size(); 
    648       core.sizeC[0] = (vs.size() + 1) / (core.sizeT[0] * core.sizeZ[0]); 
     631      core.sizeC[0] = (vs.size() + 1) / (getSizeT() * getSizeZ()); 
    649632      core.imageCount[0] = vs.size(); 
    650       while (core.imageCount[0] % core.sizeC[0] != 0) core.imageCount[0]--; 
    651       while (core.sizeC[0] * core.sizeZ[0] * core.sizeT[0] > core.imageCount[0]) 
    652       { 
    653         if (core.sizeZ[0] < core.sizeT[0]) core.sizeT[0]--; 
     633      while (getImageCount() % getSizeC() != 0) core.imageCount[0]--; 
     634      while (getSizeC() * getSizeZ() * getSizeT() > getImageCount()) { 
     635        if (getSizeZ() < getSizeT()) core.sizeT[0]--; 
    654636        else core.sizeZ[0]--; 
    655637      } 
    656638    } 
    657639 
    658     if (core.sizeC[0] * core.sizeZ[0] * core.sizeT[0] != core.imageCount[0]) { 
     640    if (getSizeC() * getSizeZ() * getSizeT() != getImageCount()) { 
    659641      core.sizeZ[0] = zs.size(); 
    660642      core.sizeT[0] = ts.size(); 
    661       core.imageCount[0] = core.sizeC[0] * core.sizeZ[0] * core.sizeT[0]; 
    662       if (vs.size() > core.imageCount[0]) { 
    663         core.sizeT[0] = vs.size() / (core.rgb[0] ? 1 : core.sizeC[0]); 
    664         core.imageCount[0] = core.sizeZ[0] * core.sizeT[0]; 
    665         if (!core.rgb[0]) core.imageCount[0] *= core.sizeC[0]; 
    666       } 
    667     } 
    668  
    669     if (core.imageCount[0] == 0) core.imageCount[0] = 1; 
    670     if (core.sizeZ[0] == 0) core.sizeZ[0] = 1; 
    671     if (core.sizeC[0] == 0) core.sizeC[0] = 1; 
    672     if (core.sizeT[0] == 0) core.sizeT[0] = 1; 
    673  
    674     Arrays.fill(core.sizeZ, core.sizeZ[0]); 
    675     Arrays.fill(core.sizeT, core.sizeT[0]); 
    676     Arrays.fill(core.imageCount, core.imageCount[0]); 
     643      core.imageCount[0] = getSizeC() * getSizeZ() * getSizeT(); 
     644      if (vs.size() > getImageCount()) { 
     645        core.sizeT[0] = vs.size() / (isRGB() ? 1 : getSizeC()); 
     646        core.imageCount[0] = getSizeZ() * getSizeT(); 
     647        if (!isRGB()) core.imageCount[0] *= getSizeC(); 
     648      } 
     649    } 
     650 
     651    if (getImageCount() == 0) core.imageCount[0] = 1; 
     652    if (getSizeZ() == 0) core.sizeZ[0] = 1; 
     653    if (getSizeC() == 0) core.sizeC[0] = 1; 
     654    if (getSizeT() == 0) core.sizeT[0] = 1; 
     655 
     656    Arrays.fill(core.sizeZ, getSizeZ()); 
     657    Arrays.fill(core.sizeT, getSizeT()); 
     658    Arrays.fill(core.imageCount, getImageCount()); 
    677659    Arrays.fill(core.currentOrder, "XYCZT"); 
    678660 
     
    688670    Arrays.fill(core.sizeX, x); 
    689671    Arrays.fill(core.sizeY, y); 
    690     if (core.sizeC[0] == 0) core.sizeC[0] = 1; 
     672    if (getSizeC() == 0) core.sizeC[0] = 1; 
    691673    int numBands = c; 
    692     c = numBands > 1 ? numBands : core.sizeC[0]; 
    693     if (numBands == 1 && core.imageCount[0] == 1) c = 1; 
     674    c = numBands > 1 ? numBands : getSizeC(); 
     675    if (numBands == 1 && getImageCount() == 1) c = 1; 
    694676    Arrays.fill(core.sizeC, c); 
    695677    Arrays.fill(core.rgb, numBands > 1); 
    696678    Arrays.fill(core.pixelType, type); 
    697679 
    698     if (core.rgb[0] && core.imageCount[0] > core.sizeZ[0] * core.sizeT[0]) { 
    699       if (core.sizeZ[0] > 1) core.sizeZ[0] *= core.sizeC[0]; 
    700       else core.sizeT[0] *= core.sizeC[0]; 
    701       Arrays.fill(core.sizeT, core.sizeT[0]); 
    702       Arrays.fill(core.sizeZ, core.sizeZ[0]); 
    703     } 
    704  
    705     if (vs.size() < core.imageCount[0]) { 
     680    if (isRGB() && getImageCount() > getSizeZ() * getSizeT()) { 
     681      if (getSizeZ() > 1) core.sizeZ[0] *= getSizeC(); 
     682      else core.sizeT[0] *= getSizeC(); 
     683      Arrays.fill(core.sizeT, getSizeT()); 
     684      Arrays.fill(core.sizeZ, getSizeZ()); 
     685    } 
     686 
     687    if (vs.size() < getImageCount()) { 
    706688      Arrays.fill(core.imageCount, vs.size()); 
    707689    } 
    708690 
    709691    if (numSeries == 0) numSeries = 1; 
    710     offsets = new long[numSeries][core.imageCount[0]]; 
    711  
    712     for (int i=0; i<core.sizeT[0]; i++) { 
     692    offsets = new long[numSeries][getImageCount()]; 
     693 
     694    for (int i=0; i<getSizeT(); i++) { 
    713695      for (int j=0; j<numSeries; j++) { 
    714         for (int q=0; q<core.sizeZ[0]; q++) { 
     696        for (int q=0; q<getSizeZ(); q++) { 
    715697          for (int k=0; k<getEffectiveSizeC(); k++) { 
    716             offsets[j][i*core.sizeZ[0]*getEffectiveSizeC() + 
     698            offsets[j][i*getSizeZ()*getEffectiveSizeC() + 
    717699              q*getEffectiveSizeC() + k] = ((Long) vs.remove(0)).longValue(); 
    718700          } 
     
    780762      } 
    781763      else if (qName.equals("uiWidthBytes")) { 
    782         int bytes = 
    783           Integer.parseInt(attributes.getValue("value")) / core.sizeX[0]; 
     764        int bytes = Integer.parseInt(attributes.getValue("value")) / getSizeX(); 
    784765        switch (bytes) { 
    785766          case 2: 
     
    798779      else if (qName.equals("uiCompCount")) { 
    799780        int v = Integer.parseInt(attributes.getValue("value")); 
    800         if (v > core.sizeC[0]) core.sizeC[0] = v; 
     781        core.sizeC[0] = (int) Math.max(getSizeC(), v); 
    801782      } 
    802783      else if (qName.equals("uiBpcInMemory")) { 
     
    820801      else if (qName.equals("uiCount")) { 
    821802        int n = Integer.parseInt(attributes.getValue("value")); 
    822         if (core.imageCount[0] == 0) { 
     803        if (getImageCount() == 0) { 
    823804          core.imageCount[0] = n; 
    824805          core.sizeT[0] = n; 
     
    828809      else if (qName.equals("uiSequenceCount")) { 
    829810        int n = Integer.parseInt(attributes.getValue("value")); 
    830         if (n > 0 && (core.imageCount[0] == 0 || core.sizeT[0] == 0 || 
    831           n < core.imageCount[0])) 
     811        if (n > 0 && (getImageCount() == 0 || getSizeT() == 0 || 
     812          n < getImageCount())) 
    832813        { 
    833814          core.imageCount[0] = n; 
     
    888869    } 
    889870    else if (key.endsWith("uiCount")) { 
    890       if (core.sizeT[0] == 0) { 
     871      if (getSizeT() == 0) { 
    891872        core.sizeT[0] = Integer.parseInt(value); 
    892873      } 
     
    908889              numSeries = v; 
    909890              if (numSeries > 1) { 
    910                 int x = core.sizeX[0]; 
    911                 int y = core.sizeY[0]; 
    912                 int z = core.sizeZ[0]; 
    913                 int tSize = core.sizeT[0]; 
    914                 int c = core.sizeC[0]; 
     891                int x = getSizeX(); 
     892                int y = getSizeY(); 
     893                int z = getSizeZ(); 
     894                int tSize = getSizeT(); 
     895                int c = getSizeC(); 
    915896                core = new CoreMetadata(numSeries); 
    916897                Arrays.fill(core.sizeX, x); 
     
    932913          } 
    933914 
    934           int count = core.sizeZ[0] * core.sizeC[0] * core.sizeT[0]; 
     915          int count = getSizeZ() * getSizeC() * getSizeT(); 
    935916          Arrays.fill(core.imageCount, count); 
    936917        } 
  • trunk/loci/formats/in/NRRDReader.java

    r4132 r4202  
    9090    if (dataFile == null) { 
    9191      if (encoding.equals("raw")) { 
    92         int bpp = FormatTools.getBytesPerPixel(core.pixelType[0]); 
    93         int pixel = bpp * core.sizeC[0]; 
    94         int rowLen = core.sizeX[0] * pixel; 
    95         in.seek(offset + no * core.sizeY[0] * rowLen + y * rowLen); 
    96  
    97         if (core.sizeX[series] == w) { 
    98           in.read(buf); 
    99         } 
    100         else { 
    101           for (int row=0; row<h; row++) { 
    102             in.skipBytes(x * pixel); 
    103             in.read(buf, row * w * pixel, w * pixel); 
    104             in.skipBytes(pixel * (core.sizeX[0] - w - x)); 
    105           } 
    106         } 
    107  
     92        int bpp = FormatTools.getBytesPerPixel(getPixelType()); 
     93        int rowLen = getSizeX() * bpp * getSizeC(); 
     94        in.seek(offset + no * getSizeY() * rowLen); 
     95 
     96        DataTools.readPlane(in, x, y, w, h, this, buf); 
    10897        return buf; 
    10998      } 
     
    187176              core.sizeC[0] = size; 
    188177            } 
    189             else if (i == 0 || (core.sizeC[0] > 1 && i == 1)) { 
     178            else if (i == 0 || (getSizeC() > 1 && i == 1)) { 
    190179              core.sizeX[0] = size; 
    191180            } 
    192             else if (i == 1 || (core.sizeC[0] > 1 && i == 2)) { 
     181            else if (i == 1 || (getSizeC() > 1 && i == 2)) { 
    193182              core.sizeY[0] = size; 
    194183            } 
    195             else if (i == 2 || (core.sizeC[0] > 1 && i == 3)) { 
     184            else if (i == 2 || (getSizeC() > 1 && i == 3)) { 
    196185              core.sizeZ[0] = size; 
    197186            } 
    198             else if (i == 3 || (core.sizeC[0] > 1 && i == 4)) { 
     187            else if (i == 3 || (getSizeC() > 1 && i == 4)) { 
    199188              core.sizeT[0] = size; 
    200189            } 
     
    242231    } 
    243232 
    244     core.rgb[0] = core.sizeC[0] > 1; 
     233    core.rgb[0] = getSizeC() > 1; 
    245234    core.interleaved[0] = true; 
    246     core.imageCount[0] = core.sizeZ[0] * core.sizeT[0]; 
     235    core.imageCount[0] = getSizeZ() * getSizeT(); 
    247236    core.indexed[0] = false; 
    248237    core.falseColor[0] = false; 
  • trunk/loci/formats/in/OMETiffReader.java

    r4116 r4202  
    9393 
    9494    // parse and populate OME-XML metadata 
    95     RandomAccessStream ras = new RandomAccessStream(new Location(id).getAbsoluteFile().getAbsolutePath()); 
     95    String fileName = new Location(id).getAbsoluteFile().getAbsolutePath(); 
     96    RandomAccessStream ras = new RandomAccessStream(fileName); 
    9697    Hashtable firstIFD = TiffTools.getFirstIFD(ras); 
    9798    ras.close(); 
  • trunk/loci/formats/in/OMEXMLReader.java

    r4113 r4202  
    183183    } 
    184184 
    185     int depth = FormatTools.getBytesPerPixel(core.pixelType[series]); 
     185    int depth = FormatTools.getBytesPerPixel(getPixelType()); 
    186186    for (int row=0; row<h; row++) { 
    187       int off = (row + y) * core.sizeX[series] * depth + x * depth; 
     187      int off = (row + y) * getSizeX() * depth + x * depth; 
    188188      System.arraycopy(pixels, off, buf, row * w * depth, w * depth); 
    189189    } 
     
    264264      core.sizeZ[i] = z.intValue(); 
    265265      core.sizeC[i] = c.intValue(); 
    266       core.imageCount[i] = core.sizeZ[i] * core.sizeC[i] * core.sizeT[i]; 
     266      core.imageCount[i] = getSizeZ() * getSizeC() * getSizeT(); 
    267267      core.littleEndian[i] = endian == null ? false : !endian.booleanValue(); 
    268268      core.rgb[i] = false; 
  • trunk/loci/formats/in/OpenlabRawReader.java

    r4061 r4202  
    6666  public boolean isThisType(byte[] block) { 
    6767    if (block.length < blockCheckLen) return false; 
    68     return block[0] == 'O' && block[1] == 'L' && 
    69       block[2] == 'R' && block[3] == 'W'; 
     68    return new String(block).startsWith("OLRW"); 
    7069  } 
    7170 
     
    8079    FormatTools.checkBufferSize(this, buf.length, w, h); 
    8180 
    82     in.seek(offsets[no / core.sizeC[0]] + 288); 
     81    in.seek(offsets[no / getSizeC()] + 288); 
     82    DataTools.readPlane(in, x, y, w, h, this, buf); 
    8383 
    84     int bpp = FormatTools.getBytesPerPixel(core.pixelType[0]); 
    85     in.skipBytes(y * core.sizeX[0] * bpp * core.sizeC[0]); 
    86  
    87     int rowLen = w * bpp * core.sizeC[0]; 
    88     if (core.sizeX[series] == w) { 
    89       in.read(buf); 
    90     } 
    91     else { 
    92       for (int row=0; row<h; row++) { 
    93         in.skipBytes(x * bpp * core.sizeC[0]); 
    94         in.read(buf, row * rowLen, rowLen); 
    95         in.skipBytes(bpp * core.sizeC[0] * (core.sizeX[0] - w - x)); 
    96       } 
    97     } 
    98  
    99     if (bytesPerPixel == 1) { 
     84    if (FormatTools.getBytesPerPixel(getPixelType()) == 1) { 
    10085      // need to invert the pixels 
    10186      for (int i=0; i<buf.length; i++) { 
     
    137122 
    138123    core.imageCount[0] = in.readInt(); 
    139     offsets = new int[core.imageCount[0]]; 
     124    offsets = new int[getImageCount()]; 
    140125    offsets[0] = 12; 
    141126 
     
    169154    addMeta("Image name", in.readString(len - 1).trim()); 
    170155 
    171     if (core.sizeC[0] <= 1) core.sizeC[0] = 1; 
     156    if (getSizeC() <= 1) core.sizeC[0] = 1; 
    172157    else core.sizeC[0] = 3; 
    173     addMeta("Width", new Integer(core.sizeX[0])); 
    174     addMeta("Height", new Integer(core.sizeY[0])); 
     158    addMeta("Width", new Integer(getSizeX())); 
     159    addMeta("Height", new Integer(getSizeY())); 
    175160    addMeta("Bytes per pixel", new Integer(bytesPerPixel)); 
    176161 
    177     int plane = core.sizeX[0] * core.sizeY[0] * bytesPerPixel; 
    178     for (int i=1; i<core.imageCount[0]; i++) { 
     162    int plane = getSizeX() * getSizeY() * bytesPerPixel; 
     163    for (int i=1; i<getImageCount(); i++) { 
    179164      offsets[i] = offsets[i - 1] + 288 + plane; 
    180165    } 
    181166 
    182     core.sizeZ[0] = core.imageCount[0]; 
     167    core.sizeZ[0] = getImageCount(); 
    183168    core.sizeT[0] = 1; 
    184169    core.currentOrder[0] = "XYZTC"; 
    185     core.rgb[0] = core.sizeC[0] > 1; 
     170    core.rgb[0] = getSizeC() > 1; 
    186171    core.interleaved[0] = false; 
    187172    core.littleEndian[0] = false; 
  • trunk/loci/formats/in/OpenlabReader.java

    r4111 r4202  
    121121    FormatTools.checkBufferSize(this, buf.length); 
    122122 
    123     in.seek(planes[planeOffsets[series][no]].planeOffset); 
    124     long first = planes[planeOffsets[series][no]].planeOffset; 
    125     long last = no == core.imageCount[series] - 1 ? in.length() : 
     123    int index = planeOffsets[series][no]; 
     124 
     125    long first = planes[index].planeOffset; 
     126    long last = no == getImageCount() - 1 ? in.length() : 
    126127      planes[planeOffsets[series][no + 1]].planeOffset; 
     128    in.seek(first); 
    127129    byte[] b = new byte[(int) (last - first)]; 
    128130 
    129131    int bpp = FormatTools.getBytesPerPixel(getPixelType()); 
    130132 
    131     if (!planes[planeOffsets[series][no]].pict) { 
     133    if (!planes[index].pict) { 
    132134      if (version == 2) { 
    133         in.skipBytes(y * getSizeX() * bpp * getRGBChannelCount()); 
    134         int rowLen = w * bpp * getRGBChannelCount(); 
    135         if (core.sizeX[series] == w) { 
    136           in.read(buf); 
    137         } 
    138         else { 
    139           for (int row=0; row<h; row++) { 
    140             in.skipBytes(x * bpp * getRGBChannelCount()); 
    141             in.read(buf, row * rowLen, rowLen); 
    142             in.skipBytes(bpp * getRGBChannelCount() * (getSizeX() - w - x)); 
    143           } 
    144         } 
     135        DataTools.readPlane(in, x, y, w, h, this, buf); 
    145136      } 
    146137      else { 
     
    149140        b = new LZOCodec().decompress(b); 
    150141 
    151         if (core.sizeX[series] * core.sizeY[series] * 4 <= b.length) { 
     142        if (getSizeX() * getSizeY() * 4 <= b.length) { 
    152143          for (int yy=y; yy<h + y; yy++) { 
    153144            for (int xx=x; xx<w + x; xx++) { 
    154               System.arraycopy(b, (yy*(core.sizeX[series]+4) + xx)*4 + 1, buf, 
     145              System.arraycopy(b, (yy*(getSizeX()+4) + xx)*4 + 1, buf, 
    155146                ((yy - y)*w + xx - x)*3, 3); 
    156147            } 
     
    158149        } 
    159150        else { 
    160           int srcLen = b.length / core.sizeY[series]; 
    161           int destLen = core.sizeX[series] * bpp * getRGBChannelCount(); 
    162           if (srcLen - destLen != 16) srcLen = destLen; 
    163           destLen = w * bpp * getRGBChannelCount(); 
     151          int src = b.length / getSizeY(); 
     152          int bytes = bpp * getRGBChannelCount(); 
     153          if (src - (getSizeX() * bytes) != 16) src = getSizeX() * bytes; 
     154          int dest = w * bytes; 
    164155          for (int row=0; row<h; row++) { 
    165             System.arraycopy(b, (row + y)*srcLen + x*bpp*getRGBChannelCount(), 
    166               buf, row*destLen, destLen); 
     156            System.arraycopy(b, (row + y)*src + x*bytes, buf, row*dest, dest); 
    167157          } 
    168158        } 
     
    185175      if (exc != null) { 
    186176        if (debug) LogTools.trace(exc); 
    187         in.seek(planes[planeOffsets[series][no]].planeOffset - 298); 
     177        in.seek(planes[index].planeOffset - 298); 
    188178 
    189179        if (in.readByte() == 1) in.skipBytes(128); 
     
    307297      readTagHeader(); 
    308298      while (tag < IMAGE_TYPE_1 || tag > 76) { 
    309         fp--; 
    310         in.seek(fp); 
     299        in.seek(--fp); 
    311300        readTagHeader(); 
    312301      } 
  • trunk/loci/formats/in/PCIReader.java

    r4132 r4202  
    7070 
    7171    RandomAccessStream s = poi.getDocumentStream((String) imageFiles.get(no)); 
    72  
    73     int bpp = FormatTools.getBytesPerPixel(core.pixelType[series]); 
    74  
    75     int rowLen = w * bpp; 
    76     int skip = y * core.sizeX[series] * bpp; 
    77     int beginSkip = bpp * x; 
    78     int endSkip = bpp * (core.sizeX[0] - w - x); 
    79  
    80     if (w == getSizeX() && h == getSizeY() && x == 0 && y == 0) { 
    81       s.read(buf); 
    82     } 
    83     else { 
    84       for (int c=0; c<core.sizeC[series]; c++) { 
    85         s.skipBytes(skip); 
    86         if (beginSkip == 0 && endSkip == 0) { 
    87           s.read(buf, c * h * rowLen, rowLen * h); 
    88         } 
    89         else { 
    90           for (int row=0; row<h; row++) { 
    91             s.skipBytes(beginSkip); 
    92             s.read(buf, c * h * rowLen + row * rowLen, rowLen); 
    93             s.skipBytes(endSkip); 
    94           } 
    95         } 
    96         s.skipBytes((core.sizeY[series] - h - y) * core.sizeX[series] * bpp); 
    97       } 
    98     } 
    99  
     72    DataTools.readPlane(s, x, y, w, h, this, buf); 
    10073    s.close(); 
    10174 
     
    133106      String relativePath = 
    134107        name.substring(name.lastIndexOf(File.separator) + 1); 
    135   
     108 
    136109      if (relativePath.equals("Field Count")) { 
    137110        byte[] b = poi.getDocumentBytes(name, 4); 
     
    178151        } 
    179152 
    180         if (core.sizeX[0] != 0 && core.sizeY[0] != 0) { 
    181           core.sizeC[0] = poi.getFileSize(name) / 
    182             (core.sizeX[0] * core.sizeY[0] * 
    183             FormatTools.getBytesPerPixel(core.pixelType[0])); 
    184           if (core.sizeC[0] == 0) { 
     153        if (getSizeX() != 0 && getSizeY() != 0) { 
     154          int bpp = FormatTools.getBytesPerPixel(getPixelType()); 
     155          int plane = getSizeX() * getSizeY() * bpp; 
     156          core.sizeC[0] = poi.getFileSize(name) / plane; 
     157          if (getSizeC() == 0) { 
    185158            core.sizeX[0] /= 16; 
    186159            core.sizeY[0] /= 16; 
    187             core.sizeC[0] = poi.getFileSize(name) / 
    188               (core.sizeX[0] * core.sizeY[0] * 
    189               FormatTools.getBytesPerPixel(core.pixelType[0])); 
     160            core.sizeC[0] = poi.getFileSize(name) / plane; 
    190161          } 
    191162        } 
     
    209180        } 
    210181      } 
    211       else if (relativePath.indexOf("Image_Height") != -1 && core.sizeY[0] == 0) 
    212       { 
     182      else if (relativePath.indexOf("Image_Height") != -1 && getSizeY() == 0) { 
    213183        byte[] b = poi.getDocumentBytes(name, 8); 
    214184        byte val = b[6]; 
     
    217187        core.sizeY[0] = mul * 16; 
    218188      } 
    219       else if (relativePath.indexOf("Image_Width") != -1 && core.sizeX[0] == 0) 
    220       { 
     189      else if (relativePath.indexOf("Image_Width") != -1 && getSizeX() == 0) { 
    221190        byte[] b = poi.getDocumentBytes(name, 8); 
    222191        byte val = b[6]; 
     
    227196    } 
    228197 
    229     if (core.sizeC[0] == 0) core.sizeC[0] = 1; 
    230  
    231     core.sizeZ[0] = core.imageCount[0]; 
     198    if (getSizeC() == 0) core.sizeC[0] = 1; 
     199 
     200    core.sizeZ[0] = getImageCount(); 
    232201    core.sizeT[0] = 1; 
    233     core.rgb[0] = core.sizeC[0] > 1; 
     202    core.rgb[0] = getSizeC() > 1; 
    234203    core.interleaved[0] = false; 
    235204    core.currentOrder[0] = "XYCZT"; 
  • trunk/loci/formats/in/PCXReader.java

    r4132 r4202  
    7979    // PCX uses a simple RLE compression algorithm 
    8080 
    81     byte[] b = new byte[bytesPerLine * core.sizeY[0] * nColorPlanes]; 
     81    byte[] b = new byte[bytesPerLine * getSizeY() * nColorPlanes]; 
    8282    int pt = 0; 
    8383    while (pt < b.length) { 
  • trunk/loci/formats/in/PGMReader.java

    r4132 r4202  
    7272    in.seek(offset); 
    7373    if (rawBits) { 
    74       int bpp = FormatTools.getBytesPerPixel(core.pixelType[0]); 
    75       int pixel = bpp * core.sizeC[0]; 
    76       in.skipBytes(pixel * core.sizeX[0] * y); 
    77  
    78       if (core.sizeX[series] == w) { 
    79         in.read(buf); 
    80       } 
    81       else { 
    82         for (int row=0; row<h; row++) { 
    83           in.skipBytes(x * pixel); 
    84           in.read(buf, row * w * pixel, w * pixel); 
    85           in.skipBytes(pixel * (core.sizeX[0] - w - x)); 
    86         } 
    87       } 
     74      DataTools.readPlane(in, x, y, w, h, this, buf); 
    8875    } 
    8976    else { 
     
    9582        while (t.hasMoreTokens()) { 
    9683          int q = Integer.parseInt(t.nextToken().trim()); 
    97           if (core.pixelType[0] == FormatTools.UINT16) { 
    98             short s = (short) q; 
    99             buf[pt] = (byte) ((s & 0xff00) >> 8); 
    100             buf[pt + 1] = (byte) (s & 0xff); 
     84          if (getPixelType() == FormatTools.UINT16) { 
     85            DataTools.unpackShort((short) q, buf, pt, isLittleEndian()); 
    10186            pt += 2; 
    10287          } 
    10388          else { 
    104             buf[pt] = (byte) q; 
    105             pt++; 
     89            buf[pt++] = (byte) q; 
    10690          } 
    10791        } 
     
    153137    offset = in.getFilePointer(); 
    154138 
    155     core.rgb[0] = core.sizeC[0] == 3; 
     139    core.rgb[0] = getSizeC() == 3; 
    156140    core.currentOrder[0] = "XYCZT"; 
    157141    core.littleEndian[0] = true; 
  • trunk/loci/formats/in/PSDReader.java

    r4132 r4202  
    7979    in.seek(offset); 
    8080 
    81     int plane = core.sizeX[0] * core.sizeY[0] * 
    82       FormatTools.getBytesPerPixel(core.pixelType[0]); 
    83     int[][] lens = new int[core.sizeC[0]][core.sizeY[0]]; 
     81    int bpp = FormatTools.getBytesPerPixel(getPixelType()); 
     82    int plane = getSizeX() * getSizeY() * bpp; 
     83    int[][] lens = new int[getSizeC()][getSizeY()]; 
    8484    boolean compressed = in.readShort() == 1; 
    85  
    86     int bpp = FormatTools.getBytesPerPixel(core.pixelType[0]); 
    8785 
    8886    if (compressed) { 
    8987      PackbitsCodec codec = new PackbitsCodec(); 
    90       for (int c=0; c<core.sizeC[0]; c++) { 
    91         for (int row=0; row<core.sizeY[0]; row++) { 
     88      for (int c=0; c<getSizeC(); c++) { 
     89        for (int row=0; row<getSizeY(); row++) { 
    9290          lens[c][row] = in.readShort(); 
    9391        } 
    9492      } 
    9593 
    96       for (int c=0; c<core.sizeC[0]; c++) { 
    97         for (int row=0; row<core.sizeY[0]; row++) { 
     94      for (int c=0; c<getSizeC(); c++) { 
     95        for (int row=0; row<getSizeY(); row++) { 
    9896          if (row < y || row >= (y + h)) in.skipBytes(lens[c][row]); 
    9997          else { 
    10098            byte[] b = new byte[lens[c][row]]; 
    10199            in.read(b); 
    102             b = codec.decompress(b, new Integer(core.sizeX[0] * bpp)); 
     100            b = codec.decompress(b, new Integer(getSizeX() * bpp)); 
    103101            System.arraycopy(b, x * bpp, buf, 
    104102              c * h * bpp * w + (row - y) * bpp * w, w * bpp); 
     
    108106    } 
    109107    else { 
    110       for (int c=0; c<core.sizeC[0]; c++) { 
    111         in.skipBytes(y * bpp * core.sizeX[0]); 
    112         for (int row=0; row<h; row++) { 
    113           in.skipBytes(x * bpp); 
    114           in.read(buf, c * h * w * bpp + row * w * bpp, w * bpp); 
    115           in.skipBytes(bpp * (core.sizeX[0] - w - x)); 
    116         } 
    117       } 
     108      DataTools.readPlane(in, x, y, w, h, this, buf); 
    118109    } 
    119110    return buf; 
     
    151142    int bits = in.readShort(); 
    152143    addMeta("Bits per pixel", new Integer(bits)); 
    153     switch (bits) { 
    154       case 16: 
    155         core.pixelType[0] = FormatTools.UINT16; 
    156         break; 
    157       default: core.pixelType[0] = FormatTools.UINT8; 
    158     } 
     144    if (bits == 16) core.pixelType[0] = FormatTools.UINT16; 
     145    else core.pixelType[0] = FormatTools.UINT8; 
    159146 
    160147    int colorMode = in.readShort(); 
     
    279266    core.sizeT[0] = 1; 
    280267    core.rgb[0] = modeString.equals("RGB"); 
    281     core.imageCount[0] = core.sizeC[0] / (core.rgb[0] ? 3 : 1); 
     268    core.imageCount[0] = getSizeC() / (isRGB() ? 3 : 1); 
    282269    core.indexed[0] = modeString.equals("palette color"); 
    283270    core.falseColor[0] = false; 
  • trunk/loci/formats/in/PerkinElmerReader.java

    r4200 r4202  
    139139    FormatTools.checkPlaneNumber(this, no); 
    140140    if (isTiff) { 
    141       tiff.setId(files[no / core.sizeC[0]]); 
     141      tiff.setId(files[no / getSizeC()]); 
    142142      return tiff.openBytes(0, buf, x, y, w, h); 
    143143    } 
     
    145145    FormatTools.checkBufferSize(this, buf.length, w, h); 
    146146 
    147     String file = files[no]; 
    148     RandomAccessStream ras = new RandomAccessStream(file); 
    149  
    150     int bytes = FormatTools.getBytesPerPixel(core.pixelType[0]); 
    151     ras.skipBytes(6 + y * core.sizeX[0] * bytes); 
    152  
    153     for (int row=0; row<h; row++) { 
    154       ras.skipBytes(x * bytes); 
    155       ras.read(buf, row * w * bytes, w * bytes); 
    156       ras.skipBytes(bytes * (core.sizeX[0] - w - x)); 
    157     } 
    158  
     147    RandomAccessStream ras = new RandomAccessStream(files[no]); 
     148    ras.seek(6); 
     149 
     150    DataTools.readPlane(ras, x, y, w, h, this, buf); 
    159151    ras.close(); 
    160152    return buf; 
     
    615607    else { 
    616608      RandomAccessStream tmp = new RandomAccessStream(files[0]); 
    617       int bpp = (int) (tmp.length() - 6) / (core.sizeX[0] * core.sizeY[0]); 
     609      int bpp = (int) (tmp.length() - 6) / (getSizeX() * getSizeY()); 
    618610      tmp.close(); 
    619611      switch (bpp) { 
     
    631623    } 
    632624 
    633     if (core.sizeZ[0] <= 0) core.sizeZ[0] = 1; 
    634     if (core.sizeC[0] <= 0) core.sizeC[0] = 1; 
    635  
    636     if (core.sizeT[0] <= 0) { 
    637       core.sizeT[0] = core.imageCount[0] / (core.sizeZ[0] * core.sizeC[0]); 
     625    if (getSizeZ() <= 0) core.sizeZ[0] = 1; 
     626    if (getSizeC() <= 0) core.sizeC[0] = 1; 
     627 
     628    if (getSizeT() <= 0) { 
     629      core.sizeT[0] = getImageCount() / (getSizeZ() * getSizeC()); 
    638630    } 
    639631    else { 
    640       core.imageCount[0] = core.sizeC[0] * core.sizeZ[0] * core.sizeT[0]; 
    641       if (core.imageCount[0] > files.length) { 
     632      core.imageCount[0] = getSizeZ() * getSizeC() * getSizeT(); 
     633      if (getImageCount() > files.length) { 
    642634        core.imageCount[0] = files.length; 
    643         core.sizeT[0] = core.imageCount[0] / (core.sizeZ[0] * core.sizeC[0]); 
     635        core.sizeT[0] = getImageCount() / (getSizeZ() * getSizeC()); 
    644636      } 
    645637    } 
     
    647639    // throw away files, if necessary 
    648640 
    649     if (files.length > core.imageCount[0]) { 
     641    if (files.length > getImageCount()) { 
    650642      String[] tmpFiles = files; 
    651       files = new String[core.imageCount[0]]; 
     643      files = new String[getImageCount()]; 
    652644 
    653645      Hashtable zSections = new Hashtable(); 
     
    670662      for (int i=0; i<keys.length; i++) { 
    671663        int oldCount = ((Integer) zSections.get(keys[i])).intValue(); 
    672         int nPlanes = (isTiff ? tiff.getEffectiveSizeC() : core.sizeC[0]) * 
    673           core.sizeT[0]; 
     664        int nPlanes = (isTiff ? tiff.getEffectiveSizeC() : getSizeC()) * 
     665          getSizeT(); 
    674666        int count = (int) Math.min(oldCount, nPlanes); 
    675667        for (int j=0; j<count; j++) { 
     
    715707 
    716708    // populate LogicalChannel element 
    717     for (int i=0; i<core.sizeC[0]; i++) { 
     709    for (int i=0; i<getSizeC(); i++) { 
    718710      if (i < emWaves.size()) { 
    719711        store.setLogicalChannelEmWave((Integer) emWaves.get(i), 0, i); 
     
    738730    } 
    739731    long range = end - start; 
    740     float msPerPlane = (float) range / core.imageCount[0]; 
     732    float msPerPlane = (float) range / getImageCount(); 
    741733 
    742734    int plane = 0; 
    743     for (int zi=0; zi<core.sizeZ[0]; zi++) { 
    744       for (int ti=0; ti<core.sizeT[0]; ti++) { 
    745         for (int ci=0; ci<core.sizeC[0]; ci++) { 
     735    for (int zi=0; zi<getSizeZ(); zi++) { 
     736      for (int ti=0; ti<getSizeT(); ti++) { 
     737        for (int ci=0; ci<getSizeC(); ci++) { 
    746738          store.setPlaneTheZ(new Integer(zi), 0, 0, plane); 
    747739          store.setPlaneTheC(new Integer(ci), 0, 0, plane); 
  • trunk/loci/formats/in/PictReader.java

    r4132 r4202  
    109109      in.read(pix); 
    110110      byte[][] b = ImageTools.getPixelBytes(ImageTools.makeBuffered( 
    111         qtTools.pictToImage(pix)), core.littleEndian[0]); 
     111        qtTools.pictToImage(pix)), isLittleEndian()); 
    112112      for (int i=0; i<b.length; i++) { 
    113113        System.arraycopy(b[i], 0, buf, i*b[i].length, b[i].length); 
     
    118118    // combine everything in the strips Vector 
    119119 
    120     if ((core.sizeY[0]*4 < strips.size()) && (((strips.size() / 3) % 
    121       core.sizeY[0]) != 0)) 
     120    if ((getSizeY()*4 < strips.size()) && (((strips.size() / 3) % 
     121      getSizeY()) != 0)) 
    122122    { 
    123123      core.sizeY[0] = strips.size(); 
    124124    } 
    125125 
    126     int plane = core.sizeX[0] * core.sizeY[0]; 
     126    int plane = getSizeX() * getSizeY(); 
    127127 
    128128    if (lookup != null) { 
     
    133133      plane *= 2; 
    134134 
    135       for (int i=0; i<core.sizeY[0]; i++) { 
     135      for (int i=0; i<getSizeY(); i++) { 
    136136        row = (byte[]) strips.get(i); 
    137137 
    138138        for (int j=0; j<row.length; j++) { 
    139           if (j < core.sizeX[0]) { 
     139          if (j < getSizeX()) { 
    140140            int ndx = row[j]; 
    141141            if (ndx < 0) ndx += lookup[0].length; 
    142142            ndx = ndx % lookup[0].length; 
    143143 
    144             int outIndex = i*core.sizeX[0]*2 + j*2; 
     144            int outIndex = i*getSizeX()*2 + j*2; 
    145145 
    146146            if (2*plane + outIndex + 2 < buf.length) { 
     
    156156      } 
    157157    } 
    158     else if (core.sizeY[0]*3 == strips.size() || 
    159       core.sizeY[0]*4 == strips.size()) 
    160     { 
     158    else if (getSizeY()*3 == strips.size() || getSizeY()*4 == strips.size()) { 
    161159      // 24 or 32 bit data 
    162160 
    163       int nc = strips.size() / core.sizeY[0]; 
    164  
    165       for (int i=0; i<core.sizeY[0]; i++) { 
     161      int nc = strips.size() / getSizeY(); 
     162 
     163      for (int i=0; i<getSizeY(); i++) { 
    166164        byte[] c0 = (byte[]) strips.get(i * nc + nc - 3); 
    167165        byte[] c1 = (byte[]) strips.get(i * nc + nc - 2); 
    168166        byte[] c2 = (byte[]) strips.get(i * nc + nc - 1); 
    169         int baseOffset = i * core.sizeX[0]; 
    170         System.arraycopy(c0, 0, buf, baseOffset, core.sizeX[0]); 
    171         System.arraycopy(c1, 0, buf, plane + baseOffset, core.sizeX[0]); 
    172         System.arraycopy(c2, 0, buf, 2*plane + baseOffset, core.sizeX[0]); 
     167        int baseOffset = i * getSizeX(); 
     168        System.arraycopy(c0, 0, buf, baseOffset, getSizeX()); 
     169        System.arraycopy(c1, 0, buf, plane + baseOffset, getSizeX()); 
     170        System.arraycopy(c2, 0, buf, 2*plane + baseOffset, getSizeX()); 
    173171      } 
    174172    } 
    175173    else { 
    176174      // RGB value is packed into a single short: xRRR RRGG GGGB BBBB 
    177       for (int i=0; i<core.sizeY[0]; i++) { 
     175      for (int i=0; i<getSizeY(); i++) { 
    178176        int[] row = (int[]) strips.get(i); 
    179177 
     
    280278    throws FormatException, IOException 
    281279  { 
    282     if (debug) debug("drivePictDecoder(" + opcode + ") @ " + in.getFilePointer()); 
     280    if (debug) { 
     281      debug("drivePictDecoder(" + opcode + ") @ " + in.getFilePointer()); 
     282    } 
    283283 
    284284    switch (opcode) { 
     
    352352      switch (pixelSize) { 
    353353        case 32: 
    354           rowBytes = core.sizeX[0] * compCount; 
     354          rowBytes = getSizeX() * compCount; 
    355355          break; 
    356356        case 16: 
    357           rowBytes = core.sizeX[0] * 2; 
     357          rowBytes = getSizeX() * 2; 
    358358          break; 
    359359        default: 
     
    408408    bufSize = rBytes; 
    409409 
    410     outBufSize = core.sizeX[0]; 
     410    outBufSize = getSizeX(); 
    411411 
    412412    // allocate buffers 
     
    414414    switch (pixelSize) { 
    415415      case 32: 
    416         if (!compressed) uBufI = new int[core.sizeX[0]]; 
     416        if (!compressed) uBufI = new int[getSizeX()]; 
    417417        else uBuf = new byte[bufSize]; 
    418418        break; 
    419419      case 16: 
    420         uBufI = new int[core.sizeX[0]]; 
     420        uBufI = new int[getSizeX()]; 
    421421        break; 
    422422      case 8: 
     
    434434      } 
    435435      buf = new byte[bufSize]; 
    436       for (int row=0; row<core.sizeY[0]; row++) { 
     436      for (int row=0; row<getSizeY(); row++) { 
    437437        in.read(buf, 0, rBytes); 
    438438 
    439439        switch (pixelSize) { 
    440440          case 16: 
    441             for (int i=0; i<core.sizeX[0]; i++) { 
     441            for (int i=0; i<getSizeX(); i++) { 
    442442              uBufI[i] = DataTools.bytesToShort(buf, i*2, 2, false); 
    443443            } 
     
    459459      } 
    460460      buf = new byte[bufSize + 1 + bufSize / 128]; 
    461       for (int row=0; row<core.sizeY[0]; row++) { 
     461      for (int row=0; row<getSizeY(); row++) { 
    462462        if (rBytes > 250) rawLen = in.readShort(); 
    463463        else rawLen = in.read(); 
     
    477477 
    478478        if (pixelSize == 16) { 
    479           uBufI = new int[core.sizeX[0]]; 
     479          uBufI = new int[getSizeX()]; 
    480480          unpackBits(buf, uBufI); 
    481481          strips.add(uBufI); 
     
    483483        else { 
    484484          PackbitsCodec c = new PackbitsCodec(); 
    485           uBuf = c.decompress(buf, new Integer(core.sizeX[0] * 4)); 
     485          uBuf = c.decompress(buf, new Integer(getSizeX() * 4)); 
    486486        } 
    487487 
     
    495495 
    496496          for (int q=0; q<compCount; q++) { 
    497             int offset = q * core.sizeX[0]; 
    498             int len = (int) Math.min(core.sizeX[0], uBuf.length - offset); 
    499             newBuf = new byte[core.sizeX[0]]; 
     497            int offset = q * getSizeX(); 
     498            int len = (int) Math.min(getSizeX(), uBuf.length - offset); 
     499            newBuf = new byte[getSizeX()]; 
    500500            if (offset < uBuf.length) { 
    501501              System.arraycopy(uBuf, offset, newBuf, 0, len); 
  • trunk/loci/formats/in/PrairieReader.java

    r4200 r4202  
    247247        core.sizeZ[0] = isZ ? zt : 1; 
    248248        core.sizeT[0] = isZ ? 1 : zt; 
    249         core.sizeC[0] = core.imageCount[0] / (core.sizeZ[0] * core.sizeT[0]); 
     249        core.sizeC[0] = getImageCount() / (getSizeZ() * getSizeT()); 
    250250        core.currentOrder[0] = "XYC" + (isZ ? "ZT" : "TZ"); 
    251251        core.pixelType[0] = FormatTools.UINT16; 
     
    263263        store.setDimensionsPhysicalSizeX(new Float(pixelSizeX), 0, 0); 
    264264        store.setDimensionsPhysicalSizeY(new Float(pixelSizeY), 0, 0); 
    265         for (int i=0; i<core.sizeC[0]; i++) { 
     265        for (int i=0; i<getSizeC(); i++) { 
    266266          String gain = (String) gains.get(i); 
    267267          String offset = (String) offsets.get(i); 
  • trunk/loci/formats/in/QTReader.java

    r4132 r4202  
    269269    // determine whether we need to strip out any padding bytes 
    270270 
    271     int pad = (4 - (core.sizeX[0] % 4)) % 4; 
     271    int pad = (4 - (getSizeX() % 4)) % 4; 
    272272    if (codec.equals("mjpb")) pad = 0; 
    273273 
    274     int size = core.sizeX[0] * core.sizeY[0]; 
     274    int size = getSizeX() * getSizeY(); 
    275275    if (size * (bitsPerPixel / 8) == prevPixels.length) pad = 0; 
    276276 
    277277    if (pad > 0) { 
    278       t = new byte[prevPixels.length - core.sizeY[0]*pad]; 
    279  
    280       for (int row=0; row<core.sizeY[0]; row++) { 
    281         System.arraycopy(prevPixels, row*(core.sizeX[0]+pad), t, 
    282           row*core.sizeX[0], core.sizeX[0]); 
    283       } 
    284     } 
    285  
    286     int bpp = FormatTools.getBytesPerPixel(core.pixelType[0]); 
    287     int srcRowLen = core.sizeX[0] * bpp * core.sizeC[0]; 
    288     int destRowLen = w * bpp * core.sizeC[0]; 
     278      t = new byte[prevPixels.length - getSizeY()*pad]; 
     279 
     280      for (int row=0; row<getSizeY(); row++) { 
     281        System.arraycopy(prevPixels, row*(getSizeX() + pad), t, 
     282          row*getSizeX(), getSizeX()); 
     283      } 
     284    } 
     285 
     286    int bpp = FormatTools.getBytesPerPixel(getPixelType()); 
     287    int srcRowLen = getSizeX() * bpp * getSizeC(); 
     288    int destRowLen = w * bpp * getSizeC(); 
    289289    for (int row=0; row<h; row++) { 
    290290      if (bitsPerPixel == 32) { 
    291291        for (int col=0; col<w; col++) { 
    292           System.arraycopy(t, row*core.sizeX[0]*bpp*4 + (x + col)*bpp*4 + 1, 
     292          System.arraycopy(t, row*getSizeX()*bpp*4 + (x + col)*bpp*4 + 1, 
    293293            buf, row*destRowLen + col*bpp*3, 3); 
    294294        } 
    295295      } 
    296296      else { 
    297         System.arraycopy(t, row*srcRowLen + x*bpp*core.sizeC[0], buf, 
     297        System.arraycopy(t, row*srcRowLen + x*bpp*getSizeC(), buf, 
    298298          row*destRowLen, destRowLen); 
    299299      } 
     
    353353 
    354354    core.imageCount[0] = offsets.size(); 
    355     if (chunkSizes.size() < core.imageCount[0] && chunkSizes.size() > 0) { 
     355    if (chunkSizes.size() < getImageCount() && chunkSizes.size() > 0) { 
    356356      core.imageCount[0] = chunkSizes.size(); 
    357357    } 
     
    430430 
    431431    core.rgb[0] = bitsPerPixel < 40; 
    432     core.sizeC[0] = core.rgb[0] ? 3 : 1; 
     432    core.sizeC[0] = isRGB() ? 3 : 1; 
    433433    core.interleaved[0] = bitsPerPixel == 32; 
    434     core.sizeT[0] = core.imageCount[0]; 
     434    core.sizeT[0] = getImageCount(); 
    435435 
    436436    // The metadata store we're working with. 
     
    508508          flip = matrix[0][0] == 0 && matrix[1][0] != 0; 
    509509 
    510           if (core.sizeX[0] == 0) core.sizeX[0] = in.readInt(); 
    511           if (core.sizeY[0] == 0) core.sizeY[0] = in.readInt(); 
     510          if (getSizeX() == 0) core.sizeX[0] = in.readInt(); 
     511          if (getSizeY() == 0) core.sizeY[0] = in.readInt(); 
    512512        } 
    513513        else if (atomType.equals("cmov")) { 
     
    548548          in.skipBytes(4); 
    549549          int numPlanes = in.readInt(); 
    550           if (numPlanes != core.imageCount[0]) { 
     550          if (numPlanes != getImageCount()) { 
    551551            in.seek(in.getFilePointer() - 4); 
    552552            int off = in.readInt(); 
    553553            offsets.add(new Integer(off)); 
    554             for (int i=1; i<core.imageCount[0]; i++) { 
     554            for (int i=1; i<getImageCount(); i++) { 
    555555              if ((chunkSizes.size() > 0) && (i < chunkSizes.size())) { 
    556556                rawSize = ((Integer) chunkSizes.get(i)).intValue(); 
    557557              } 
    558               else i = core.imageCount[0]; 
     558              else i = getImageCount(); 
    559559              off += rawSize; 
    560560              offsets.add(new Integer(off)); 
     
    612612          if (rawSize == 0) { 
    613613            in.seek(in.getFilePointer() - 4); 
    614             for (int b=0; b<core.imageCount[0]; b++) { 
     614            for (int b=0; b<getImageCount(); b++) { 
    615615              chunkSizes.add(new Integer(in.readInt())); 
    616616            } 
     
    678678    else if (code.equals("rle ")) { 
    679679      Object[] options = new Object[2]; 
    680       options[0] = new int[] {core.sizeX[0], core.sizeY[0], 
     680      options[0] = new int[] {getSizeX(), getSizeY(), 
    681681        bitsPerPixel < 40 ? bitsPerPixel / 8 : (bitsPerPixel - 32) / 8}; 
    682682      options[1] = canUsePrevious ? prevPixels : null; 
     
    684684    } 
    685685    else if (code.equals("rpza")) { 
    686       int[] options = new int[2]; 
    687       options[0] = core.sizeX[0]; 
    688       options[1] = core.sizeY[0]; 
     686      int[] options = new int[] {getSizeX(), getSizeY()}; 
    689687      return new RPZACodec().decompress(pixs, options); 
    690688    } 
    691689    else if (code.equals("mjpb")) { 
    692690      int[] options = new int[4]; 
    693       options[0] = core.sizeX[0]; 
    694       options[1] = core.sizeY[0]; 
     691      options[0] = getSizeX(); 
     692      options[1] = getSizeY(); 
    695693      options[2] = bitsPerPixel; 
    696694      options[3] = interlaced ? 1 : 0; 
     
    698696    } 
    699697    else if (code.equals("jpeg")) { 
    700       return new JPEGCodec().decompress(pixs, 
    701         new Boolean(core.littleEndian[0])); 
     698      return new JPEGCodec().decompress(pixs, new Boolean(isLittleEndian())); 
    702699    } 
    703700    else throw new FormatException("Unsupported codec : " + code); 
  • trunk/loci/formats/in/SDTReader.java

    r4132 r4202  
    131131    FormatTools.checkBufferSize(this, buf.length, w, h); 
    132132 
    133     int sizeX = core.sizeX[series]; 
    134     int sizeY = core.sizeY[series]; 
    135     int bpp = FormatTools.getBytesPerPixel(core.pixelType[series]); 
    136     boolean little = core.littleEndian[series]; 
     133    int sizeX = getSizeX(); 
     134    int sizeY = getSizeY(); 
     135    int bpp = FormatTools.getBytesPerPixel(getPixelType()); 
     136    boolean little = isLittleEndian(); 
    137137 
    138138    boolean direct = !intensity && x == 0 && y == 0 && w == sizeX && h == sizeY; 
  • trunk/loci/formats/in/SEQReader.java

    r4048 r4202  
    8181      } 
    8282 
    83       addMeta("Number of images", new Integer(core.sizeZ[0])); 
     83      addMeta("Number of images", new Integer(getSizeZ())); 
    8484    } 
    8585 
    86     if (core.sizeZ[0] == 0) core.sizeZ[0] = 1; 
    87     if (core.sizeT[0] == 0) core.sizeT[0] = 1; 
     86    if (getSizeZ() == 0) core.sizeZ[0] = 1; 
     87    if (getSizeT() == 0) core.sizeT[0] = 1; 
    8888 
    89     if (core.sizeZ[0] == 1 && core.sizeT[0] == 1) { 
     89    if (getSizeZ() == 1 && getSizeT() == 1) { 
    9090      core.sizeZ[0] = ifds.length; 
    9191    } 
    9292 
    9393    // default values 
    94     addMeta("frames", "" + core.sizeZ[0]); 
    95     addMeta("channels", "" + super.getSizeC()); 
    96     addMeta("slices", "" + core.sizeT[0]); 
     94    addMeta("frames", String.valueOf(getSizeZ())); 
     95    addMeta("channels", String.valueOf(super.getSizeC())); 
     96    addMeta("slices", String.valueOf(getSizeT())); 
    9797 
    9898    // parse the description to get channels, slices and times where applicable 
     
    112112    } 
    113113 
    114     if (isRGB() && core.sizeC[0] != 3) core.sizeC[0] *= 3; 
     114    if (isRGB() && getSizeC() != 3) core.sizeC[0] *= 3; 
    115115 
    116116    core.currentOrder[0] = "XY"; 
    117117 
    118118    int maxNdx = 0, max = 0; 
    119     int[] dims = {core.sizeZ[0], core.sizeC[0], core.sizeT[0]}; 
     119    int[] dims = {getSizeZ(), getSizeC(), getSizeT()}; 
    120120    String[] axes = {"Z", "C", "T"}; 
    121121 
     
    130130 
    131131    if (maxNdx != 1) { 
    132       if (core.sizeC[0] > 1) { 
     132      if (getSizeC() > 1) { 
    133133        core.currentOrder[0] += "C"; 
    134134        core.currentOrder[0] += (maxNdx == 0 ? axes[2] : axes[0]); 
     
    137137    } 
    138138    else { 
    139       if (core.sizeZ[0] > core.sizeT[0]) core.currentOrder[0] += "ZT"; 
     139      if (getSizeZ() > getSizeT()) core.currentOrder[0] += "ZT"; 
    140140      else core.currentOrder[0] += "TZ"; 
    141141    } 
  • trunk/loci/formats/in/SlidebookReader.java

    r4132 r4202  
    7474    FormatTools.checkBufferSize(this, buf.length, w, h); 
    7575 
    76     int plane = core.sizeX[series] * core.sizeY[series] * 2; 
    77  
     76    int plane = getSizeX() * getSizeY() * 2; 
    7877    long offset = ((Long) pixelOffsets.get(series)).longValue() + plane * no; 
    79     in.seek(offset + y * core.sizeX[series] * 2); 
    80  
    81     if (core.sizeX[series] == w) { 
    82       in.read(buf); 
    83     } 
    84     else { 
    85       for (int row=0; row<h; row++) { 
    86         in.skipBytes(x * 2); 
    87         in.read(buf, row * w * 2, w * 2); 
    88         in.skipBytes(2 * (core.sizeX[series] - w - x)); 
    89       } 
    90     } 
    91  
     78    in.seek(offset); 
     79 
     80    DataTools.readPlane(in, x, y, w, h, this, buf); 
    9281    return buf; 
    9382  } 
     
    137126    in.skipBytes(4); 
    138127    core.littleEndian[0] = in.read() == 0x49; 
    139     in.order(core.littleEndian[0]); 
     128    in.order(isLittleEndian()); 
    140129 
    141130    metadataOffsets = new Vector(); 
     
    296285        } 
    297286      } 
    298       boolean little = core.littleEndian[0]; 
     287      boolean little = isLittleEndian(); 
    299288      core = new CoreMetadata(pixelOffsets.size()); 
    300289      Arrays.fill(core.littleEndian, little); 
     
    405394 
    406395    for (int i=0; i<core.sizeX.length; i++) { 
     396      setSeries(i); 
    407397      long pixels = ((Long) pixelLengths.get(i)).longValue() / 2; 
    408398      boolean x = true; 
    409       while (core.sizeX[i] * core.sizeY[i] * core.sizeC[i] * core.sizeZ[i] > 
    410         pixels) 
    411       { 
     399      while (getSizeX() * getSizeY() * getSizeC() * getSizeZ() > pixels) { 
    412400        if (x) core.sizeX[i] /= 2; 
    413401        else core.sizeY[i] /= 2; 
    414402        x = !x; 
    415403      } 
    416       if (core.sizeZ[i] == 0) core.sizeZ[i] = 1; 
     404      if (getSizeZ() == 0) core.sizeZ[i] = 1; 
    417405      core.sizeT[i] = (int) (pixels / 
    418         (core.sizeX[i] * core.sizeY[i] * core.sizeZ[i] * core.sizeC[i])); 
    419       if (core.sizeT[i] == 0) core.sizeT[i] = 1; 
    420       core.imageCount[i] = core.sizeZ[i] * core.sizeT[i] * core.sizeC[i]; 
     406        (getSizeX() * getSizeY() * getSizeZ() * getSizeC())); 
     407      if (getSizeT() == 0) core.sizeT[i] = 1; 
     408      core.imageCount[i] = getSizeZ() * getSizeC() * getSizeT(); 
    421409      core.pixelType[i] = FormatTools.UINT16; 
    422410      core.currentOrder[i] = "XYZTC"; 
     
    425413      core.metadataComplete[i] = true; 
    426414    } 
     415    setSeries(0); 
    427416 
    428417    MetadataStore store = 
  • trunk/loci/formats/in/TCSReader.java

    r4132 r4202  
    193193    if (checkSuffix(id, XML_SUFFIX)) { 
    194194      in = new RandomAccessStream(id); 
    195       xcal = new Vector(); 
    196       ycal = new Vector(); 
    197       zcal = new Vector(); 
    198       seriesNames = new Vector(); 
    199       containerNames = new Vector(); 
    200       containerCounts = new Vector(); 
    201       x = new Vector(); 
    202       y = new Vector(); 
    203       z = new Vector(); 
    204       c = new Vector(); 
    205       t = new Vector(); 
    206       bits = new Vector(); 
    207195 
    208196      // parse XML metadata 
    209197 
    210       TCSHandler handler = new TCSHandler(); 
     198      LeicaHandler handler = new LeicaHandler(); 
    211199      String prefix = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><LEICA>"; 
    212200      String suffix = "</LEICA>"; 
     
    230218        throw new FormatException(exc); 
    231219      } 
     220 
     221      xcal = handler.getXCal(); 
     222      ycal = handler.getYCal(); 
     223      zcal = handler.getZCal(); 
     224      seriesNames = handler.getSeriesNames(); 
     225      containerNames = handler.getContainerNames(); 
     226      containerCounts = handler.getContainerCounts(); 
     227      x = handler.getWidths(); 
     228      y = handler.getHeights(); 
     229      z = handler.getZs(); 
     230      c = handler.getChannels(); 
     231      t = handler.getTs(); 
     232      bits = handler.getBits(); 
     233      metadata = handler.getMetadata(); 
    232234 
    233235      // look for associated TIFF files 
     
    289291      } 
    290292      Arrays.fill(core.currentOrder, 
    291         core.sizeZ[0] > core.sizeT[0] ? "XYCZT" : "XYCTZ"); 
     293        getSizeZ() > getSizeT() ? "XYCZT" : "XYCTZ"); 
    292294      Arrays.fill(core.metadataComplete, true); 
    293295      Arrays.fill(core.rgb, false); 
     
    356358 
    357359      core.sizeT[0] = 0; 
    358       core.currentOrder[0] = core.rgb[0] ? "XYC" : "XY"; 
     360      core.currentOrder[0] = isRGB() ? "XYC" : "XY"; 
    359361 
    360362      // determine the axis sizes and ordering 
     
    369371        if (unique) { 
    370372          core.sizeT[0]++; 
    371           if (core.currentOrder[0].indexOf("T") < 0) { 
     373          if (getDimensionOrder().indexOf("T") < 0) { 
    372374            core.currentOrder[0] += "T"; 
    373375          } 
    374376        } 
    375377        else if (i > 0) { 
    376           if ((ch[i] != ch[i - 1]) && core.currentOrder[0].indexOf("C") < 0) { 
     378          if ((ch[i] != ch[i - 1]) && getDimensionOrder().indexOf("C") < 0) { 
    377379            core.currentOrder[0] += "C"; 
    378380          } 
    379           else if (core.currentOrder[0].indexOf("Z") < 0) { 
     381          else if (getDimensionOrder().indexOf("Z") < 0) { 
    380382            core.currentOrder[0] += "Z"; 
    381383          } 
     
    384386      } 
    385387 
    386       if (core.currentOrder[0].indexOf("Z") < 0) core.currentOrder[0] += "Z"; 
    387       if (core.currentOrder[0].indexOf("C") < 0) core.currentOrder[0] += "C"; 
    388       if (core.currentOrder[0].indexOf("T") < 0) core.currentOrder[0] += "T"; 
    389  
    390       if (core.sizeT[0] == 0) core.sizeT[0] = 1; 
     388      if (getDimensionOrder().indexOf("Z") < 0) core.currentOrder[0] += "Z"; 
     389      if (getDimensionOrder().indexOf("C") < 0) core.currentOrder[0] += "C"; 
     390      if (getDimensionOrder().indexOf("T") < 0) core.currentOrder[0] += "T"; 
     391 
     392      if (getSizeT() == 0) core.sizeT[0] = 1; 
    391393      if (channelCount == 0) channelCount = 1; 
    392       core.sizeZ[0] = ifds.length / (core.sizeT[0] * channelCount); 
     394      core.sizeZ[0] = ifds.length / (getSizeT() * channelCount); 
    393395      core.sizeC[0] *= channelCount; 
    394       core.imageCount[0] = core.sizeZ[0] * core.sizeT[0] * channelCount; 
     396      core.imageCount[0] = getSizeZ() * getSizeT() * channelCount; 
    395397 
    396398      // cut up comment 
     
    435437  } 
    436438 
    437   // -- Helper classes -- 
    438  
    439   /** SAX handler for parsing XML. */ 
    440   class TCSHandler extends DefaultHandler { 
    441     private String series = "", fullSeries = ""; 
    442     private int count = 0; 
    443     private boolean firstElement = true; 
    444  
    445     public void startElement(String uri, String localName, String qName, 
    446       Attributes attributes) 
    447     { 
    448       if (qName.equals("Element")) { 
    449         if (!attributes.getValue("Name").equals("DCROISet") && !firstElement) { 
    450           series = attributes.getValue("Name"); 
    451           containerNames.add(series); 
    452           if (fullSeries == null || fullSeries.equals("")) fullSeries = series; 
    453           else fullSeries = "/" + series; 
    454         } 
    455         else if (firstElement) firstElement = false; 
    456       } 
    457       else if (qName.equals("Experiment")) { 
    458         for (int i=0; i<attributes.getLength(); i++) { 
    459           addMeta(attributes.getQName(i), attributes.getValue(i)); 
    460         } 
    461       } 
    462       else if (qName.equals("Image")) { 
    463         containerNames.remove(series); 
    464         if (containerCounts.size() < containerNames.size()) { 
    465           containerCounts.add(new Integer(1)); 
    466         } 
    467         else if (containerCounts.size() > 0) { 
    468           int ndx = containerCounts.size() - 1; 
    469           int n = ((Integer) containerCounts.get(ndx)).intValue(); 
    470           containerCounts.setElementAt(new Integer(n + 1), ndx); 
    471         } 
    472         if (fullSeries == null || fullSeries.equals("")) fullSeries = series; 
    473         seriesNames.add(fullSeries); 
    474       } 
    475       else if (qName.equals("ChannelDescription")) { 
    476         String prefix = "Channel " + count + " - "; 
    477         if (fullSeries != null && !fullSeries.equals("")) { 
    478           prefix = fullSeries + " - " + prefix; 
    479         } 
    480         for (int i=0; i<attributes.getLength(); i++) { 
    481           addMeta(prefix + attributes.getQName(i), attributes.getValue(i)); 
    482         } 
    483         count++; 
    484         if (c.size() > seriesNames.size() - 1) { 
    485           c.setElementAt(new Integer(count), seriesNames.size() - 1); 
    486         } 
    487         else c.add(new Integer(count)); 
    488       } 
    489       else if (qName.equals("DimensionDescription")) { 
    490         String prefix = "Dimension " + count + " - "; 
    491         if (fullSeries != null && !fullSeries.equals("")) { 
    492           prefix = fullSeries + " - " + prefix; 
    493         } 
    494         for (int i=0; i<attributes.getLength(); i++) { 
    495           addMeta(prefix + attributes.getQName(i), attributes.getValue(i)); 
    496         } 
    497         int len = Integer.parseInt(attributes.getValue("NumberOfElements")); 
    498         int id = Integer.parseInt(attributes.getValue("DimID")); 
    499         float size = Float.parseFloat(attributes.getValue("Length")); 
    500         if (size < 0) size *= -1; 
    501  
    502         switch (id) { 
    503           case 1: 
    504             x.add(new Integer(len)); 
    505             xcal.add(new Float((size * 1000000) / len)); 
    506             int b = Integer.parseInt(attributes.getValue("BytesInc")); 
    507             bits.add(new Integer(b * 8)); 
    508             break; 
    509           case 2: 
    510             y.add(new Integer(len)); 
    511             ycal.add(new Float((size * 1000000) / len)); 
    512             break; 
    513           case 3: 
    514             z.add(new Integer(len)); 
    515             zcal.add(new Float((size * 1000000) / len)); 
    516             break; 
    517           default: 
    518             t.add(new Integer(len)); 
    519             break; 
    520         } 
    521       } 
    522       else if (qName.equals("ScannerSettingRecord")) { 
    523         String key = attributes.getValue("Identifier") + " - " + 
    524           attributes.getValue("Description"); 
    525         if (fullSeries != null && !fullSeries.equals("")) { 
    526           key = fullSeries + " - " + key; 
    527         } 
    528         addMeta(key, attributes.getValue("Variant")); 
    529       } 
    530       else if (qName.equals("FilterSettingRecord")) { 
    531         String key = attributes.getValue("ObjectName") + " - " + 
    532           attributes.getValue("Description") + " - " + 
    533           attributes.getValue("Attribute"); 
    534         for (int i=0; i<attributes.getLength(); i++) { 
    535           addMeta(key + " - " + attributes.getQName(i), 
    536             attributes.getValue(i)); 
    537         } 
    538       } 
    539       else if (qName.equals("ATLConfocalSettingDefinition")) { 
    540         if (fullSeries.endsWith("Master sequential setting")) { 
    541           fullSeries = fullSeries.replaceAll("Master sequential setting", 
    542             "Sequential Setting 0"); 
    543         } 
    544  
    545         if (fullSeries.indexOf("Sequential Setting ") == -1) { 
    546           if (fullSeries.equals("")) fullSeries = "Master sequential setting"; 
    547           else fullSeries += " - Master sequential setting"; 
    548         } 
    549         else { 
    550           int ndx = fullSeries.indexOf("Sequential Setting ") + 19; 
    551           int n = Integer.parseInt(fullSeries.substring(ndx)) + 1; 
    552           fullSeries = fullSeries.substring(0, ndx) + String.valueOf(n); 
    553         } 
    554         String prefix = ""; 
    555         if (fullSeries != null && !fullSeries.equals("")) { 
    556           prefix = fullSeries + " - "; 
    557         } 
    558         for (int i=0; i<attributes.getLength(); i++) { 
    559           addMeta(prefix + attributes.getQName(i), attributes.getValue(i)); 
    560         } 
    561       } 
    562       else if (qName.equals("Wheel")) { 
    563         String prefix = "Wheel " + count + " - "; 
    564         if (fullSeries != null && !fullSeries.equals("")) { 
    565           prefix = fullSeries + " - " + prefix; 
    566         } 
    567         for (int i=0; i<attributes.getLength(); i++) { 
    568           addMeta(prefix + attributes.getQName(i), attributes.getValue(i)); 
    569         } 
    570         count++; 
    571       } 
    572       else if (qName.equals("WheelName")) { 
    573         String prefix = "Wheel " + (count - 1) + " - WheelName "; 
    574         if (fullSeries != null && !fullSeries.equals("")) { 
    575           prefix = fullSeries + " - " + prefix; 
    576         } 
    577         int ndx = 0; 
    578         while (getMeta(prefix + ndx) != null) ndx++; 
    579         addMeta(prefix + ndx, attributes.getValue("FilterName")); 
    580       } 
    581       else if (qName.equals("MultiBand")) { 
    582         String prefix = "MultiBand Channel " + attributes.getValue("Channel"); 
    583         if (fullSeries != null && !fullSeries.equals("")) { 
    584           prefix = fullSeries + " - " + prefix; 
    585         } 
    586         for (int i=0; i<attributes.getLength(); i++) { 
    587           addMeta(prefix + " - " + attributes.getQName(i), 
    588             attributes.getValue(i)); 
    589         } 
    590       } 
    591       else if (qName.equals("LaserLineSetting")) { 
    592         String prefix = "LaserLine " + attributes.getValue("LaserLine"); 
    593         if (fullSeries != null && !fullSeries.equals("")) { 
    594           prefix = fullSeries + " - " + prefix; 
    595         } 
    596         for (int i=0; i<attributes.getLength(); i++) { 
    597           addMeta(prefix + " - " + attributes.getQName(i), 
    598             attributes.getValue(i)); 
    599         } 
    600       } 
    601       else if (qName.equals("Detector")) { 
    602         String prefix = "Detector Channel " + attributes.getValue("Channel"); 
    603         if (fullSeries != null && !fullSeries.equals("")) { 
    604           prefix = fullSeries + " - " + prefix; 
    605         } 
    606         for (int i=0; i<attributes.getLength(); i++) { 
    607           addMeta(prefix + " - " + attributes.getQName(i), 
    608             attributes.getValue(i)); 
    609         } 
    610       } 
    611       else if (qName.equals("Laser")) { 
    612         String prefix = "Laser " + attributes.getValue("LaserName"); 
    613         if (fullSeries != null && !fullSeries.equals("")) { 
    614           prefix = fullSeries + " - " + prefix; 
    615         } 
    616         for (int i=0; i<attributes.getLength(); i++) { 
    617           addMeta(prefix + " - " + attributes.getQName(i), 
    618             attributes.getValue(i)); 
    619         } 
    620       } 
    621       else if (qName.equals("TimeStamp")) { 
    622         long high = Long.parseLong(attributes.getValue("HighInteger")); 
    623         long low = Long.parseLong(attributes.getValue("LowInteger")); 
    624  
    625         high <<= 32; 
    626         if ((int) low < 0) { 
    627           low &= 0xffffffffL; 
    628         } 
    629         long stamp = high + low; 
    630         long ms = stamp / 10000; 
    631  
    632         String n = String.valueOf(count); 
    633         while (n.length() < 4) n = "0" + n; 
    634         addMeta(fullSeries + " - TimeStamp " + n, 
    635           DataTools.convertDate(ms, DataTools.COBOL)); 
    636         count++; 
    637       } 
    638       else if (qName.equals("ChannelScalingInfo")) { 
    639         String prefix = "ChannelScalingInfo " + count; 
    640         if (fullSeries != null && !fullSeries.equals("")) { 
    641           prefix = fullSeries + " - " + prefix; 
    642         } 
    643         for (int i=0; i<attributes.getLength(); i++) { 
    644           addMeta(prefix + " - " + attributes.getQName(i), 
    645             attributes.getValue(i)); 
    646         } 
    647       } 
    648       else if (qName.equals("RelTimeStamp")) { 
    649         addMeta(fullSeries + " RelTimeStamp " + attributes.getValue("Frame"), 
    650           attributes.getValue("Time")); 
    651       } 
    652       else count = 0; 
    653     } 
    654   } 
    655  
    656439} 
  • trunk/loci/formats/in/TiffReader.java

    r4181 r4202  
    4343  // -- Constants -- 
    4444 
    45   public static final String[] TIFF_SUFFIXES = {"tif", "tiff", "tf2", "tf8", "btf"}; 
     45  public static final String[] TIFF_SUFFIXES = 
     46    {"tif", "tiff", "tf2", "tf8", "btf"}; 
    4647 
    4748  // -- Constructor -- 
     
    4950  /** Constructs a new Tiff reader. */ 
    5051  public TiffReader() { 
    51     super("Tagged Image File Format", 
    52       new String[] {"tif", "tiff", "tf2", "tf8", "btf"}); 
    53   } 
    54  
    55   // -- Internal TiffReader API methods -- 
    56  
    57   /** 
    58    * Allows a class which is delegating parsing responsibility to 
    59    * <code>TiffReader</code> the ability to affect the <code>sizeZ</code> value 
    60    * that is inserted into the metadata store. 
    61    * @param zSize the number of optical sections to use when making a call to 
    62    * {@link loci.formats.meta.MetadataStore#setPixelsSizeZ(Integer, int, int)}. 
    63    */ 
    64   protected void setSizeZ(int zSize) { 
    65     if (core.sizeZ == null) core.sizeZ = new int[1]; 
    66     core.sizeZ[0] = zSize; 
     52    super("Tagged Image File Format", TIFF_SUFFIXES); 
    6753  } 
    6854 
     
    9278      while (st.hasMoreTokens()) { 
    9379        String token = st.nextToken(); 
     80        int value = 0; 
     81        if (token.indexOf("=") != -1) { 
     82          value = Integer.parseInt(token.substring(token.indexOf("=" + 1))); 
     83        } 
     84 
    9485        if (token.startsWith("channels=")) { 
    95           core.sizeC[0] = 
    96             Integer.parseInt(token.substring(token.indexOf("=") + 1)); 
     86          core.sizeC[0] = value; 
    9787        } 
    9888        else if (token.startsWith("slices=")) { 
    99           core.sizeZ[0] = 
    100             Integer.parseInt(token.substring(token.indexOf("=") + 1)); 
     89          core.sizeZ[0] = value; 
    10190        } 
    10291        else if (token.startsWith("frames=")) { 
    103           core.sizeT[0] = 
    104             Integer.parseInt(token.substring(token.indexOf("=") + 1)); 
     92          core.sizeT[0] = value; 
    10593        } 
    10694      } 
    107       if (core.sizeZ[0] * core.sizeT[0] * core.sizeC[0] == core.sizeC[0]) { 
    108         core.sizeT[0] = core.imageCount[0]; 
     95      if (getSizeZ() * getSizeT() * getSizeC() == getSizeC()) { 
     96        core.sizeT[0] = getImageCount(); 
    10997      } 
    11098      core.currentOrder[0] = "XYCZT"; 
  • trunk/loci/formats/in/VisitechReader.java

    r4132 r4202  
    7676    FormatTools.checkBufferSize(this, buf.length, w, h); 
    7777 
    78     int bpp = FormatTools.getBytesPerPixel(core.pixelType[series]); 
    79     int plane = core.sizeX[series] * core.sizeY[series] * bpp; 
    80  
    81     int div = core.sizeZ[series] * core.sizeT[series]; 
    82     int fileIndex = (series * core.sizeC[series]) + no / div; 
     78    int bpp = FormatTools.getBytesPerPixel(getPixelType()); 
     79    int plane = getSizeX() * getSizeY() * bpp; 
     80 
     81    int div = getSizeZ() * getSizeT(); 
     82    int fileIndex = (series * getSizeC()) + no / div; 
    8383    int planeIndex = no % div; 
    8484 
     
    9494    } 
    9595 
    96     s.skipBytes(y * core.sizeX[series] * bpp); 
    97     for (int row=0; row<h; row++) { 
    98       s.skipBytes(x * bpp); 
    99       s.read(buf, row * w * bpp, w * bpp); 
    100       s.skipBytes(bpp * (core.sizeX[series] - w - x)); 
    101     } 
    102  
     96    DataTools.readPlane(s, x, y, w, h, this, buf); 
    10397    s.close(); 
    10498    return buf; 
     
    177171                core.pixelType[0] = FormatTools.UINT32; 
    178172                break; 
    179               default: core.pixelType[0] = FormatTools.UINT8; 
     173              default: 
     174                core.pixelType[0] = FormatTools.UINT8; 
    180175            } 
    181176          } 
     
    208203    } 
    209204 
    210     if (core.sizeT[0] == 0) { 
    211       core.sizeT[0] = core.imageCount[0] / (core.sizeZ[0] * core.sizeC[0]); 
    212       if (core.sizeT[0] == 0) core.sizeT[0] = 1; 
    213     } 
    214     if (core.imageCount[0] == 0) { 
    215       core.imageCount[0] = core.sizeZ[0] * core.sizeC[0] * core.sizeT[0]; 
     205    if (getSizeT() == 0) { 
     206      core.sizeT[0] = getImageCount() / (getSizeZ() * getSizeC()); 
     207      if (getSizeT() == 0) core.sizeT[0] = 1; 
     208    } 
     209    if (getImageCount() == 0) { 
     210      core.imageCount[0] = getSizeZ() * getSizeC() * getSizeT(); 
    216211    } 
    217212 
    218213    if (numSeries > 1) { 
    219       int x = core.sizeX[0]; 
    220       int y = core.sizeY[0]; 
    221       int z = core.sizeZ[0]; 
    222       int c = core.sizeC[0] / numSeries; 
    223       int t = core.sizeT[0]; 
     214      int x = getSizeX(); 
     215      int y = getSizeY(); 
     216      int z = getSizeZ(); 
     217      int c = getSizeC() / numSeries; 
     218      int t = getSizeT(); 
    224219      int count = z * c * t; 
    225       int ptype = core.pixelType[0]; 
     220      int ptype = getPixelType(); 
    226221      core = new CoreMetadata(numSeries); 
    227222      Arrays.fill(core.sizeX, x); 
     
    250245 
    251246    File f = new File(currentId).getAbsoluteFile(); 
     247    String file = f.exists() ? f.getParent() + File.separator : ""; 
    252248 
    253249    if (numSeries == 0) numSeries = 1; 
    254     for (int i=0; i<core.sizeC[0]*numSeries; i++) { 
    255       files.add((f.exists() ? f.getParent() + File.separator : "") + base + 
    256         " " + (i + 1) + ".xys"); 
     250    for (int i=0; i<getSizeC()*numSeries; i++) { 
     251      files.add(file + base + " " + (i + 1) + ".xys"); 
    257252    } 
    258253    files.add(currentId); 
  • trunk/loci/formats/in/ZeissLSMReader.java

    r4177 r4202  
    143143  public byte[][] get8BitLookupTable() throws FormatException, IOException { 
    144144    FormatTools.assertId(currentId, true, 1); 
    145     if (lut == null || core.pixelType[0] != FormatTools.UINT8) return null; 
     145    if (lut == null || getPixelType() != FormatTools.UINT8) return null; 
    146146    byte[][] b = new byte[3][256]; 
    147147    for (int i=2; i>=3-validChannels; i--) { 
     
    156156  public short[][] get16BitLookupTable() throws FormatException, IOException { 
    157157    FormatTools.assertId(currentId, true, 1); 
    158     if (lut == null || core.pixelType[0] != FormatTools.UINT16) return null; 
     158    if (lut == null || getPixelType() != FormatTools.UINT16) return null; 
    159159    short[][] s = new short[3][65536]; 
    160160    for (int i=2; i>=3-validChannels; i--) { 
     
    165165    return s; 
    166166  } 
    167  
    168   /** 
    169    * @see loci.formats.IFormatReader#openBytes(int, byte[], int, int, int, int) 
    170    */ 
    171   public byte[] openBytes(int no, byte[] buf, int x, int y, int w, int h) 
    172     throws FormatException, IOException 
    173   { 
    174     FormatTools.assertId(currentId, true, 1); 
    175     FormatTools.checkPlaneNumber(this, no); 
    176     FormatTools.checkBufferSize(this, buf.length, w, h); 
    177  
    178     TiffTools.getSamples(ifds[no], in, buf, x, y, w, h); 
    179     return buf; 
    180   } 
    181  
    182167 
    183168  // -- Internal BaseTiffReader API methods -- 
     
    205190 
    206191      RandomAccessStream ras = new RandomAccessStream(cz); 
    207       ras.order(core.littleEndian[0]); 
     192      ras.order(isLittleEndian()); 
    208193 
    209194      put("MagicNumber", ras.readInt()); 
     
    302287 
    303288      int spectralScan = ras.readShort(); 
    304       switch (spectralScan) { 
    305         case 1: 
    306           put("SpectralScan", "acquired with spectral scan"); 
    307           break; 
    308         default: 
    309           put("SpectralScan", "no spectral scan"); 
    310       } 
     289      if (spectralScan != 1) put("SpectralScan", "no spectral scan"); 
     290      else put("SpectralScan", "acquired with spectral scan"); 
    311291 
    312292      int type = ras.readInt(); 
     
    363343 
    364344      core.indexed[0] = lut != null && getSizeC() == 1; 
    365       if (core.indexed[0]) { 
     345      if (isIndexed()) { 
    366346        core.sizeC[0] = 1; 
    367347        core.rgb[0] = false; 
    368348      } 
    369       if (core.sizeC[0] == 0) core.sizeC[0] = 1; 
    370  
    371       if (core.rgb[0]) { 
     349      if (getSizeC() == 0) core.sizeC[0] = 1; 
     350 
     351      if (isRGB()) { 
    372352        // shuffle C to front of order string 
    373         core.currentOrder[0] = core.currentOrder[0].replaceAll("C", ""); 
    374         core.currentOrder[0] = core.currentOrder[0].replaceAll("XY", "XYC"); 
    375       } 
    376  
    377       put("DimensionZ", core.sizeZ[0]); 
    378       put("DimensionChannels", core.sizeC[0]); 
     353        core.currentOrder[0] = getDimensionOrder().replaceAll("C", ""); 
     354        core.currentOrder[0] = getDimensionOrder().replaceAll("XY", "XYC"); 
     355      } 
     356 
     357      put("DimensionZ", getSizeZ()); 
     358      put("DimensionChannels", getSizeC()); 
    379359 
    380360      if (channelColorsOffset != 0) { 
     
    387367          in.skipBytes(namesOffset - 16); 
    388368 
    389           for (int i=0; i<core.sizeC[0]; i++) { 
     369          for (int i=0; i<getSizeC(); i++) { 
    390370            if (in.getFilePointer() >= in.length() - 1) break; 
    391371            // we want to read until we find a null char 
     
    399379        if ((timeStampOffset % 2) == 1) in.seek(timeStampOffset + 7); 
    400380        else in.seek(timeStampOffset - 248); 
    401         for (int i=0; i<core.sizeT[0]; i++) { 
     381        for (int i=0; i<getSizeT(); i++) { 
    402382          double stamp = in.readDouble(); 
    403383          put("TimeStamp" + i, stamp); 
     
    445425 
    446426        boolean done = false; 
    447         int nextLaserMedium = 0, nextLaserType = 0, nextGain = 0, 
    448           nextPinhole = 0, nextEmWave = 0, nextExWave = 0, nextChannelName = 0; 
     427        int nextLaserMedium = 0, nextLaserType = 0, nextGain = 0; 
     428        int nextPinhole = 0, nextEmWave = 0, nextExWave = 0; 
     429        int nextChannelName = 0; 
     430 
    449431        while (!done) { 
    450432          int entry = in.readInt(); 
     
    591573            case CHANNEL_ENTRY_PINHOLE_DIAMETER: 
    592574              int n = (int) Float.parseFloat(value.toString()); 
    593               if (n > 0 && nextPinhole < core.sizeC[0]) { 
     575              if (n > 0 && nextPinhole < getSizeC()) { 
    594576                store.setLogicalChannelPinholeSize(new Integer(n), 0, 
    595577                  nextPinhole++); 
     
    599581              n = (int) Float.parseFloat(value.toString()); 
    600582              store.setLogicalChannelEmWave(new Integer(n), 0, 
    601                 (nextEmWave % core.sizeC[0])); 
     583                (nextEmWave % getSizeC())); 
    602584              nextEmWave++; 
    603585              break; 
     
    605587              n = (int) Float.parseFloat(value.toString()); 
    606588              store.setLogicalChannelExWave(new Integer(n), 0, 
    607                 (nextExWave % core.sizeC[0])); 
     589                (nextExWave % getSizeC())); 
    608590              nextExWave++; 
    609591              break; 
     
    611593              n = (int) Float.parseFloat(value.toString()); 
    612594              store.setLogicalChannelEmWave(new Integer(n), 0, 
    613                 (nextEmWave % core.sizeC[0])); 
     595                (nextEmWave % getSizeC())); 
    614596              store.setLogicalChannelExWave(new Integer(n), 0, 
    615                 (nextExWave % core.sizeC[0])); 
     597                (nextExWave % getSizeC())); 
    616598              nextEmWave++; 
    617599              nextExWave++; 
     
    642624    } 
    643625 
    644     if (core.indexed[0]) core.rgb[0] = false; 
    645     core.imageCount[0] = core.sizeZ[0] * core.sizeT[0] * 
    646       ((core.rgb[0] || core.indexed[0]) ? 1 : core.sizeC[0]); 
    647  
    648     if (core.imageCount[0] != ifds.length) { 
    649       int diff = core.imageCount[0] - ifds.length; 
     626    if (isIndexed()) core.rgb[0] = false; 
     627    core.imageCount[0] = getSizeZ() * getSizeT() * getEffectiveSizeC(); 
     628 
     629    if (getImageCount() != ifds.length) { 
     630      int diff = getImageCount() - ifds.length; 
    650631      core.imageCount[0] = ifds.length; 
    651       if (diff % core.sizeZ[0] == 0) { 
    652         core.sizeT[0] -= (diff / core.sizeZ[0]); 
    653       } 
    654       else if (diff % core.sizeT[0] == 0) { 
    655         core.sizeZ[0] -= (diff / core.sizeT[0]); 
    656       } 
    657       else if (core.sizeZ[0] > 1) { 
     632      if (diff % getSizeZ() == 0) { 
     633        core.sizeT[0] -= (diff / getSizeZ()); 
     634      } 
     635      else if (diff % getSizeT() == 0) { 
     636        core.sizeZ[0] -= (diff / getSizeT()); 
     637      } 
     638      else if (getSizeZ() > 1) { 
    658639        core.sizeZ[0] = ifds.length; 
    659640        core.sizeT[0] = 1; 
    660641      } 
    661       else if (core.sizeT[0] > 1) { 
     642      else if (getSizeT() > 1) { 
    662643        core.sizeT[0] = ifds.length; 
    663644        core.sizeZ[0] = 1; 
     
    678659      timestamps.size() == 0 ? 0f : ((Double) timestamps.get(0)).floatValue(); 
    679660 
    680     for (int i=0; i<core.imageCount[0]; i++) { 
     661    for (int i=0; i<getImageCount(); i++) { 
    681662      int[] zct = FormatTools.getZCTCoords(this, i); 
    682663      store.setPlaneTheZ(new Integer(zct[0]), 0, 0, i); 
     
    687668        float thisStamp = ((Double) timestamps.get(zct[2])).floatValue(); 
    688669        store.setPlaneTimingDeltaT(new Float(thisStamp - firstStamp), 0, 0, i); 
    689         float nextStamp = i < core.sizeT[0] - 1 ? 
     670        float nextStamp = i < getSizeT() - 1 ? 
    690671          ((Double) timestamps.get(zct[2] + 1)).floatValue() : thisStamp; 
    691         if (i == core.sizeT[0] - 1 && zct[2] > 0) { 
     672        if (i == getSizeT() - 1 && zct[2] > 0) { 
    692673          thisStamp = ((Double) timestamps.get(zct[2] - 1)).floatValue(); 
    693674        } 
     
    768749 
    769750    initMetadata(); 
    770     core.littleEndian[0] = !core.littleEndian[0]; 
     751    core.littleEndian[0] = !isLittleEndian(); 
    771752  } 
    772753 
  • trunk/loci/formats/in/ZeissZVIReader.java

    r4132 r4202  
    104104    FormatTools.checkBufferSize(this, buf.length, w, h); 
    105105 
    106     int bytes = FormatTools.getBytesPerPixel(core.pixelType[0]); 
     106    int bytes = FormatTools.getBytesPerPixel(getPixelType()); 
    107107 
    108108    if (tileRows * tileColumns == 0 || tileWidth * tileHeight == 0) { 
    109       RandomAccessStream s = 
    110         poi.getDocumentStream((String) imageFiles.get(no)); 
     109      RandomAccessStream s = poi.getDocumentStream((String) imageFiles.get(no)); 
    111110      s.seek(((Integer) offsets.get(new Integer(no))).intValue()); 
    112111 
     
    117116        s.read(t); 
    118117        t = new JPEGCodec().decompress(t, new Object[] { 
    119           new Boolean(core.littleEndian[0]), new Boolean(core.interleaved[0])}); 
    120  
    121         int row = core.sizeX[0] * bytes * getRGBChannelCount(); 
     118          new Boolean(isLittleEndian()), new Boolean(isInterleaved())}); 
     119 
     120        int row = getSizeX() * bytes * getRGBChannelCount(); 
    122121 
    123122        for (int yy=0; yy<h; yy++) { 
     
    127126      } 
    128127      else { 
    129         s.skipBytes(y * core.sizeX[0] * bytes * getRGBChannelCount()); 
    130  
    131         for (int yy=0; yy<h; yy++) { 
    132           s.skipBytes(x * bytes * getRGBChannelCount()); 
    133           s.read(buf, yy * len, len); 
    134           s.skipBytes(bytes * getRGBChannelCount() * (core.sizeX[0] - w - x)); 
    135         } 
     128        DataTools.readPlane(s, x, y, w, h, this, buf); 
    136129      } 
    137130      s.close(); 
     
    166159                tileHeight - tileY : y + h - rowIndex - tileY; 
    167160 
    168               int count = core.sizeZ[0] * core.sizeT[0]; 
    169               count *= core.sizeC[0]; 
     161              int count = getSizeZ() * getSizeT() * getSizeC(); 
    170162              int ii = no + (row*tileColumns + col)*count; 
    171163              if ((row % 2) == 1) { 
     
    180172              if (isJPEG) { 
    181173                tile = new JPEGCodec().decompress(tile, 
    182                   new Object[] {new Boolean(core.littleEndian[0]), 
    183                   new Boolean(core.interleaved[0])}); 
     174                  new Object[] {new Boolean(isLittleEndian()), 
     175                  new Boolean(isInterleaved())}); 
    184176              } 
    185177              s.close(); 
     
    325317 
    326318          int tw = s.readInt(); 
    327           if (core.sizeX[0] == 0 || (tw < core.sizeX[0] && tw > 0)) { 
     319          if (getSizeX() == 0 || (tw < getSizeX() && tw > 0)) { 
    328320            core.sizeX[0] = tw; 
    329321          } 
    330322          s.skipBytes(2); 
    331323          int th = s.readInt(); 
    332           if (core.sizeY[0] == 0 || (th < core.sizeY[0] && th > 0)) { 
     324          if (getSizeY() == 0 || (th < getSizeY() && th > 0)) { 
    333325            core.sizeY[0] = th; 
    334326          } 
     
    367359          s.seek(old + len + 4); 
    368360 
    369           boolean foundWidth = s.readInt() == core.sizeX[0]; 
    370           boolean foundHeight = s.readInt() == core.sizeY[0]; 
     361          boolean foundWidth = s.readInt() == getSizeX(); 
     362          boolean foundHeight = s.readInt() == getSizeY(); 
    371363          boolean findFailed = false; 
    372364          while ((!foundWidth || !foundHeight) && 
     
    374366          { 
    375367            s.seek(s.getFilePointer() - 7); 
    376             foundWidth = s.readInt() == core.sizeX[0]; 
    377             foundHeight = s.readInt() == core.sizeY[0]; 
     368            foundWidth = s.readInt() == getSizeX(); 
     369            foundHeight = s.readInt() == getSizeY(); 
    378370          } 
    379371          s.seek(s.getFilePointer() - 16); 
     
    414406    status("Populating metadata"); 
    415407 
    416     core.rgb[0] = core.sizeC[0] > 1 && 
    417       (core.sizeZ[0] * core.sizeC[0] * core.sizeT[0] != core.imageCount[0]); 
     408    core.rgb[0] = getSizeC() > 1 && 
     409      (getSizeZ() * getSizeC() * getSizeT() != getImageCount()); 
    418410    core.littleEndian[0] = true; 
    419411    core.interleaved[0] = !isJPEG; 
     
    428420    else core.sizeC[0] *= cIndices.size(); 
    429421 
    430     core.imageCount[0] = core.sizeZ[0] * core.sizeT[0] * 
    431       (core.rgb[0] ? core.sizeC[0] / 3 : core.sizeC[0]); 
     422    core.imageCount[0] = getSizeZ() * getSizeT() * 
     423      (isRGB() ? getSizeC() / 3 : getSizeC()); 
    432424 
    433425    if (isTiled) { 
    434426      // calculate tile dimensions and number of tiles 
    435       int totalTiles = 
    436         offsets.size() / (core.sizeZ[0] * core.sizeC[0] * core.sizeT[0]); 
    437  
    438       tileRows = (realHeight / core.sizeY[0]) + 1; 
    439       tileColumns = (realWidth / core.sizeX[0]) + 1; 
     427      int totalTiles = offsets.size() / (getSizeZ() * getSizeC() * getSizeT()); 
     428 
     429      tileRows = (realHeight / getSizeY()) + 1; 
     430      tileColumns = (realWidth / getSizeX()) + 1; 
    440431 
    441432      if (totalTiles <= 1) { 
     
    447438 
    448439      while (tileRows * tileColumns > totalTiles) { 
    449         totalTiles = 
    450           offsets.size() / (core.sizeZ[0] * core.sizeC[0] * core.sizeT[0]); 
    451         core.imageCount[0] -= core.sizeZ[0] * core.sizeT[0]; 
     440        totalTiles = offsets.size() / (getSizeZ() * getSizeC() * getSizeT()); 
     441        core.imageCount[0] -= getSizeZ() * getSizeT(); 
    452442      } 
    453443 
     
    457447      if (tileColumns == 1 && tileRows == 1) isTiled = false; 
    458448      else { 
    459         tileWidth = core.sizeX[0]; 
    460         tileHeight = core.sizeY[0]; 
     449        tileWidth = getSizeX(); 
     450        tileHeight = getSizeY(); 
    461451        core.sizeX[0] = tileWidth * tileColumns; 
    462452        core.sizeY[0] = tileHeight * tileRows; 
     
    471461      int deltaC = zct2[1] - zct1[1]; 
    472462      int deltaT = zct2[2] - zct1[2]; 
    473       if (deltaZ > 0 && core.currentOrder[0].indexOf("Z") == -1) { 
     463      if (deltaZ > 0 && getDimensionOrder().indexOf("Z") == -1) { 
    474464        core.currentOrder[0] += "Z"; 
    475465      } 
    476       if (deltaC > 0 && core.currentOrder[0].indexOf("C") == -1) { 
     466      if (deltaC > 0 && getDimensionOrder().indexOf("C") == -1) { 
    477467        core.currentOrder[0] += "C"; 
    478468      } 
    479       if (deltaT > 0 && core.currentOrder[0].indexOf("T") == -1) { 
     469      if (deltaT > 0 && getDimensionOrder().indexOf("T") == -1) { 
    480470        core.currentOrder[0] += "T"; 
    481471      } 
    482472    } 
    483     if (core.currentOrder[0].indexOf("C") == -1) { 
     473    if (getDimensionOrder().indexOf("C") == -1) { 
    484474      core.currentOrder[0] += "C"; 
    485475    } 
    486     if (core.currentOrder[0].indexOf("Z") == -1) { 
     476    if (getDimensionOrder().indexOf("Z") == -1) { 
    487477      core.currentOrder[0] += "Z"; 
    488478    } 
    489     if (core.currentOrder[0].indexOf("T") == -1) { 
     479    if (getDimensionOrder().indexOf("T") == -1) { 
    490480      core.currentOrder[0] += "T"; 
    491481    } 
     
    498488      ((Integer) tIndices.get(tIndices.size() - 1)).intValue(); 
    499489 
    500     if ((zIndex > lastZ || tIndex > lastT) && (zIndex == core.sizeC[0] - 1 || 
    501       tIndex == core.sizeC[0] - 1 || 
    502       (zIndex != 0 && zIndex % core.sizeC[0] == 0) || 
    503       (tIndex != 0 && tIndex % core.sizeC[0] == 0)) && zIndex != lastT) 
     490    if ((zIndex > lastZ || tIndex > lastT) && (zIndex == getSizeC() - 1 || 
     491      tIndex == getSizeC() - 1 || 
     492      (zIndex != 0 && zIndex % getSizeC() == 0) || 
     493      (tIndex != 0 && tIndex % getSizeC() == 0)) && zIndex != lastT) 
    504494    { 
    505       if (zIndex >= core.sizeZ[0] || tIndex >= core.sizeT[0]) { 
    506         int tmp = core.sizeZ[0]; 
    507         core.sizeZ[0] = core.sizeT[0]; 
     495      if (zIndex >= getSizeZ() || tIndex >= getSizeT()) { 
     496        int tmp = getSizeZ(); 
     497        core.sizeZ[0] = getSizeT(); 
    508498        core.sizeT[0] = tmp; 
    509499      } 
     
    571561    Arrays.sort(channelNumbers); 
    572562 
    573     for (int i=0; i<core.sizeC[0]; i++) { 
     563    for (int i=0; i<getSizeC(); i++) { 
    574564      int idx = i % getEffectiveSizeC(); 
    575565      String em = idx < emWave.size() ? (String) emWave.get(idx) : null; 
     
    628618    } 
    629619 
    630     for (int plane=0; plane<core.imageCount[0]; plane++) { 
     620    for (int plane=0; plane<getImageCount(); plane++) { 
    631621      int[] zct = FormatTools.getZCTCoords(this, plane); 
    632622      String exposure = 
     
    794784      else if (key.equals("ImageWidth")) { 
    795785        try { 
    796           if (core.sizeX[0] == 0) Integer.parseInt(value); 
     786          if (getSizeX() == 0) Integer.parseInt(value); 
    797787          if (realWidth == 0 && Integer.parseInt(value) > realWidth) { 
    798788            realWidth = Integer.parseInt(value); 
     
    803793      else if (key.equals("ImageHeight")) { 
    804794        try { 
    805           if (core.sizeY[0] == 0) core.sizeY[0] = Integer.parseInt(value); 
     795          if (getSizeY() == 0) core.sizeY[0] = Integer.parseInt(value); 
    806796          if (realHeight == 0 || Integer.parseInt(value) > realHeight) { 
    807797            realHeight = Integer.parseInt(value); 
Note: See TracChangeset for help on using the changeset viewer.