Changeset 7006


Ignore:
Timestamp:
09/28/10 13:09:21 (9 years ago)
Author:
melissa
Message:

Merged remaining reader changes: r6708, r6727, r6778, r6779, r6782, r6787, r6799, r6804, r6805, r6816, r6819, r6823, r6835, r6844, r6852, r6857, r6862, r6863, r6864, r6875, r6880, r6886, r6945, r6952, r6953, r6965, r6969, r6986, r6988, and r6989.

Location:
branches/4.2
Files:
33 edited

Legend:

Unmodified
Added
Removed
  • branches/4.2

  • branches/4.2/components/bio-formats/src/loci/formats/FormatWriter.java

    r6993 r7006  
    357357    } 
    358358 
    359     if (!DataTools.containsValue(getPixelTypes(), pixelType)) { 
     359    if (!DataTools.containsValue(getPixelTypes(compression), pixelType)) { 
    360360      throw new FormatException("Unsupported image type '" + 
    361361        FormatTools.getPixelTypeString(pixelType) + "'."); 
  • branches/4.2/components/bio-formats/src/loci/formats/in

  • branches/4.2/components/bio-formats/src/loci/formats/in/AVIReader.java

    r6754 r7006  
    6868  private Vector<Long> lengths; 
    6969 
     70  private String listString; 
    7071  private String type = "error"; 
    7172  private String fcc = "error"; 
     
    210211    super.close(fileOnly); 
    211212    if (!fileOnly) { 
     213      listString = null; 
    212214      offsets = null; 
    213215      lengths = null; 
     
    239241    lastImageNo = -1; 
    240242 
    241     String listString; 
    242  
     243    while (in.getFilePointer() < in.length() - 8) { 
     244      readChunk(); 
     245    } 
     246    LOGGER.info("Populating metadata"); 
     247 
     248    core[0].imageCount = offsets.size(); 
     249    core[0].sizeZ = 1; 
     250    core[0].sizeT = getImageCount(); 
     251    core[0].littleEndian = true; 
     252    core[0].interleaved = bmpBitsPerPixel != 16; 
     253 
     254    if (bmpBitsPerPixel == 32) { 
     255      core[0].sizeC = 4; 
     256      core[0].rgb = true; 
     257    } 
     258    else if (bytesPerPlane == 0 || bmpBitsPerPixel == 24) { 
     259      core[0].rgb = bmpBitsPerPixel > 8 || (bmpCompression != 0 && lut == null); 
     260      core[0].sizeC = isRGB() ? 3 : 1; 
     261    } 
     262    else { 
     263      core[0].sizeC = bytesPerPlane / 
     264        (getSizeX() * getSizeY() * (bmpBitsPerPixel / 8)); 
     265      core[0].rgb = getSizeC() > 1; 
     266    } 
     267    core[0].dimensionOrder = isRGB() ? "XYCTZ" : "XYTCZ"; 
     268    core[0].falseColor = false; 
     269    core[0].metadataComplete = true; 
     270    core[0].indexed = lut != null && !isRGB(); 
     271 
     272    if (bmpBitsPerPixel <= 8) { 
     273      core[0].pixelType = FormatTools.UINT8; 
     274      core[0].bitsPerPixel = bmpBitsPerPixel; 
     275    } 
     276    else if (bmpBitsPerPixel == 16) core[0].pixelType = FormatTools.UINT16; 
     277    else if (bmpBitsPerPixel == 24 || bmpBitsPerPixel == 32) { 
     278      core[0].pixelType = FormatTools.UINT8; 
     279    } 
     280    else { 
     281      throw new FormatException( 
     282          "Unknown matching for pixel bit width of: " + bmpBitsPerPixel); 
     283    } 
     284 
     285    if (bmpCompression != 0) core[0].pixelType = FormatTools.UINT8; 
     286 
     287    MetadataStore store = makeFilterMetadata(); 
     288    MetadataTools.populatePixels(store, this); 
     289    MetadataTools.setDefaultCreationDate(store, id, 0); 
     290  } 
     291 
     292  // -- Helper methods -- 
     293 
     294  private byte[] uncompress(int no, byte[] buf) 
     295    throws FormatException, IOException 
     296  { 
     297    CodecOptions options = new CodecOptions(); 
     298    options.width = getSizeX(); 
     299    options.height = getSizeY(); 
     300    options.previousImage = (lastImageNo == no - 1) ? lastImage : null; 
     301    options.bitsPerSample = bmpBitsPerPixel; 
     302 
     303    if (bmpCompression == MSRLE) { 
     304      byte[] b = new byte[(int) lengths.get(no).longValue()]; 
     305      in.read(b); 
     306      MSRLECodec codec = new MSRLECodec(); 
     307      buf = codec.decompress(b, options); 
     308      lastImage = buf; 
     309      lastImageNo = no; 
     310    } 
     311    else if (bmpCompression == MS_VIDEO) { 
     312      MSVideoCodec codec = new MSVideoCodec(); 
     313      buf = codec.decompress(in, options); 
     314      lastImage = buf; 
     315      lastImageNo = no; 
     316    } 
     317    /* 
     318    else if (bmpCompression == CINEPAK) { 
     319      Object[] options = new Object[2]; 
     320      options[0] = new Integer(bmpBitsPerPixel); 
     321      options[1] = lastImage; 
     322 
     323      CinepakCodec codec = new CinepakCodec(); 
     324      buf = codec.decompress(b, options); 
     325      lastImage = buf; 
     326      if (no == core[0].imageCount - 1) lastImage = null; 
     327      return buf; 
     328    } 
     329    */ 
     330    else { 
     331      throw new FormatException("Unsupported compression : " + bmpCompression); 
     332    } 
     333    return buf; 
     334  } 
     335 
     336  private void readChunkHeader() throws IOException { 
     337    readTypeAndSize(); 
     338    fcc = in.readString(4); 
     339  } 
     340 
     341  private void readTypeAndSize() throws IOException { 
     342    type = in.readString(4); 
     343    size = in.readInt(); 
     344  } 
     345 
     346  private void readChunk() throws FormatException, IOException { 
    243347    readChunkHeader(); 
    244348 
    245349    if (type.equals("RIFF")) { 
    246       if (!fcc.equals("AVI ")) { 
     350      if (!fcc.startsWith("AVI")) { 
    247351        throw new FormatException("Sorry, AVI RIFF format not found."); 
    248352      } 
    249353    } 
    250     else throw new FormatException("Not an AVI file"); 
     354    else if (in.getFilePointer() == 12) { 
     355      throw new FormatException("Not an AVI file"); 
     356    } 
     357    else return; 
    251358 
    252359    pos = in.getFilePointer(); 
     
    441548 
    442549              spos = in.getFilePointer(); 
    443               readTypeAndSize(); 
    444               if (type.startsWith("ix")) { 
    445                 in.skipBytes(size); 
     550              boolean end = false; 
     551              while (!end) { 
    446552                readTypeAndSize(); 
     553                String oldType = type; 
     554                if (type.startsWith("ix")) { 
     555                  in.skipBytes(size); 
     556                  readTypeAndSize(); 
     557                } 
     558 
     559                String check = type.substring(2); 
     560                boolean foundPixels = false; 
     561                while (check.equals("db") || check.equals("dc") || 
     562                  check.equals("wb")) 
     563                { 
     564                  foundPixels = true; 
     565                  if (check.startsWith("d")) { 
     566                    if (size > 0 || bmpCompression != 0) { 
     567                      offsets.add(new Long(in.getFilePointer())); 
     568                      lengths.add(new Long(size)); 
     569                      in.skipBytes(size); 
     570                    } 
     571                  } 
     572 
     573                  spos = in.getFilePointer(); 
     574                  if (spos + 8 >= in.length()) return; 
     575 
     576                  readTypeAndSize(); 
     577                  if (type.equals("JUNK")) { 
     578                    in.skipBytes(size); 
     579                    spos = in.getFilePointer(); 
     580                    readTypeAndSize(); 
     581                  } 
     582                  check = type.substring(2); 
     583                } 
     584                in.seek(spos); 
     585                if (!oldType.startsWith("ix") && !foundPixels) { 
     586                  end = true; 
     587                } 
    447588              } 
    448  
    449               String check = type.substring(2); 
    450               while (check.equals("db") || check.equals("dc") || 
    451                 check.equals("wb")) 
    452               { 
    453                 if (check.startsWith("d")) { 
    454                   if (size > 0 || bmpCompression != 0) { 
    455                     offsets.add(new Long(in.getFilePointer())); 
    456                     lengths.add(new Long(size)); 
    457                     in.skipBytes(size); 
    458                   } 
    459                 } 
    460  
    461                 spos = in.getFilePointer(); 
    462  
    463                 readTypeAndSize(); 
    464                 if (type.equals("JUNK")) { 
    465                   in.skipBytes(size); 
    466                   spos = in.getFilePointer(); 
    467                   readTypeAndSize(); 
    468                 } 
    469                 check = type.substring(2); 
    470               } 
    471               in.seek(spos); 
    472589            } 
    473590          } 
     
    481598        // skipping unknown block 
    482599        readTypeAndSize(); 
    483         if (in.getFilePointer() + 8 < in.length()) { 
     600        if (in.getFilePointer() + 8 < in.length() && !type.equals("idx1")) { 
    484601          readTypeAndSize(); 
    485602        } 
    486         else break; 
     603        else if (!type.equals("idx1")) break; 
    487604        if (in.getFilePointer() + size + 4 <= in.length()) { 
    488605          in.skipBytes(size); 
    489606        } 
     607        if (type.equals("idx1")) break; 
    490608      } 
    491609      pos = in.getFilePointer(); 
    492610    } 
    493     LOGGER.info("Populating metadata"); 
    494  
    495     core[0].imageCount = offsets.size(); 
    496     core[0].sizeZ = 1; 
    497     core[0].sizeT = getImageCount(); 
    498     core[0].littleEndian = true; 
    499     core[0].interleaved = bmpBitsPerPixel != 16; 
    500  
    501     if (bmpBitsPerPixel == 32) { 
    502       core[0].sizeC = 4; 
    503       core[0].rgb = true; 
    504     } 
    505     else if (bytesPerPlane == 0 || bmpBitsPerPixel == 24) { 
    506       core[0].rgb = bmpBitsPerPixel > 8 || (bmpCompression != 0 && lut == null); 
    507       core[0].sizeC = isRGB() ? 3 : 1; 
    508     } 
    509     else { 
    510       core[0].sizeC = bytesPerPlane / 
    511         (getSizeX() * getSizeY() * (bmpBitsPerPixel / 8)); 
    512       core[0].rgb = getSizeC() > 1; 
    513     } 
    514     core[0].dimensionOrder = isRGB() ? "XYCTZ" : "XYTCZ"; 
    515     core[0].falseColor = false; 
    516     core[0].metadataComplete = true; 
    517     core[0].indexed = lut != null && !isRGB(); 
    518  
    519     if (bmpBitsPerPixel <= 8) { 
    520       core[0].pixelType = FormatTools.UINT8; 
    521       core[0].bitsPerPixel = bmpBitsPerPixel; 
    522     } 
    523     else if (bmpBitsPerPixel == 16) core[0].pixelType = FormatTools.UINT16; 
    524     else if (bmpBitsPerPixel == 24 || bmpBitsPerPixel == 32) { 
    525       core[0].pixelType = FormatTools.UINT8; 
    526     } 
    527     else { 
    528       throw new FormatException( 
    529           "Unknown matching for pixel bit width of: " + bmpBitsPerPixel); 
    530     } 
    531  
    532     if (bmpCompression != 0) core[0].pixelType = FormatTools.UINT8; 
    533  
    534     MetadataStore store = makeFilterMetadata(); 
    535     MetadataTools.populatePixels(store, this); 
    536     MetadataTools.setDefaultCreationDate(store, id, 0); 
    537   } 
    538  
    539   // -- Helper methods -- 
    540  
    541   private byte[] uncompress(int no, byte[] buf) 
    542     throws FormatException, IOException 
    543   { 
    544     CodecOptions options = new CodecOptions(); 
    545     options.width = getSizeX(); 
    546     options.height = getSizeY(); 
    547     options.previousImage = (lastImageNo == no - 1) ? lastImage : null; 
    548     options.bitsPerSample = bmpBitsPerPixel; 
    549  
    550     if (bmpCompression == MSRLE) { 
    551       byte[] b = new byte[(int) lengths.get(no).longValue()]; 
    552       in.read(b); 
    553       MSRLECodec codec = new MSRLECodec(); 
    554       buf = codec.decompress(b, options); 
    555       lastImage = buf; 
    556       lastImageNo = no; 
    557     } 
    558     else if (bmpCompression == MS_VIDEO) { 
    559       MSVideoCodec codec = new MSVideoCodec(); 
    560       buf = codec.decompress(in, options); 
    561       lastImage = buf; 
    562       lastImageNo = no; 
    563     } 
    564     /* 
    565     else if (bmpCompression == CINEPAK) { 
    566       Object[] options = new Object[2]; 
    567       options[0] = new Integer(bmpBitsPerPixel); 
    568       options[1] = lastImage; 
    569  
    570       CinepakCodec codec = new CinepakCodec(); 
    571       buf = codec.decompress(b, options); 
    572       lastImage = buf; 
    573       if (no == core[0].imageCount - 1) lastImage = null; 
    574       return buf; 
    575     } 
    576     */ 
    577     else { 
    578       throw new FormatException("Unsupported compression : " + bmpCompression); 
    579     } 
    580     return buf; 
    581   } 
    582  
    583   private void readChunkHeader() throws IOException { 
    584     readTypeAndSize(); 
    585     fcc = in.readString(4); 
    586   } 
    587  
    588   private void readTypeAndSize() throws IOException { 
    589     type = in.readString(4); 
    590     size = in.readInt(); 
    591611  } 
    592612 
  • branches/4.2/components/bio-formats/src/loci/formats/in/BDReader.java

    r7003 r7006  
    2929import java.io.FileReader; 
    3030import java.io.IOException; 
     31import java.io.StringReader; 
    3132import java.util.Arrays; 
     33import java.util.HashMap; 
    3234import java.util.Vector; 
    3335 
     
    251253 
    252254    reader.close(); 
     255 
     256    if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) { 
     257      IniParser parser = new IniParser(); 
     258      for (String metadataFile : metadataFiles) { 
     259        String filename = new Location(metadataFile).getName(); 
     260        if (!checkSuffix(metadataFile, "txt")) { 
     261          String data = DataTools.readFile(metadataFile); 
     262          IniList ini = 
     263            parser.parseINI(new BufferedReader(new StringReader(data))); 
     264          HashMap<String, String> h = ini.flattenIntoHashMap(); 
     265          for (String key : h.keySet()) { 
     266            addGlobalMeta(filename + " " + key, h.get(key)); 
     267          } 
     268        } 
     269      } 
     270    } 
    253271 
    254272    for (int i=0; i<getSeriesCount(); i++) { 
  • branches/4.2/components/bio-formats/src/loci/formats/in/BaseTiffReader.java

    r7003 r7006  
    5454    "yyyy:MM:dd HH:mm:ss", 
    5555    "dd/MM/yyyy HH:mm:ss.SS", 
    56     "MM/dd/yyyy hh:mm:ss.SSS aa" 
     56    "MM/dd/yyyy hh:mm:ss.SSS aa", 
     57    "yyyyMMdd HH:mm:ss.SSS" 
    5758  }; 
    5859 
     
    419420      // set the X and Y pixel dimensions 
    420421 
    421       int resolutionUnit = firstIFD.getIFDIntValue(IFD.RESOLUTION_UNIT); 
    422       TiffRational xResolution = firstIFD.getIFDRationalValue(IFD.X_RESOLUTION); 
    423       TiffRational yResolution = firstIFD.getIFDRationalValue(IFD.Y_RESOLUTION); 
    424       double pixX = xResolution == null ? 0 : 1 / xResolution.doubleValue(); 
    425       double pixY = yResolution == null ? 0 : 1 / yResolution.doubleValue(); 
    426  
    427       switch (resolutionUnit) { 
    428         case 2: 
    429           // resolution is expressed in pixels per inch 
    430           pixX *= 25400; 
    431           pixY *= 25400; 
    432           break; 
    433         case 3: 
    434           // resolution is expressed in pixels per centimeter 
    435           pixX *= 10000; 
    436           pixY *= 10000; 
    437           break; 
    438       } 
     422      double pixX = firstIFD.getXResolution(); 
     423      double pixY = firstIFD.getYResolution(); 
    439424 
    440425      store.setPixelsPhysicalSizeX(pixX, 0); 
  • branches/4.2/components/bio-formats/src/loci/formats/in/BioRadGelReader.java

    r6663 r7006  
    4545  // -- Constants -- 
    4646 
     47  private static final int MAGIC_BYTES = 0xafaf; 
     48 
    4749  private static final long PIXEL_OFFSET = 59654; 
     50  private static final long START_OFFSET = 160; 
     51  private static final long BASE_OFFSET = 352; 
    4852 
    4953  // -- Fields -- 
    5054 
    5155  private long offset; 
     56  private long diff; 
    5257 
    5358  // -- Constructor -- 
     
    6671    final int blockLen = 2; 
    6772    if (!FormatTools.validStream(stream, blockLen, false)) return false; 
    68     return (stream.readShort() & 0xffff) == 0xafaf; 
     73    return (stream.readShort() & 0xffff) == MAGIC_BYTES; 
    6974  } 
    7075 
     
    7782    FormatTools.checkPlaneParameters(this, no, buf.length, x, y, w, h); 
    7883 
    79     if (offset > PIXEL_OFFSET) { 
    80       in.seek(offset + 1285); 
    81     } 
    82     else in.seek(PIXEL_OFFSET); 
     84    int planeSize = FormatTools.getPlaneSize(this); 
     85 
     86    if (PIXEL_OFFSET + planeSize < in.length()) { 
     87      if (diff < 0) { 
     88        in.seek(0x379d1); 
     89      } 
     90      else in.seek(PIXEL_OFFSET); 
     91    } 
     92    else in.seek(in.length() - planeSize); 
    8393 
    8494    int bpp = FormatTools.getBytesPerPixel(getPixelType()); 
     
    103113    in = new RandomAccessInputStream(id); 
    104114 
    105     in.seek(348); 
    106     int skip = in.readInt() - 28; 
     115    String check = in.readString(48); 
     116    if (check.indexOf("Intel Format") != -1) { 
     117      in.order(true); 
     118    } 
     119 
     120    in.seek(START_OFFSET); 
     121 
     122    boolean codeFound = false; 
     123    int skip = 0; 
     124 
     125    while (!codeFound) { 
     126      short code = in.readShort(); 
     127      if (code == 0x81) codeFound = true; 
     128      short length = in.readShort(); 
     129 
     130      in.skipBytes(2 + 2 * length); 
     131      if (codeFound) { 
     132        skip = (in.readShort() & 0xffff) - 32; 
     133      } 
     134      else { 
     135        if (length == 1) in.skipBytes(12); 
     136        else if (length == 2) in.skipBytes(10); 
     137      } 
     138    } 
     139 
     140    long baseFP = in.getFilePointer(); 
     141    diff = BASE_OFFSET - baseFP; 
     142    skip += diff; 
    107143 
    108144    double physicalWidth = 0d, physicalHeight = 0d; 
    109145    if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) { 
    110       in.seek(348 + skip - 8187); 
    111       String scannerName = in.readCString(); 
    112       in.skipBytes(8); 
    113       in.readCString(); 
    114       in.skipBytes(8); 
    115       String imageArea = in.readCString(); 
    116  
    117       scannerName = scannerName.substring(scannerName.indexOf(":") + 1).trim(); 
    118       addGlobalMeta("Scanner name", scannerName); 
    119  
    120       imageArea = imageArea.substring(imageArea.indexOf(":") + 1).trim(); 
    121       int xIndex = imageArea.indexOf("x"); 
    122       if (xIndex > 0) { 
    123         String width = imageArea.substring(1, imageArea.indexOf(" ")); 
    124         String height = 
    125           imageArea.substring(xIndex + 1, imageArea.indexOf(" ", xIndex + 2)); 
    126         physicalWidth = Double.parseDouble(width.trim()) * 1000; 
    127         physicalHeight = Double.parseDouble(height.trim()) * 1000; 
    128       } 
    129     } 
    130  
    131     in.seek(348 + skip - 273); 
    132     String date = in.readCString(); 
     146      if (baseFP + skip - 8187 > 0) { 
     147        in.seek(baseFP + skip - 8187); 
     148        String scannerName = in.readCString(); 
     149        in.skipBytes(8); 
     150        in.readCString(); 
     151        in.skipBytes(8); 
     152        String imageArea = in.readCString(); 
     153 
     154        imageArea = imageArea.substring(imageArea.indexOf(":") + 1).trim(); 
     155        int xIndex = imageArea.indexOf("x"); 
     156        if (xIndex > 0) { 
     157          int space = imageArea.indexOf(" "); 
     158          if (space >= 0) { 
     159            String width = imageArea.substring(1, space); 
     160            int nextSpace = imageArea.indexOf(" ", xIndex + 2); 
     161            if (nextSpace > xIndex) { 
     162              String height = imageArea.substring(xIndex + 1, nextSpace); 
     163              physicalWidth = Double.parseDouble(width.trim()) * 1000; 
     164              physicalHeight = Double.parseDouble(height.trim()) * 1000; 
     165            } 
     166          } 
     167        } 
     168      } 
     169    } 
     170 
     171    in.seek(baseFP + skip - 298); 
     172    String date = in.readString(17); 
    133173    date = DateTools.formatDate(date, "dd-MMM-yyyy HH:mm"); 
    134  
    135     in.seek(348 + skip); 
     174    in.skipBytes(73); 
     175    String scannerName = in.readCString(); 
     176    addGlobalMeta("Scanner name", scannerName); 
     177 
     178    in.seek(baseFP + skip); 
    136179 
    137180    core[0].sizeX = in.readShort() & 0xffff; 
  • branches/4.2/components/bio-formats/src/loci/formats/in/DicomReader.java

    r6663 r7006  
    550550        case 0x7fe00000: 
    551551          in.skipBytes(elementLength); 
     552          break; 
     553        case 0: 
     554          in.seek(in.getFilePointer() - 4); 
    552555          break; 
    553556        default: 
  • branches/4.2/components/bio-formats/src/loci/formats/in/FEITiffReader.java

    r6997 r7006  
    2828import java.io.StringReader; 
    2929import java.util.ArrayList; 
     30import java.util.HashMap; 
    3031 
    3132import loci.common.DateTools; 
     
    164165 
    165166    if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) { 
    166       for (IniTable table : ini) { 
    167         String tableName = table.get(IniTable.HEADER_KEY); 
    168         for (String key : table.keySet()) { 
    169           if (!key.equals(IniTable.HEADER_KEY)) { 
    170             addGlobalMeta("[" + tableName + "] " + key, table.get(key)); 
    171           } 
    172         } 
    173       } 
     167      HashMap<String, String> iniMap = ini.flattenIntoHashMap(); 
     168      metadata.putAll(iniMap); 
    174169    } 
    175170  } 
  • branches/4.2/components/bio-formats/src/loci/formats/in/FV1000Reader.java

    r7002 r7006  
    2929import java.io.StringReader; 
    3030import java.util.Arrays; 
     31import java.util.HashMap; 
    3132import java.util.Hashtable; 
    3233import java.util.Vector; 
     
    505506      } 
    506507 
    507       for (IniTable table : f) { 
    508         String tableName = table.get(IniTable.HEADER_KEY); 
    509         String[] keys = table.keySet().toArray(new String[table.size()]); 
    510         for (String key : keys) { 
    511           addGlobalMeta(tableName + " " + key, table.get(key)); 
    512         } 
    513       } 
     508      HashMap<String, String> iniMap = f.flattenIntoHashMap(); 
     509      metadata.putAll(iniMap); 
    514510    } 
    515511 
     
    569565    core[0].dimensionOrder = "XY"; 
    570566 
     567    Hashtable<String, String> values = new Hashtable<String, String>(); 
     568    Vector<String> baseKeys = new Vector<String>(); 
     569 
    571570    for (int i=0, ii=0; ii<getImageCount(); i++, ii++) { 
    572571      String file = filenames.get(new Integer(i)); 
     
    643642          String[] keys = table.keySet().toArray(new String[table.size()]); 
    644643          for (String key : keys) { 
    645             addGlobalMeta("Image " + ii + " : " + key, table.get(key)); 
    646           } 
     644            values.put("Image " + ii + " : " + key, table.get(key)); 
     645            if (!baseKeys.contains(key)) baseKeys.add(key); 
     646          } 
     647        } 
     648      } 
     649    } 
     650 
     651    for (String key : baseKeys) { 
     652      if (key.equals("DataName") || key.indexOf("FileName") >= 0) break; 
     653      boolean equal = true; 
     654      String first = values.get("Image 0 : " + key); 
     655      for (int i=1; i<getImageCount(); i++) { 
     656        if (!first.equals(values.get("Image " + i + " : " + key))) { 
     657          equal = false; 
     658          break; 
     659        } 
     660      } 
     661      if (equal) { 
     662        addGlobalMeta(key, first); 
     663      } 
     664      else { 
     665        for (int i=0; i<getImageCount(); i++) { 
     666          String k = "Image " + i + " : " + key; 
     667          addGlobalMeta(k, values.get(k)); 
    647668        } 
    648669      } 
  • branches/4.2/components/bio-formats/src/loci/formats/in/FlexReader.java

    r7003 r7006  
    15301530      } 
    15311531      else { 
    1532         Location server = new Location(realName); 
    1533  
    15341532        LOGGER.debug("Finding base server name..."); 
    15351533        if (realName.endsWith(File.separator)) { 
  • branches/4.2/components/bio-formats/src/loci/formats/in/LeicaHandler.java

    r7003 r7006  
    153153 
    154154      if (coreMeta.sizeX == 0 && coreMeta.sizeY == 0) { 
    155         numDatasets--; 
     155        if (numDatasets > 0) numDatasets--; 
    156156      } 
    157157      else { 
     
    232232      nextROI = 0; 
    233233 
    234       int nChannels = core.get(numDatasets).rgb ? 1 : numChannels; 
    235  
    236       for (int c=0; c<detectorIndices.size(); c++) { 
    237         int index = detectorIndices.get(c).intValue(); 
    238         if (c >= nChannels || index >= nChannels || index >= 0) break; 
    239         String id = MetadataTools.createLSID("Detector", numDatasets, index); 
    240         store.setDetectorSettingsID(id, numDatasets, index); 
    241       } 
    242       for (int c=0; c<nChannels; c++) { 
    243         store.setChannelPinholeSize(pinhole, numDatasets, c); 
     234      if (numDatasets >= 0) { 
     235        int nChannels = core.get(numDatasets).rgb ? 1 : numChannels; 
     236 
     237        for (int c=0; c<detectorIndices.size(); c++) { 
     238          int index = detectorIndices.get(c).intValue(); 
     239          if (c >= nChannels || index >= nChannels || index >= 0) break; 
     240          String id = MetadataTools.createLSID("Detector", numDatasets, index); 
     241          store.setDetectorSettingsID(id, numDatasets, index); 
     242        } 
     243        for (int c=0; c<nChannels; c++) { 
     244          store.setChannelPinholeSize(pinhole, numDatasets, c); 
     245        } 
    244246      } 
    245247    } 
     
    285287    if (level != MetadataLevel.MINIMUM) { 
    286288      if (suffix != null && value != null) { 
    287         int index = 1; 
    288         while (h.get(key.toString() + suffix + " " + index) != null) index++; 
    289         h.put(key.toString() + suffix + " " + index, value); 
     289        storeKeyValue(h, key.toString() + suffix, value); 
    290290      } 
    291291      else { 
    292292        for (int i=0; i<attributes.getLength(); i++) { 
    293           int index = 1; 
    294293          String name = attributes.getQName(i); 
    295           while (h.get(key.toString() + name + " " + index) != null) { 
    296             index++; 
    297           } 
    298           h.put(key.toString() + name + " " + index, attributes.getValue(i)); 
     294          storeKeyValue(h, key.toString() + name, attributes.getValue(i)); 
    299295        } 
    300296      } 
     
    896892  private void storeSeriesHashtable(int series, Hashtable h) { 
    897893    if (series < 0) return; 
     894 
     895    Object[] keys = h.keySet().toArray(new Object[h.size()]); 
     896    for (Object key : keys) { 
     897      Object value = h.get(key); 
     898      if (value instanceof Vector) { 
     899        Vector v = (Vector) value; 
     900        for (int o=0; o<v.size(); o++) { 
     901          h.put(key + " " + (o + 1), v.get(o)); 
     902        } 
     903        h.remove(key); 
     904      } 
     905    } 
     906 
    898907    CoreMetadata coreMeta = core.get(series); 
    899908    coreMeta.seriesMetadata = h; 
     
    10581067  } 
    10591068 
     1069  private void storeKeyValue(Hashtable h, String key, String value) { 
     1070    if (h.get(key) == null) { 
     1071      h.put(key, value); 
     1072    } 
     1073    else { 
     1074      Object oldValue = h.get(key); 
     1075      if (oldValue instanceof Vector) { 
     1076        Vector values = (Vector) oldValue; 
     1077        values.add(value); 
     1078        h.put(key, values); 
     1079      } 
     1080      else { 
     1081        Vector values = new Vector(); 
     1082        values.add(oldValue); 
     1083        values.add(value); 
     1084        h.put(key, values); 
     1085      } 
     1086    } 
     1087  } 
     1088 
    10601089  // -- Helper classes -- 
    10611090 
  • branches/4.2/components/bio-formats/src/loci/formats/in/MIASReader.java

    r7003 r7006  
    101101  /** Constructs a new MIAS reader. */ 
    102102  public MIASReader() { 
    103     super("MIAS", new String[] {"tif", "tiff"}); 
     103    super("MIAS", new String[] {"tif", "tiff", "txt"}); 
    104104    suffixSufficient = false; 
    105105    domains = new String[] {FormatTools.HCS_DOMAIN}; 
     
    120120    Location baseFile = new Location(filename).getAbsoluteFile(); 
    121121    Location wellDir = baseFile.getParentFile(); 
     122    String wellName = wellDir.getName(); 
     123 
     124    if (checkSuffix(filename, "txt")) { 
     125      String name = baseFile.getName(); 
     126      return wellName.equals("results") || wellName.equals("Batchresults") || 
     127        name.equals("Nugenesistemplate.txt") || name.startsWith("mode"); 
     128    } 
     129 
    122130    Location experiment = null; 
    123131    try { 
     
    128136    if (experiment == null) return false; 
    129137 
    130     String wellName = wellDir.getName(); 
    131138    boolean validName = 
    132139      wellName.startsWith("Well") || wellName.equals("results") || 
     
    233240    Vector<String> files = new Vector<String>(); 
    234241 
    235     if (!noPixels) { 
     242    if (!noPixels && tiffs != null) { 
    236243      String[] f = new String[tiffs[getSeries()].length]; 
    237244      System.arraycopy(tiffs[getSeries()], 0, f, 0, f.length); 
     
    286293  protected void initFile(String id) throws FormatException, IOException { 
    287294    super.initFile(id); 
     295 
     296    if (checkSuffix(id, "txt")) { 
     297      // first need to find a relevant TIFF file 
     298 
     299      Location base = new Location(id).getAbsoluteFile(); 
     300      Location plate = null; 
     301      if (base.getParentFile().getName().equals("Batchresults")) { 
     302        Location experiment = base.getParentFile().getParentFile(); 
     303        String[] plates = experiment.list(true); 
     304        Arrays.sort(plates); 
     305        plate = new Location(experiment, plates[0]); 
     306      } 
     307      else { 
     308        plate = base.getParentFile(); 
     309        if (plate.getName().equals("results")) plate = plate.getParentFile(); 
     310      } 
     311 
     312      String[] list = plate.list(true); 
     313      for (String f : list) { 
     314        if (f.startsWith("Well")) { 
     315          Location well = new Location(plate, f); 
     316          String[] wellList = well.list(true); 
     317          for (String file : wellList) { 
     318            String path = new Location(well, file).getAbsolutePath(); 
     319            if (isThisType(path) && 
     320              checkSuffix(path, new String[] {"tif", "tiff"})) 
     321            { 
     322              initFile(path); 
     323              return; 
     324            } 
     325          } 
     326        } 
     327      } 
     328 
     329      throw new FormatException("Could not locate an appropriate TIFF file."); 
     330    } 
    288331 
    289332    if (!isGroupFiles()) { 
  • branches/4.2/components/bio-formats/src/loci/formats/in/NativeND2Reader.java

    r6800 r7006  
    2525 
    2626import java.io.IOException; 
    27 import java.text.DecimalFormatSymbols; 
     27import java.util.ArrayList; 
    2828import java.util.Hashtable; 
    29 import java.util.StringTokenizer; 
    30 import java.util.Vector; 
    3129 
    3230import loci.common.ByteArrayHandle; 
     
    4745import ome.xml.model.primitives.NonNegativeInteger; 
    4846import ome.xml.model.primitives.PositiveInteger; 
    49  
    50 import org.xml.sax.Attributes; 
    51 import org.xml.sax.helpers.DefaultHandler; 
    5247 
    5348/** 
     
    8681  private boolean isLossless; 
    8782 
    88   private Vector<Long> zs = new Vector<Long>(); 
    89   private Vector<Long> ts = new Vector<Long>(); 
    90   private Vector<Double> tsT = new Vector<Double>(); 
    91  
    92   private int numSeries; 
    93  
    94   private double pixelSizeX, pixelSizeY, pixelSizeZ; 
    95   private Double pinholeSize; 
    96   private String voltage, mag, na, objectiveModel, immersion, correction; 
    97   private String refractiveIndex; 
    98  
    99   private Vector<String> channelNames, modality, binning; 
    100   private Vector<Double> speed, gain, temperature, exposureTime; 
    101   private Vector<Integer> exWave, emWave, power; 
    102   private Vector<Hashtable<String, String>> rois; 
    103   private Vector<Double> posX, posY, posZ; 
    104  
    105   private String cameraModel; 
     83  private ArrayList<Double> tsT = new ArrayList<Double>(); 
    10684 
    10785  private int fieldIndex; 
    10886 
    10987  private long xOffset, yOffset, zOffset; 
     88 
     89  private ArrayList<Double> posX; 
     90  private ArrayList<Double> posY; 
     91  private ArrayList<Double> posZ; 
    11092 
    11193  // -- Constructor -- 
     
    177159    if (!fileOnly) { 
    178160      offsets = null; 
    179       zs.clear(); 
    180       ts.clear(); 
    181161      isJPEG = isLossless = false; 
    182162      codec = null; 
    183       numSeries = 0; 
    184163      tsT.clear(); 
    185164 
    186       pixelSizeX = pixelSizeY = pixelSizeZ = 0f; 
    187       voltage = mag = na = objectiveModel = immersion = correction = null; 
    188       refractiveIndex = null; 
    189       channelNames = null; 
    190       binning = null; 
    191       speed = null; 
    192       gain = null; 
    193       temperature = null; 
    194       exposureTime = null; 
    195       modality = null; 
    196       exWave = null; 
    197       emWave = null; 
    198       power = null; 
    199       cameraModel = null; 
     165      fieldIndex = 0; 
     166      xOffset = yOffset = zOffset = 0; 
    200167      posX = posY = posZ = null; 
    201       fieldIndex = 0; 
    202       rois = null; 
    203       pinholeSize = null; 
    204       xOffset = yOffset = zOffset = 0; 
    205168    } 
    206169  } 
     
    212175    super.initFile(id); 
    213176 
    214     channelNames = new Vector<String>(); 
    215     binning = new Vector<String>(); 
    216     speed = new Vector<Double>(); 
    217     gain = new Vector<Double>(); 
    218     temperature = new Vector<Double>(); 
    219     exposureTime = new Vector<Double>(); 
    220     modality = new Vector<String>(); 
    221     exWave = new Vector<Integer>(); 
    222     emWave = new Vector<Integer>(); 
    223     power = new Vector<Integer>(); 
    224     rois = new Vector<Hashtable<String, String>>(); 
    225     posX = new Vector<Double>(); 
    226     posY = new Vector<Double>(); 
    227     posZ = new Vector<Double>(); 
    228  
    229177    in = new RandomAccessInputStream(id); 
    230178 
     
    239187      // assemble offsets to each block 
    240188 
    241       Vector<String> imageNames = new Vector<String>(); 
    242       Vector<Long> imageOffsets = new Vector<Long>(); 
    243       Vector<int[]> imageLengths = new Vector<int[]>(); 
    244       Vector<Long> customDataOffsets = new Vector<Long>(); 
    245       Vector<int[]> customDataLengths = new Vector<int[]>(); 
     189      ArrayList<String> imageNames = new ArrayList<String>(); 
     190      ArrayList<Long> imageOffsets = new ArrayList<Long>(); 
     191      ArrayList<int[]> imageLengths = new ArrayList<int[]>(); 
     192      ArrayList<Long> customDataOffsets = new ArrayList<Long>(); 
     193      ArrayList<int[]> customDataLengths = new ArrayList<int[]>(); 
    246194 
    247195      ByteArrayHandle xml = new ByteArrayHandle(); 
     
    354302      // parse XML blocks 
    355303 
    356       DefaultHandler handler = new ND2Handler(); 
    357  
    358304      String xmlString = new String(xml.getBytes(), 0, (int) xml.length()); 
    359305      xmlString = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><ND2>" + 
     
    362308      core[0].dimensionOrder = ""; 
    363309 
     310      ND2Handler handler = new ND2Handler(core); 
    364311      XMLTools.parseXML(xmlString, handler); 
     312 
     313      isLossless = handler.isLossless(); 
     314      fieldIndex = handler.getFieldIndex(); 
     315      core = handler.getCoreMetadata(); 
     316      Hashtable<String, Object> globalMetadata = handler.getMetadata(); 
     317      for (String key : globalMetadata.keySet()) { 
     318        addGlobalMeta(key, globalMetadata.get(key)); 
     319      } 
     320 
     321      int numSeries = handler.getSeriesCount(); 
    365322 
    366323      // rearrange image data offsets 
     
    484441      } 
    485442 
    486       Vector<long[]> tmpOffsets = new Vector<long[]>(); 
     443      ArrayList<long[]> tmpOffsets = new ArrayList<long[]>(); 
    487444      for (int i=0; i<offsets.length; i++) { 
    488445        if (offsets[i][0] > 0) tmpOffsets.add(offsets[i]); 
     
    551508 
    552509      if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) { 
     510        posX = handler.getXPositions(); 
     511        posY = handler.getYPositions(); 
     512        posZ = handler.getZPositions(); 
     513 
    553514        if (customDataOffsets.size() > 0) { 
    554515          in.seek(customDataOffsets.get(0).longValue()); 
     
    593554      } 
    594555 
    595       populateMetadataStore(); 
     556      populateMetadataStore(handler); 
    596557      return; 
    597558    } 
     
    604565    LOGGER.info("Calculating image offsets"); 
    605566 
    606     Vector<Long> vs = new Vector<Long>(); 
     567    ArrayList<Long> vs = new ArrayList<Long>(); 
    607568 
    608569    long pos = in.getFilePointer(); 
     
    678639    LOGGER.info("Parsing XML"); 
    679640 
     641    ArrayList<Long> zs = new ArrayList<Long>(); 
     642    ArrayList<Long> ts = new ArrayList<Long>(); 
     643 
     644    int numSeries = 0; 
     645    ND2Handler handler = null; 
    680646    if (off > 0 && off < in.length() - 5 && (in.length() - off - 5) > 14) { 
    681647      in.seek(off + 4); 
     
    715681      LOGGER.info("Finished assembling XML string"); 
    716682 
    717       DefaultHandler handler = new ND2Handler(); 
    718  
    719683      // strip out invalid characters 
    720684      int offset = 0; 
     
    732696 
    733697      String xml = sb.toString().substring(offset, len - offset); 
     698      handler = new ND2Handler(core); 
    734699      XMLTools.parseXML(xml, handler); 
    735700      xml = null; 
     701 
     702      isLossless = handler.isLossless(); 
     703      fieldIndex = handler.getFieldIndex(); 
     704      zs = handler.getZSections(); 
     705      ts = handler.getTimepoints(); 
     706      numSeries = handler.getSeriesCount(); 
     707      core = handler.getCoreMetadata(); 
     708      Hashtable<String, Object> globalMetadata = handler.getMetadata(); 
     709      for (String key : globalMetadata.keySet()) { 
     710        addGlobalMeta(key, globalMetadata.get(key)); 
     711      } 
    736712    } 
    737713 
     
    810786    } 
    811787 
    812     populateMetadataStore(); 
     788    populateMetadataStore(handler); 
    813789  } 
    814790 
    815   // -- Helper class -- 
    816  
    817   /** SAX handler for parsing XML. */ 
    818   class ND2Handler extends DefaultHandler { 
    819     private String prefix = null; 
    820     private String prevRuntype = null; 
    821     private String prevElement = null; 
    822  
    823     public void endElement(String uri, String localName, String qName, 
    824       Attributes attributes) 
    825     { 
    826       if (qName.equals("CalibrationSeq") || qName.equals("MetadataSeq")) { 
    827         prefix = null; 
    828       } 
    829       if (qName.equals(prevElement)) { 
    830         prevElement = null; 
    831       } 
    832     } 
    833  
    834     public void startElement(String uri, String localName, String qName, 
    835       Attributes attributes) 
    836     { 
    837       if ("CLxListVariant".equals(attributes.getValue("runtype"))) { 
    838         prevElement = qName; 
    839       } 
    840  
    841       String value = attributes.getValue("value"); 
    842       if (qName.equals("uiWidth")) { 
    843         core[0].sizeX = Integer.parseInt(value); 
    844       } 
    845       else if (qName.equals("uiWidthBytes") || qName.equals("uiBpcInMemory")) { 
    846         int div = qName.equals("uiWidthBytes") ? getSizeX() : 8; 
    847         int bytes = Integer.parseInt(value) / div; 
    848  
    849         try { 
    850           core[0].pixelType = 
    851             FormatTools.pixelTypeFromBytes(bytes, false, false); 
    852         } 
    853         catch (FormatException e) { } 
    854         parseKeyAndValue(qName, value, prevRuntype); 
    855       } 
    856       else if ("dPosX".equals(prevElement) && qName.startsWith("item_")) { 
    857         posX.add(new Double(sanitizeDouble(value))); 
    858       } 
    859       else if ("dPosY".equals(prevElement) && qName.startsWith("item_")) { 
    860         posY.add(new Double(sanitizeDouble(value))); 
    861       } 
    862       else if ("dPosZ".equals(prevElement) && qName.startsWith("item_")) { 
    863         posZ.add(new Double(sanitizeDouble(value))); 
    864       } 
    865       else if (qName.startsWith("item_")) { 
    866         int v = Integer.parseInt(qName.substring(qName.indexOf("_") + 1)); 
    867         if (v == numSeries) { 
    868           fieldIndex = getDimensionOrder().length(); 
    869           numSeries++; 
    870         } 
    871       } 
    872       else if (qName.equals("uiCompCount")) { 
    873         int v = Integer.parseInt(value); 
    874         core[0].sizeC = (int) Math.max(getSizeC(), v); 
    875       } 
    876       else if (qName.equals("uiHeight")) { 
    877         core[0].sizeY = Integer.parseInt(value); 
    878       } 
    879       else if (qName.startsWith("TextInfo")) { 
    880         parseKeyAndValue(qName, attributes.getValue("Text"), prevRuntype); 
    881         parseKeyAndValue(qName, value, prevRuntype); 
    882       } 
    883       else if (qName.equals("dCompressionParam")) { 
    884         isLossless = Integer.parseInt(value) > 0; 
    885         parseKeyAndValue(qName, value, prevRuntype); 
    886       } 
    887       else if (qName.equals("CalibrationSeq") || qName.equals("MetadataSeq")) { 
    888         prefix = qName + " " + attributes.getValue("_SEQUENCE_INDEX"); 
    889       } 
    890       else if (qName.equals("HorizontalLine") || qName.equals("VerticalLine") || 
    891         qName.equals("Text")) 
    892       { 
    893         Hashtable<String, String> roi = new Hashtable<String, String>(); 
    894         roi.put("ROIType", qName); 
    895         for (int q=0; q<attributes.getLength(); q++) { 
    896           roi.put(attributes.getQName(q), attributes.getValue(q)); 
    897         } 
    898         rois.add(roi); 
    899       } 
    900       else if (qName.equals("dPinholeRadius")) { 
    901         pinholeSize = new Double(sanitizeDouble(value)); 
    902         addGlobalMeta("Pinhole size", value); 
    903       } 
    904       else { 
    905         StringBuffer sb = new StringBuffer(); 
    906         if (prefix != null) { 
    907           sb.append(prefix); 
    908           sb.append(" "); 
    909         } 
    910         sb.append(qName); 
    911         parseKeyAndValue(sb.toString(), value, prevRuntype); 
    912       } 
    913  
    914       prevRuntype = attributes.getValue("runtype"); 
    915     } 
    916   } 
    917  
    918791  // -- Helper methods -- 
    919792 
    920   private void populateMetadataStore() throws FormatException { 
     793  private void populateMetadataStore(ND2Handler handler) throws FormatException 
     794  { 
    921795    MetadataStore store = makeFilterMetadata(); 
    922796    MetadataTools.populatePixels(store, this, true); 
     
    941815 
    942816    // populate Dimensions data 
    943     for (int i=0; i<getSeriesCount(); i++) { 
    944       store.setPixelsPhysicalSizeX(pixelSizeX, i); 
    945       store.setPixelsPhysicalSizeY(pixelSizeY, i); 
    946       store.setPixelsPhysicalSizeZ(pixelSizeZ, i); 
     817    if (handler != null) { 
     818      for (int i=0; i<getSeriesCount(); i++) { 
     819        store.setPixelsPhysicalSizeX(handler.getPixelSizeX(), i); 
     820        store.setPixelsPhysicalSizeY(handler.getPixelSizeY(), i); 
     821        store.setPixelsPhysicalSizeZ(handler.getPixelSizeZ(), i); 
     822      } 
    947823    } 
    948824 
    949825    // populate PlaneTiming and StagePosition data 
     826    ArrayList<Double> exposureTime = null; 
     827    if (handler != null) handler.getExposureTimes(); 
    950828    for (int i=0; i<getSeriesCount(); i++) { 
    951829      if (tsT.size() > 0) { 
     
    959837 
    960838          int index = i * getSizeC() + coords[1]; 
    961           if (index < exposureTime.size()) { 
     839          if (exposureTime != null && index < exposureTime.size()) { 
    962840            store.setPlaneExposureTime(exposureTime.get(index), i, n); 
    963841          } 
    964842        } 
    965843      } 
     844 
     845      if (handler != null) { 
     846        if (posX == null) posX = handler.getXPositions(); 
     847        if (posY == null) posY = handler.getYPositions(); 
     848        if (posZ == null) posZ = handler.getZPositions(); 
     849      } 
     850 
     851      String pos = "for position #" + (i + 1); 
    966852      for (int n=0; n<getImageCount(); n++) { 
    967853        int index = i * getImageCount() + n; 
    968         if (index >= posX.size()) index = i; 
    969         if (index < posX.size()) { 
    970           store.setPlanePositionX(posX.get(index), i, n); 
    971           addSeriesMeta("X position " + (i + 1), posX.get(index)); 
    972           addGlobalMeta("X position for position #" + (i + 1), posX.get(index)); 
    973         } 
    974         if (index < posY.size()) { 
    975           store.setPlanePositionY(posY.get(index), i, n); 
    976           addSeriesMeta("Y position " + (i + 1), posY.get(index)); 
    977           addGlobalMeta("Y position for position #" + (i + 1), posY.get(index)); 
    978         } 
    979         if (index < posZ.size()) { 
    980           store.setPlanePositionZ(posZ.get(index), i, n); 
    981           String key = 
    982             "Z position for position #" + (i + 1) + ", plane #" + (n + 1); 
    983           addSeriesMeta(key, posZ.get(index)); 
    984           addGlobalMeta(key, posZ.get(index)); 
    985         } 
    986  
    987       } 
     854        if (posX != null) { 
     855          if (index >= posX.size()) index = i; 
     856          if (index < posX.size()) { 
     857            String key = "X position "; 
     858            store.setPlanePositionX(posX.get(index), i, n); 
     859            addSeriesMeta(key + (i + 1), posX.get(index)); 
     860            addGlobalMeta(key + pos, posX.get(index)); 
     861          } 
     862        } 
     863        if (posY != null) { 
     864          if (index < posY.size()) { 
     865            String key = "Y position "; 
     866            store.setPlanePositionY(posY.get(index), i, n); 
     867            addSeriesMeta(key + (i + 1), posY.get(index)); 
     868            addGlobalMeta(key + pos, posY.get(index)); 
     869          } 
     870        } 
     871        if (posZ != null) { 
     872          if (index < posZ.size()) { 
     873            store.setPlanePositionZ(posZ.get(index), i, n); 
     874            String key = "Z position " + pos + ", plane #" + (n + 1); 
     875            addSeriesMeta(key, posZ.get(index)); 
     876            addGlobalMeta(key, posZ.get(index)); 
     877          } 
     878        } 
     879      } 
     880    } 
     881 
     882    if (handler == null) { 
     883      setSeries(0); 
     884      return; 
    988885    } 
    989886 
    990887    String detectorID = MetadataTools.createLSID("Detector", 0, 0); 
    991888    store.setDetectorID(detectorID, 0, 0); 
    992     store.setDetectorModel(cameraModel, 0, 0); 
     889    store.setDetectorModel(handler.getCameraModel(), 0, 0); 
    993890    store.setDetectorType(getDetectorType("Other"), 0, 0); 
     891 
     892    ArrayList<String> channelNames = handler.getChannelNames(); 
     893    ArrayList<String> modality = handler.getModalities(); 
     894    ArrayList<String> binning = handler.getBinnings(); 
     895    ArrayList<Double> speed = handler.getSpeeds(); 
     896    ArrayList<Double> gain = handler.getGains(); 
     897    ArrayList<Double> temperature = handler.getTemperatures(); 
     898    ArrayList<Integer> exWave = handler.getExcitationWavelengths(); 
     899    ArrayList<Integer> emWave = handler.getEmissionWavelengths(); 
     900    ArrayList<Integer> power = handler.getPowers(); 
     901    ArrayList<Hashtable<String, String>> rois = handler.getROIs(); 
    994902 
    995903    for (int i=0; i<getSeriesCount(); i++) { 
    996904      for (int c=0; c<getEffectiveSizeC(); c++) { 
    997905        int index = i * getSizeC() + c; 
     906        Double pinholeSize = handler.getPinholeSize(); 
    998907        if (pinholeSize != null) { 
    999908          store.setChannelPinholeSize(pinholeSize, i, c); 
     
    1036945 
    1037946    // populate DetectorSettings 
     947    Double voltage = handler.getVoltage(); 
    1038948    if (voltage != null) { 
    1039       voltage = sanitizeDouble(voltage); 
    1040       store.setDetectorSettingsVoltage(new Double(voltage), 0, 0); 
     949      store.setDetectorSettingsVoltage(voltage, 0, 0); 
    1041950    } 
    1042951 
    1043952    // populate Objective 
     953    Double na = handler.getNumericalAperture(); 
    1044954    if (na != null) { 
    1045       na = sanitizeDouble(na); 
    1046       store.setObjectiveLensNA(new Double(na), 0, 0); 
    1047     } 
     955      store.setObjectiveLensNA(na, 0, 0); 
     956    } 
     957    Double mag = handler.getMagnification(); 
    1048958    if (mag != null) { 
    1049       mag = sanitizeDouble(mag); 
    1050       store.setObjectiveCalibratedMagnification(new Double(mag), 0, 0); 
    1051     } 
    1052     if (objectiveModel != null) { 
    1053       store.setObjectiveModel(objectiveModel, 0, 0); 
    1054     } 
     959      store.setObjectiveCalibratedMagnification(mag, 0, 0); 
     960    } 
     961    store.setObjectiveModel(handler.getObjectiveModel(), 0, 0); 
     962 
     963    String immersion = handler.getImmersion(); 
    1055964    if (immersion == null) immersion = "Other"; 
    1056965    store.setObjectiveImmersion(getImmersion(immersion), 0, 0); 
     966 
     967    String correction = handler.getCorrection(); 
    1057968    if (correction == null || correction.length() == 0) correction = "Other"; 
    1058969    store.setObjectiveCorrection(getCorrection(correction), 0, 0); 
     
    1062973    store.setObjectiveID(objectiveID, 0, 0); 
    1063974 
    1064     if (refractiveIndex != null) { 
    1065       refractiveIndex = sanitizeDouble(refractiveIndex); 
    1066     } 
     975    Double refractiveIndex = handler.getRefractiveIndex(); 
    1067976 
    1068977    for (int i=0; i<getSeriesCount(); i++) { 
    1069978      store.setImageObjectiveSettingsID(objectiveID, i); 
    1070979      if (refractiveIndex != null) { 
    1071         store.setImageObjectiveSettingsRefractiveIndex( 
    1072           new Double(refractiveIndex), i); 
     980        store.setImageObjectiveSettingsRefractiveIndex(refractiveIndex, i); 
    1073981      } 
    1074982    } 
     
    1081989      return; 
    1082990    } 
    1083     for (int r=0; r<rois.size(); r++) { 
    1084       Hashtable<String, String> roi = rois.get(r); 
    1085       String type = roi.get("ROIType"); 
    1086  
    1087       if (type.equals("Text")) { 
    1088         store.setTextFontSize( 
    1089           NonNegativeInteger.valueOf(roi.get("fHeight")), r, 0); 
    1090         store.setTextValue(roi.get("eval-text"), r, 0); 
    1091         store.setTextStrokeWidth(new Double(roi.get("line-width")), r, 0); 
    1092  
    1093         String rectangle = roi.get("rectangle"); 
    1094         String[] p = rectangle.split(","); 
    1095         double[] points = new double[p.length]; 
    1096         for (int i=0; i<p.length; i++) { 
    1097           points[i] = Double.parseDouble(p[i]); 
    1098         } 
    1099  
    1100         store.setRectangleX(points[0], r, 1); 
    1101         store.setRectangleY(points[1], r, 1); 
    1102         store.setRectangleWidth(points[2] - points[0], r, 1); 
    1103         store.setRectangleHeight(points[3] - points[1], r, 1); 
    1104       } 
    1105       else if (type.equals("HorizontalLine") || type.equals("VerticalLine")) { 
    1106         String segments = roi.get("segments"); 
    1107         segments = segments.replaceAll("\\[", ""); 
    1108         segments = segments.replaceAll("\\]", ""); 
    1109         String[] points = segments.split("\\)"); 
    1110  
    1111         StringBuffer sb = new StringBuffer(); 
    1112         for (int i=0; i<points.length; i++) { 
    1113           points[i] = points[i].substring(points[i].indexOf(":") + 1); 
    1114           sb.append(points[i]); 
    1115           if (i < points.length - 1) sb.append(" "); 
    1116         } 
    1117         store.setPolylinePoints(sb.toString(), r, 0); 
    1118       } 
    1119     } 
    1120   } 
    1121  
    1122   private void parseKeyAndValue(String key, String value, String runtype) { 
    1123     if (key == null || value == null) return; 
    1124     addGlobalMeta(key, value); 
    1125     if (key.endsWith("dCalibration")) { 
    1126       pixelSizeX = Double.parseDouble(sanitizeDouble(value)); 
    1127       pixelSizeY = pixelSizeX; 
    1128     } 
    1129     else if (key.endsWith("dZStep")) { 
    1130       pixelSizeZ = Double.parseDouble(sanitizeDouble(value)); 
    1131     } 
    1132     else if (key.endsWith("Gain")) gain.add(new Double(sanitizeDouble(value))); 
    1133     else if (key.endsWith("dLampVoltage")) voltage = value; 
    1134     else if (key.endsWith("dObjectiveMag") && mag == null) mag = value; 
    1135     else if (key.endsWith("dObjectiveNA")) na = value; 
    1136     else if (key.endsWith("dRefractIndex1")) refractiveIndex = value; 
    1137     else if (key.equals("sObjective") || key.equals("wsObjectiveName")) { 
    1138       String[] tokens = value.split(" "); 
    1139       int magIndex = -1; 
    1140       for (int i=0; i<tokens.length; i++) { 
    1141         if (tokens[i].indexOf("x") != -1) { 
    1142           magIndex = i; 
    1143           break; 
    1144         } 
    1145       } 
    1146       StringBuffer s = new StringBuffer(); 
    1147       for (int i=0; i<magIndex; i++) { 
    1148         s.append(tokens[i]); 
    1149       } 
    1150       correction = s.toString(); 
    1151       if (magIndex >= 0) { 
    1152         mag = tokens[magIndex].substring(0, tokens[magIndex].indexOf("x")); 
    1153       } 
    1154       if (magIndex + 1 < tokens.length) immersion = tokens[magIndex + 1]; 
    1155     } 
    1156     else if (key.endsWith("dTimeMSec")) { 
    1157       long v = (long) Double.parseDouble(sanitizeDouble(value)); 
    1158       if (!ts.contains(new Long(v))) { 
    1159         ts.add(new Long(v)); 
    1160         addGlobalMeta("number of timepoints", ts.size()); 
    1161       } 
    1162     } 
    1163     else if (key.endsWith("dZPos")) { 
    1164       long v = (long) Double.parseDouble(sanitizeDouble(value)); 
    1165       if (!zs.contains(new Long(v))) { 
    1166         zs.add(new Long(v)); 
    1167       } 
    1168     } 
    1169     else if (key.endsWith("uiCount")) { 
    1170       if (runtype != null) { 
    1171         if (runtype.endsWith("ZStackLoop")) { 
    1172           if (getSizeZ() == 0) { 
    1173             core[0].sizeZ = Integer.parseInt(value); 
    1174             if (getDimensionOrder().indexOf("Z") == -1) { 
    1175               core[0].dimensionOrder = "Z" + getDimensionOrder(); 
    1176             } 
    1177           } 
    1178         } 
    1179         else if (runtype.endsWith("TimeLoop")) { 
    1180           if (getSizeT() == 0) { 
    1181             core[0].sizeT = Integer.parseInt(value); 
    1182             if (getDimensionOrder().indexOf("T") == -1) { 
    1183               core[0].dimensionOrder = "T" + getDimensionOrder(); 
    1184             } 
    1185           } 
    1186         } 
    1187       } 
    1188     } 
    1189     else if (key.endsWith("uiBpcSignificant")) { 
    1190       core[0].bitsPerPixel = Integer.parseInt(value); 
    1191     } 
    1192     else if (key.equals("VirtualComponents")) { 
    1193       if (getSizeC() == 0) { 
    1194         core[0].sizeC = Integer.parseInt(value); 
    1195         if (getDimensionOrder().indexOf("C") == -1) { 
    1196           core[0].dimensionOrder += "C" + getDimensionOrder(); 
    1197         } 
    1198       } 
    1199     } 
    1200     else if (key.startsWith("TextInfoItem") || key.endsWith("TextInfoItem")) { 
    1201       metadata.remove(key); 
    1202       value = value.replaceAll("&#x000d;&#x000a;", "\n"); 
    1203       StringTokenizer tokens = new StringTokenizer(value, "\n"); 
    1204       while (tokens.hasMoreTokens()) { 
    1205         String t = tokens.nextToken().trim(); 
    1206         if (t.startsWith("Dimensions:")) { 
    1207           t = t.substring(11); 
    1208           StringTokenizer dims = new StringTokenizer(t, " x "); 
    1209  
    1210           if (getSizeZ() == 0) core[0].sizeZ = 1; 
    1211           if (getSizeT() == 0) core[0].sizeT = 1; 
    1212           if (getSizeC() == 0) core[0].sizeC = 1; 
    1213  
    1214           while (dims.hasMoreTokens()) { 
    1215             String dim = dims.nextToken().trim(); 
    1216             int v = Integer.parseInt(dim.replaceAll("\\D", "")); 
    1217             v = (int) Math.max(v, 1); 
    1218             if (dim.startsWith("XY")) { 
    1219               numSeries = v; 
    1220               if (numSeries > 1) { 
    1221                 int x = getSizeX(); 
    1222                 int y = getSizeY(); 
    1223                 int z = getSizeZ(); 
    1224                 int tSize = getSizeT(); 
    1225                 int c = getSizeC(); 
    1226                 String order = getDimensionOrder(); 
    1227                 core = new CoreMetadata[numSeries]; 
    1228                 for (int i=0; i<numSeries; i++) { 
    1229                   core[i] = new CoreMetadata(); 
    1230                   core[i].sizeX = x; 
    1231                   core[i].sizeY = y; 
    1232                   core[i].sizeZ = z == 0 ? 1 : z; 
    1233                   core[i].sizeC = c == 0 ? 1 : c; 
    1234                   core[i].sizeT = tSize == 0 ? 1 : tSize; 
    1235                   core[i].dimensionOrder = order; 
    1236                 } 
    1237               } 
    1238             } 
    1239             else if (dim.startsWith("T")) { 
    1240               if (getSizeT() <= 1 || v < getSizeT()) { 
    1241                 core[0].sizeT = v; 
    1242               } 
    1243             } 
    1244             else if (dim.startsWith("Z")) { 
    1245               if (getSizeZ() <= 1) { 
    1246                 core[0].sizeZ = v; 
    1247               } 
    1248             } 
    1249             else if (getSizeC() <= 1) { 
    1250               core[0].sizeC = v; 
    1251             } 
    1252           } 
    1253  
    1254           core[0].imageCount = getSizeZ() * getSizeC() * getSizeT(); 
    1255         } 
    1256         else if (t.startsWith("Number of Picture Planes")) { 
    1257           core[0].sizeC = Integer.parseInt(t.replaceAll("\\D", "")); 
    1258         } 
    1259         else { 
    1260           String[] v = t.split(":"); 
    1261           if (v.length == 2) { 
    1262             v[1] = v[1].trim(); 
    1263             if (v[0].equals("Name")) { 
    1264               channelNames.add(v[1]); 
    1265             } 
    1266             else if (v[0].equals("Modality")) { 
    1267               modality.add(v[1]); 
    1268             } 
    1269             else if (v[0].equals("Camera Type")) { 
    1270               cameraModel = v[1]; 
    1271             } 
    1272             else if (v[0].equals("Binning")) { 
    1273               binning.add(v[1]); 
    1274             } 
    1275             else if (v[0].equals("Readout Speed")) { 
    1276               int last = v[1].lastIndexOf(" "); 
    1277               if (last != -1) v[1] = v[1].substring(0, last); 
    1278               speed.add(new Double(sanitizeDouble(v[1]))); 
    1279             } 
    1280             else if (v[0].equals("Temperature")) { 
    1281               String temp = v[1].replaceAll("[\\D&&[^-.]]", ""); 
    1282               temperature.add(new Double(sanitizeDouble(temp))); 
    1283             } 
    1284             else if (v[0].equals("Exposure")) { 
    1285               String[] s = v[1].trim().split(" "); 
    1286               try { 
    1287                 double time = Double.parseDouble(sanitizeDouble(s[0])); 
    1288                 // TODO: check for other units 
    1289                 if (s[1].equals("ms")) time /= 1000; 
    1290                 exposureTime.add(new Double(time)); 
    1291               } 
    1292               catch (NumberFormatException e) { } 
    1293             } 
    1294             else if (v[0].equals("{Pinhole Size}")) { 
    1295               pinholeSize = new Double(sanitizeDouble(v[1])); 
    1296               addGlobalMeta("Pinhole size", v[1]); 
    1297             } 
    1298           } 
    1299           else if (v[0].startsWith("- Step")) { 
    1300             int space = v[0].indexOf(" ", v[0].indexOf("Step") + 1); 
    1301             int last = v[0].indexOf(" ", space + 1); 
    1302             if (last == -1) last = v[0].length(); 
    1303             pixelSizeZ = 
    1304               Double.parseDouble(sanitizeDouble(v[0].substring(space, last))); 
    1305           } 
    1306           else if (v[0].equals("Line")) { 
    1307             String[] values = t.split(";"); 
    1308             for (int q=0; q<values.length; q++) { 
    1309               int colon = values[q].indexOf(":"); 
    1310               if (colon < 0) continue; 
    1311               String nextKey = values[q].substring(0, colon).trim(); 
    1312               String nextValue = values[q].substring(colon + 1).trim(); 
    1313               if (nextKey.equals("Emission wavelength")) { 
    1314                 emWave.add(new Integer(nextValue)); 
    1315               } 
    1316               else if (nextKey.equals("Excitation wavelength")) { 
    1317                 exWave.add(new Integer(nextValue)); 
    1318               } 
    1319               else if (nextKey.equals("Power")) { 
    1320                 nextValue = sanitizeDouble(nextValue); 
    1321                 power.add(new Integer((int) Double.parseDouble(nextValue))); 
    1322               } 
    1323             } 
    1324           } 
    1325           else if (v.length > 1) { 
    1326             v[0] = v[0].replace('{', ' '); 
    1327             v[0] = v[0].replace('}', ' '); 
    1328             addGlobalMeta(v[0].trim(), v[1]); 
    1329           } 
    1330         } 
    1331       } 
    1332     } 
    1333   } 
    1334  
    1335   private String sanitizeDouble(String value) { 
    1336     value = value.replaceAll("[^0-9,\\.]", ""); 
    1337     char separator = new DecimalFormatSymbols().getDecimalSeparator(); 
    1338     if (value.indexOf(separator) == -1) { 
    1339       char usedSeparator = separator == '.' ? ',' : '.'; 
    1340       value = value.replace(usedSeparator, separator); 
    1341     } 
    1342     return value; 
     991    handler.populateROIs(store); 
    1343992  } 
    1344993 
  • branches/4.2/components/bio-formats/src/loci/formats/in/OMETiffReader.java

    r7003 r7006  
    393393 
    394394      int tiffDataCount = meta.getTiffDataCount(i); 
     395      boolean zOneIndexed = false; 
     396      boolean cOneIndexed = false; 
     397      boolean tOneIndexed = false; 
     398 
     399      // pre-scan TiffData indices to see if any of them are indexed from 1 
     400 
     401      for (int td=0; td<tiffDataCount; td++) { 
     402        NonNegativeInteger firstC = meta.getTiffDataFirstC(i, td); 
     403        NonNegativeInteger firstT = meta.getTiffDataFirstT(i, td); 
     404        NonNegativeInteger firstZ = meta.getTiffDataFirstZ(i, td); 
     405        int c = firstC == null ? 0 : firstC.getValue(); 
     406        int t = firstT == null ? 0 : firstT.getValue(); 
     407        int z = firstZ == null ? 0 : firstZ.getValue(); 
     408 
     409        if (c >= effSizeC) cOneIndexed = true; 
     410        if (z >= sizeZ) zOneIndexed = true; 
     411        if (t >= sizeT) tOneIndexed = true; 
     412      } 
     413 
    395414      for (int td=0; td<tiffDataCount; td++) { 
    396415        LOGGER.debug("    TiffData[{}] {", td); 
     
    419438 
    420439        // NB: some writers index FirstC, FirstZ and FirstT from 1 
    421         if (c >= effSizeC) c--; 
    422         if (z >= sizeZ) z--; 
    423         if (t >= sizeT) t--; 
     440        if (cOneIndexed) c--; 
     441        if (zOneIndexed) z--; 
     442        if (tOneIndexed) t--; 
    424443 
    425444        int index = FormatTools.getIndex(order, 
     
    545564        core[s].imageCount = num; 
    546565        core[s].dimensionOrder = meta.getPixelsDimensionOrder(i).toString(); 
     566 
     567        // hackish workaround for files exported by OMERO that have an 
     568        // incorrect dimension order 
     569        if (meta.getChannelCount(i) > 0 && meta.getChannelName(i, 0) == null && 
     570          meta.getTiffDataCount(i) > 0 && 
     571          meta.getUUIDFileName(i, 0).indexOf("__omero_export") != -1) 
     572        { 
     573          int zIndex = core[s].dimensionOrder.indexOf("Z"); 
     574          int tIndex = core[s].dimensionOrder.indexOf("T"); 
     575          core[s].dimensionOrder = zIndex < tIndex ? "XYCZT" : "XYCTZ"; 
     576        } 
     577 
    547578        core[s].orderCertain = true; 
    548579        PhotoInterp photo = firstIFD.getPhotometricInterpretation(); 
     
    603634    info = planeInfo.toArray(new OMETiffPlane[0][0]); 
    604635 
    605     MetadataTools.populatePixels(metadataStore, this); 
     636    MetadataTools.populatePixels(metadataStore, this, false, false); 
    606637    metadataStore = getMetadataStoreForDisplay(); 
    607638  } 
  • branches/4.2/components/bio-formats/src/loci/formats/in/OMEXMLReader.java

    r7003 r7006  
    5151 
    5252import org.xml.sax.Attributes; 
     53import org.xml.sax.Locator; 
    5354import org.xml.sax.helpers.DefaultHandler; 
    5455 
     
    8788 
    8889  // compression value and offset for each BinData element 
     90  private Vector<BinData> binData; 
    8991  private Vector<Long> binDataOffsets; 
    90   private Vector<Long> binDataLengths; 
    9192  private Vector<String> compression; 
    9293 
     
    136137 
    137138    long offset = binDataOffsets.get(index).longValue(); 
    138     long length = binDataLengths.get(index).longValue(); 
    139139    String compress = compression.get(index); 
    140140 
    141     in.seek(offset - 64); 
    142  
    143     // offset is approximate, we will need to skip a few bytes 
    144     boolean foundBinData = false; 
    145     byte[] check = new byte[8192]; 
    146     int overlap = 14; 
    147     int n = in.read(check, 0, overlap); 
    148  
    149     while (!foundBinData) { 
    150       int r = in.read(check, overlap, check.length - overlap); 
    151       if (r <= 0) throw new IOException("Cannot read from input stream"); 
    152       n += r; 
    153       String checkString = new String(check); 
    154       int pos = 0; 
    155       while (checkString.indexOf("BinData", pos) != -1 && 
    156         pos < checkString.length() && pos >= 0) 
    157       { 
    158         int idx = checkString.indexOf("BinData", pos) + 7; 
    159         pos = idx + 1; 
    160         boolean foundBeginning = false; 
    161         int openBracket = idx; 
    162         while (!foundBeginning && openBracket >= 1) { 
    163           openBracket--; 
    164           foundBeginning = checkString.charAt(openBracket) == '<'; 
    165         } 
    166         if (checkString.charAt(openBracket + 1) == '/') continue; 
    167         foundBinData = true; 
    168         in.seek(in.getFilePointer() - n + idx); 
    169         while (true) { 
    170           r = in.read(); 
    171           if (r <= 0) { 
    172             throw new IOException("EOF looking for terminating > character"); 
    173           } 
    174           if (r == '>') break; 
    175         } 
    176         if (foundBinData) break; 
    177       } 
    178       if (!foundBinData) { 
    179         System.arraycopy(check, check.length - overlap, check, 0, overlap); 
    180         n = overlap; 
    181       } 
    182     } 
    183  
    184     if (length < 0 && index + 1 < binDataOffsets.size()) { 
    185       length = binDataOffsets.get(index + 1).longValue() - offset; 
    186     } 
    187     else if (length < 0) { 
    188       length = in.length() - offset; 
    189     } 
     141    in.seek(offset); 
    190142 
    191143    int depth = FormatTools.getBytesPerPixel(getPixelType()); 
     
    243195      compression = null; 
    244196      binDataOffsets = null; 
    245       binDataLengths = null; 
     197      binData = null; 
    246198      omexml = null; 
    247199      hasSPW = false; 
     
    258210    in = new RandomAccessInputStream(id); 
    259211 
     212    binData = new Vector<BinData>(); 
    260213    binDataOffsets = new Vector<Long>(); 
    261     binDataLengths = new Vector<Long>(); 
    262214    compression = new Vector<String>(); 
    263215 
     
    270222    catch (IOException e) { 
    271223      throw new FormatException("Malformed OME-XML", e); 
     224    } 
     225 
     226    int lineNumber = 1; 
     227    for (BinData bin : binData) { 
     228      int line = bin.getRow(); 
     229      int col = bin.getColumn(); 
     230 
     231      while (lineNumber < line) { 
     232        in.readLine(); 
     233        lineNumber++; 
     234      } 
     235      binDataOffsets.add(in.getFilePointer() + col - 1); 
    272236    } 
    273237 
     
    349313  class OMEXMLHandler extends DefaultHandler { 
    350314    private StringBuffer xmlBuffer; 
    351     private long nextBinDataOffset; 
    352315    private String currentQName; 
    353     private boolean hadCharData; 
    354     private int binDataChars; 
     316    private Locator locator; 
    355317 
    356318    public OMEXMLHandler() { 
    357319      xmlBuffer = new StringBuffer(); 
    358       nextBinDataOffset = 0; 
    359320    } 
    360321 
    361322    public void characters(char[] ch, int start, int length) { 
    362       if (currentQName.indexOf("BinData") != -1) { 
    363         binDataChars += length; 
     323      if (currentQName.indexOf("BinData") < 0) { 
     324        xmlBuffer.append(new String(ch, start, length)); 
    364325      } 
    365       else xmlBuffer.append(new String(ch, start, length)); 
    366       nextBinDataOffset += length; 
    367       hadCharData = true; 
    368326    } 
    369327 
     
    372330      xmlBuffer.append(qName); 
    373331      xmlBuffer.append(">"); 
    374       if (qName.indexOf("BinData") >= 0) { 
    375         binDataOffsets.add(new Long(nextBinDataOffset - binDataChars)); 
    376       } 
    377  
    378       nextBinDataOffset += 2; 
    379       if (!qName.equals(currentQName) || hadCharData) { 
    380         nextBinDataOffset += qName.length(); 
    381       } 
    382     } 
    383  
    384     public void ignorableWhitespace(char[] ch, int start, int length) { 
    385       nextBinDataOffset += length; 
    386332    } 
    387333 
     
    389335      Attributes attributes) 
    390336    { 
    391       hadCharData = false; 
    392337      currentQName = qName; 
    393338 
     
    417362      } 
    418363      else { 
    419         String length = attributes.getValue("Length"); 
    420         if (length == null) { 
    421           binDataLengths.add(new Long(-1)); 
    422         } 
    423         else binDataLengths.add(new Long(length)); 
     364        binData.add( 
     365          new BinData(locator.getLineNumber(), locator.getColumnNumber())); 
    424366        String compress = attributes.getValue("Compression"); 
    425367        compression.add(compress == null ? "" : compress); 
    426         binDataChars = 0; 
    427368 
    428369        xmlBuffer.append("<"); 
     
    440381        xmlBuffer.append(">"); 
    441382      } 
    442  
    443       nextBinDataOffset += 2 + qName.length() + 4*attributes.getLength(); 
    444       for (int i=0; i<attributes.getLength(); i++) { 
    445         nextBinDataOffset += attributes.getQName(i).length(); 
    446         nextBinDataOffset += attributes.getValue(i).length(); 
    447       } 
    448383    } 
    449384 
     
    452387    } 
    453388 
     389    public void setDocumentLocator(Locator locator) { 
     390      this.locator = locator; 
     391    } 
     392  } 
     393 
     394  class BinData { 
     395    private int row; 
     396    private int column; 
     397 
     398    public BinData(int row, int column) { 
     399      this.row = row; 
     400      this.column = column; 
     401    } 
     402 
     403    public int getRow() { return row; } 
     404    public int getColumn() { return column; } 
    454405  } 
    455406 
  • branches/4.2/components/bio-formats/src/loci/formats/in/PrairieReader.java

    r6663 r7006  
    4343import loci.formats.tiff.TiffParser; 
    4444 
     45import ome.xml.model.primitives.PositiveInteger; 
     46 
    4547import org.xml.sax.Attributes; 
    4648import org.xml.sax.helpers.DefaultHandler; 
     
    8284  private boolean readXML = false, readCFG = false; 
    8385 
    84   private int zt; 
    8586  private Vector<String> f, gains, offsets; 
    86   private boolean isZ; 
    8787  private double pixelSizeX, pixelSizeY; 
    8888  private String date, laserPower; 
     89 
     90  private String microscopeModel; 
     91  private String objectiveManufacturer; 
     92  private PositiveInteger magnification; 
     93  private String immersion; 
     94  private Double lensNA; 
     95  private Double waitTime; 
     96 
     97  private Vector<Double> deltaT = new Vector<Double>(); 
     98  private Vector<Double> positionX = new Vector<Double>(); 
     99  private Vector<Double> positionY = new Vector<Double>(); 
     100  private Vector<Double> positionZ = new Vector<Double>(); 
     101  private Vector<String> channels = new Vector<String>(); 
     102 
     103  private Double zoom; 
    89104 
    90105  // -- Constructor -- 
     
    201216      readXML = false; 
    202217      readCFG = false; 
    203       isZ = false; 
    204       zt = 0; 
    205218      f = gains = offsets = null; 
    206219      pixelSizeX = pixelSizeY = 0; 
    207220      date = laserPower = null; 
     221      microscopeModel = null; 
     222      objectiveManufacturer = null; 
     223      magnification = null; 
     224      immersion = null; 
     225      lensNA = null; 
     226      deltaT.clear(); 
     227      positionX.clear(); 
     228      positionY.clear(); 
     229      positionZ.clear(); 
     230      channels.clear(); 
     231      zoom = null; 
     232      waitTime = null; 
    208233    } 
    209234  } 
     
    238263      gains = new Vector<String>(); 
    239264      offsets = new Vector<String>(); 
    240       zt = 0; 
    241  
    242       String xml = DataTools.readFile(id); 
     265 
     266      String xml = XMLTools.sanitizeXML(DataTools.readFile(id)).trim(); 
    243267 
    244268      if (checkSuffix(id, XML_SUFFIX)) { 
     
    248272      DefaultHandler handler = new PrairieHandler(); 
    249273      XMLTools.parseXML(xml, handler); 
     274 
     275      core[0].sizeT = getImageCount() / (getSizeZ() * getSizeC()); 
     276 
     277      boolean minimumMetadata = 
     278        getMetadataOptions().getMetadataLevel() == MetadataLevel.MINIMUM; 
     279      MetadataStore store = makeFilterMetadata(); 
    250280 
    251281      if (checkSuffix(id, XML_SUFFIX)) { 
     
    259289        LOGGER.info("Populating metadata"); 
    260290 
    261         if (zt == 0) zt = 1; 
    262  
    263         core[0].sizeZ = isZ ? zt : 1; 
    264         core[0].sizeT = isZ ? 1 : zt; 
    265         core[0].sizeC = getImageCount() / (getSizeZ() * getSizeT()); 
    266         core[0].dimensionOrder = "XYC" + (isZ ? "ZT" : "TZ"); 
     291        if (getSizeZ() == 0) core[0].sizeZ = 1; 
     292        if (getSizeT() == 0) core[0].sizeT = 1; 
     293 
     294        core[0].dimensionOrder = "XYCZT"; 
    267295        core[0].pixelType = FormatTools.UINT16; 
    268296        core[0].rgb = false; 
     
    271299        core[0].indexed = tiff.isIndexed(); 
    272300        core[0].falseColor = false; 
    273  
    274         MetadataStore store = makeFilterMetadata(); 
    275         MetadataTools.populatePixels(store, this); 
    276  
    277301        if (date != null) { 
    278302          date = DateTools.formatDate(date, "MM/dd/yyyy h:mm:ss a"); 
     
    281305        else MetadataTools.setDefaultCreationDate(store, id, 0); 
    282306 
    283         if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) { 
     307        MetadataTools.populatePixels(store, this, !minimumMetadata); 
     308 
     309        if (!minimumMetadata) { 
    284310          // link Instrument and Image 
    285311          String instrumentID = MetadataTools.createLSID("Instrument", 0); 
     
    305331            store.setDetectorSettingsID(detectorID, 0, i); 
    306332            store.setDetectorType(getDetectorType("Other"), 0, i); 
    307           } 
    308  
    309           /* TODO : check if this is correct 
     333            store.setDetectorZoom(zoom, 0, i); 
     334 
     335            if (i < channels.size()) { 
     336              store.setChannelName(channels.get(i), 0, i); 
     337            } 
     338          } 
     339 
     340          for (int i=0; i<getImageCount(); i++) { 
     341            int[] zct = getZCTCoords(i); 
     342            int index = FormatTools.getIndex(getDimensionOrder(), getSizeZ(), 
     343              1, getSizeT(), getImageCount() / getSizeC(), zct[0], 0, zct[2]); 
     344            store.setPlanePositionX(positionX.get(index), 0, i); 
     345            store.setPlanePositionY(positionY.get(index), 0, i); 
     346            store.setPlanePositionZ(positionZ.get(index), 0, i); 
     347          } 
     348 
     349          if (microscopeModel != null) { 
     350            store.setMicroscopeModel(microscopeModel, 0); 
     351          } 
     352 
     353          String objective = MetadataTools.createLSID("Objective", 0, 0); 
     354          store.setObjectiveID(objective, 0, 0); 
     355          store.setImageObjectiveSettingsID(objective, 0); 
     356 
     357          store.setObjectiveNominalMagnification(magnification, 0, 0); 
     358          store.setObjectiveManufacturer(objectiveManufacturer, 0, 0); 
     359          store.setObjectiveImmersion(getImmersion(immersion), 0, 0); 
     360          store.setObjectiveCorrection(getCorrection("Other"), 0, 0); 
     361          store.setObjectiveLensNA(lensNA, 0, 0); 
     362 
    310363          if (laserPower != null) { 
     364            String laser = MetadataTools.createLSID("LightSource", 0 ,0); 
     365            store.setLaserID(laser, 0, 0); 
    311366            store.setLaserPower(new Double(laserPower), 0, 0); 
    312367          } 
    313           */ 
    314         } 
     368        } 
     369      } 
     370      else if (checkSuffix(id, CFG_SUFFIX)) { 
     371        store.setPixelsTimeIncrement(waitTime, 0); 
    315372      } 
    316373 
     
    375432        date = attributes.getValue("date"); 
    376433      } 
    377       else if (qName.equals("Frame")) zt++; 
    378       else if (qName.equals("Sequence")) { 
    379         isZ = attributes.getValue("type").equals("ZSeries"); 
     434      else if (qName.equals("Frame")) { 
     435        String index = attributes.getValue("index"); 
     436        if (index != null) { 
     437          int zIndex = Integer.parseInt(index); 
     438          if (zIndex > getSizeZ()) core[0].sizeZ++; 
     439        } 
    380440      } 
    381441      else if (qName.equals("File")) { 
     
    388448        } 
    389449        f.add(dir + attributes.getValue("filename")); 
     450 
     451        String ch = attributes.getValue("channel"); 
     452        String channelName = attributes.getValue("channelName"); 
     453        if (channelName == null) channelName = ch; 
     454        if (ch != null) { 
     455          int cIndex = Integer.parseInt(ch); 
     456          if (cIndex > getSizeC() && !channels.contains(channelName)) { 
     457            core[0].sizeC++; 
     458            channels.add(channelName); 
     459          } 
     460        } 
    390461      } 
    391462      else if (qName.equals("Key")) { 
     
    406477          pixelSizeY = Double.parseDouble(value); 
    407478        } 
     479        else if (key.equals("objectiveLens")) { 
     480          String[] tokens = value.split(" "); 
     481          if (tokens.length > 0) { 
     482            objectiveManufacturer = tokens[0]; 
     483          } 
     484          if (tokens.length > 1) { 
     485            String mag = tokens[1].toLowerCase().replaceAll("x", ""); 
     486            magnification = new PositiveInteger(new Integer(mag)); 
     487          } 
     488          if (tokens.length > 2) { 
     489            immersion = tokens[2]; 
     490          } 
     491        } 
     492        else if (key.equals("objectiveLensNA")) { 
     493          lensNA = new Double(value); 
     494        } 
     495        else if (key.equals("imagingDevice")) { 
     496          microscopeModel = value; 
     497        } 
    408498        else if (key.startsWith("pmtGain_")) gains.add(value); 
    409499        else if (key.startsWith("pmtOffset_")) offsets.add(value); 
    410500        else if (key.equals("laserPower_0")) laserPower = value; 
     501        else if (key.equals("positionCurrent_XAxis")) { 
     502          positionX.add(new Double(value)); 
     503        } 
     504        else if (key.equals("positionCurrent_YAxis")) { 
     505          positionY.add(new Double(value)); 
     506        } 
     507        else if (key.equals("positionCurrent_ZAxis")) { 
     508          positionZ.add(new Double(value)); 
     509        } 
     510        else if (key.equals("opticalZoom")) { 
     511          zoom = new Double(value); 
     512        } 
     513        else if (key.equals("bitDepth")) { 
     514          core[0].bitsPerPixel = Integer.parseInt(value); 
     515        } 
     516      } 
     517      else if (qName.equals("PVTSeriesElementWait")) { 
     518        waitTime = new Double(attributes.getValue("waitTime")); 
    411519      } 
    412520    } 
  • branches/4.2/components/bio-formats/src/loci/formats/in/SimplePCITiffReader.java

    r6997 r7006  
    2828import java.io.StringReader; 
    2929import java.util.ArrayList; 
     30import java.util.HashMap; 
    3031 
    3132import loci.common.DateTools; 
     
    181182 
    182183    if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) { 
    183       for (IniTable table : ini) { 
    184         String tableName = table.get(IniTable.HEADER_KEY); 
    185         for (String key : table.keySet()) { 
    186           if (!key.equals(IniTable.HEADER_KEY)) { 
    187             addGlobalMeta("[" + tableName + "] " + key, table.get(key)); 
    188           } 
    189         } 
    190       } 
     184      HashMap<String, String> iniMap = ini.flattenIntoHashMap(); 
     185      metadata.putAll(iniMap); 
    191186    } 
    192187  } 
  • branches/4.2/components/bio-formats/src/loci/formats/in/SlidebookReader.java

    r6663 r7006  
    344344    // determine total number of pixel bytes 
    345345 
    346     float pixelSize = 1; 
     346    Vector<Float> pixelSize = new Vector<Float>(); 
    347347    String objective = null; 
    348348    Vector<Double> pixelSizeZ = new Vector<Double>(); 
     
    457457          objective = in.readCString(); 
    458458          in.seek(fp + 144); 
    459           pixelSize = in.readFloat(); 
     459          pixelSize.add(in.readFloat()); 
    460460        } 
    461461        else if (n == 'e') { 
     
    469469        else if (n == 'k') { 
    470470          in.skipBytes(14); 
    471           setSeries(nextName - 1); 
     471          if (nextName > 0) setSeries(nextName - 1); 
    472472          addSeriesMeta("Mag. changer", in.readCString()); 
    473473        } 
     
    545545 
    546546      for (int i=0; i<getSeriesCount(); i++) { 
    547         store.setPixelsPhysicalSizeX(new Double(pixelSize), i); 
    548         store.setPixelsPhysicalSizeY(new Double(pixelSize), i); 
     547        if (i < pixelSize.size()) { 
     548          store.setPixelsPhysicalSizeX(new Double(pixelSize.get(i)), i); 
     549          store.setPixelsPhysicalSizeY(new Double(pixelSize.get(i)), i); 
     550        } 
    549551        int idx = 0; 
    550552        for (int q=0; q<i; q++) { 
  • branches/4.2/components/bio-formats/src/loci/formats/in/TillVisionReader.java

    r7003 r7006  
    2929import java.io.IOException; 
    3030import java.util.Arrays; 
     31import java.util.HashMap; 
    3132import java.util.Hashtable; 
    3233import java.util.Vector; 
     
    401402 
    402403        if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) { 
    403           for (IniTable table : data) { 
    404             for (String key : table.keySet()) { 
    405               addSeriesMeta(key, table.get(key)); 
    406             } 
    407           } 
     404          HashMap<String, String> iniMap = data.flattenIntoHashMap(); 
     405          core[i].seriesMetadata.putAll(iniMap); 
    408406        } 
    409407      } 
  • branches/4.2/components/bio-formats/src/loci/formats/meta

  • branches/4.2/components/bio-formats/src/loci/formats/ome

  • branches/4.2/components/bio-formats/src/loci/formats/out/TiffWriter.java

    r7004 r7006  
    236236      return new int[] {FormatTools.INT8, FormatTools.UINT8}; 
    237237    } 
    238     return super.getPixelTypes(codec); 
     238    return new int[] {FormatTools.INT8, FormatTools.UINT8, FormatTools.INT16, 
     239      FormatTools.UINT16, FormatTools.INT32, FormatTools.UINT32, 
     240      FormatTools.FLOAT, FormatTools.DOUBLE}; 
    239241  } 
    240242 
  • branches/4.2/components/bio-formats/src/loci/formats/readers.txt

    r7003 r7006  
    139139loci.formats.in.FEITiffReader         # tif 
    140140loci.formats.in.SimplePCITiffReader   # tif 
     141loci.formats.in.NikonElementsTiffReader # tif 
    141142 
    142143# standard TIFF reader must go last (it accepts any TIFF) 
  • branches/4.2/components/bio-formats/src/loci/formats/tiff

  • branches/4.2/components/bio-formats/src/loci/formats/tiff/IFD.java

    r6509 r7006  
    344344          sb.append((char) s); 
    345345        } 
    346         else sb.append("\n"); 
     346        else if (s != 0) sb.append("\n"); 
    347347      } 
    348348      value = sb.toString(); 
     
    815815  } 
    816816 
     817  /** 
     818   * Retrieve the X resolution (TIFF tag XResolution) from this IFD. 
     819   * The resolution will be normalized to microns per pixel. 
     820   * 
     821   * @return the X resolution, in microns per pixel 
     822   * @throws FormatException if there is a problem parsing the IFD metadata. 
     823   */ 
     824  public double getXResolution() throws FormatException { 
     825    TiffRational xResolution = getIFDRationalValue(X_RESOLUTION); 
     826    double x = xResolution == null ? 0 : 1 / xResolution.doubleValue(); 
     827 
     828    int resolutionUnit = getIFDIntValue(RESOLUTION_UNIT); 
     829    int multiplier = resolutionUnit == 2 ? 25400 : 10000; 
     830    return x * multiplier; 
     831  } 
     832 
     833  /** 
     834   * Retrieve the Y resolution (TIFF tag YResolution) from this IFD. 
     835   * The resolution will be normalized to microns per pixel. 
     836   * 
     837   * @return the Y resolution, in microns per pixel 
     838   * @throws FormatException if there is a problem parsing the IFD metadata. 
     839   */ 
     840  public double getYResolution() throws FormatException { 
     841    TiffRational yResolution = getIFDRationalValue(Y_RESOLUTION); 
     842    double y = yResolution == null ? 0 : 1 / yResolution.doubleValue(); 
     843 
     844    int resolutionUnit = getIFDIntValue(RESOLUTION_UNIT); 
     845    int multiplier = resolutionUnit == 2 ? 25400 : 10000; 
     846    return y * multiplier; 
     847  } 
     848 
    817849  // -- IFD population methods -- 
    818850 
  • branches/4.2/components/bio-formats/src/loci/formats/tiff/TiffRational.java

    r6477 r7006  
    9999 
    100100  /** Indicates whether some other object is "equal to" this one. */ 
    101   public boolean equals(TiffRational o) { 
    102     return o != null && compareTo(o) == 0; 
     101  public boolean equals(Object o) { 
     102    return o != null && o instanceof TiffRational && 
     103      compareTo((TiffRational) o) == 0; 
    103104  } 
    104105 
  • branches/4.2/components/bio-formats/test/loci/formats/utests

  • branches/4.2/components/bio-formats/test/loci/formats/utests/tiff/TiffRationalTest.java

    r6128 r7006  
    4444    TiffRational b = new TiffRational(1, 4); 
    4545    assertTrue(a.equals(b)); 
    46     assertTrue(!(a.equals((Object) b))); 
     46    assertTrue(a.equals((Object) b)); 
    4747    assertEquals(0, a.compareTo(b)); 
    4848  } 
  • branches/4.2/components/common/src/loci/common/AbstractNIOHandle.java

    r6155 r7006  
    6060    if (!(mode.equals("r") || mode.equals("rw"))) { 
    6161      throw new IllegalArgumentException( 
    62           String.format("%s mode not in supported modes ('r', 'rw')")); 
     62        String.format("%s mode not in supported modes ('r', 'rw')", mode)); 
    6363    } 
    6464  } 
  • branches/4.2/components/common/src/loci/common/IniList.java

    r6050 r7006  
    2525 
    2626import java.util.ArrayList; 
     27import java.util.HashMap; 
    2728 
    2829/** 
     
    4849  } 
    4950 
     51  /** 
     52   * Flattens all of the INI tables into a single HashMap whose keys are 
     53   * of the format "[table name] table key". 
     54   */ 
     55  public HashMap<String, String> flattenIntoHashMap() { 
     56    HashMap<String, String> h = new HashMap<String, String>(); 
     57    for (IniTable table : this) { 
     58      String tableName = table.get(IniTable.HEADER_KEY); 
     59      for (String key : table.keySet()) { 
     60        if (!key.equals(IniTable.HEADER_KEY)) { 
     61          h.put("[" + tableName + "] " + key, table.get(key)); 
     62        } 
     63      } 
     64    } 
     65    return h; 
     66  } 
     67 
    5068} 
  • branches/4.2/components/ome-xml

  • branches/4.2/components/slim-plotter/src/loci/slim/TwoDPane.java

    r5093 r7006  
    208208    } 
    209209    final DataReferenceImpl curveRef = new DataReferenceImpl("curve"); 
    210     RealTupleType xy = new RealTupleType(types.xType, types.yType); 
     210    //RealTupleType xy = new RealTupleType(types.xType, types.yType); 
    211211    UnionSet dummyCurve = new UnionSet(new Gridded2DSet[] { 
    212212      new Gridded2DSet(types.xy, new float[][] {{0}, {0}}, 1) 
Note: See TracChangeset for help on using the changeset viewer.