Changeset 6129


Ignore:
Timestamp:
04/15/10 17:05:41 (10 years ago)
Author:
melissa
Message:

Updated more readers to respect MetadataOptions, and added some TIFF IFD caching logic.

Location:
trunk/components/bio-formats/src/loci/formats
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/components/bio-formats/src/loci/formats/in/GelReader.java

    r6118 r6129  
    9090  public boolean isThisType(RandomAccessInputStream stream) throws IOException { 
    9191    TiffParser parser = new TiffParser(stream); 
     92    parser.setDoCaching(false); 
    9293    IFD ifd = parser.getFirstIFD(); 
    9394    if (ifd == null) return false; 
  • trunk/components/bio-formats/src/loci/formats/in/IPLabReader.java

    r6055 r6129  
    4747 
    4848  // -- Fields -- 
    49  
    50   /** Bytes per pixel. */ 
    51   private int bps; 
    52  
    53   /** Total number of pixel bytes. */ 
    54   private int dataSize; 
    5549 
    5650  private Double pixelSize, timeIncrement; 
     
    10296    super.close(fileOnly); 
    10397    if (!fileOnly) { 
    104       bps = dataSize = 0; 
    10598      pixelSize = timeIncrement = null; 
    10699    } 
     
    124117    // read axis sizes from header 
    125118 
    126     dataSize = in.readInt() - 28; 
     119    int dataSize = in.readInt() - 28; 
    127120    core[0].sizeX = in.readInt(); 
    128121    core[0].sizeY = in.readInt(); 
     
    134127    core[0].imageCount = getSizeZ() * getSizeT(); 
    135128 
     129    String ptype; 
     130    switch (filePixelType) { 
     131      case 0: 
     132        ptype = "8 bit unsigned"; 
     133        core[0].pixelType = FormatTools.UINT8; 
     134        break; 
     135      case 1: 
     136        ptype = "16 bit signed short"; 
     137        core[0].pixelType = FormatTools.INT16; 
     138        break; 
     139      case 2: 
     140        ptype = "16 bit unsigned short"; 
     141        core[0].pixelType = FormatTools.UINT16; 
     142        break; 
     143      case 3: 
     144        ptype = "32 bit signed long"; 
     145        core[0].pixelType = FormatTools.INT32; 
     146        break; 
     147      case 4: 
     148        ptype = "32 bit single-precision float"; 
     149        core[0].pixelType = FormatTools.FLOAT; 
     150        break; 
     151      case 5: 
     152        ptype = "Color24"; 
     153        core[0].pixelType = FormatTools.UINT32; 
     154        break; 
     155      case 6: 
     156        ptype = "Color48"; 
     157        core[0].pixelType = FormatTools.UINT16; 
     158        break; 
     159      case 10: 
     160        ptype = "64 bit double-precision float"; 
     161        core[0].pixelType = FormatTools.DOUBLE; 
     162        break; 
     163      default: 
     164        ptype = "reserved"; // for values 7-9 
     165    } 
     166 
     167    core[0].dimensionOrder = "XY"; 
     168    if (getSizeC() > 1) core[0].dimensionOrder += "CZT"; 
     169    else core[0].dimensionOrder += "ZTC"; 
     170 
     171    core[0].rgb = getSizeC() > 1; 
     172    core[0].interleaved = false; 
     173    core[0].indexed = false; 
     174    core[0].falseColor = false; 
     175    core[0].metadataComplete = true; 
     176 
     177    addGlobalMeta("PixelType", ptype); 
    136178    addGlobalMeta("Width", getSizeX()); 
    137179    addGlobalMeta("Height", getSizeY()); 
     
    140182    addGlobalMeta("TDepth", getSizeT()); 
    141183 
    142     String ptype; 
    143     switch (filePixelType) { 
    144       case 0: 
    145         ptype = "8 bit unsigned"; 
    146         core[0].pixelType = FormatTools.UINT8; 
    147         break; 
    148       case 1: 
    149         ptype = "16 bit signed short"; 
    150         core[0].pixelType = FormatTools.INT16; 
    151         break; 
    152       case 2: 
    153         ptype = "16 bit unsigned short"; 
    154         core[0].pixelType = FormatTools.UINT16; 
    155         break; 
    156       case 3: 
    157         ptype = "32 bit signed long"; 
    158         core[0].pixelType = FormatTools.INT32; 
    159         break; 
    160       case 4: 
    161         ptype = "32 bit single-precision float"; 
    162         core[0].pixelType = FormatTools.FLOAT; 
    163         break; 
    164       case 5: 
    165         ptype = "Color24"; 
    166         core[0].pixelType = FormatTools.UINT32; 
    167         break; 
    168       case 6: 
    169         ptype = "Color48"; 
    170         core[0].pixelType = FormatTools.UINT16; 
    171         break; 
    172       case 10: 
    173         ptype = "64 bit double-precision float"; 
    174         core[0].pixelType = FormatTools.DOUBLE; 
    175         break; 
    176       default: 
    177         ptype = "reserved"; // for values 7-9 
    178     } 
    179  
    180     bps = FormatTools.getBytesPerPixel(getPixelType()); 
    181  
    182     addGlobalMeta("PixelType", ptype); 
    183     in.skipBytes(dataSize); 
    184  
    185     core[0].dimensionOrder = "XY"; 
    186     if (getSizeC() > 1) core[0].dimensionOrder += "CZT"; 
    187     else core[0].dimensionOrder += "ZTC"; 
    188  
    189     core[0].rgb = getSizeC() > 1; 
    190     core[0].interleaved = false; 
    191     core[0].indexed = false; 
    192     core[0].falseColor = false; 
    193     core[0].metadataComplete = true; 
    194  
    195184    // The metadata store we're working with. 
    196185    MetadataStore store = 
    197186      new FilterMetadata(getMetadataStore(), isMetadataFiltered()); 
    198187    MetadataTools.populatePixels(store, this, true); 
    199  
     188    MetadataTools.setDefaultCreationDate(store, id, 0); 
     189 
     190    if (getMetadataOptions().getMetadataLevel() == MetadataLevel.ALL) { 
     191      in.skipBytes(dataSize); 
     192      parseTags(store); 
     193 
     194      if (pixelSize != null) { 
     195        store.setDimensionsPhysicalSizeX(pixelSize, 0, 0); 
     196        store.setDimensionsPhysicalSizeY(pixelSize, 0, 0); 
     197      } 
     198      if (timeIncrement != null) { 
     199        store.setDimensionsTimeIncrement(timeIncrement, 0, 0); 
     200      } 
     201    } 
     202  } 
     203 
     204  // -- Helper methods -- 
     205 
     206  private void parseTags(MetadataStore store) throws FormatException, IOException { 
    200207    LOGGER.info("Reading tags"); 
    201208 
    202     byte[] tagBytes = new byte[4]; 
    203     in.read(tagBytes); 
    204     String tag = new String(tagBytes); 
     209    String tag = in.readString(4); 
    205210    while (!tag.equals("fini") && in.getFilePointer() < in.length() - 4) { 
    206211      int size = in.readInt(); 
     
    257262          addGlobalMeta("NormalizationBlack" + i, black); 
    258263          addGlobalMeta("NormalizationWhite" + i, white); 
    259  
    260           // CTR CHECK 
    261           //store.setDisplayChannel(core[0].sizeC, black, white, gamma, null); 
    262264        } 
    263265      } 
     
    283285        int numRoiPts = in.readInt(); 
    284286 
    285         Integer x0 = new Integer(roiLeft); 
    286         Integer x1 = new Integer(roiRight); 
    287         Integer y0 = new Integer(roiBottom); 
    288         Integer y1 = new Integer(roiTop); 
    289         // TODO 
    290         //store.setDisplayROIX0(x0, 0, 0); 
    291         //store.setDisplayROIY0(y0, 0, 0); 
    292         //store.setDisplayROIX1(x1, 0, 0); 
    293         //store.setDisplayROIY1(y1, 0, 0); 
     287        store.setRectX(String.valueOf(roiLeft), 0, 0, 0); 
     288        store.setRectY(String.valueOf(roiTop), 0, 0, 0); 
     289        store.setRectWidth(String.valueOf(roiRight - roiLeft), 0, 0, 0); 
     290        store.setRectHeight(String.valueOf(roiBottom - roiTop), 0, 0, 0); 
    294291 
    295292        in.skipBytes(8 * numRoiPts); 
     
    350347 
    351348        store.setImageDescription(notes, 0); 
    352         MetadataTools.setDefaultCreationDate(store, id, 0); 
    353       } 
    354       else if (tagBytes[0] == 0x1a && tagBytes[1] == (byte) 0xd9 && 
    355         tagBytes[2] == (byte) 0x8b && tagBytes[3] == (byte) 0xef) 
     349      } 
     350      else if (tag.charAt(0) == (char) 0x1a && tag.charAt(1) == (char) 0xd9 && 
     351        tag.charAt(2) == (char) 0x8b && tag.charAt(3) == (char) 0xef) 
    356352      { 
    357353        int units = in.readInt(); 
     
    391387 
    392388      if (in.getFilePointer() + 4 <= in.length()) { 
    393         in.read(tagBytes); 
    394         tag = new String(tagBytes); 
     389        tag = in.readString(4); 
    395390      } 
    396391      else { 
     
    401396      } 
    402397    } 
    403  
    404     if (pixelSize != null) { 
    405       store.setDimensionsPhysicalSizeX(pixelSize, 0, 0); 
    406       store.setDimensionsPhysicalSizeY(pixelSize, 0, 0); 
    407     } 
    408     if (timeIncrement != null) { 
    409       store.setDimensionsTimeIncrement(timeIncrement, 0, 0); 
    410     } 
    411398  } 
    412399 
  • trunk/components/bio-formats/src/loci/formats/in/IPWReader.java

    r6128 r6129  
    7272  private POIService poi; 
    7373 
    74   /** Image description. */ 
    75   private String description; 
    76  
    77   /** Creation date of the images in this file. */ 
    78   private String creationDate; 
    79  
    8074  // -- Constructor -- 
    8175 
     
    9892  public byte[][] get8BitLookupTable() throws FormatException, IOException { 
    9993    FormatTools.assertId(currentId, true, 1); 
    100     RandomAccessInputStream stream = 
    101       poi.getDocumentStream(imageFiles.get(new Integer(0))); 
     94    RandomAccessInputStream stream = poi.getDocumentStream(imageFiles.get(0)); 
    10295    TiffParser tp = new TiffParser(stream); 
    103     IFDList ifds = tp.getIFDs(); 
    104     IFD firstIFD = ifds.get(0); 
     96    IFD firstIFD = tp.getFirstIFD(); 
    10597    int[] bits = firstIFD.getBitsPerSample(); 
    10698    if (bits[0] <= 8) { 
     
    129121    FormatTools.checkPlaneParameters(this, no, buf.length, x, y, w, h); 
    130122 
    131     RandomAccessInputStream stream = 
    132       poi.getDocumentStream(imageFiles.get(new Integer(no))); 
     123    RandomAccessInputStream stream = poi.getDocumentStream(imageFiles.get(no)); 
    133124    TiffParser tp = new TiffParser(stream); 
    134     IFDList ifds = tp.getIFDs(); 
    135     tp.getSamples(ifds.get(0), buf, x, y, w, h); 
     125    IFD ifd = tp.getFirstIFD(); 
     126    tp.getSamples(ifd, buf, x, y, w, h); 
    136127    stream.close(); 
    137128    return buf; 
     
    145136      poi = null; 
    146137      imageFiles = null; 
    147       description = null; 
    148       creationDate = null; 
    149138    } 
    150139  } 
     
    172161    Vector<String> fileList = poi.getDocumentList(); 
    173162 
     163    String description = null, creationDate = null; 
     164 
    174165    for (String name : fileList) { 
    175166      String relativePath = 
    176167        name.substring(name.lastIndexOf(File.separator) + 1); 
    177168 
    178       if (relativePath.equals("CONTENTS")) { 
    179         addGlobalMeta("Version", new String(poi.getDocumentBytes(name)).trim()); 
    180       } 
    181       else if (relativePath.equals("FrameRate")) { 
    182         byte[] b = poi.getDocumentBytes(name, 4); 
    183         addGlobalMeta("Frame Rate", DataTools.bytesToInt(b, true)); 
    184       } 
    185       else if (relativePath.equals("FrameInfo")) { 
    186         byte[] b = poi.getDocumentBytes(name); 
    187         for (int q=0; q<b.length/2; q++) { 
    188           addGlobalMeta("FrameInfo " + q, 
    189             DataTools.bytesToShort(b, q*2, 2, true)); 
    190         } 
    191       } 
    192       else if (relativePath.equals("ImageInfo")) { 
     169      if (getMetadataOptions().getMetadataLevel() == MetadataLevel.ALL) { 
     170        if (relativePath.equals("CONTENTS")) { 
     171          addGlobalMeta("Version", new String(poi.getDocumentBytes(name)).trim()); 
     172        } 
     173        else if (relativePath.equals("FrameRate")) { 
     174          byte[] b = poi.getDocumentBytes(name, 4); 
     175          addGlobalMeta("Frame Rate", DataTools.bytesToInt(b, true)); 
     176        } 
     177        else if (relativePath.equals("FrameInfo")) { 
     178          RandomAccessInputStream s = poi.getDocumentStream(name); 
     179          s.order(true); 
     180          for (int q=0; q<s.length()/2; q++) { 
     181            addGlobalMeta("FrameInfo " + q, s.readShort()); 
     182          } 
     183          s.close(); 
     184        } 
     185      } 
     186 
     187      if (relativePath.equals("ImageInfo")) { 
    193188        description = new String(poi.getDocumentBytes(name)).trim(); 
    194189        addGlobalMeta("Image Description", description); 
     
    199194        // basically the same as in SEQReader 
    200195        if (description != null) { 
    201           StringTokenizer tokenizer = new StringTokenizer(description, "\n"); 
    202           while (tokenizer.hasMoreTokens()) { 
    203             String token = tokenizer.nextToken(); 
     196          String[] tokens = description.split("\n"); 
     197          for (String token : tokens) { 
    204198            String label = "Timestamp"; 
    205             String data; 
     199            String data = token.trim(); 
    206200            if (token.indexOf("=") != -1) { 
    207201              label = token.substring(0, token.indexOf("=")).trim(); 
    208202              data = token.substring(token.indexOf("=") + 1).trim(); 
    209203            } 
    210             else data = token.trim(); 
    211204            addGlobalMeta(label, data); 
    212205            if (label.equals("frames")) core[0].sizeT = Integer.parseInt(data); 
     
    239232 
    240233        imageFiles.put(new Integer(idx), name); 
    241         core[0].imageCount++; 
    242234      } 
    243235    } 
     
    245237    LOGGER.info("Populating metadata"); 
    246238 
    247     RandomAccessInputStream stream = 
    248       poi.getDocumentStream(imageFiles.get(new Integer(0))); 
     239    core[0].imageCount = imageFiles.size(); 
     240 
     241    RandomAccessInputStream stream = poi.getDocumentStream(imageFiles.get(0)); 
    249242    TiffParser tp = new TiffParser(stream); 
    250     IFDList ifds = tp.getIFDs(); 
     243    IFD firstIFD = tp.getFirstIFD(); 
    251244    stream.close(); 
    252  
    253     IFD firstIFD = ifds.get(0); 
    254245 
    255246    core[0].rgb = firstIFD.getSamplesPerPixel() > 1; 
     
    287278 
    288279    int bitsPerSample = firstIFD.getBitsPerSample()[0]; 
    289     int bitFormat = firstIFD.getIFDIntValue(IFD.SAMPLE_FORMAT); 
    290  
    291     while (bitsPerSample % 8 != 0) bitsPerSample++; 
    292     if (bitsPerSample == 24 || bitsPerSample == 48) bitsPerSample /= 3; 
    293  
    294     boolean fp = bitFormat == 3; 
    295     boolean signed = bitFormat == 2; 
    296  
    297     core[0].pixelType = 
    298       FormatTools.pixelTypeFromBytes(bitsPerSample / 4, signed, fp); 
     280    core[0].pixelType = firstIFD.getPixelType(); 
    299281 
    300282    MetadataStore store = 
  • trunk/components/bio-formats/src/loci/formats/in/ImaconReader.java

    r6026 r6129  
    5757  private static final int CREATOR_TAG = 34377; 
    5858  private static final int XML_TAG = 50457; 
     59  private static final int PIXELS_TAG = 46275; 
    5960 
    6061  // -- Fields -- 
     
    7778  public boolean isThisType(RandomAccessInputStream stream) throws IOException { 
    7879    TiffParser parser = new TiffParser(stream); 
     80    parser.setDoCaching(false); 
    7981    IFD ifd = parser.getFirstIFD(); 
    8082    if (ifd == null) return false; 
     
    105107      core[i].imageCount = 1; 
    106108      IFD ifd = ifds.get(i); 
     109      ifd.remove(PIXELS_TAG); 
    107110 
    108111      PhotoInterp photo = ifd.getPhotometricInterpretation(); 
     
    124127 
    125128    IFD firstIFD = ifds.get(0); 
    126     String xml = firstIFD.getIFDTextValue(XML_TAG).trim(); 
    127     xml = xml.substring(xml.indexOf("<")); 
    128  
    129     XMLTools.parseXML(xml, new ImaconHandler()); 
     129 
     130    if (getMetadataOptions().getMetadataLevel() == MetadataLevel.ALL) { 
     131      String xml = firstIFD.getIFDTextValue(XML_TAG).trim(); 
     132      xml = xml.substring(xml.indexOf("<")); 
     133      XMLTools.parseXML(xml, new ImaconHandler()); 
     134    } 
    130135 
    131136    String[] creationInfo = firstIFD.getIFDTextValue(CREATOR_TAG).split("\n"); 
    132137 
    133     int lineNumber = 0; 
    134     for (String s : creationInfo) { 
    135       if (s.trim().length() == 0) continue; 
    136       switch (lineNumber) { 
    137         case 4: 
    138           // creator's name 
    139           experimenterName = s.trim(); 
    140           break; 
    141         case 6: 
    142           // image name 
    143           imageName = s.trim(); 
    144           break; 
    145         case 8: 
    146           // creation date 
    147           creationDate = s.trim(); 
    148           break; 
    149         case 10: 
    150           // creation time 
    151           creationDate += " " + s.trim(); 
    152           break; 
    153       } 
    154  
    155       lineNumber++; 
     138    if (creationInfo.length > 4) { 
     139      experimenterName = creationInfo[4].trim(); 
     140    } 
     141    if (creationInfo.length > 6) { 
     142      imageName = creationInfo[6].trim(); 
     143    } 
     144    if (creationInfo.length > 8) { 
     145      creationDate = creationInfo[8].trim(); 
     146    } 
     147    if (creationInfo.length > 10) { 
     148      creationDate += " " + creationInfo[10].trim(); 
    156149    } 
    157150  } 
     
    164157      new FilterMetadata(getMetadataStore(), isMetadataFiltered()); 
    165158 
    166     if (experimenterName == null) experimenterName = ""; 
    167  
    168     int nameSpace = experimenterName.indexOf(" "); 
    169     String firstName = 
    170       nameSpace == -1 ? "" : experimenterName.substring(0, nameSpace); 
    171     String lastName = nameSpace == -1 ? experimenterName : 
    172       experimenterName.substring(nameSpace + 1); 
    173  
    174     String experimenter = MetadataTools.createLSID("Experimenter", 0); 
    175  
    176     store.setExperimenterID(experimenter, 0); 
    177     store.setExperimenterFirstName(firstName, 0); 
    178     store.setExperimenterLastName(lastName, 0); 
    179  
    180159    if (creationDate != null) { 
    181160      creationDate = DateTools.formatDate(creationDate, "yyyyMMdd HHmmSSZ"); 
     
    183162 
    184163    for (int i=0; i<getSeriesCount(); i++) { 
    185       store.setImageExperimenterRef(experimenter, i); 
    186164      store.setImageName(imageName + " #" + (i + 1), i); 
    187165      if (creationDate != null) { 
     
    189167      } 
    190168      else MetadataTools.setDefaultCreationDate(store, currentId, i); 
     169    } 
     170 
     171    if (getMetadataOptions().getMetadataLevel() == MetadataLevel.ALL) { 
     172      if (experimenterName == null) experimenterName = ""; 
     173 
     174      int nameSpace = experimenterName.indexOf(" "); 
     175      String firstName = 
     176        nameSpace == -1 ? "" : experimenterName.substring(0, nameSpace); 
     177      String lastName = nameSpace == -1 ? experimenterName : 
     178        experimenterName.substring(nameSpace + 1); 
     179 
     180      String experimenter = MetadataTools.createLSID("Experimenter", 0); 
     181 
     182      store.setExperimenterID(experimenter, 0); 
     183      store.setExperimenterFirstName(firstName, 0); 
     184      store.setExperimenterLastName(lastName, 0); 
     185   
     186      for (int i=0; i<getSeriesCount(); i++) { 
     187        store.setImageExperimenterRef(experimenter, i); 
     188      } 
    191189    } 
    192190  } 
  • trunk/components/bio-formats/src/loci/formats/in/KhorosReader.java

    r5517 r6129  
    5050 
    5151  /** Global lookup table. */ 
    52   private byte[] lut; 
     52  private byte[][] lut; 
    5353 
    5454  /** Image offset. */ 
     
    7575  public byte[][] get8BitLookupTable() throws FormatException, IOException { 
    7676    FormatTools.assertId(currentId, true, 1); 
    77     if (lut == null) return null; 
    78     byte[][] table = new byte[3][lut.length / 3]; 
    79     int next = 0; 
    80     for (int i=0; i<table[0].length; i++) { 
    81       for (int j=0; j<table.length; j++) { 
    82         table[j][i] = lut[next++]; 
    83       } 
    84     } 
    85     return table; 
     77    return lut;     
    8678  } 
    8779 
     
    163155      core[0].sizeC = c; 
    164156      int n = in.readInt(); 
    165       lut = new byte[n * c]; 
     157      lut = new byte[c][n]; 
    166158      in.skipBytes(436); 
    167159 
    168       for (int i=0; i<lut.length; i++) { 
    169         int value = in.read(); 
    170         if (i < n) { 
    171           lut[i*3] = (byte) value; 
    172           lut[i*3 + 1] = (byte) value; 
    173           lut[i*3 + 2] = (byte) value; 
    174         } 
    175         else if (i < n*2) { 
    176           lut[(i % n)*3 + 1] = (byte) value; 
    177         } 
    178         else if (i < n*3) { 
    179           lut[(i % n)*3 + 2] = (byte) value; 
     160      for (int i=0; i<lut[0].length; i++) { 
     161        for (int j=0; j<lut.length; j++) { 
     162          lut[j][i] = in.readByte(); 
    180163        } 
    181164      } 
  • trunk/components/bio-formats/src/loci/formats/in/L2DReader.java

    r6058 r6129  
    2626import java.io.IOException; 
    2727import java.util.Hashtable; 
    28 import java.util.StringTokenizer; 
    2928import java.util.Vector; 
    3029 
     30import loci.common.DataTools; 
    3131import loci.common.DateTools; 
    3232import loci.common.Location; 
    33 import loci.common.RandomAccessInputStream; 
    3433import loci.formats.CoreMetadata; 
    3534import loci.formats.FormatException; 
     
    5655 
    5756  /** List of constituent TIFF files. */ 
    58   private Vector[] tiffs; 
     57  private String[][] tiffs; 
    5958 
    6059  /** List of all metadata files in the dataset. */ 
     
    101100    FormatTools.checkPlaneParameters(this, no, buf.length, x, y, w, h); 
    102101 
    103     reader.setId((String) tiffs[series].get(no)); 
     102    reader.setId(tiffs[series][no]); 
    104103    return reader.openBytes(0, buf, x, y, w, h); 
    105104  } 
     
    118117      files.addAll(metadataFiles[getSeries()]); 
    119118    } 
    120     if (!noPixels) files.addAll(tiffs[series]); 
     119    if (!noPixels) { 
     120      for (String tiff : tiffs[series]) { 
     121        files.add(tiff); 
     122      } 
     123    } 
    121124    return files.toArray(new String[files.size()]); 
    122125  } 
     
    156159      super.initFile(id); 
    157160 
    158       tiffs = new Vector[1]; 
    159       tiffs[0] = new Vector<String>(); 
    160       tiffs[0].add(id); 
     161      tiffs = new String[][] {{id}}; 
    161162 
    162163      TiffReader r = new TiffReader(); 
     
    176177 
    177178    super.initFile(id); 
    178     in = new RandomAccessInputStream(id); 
     179 
     180    String[] scans = getScanNames(); 
     181 
     182    // read metadata from each scan 
     183 
     184    tiffs = new String[scans.length][]; 
     185    metadataFiles = new Vector[scans.length]; 
     186 
     187    core = new CoreMetadata[scans.length]; 
     188 
     189    String[] comments = new String[scans.length]; 
     190    String[] wavelengths = new String[scans.length]; 
     191    String[] dates = new String[scans.length]; 
     192    String model = null; 
    179193 
    180194    Location parent = new Location(id).getAbsoluteFile().getParentFile(); 
    181  
    182     // parse key/value pairs from file - this gives us a list of scans 
    183  
    184     Vector<String> scans = new Vector<String>(); 
    185  
    186     String line = in.readLine().trim(); 
    187     while (line != null && line.length() > 0) { 
    188       if (!line.startsWith("#")) { 
    189         String key = line.substring(0, line.indexOf("=")); 
    190         String value = line.substring(line.indexOf("=") + 1); 
    191         addGlobalMeta(key, value); 
    192  
    193         if (key.equals("ScanNames")) { 
    194           StringTokenizer names = new StringTokenizer(value, ","); 
    195           while (names.hasMoreTokens()) { 
    196             scans.add(names.nextToken().trim()); 
    197           } 
    198         } 
    199       } 
    200       if (in.getFilePointer() < in.length()) { 
    201         line = in.readLine().trim(); 
    202       } 
    203       else line = null; 
    204     } 
    205     in.close(); 
    206  
    207     // read metadata from each scan 
    208  
    209     tiffs = new Vector[scans.size()]; 
    210     metadataFiles = new Vector[scans.size()]; 
    211  
    212     core = new CoreMetadata[scans.size()]; 
    213  
    214     Vector<String> comments = new Vector<String>(); 
    215     Vector<String> wavelengths = new Vector<String>(); 
    216     Vector<String> dates = new Vector<String>(); 
    217     String model = null; 
    218  
    219     for (int i=0; i<scans.size(); i++) { 
     195    for (int i=0; i<scans.length; i++) { 
    220196      setSeries(i); 
    221197      core[i] = new CoreMetadata(); 
    222       tiffs[i] = new Vector(); 
    223198      metadataFiles[i] = new Vector(); 
    224       String scanName = scans.get(i); 
    225       Location scanDir = new Location(parent, scanName); 
     199      String scanName = scans[i] + ".scn"; 
     200      Location scanDir = new Location(parent, scans[i]); 
    226201 
    227202      // read .scn file from each scan 
    228203 
    229       String scanPath = 
    230         new Location(scanDir, scanName + ".scn").getAbsolutePath(); 
     204      String scanPath = new Location(scanDir, scanName).getAbsolutePath(); 
    231205      addDirectory(scanDir.getAbsolutePath(), i); 
    232       RandomAccessInputStream scan = new RandomAccessInputStream(scanPath); 
    233       line = scan.readLine().trim(); 
    234       while (line != null && line.length() > 0) { 
     206      String scanData = DataTools.readFile(scanPath); 
     207      String[] lines = scanData.split("\n"); 
     208      for (String line : lines) { 
    235209        if (!line.startsWith("#")) { 
    236210          String key = line.substring(0, line.indexOf("=")); 
     
    243217          } 
    244218          else if (key.equals("ImageNames")) { 
    245             StringTokenizer names = new StringTokenizer(value, ","); 
    246             while (names.hasMoreTokens()) { 
    247               String path = names.nextToken().trim(); 
    248               String tiff = new Location(scanDir, path).getAbsolutePath(); 
    249               tiffs[i].add(tiff); 
     219            tiffs[i] = value.split(","); 
     220            for (int t=0; t<tiffs[i].length; t++) { 
     221              tiffs[i][t] = 
     222                new Location(scanDir, tiffs[i][t].trim()).getAbsolutePath(); 
    250223            } 
    251224          } 
    252225          else if (key.equals("Comments")) { 
    253             comments.add(value); 
     226            comments[i] = value; 
    254227          } 
    255228          else if (key.equals("ScanDate")) { 
    256             dates.add(value); 
     229            dates[i] = value; 
    257230          } 
    258231          else if (key.equals("ScannerName")) { 
     
    260233          } 
    261234          else if (key.equals("ScanChannels")) { 
    262             wavelengths.add(value); 
     235            wavelengths[i] = value; 
    263236          } 
    264237        } 
    265         if (scan.getFilePointer() < scan.length()) { 
    266           line = scan.readLine().trim(); 
    267         } 
    268         else line = null; 
    269       } 
    270       if (comments.size() == i) comments.add(null); 
    271       if (dates.size() == i) dates.add(null); 
    272       if (wavelengths.size() == i) wavelengths.add(null); 
     238      } 
    273239    } 
    274240    setSeries(0); 
     
    279245      new FilterMetadata(getMetadataStore(), isMetadataFiltered()); 
    280246 
    281     for (int i=0; i<scans.size(); i++) { 
    282       core[i].imageCount = tiffs[i].size(); 
    283       core[i].sizeC = tiffs[i].size(); 
     247    for (int i=0; i<getSeriesCount(); i++) { 
     248      core[i].imageCount = tiffs[i].length; 
     249      core[i].sizeC = tiffs[i].length; 
    284250      core[i].sizeT = 1; 
    285251      core[i].sizeZ = 1; 
    286252      core[i].dimensionOrder = "XYCZT"; 
    287253 
    288       for (int t=0; t<tiffs[i].size(); t++) { 
    289         reader.setId((String) tiffs[i].get(t)); 
    290         if (t == 0) { 
    291           core[i].sizeX = reader.getSizeX(); 
    292           core[i].sizeY = reader.getSizeY(); 
    293           core[i].sizeC *= reader.getSizeC(); 
    294           core[i].rgb = reader.isRGB(); 
    295           core[i].indexed = reader.isIndexed(); 
    296           core[i].littleEndian = reader.isLittleEndian(); 
    297           core[i].pixelType = reader.getPixelType(); 
     254      reader.setId(tiffs[i][0]); 
     255      core[i].sizeX = reader.getSizeX(); 
     256      core[i].sizeY = reader.getSizeY(); 
     257      core[i].sizeC *= reader.getSizeC(); 
     258      core[i].rgb = reader.isRGB(); 
     259      core[i].indexed = reader.isIndexed(); 
     260      core[i].littleEndian = reader.isLittleEndian(); 
     261      core[i].pixelType = reader.getPixelType(); 
     262    } 
     263 
     264    MetadataTools.populatePixels(store, this); 
     265 
     266    for (int i=0; i<getSeriesCount(); i++) { 
     267      store.setImageName(scans[i], i); 
     268      if (dates[i] != null) { 
     269        dates[i] = DateTools.formatDate(dates[i], DATE_FORMAT); 
     270        store.setImageCreationDate(dates[i], i); 
     271      } 
     272      else MetadataTools.setDefaultCreationDate(store, id, i); 
     273    } 
     274 
     275    if (getMetadataOptions().getMetadataLevel() == MetadataLevel.ALL) { 
     276      String instrumentID = MetadataTools.createLSID("Instrument", 0); 
     277      store.setInstrumentID(instrumentID, 0); 
     278 
     279      for (int i=0; i<getSeriesCount(); i++) { 
     280        store.setImageInstrumentRef(instrumentID, i); 
     281 
     282        store.setImageDescription(comments[i], i); 
     283 
     284        if (wavelengths[i] != null) { 
     285          String[] waves = wavelengths[i].split("[, ]"); 
     286          if (waves.length < getEffectiveSizeC()) { 
     287            LOGGER.debug("Expected {} wavelengths; got {} wavelengths.", 
     288              getEffectiveSizeC(), waves.length); 
     289          } 
     290          for (int q=0; q<waves.length; q++) { 
     291            String lightSource = MetadataTools.createLSID("LightSource", 0, q); 
     292            store.setLightSourceID(lightSource, 0, q); 
     293            store.setLaserWavelength(new Integer(waves[q].trim()), 0, q); 
     294            store.setLaserType("Unknown", 0, q); 
     295            store.setLaserLaserMedium("Unknown", 0, q); 
     296            store.setLogicalChannelLightSource(lightSource, i, q); 
     297          } 
    298298        } 
    299299      } 
    300     } 
    301  
    302     MetadataTools.populatePixels(store, this); 
    303  
    304     String instrumentID = MetadataTools.createLSID("Instrument", 0); 
    305     store.setInstrumentID(instrumentID, 0); 
    306  
    307     for (int i=0; i<scans.size(); i++) { 
    308       store.setImageInstrumentRef(instrumentID, i); 
    309  
    310       store.setImageName(scans.get(i), i); 
    311       store.setImageDescription(comments.get(i), i); 
    312  
    313       String date = dates.get(i); 
    314       if (date != null) { 
    315         date = DateTools.formatDate(date, DATE_FORMAT); 
    316         store.setImageCreationDate(date, i); 
    317       } 
    318       else MetadataTools.setDefaultCreationDate(store, id, i); 
    319  
    320       String c = wavelengths.get(i); 
    321       if (c != null) { 
    322         String[] waves = c.split("[, ]"); 
    323         if (waves.length < getEffectiveSizeC()) { 
    324           LOGGER.debug("Expected {} wavelengths; got {} wavelengths.", 
    325             getEffectiveSizeC(), waves.length); 
    326         } 
    327         for (int q=0; q<waves.length; q++) { 
    328           String lightSourceID = MetadataTools.createLSID("LightSource", 0, q); 
    329           store.setLightSourceID(lightSourceID, 0, q); 
    330           store.setLaserWavelength(new Integer(waves[q].trim()), 0, q); 
    331           store.setLaserType("Unknown", 0, q); 
    332           store.setLaserLaserMedium("Unknown", 0, q); 
    333           store.setLogicalChannelLightSource(lightSourceID, i, q); 
    334         } 
    335       } 
    336     } 
    337  
    338     store.setMicroscopeModel(model, 0); 
    339     store.setMicroscopeType("Unknown", 0); 
     300 
     301      store.setMicroscopeModel(model, 0); 
     302      store.setMicroscopeType("Unknown", 0); 
     303    } 
    340304  } 
    341305 
     
    350314    String[] files = dir.list(); 
    351315    if (files == null) return; 
    352     for (int i=0; i<files.length; i++) { 
    353       Location file = new Location(path, files[i]); 
     316    for (String f : files) { 
     317      Location file = new Location(path, f); 
    354318      if (file.isDirectory()) { 
    355319        addDirectory(file.getAbsolutePath(), series); 
    356320      } 
    357       else { 
    358         String check = files[i].toLowerCase(); 
    359         if (check.endsWith(".scn")) { 
    360           metadataFiles[series].add(file.getAbsolutePath()); 
     321      else if (checkSuffix(f, "scn")) { 
     322        metadataFiles[series].add(file.getAbsolutePath()); 
     323      } 
     324    } 
     325  } 
     326 
     327  /** Return a list of scan names. */ 
     328  private String[] getScanNames() throws IOException { 
     329    String[] scans = null; 
     330 
     331    String data = DataTools.readFile(currentId); 
     332    String[] lines = data.split("\n"); 
     333    for (String line : lines) { 
     334      if (!line.startsWith("#")) { 
     335        String key = line.substring(0, line.indexOf("=")).trim(); 
     336        String value = line.substring(line.indexOf("=") + 1).trim(); 
     337        addGlobalMeta(key, value); 
     338 
     339        if (key.equals("ScanNames")) { 
     340          scans = value.split(","); 
     341          for (int i=0; i<scans.length; i++) { 
     342            scans[i] = scans[i].trim(); 
     343          } 
    361344        } 
    362345      } 
    363346    } 
     347    return scans; 
    364348  } 
    365349 
  • trunk/components/bio-formats/src/loci/formats/in/LEOReader.java

    r6055 r6129  
    6969  public boolean isThisType(RandomAccessInputStream stream) throws IOException { 
    7070    TiffParser parser = new TiffParser(stream); 
     71    parser.setDoCaching(false); 
    7172    IFD ifd = parser.getFirstIFD(); 
    7273    if (ifd == null) return false; 
  • trunk/components/bio-formats/src/loci/formats/in/MetamorphReader.java

    r6055 r6129  
    126126  public boolean isThisType(RandomAccessInputStream stream) throws IOException { 
    127127    TiffParser tp = new TiffParser(stream); 
     128    tp.setDoCaching(false); 
    128129    IFD ifd = tp.getFirstIFD(); 
    129130    if (ifd == null) return false; 
  • trunk/components/bio-formats/src/loci/formats/in/NikonReader.java

    r6125 r6129  
    119119  public boolean isThisType(RandomAccessInputStream stream) throws IOException { 
    120120    TiffParser tp = new TiffParser(stream); 
     121    tp.setDoCaching(false); 
    121122    IFD ifd = tp.getFirstIFD(); 
    122123    if (ifd == null) return false; 
  • trunk/components/bio-formats/src/loci/formats/in/PhotoshopTiffReader.java

    r6128 r6129  
    8282  public boolean isThisType(RandomAccessInputStream stream) throws IOException { 
    8383    TiffParser tp = new TiffParser(stream); 
     84    tp.setDoCaching(false); 
    8485    IFD ifd = tp.getFirstIFD(); 
    8586    if (ifd == null) return false; 
  • trunk/components/bio-formats/src/loci/formats/in/SEQReader.java

    r6026 r6129  
    6868  public boolean isThisType(RandomAccessInputStream stream) throws IOException { 
    6969    TiffParser parser = new TiffParser(stream); 
     70    parser.setDoCaching(false); 
    7071    IFD ifd = parser.getFirstIFD(); 
    7172    if (ifd == null) return false; 
  • trunk/components/bio-formats/src/loci/formats/tiff/TiffParser.java

    r6128 r6129  
    7070  private boolean doCaching; 
    7171 
     72  /** Cached list of IFDs in the current file. */ 
     73  private IFDList ifdList; 
     74 
     75  /** Cached first IFD in the current file. */ 
     76  private IFD firstIFD; 
     77 
    7278  // -- Constructors -- 
    7379 
     
    147153  /** Returns all IFDs in the file.  */ 
    148154  public IFDList getIFDs() throws IOException { 
     155    if (ifdList != null) return ifdList; 
     156 
    149157    long[] offsets = getIFDOffsets(); 
    150158    IFDList ifds = new IFDList(); 
     
    168176      } 
    169177    } 
     178    if (doCaching) ifdList = ifds; 
    170179 
    171180    return ifds; 
     
    175184  public IFDList getThumbnailIFDs() throws IOException { 
    176185    IFDList ifds = getIFDs(); 
    177     for (int i=0; i<ifds.size(); i++) { 
    178       Number subfile = (Number) ifds.get(i).getIFDValue(IFD.NEW_SUBFILE_TYPE); 
     186    IFDList thumbnails = new IFDList(); 
     187    for (IFD ifd : ifds) { 
     188      Number subfile = (Number) ifd.getIFDValue(IFD.NEW_SUBFILE_TYPE); 
    179189      int subfileType = subfile == null ? 0 : subfile.intValue(); 
    180       if (subfileType != 1) { 
    181         ifds.remove(i--); 
    182       } 
    183     } 
    184     return ifds; 
     190      if (subfileType == 1) { 
     191        thumbnails.add(ifd); 
     192      } 
     193    } 
     194    return thumbnails; 
    185195  } 
    186196 
     
    188198  public IFDList getNonThumbnailIFDs() throws IOException { 
    189199    IFDList ifds = getIFDs(); 
    190     for (int i=0; i<ifds.size(); i++) { 
    191       Number subfile = (Number) ifds.get(i).getIFDValue(IFD.NEW_SUBFILE_TYPE); 
     200    IFDList nonThumbs = new IFDList(); 
     201    for (IFD ifd : ifds) { 
     202      Number subfile = (Number) ifd.getIFDValue(IFD.NEW_SUBFILE_TYPE); 
    192203      int subfileType = subfile == null ? 0 : subfile.intValue(); 
    193       if (subfileType == 1 && ifds.size() > 1) { 
    194         ifds.remove(i--); 
    195       } 
    196     } 
    197     return ifds; 
     204      if (subfileType != 1 || ifds.size() <= 1) { 
     205        nonThumbs.add(ifd); 
     206      } 
     207    } 
     208    return nonThumbs; 
    198209  } 
    199210 
     
    243254   */ 
    244255  public IFD getFirstIFD() throws IOException { 
     256    if (firstIFD != null) return firstIFD; 
    245257    long offset = getFirstOffset(); 
    246     return getIFD(offset); 
     258    IFD ifd = getIFD(offset); 
     259    if (doCaching) firstIFD = ifd; 
     260    return ifd; 
    247261  } 
    248262 
     
    369383    int count = entry.getValueCount(); 
    370384    long offset = entry.getValueOffset(); 
     385 
     386    LOGGER.debug("Reading entry {} from {}; type={}, count={}", 
     387      new Object[] {entry.getTag(), offset, type, count}); 
    371388 
    372389    if (offset != in.getFilePointer()) { 
Note: See TracChangeset for help on using the changeset viewer.