Changeset 3854


Ignore:
Timestamp:
03/28/08 13:32:14 (12 years ago)
Author:
melissa
Message:
  • Eliminated remainder of string logic for parsing XML.
  • Added a few more comments, especially for formats that were reverse engineered.
  • Minor bug fixes and code cleanup.
Location:
trunk/loci/formats/in
Files:
43 edited

Legend:

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

    r3727 r3854  
    7777    int planeSize = (core.sizeX[0] + pad) * core.sizeY[0]; 
    7878 
     79    // 16-bit images are stored in a non-standard format: 
     80    // all of the LSBs are stored together, followed by all of the MSBs 
     81    // so instead of LMLMLM... storage, we have LLLLL...MMMMM... 
    7982    for (int i=0; i<numBytes; i++) { 
    8083      in.seek(textureOffset + (no * planeSize * (i + 1))); 
     
    8689    } 
    8790 
     91    if (numBytes > 1) { 
     92      byte[] tmp = new byte[buf.length]; 
     93      for (int i=0; i<planeSize; i++) { 
     94        for (int j=0; j<numBytes; j++) { 
     95          tmp[i*numBytes + j] = buf[planeSize*j + i]; 
     96        } 
     97      } 
     98      System.arraycopy(tmp, 0, buf, 0, tmp.length); 
     99      tmp = null; 
     100    } 
     101 
    88102    return buf; 
    89103  } 
  • trunk/loci/formats/in/BMPReader.java

    r3727 r3854  
    4343public class BMPReader extends FormatReader { 
    4444 
     45  // -- Constants -- 
     46 
     47  /** Compression types. */ 
     48  private static final int RAW = 0; 
     49  private static final int RLE_8 = 1; 
     50  private static final int RLE_4 = 2; 
     51  private static final int RGB_MASK = 3; 
     52 
    4553  // -- Fields -- 
    4654 
     
    5462  private byte[][] palette; 
    5563 
    56   /** 
    57    * Compression type: 
    58    * 0 = no compression, 
    59    * 1 = 8 bit run length encoding, 
    60    * 2 = 4 bit run length encoding, 
    61    * 3 = RGB bitmap with mask. 
    62    */ 
     64  /** Compression type */ 
    6365  private int compression; 
    6466 
     
    98100    FormatTools.checkBufferSize(this, buf.length, w, h); 
    99101 
    100     if (compression != 0) { 
     102    if (compression != RAW) { 
    101103      throw new FormatException("Compression type " + compression + 
    102104        " not supported"); 
     
    186188 
    187189    switch (compression) { 
    188       case 0: 
     190      case RAW: 
    189191        comp = "None"; 
    190192        break; 
    191       case 1: 
     193      case RLE_8: 
    192194        comp = "8 bit run length encoding"; 
    193195        break; 
    194       case 2: 
     196      case RLE_4: 
    195197        comp = "4 bit run length encoding"; 
    196198        break; 
    197       case 3: 
     199      case RGB_MASK: 
    198200        comp = "RGB bitmap with mask"; 
    199201        break; 
     
    228230    global = in.getFilePointer(); 
    229231 
    230     addMeta("Indexed color", palette == null ? "false" : "true"); 
     232    addMeta("Indexed color", String.valueOf(palette != null)); 
    231233 
    232234    status("Populating metadata"); 
  • trunk/loci/formats/in/BaseTiffReader.java

    r3629 r3854  
    108108  } 
    109109 
    110   // -- BaseTiffReader API methods -- 
    111  
    112   /** Gets the dimensions of the given (possibly multi-page) TIFF file. */ 
    113   public int[] getTiffDimensions() throws FormatException, IOException { 
    114     if (ifds == null || ifds.length == 0) return null; 
    115     return new int[] { 
    116       TiffTools.getIFDIntValue(ifds[0], TiffTools.IMAGE_WIDTH, false, -1), 
    117       TiffTools.getIFDIntValue(ifds[0], TiffTools.IMAGE_LENGTH, false, -1), 
    118       core.imageCount[0] 
    119     }; 
    120   } 
    121  
    122110  // -- IFormatReader API methods -- 
    123111 
     
    133121    if (bits[0] <= 8) { 
    134122      int[] colorMap = 
    135         (int[]) TiffTools.getIFDValue(ifds[0], TiffTools.COLOR_MAP); 
     123        TiffTools.getIFDIntArray(ifds[0], TiffTools.COLOR_MAP, false); 
    136124      if (colorMap == null) return null; 
    137125 
     
    155143    if (bits[0] <= 16 && bits[0] > 8) { 
    156144      int[] colorMap = 
    157         (int[]) TiffTools.getIFDValue(ifds[0], TiffTools.COLOR_MAP); 
     145        TiffTools.getIFDIntArray(ifds[0], TiffTools.COLOR_MAP, false); 
    158146      if (colorMap == null || colorMap.length < 65536 * 3) return null; 
    159147      short[][] table = new short[3][colorMap.length / 3]; 
     
    176164  } 
    177165 
    178   /* @see loci.formats.IFormatReader#getMetadataValue(String) */ 
    179   public Object getMetadataValue(String field) { 
    180     FormatTools.assertId(currentId, true, 1); 
    181     return getMeta(field); 
    182   } 
    183  
    184166  /** 
    185167   * @see loci.formats.FormatReader#openBytes(int, byte[], int, int, int, int) 
     
    193175 
    194176    TiffTools.getSamples(ifds[no], in, buf, x, y, width, height); 
    195     return swapIfRequired(buf); 
     177    return buf; 
    196178  } 
    197179 
     
    238220    } 
    239221 
    240     int comp = TiffTools.getIFDIntValue(ifd, TiffTools.COMPRESSION); 
     222    int comp = TiffTools.getCompression(ifd); 
    241223    String compression = null; 
    242224    switch (comp) { 
     
    265247    put("Compression", compression); 
    266248 
    267     int photo = TiffTools.getIFDIntValue(ifd, 
    268       TiffTools.PHOTOMETRIC_INTERPRETATION); 
     249    int photo = TiffTools.getPhotometricInterpretation(ifd); 
    269250    String photoInterp = null; 
    270251    String metaDataPhotoInterp = null; 
     
    547528 
    548529    // bits per sample and number of channels 
    549     Object bpsObj = TiffTools.getIFDValue(ifd, TiffTools.BITS_PER_SAMPLE); 
    550     int bps = -1, numC = 3; 
    551     if (bpsObj instanceof int[]) { 
    552       int[] q = (int[]) bpsObj; 
    553       bps = q[0]; 
    554       numC = q.length; 
    555     } 
    556     else if (bpsObj instanceof Number) { 
    557       bps = ((Number) bpsObj).intValue(); 
    558       numC = 1; 
    559     } 
     530    int[] q = TiffTools.getBitsPerSample(ifd); 
     531    int bps = q[0]; 
     532    int numC = q.length; 
    560533 
    561534    // numC isn't set properly if we have an indexed color image, so we need 
    562535    // to reset it here 
    563536 
    564     int p = TiffTools.getIFDIntValue(ifd, TiffTools.PHOTOMETRIC_INTERPRETATION); 
    565     if (p == TiffTools.RGB_PALETTE || p == TiffTools.CFA_ARRAY) { 
     537    if (photo == TiffTools.RGB_PALETTE || photo == TiffTools.CFA_ARRAY) { 
    566538      numC = 3; 
    567539      bps *= 3; 
     
    580552    } 
    581553 
    582     int samples = TiffTools.getIFDIntValue(ifds[0], 
    583       TiffTools.SAMPLES_PER_PIXEL, false, 1); 
    584     core.rgb[0] = samples > 1 || p == TiffTools.RGB; 
     554    int samples = TiffTools.getSamplesPerPixel(ifd); 
     555    core.rgb[0] = samples > 1 || photo == TiffTools.RGB; 
    585556    core.interleaved[0] = false; 
    586557    core.littleEndian[0] = TiffTools.isLittleEndian(ifds[0]); 
    587558 
    588     core.sizeX[0] = 
    589       TiffTools.getIFDIntValue(ifds[0], TiffTools.IMAGE_WIDTH, false, 0); 
    590     core.sizeY[0] = 
    591       TiffTools.getIFDIntValue(ifds[0], TiffTools.IMAGE_LENGTH, false, 0); 
     559    core.sizeX[0] = (int) TiffTools.getImageWidth(ifds[0]); 
     560    core.sizeY[0] = (int) TiffTools.getImageLength(ifds[0]); 
    592561    core.sizeZ[0] = 1; 
    593562    core.sizeC[0] = core.rgb[0] ? samples : 1; 
    594563    core.sizeT[0] = ifds.length; 
    595564    core.metadataComplete[0] = true; 
    596     core.indexed[0] = p == TiffTools.RGB_PALETTE && 
     565    core.indexed[0] = photo == TiffTools.RGB_PALETTE && 
    597566      (get8BitLookupTable() != null || get16BitLookupTable() != null); 
    598567    if (core.indexed[0]) { 
     
    603572    core.falseColor[0] = false; 
    604573 
    605     int bitFormat = TiffTools.getIFDIntValue(ifds[0], 
    606       TiffTools.SAMPLE_FORMAT); 
     574    int bitFormat = TiffTools.getIFDIntValue(ifds[0], TiffTools.SAMPLE_FORMAT); 
    607575 
    608576    while (bps % 8 != 0) bps++; 
     
    651619   */ 
    652620  protected void initMetadataStore() { 
    653     Hashtable ifd = ifds[0]; 
    654621    try { 
    655622      // the metadata store we're working with 
     
    662629 
    663630      // populate Experimenter 
    664       String artist = (String) TiffTools.getIFDValue(ifd, TiffTools.ARTIST); 
     631      String artist = (String) TiffTools.getIFDValue(ifds[0], TiffTools.ARTIST); 
    665632      if (artist != null) { 
    666633        String firstName = null, lastName = null; 
     
    672639        } 
    673640        String email = (String) 
    674           TiffTools.getIFDValue(ifd, TiffTools.HOST_COMPUTER); 
     641          TiffTools.getIFDValue(ifds[0], TiffTools.HOST_COMPUTER); 
    675642        store.setExperimenterFirstName(firstName, 0); 
    676643        store.setExperimenterLastName(lastName, 0); 
     
    724691      // set the X and Y pixel dimensions 
    725692 
    726       int resolutionUnit = TiffTools.getIFDIntValue(ifd, 
     693      int resolutionUnit = TiffTools.getIFDIntValue(ifds[0], 
    727694        TiffTools.RESOLUTION_UNIT); 
    728       TiffRational xResolution = TiffTools.getIFDRationalValue(ifd, 
     695      TiffRational xResolution = TiffTools.getIFDRationalValue(ifds[0], 
    729696        TiffTools.X_RESOLUTION, false); 
    730       TiffRational yResolution = TiffTools.getIFDRationalValue(ifd, 
     697      TiffRational yResolution = TiffTools.getIFDRationalValue(ifds[0], 
    731698        TiffTools.Y_RESOLUTION, false); 
    732699      float pixX = xResolution == null ? 0f : xResolution.floatValue(); 
     
    750717 
    751718      // populate StageLabel 
    752       Object x = TiffTools.getIFDValue(ifd, TiffTools.X_POSITION); 
    753       Object y = TiffTools.getIFDValue(ifd, TiffTools.Y_POSITION); 
     719      Object x = TiffTools.getIFDValue(ifds[0], TiffTools.X_POSITION); 
     720      Object y = TiffTools.getIFDValue(ifds[0], TiffTools.Y_POSITION); 
    754721      Float stageX; 
    755722      Float stageY; 
     
    762729        stageY = y == null ? null : new Float((String) y); 
    763730      } 
    764       // CHECK 
    765       /* 
    766       if (stageX != null || stageY != null) { 
    767         store.setStageLabelX(stageX, 0); 
    768         store.setStageLabelY(stageY, 0); 
    769       } 
    770       */ 
    771  
    772731      // populate Instrument 
    773732      // CTR CHECK 
  • trunk/loci/formats/in/BioRadReader.java

    r3794 r3854  
    170170  // -- Fields -- 
    171171 
    172   /** Flag indicating current Bio-Rad PIC is packed with bytes. */ 
    173   private boolean byteFormat; 
    174  
    175172  private Vector used; 
    176173 
     
    235232    lastChannel = getZCTCoords(no)[1]; 
    236233 
    237     int bytes = byteFormat ? 1 : 2; 
     234    int bytes = FormatTools.getBytesPerPixel(core.pixelType[0]); 
    238235 
    239236    if (picFiles != null) { 
     
    271268  public void close() throws IOException { 
    272269    super.close(); 
    273     byteFormat = false; 
    274270    used = null; 
    275271    picFiles = null; 
     
    283279    if (debug) debug("BioRadReader.initFile(" + id + ")"); 
    284280 
     281    // always initialize a PIC file, even if we were given something else 
    285282    if (!checkSuffix(id, PIC_SUFFIX)) { 
    286283      Location dir = new Location(id).getAbsoluteFile().getParentFile(); 
     
    316313    int ramp1max = in.readShort(); 
    317314    boolean notes = in.readInt() != 0; 
    318     byteFormat = in.readShort() != 0; 
     315    core.pixelType[0] = 
     316      in.readShort() == 0 ? FormatTools.UINT16 : FormatTools.UINT8; 
    319317    int imageNumber = in.readShort(); 
    320318    String name = in.readString(32); 
     
    341339    addMeta("ramp1_max", new Integer(ramp1max)); 
    342340    addMeta("notes", new Boolean(notes)); 
    343     addMeta("byte_format", new Boolean(byteFormat)); 
    344341    addMeta("image_number", new Integer(imageNumber)); 
    345342    addMeta("name", name); 
     
    356353    // skip image data 
    357354    int imageLen = core.sizeX[0] * core.sizeY[0]; 
    358     int bpp = byteFormat ? 1 : 2; 
     355    int bpp = FormatTools.getBytesPerPixel(core.pixelType[0]); 
    359356    in.skipBytes(bpp * core.imageCount[0] * imageLen + 6); 
    360357 
  • trunk/loci/formats/in/DeltavisionReader.java

    r3619 r3854  
    5151  private int extSize; 
    5252 
    53   /** Bytes per pixel. */ 
    54   private int bytesPerPixel; 
    55  
    5653  /** Size of one wave in the extended header. */ 
    5754  protected int wSize; 
     
    9895 
    9996    // read the image plane's pixel data 
     97    int bytesPerPixel = FormatTools.getBytesPerPixel(core.pixelType[0]); 
    10098    long offset = HEADER_LENGTH + extSize; 
    10199    long bytes = core.sizeX[0] * core.sizeY[0] * bytesPerPixel; 
     
    116114  public void close() throws IOException { 
    117115    super.close(); 
    118     extSize = bytesPerPixel = wSize = zSize = tSize = 0; 
     116    extSize = wSize = zSize = tSize = 0; 
    119117    numIntsPerSection = numFloatsPerSection = 0; 
    120118    extHdrFields = null; 
     
    149147    core.sizeY[0] = in.readInt(); 
    150148 
    151     Integer xSize = new Integer(core.sizeX[0]); 
    152     Integer ySize = new Integer(core.sizeY[0]); 
    153     addMeta("ImageWidth", xSize); 
    154     addMeta("ImageHeight", ySize); 
     149    addMeta("ImageWidth", new Integer(core.sizeX[0])); 
     150    addMeta("ImageHeight", new Integer(core.sizeY[0])); 
    155151    addMeta("NumberOfImages", new Integer(in.readInt())); 
    156152    int filePixelType = in.readInt(); 
     
    161157        pixel = "8 bit unsigned integer"; 
    162158        core.pixelType[0] = FormatTools.UINT8; 
    163         bytesPerPixel = 1; 
    164159        break; 
    165160      case 1: 
    166161        pixel = "16 bit signed integer"; 
    167162        core.pixelType[0] = FormatTools.INT16; 
    168         bytesPerPixel = 2; 
    169163        break; 
    170164      case 2: 
    171165        pixel = "32 bit floating point"; 
    172166        core.pixelType[0] = FormatTools.FLOAT; 
    173         bytesPerPixel = 4; 
    174167        break; 
    175168      case 3: 
    176169        pixel = "16 bit complex"; 
    177170        core.pixelType[0] = FormatTools.INT16; 
    178         bytesPerPixel = 4; 
    179171        break; 
    180172      case 4: 
    181173        pixel = "64 bit complex"; 
    182174        core.pixelType[0] = FormatTools.FLOAT; 
    183         bytesPerPixel = 8; 
    184175        break; 
    185176      case 6: 
    186177        pixel = "16 bit unsigned integer"; 
    187178        core.pixelType[0] = FormatTools.UINT16; 
    188         bytesPerPixel = 2; 
    189179        break; 
    190180      default: 
    191181        pixel = "unknown"; 
    192182        core.pixelType[0] = FormatTools.UINT8; 
    193         bytesPerPixel = 1; 
    194183    } 
    195184 
     
    281270    switch (sequence) { 
    282271      case 0: 
    283         imageSequence = "ZTW"; core.currentOrder[0] = "XYZTC"; 
     272        imageSequence = "ZTW"; 
    284273        break; 
    285274      case 1: 
    286         imageSequence = "WZT"; core.currentOrder[0] = "XYCZT"; 
     275        imageSequence = "WZT"; 
    287276        break; 
    288277      case 2: 
    289         imageSequence = "ZWT"; core.currentOrder[0] = "XYZCT"; 
     278        imageSequence = "ZWT"; 
    290279        break; 
    291280      case 65536: 
    292         imageSequence = "WZT"; core.currentOrder[0] = "XYCZT"; 
     281        imageSequence = "WZT"; 
    293282        break; 
    294283      default: 
    295         imageSequence = "unknown"; core.currentOrder[0] = "XYZTC"; 
    296     } 
     284        imageSequence = "ZTW"; 
     285    } 
     286    core.currentOrder[0] = "XY" + imageSequence.replaceAll("W", "C"); 
    297287    addMeta("Image sequence", imageSequence); 
    298288 
     
    361351    store.setImageDescription(title, 0); 
    362352 
    363     // Run through every timeslice, for each wavelength, for each z section 
    364     // and fill in the Extended Header information array for that image 
     353    // Run through every image and fill in the 
     354    // Extended Header information array for that image 
    365355    int p = 0; 
    366356    int offset = HEADER_LENGTH + numIntsPerSection * 4; 
    367     for (int z=0; z<core.sizeZ[0]; z++) { 
    368       for (int t=0; t<core.sizeT[0]; t++) { 
    369         for (int w=0; w<core.sizeC[0]; w++) { 
    370           in.seek(offset + getTotalOffset(z, w, t)); 
    371           extHdrFields[z][w][t] = new DVExtHdrFields(in); 
    372  
    373           // plane timing 
    374           store.setPlaneTheZ(new Integer(z), 0, 0, p); 
    375           store.setPlaneTheC(new Integer(w), 0, 0, p); 
    376           store.setPlaneTheT(new Integer(t), 0, 0, p); 
    377           store.setPlaneTimingDeltaT( 
    378             new Float(extHdrFields[z][w][t].getTimeStampSeconds()), 
    379             0, 0, p); 
    380           store.setPlaneTimingExposureTime( 
    381             new Float(extHdrFields[z][w][t].getExpTime()), 0, 0, p); 
    382  
    383           // stage position 
    384           store.setStagePositionPositionX( 
    385             new Float(extHdrFields[z][w][t].getStageXCoord()), 0, 0, p); 
    386           store.setStagePositionPositionY( 
    387             new Float(extHdrFields[z][w][t].getStageYCoord()), 0, 0, p); 
    388           store.setStagePositionPositionZ( 
    389             new Float(extHdrFields[z][w][t].getStageZCoord()), 0, 0, p); 
    390  
    391           p++; 
    392         } 
    393       } 
     357    for (int i=0; i<core.imageCount[0]; i++) { 
     358      int[] coords = getZCTCoords(i); 
     359      int z = coords[0]; 
     360      int w = coords[1]; 
     361      int t = coords[2]; 
     362      in.seek(offset + getTotalOffset(z, w, t)); 
     363      extHdrFields[z][w][t] = new DVExtHdrFields(in); 
     364 
     365      // plane timing 
     366      store.setPlaneTheZ(new Integer(z), 0, 0, p); 
     367      store.setPlaneTheC(new Integer(w), 0, 0, p); 
     368      store.setPlaneTheT(new Integer(t), 0, 0, p); 
     369      store.setPlaneTimingDeltaT( 
     370        new Float(extHdrFields[z][w][t].getTimeStampSeconds()), 0, 0, p); 
     371      store.setPlaneTimingExposureTime( 
     372        new Float(extHdrFields[z][w][t].getExpTime()), 0, 0, p); 
     373 
     374      // stage position 
     375      store.setStagePositionPositionX( 
     376        new Float(extHdrFields[z][w][t].getStageXCoord()), 0, 0, p); 
     377      store.setStagePositionPositionY( 
     378        new Float(extHdrFields[z][w][t].getStageYCoord()), 0, 0, p); 
     379      store.setStagePositionPositionZ( 
     380        new Float(extHdrFields[z][w][t].getStageZCoord()), 0, 0, p); 
     381 
     382      p++; 
    394383    } 
    395384 
     
    555544     */ 
    556545    public String toString() { 
    557       String s = new String(); 
    558  
    559       s += "photosensorReading: " + photosensorReading + "\n"; 
    560       s += "timeStampSeconds: " + timeStampSeconds + "\n"; 
    561       s += "stageXCoord: " + stageXCoord + "\n"; 
    562       s += "stageYCoord: " + stageYCoord + "\n"; 
    563       s += "stageZCoord: " + stageZCoord + "\n"; 
    564       s += "minInten: " + minInten + "\n"; 
    565       s += "maxInten: " + maxInten + "\n"; 
    566       s += "meanInten: " + meanInten + "\n"; 
    567       s += "expTime: " + expTime + "\n"; 
    568       s += "ndFilter: " + ndFilter + "\n"; 
    569       s += "exFilter: " + exFilter + "\n"; 
    570       s += "emFilter: " + emFilter + "\n"; 
    571       s += "exWavelen: " + exWavelen + "\n"; 
    572       s += "emWavelen: " + emWavelen + "\n"; 
    573       s += "intenScaling: " + intenScaling + "\n"; 
    574       s += "energyConvFactor: " + energyConvFactor + "\n"; 
    575  
    576       return s; 
     546      StringBuffer sb = new StringBuffer(); 
     547      sb.append("photosensorReading: "); 
     548      sb.append(photosensorReading); 
     549      sb.append("\ntimeStampSeconds: "); 
     550      sb.append(timeStampSeconds); 
     551      sb.append("\nstageXCoord: "); 
     552      sb.append(stageXCoord); 
     553      sb.append("\nstageYCoord: "); 
     554      sb.append(stageYCoord); 
     555      sb.append("\nstageZCoord: "); 
     556      sb.append(stageZCoord); 
     557      sb.append("\nminInten: "); 
     558      sb.append(minInten); 
     559      sb.append("\nmaxInten: "); 
     560      sb.append(maxInten); 
     561      sb.append("\nmeanInten: "); 
     562      sb.append(meanInten); 
     563      sb.append("\nexpTime: "); 
     564      sb.append(expTime); 
     565      sb.append("\nndFilter: "); 
     566      sb.append(ndFilter); 
     567      sb.append("\nexFilter: "); 
     568      sb.append(exFilter); 
     569      sb.append("\nemFilter: "); 
     570      sb.append(emFilter); 
     571      sb.append("\nexWavelen: "); 
     572      sb.append(exWavelen); 
     573      sb.append("\nemWavelen: "); 
     574      sb.append(emWavelen); 
     575      sb.append("\nintenScaling: "); 
     576      sb.append(intenScaling); 
     577      sb.append("\nenergyConvFactor: "); 
     578      sb.append(energyConvFactor); 
     579      return sb.toString(); 
    577580    } 
    578581 
     
    602605      } 
    603606      catch (IOException e) { 
    604         LogTools.trace(e); 
     607        if (debug) LogTools.trace(e); 
    605608      } 
    606609    } 
  • trunk/loci/formats/in/DicomReader.java

    r3781 r3854  
    165165 
    166166    if (isRLE) { 
     167      // plane is compressed using run-length encoding 
    167168      byte[] b = new byte[bytes]; 
    168169      in.read(b); 
     
    198199    } 
    199200    else if (isJPEG || isJP2K) { 
     201      // plane is compressed using JPEG or JPEG-2000 
    200202      byte[] b = new byte[(int) (in.length() - in.getFilePointer())]; 
    201203      in.read(b); 
     
    228230    } 
    229231    else { 
     232      // plane is not compressed 
    230233      in.skipBytes(4); 
    231234      byte b1 = in.readByte(); 
     
    251254 
    252255    if (inverted) { 
     256      // pixels are stored such that white -> 0; invert the values so that 
     257      // white -> 255 (or 65535) 
    253258      if (bpp == 1) { 
    254259        for (int i=0; i<buf.length; i++) { 
     
    341346      if (elementLength == 0) continue; 
    342347 
    343       if ((location & 1) != 0) oddLocations = true; 
     348      oddLocations = (location & 1) != 0; 
    344349 
    345350      String s; 
    346351      switch (tag) { 
    347352        case TRANSFER_SYNTAX_UID: 
     353          // this tag can indicate which compression scheme is used 
    348354          s = in.readString(elementLength); 
    349355          addInfo(tag, s); 
     
    366372          break; 
    367373        case SAMPLES_PER_PIXEL: 
    368           int samplesPerPixel = in.readShort(); 
    369           addInfo(tag, samplesPerPixel); 
     374          addInfo(tag, in.readShort()); 
    370375          break; 
    371376        case PHOTOMETRIC_INTERPRETATION: 
     
    456461    status("Calculating image offsets"); 
    457462 
     463    // calculate the offset to each plane 
     464 
    458465    offsets = new long[core.imageCount[0]]; 
    459466    for (int i=0; i<core.imageCount[0]; i++) { 
     
    469476      } 
    470477      else if (isJPEG || isJP2K) { 
     478        // scan for next JPEG magic byte sequence 
    471479        if (i == 0) offsets[i] = baseOffset; 
    472480        else offsets[i] = offsets[i - 1] + 3; 
     
    474482        byte secondCheck = isJPEG ? (byte) 0xd8 : (byte) 0x4f; 
    475483 
     484        in.seek(offsets[i]); 
    476485        byte[] buf = new byte[8192]; 
     486        in.read(buf); 
    477487        boolean found = false; 
    478488        while (!found) { 
     
    483493              { 
    484494                found = true; 
    485                 offsets[i] = in.getFilePointer() + q - 8192; 
     495                offsets[i] = in.getFilePointer() + q - buf.length; 
    486496                break; 
    487497              } 
  • trunk/loci/formats/in/EPSReader.java

    r3617 r3854  
    125125    int bytes = FormatTools.getBytesPerPixel(core.pixelType[0]); 
    126126    if (binary) { 
     127      // pixels are stored as raw bytes 
    127128      ras.skipBytes(y * core.sizeX[0] * bytes * core.sizeC[0]); 
    128129      for (int row=0; row<h; row++) { 
     
    133134    } 
    134135    else { 
     136      // pixels are stored as a 2 character hexadecimal value 
    135137      String pix = ras.readString((int) (ras.length() - ras.getFilePointer())); 
    136138      pix = pix.replaceAll("\n", ""); 
     
    230232    int lineNum = 1; 
    231233 
    232     line = in.readLine(); 
     234    line = in.readLine().trim(); 
    233235 
    234236    while (line != null) { 
    235       if (line.trim().equals(image) || line.trim().endsWith(image)) { 
    236         if (line.trim().endsWith(image) && !line.trim().startsWith(image)) { 
     237      if (line.endsWith(image)) { 
     238        if (!line.startsWith(image)) { 
    237239          if (line.indexOf("colorimage") != -1) core.sizeC[0] = 3; 
    238240          StringTokenizer t = new StringTokenizer(line, " "); 
     
    315317    MetadataStore store = getMetadataStore(); 
    316318    store.setImageName("", 0); 
     319    store.setImageCreationDate( 
     320      DataTools.convertDate(System.currentTimeMillis(), DataTools.UNIX), 0); 
    317321 
    318322    MetadataTools.populatePixels(store, this); 
  • trunk/loci/formats/in/FV1000Reader.java

    r3843 r3854  
    210210    if (isOIB) poi = new POITools(Location.getMappedId(id)); 
    211211 
     212    // mappedOIF is used to distinguish between datasets that are being read 
     213    // directly (e.g. using ImageJ or showinf), and datasets that are being 
     214    // imported through omebf. In the latter case, the necessary directory 
     215    // structure is not preserved (only relative file names are stored in 
     216    // OMEIS), so we will need to use slightly different logic to build the 
     217    // list of associated files. 
    212218    boolean mappedOIF = !isOIB && !new File(id).getAbsoluteFile().exists(); 
    213219 
     
    225231 
    226232      oibMapping = new Hashtable(); 
     233 
     234      // set up file name mappings 
    227235 
    228236      String s = DataTools.stripString(ras.readString((int) ras.length())); 
     
    303311      oif = getFile(oifName.replaceAll(".oif", ".OIF")); 
    304312    } 
     313 
     314    // parse key/value pairs from the OIF file 
    305315 
    306316    String s = oif.readString((int) oif.length()); 
     
    373383        } 
    374384        else if (value.indexOf("-R") != -1) { 
     385          // "-R" in the file name indicates that this is a preview image 
    375386          value = value.replaceAll("/", File.separator); 
    376387          value = value.replace('\\', File.separatorChar); 
     
    445456 
    446457    status("Initializing helper readers"); 
     458 
     459    // populate core metadata for preview series 
    447460 
    448461    if (previewNames.size() > 0) { 
     
    480493    } 
    481494 
    482     thumbReader = new BMPReader(); 
    483495    core.imageCount[0] = filenames.size(); 
    484496    tiffs = new Vector(core.imageCount[0]); 
    485497 
     498    thumbReader = new BMPReader(); 
    486499    thumbId = thumbId.replaceAll("pty", "bmp"); 
    487500    thumbId = sanitizeFile(thumbId, (isOIB || mappedOIF) ? "" : path); 
     
    490503    status("Reading additional metadata"); 
    491504 
    492     // open each INI file (.pty extension) 
     505    // open each INI file (.pty extension) and build list of TIFF files 
    493506 
    494507    String tiffPath = null; 
     
    554567    status("Populating metadata"); 
    555568 
     569    // calculate axis sizes 
     570 
    556571    int realChannels = 0; 
    557572    for (int i=0; i<9; i++) { 
     
    607622    in = null; 
    608623 
     624    // set up thumbnail file mapping 
     625 
    609626    RandomAccessStream thumb = getFile(thumbId); 
    610627    if (thumb != null) { 
     
    617634      Arrays.fill(core.thumbSizeY, thumbReader.getSizeY()); 
    618635    } 
     636 
     637    // initialize lookup table 
    619638 
    620639    lut = new short[core.sizeC[0]][3][65536]; 
  • trunk/loci/formats/in/FlexReader.java

    r3772 r3854  
    8989      for (int i=num-1; i>=0; i--) { 
    9090        int q = (int) ((bytes[i] & 0xff) * factors[no]); 
    91         byte b0 = (byte) (q & 0xff); 
    92         byte b1 = (byte) ((q >> 8) & 0xff); 
    93         int ndx = 2 * i; 
    94         if (core.littleEndian[0]) { 
    95           bytes[ndx] = b0; 
    96           bytes[ndx + 1] = b1; 
    97         } 
    98         else { 
    99           bytes[ndx] = b1; 
    100           bytes[ndx + 1] = b0; 
    101         } 
     91        DataTools.unpackBytes(q, bytes, i * 2, 2, core.littleEndian[0]); 
    10292      } 
    10393    } 
     
    10696      for (int i=num-1; i>=0; i--) { 
    10797        int q = (int) ((bytes[i] & 0xff) * factors[no]); 
    108         byte b0 = (byte) (q & 0xff); 
    109         byte b1 = (byte) ((q >> 8) & 0xff); 
    110         byte b2 = (byte) ((q >> 16) & 0xff); 
    111         byte b3 = (byte) ((q >> 24) & 0xff); 
    112         int ndx = 4 * i; 
    113         if (core.littleEndian[0]) { 
    114           bytes[ndx] = b0; 
    115           bytes[ndx + 1] = b1; 
    116           bytes[ndx + 2] = b2; 
    117           bytes[ndx + 3] = b3; 
    118         } 
    119         else { 
    120           bytes[ndx] = b3; 
    121           bytes[ndx + 1] = b2; 
    122           bytes[ndx + 2] = b1; 
    123           bytes[ndx + 3] = b0; 
    124         } 
     98        DataTools.unpackBytes(q, bytes, i * 4, 4, core.littleEndian[0]); 
    12599      } 
    126100    } 
  • trunk/loci/formats/in/FluoviewReader.java

    r3811 r3854  
    118118    byte[] b = new byte[w * h * 
    119119      getRGBChannelCount() * FormatTools.getBytesPerPixel(core.pixelType[0])]; 
    120     super.openBytes(0, b, x, y, w, h); 
    121     System.arraycopy(b, 0, buf, 0, buf.length); 
     120    super.openBytes(0, buf, x, y, w, h); 
     121    System.arraycopy(b, no*b.length, buf, 0, b.length); 
    122122    return buf; 
    123123  } 
  • trunk/loci/formats/in/GIFReader.java

    r3629 r3854  
    105105  public GIFReader() { 
    106106    super("Graphics Interchange Format", "gif"); 
     107    blockCheckLen = 6; 
    107108  } 
    108109 
     
    110111 
    111112  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
    112   public boolean isThisType(byte[] block) { return false; } 
     113  public boolean isThisType(byte[] block) { 
     114    if (block.length < blockCheckLen) return false; 
     115    return new String(block).startsWith("GIF"); 
     116  } 
    113117 
    114118  /* @see loci.formats.IFormatReader#get8BitLookupTable() */ 
     
    350354    core.pixelType[0] = FormatTools.UINT8; 
    351355    MetadataTools.populatePixels(store, this); 
    352     // CTR CHECK 
    353 //    for (int i=0; i<core.sizeC[0]; i++) { 
    354 //      store.setLogicalChannel(i, null, null, null, null, null, null, null, null, 
    355 //        null, null, null, null, null, null, null, null, null, null, null, null, 
    356 //        null, null, null, null); 
    357 //    } 
    358356  } 
    359357 
  • trunk/loci/formats/in/GatanReader.java

    r3711 r3854  
    250250   * http://rsb.info.nih.gov/ij/plugins/DM3Format.gj.html and 
    251251   * http://www-hrem.msm.cam.ac.uk/~cbb/info/dmformat/ 
     252   * 
     253   * The basic structure is this: the file is comprised of a list of tags. 
     254   * Each tag is either a data tag or a group tag.  Group tags are simply 
     255   * containers for more group and data tags, where data tags contain actual 
     256   * metadata.  Each data tag is comprised of a type (byte, short, etc.), 
     257   * a label, and a value. 
    252258   */ 
    253259  private void parseTags(int numTags, String parent) throws IOException { 
     
    266272        in.skipBytes(4);  // equal to '%%%%' 
    267273        int n = in.readInt(); 
    268         int dataType = 0; 
     274        int dataType = in.readInt(); 
    269275        if (n == 1) { 
    270           dataType = in.readInt(); 
    271276          if (parent.equals("Dimensions") && labelString.length() == 0) { 
    272277            in.order(!in.isLittleEndian()); 
     
    278283        } 
    279284        else if (n == 2) { 
    280           dataType = in.readInt(); 
    281285          if (dataType == 18) { // this should always be true 
    282286            length = in.readInt(); 
     
    285289        } 
    286290        else if (n == 3 && !labelString.equals("Data")) { 
    287           dataType = in.readInt(); 
    288291          if (dataType == GROUP) { // this should always be true 
    289292            dataType = in.readInt(); 
     
    298301        } 
    299302        else if (n == 3 && labelString.equals("Data")) { 
    300           dataType = in.readInt(); 
    301303          if (dataType == GROUP) {  // this should always be true 
    302304            dataType = in.readInt(); 
     
    308310        } 
    309311        else { 
    310           dataType = in.readInt(); 
    311312          // this is a normal struct of simple types 
    312313          if (dataType == ARRAY) { 
  • trunk/loci/formats/in/ICSReader.java

    r3829 r3854  
    4343 * @author Melissa Linkert linkert at wisc.edu 
    4444 */ 
    45  
    4645public class ICSReader extends FormatReader { 
    4746 
     
    138137 
    139138    if (!core.rgb[0] && core.sizeC[0] > 4) { 
     139      // channels are stored interleaved, but because there are more than we 
     140      // can display as RGB, we need to separate them 
    140141      if (!gzip && data == null) { 
    141142        data = new byte[len * core.sizeC[0]]; 
     
    215216    status("Finding companion file"); 
    216217 
    217     //String icsId = l.getPath(), idsId = l.getPath(); 
    218218    String icsId = id, idsId = id; 
    219219    int dot = id.lastIndexOf("."); 
     
    238238    status("Checking file version"); 
    239239 
    240     // check if we have a v2 ICS file 
     240    // check if we have a v2 ICS file - means there is no companion IDS file 
    241241    RandomAccessStream f = new RandomAccessStream(icsId); 
    242242    if (f.readString(17).trim().equals("ics_version\t2.0")) { 
     
    262262    String layoutSizes = null, layoutOrder = null, byteOrder = null; 
    263263    String rFormat = null, compression = null, scale = null; 
     264 
     265    // parse key/value pairs from beginning of ICS file 
    264266 
    265267    RandomAccessStream reader = new RandomAccessStream(icsIn.getAbsolutePath()); 
     
    321323 
    322324    layoutOrder = layoutOrder.trim(); 
    323     // bpp, width, height, z, channels 
    324325    StringTokenizer t1 = new StringTokenizer(layoutSizes); 
    325326    StringTokenizer t2 = new StringTokenizer(layoutOrder); 
     
    327328    core.rgb[0] = layoutOrder.indexOf("ch") >= 0 && 
    328329      layoutOrder.indexOf("ch") < layoutOrder.indexOf("x"); 
     330 
     331    // find axis sizes 
    329332 
    330333    String imageToken; 
     
    510513      } 
    511514    } 
    512  
    513     /* 
    514     for (int i=0; i<core.sizeC[0]; i++) { 
    515       // CTR CHECK 
    516 //      store.setLogicalChannel(i, null, null, null, null, null, null, null, null, 
    517 //       null, null, null, null, null, null, null, null, null, null, null, 
    518 //       new Integer(emWave[i]), new Integer(exWave[i]), null, null, null); 
    519       store.setLogicalChannelEmWave(new Integer(emWave[i]), 0, i); 
    520       store.setLogicalChannelExWave(new Integer(exWave[i]), 0, i); 
    521     } 
    522     */ 
    523515  } 
    524516 
  • trunk/loci/formats/in/IPLabReader.java

    r3683 r3854  
    123123    in.order(core.littleEndian[0]); 
    124124 
    125     // populate standard metadata hashtable and OME root node 
    126125    in.skipBytes(12); 
     126 
     127    // read axis sizes from header 
    127128 
    128129    dataSize = in.readInt() - 28; 
     
    143144 
    144145    String ptype; 
    145     bps = 1; 
    146146    switch (filePixelType) { 
    147147      case 0: 
    148148        ptype = "8 bit unsigned"; 
    149149        core.pixelType[0] = FormatTools.UINT8; 
    150         bps = 1; 
    151150        break; 
    152151      case 1: 
    153152        ptype = "16 bit signed short"; 
    154153        core.pixelType[0] = FormatTools.INT16; 
    155         bps = 2; 
    156154        break; 
    157155      case 2: 
    158156        ptype = "16 bit unsigned short"; 
    159157        core.pixelType[0] = FormatTools.UINT16; 
    160         bps = 2; 
    161158        break; 
    162159      case 3: 
    163160        ptype = "32 bit signed long"; 
    164161        core.pixelType[0] = FormatTools.INT32; 
    165         bps = 4; 
    166162        break; 
    167163      case 4: 
    168164        ptype = "32 bit single-precision float"; 
    169165        core.pixelType[0] = FormatTools.FLOAT; 
    170         bps = 4; 
    171166        break; 
    172167      case 5: 
    173168        ptype = "Color24"; 
    174169        core.pixelType[0] = FormatTools.UINT32; 
    175         bps = 1; 
    176170        break; 
    177171      case 6: 
    178172        ptype = "Color48"; 
    179173        core.pixelType[0] = FormatTools.UINT16; 
    180         bps = 2; 
    181174        break; 
    182175      case 10: 
    183176        ptype = "64 bit double-precision float"; 
    184177        core.pixelType[0] = FormatTools.DOUBLE; 
    185         bps = 8; 
    186178        break; 
    187179      default: 
    188180        ptype = "reserved"; // for values 7-9 
    189181    } 
     182 
     183    bps = FormatTools.getBytesPerPixel(core.pixelType[0]); 
    190184 
    191185    addMeta("PixelType", ptype); 
     
    271265          addMeta("NormalizationWhite" + i, new Double(white)); 
    272266 
    273           store = new FilterMetadata(getMetadataStore(), isMetadataFiltered()); 
    274267          // CTR CHECK 
    275268//          store.setChannelGlobalMinMax(i, new Double(min), 
  • trunk/loci/formats/in/IPWReader.java

    r3836 r3854  
    5858  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
    5959  public boolean isThisType(byte[] block) { 
    60     // all of our samples begin with 0xd0cf11e0 
    6160    return block[0] == 0xd0 && block[1] == 0xcf && 
    6261      block[2] == 0x11 && block[3] == 0xe0; 
     
    103102    TiffTools.getSamples(ifds[0], stream, buf, x, y, w, h); 
    104103    stream.close(); 
    105  
    106     if (core.pixelType[0] == FormatTools.UINT16 || 
    107       core.pixelType[0] == FormatTools.INT16) 
    108     { 
    109       for (int i=0; i<buf.length; i+=2) { 
    110         byte b = buf[i]; 
    111         buf[i] = buf[i + 1]; 
    112         buf[i + 1] = b; 
    113       } 
    114     } 
    115     else if (core.pixelType[0] == FormatTools.UINT32 || 
    116       core.pixelType[0] == FormatTools.INT32) 
    117     { 
    118       for (int i=0; i<buf.length; i+=4) { 
    119         byte b = buf[i]; 
    120         buf[i] = buf[i + 3]; 
    121         buf[i + 3] = b; 
    122         b = buf[i + 1]; 
    123         buf[i + 1] = buf[i + 2]; 
    124         buf[i + 2] = b; 
    125       } 
    126     } 
    127  
    128104    return buf; 
    129105  } 
     
    272248    core.littleEndian[0] = TiffTools.isLittleEndian(ifds[0]); 
    273249 
    274     // default values 
     250    // retrieve axis sizes 
    275251 
    276252    addMeta("slices", "1"); 
  • trunk/loci/formats/in/ImarisHDFReader.java

    r3841 r3854  
    8989    blockCheckLen = 8; 
    9090    suffixSufficient = false; 
     91    // NetCDF prints a fair number of warning messages to stdout - we need to 
     92    // filter these out so that they don't interfere with omebf. 
    9193    OutputFilter out = new OutputFilter(System.out); 
    9294    System.setOut(out); 
     
    115117    int[] oldZCT = previousImageNumber == -1 ? new int[] {-1, -1, -1} : 
    116118      FormatTools.getZCTCoords(this, previousImageNumber); 
     119 
     120    // pixel data is stored in XYZ blocks 
    117121 
    118122    if (zct[1] != oldZCT[1] || zct[2] != oldZCT[2] || series != previousSeries) 
     
    144148      } 
    145149      else if (previousImage instanceof short[][][]) { 
    146         short[] s = ((short[][][]) previousImage)[zct[0]][row + y]; 
    147150        for (int i=0; i<w; i++) { 
    148           buf[row*w*2 + i*2] = (byte) ((s[x + i] >> 8) & 0xff); 
    149           buf[row*w*2 + i*2 + 1] = (byte) (s[x + i] & 0xff); 
     151          DataTools.unpackShort( 
     152            ((short[][][]) previousImage)[zct[0]][row + y][x + i], buf, 
     153            2 * (row * w + i), core.littleEndian[0]); 
    150154        } 
    151155      } 
    152156      else if (previousImage instanceof int[][][]) { 
    153         int[] s = ((int[][][]) previousImage)[zct[0]][row + y]; 
    154         int base = row * w * 4; 
    155157        for (int i=0; i<w; i++) { 
    156           buf[base + i*4] = (byte) ((s[x + i] >> 24) & 0xff); 
    157           buf[base + i*4 + 1] = (byte) ((s[x + i] >> 16) & 0xff); 
    158           buf[base + i*4 + 2] = (byte) ((s[x + i] >> 8) & 0xff); 
    159           buf[base + i*4 + 3] = (byte) (s[x + i] & 0xff); 
     158          DataTools.unpackBytes( 
     159            ((int[][][]) previousImage)[zct[0]][row + y][x + i], buf, 
     160            4 * (row * w + i), 4, core.littleEndian[0]); 
    160161        } 
    161162      } 
     
    165166        for (int i=0; i<w; i++) { 
    166167          int v = Float.floatToIntBits(s[x + i]); 
    167           buf[base + i*4] = (byte) ((v >> 24) & 0xff); 
    168           buf[base + i*4 + 1] = (byte) ((v >> 16) & 0xff); 
    169           buf[base + i*4 + 2] = (byte) ((v >> 8) & 0xff); 
    170           buf[base + i*4 + 3] = (byte) (v & 0xff); 
     168          DataTools.unpackBytes(v, buf, base + i*4, 4, core.littleEndian[0]); 
    171169        } 
    172170      } 
     
    204202      new FilterMetadata(getMetadataStore(), isMetadataFiltered()); 
    205203 
     204    // initialize the file 
     205 
    206206    try { 
    207207      r.setVar("currentId", Location.getMappedId(id)); 
     
    215215    getValue("root", "ImarisDataSet"); 
    216216    getValue("root", "ImarisVersion"); 
     217 
     218    // read all of the metadata key/value pairs 
    217219 
    218220    findGroup("DataSetInfo", "root", "dataSetInfo"); 
     
    257259    } 
    258260    core.imageCount[0] = core.sizeZ[0] * core.sizeC[0] * core.sizeT[0]; 
     261 
     262    // determine pixel type - this isn't stored in the metadata, so we need 
     263    // to check the pixels themselves 
    259264 
    260265    try { 
     
    418423  } 
    419424 
     425  /** 
     426   * Look for a group of the given name within the given parent group. 
     427   * Stores the resulting group object in a variable whose name is the 
     428   * value of 'store'. 
     429   */ 
    420430  private Object findGroup(String name, String parent, String store) { 
    421431    try { 
  • trunk/loci/formats/in/ImarisReader.java

    r3801 r3854  
    120120    status("Reading header"); 
    121121 
    122     int version = in.readInt(); 
    123     addMeta("Version", new Integer(version)); 
     122    addMeta("Version", new Integer(in.readInt())); 
    124123    in.skipBytes(4); 
    125124 
  • trunk/loci/formats/in/ImarisTiffReader.java

    r3847 r3854  
    9595    core.sizeZ[0] = tmp.size() / core.sizeC[0]; 
    9696    core.sizeT[0] = 1; 
    97     core.sizeX[0] = 
    98       TiffTools.getIFDIntValue(ifds[1], TiffTools.IMAGE_WIDTH, false, 0); 
    99     core.sizeY[0] = 
    100       TiffTools.getIFDIntValue(ifds[1], TiffTools.IMAGE_LENGTH, false, 0); 
     97    core.sizeX[0] = (int) TiffTools.getImageWidth(ifds[1]); 
     98    core.sizeY[0] = (int) TiffTools.getImageLength(ifds[1]); 
    10199 
    102100    ifds = (Hashtable[]) tmp.toArray(new Hashtable[0]); 
     
    114112    if (bitsPerSample == 24 || bitsPerSample == 48) bitsPerSample /= 3; 
    115113 
     114    boolean signed = bitFormat == 2; 
     115 
    116116    if (bitFormat == 3) core.pixelType[0] = FormatTools.FLOAT; 
    117     else if (bitFormat == 2) { 
    118       switch (bitsPerSample) { 
    119         case 8: 
    120           core.pixelType[0] = FormatTools.INT8; 
    121           break; 
    122         case 16: 
    123           core.pixelType[0] = FormatTools.INT16; 
    124           break; 
    125         case 32: 
    126           core.pixelType[0] = FormatTools.INT32; 
    127           break; 
    128       } 
    129     } 
    130117    else { 
    131118      switch (bitsPerSample) { 
    132119        case 8: 
    133           core.pixelType[0] = FormatTools.UINT8; 
     120          core.pixelType[0] = signed ? FormatTools.INT8 : FormatTools.UINT8; 
    134121          break; 
    135122        case 16: 
    136           core.pixelType[0] = FormatTools.UINT16; 
     123          core.pixelType[0] = signed ? FormatTools.INT16 : FormatTools.UINT16; 
    137124          break; 
    138125        case 32: 
    139           core.pixelType[0] = FormatTools.UINT32; 
     126          core.pixelType[0] = signed ? FormatTools.INT32: FormatTools.UINT32; 
    140127          break; 
    141128      } 
  • trunk/loci/formats/in/ImprovisionTiffReader.java

    r3790 r3854  
    213213      new FilterMetadata(getMetadataStore(), isMetadataFiltered()); 
    214214    store.setImageName("", 0); 
     215    store.setImageCreationDate( 
     216      DataTools.convertDate(System.currentTimeMillis(), DataTools.UNIX), 0); 
    215217 
    216218    MetadataTools.populatePixels(store, this); 
  • trunk/loci/formats/in/InCellReader.java

    r3842 r3854  
    170170      DataTools.convertDate(System.currentTimeMillis(), DataTools.UNIX), 0); 
    171171    MetadataTools.populatePixels(store, this); 
    172     // CTR CHECK 
    173 //    for (int c=0; c<core.sizeC[0]; c++) { 
    174 //      store.setLogicalChannel(c, null, null, null, null, null, null, null, null, 
    175 //        null, null, null, null, null, null, null, null, null, null, null, null, 
    176 //        null, null, null, null); 
    177 //    } 
    178172  } 
    179173 
  • trunk/loci/formats/in/KhorosReader.java

    r3732 r3854  
    151151      default: throw new FormatException("Unsupported pixel type : " + type); 
    152152    } 
     153 
     154    // read lookup table 
    153155 
    154156    in.skipBytes(12); 
  • trunk/loci/formats/in/L2DReader.java

    r3829 r3854  
    9696  protected void initFile(String id) throws FormatException, IOException { 
    9797    if (debug) debug("L2DReader.initFile(" + id + ")"); 
     98 
     99    // NB: This format cannot be imported using omebf. 
     100    // See Trac ticket #266 for details. 
    98101 
    99102    if (id.toLowerCase().endsWith(".scn")) { 
  • trunk/loci/formats/in/LIFReader.java

    r3849 r3854  
    166166 
    167167    // number of Unicode characters in the XML block 
    168  
    169168    int nc = in.readInt(); 
    170169    String xml = DataTools.stripString(in.readString(nc * 2)); 
     
    214213  /** Parses a string of XML and puts the values in a Hashtable. */ 
    215214  private void initMetadata(String xml) throws FormatException, IOException { 
    216     // parse raw key/value pairs - adapted from FlexReader 
    217  
    218215    containerNames = new Vector(); 
    219216    containerCounts = new Vector(); 
     
    230227 
    231228    LIFHandler handler = new LIFHandler(); 
     229 
     230    // the XML blocks stored in a LIF file are invalid, 
     231    // because they don't have a root node 
    232232 
    233233    xml = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><LEICA>" + xml + 
     
    485485            ordering.indexOf("xy") == -1) 
    486486          { 
     487            // switch the axis sizes around, depending on the 
     488            // stored dimension order 
     489 
    487490            int xPos = ordering.indexOf("x"); 
    488491            int yPos = ordering.indexOf("y"); 
     
    615618      } 
    616619      else if (qName.equals("TimeStamp")) { 
     620        // parse the time stamp 
     621        // we're not 100% sure of how time stamps should be stored, but this 
     622        // seems to work 
    617623        long high = Long.parseLong(attributes.getValue("HighInteger")); 
    618624        long low = Long.parseLong(attributes.getValue("LowInteger")); 
  • trunk/loci/formats/in/LIMReader.java

    r3617 r3854  
    153153      DataTools.convertDate(System.currentTimeMillis(), DataTools.UNIX), 0); 
    154154    MetadataTools.populatePixels(store, this); 
    155     // CTR CHECK 
    156 //    for (int i=0; i<core.sizeC[0]; i++) { 
    157 //      store.setLogicalChannel(i, null, null, null, null, null, null, null, 
    158 //        null, null, null, null, null, null, null, null, null, null, null, 
    159 //        null, null, null, null, null, null); 
    160 //    } 
    161  
    162155  } 
    163156 
  • trunk/loci/formats/in/LeicaReader.java

    r3842 r3854  
    9797    if (!open) return false; // not allowed to touch the file system 
    9898 
     99    // check for that there is an .lei file in the same directory 
    99100    String prefix = name; 
    100101    if (prefix.indexOf(".") != -1) { 
     
    203204 
    204205    if (checkSuffix(id, TiffReader.TIFF_SUFFIXES)) { 
     206      // need to find the associated .lei file 
    205207      if (ifds == null) super.initFile(id); 
    206208 
     
    259261      throw new FormatException("LEI file not found."); 
    260262    } 
    261     else { 
    262       // parse the LEI file 
    263  
    264       super.initFile(id); 
    265  
    266       leiFilename = new File(id).exists() ? 
    267         new Location(id).getAbsolutePath() : id; 
    268       in = new RandomAccessStream(id); 
    269  
    270       seriesNames = new Vector(); 
    271  
    272       byte[] fourBytes = new byte[4]; 
    273       in.read(fourBytes); 
    274       core.littleEndian[0] = (fourBytes[0] == TiffTools.LITTLE && 
    275         fourBytes[1] == TiffTools.LITTLE && 
    276         fourBytes[2] == TiffTools.LITTLE && 
    277         fourBytes[3] == TiffTools.LITTLE); 
    278  
    279       in.order(core.littleEndian[0]); 
    280  
    281       status("Reading metadata blocks"); 
    282  
    283       in.skipBytes(8); 
    284       int addr = in.readInt(); 
    285       Vector v = new Vector(); 
    286       Hashtable ifd; 
    287       while (addr != 0) { 
    288         ifd = new Hashtable(); 
    289         v.add(ifd); 
    290         in.seek(addr + 4); 
    291  
    292         int tag = in.readInt(); 
    293  
    294         while (tag != 0) { 
    295           // create the IFD structure 
    296           int offset = in.readInt(); 
    297  
    298           long pos = in.getFilePointer(); 
    299           in.seek(offset + 12); 
    300  
    301           int size = in.readInt(); 
    302           byte[] data = new byte[size]; 
    303           in.read(data); 
    304           ifd.put(new Integer(tag), (Object) data); 
    305           in.seek(pos); 
    306           tag = in.readInt(); 
    307         } 
    308  
    309         addr = in.readInt(); 
    310       } 
    311  
    312       numSeries = v.size(); 
    313  
    314       core = new CoreMetadata(numSeries); 
    315       files = new Vector[numSeries]; 
    316  
    317       headerIFDs = (Hashtable[]) v.toArray(new Hashtable[0]); 
    318  
    319       // determine the length of a filename 
    320  
    321       int nameLength = 0; 
    322       int maxPlanes = 0; 
    323  
    324       status("Parsing metadata blocks"); 
    325  
    326       core.littleEndian[0] = !core.littleEndian[0]; 
    327  
    328       for (int i=0; i<headerIFDs.length; i++) { 
    329         if (headerIFDs[i].get(new Integer(SERIES)) != null) { 
    330           byte[] temp = (byte[]) headerIFDs[i].get(new Integer(SERIES)); 
    331           nameLength = DataTools.bytesToInt(temp, 8, core.littleEndian[0]) * 2; 
    332         } 
    333  
    334         Vector f = new Vector(); 
    335         byte[] tempData = (byte[]) headerIFDs[i].get(new Integer(IMAGES)); 
    336         int tempImages = DataTools.bytesToInt(tempData, 0, 
    337           core.littleEndian[0]); 
    338  
    339         File dirFile = new File(id).getAbsoluteFile(); 
    340         String[] listing = null; 
    341         String dirPrefix = ""; 
    342         if (dirFile.exists()) { 
    343           listing = dirFile.getParentFile().list(); 
    344           dirPrefix = dirFile.getParent(); 
    345           if (!dirPrefix.endsWith(File.separator)) dirPrefix += File.separator; 
    346         } 
    347         else { 
    348           listing = 
    349             (String[]) Location.getIdMap().keySet().toArray(new String[0]); 
    350         } 
    351  
    352         Vector list = new Vector(); 
    353  
    354         for (int k=0; k<listing.length; k++) { 
    355           if (checkSuffix(listing[k], TiffReader.TIFF_SUFFIXES)) { 
    356             list.add(listing[k]); 
    357           } 
    358         } 
    359  
    360         listing = (String[]) list.toArray(new String[0]); 
    361  
    362         boolean tiffsExist = true; 
    363  
    364         String prefix = ""; 
    365         for (int j=0; j<tempImages; j++) { 
    366           // read in each filename 
    367           prefix = DataTools.stripString(new String(tempData, 
    368             20 + j*nameLength, nameLength)); 
    369           f.add(dirPrefix + prefix); 
    370           // test to make sure the path is valid 
    371           Location test = new Location((String) f.get(f.size() - 1)); 
    372           if (tiffsExist) tiffsExist = test.exists(); 
    373         } 
    374  
    375         // at least one of the TIFF files was renamed 
    376  
    377         if (!tiffsExist) { 
    378           status("Handling renamed TIFF files"); 
    379  
    380           // get original LEI name associate with each TIFF 
    381           // this lets us figure out which TIFFs we need for this dataset 
    382           Hashtable leiMapping = new Hashtable(); 
    383           int numLeis = 0; 
     263 
     264    // parse the LEI file 
     265 
     266    super.initFile(id); 
     267 
     268    leiFilename = new File(id).exists() ? 
     269      new Location(id).getAbsolutePath() : id; 
     270    in = new RandomAccessStream(id); 
     271 
     272    seriesNames = new Vector(); 
     273 
     274    byte[] fourBytes = new byte[4]; 
     275    in.read(fourBytes); 
     276    core.littleEndian[0] = (fourBytes[0] == TiffTools.LITTLE && 
     277      fourBytes[1] == TiffTools.LITTLE && 
     278      fourBytes[2] == TiffTools.LITTLE && 
     279      fourBytes[3] == TiffTools.LITTLE); 
     280 
     281    in.order(core.littleEndian[0]); 
     282 
     283    status("Reading metadata blocks"); 
     284 
     285    in.skipBytes(8); 
     286    int addr = in.readInt(); 
     287    Vector v = new Vector(); 
     288    Hashtable ifd; 
     289    while (addr != 0) { 
     290      ifd = new Hashtable(); 
     291      v.add(ifd); 
     292      in.seek(addr + 4); 
     293 
     294      int tag = in.readInt(); 
     295 
     296      while (tag != 0) { 
     297        // create the IFD structure 
     298        int offset = in.readInt(); 
     299 
     300        long pos = in.getFilePointer(); 
     301        in.seek(offset + 12); 
     302 
     303        int size = in.readInt(); 
     304        byte[] data = new byte[size]; 
     305        in.read(data); 
     306        ifd.put(new Integer(tag), (Object) data); 
     307        in.seek(pos); 
     308        tag = in.readInt(); 
     309      } 
     310 
     311      addr = in.readInt(); 
     312    } 
     313 
     314    numSeries = v.size(); 
     315 
     316    core = new CoreMetadata(numSeries); 
     317    files = new Vector[numSeries]; 
     318 
     319    headerIFDs = (Hashtable[]) v.toArray(new Hashtable[0]); 
     320 
     321    // determine the length of a filename 
     322 
     323    int nameLength = 0; 
     324    int maxPlanes = 0; 
     325 
     326    status("Parsing metadata blocks"); 
     327 
     328    core.littleEndian[0] = !core.littleEndian[0]; 
     329 
     330    for (int i=0; i<headerIFDs.length; i++) { 
     331      if (headerIFDs[i].get(new Integer(SERIES)) != null) { 
     332        byte[] temp = (byte[]) headerIFDs[i].get(new Integer(SERIES)); 
     333        nameLength = DataTools.bytesToInt(temp, 8, core.littleEndian[0]) * 2; 
     334      } 
     335 
     336      Vector f = new Vector(); 
     337      byte[] tempData = (byte[]) headerIFDs[i].get(new Integer(IMAGES)); 
     338      int tempImages = DataTools.bytesToInt(tempData, 0, 
     339        core.littleEndian[0]); 
     340 
     341      File dirFile = new File(id).getAbsoluteFile(); 
     342      String[] listing = null; 
     343      String dirPrefix = ""; 
     344      if (dirFile.exists()) { 
     345        listing = dirFile.getParentFile().list(); 
     346        dirPrefix = dirFile.getParent(); 
     347        if (!dirPrefix.endsWith(File.separator)) dirPrefix += File.separator; 
     348      } 
     349      else { 
     350        listing = 
     351          (String[]) Location.getIdMap().keySet().toArray(new String[0]); 
     352      } 
     353 
     354      Vector list = new Vector(); 
     355 
     356      for (int k=0; k<listing.length; k++) { 
     357        if (checkSuffix(listing[k], TiffReader.TIFF_SUFFIXES)) { 
     358          list.add(listing[k]); 
     359        } 
     360      } 
     361 
     362      listing = (String[]) list.toArray(new String[0]); 
     363 
     364      boolean tiffsExist = true; 
     365 
     366      String prefix = ""; 
     367      for (int j=0; j<tempImages; j++) { 
     368        // read in each filename 
     369        prefix = DataTools.stripString(new String(tempData, 
     370          20 + j*nameLength, nameLength)); 
     371        f.add(dirPrefix + prefix); 
     372        // test to make sure the path is valid 
     373        Location test = new Location((String) f.get(f.size() - 1)); 
     374        if (tiffsExist) tiffsExist = test.exists(); 
     375      } 
     376 
     377      // at least one of the TIFF files was renamed 
     378 
     379      if (!tiffsExist) { 
     380        status("Handling renamed TIFF files"); 
     381 
     382        // get original LEI name associate with each TIFF 
     383        // this lets us figure out which TIFFs we need for this dataset 
     384        Hashtable leiMapping = new Hashtable(); 
     385        int numLeis = 0; 
     386        for (int j=0; j<listing.length; j++) { 
     387          RandomAccessStream ras = new RandomAccessStream( 
     388            new Location(dirPrefix, listing[j]).getAbsolutePath()); 
     389          ifd = TiffTools.getFirstIFD(ras); 
     390          ras.close(); 
     391          String descr = TiffTools.getComment(ifd); 
     392          int ndx = descr.indexOf("=", descr.indexOf("Series Name")); 
     393          String leiFile = descr.substring(ndx + 1, descr.indexOf("\n", ndx)); 
     394          leiFile = leiFile.trim(); 
     395          if (!leiMapping.contains(leiFile)) numLeis++; 
     396          leiMapping.put(listing[j], leiFile); 
     397        } 
     398 
     399        // compare original TIFF prefix with original LEI prefix 
     400 
     401        f.clear(); 
     402        String[] keys = (String[]) leiMapping.keySet().toArray(new String[0]); 
     403        for (int j=0; j<keys.length; j++) { 
     404          String lei = (String) leiMapping.get(keys[j]); 
     405          if (DataTools.samePrefix(lei, prefix)) { 
     406            f.add(keys[j]); 
     407          } 
     408        } 
     409 
     410        // now that we have our list of files, all that remains is to figure 
     411        // out how they should be ordered 
     412 
     413        // we'll try looking for a naming convention, using FilePattern 
     414        String[] usedFiles = null; 
     415        for (int j=0; j<f.size(); j++) { 
     416          if (usedFiles != null) { 
     417            for (int k=0; k<usedFiles.length; k++) { 
     418              if (usedFiles[k].equals((String) f.get(j)) || 
     419                usedFile((String) f.get(j))) 
     420              { 
     421                k = 0; 
     422                j++; 
     423              } 
     424            } 
     425          } 
     426          if (j >= f.size()) break; 
     427 
     428          FilePattern fp = new FilePattern(new Location((String) f.get(j))); 
     429          if (fp != null) usedFiles = fp.getFiles(); 
     430          if (usedFiles != null && usedFiles.length == tempImages) { 
     431            files[i] = new Vector(); 
     432            for (int k=0; k<usedFiles.length; k++) { 
     433              files[i].add(new Location(usedFiles[k]).getAbsolutePath()); 
     434            } 
     435            break; 
     436          } 
     437        } 
     438 
     439        // failing that, we can check the datestamp in each TIFF file 
     440        // note that this is not guaranteed to work - some versions of 
     441        // the Leica software will write a blank datestamp 
     442        if (files[i] == null || files[i].size() == 0) { 
     443          files[i] = new Vector(); 
     444          Hashtable h = new Hashtable(); 
    384445          for (int j=0; j<listing.length; j++) { 
    385446            RandomAccessStream ras = new RandomAccessStream( 
    386447              new Location(dirPrefix, listing[j]).getAbsolutePath()); 
    387             ifd = TiffTools.getFirstIFD(ras); 
    388             ras.close(); 
    389             String descr = TiffTools.getComment(ifd); 
    390             int ndx = descr.indexOf("=", descr.indexOf("Series Name")); 
    391             String leiFile = descr.substring(ndx + 1, descr.indexOf("\n", ndx)); 
    392             leiFile = leiFile.trim(); 
    393             if (!leiMapping.contains(leiFile)) numLeis++; 
    394             leiMapping.put(listing[j], leiFile); 
    395           } 
    396  
    397           // compare original TIFF prefix with original LEI prefix 
    398  
    399           f.clear(); 
    400           String[] keys = (String[]) leiMapping.keySet().toArray(new String[0]); 
    401           for (int j=0; j<keys.length; j++) { 
    402             String lei = (String) leiMapping.get(keys[j]); 
    403             if (DataTools.samePrefix(lei, prefix)) { 
    404               f.add(keys[j]); 
    405             } 
    406           } 
    407  
    408           // now that we have our list of files, all that remains is to figure 
    409           // out how they should be ordered 
    410  
    411           // we'll try looking for a naming convention, using FilePattern 
    412           String[] usedFiles = null; 
    413           for (int j=0; j<f.size(); j++) { 
    414             if (usedFiles != null) { 
    415               for (int k=0; k<usedFiles.length; k++) { 
    416                 if (usedFiles[k].equals((String) f.get(j)) || 
    417                   usedFile((String) f.get(j))) 
    418                 { 
    419                   k = 0; 
    420                   j++; 
    421                 } 
    422               } 
    423             } 
    424             if (j >= f.size()) break; 
    425  
    426             FilePattern fp = new FilePattern(new Location((String) f.get(j))); 
    427             if (fp != null) usedFiles = fp.getFiles(); 
    428             if (usedFiles != null && usedFiles.length == tempImages) { 
    429               files[i] = new Vector(); 
    430               for (int k=0; k<usedFiles.length; k++) { 
    431                 files[i].add(new Location(usedFiles[k]).getAbsolutePath()); 
    432               } 
    433               break; 
    434             } 
    435           } 
    436  
    437           // failing that, we can check the datestamp in each TIFF file 
    438           // note that this is not guaranteed to work - some versions of 
    439           // the Leica software will write a blank datestamp 
    440           if (files[i] == null || files[i].size() == 0) { 
    441             files[i] = new Vector(); 
    442             Hashtable h = new Hashtable(); 
    443             for (int j=0; j<listing.length; j++) { 
    444               RandomAccessStream ras = new RandomAccessStream( 
    445                 new Location(dirPrefix, listing[j]).getAbsolutePath()); 
    446               Hashtable fd = TiffTools.getFirstIFD(ras); 
    447               String stamp = 
    448                 (String) TiffTools.getIFDValue(fd, TiffTools.DATE_TIME); 
    449               if (h.size() == tempImages) { 
    450                 String[] ks = (String[]) h.keySet().toArray(new String[0]); 
    451                 Arrays.sort(ks); 
    452                 for (int k=0; k<ks.length; k++) { 
    453                   files[i].add(new Location(dirPrefix, 
    454                     (String) h.get(ks[k])).getAbsolutePath()); 
    455                 } 
    456                 h.clear(); 
    457                 break; 
    458               } 
    459               else { 
    460                 if (!h.contains(stamp)) h.put(stamp, listing[j]); 
    461                 else { 
    462                   h.clear(); 
    463                   h.put(stamp, listing[j]); 
    464                 } 
    465               } 
    466               ras.close(); 
    467             } 
     448            Hashtable fd = TiffTools.getFirstIFD(ras); 
     449            String stamp = 
     450              (String) TiffTools.getIFDValue(fd, TiffTools.DATE_TIME); 
    468451            if (h.size() == tempImages) { 
    469452              String[] ks = (String[]) h.keySet().toArray(new String[0]); 
     
    473456                  (String) h.get(ks[k])).getAbsolutePath()); 
    474457              } 
     458              h.clear(); 
     459              break; 
    475460            } 
    476           } 
    477  
    478           // Our final effort is to just sort the filenames lexicographically. 
    479           // This gives us a pretty good chance of getting the order right, 
    480           // but it's not perfect.  Basically covers the (hopefully) unlikely 
    481           // case where filenames are nonsensical, and datestamps are invalid. 
    482           if (files[i] == null || files[i].size() == 0) { 
    483             if (debug) debug("File ordering is not obvious."); 
    484             files[i] = new Vector(); 
    485             Arrays.sort(listing); 
    486             int ndx = 0; 
    487             for (int j=0; j<i; j++) ndx += files[j].size(); 
    488             for (int j=ndx; j<ndx+tempImages; j++) { 
     461            else { 
     462              if (!h.contains(stamp)) h.put(stamp, listing[j]); 
     463              else { 
     464                h.clear(); 
     465                h.put(stamp, listing[j]); 
     466              } 
     467            } 
     468            ras.close(); 
     469          } 
     470          if (h.size() == tempImages) { 
     471            String[] ks = (String[]) h.keySet().toArray(new String[0]); 
     472            Arrays.sort(ks); 
     473            for (int k=0; k<ks.length; k++) { 
    489474              files[i].add(new Location(dirPrefix, 
    490                 listing[j]).getAbsolutePath()); 
     475                (String) h.get(ks[k])).getAbsolutePath()); 
    491476            } 
    492477          } 
    493  
    494           // Ways to break the renaming heuristics: 
    495           // 
    496           // 1) Don't use a detectable naming convention, and remove datestamps 
    497           //    from TIFF files. 
    498           // 2) Use a naming convention such as plane 0 -> "5.tif", 
    499           //    plane 1 -> "4.tif", plane 2 -> "3.tif", etc. 
    500           // 3) Place two datasets in the same folder: 
    501           //      a) swap the two LEI file names 
    502           //      b) use the same naming convention for both sets of TIFF files 
    503           //      c) use the same naming convention AND make sure the datestamps 
    504           //         are the same between TIFF files 
    505         } 
    506         else files[i] = f; 
    507         core.imageCount[i] = files[i].size(); 
    508         if (core.imageCount[i] > maxPlanes) maxPlanes = core.imageCount[i]; 
    509       } 
    510  
    511       tiff = new TiffReader[numSeries][maxPlanes]; 
    512  
    513       for (int i=0; i<tiff.length; i++) { 
    514         for (int j=0; j<tiff[i].length; j++) { 
    515           tiff[i][j] = new TiffReader(); 
    516           if (j > 0) tiff[i][j].setMetadataCollected(false); 
    517         } 
    518       } 
    519  
    520       status("Populating metadata"); 
    521       initMetadata(); 
    522     } 
    523   } 
    524  
    525   // -- Helper methods -- 
    526  
    527   protected void initMetadata() throws FormatException, IOException { 
     478        } 
     479 
     480        // Our final effort is to just sort the filenames lexicographically. 
     481        // This gives us a pretty good chance of getting the order right, 
     482        // but it's not perfect.  Basically covers the (hopefully) unlikely 
     483        // case where filenames are nonsensical, and datestamps are invalid. 
     484        if (files[i] == null || files[i].size() == 0) { 
     485          if (debug) debug("File ordering is not obvious."); 
     486          files[i] = new Vector(); 
     487          Arrays.sort(listing); 
     488          int ndx = 0; 
     489          for (int j=0; j<i; j++) ndx += files[j].size(); 
     490          for (int j=ndx; j<ndx+tempImages; j++) { 
     491            files[i].add(new Location(dirPrefix, 
     492              listing[j]).getAbsolutePath()); 
     493          } 
     494        } 
     495 
     496        // Ways to break the renaming heuristics: 
     497        // 
     498        // 1) Don't use a detectable naming convention, and remove datestamps 
     499        //    from TIFF files. 
     500        // 2) Use a naming convention such as plane 0 -> "5.tif", 
     501        //    plane 1 -> "4.tif", plane 2 -> "3.tif", etc. 
     502        // 3) Place two datasets in the same folder: 
     503        //      a) swap the two LEI file names 
     504        //      b) use the same naming convention for both sets of TIFF files 
     505        //      c) use the same naming convention AND make sure the datestamps 
     506        //         are the same between TIFF files 
     507      } 
     508      else files[i] = f; 
     509      core.imageCount[i] = files[i].size(); 
     510      if (core.imageCount[i] > maxPlanes) maxPlanes = core.imageCount[i]; 
     511    } 
     512 
     513    tiff = new TiffReader[numSeries][maxPlanes]; 
     514 
     515    for (int i=0; i<tiff.length; i++) { 
     516      for (int j=0; j<tiff[i].length; j++) { 
     517        tiff[i][j] = new TiffReader(); 
     518        if (j > 0) tiff[i][j].setMetadataCollected(false); 
     519      } 
     520    } 
     521 
     522    status("Populating metadata"); 
     523 
    528524    if (headerIFDs == null) headerIFDs = ifds; 
    529525 
     
    788784 
    789785            for (int k=0; k<numDims; k++) { 
    790               int v = stream.readInt(); 
     786              int value = stream.readInt(); 
    791787              addMeta("Time-marker " + j + 
    792                 " Dimension " + k + " coordinate", new Integer(v)); 
     788                " Dimension " + k + " coordinate", new Integer(value)); 
    793789            } 
    794790            addMeta("Time-marker " + j, 
     
    851847 
    852848        for (int j=0; j<nChannels; j++) { 
    853           int v = stream.readInt(); 
    854           addMeta("LUT Channel " + j + " version", new Integer(v)); 
     849          int value = stream.readInt(); 
     850          addMeta("LUT Channel " + j + " version", new Integer(value)); 
    855851 
    856852          int invert = stream.read(); 
     
    936932  } 
    937933 
     934  // -- Helper methods -- 
     935 
    938936  private boolean usedFile(String s) { 
    939937    if (files == null) return false; 
  • trunk/loci/formats/in/MNGReader.java

    r3829 r3854  
    138138    status("Finding image offsets"); 
    139139 
     140    // read sequence of [len, code, value] tags 
     141 
    140142    while (in.getFilePointer() < in.length()) { 
    141143      int len = in.readInt(); 
     
    145147 
    146148      if (code.equals("IHDR")) { 
    147         offsets.add(new Long(in.getFilePointer() - 8)); 
     149        offsets.add(new Long(fp - 8)); 
    148150        core.imageCount[0]++; 
    149151      } 
     
    152154      } 
    153155      else if (code.equals("LOOP")) { 
    154         stack.add(new Long(in.getFilePointer() + len + 4)); 
     156        stack.add(new Long(fp + len + 4)); 
    155157        in.skipBytes(1); 
    156158        maxIterations = in.readInt(); 
     
    175177 
    176178    core.sizeZ[0] = 1; 
     179 
     180    // easiest way to get image dimensions is by opening the first plane 
    177181 
    178182    long offset = ((Long) offsets.get(0)).longValue(); 
  • trunk/loci/formats/in/MRCReader.java

    r3617 r3854  
    111111    core.littleEndian[0] = in.read() == 68; 
    112112 
    113     // read 1024 byte header 
     113    // read dimension information from 1024 byte header 
    114114 
    115115    in.seek(0); 
     
    125125    switch (mode) { 
    126126      case 0: 
    127         bpp = 1; 
    128127        core.pixelType[0] = FormatTools.UINT8; 
    129128        break; 
    130129      case 1: 
    131         bpp = 2; 
    132130        core.pixelType[0] = FormatTools.INT16; 
    133131        break; 
    134132      case 6: 
    135         bpp = 2; 
    136133        core.pixelType[0] = FormatTools.UINT16; 
    137134        break; 
    138135      case 2: 
    139         bpp = 4; 
    140136        isFloat = true; 
    141137        core.pixelType[0] = FormatTools.FLOAT; 
    142138        break; 
    143139      case 3: 
    144         bpp = 4; 
    145140        core.pixelType[0] = FormatTools.UINT32; 
    146141        break; 
    147142      case 4: 
    148         bpp = 8; 
    149143        isFloat = true; 
    150144        core.pixelType[0] = FormatTools.DOUBLE; 
    151145        break; 
    152146      case 16: 
    153         bpp = 2; 
    154147        core.sizeC[0] = 3; 
    155148        core.pixelType[0] = FormatTools.UINT16; 
    156149        break; 
    157150    } 
     151 
     152    bpp = FormatTools.getBytesPerPixel(core.pixelType[0]); 
    158153 
    159154    // pixel size = xlen / mx 
     
    167162    float zlen = in.readFloat(); 
    168163 
    169     addMeta("Pixel size (X)", "" + (xlen / mx)); 
    170     addMeta("Pixel size (Y)", "" + (ylen / my)); 
    171     addMeta("Pixel size (Z)", "" + (zlen / mz)); 
    172  
    173     addMeta("Alpha angle", "" + in.readFloat()); 
    174     addMeta("Beta angle", "" + in.readFloat()); 
    175     addMeta("Gamma angle", "" + in.readFloat()); 
     164    addMeta("Pixel size (X)", String.valueOf(xlen / mx)); 
     165    addMeta("Pixel size (Y)", String.valueOf(ylen / my)); 
     166    addMeta("Pixel size (Z)", String.valueOf(zlen / mz)); 
     167 
     168    addMeta("Alpha angle", String.valueOf(in.readFloat())); 
     169    addMeta("Beta angle", String.valueOf(in.readFloat())); 
     170    addMeta("Gamma angle", String.valueOf(in.readFloat())); 
    176171 
    177172    in.skipBytes(12); 
     
    179174    // min, max and mean pixel values 
    180175 
    181     addMeta("Minimum pixel value", "" + in.readFloat()); 
    182     addMeta("Maximum pixel value", "" + in.readFloat()); 
    183     addMeta("Mean pixel value", "" + in.readFloat()); 
     176    addMeta("Minimum pixel value", String.valueOf(in.readFloat())); 
     177    addMeta("Maximum pixel value", String.valueOf(in.readFloat())); 
     178    addMeta("Mean pixel value", String.valueOf(in.readFloat())); 
    184179 
    185180    in.skipBytes(4); 
     
    195190 
    196191    addMeta("Series type", type); 
    197     addMeta("Lens", "" + in.readShort()); 
    198     addMeta("ND1", "" + in.readShort()); 
    199     addMeta("ND2", "" + in.readShort()); 
    200     addMeta("VD1", "" + in.readShort()); 
    201     addMeta("VD2", "" + in.readShort()); 
     192    addMeta("Lens", String.valueOf(in.readShort())); 
     193    addMeta("ND1", String.valueOf(in.readShort())); 
     194    addMeta("ND2", String.valueOf(in.readShort())); 
     195    addMeta("VD1", String.valueOf(in.readShort())); 
     196    addMeta("VD2", String.valueOf(in.readShort())); 
    202197 
    203198    float[] angles = new float[6]; 
  • trunk/loci/formats/in/MetamorphReader.java

    r3781 r3854  
    6464  private String imageCreationDate; 
    6565 
    66   //** The TIFF's emWavelength */ 
     66  /** The TIFF's emWavelength */ 
    6767  private long[] emWavelength; 
    6868 
     
    9494       id.startsWith(files[i].substring(0, files[i].lastIndexOf(".")))) 
    9595      { 
    96         return FormatTools.CAN_GROUP; 
     96        return FormatTools.MUST_GROUP; 
    9797      } 
    9898    } 
     
    191191      (fileGroupOption(id) == FormatTools.MUST_GROUP || isGroupFiles())) 
    192192    { 
     193      // parse key/value pairs from .nd file 
     194 
    193195      RandomAccessStream ndStream = 
    194196        new RandomAccessStream(ndfile.getAbsolutePath()); 
     
    261263        } 
    262264      } 
     265 
     266      // build list of STK files 
    263267 
    264268      int[] pt = new int[seriesCount]; 
     
    277281 
    278282      ndfile = ndfile.getAbsoluteFile(); 
     283 
     284      // check that each STK file exists 
    279285 
    280286      for (int s=0; s<stks.length; s++) { 
     
    403409      Hashtable temp; 
    404410      for(int i=0; i<core.imageCount[0]; i++) { 
    405         temp = new Hashtable(); 
    406  
    407         // copy most of the data from 1st IFD 
    408         temp.put(new Integer(TiffTools.LITTLE_ENDIAN), ifds[0].get( 
    409             new Integer(TiffTools.LITTLE_ENDIAN))); 
    410         temp.put(new Integer(TiffTools.IMAGE_WIDTH), ifds[0].get( 
    411             new Integer(TiffTools.IMAGE_WIDTH))); 
    412         temp.put(new Integer(TiffTools.IMAGE_LENGTH), 
    413             ifds[0].get(new Integer(TiffTools.IMAGE_LENGTH))); 
    414         temp.put(new Integer(TiffTools.BITS_PER_SAMPLE), ifds[0].get( 
    415             new Integer(TiffTools.BITS_PER_SAMPLE))); 
    416         temp.put(new Integer(TiffTools.COMPRESSION), ifds[0].get( 
    417             new Integer(TiffTools.COMPRESSION))); 
    418         temp.put(new Integer(TiffTools.PHOTOMETRIC_INTERPRETATION), 
    419             ifds[0].get(new Integer(TiffTools.PHOTOMETRIC_INTERPRETATION))); 
    420         temp.put(new Integer(TiffTools.STRIP_BYTE_COUNTS), ifds[0].get( 
    421             new Integer(TiffTools.STRIP_BYTE_COUNTS))); 
    422         temp.put(new Integer(TiffTools.ROWS_PER_STRIP), ifds[0].get( 
    423             new Integer(TiffTools.ROWS_PER_STRIP))); 
    424         temp.put(new Integer(TiffTools.X_RESOLUTION), ifds[0].get( 
    425             new Integer(TiffTools.X_RESOLUTION))); 
    426         temp.put(new Integer(TiffTools.Y_RESOLUTION), ifds[0].get( 
    427             new Integer(TiffTools.Y_RESOLUTION))); 
    428         temp.put(new Integer(TiffTools.RESOLUTION_UNIT), ifds[0].get( 
    429             new Integer(TiffTools.RESOLUTION_UNIT))); 
    430         temp.put(new Integer(TiffTools.PREDICTOR), ifds[0].get( 
    431             new Integer(TiffTools.PREDICTOR))); 
    432  
    433         // now we need a StripOffsets entry 
     411        // copy data from the first IFD 
     412        temp = new Hashtable(ifds[0]); 
     413 
     414        // now we need a StripOffsets entry - the original IFD doesn't have this 
    434415 
    435416        long planeOffset = i*(oldOffsets[stripsPerImage - 1] + 
     
    784765          int zoom = valOrOffset; 
    785766          put("Zoom", zoom); 
    786           //OMETools.setAttribute(ome, "DisplayOptions", "Zoom", "" + zoom); 
    787767          break; 
    788768        case 16: // oh how we hate you Julian format... 
  • trunk/loci/formats/in/MetamorphTiffReader.java

    r3790 r3854  
    7777      RandomAccessStream stream = new RandomAccessStream(block); 
    7878      String comment = TiffTools.getComment(TiffTools.getFirstIFD(stream)); 
    79       stream.close();  
     79      stream.close(); 
    8080      return comment != null && comment.trim().startsWith("<MetaData>"); 
    8181    } 
     
    101101    zpPointer = 0; 
    102102    wavePointer = 0; 
     103 
     104    // parse XML comment 
     105 
    103106    MetamorphHandler handler = new MetamorphHandler(); 
    104107    try { 
     
    117120 
    118121    core.sizeC[0] = core.sizeZ[0] = 0; 
     122 
     123    // calculate axis sizes 
    119124 
    120125    Vector uniqueZ = new Vector(); 
  • trunk/loci/formats/in/MicromanagerReader.java

    r3842 r3854  
    161161    // now parse the rest of the metadata 
    162162 
     163    // metadata.txt looks something like this: 
     164    // 
     165    // { 
     166    //   "Section Name": { 
     167    //      "Key": "Value", 
     168    //      "Array key": [ 
     169    //        first array value, second array value 
     170    //      ] 
     171    //   } 
     172    // 
     173    // } 
     174 
    163175    status("Populating metadata"); 
    164176 
     
    229241 
    230242          addMeta(key, value); 
    231  
    232           if (key.equals("Exposure-ms")) { 
    233  
    234           } 
    235           else if (key.equals("ElapsedTime-ms")) { 
    236  
    237           } 
    238           else if (key.equals("Z-um")) { 
    239  
    240           } 
    241243 
    242244          token = st.nextToken().trim(); 
  • trunk/loci/formats/in/ND2Reader.java

    r3844 r3854  
    4848 * (2) the JAI jar file precedes JJ2000 in the classpath. 
    4949 * 
     50 * Also note that there is alternate ND2 reader for Windows 
     51 * (see LegacyND2Reader.java) that requires a native library.  If that native 
     52 * library is installed, then ND2Reader's logic will be bypassed. 
     53 * 
    5054 * <dl><dt><b>Source code:</b></dt> 
    5155 * <dd><a href="https://skyking.microscopy.wisc.edu/trac/java/browser/trunk/loci/formats/in/ND2Reader.java">Trac</a>, 
     
    183187 
    184188    if (isJPEG) { 
     189      // plane is compressed using JPEG 2000 
    185190      BufferedImage b = openImage(no, x, y, w, h); 
    186191      byte[][] pixels = ImageTools.getPixelBytes(b, false); 
     
    196201    } 
    197202    else if (isLossless) { 
     203      // plane is compressed using ZLIB 
    198204      int plane = core.sizeX[series] * core.sizeY[series] * pixel; 
    199205      byte[] b = new byte[plane]; 
     
    221227    } 
    222228    else { 
     229      // plane is not compressed 
    223230      in.skipBytes(y * core.sizeX[series] * pixel); 
    224231      for (int row=0; row<h; row++) { 
     
    505512    else in.seek(0); 
    506513 
     514    // older version of ND2 - uses JPEG 2000 compression 
     515 
    507516    isJPEG = true; 
    508517 
     
    515524    int length = 0; 
    516525    int box = 0; 
     526 
     527    // assemble offsets to each plane 
    517528 
    518529    while (!lastBoxFound) { 
     
    566577    if (off > 0 && off < in.length() - 5 && (in.length() - off - 5) > 14) { 
    567578      in.seek(off + 5); 
    568       byte[] b = new byte[(int) (in.length() - off - 5)]; 
    569       in.readFully(b); 
    570       String xml = new String(b); 
    571  
    572       // assume that this XML string will be malformed, since that's how both 
    573       // sample files are; this means we need to manually parse it :-( 
     579      String xml = in.readString((int) (in.length() - in.getFilePointer())); 
    574580 
    575581      // strip out binary data at the end - this is irrelevant for our purposes 
    576       xml = xml.substring(0, xml.lastIndexOf("</MetadataSeq>") + 14); 
     582      xml = "\n" + xml.substring(0, xml.lastIndexOf("</MetadataSeq>") + 14); 
    577583 
    578584      // strip out all comments 
    579       xml = xml.replaceAll("<!--*-->", ""); 
    580  
    581       // each chunk appears on a separate line, so split up the chunks 
    582  
    583       StringTokenizer st = new StringTokenizer(xml, "\r\n"); 
    584       while (st.hasMoreTokens()) { 
    585         String token = st.nextToken().trim(); 
    586         if (token.indexOf("<") != -1) { 
    587           String prefix = token.substring(1, token.indexOf(">")).trim(); 
    588           token = token.substring(token.indexOf(">") + 1); 
    589  
    590           while (token.indexOf("<") != -1) { 
    591             int start = token.indexOf("<"); 
    592             String s = token.substring(start + 1, token.indexOf(">", start)); 
    593             token = token.substring(token.indexOf(">", start)); 
    594  
    595             // get the prefix for this tag 
    596             if (s.indexOf(" ") != -1) { 
    597               String pre = s.substring(0, s.indexOf(" ")).trim(); 
    598               s = s.substring(s.indexOf(" ") + 1); 
    599  
    600               // get key/value pairs 
    601               while (s.indexOf("=") != -1) { 
    602                 int eq = s.indexOf("="); 
    603                 int end = s.indexOf("\"", eq + 2); 
    604                 if (eq < 0 || end < 0) break; 
    605                 String key = s.substring(0, eq).trim(); 
    606                 String value = s.substring(eq + 2, end).trim(); 
    607  
    608                 // strip out the data types 
    609                 if (key.indexOf("runtype") == -1) { 
    610                   if (prefix.startsWith("Metadata_V1.2")) { 
    611                     prefix = ""; 
    612                   } 
    613                   String effectiveKey = prefix + " " + pre + " " + key; 
    614                   if (effectiveKey.endsWith("dTimeMSec value")) { 
    615                     long v = (long) Double.parseDouble(value); 
    616                     if (!ts.contains(new Long(v))) { 
    617                       ts.add(new Long(v)); 
    618                     } 
    619                   } 
    620                   else if (effectiveKey.endsWith("dZPos value")) { 
    621                     long v = (long) Double.parseDouble(value); 
    622                     if (!zs.contains(new Long(v))) { 
    623                       zs.add(new Long(v)); 
    624                     } 
    625                   } 
    626                   else if (effectiveKey.endsWith("uiComp value")) { 
    627                     if (core.sizeC[0] == 0) { 
    628                       core.sizeC[0] = Integer.parseInt(value); 
    629                     } 
    630                   } 
    631                   else if (effectiveKey.endsWith("uiCount value")) { 
    632                     if (core.sizeT[0] == 0) { 
    633                       core.sizeT[0] = Integer.parseInt(value); 
    634                     } 
    635                   } 
    636                   else if (effectiveKey.endsWith("TextInfoItem Text")) { 
    637                     value = value.replaceAll("&#x000d;&#x000a;", "\n"); 
    638                     StringTokenizer tokens = new StringTokenizer(value, "\n"); 
    639                     while (tokens.hasMoreTokens()) { 
    640                       String t = tokens.nextToken().trim(); 
    641                       if (t.startsWith("Dimensions:")) { 
    642                         t = t.substring(11); 
    643                         StringTokenizer dims = new StringTokenizer(t, " x "); 
    644                         while (dims.hasMoreTokens()) { 
    645                           String dim = dims.nextToken().trim(); 
    646                           int idx = dim.indexOf("("); 
    647                           int v = Integer.parseInt(dim.substring(idx + 1, 
    648                             dim.indexOf(")", idx))); 
    649                           if (dim.startsWith("XY")) { 
    650                             numSeries = v; 
    651                             if (numSeries > 1) { 
    652                               int x = core.sizeX[0]; 
    653                               int y = core.sizeY[0]; 
    654                               int z = core.sizeZ[0]; 
    655                               int tSize = core.sizeT[0]; 
    656                               int c = core.sizeC[0]; 
    657                               core = new CoreMetadata(numSeries); 
    658                               Arrays.fill(core.sizeX, x); 
    659                               Arrays.fill(core.sizeY, y); 
    660                               Arrays.fill(core.sizeZ, z); 
    661                               Arrays.fill(core.sizeC, c); 
    662                               Arrays.fill(core.sizeT, tSize); 
    663                             } 
    664                           } 
    665                           else if (dim.startsWith("T")) { 
    666                             Arrays.fill(core.sizeT, v); 
    667                           } 
    668                           else if (dim.startsWith("Z")) { 
    669                             Arrays.fill(core.sizeZ, v); 
    670                           } 
    671                           else { 
    672                             Arrays.fill(core.sizeC, v); 
    673                           } 
    674                         } 
    675  
    676                         if (core.sizeZ[0] == 0) Arrays.fill(core.sizeZ, 1); 
    677                         if (core.sizeC[0] == 0) Arrays.fill(core.sizeC, 1); 
    678                         if (core.sizeT[0] == 0) Arrays.fill(core.sizeT, 1); 
    679  
    680                         int count = 
    681                           core.sizeZ[0] * core.sizeC[0] * core.sizeT[0]; 
    682                         Arrays.fill(core.imageCount, count); 
    683                       } 
    684                     } 
    685                   } 
    686                   parseKeyAndValue(effectiveKey, value); 
    687                 } 
    688                 s = s.substring(s.indexOf("\"", eq + 2) + 1); 
    689               } 
    690             } 
    691           } 
    692         } 
    693       } 
    694       b = null; 
     585      xml = xml.replaceAll("<!--.*-->", ""); 
     586      xml = xml.replaceAll("\n.*xml", ""); 
     587 
     588      // stored XML doesn't have a root node - add one, so that we can parse 
     589      // using SAX 
     590 
     591      xml = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><NIKON>" + xml + 
     592        "</NIKON>"; 
     593 
     594      ND2Handler handler = new ND2Handler(); 
     595 
     596      // strip out invalid characters 
     597      int offset = 0; 
     598      byte[] b = xml.getBytes(); 
     599      int len = b.length; 
     600      for (int i=0; i<len; i++) { 
     601        char c = (char) b[i]; 
     602        if (offset == 0 && c == '!') offset = i + 1; 
     603 
     604        if (Character.isISOControl(c) || !Character.isDefined(c)) { 
     605          b[i] = (byte) ' '; 
     606        } 
     607      } 
     608 
     609      ByteArrayInputStream s = 
     610        new ByteArrayInputStream(b, offset, len - offset); 
     611 
     612      try { 
     613        SAXParser parser = SAX_FACTORY.newSAXParser(); 
     614        parser.parse(s, handler); 
     615      } 
     616      catch (ParserConfigurationException exc) { 
     617        throw new FormatException(exc); 
     618      } 
     619      catch (SAXException exc) { 
     620        throw new FormatException(exc); 
     621      } 
     622 
     623      s.close(); 
    695624      xml = null; 
    696       st = null; 
    697625    } 
    698626 
     
    837765  /** SAX handler for parsing XML. */ 
    838766  class ND2Handler extends DefaultHandler { 
     767    private String prefix = null; 
     768 
     769    public void endElement(String uri, String localName, String qName, 
     770      Attributes attributes) 
     771    { 
     772      if (qName.equals("CalibrationSeq") || qName.equals("MetadataSeq")) { 
     773        prefix = null; 
     774      } 
     775    } 
     776 
    839777    public void startElement(String uri, String localName, String qName, 
    840778      Attributes attributes) 
     
    861799      } 
    862800      else if (qName.equals("uiComp")) { 
    863         core.sizeC[0] = Integer.parseInt(attributes.getValue("value")); 
     801        if (core.sizeC[0] == 0) { 
     802          core.sizeC[0] = Integer.parseInt(attributes.getValue("value")); 
     803        } 
    864804      } 
    865805      else if (qName.equals("uiBpcInMemory")) { 
     
    868808        int bytes = bits / 8; 
    869809        switch (bytes) { 
    870           case 1: 
    871             core.pixelType[0] = FormatTools.UINT8; 
    872             break; 
    873810          case 2: 
    874811            core.pixelType[0] = FormatTools.UINT16; 
     
    932869        parseKeyAndValue(qName, attributes.getValue("value")); 
    933870      } 
     871      else if (qName.equals("CalibrationSeq") || qName.equals("MetadataSeq")) { 
     872        prefix = qName + " " + attributes.getValue("_SEQUENCE_INDEX"); 
     873      } 
    934874      else { 
    935         parseKeyAndValue(qName, attributes.getValue("value")); 
     875        StringBuffer sb = new StringBuffer(); 
     876        if (prefix != null) { 
     877          sb.append(prefix); 
     878          sb.append(" "); 
     879        } 
     880        sb.append(qName); 
     881        if (prefix != null) sb.append(" value"); 
     882        parseKeyAndValue(sb.toString(), attributes.getValue("value")); 
    936883      } 
    937884    } 
     
    942889  private void parseKeyAndValue(String key, String value) { 
    943890    addMeta(key, value); 
    944     if (key.equals("CalibrationSeq _SEQUENCE_INDEX=\"0\" dCalibration value")) { 
     891    if (key.endsWith("dCalibration value")) { 
    945892      pixelSizeX = Float.parseFloat(value); 
    946893      pixelSizeY = pixelSizeX; 
    947894    } 
    948     else if (key.equals("CalibrationSeq _SEQUENCE_INDEX=\"0\" dAspect value")) { 
     895    else if (key.endsWith("dAspect value")) { 
    949896      pixelSizeZ = Float.parseFloat(value); 
    950897    } 
    951     else if (key.equals("MetadataSeq _SEQUENCE_INDEX=\"0\" dGain value")) { 
     898    else if (key.endsWith("dGain value")) { 
    952899      gain = value; 
    953900    } 
    954     else if (key.equals("MetadataSeq _SEQUENCE_INDEX=\"0\" dLampVoltage value")) 
     901    else if (key.endsWith("dLampVoltage value")) 
    955902    { 
    956903      voltage = value; 
    957904    } 
    958     else if (key.equals("MetadataSeq " + 
    959       "_SEQUENCE_INDEX=\"0\" dObjectiveMag value")) 
     905    else if (key.endsWith("dObjectiveMag value")) 
    960906    { 
    961907      mag = value; 
    962908    } 
    963     else if (key.equals("MetadataSeq _SEQUENCE_INDEX=\"0\" dObjectiveNA value")) 
     909    else if (key.endsWith("dObjectiveNA value")) 
    964910    { 
    965911      na = value; 
    966912    } 
     913    else if (key.endsWith("dTimeMSec value")) { 
     914      long v = (long) Double.parseDouble(value); 
     915      if (!ts.contains(new Long(v))) { 
     916        ts.add(new Long(v)); 
     917      } 
     918    } 
     919    else if (key.endsWith("dZPos value")) { 
     920      long v = (long) Double.parseDouble(value); 
     921      if (!zs.contains(new Long(v))) { 
     922        zs.add(new Long(v)); 
     923      } 
     924    } 
     925    else if (key.endsWith("uiCount value")) { 
     926      if (core.sizeT[0] == 0) { 
     927        core.sizeT[0] = Integer.parseInt(value); 
     928      } 
     929    } 
     930    else if (key.endsWith("TextInfoItem Text")) { 
     931      value = value.replaceAll("&#x000d;&#x000a;", "\n"); 
     932      StringTokenizer tokens = new StringTokenizer(value, "\n"); 
     933      while (tokens.hasMoreTokens()) { 
     934        String t = tokens.nextToken().trim(); 
     935        if (t.startsWith("Dimensions:")) { 
     936          t = t.substring(11); 
     937          StringTokenizer dims = new StringTokenizer(t, " x "); 
     938          while (dims.hasMoreTokens()) { 
     939            String dim = dims.nextToken().trim(); 
     940            int idx = dim.indexOf("("); 
     941            int v = Integer.parseInt(dim.substring(idx + 1, 
     942              dim.indexOf(")", idx))); 
     943            if (dim.startsWith("XY")) { 
     944              numSeries = v; 
     945              if (numSeries > 1) { 
     946                int x = core.sizeX[0]; 
     947                int y = core.sizeY[0]; 
     948                int z = core.sizeZ[0]; 
     949                int tSize = core.sizeT[0]; 
     950                int c = core.sizeC[0]; 
     951                core = new CoreMetadata(numSeries); 
     952                Arrays.fill(core.sizeX, x); 
     953                Arrays.fill(core.sizeY, y); 
     954                Arrays.fill(core.sizeZ, z); 
     955                Arrays.fill(core.sizeC, c); 
     956                Arrays.fill(core.sizeT, tSize); 
     957              } 
     958            } 
     959            else if (dim.startsWith("T")) { 
     960              Arrays.fill(core.sizeT, v); 
     961            } 
     962            else if (dim.startsWith("Z")) { 
     963              Arrays.fill(core.sizeZ, v); 
     964            } 
     965            else { 
     966              Arrays.fill(core.sizeC, v); 
     967            } 
     968          } 
     969 
     970          if (core.sizeZ[0] == 0) Arrays.fill(core.sizeZ, 1); 
     971          if (core.sizeC[0] == 0) Arrays.fill(core.sizeC, 1); 
     972          if (core.sizeT[0] == 0) Arrays.fill(core.sizeT, 1); 
     973 
     974          int count = core.sizeZ[0] * core.sizeC[0] * core.sizeT[0]; 
     975          Arrays.fill(core.imageCount, count); 
     976        } 
     977      } 
     978    } 
    967979  } 
    968980 
  • trunk/loci/formats/in/NRRDReader.java

    r3794 r3854  
    3232 
    3333/** 
    34  * File format reader for NRRD files;  see http://teem.sourceforge.net/nrrd. 
     34 * File format reader for NRRD files; see http://teem.sourceforge.net/nrrd. 
    3535 * 
    3636 * <dl><dt><b>Source code:</b></dt> 
     
    223223    } 
    224224 
     225    // nrrd files store pixel data in addition to metadata 
     226    // nhdr files don't store pixel data, but instead provide a path to the 
     227    //   pixels file (this can be any format) 
     228 
    225229    if (dataFile == null) offset = in.getFilePointer(); 
    226230    else { 
  • trunk/loci/formats/in/OpenlabReader.java

    r3683 r3854  
    166166    } 
    167167    else { 
     168      // PICT plane 
    168169      in.read(b); 
    169170      Exception exc = null; 
  • trunk/loci/formats/in/PCIReader.java

    r3836 r3854  
    9090 
    9191    s.close(); 
    92  
    93     if (core.pixelType[0] == FormatTools.UINT16) { 
    94       for (int i=0; i<buf.length; i+=2) { 
    95         byte b = buf[i]; 
    96         buf[i] = buf[i + 1]; 
    97         buf[i + 1] = b; 
    98       } 
    99     } 
    100     else if (core.pixelType[0] == FormatTools.UINT32) { 
    101       for (int i=0; i<buf.length; i+=4) { 
    102         byte b = buf[i]; 
    103         buf[i] = buf[i + 3]; 
    104         buf[i + 3] = b; 
    105         b = buf[i + 1]; 
    106         buf[i + 1] = buf[i + 2]; 
    107         buf[i + 2] = b; 
    108       } 
    109     } 
    11092 
    11193    return buf; 
     
    219201    core.interleaved[0] = false; 
    220202    core.currentOrder[0] = "XYCZT"; 
    221     core.littleEndian[0] = false; 
     203    core.littleEndian[0] = true; 
    222204    core.indexed[0] = false; 
    223205    core.falseColor[0] = false; 
  • trunk/loci/formats/in/PCXReader.java

    r3801 r3854  
    140140    int horizDPI = version == 5 ? in.readShort() : 1; 
    141141 
    142     in.skipBytes(48); 
    143  
    144     in.skipBytes(1); 
     142    in.skipBytes(49); 
    145143 
    146144    nColorPlanes = in.read(); 
  • trunk/loci/formats/in/PictReader.java

    r3732 r3854  
    3333import loci.formats.meta.FilterMetadata; 
    3434import loci.formats.meta.MetadataStore; 
     35 
     36// TODO : lots of duplicate code can be removed from this reader 
    3537 
    3638/** 
  • trunk/loci/formats/in/PrairieReader.java

    r3842 r3854  
    2828import java.text.*; 
    2929import java.util.*; 
     30import javax.xml.parsers.*; 
    3031import loci.formats.*; 
    3132import loci.formats.meta.FilterMetadata; 
    3233import loci.formats.meta.MetadataStore; 
     34import org.xml.sax.Attributes; 
     35import org.xml.sax.SAXException; 
     36import org.xml.sax.helpers.DefaultHandler; 
    3337 
    3438/** 
     
    5660  private static final int PRAIRIE_TAG_3 = 33630; 
    5761 
     62  /** Factory for generating SAX parsers. */ 
     63  public static final SAXParserFactory SAX_FACTORY = 
     64    SAXParserFactory.newInstance(); 
     65 
    5866  // -- Fields -- 
    5967 
     
    6775  private String xmlFile, cfgFile; 
    6876  private boolean readXML = false, readCFG = false; 
     77 
     78  private int zt; 
     79  private Vector f, gains, offsets; 
     80  private boolean isZ; 
     81  private float pixelSizeX, pixelSizeY; 
     82  private String date, laserPower; 
    6983 
    7084  // -- Constructor -- 
     
    173187    readXML = false; 
    174188    readCFG = false; 
     189    isZ = false; 
     190    zt = 0; 
     191    f = null; 
    175192  } 
    176193 
     
    200217      } 
    201218 
     219      f = new Vector(); 
     220      gains = new Vector(); 
     221      offsets = new Vector(); 
     222      zt = 0; 
     223 
    202224      RandomAccessStream is = new RandomAccessStream(id); 
    203225      byte[] b = new byte[(int) is.length()]; 
    204226      is.read(b); 
    205227      is.close(); 
    206       String s = new String(b); 
    207  
    208       Vector elements = new Vector(); 
    209  
    210       while (s.length() > 0) { 
    211         int ndx = s.indexOf("<"); 
    212         int val1 = s.indexOf(">", ndx); 
    213         if (val1 != -1 && val1 > ndx) { 
    214           String sub = s.substring(ndx + 1, val1); 
    215           s = s.substring(val1 + 1); 
    216           elements.add(sub); 
    217         } 
    218       } 
    219  
    220       int zt = 0; 
    221       boolean isZ = false; 
    222       Vector f = new Vector(); 
    223       int fileIndex = 1; 
    224       if (checkSuffix(id, XML_SUFFIX)) core.imageCount[0] = 0; 
    225  
    226       float pixelSizeX = 1f, pixelSizeY = 1f; 
    227       String date = null, laserPower = null; 
    228       Vector gains = new Vector(), offsets = new Vector(); 
    229  
    230       String pastPrefix = ""; 
    231       for (int i=1; i<elements.size(); i++) { 
    232         String el = (String) elements.get(i); 
    233         if (el.indexOf(" ") != -1) { 
    234           boolean closed = el.endsWith("/"); 
    235  
    236           String prefix = el.substring(0, el.indexOf(" ")); 
    237           if (prefix.equals("File")) core.imageCount[0]++; 
    238           if (prefix.equals("Frame")) { 
    239             zt++; 
    240             fileIndex = 1; 
    241           } 
    242  
    243           if (!prefix.equals("Key") && !prefix.equals("Frame")) { 
    244             el = el.substring(el.indexOf(" ") + 1); 
    245             while (el.indexOf("=") != -1) { 
    246               int eq = el.indexOf("="); 
    247               String key = el.substring(0, eq); 
    248               String value = el.substring(eq + 2, el.indexOf("\"", eq + 2)); 
    249               if (prefix.equals("File")) { 
    250                 addMeta(pastPrefix + " " + prefix + " " + fileIndex + 
    251                   " " + key, value); 
    252                 if (key.equals("filename")) fileIndex++; 
    253               } 
    254               else { 
    255                 addMeta(pastPrefix + " " + prefix + " " + key, value); 
    256                 if (pastPrefix.equals("PVScan") && 
    257                   prefix.equals("Sequence") && key.equals("type")) 
    258                 { 
    259                   isZ = value.equals("ZSeries"); 
    260                 } 
    261                 if (prefix.equals("PVScan") && key.equals("date")) { 
    262                   date = value; 
    263                 } 
    264               } 
    265               el = el.substring(el.indexOf("\"", eq + 2) + 1).trim(); 
    266               if (prefix.equals("File") && key.equals("filename")) { 
    267                 File current = new File(id).getAbsoluteFile(); 
    268                 String dir = ""; 
    269                 if (current.exists()) { 
    270                   dir = current.getPath(); 
    271                   dir = dir.substring(0, dir.lastIndexOf(File.separator) + 1); 
    272                 } 
    273                 f.add(dir + value); 
    274               } 
    275             } 
    276           } 
    277           else if (prefix.equals("Key")) { 
    278             int keyIndex = el.indexOf("key") + 5; 
    279             int valueIndex = el.indexOf("value") + 7; 
    280             String key = el.substring(keyIndex, el.indexOf("\"", keyIndex)); 
    281             String value = 
    282               el.substring(valueIndex, el.indexOf("\"", valueIndex)); 
    283             addMeta(key, value); 
    284  
    285             if (key.equals("pixelsPerLine")) { 
    286               core.sizeX[0] = Integer.parseInt(value); 
    287             } 
    288             else if (key.equals("linesPerFrame")) { 
    289               core.sizeY[0] = Integer.parseInt(value); 
    290             } 
    291             else if (key.equals("micronsPerPixel_XAxis")) { 
    292               pixelSizeX = Float.parseFloat(value); 
    293             } 
    294             else if (key.equals("micronsPerPixel_YAxis")) { 
    295               pixelSizeY = Float.parseFloat(value); 
    296             } 
    297             else if (key.startsWith("pmtGain_")) gains.add(value); 
    298             else if (key.startsWith("pmtOffset_")) offsets.add(value); 
    299             else if (key.equals(" PVScan date")) date = value; 
    300             else if (key.equals("laserPower_0")) laserPower = value; 
    301           } 
    302           if (!closed) { 
    303             pastPrefix = prefix; 
    304             if (prefix.equals("Frame")) { 
    305               int index = el.indexOf("index") + 7; 
    306               String idx = el.substring(index, el.indexOf("\"", index)); 
    307               pastPrefix += " " + idx; 
    308             } 
    309           } 
    310         } 
     228 
     229      PrairieHandler handler = new PrairieHandler(); 
     230      try { 
     231        SAXParser parser = SAX_FACTORY.newSAXParser(); 
     232        parser.parse(new ByteArrayInputStream(b), handler); 
     233      } 
     234      catch (ParserConfigurationException exc) { 
     235        throw new FormatException(exc); 
     236      } 
     237      catch (SAXException exc) { 
     238        throw new FormatException(exc); 
    311239      } 
    312240 
     
    415343  } 
    416344 
     345  // -- Helper classes -- 
     346 
     347  /** SAX handler for parsing XML. */ 
     348  public class PrairieHandler extends DefaultHandler { 
     349    public void startElement(String uri, String localName, String qName, 
     350      Attributes attributes) 
     351    { 
     352      if (qName.equals("PVScan")) { 
     353        date = attributes.getValue("date"); 
     354      } 
     355      else if (qName.equals("Frame")) zt++; 
     356      else if (qName.equals("Sequence")) { 
     357        isZ = attributes.getValue("type").equals("ZSeries"); 
     358      } 
     359      else if (qName.equals("File")) { 
     360        core.imageCount[0]++; 
     361        File current = new File(currentId).getAbsoluteFile(); 
     362        String dir = ""; 
     363        if (current.exists()) { 
     364          dir = current.getPath(); 
     365          dir = dir.substring(0, dir.lastIndexOf(File.separator) + 1); 
     366        } 
     367        f.add(dir + attributes.getValue("filename")); 
     368      } 
     369      else if (qName.equals("Key")) { 
     370        String key = attributes.getValue("key"); 
     371        String value = attributes.getValue("value"); 
     372        addMeta(key, value); 
     373 
     374        if (key.equals("pixelsPerLine")) { 
     375          core.sizeX[0] = Integer.parseInt(value); 
     376        } 
     377        else if (key.equals("linesPerFrame")) { 
     378          core.sizeY[0] = Integer.parseInt(value); 
     379        } 
     380        else if (key.equals("micronsPerPixel_XAxis")) { 
     381          pixelSizeX = Float.parseFloat(value); 
     382        } 
     383        else if (key.equals("micronsPerPixel_YAxis")) { 
     384          pixelSizeY = Float.parseFloat(value); 
     385        } 
     386        else if (key.startsWith("pmtGain_")) gains.add(value); 
     387        else if (key.startsWith("pmtOffset_")) offsets.add(value); 
     388        else if (key.equals("laserPower_0")) laserPower = value; 
     389      } 
     390    } 
     391  } 
     392 
    417393} 
  • trunk/loci/formats/in/SDTReader.java

    r3617 r3854  
    164164          } 
    165165          int ndx = 2 * (w * row + col); 
    166           buf[ndx] = (byte) (sum & 0xff); 
    167           buf[ndx + 1] = (byte) ((sum >> 8) & 0xff); 
     166          DataTools.unpackShort(sum, buf, ndx, core.littleEndian[0]); 
    168167        } 
    169168        offset += timeBins * 2 * (core.sizeX[series] - w - x); 
     
    245244  } 
    246245 
    247   // -- Deprecated API methods -- 
    248  
    249   /** @deprecated Replaced by {@link #getTimeBinCount()} */ 
    250   public int getTimeBinCount(String id) throws FormatException, IOException { 
    251     setId(id); 
    252     return getTimeBinCount(); 
    253   } 
    254  
    255   /** @deprecated Replaced by {@link #getChannelCount()} */ 
    256   public int getChannelCount(String id) throws FormatException, IOException { 
    257     setId(id); 
    258     return getChannelCount(); 
    259   } 
    260  
    261   /** @deprecated Replaced by {@link #getInfo()} */ 
    262   public SDTInfo getInfo(String id) throws FormatException, IOException { 
    263     setId(id); 
    264     return getInfo(); 
    265   } 
    266  
    267246} 
  • trunk/loci/formats/in/SVSReader.java

    r3772 r3854  
    9494    } 
    9595 
    96     // repopulate core 
     96    // repopulate core metadata 
    9797 
    9898    core = new CoreMetadata(ifds.length); 
  • trunk/loci/formats/in/SlidebookReader.java

    r3848 r3854  
    106106    status("Finding offsets to pixel data"); 
    107107 
     108    // Slidebook files appear to be comprised of three types of blocks: 
     109    // variable length pixel data blocks, 512 byte metadata blocks and 
     110    // 128 byte metadata blocks. 
     111    // 
     112    // Metadata blocks begin with a 2 byte identifier, e.g. 'i' or 'h'. 
     113    // Following this are two unknown bytes (usually 256), then a 2 byte 
     114    // endianness identifier - II or MM, for little or big endian, respectively. 
     115    // Presumably these blocks contain useful information, but for the most 
     116    // part we aren't sure what it is or how to extract it. 
     117    // 
     118    // Each pixel data block corresponds to one series. 
     119    // The first 'i' metadata block after each pixel data block contains 
     120    // the width and height of the planes in that block - this can (and does) 
     121    // vary between blocks. 
     122    // 
     123    // Z, C, and T sizes are computed heuristically based on the number of 
     124    // metadata blocks of a specific type. 
     125 
    108126    in.skipBytes(4); 
    109127    core.littleEndian[0] = in.read() == 0x49; 
     
    115133 
    116134    in.seek(0); 
     135 
     136    // gather offsets to metadata and pixel data blocks 
    117137 
    118138    while (in.getFilePointer() < in.length() - 8) { 
     
    132152        int len = in.read(); 
    133153        if (len > 0 && len <= 32) { 
    134           byte[] b = new byte[len]; 
    135           in.read(b); 
    136           s = new String(b); 
     154          s = in.readString(len); 
    137155        } 
    138156 
  • trunk/loci/formats/in/TCSReader.java

    r3781 r3854  
    140140    FormatTools.checkBufferSize(this, buf.length, w, h); 
    141141 
    142     int n = 0; 
     142    int n = no; 
    143143    for (int i=0; i<series; i++) { 
    144144      n += core.imageCount[i]; 
    145145    } 
    146     n += no; 
    147146 
    148147    if (tiffReaders.length == 1) { 
  • trunk/loci/formats/in/VisitechReader.java

    r3842 r3854  
    131131      String base = id.substring(0, id.lastIndexOf(" ")); 
    132132 
    133       String suffix = " Report.html"; 
    134133      currentId = null; 
    135       initFile(base + suffix); 
     134      initFile(base + " Report.html"); 
    136135      return; 
    137136    } 
     
    268267    } 
    269268    MetadataTools.populatePixels(store, this); 
    270  
    271     // CTR CHECK 
    272 //    for (int i=0; i<numSeries; i++) { 
    273 //      for (int j=0; j<core.sizeC[i]; j++) { 
    274 //        store.setLogicalChannel(j, null, null, null, null, null, null, null, 
    275 //          null, null, null, null, null, null, null, null, null, null, null, 
    276 //          null, null, null, null, null, new Integer(i)); 
    277 //      } 
    278 //    } 
    279269  } 
    280270 
  • trunk/loci/formats/in/ZeissZVIReader.java

    r3836 r3854  
    8989  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
    9090  public boolean isThisType(byte[] block) { 
    91     // all of our samples begin with 0xd0cf11e0 
    9291    return (block[0] == 0xd0 && block[1] == 0xcf && 
    9392      block[2] == 0x11 && block[3] == 0xe0); 
     
    264263    poi = new POITools(Location.getMappedId(id)); 
    265264 
     265    // parse each embedded file 
     266 
    266267    Vector files = poi.getDocumentList(); 
    267268 
     
    287288        (s.length() > 1024)) 
    288289      { 
     290        // found a valid image stream 
    289291        try { 
    290292          s.seek(6); 
     
    419421 
    420422    if (isTiled) { 
     423      // calculate tile dimensions and number of tiles 
    421424      int totalTiles = 
    422425        offsets.size() / (core.sizeZ[0] * core.sizeC[0] * core.sizeT[0]); 
Note: See TracChangeset for help on using the changeset viewer.