Changeset 1282


Ignore:
Timestamp:
08/17/06 06:35:39 (14 years ago)
Author:
callan
Message:

Bug fixes:

  • Separated TIFF fixes to allow proper usage of getSizeT and getImage
  • UIC4TAG parsing restored
  • Fixed ordering of metadata parsing within MetaMorph reader

New functionality:

  • Added functionality to retrieve "raw" TIFF IFD entries (needed for MetaMorph reader)
Location:
trunk/loci/formats
Files:
2 added
4 edited

Legend:

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

    r1264 r1282  
    538538  public static byte[] getBytes(BufferedImage img, boolean separated, int c) { 
    539539    byte[][] p = getBytes(img); 
    540     if (separated) return p[c]; 
     540    if (separated) return p[0]; 
    541541    else { 
    542542      byte[] rtn = new byte[p.length * p[0].length]; 
  • trunk/loci/formats/TiffTools.java

    r1264 r1282  
    4242 
    4343  public static final boolean DEBUG = false; 
     44   
     45  /** The number of bytes in each IFD entry. */ 
     46  public static final int BYTES_PER_ENTRY = 12; 
    4447 
    4548  // non-IFD tags (for internal use) 
     
    288291    return getIFD(in, 0, globalOffset, offset); 
    289292  } 
     293   
     294  /** 
     295   * Retrieve a given entry from the first IFD in a stream. 
     296   *  
     297   * @param in the stream to retrieve the entry from. 
     298   * @param tag the tag of the entry to be retrieved. 
     299   * @return an object representing the entry's fields. 
     300   * @throws IOException when there is an error accessing the stream <i>in</i>. 
     301   * @throws UnknownTagException if the <i>tag</i> is not found or unknown. 
     302   */ 
     303  public static TiffIFDEntry getFirstIFDEntry (RandomAccessStream in, int tag) 
     304        throws IOException 
     305  { 
     306          // First lets re-position the file pointer by checking the TIFF header 
     307          Boolean result = checkHeader(in, 0); 
     308          if (result == null) return null; 
     309 
     310          // Get the offset of the first IFD 
     311          long offset = getFirstOffset(in); 
     312           
     313          // The following loosly resembles the logic of getIFD()... 
     314          in.seek(offset); 
     315          int numEntries = in.readShort(); 
     316          if (numEntries < 0) numEntries += 65536; 
     317           
     318          for (int i = 0; i < numEntries; i++) { 
     319              in.seek(offset  // The beginning of the IFD 
     320                          + 2     // The width of the initial numEntries field 
     321                          + (BYTES_PER_ENTRY * i)); 
     322               
     323              int entryTag = in.readShort(); 
     324              if (entryTag < 0) entryTag += 65536; 
     325               
     326              // Skip this tag unless it matches the one we want 
     327              if (entryTag != tag) continue; 
     328               
     329              // Parse the entry's "Type" 
     330              int entryType = in.readShort(); 
     331              if (entryType < 0) entryType += 65536; 
     332               
     333              // Parse the entry's "ValueCount" 
     334              int valueCount = in.readInt(); 
     335              if (valueCount < 0) 
     336                  throw new RuntimeException( 
     337                                  "Count of '" + valueCount + "' unexpected."); 
     338 
     339              // Parse the entry's "ValueOffset" 
     340              int valueOffset = in.readInt(); 
     341               
     342              return new TiffIFDEntry(entryTag, entryType, valueCount, valueOffset); 
     343          } 
     344          throw new UnknownTagException(); 
     345  } 
    290346 
    291347  /** 
  • trunk/loci/formats/in/BaseTiffReader.java

    r1264 r1282  
    122122      TiffTools.PHOTOMETRIC_INTERPRETATION); 
    123123    String photoInterp = null; 
     124    String MetaDataPhotoInterp = null; 
     125     
    124126    switch (photo) { 
    125127      case TiffTools.WHITE_IS_ZERO: 
    126         photoInterp = "WhiteIsZero"; break; 
     128        photoInterp = "WhiteIsZero";  
     129        MetaDataPhotoInterp = "Monochrome"; 
     130        break; 
    127131      case TiffTools.BLACK_IS_ZERO: 
    128         photoInterp = "BlackIsZero"; break; 
     132        photoInterp = "BlackIsZero";  
     133        MetaDataPhotoInterp = "Monochrome";       
     134        break; 
    129135      case TiffTools.RGB: 
    130         photoInterp = "RGB"; break; 
     136        photoInterp = "RGB";  
     137        MetaDataPhotoInterp = "RGB"; 
     138        break;    
    131139      case TiffTools.RGB_PALETTE: 
    132         photoInterp = "Palette"; break; 
     140        photoInterp = "Palette";  
     141        MetaDataPhotoInterp = "Monochrome"; 
     142        break; 
    133143      case TiffTools.TRANSPARENCY_MASK: 
    134         photoInterp = "Transparency Mask"; break; 
     144        photoInterp = "Transparency Mask";  
     145        MetaDataPhotoInterp = "RGB"; 
     146        break; 
    135147      case TiffTools.CMYK: 
    136         photoInterp = "CMYK"; break; 
     148        photoInterp = "CMYK";  
     149        MetaDataPhotoInterp = "CMYK"; 
     150        break; 
    137151      case TiffTools.Y_CB_CR: 
    138         photoInterp = "YCbCr"; break; 
     152        photoInterp = "YCbCr";  
     153        MetaDataPhotoInterp = "RGB"; 
     154        break; 
    139155      case TiffTools.CIE_LAB: 
    140         photoInterp = "CIELAB"; break; 
     156        photoInterp = "CIELAB"; 
     157        MetaDataPhotoInterp = "RGB"; 
     158        break; 
    141159    } 
    142160    put("PhotometricInterpretation", photoInterp); 
     161    put("MetaDataPhotometricInterpretation", MetaDataPhotoInterp); 
    143162 
    144163    putInt("CellWidth", ifd, TiffTools.CELL_WIDTH); 
     
    393412      // populate Image element 
    394413      setImage(); 
     414       
     415      // populate Logical Channel elements 
     416      for (int i=0; i < getSizeC(currentId); i++) 
     417      { 
     418          setLogicalChannel(i); 
     419      } 
    395420 
    396421      // populate Dimensions element 
     
    407432//        TiffTools.getIFDIntValue(ifd, TiffTools.SAMPLES_PER_PIXEL)); 
    408433 
    409 //      int photoInterp2 = TiffTools.getIFDIntValue(ifd, 
    410 //        TiffTools.PHOTOMETRIC_INTERPRETATION, true, 0); 
    411 //      String photo2; 
    412 //      switch (photoInterp2) { 
    413 //        case 0: photo2 = "monochrome"; break; 
    414 //        case 1: photo2 = "monochrome"; break; 
    415 //        case 2: photo2 = "RGB"; break; 
    416 //        case 3: photo2 = "monochrome"; break; 
    417 //        case 4: photo2 = "RGB"; break; 
    418 //        default: photo2 = unknown; 
    419 //      } 
    420 //      OMETools.setAttribute(ome, "ChannelInfo", 
    421 //        "PhotometricInterpretation", photo2); 
    422  
    423434      // populate StageLabel element 
    424  
    425435      Object x = TiffTools.getIFDValue(ifd, TiffTools.X_POSITION); 
    426436      Object y = TiffTools.getIFDValue(ifd, TiffTools.Y_POSITION); 
     
    666676  } 
    667677 
    668  
    669   /** 
     678  private void setChannelGlobalMinMax(int i) throws FormatException, IOException { 
     679      getMetadataStore(currentId).setChannelGlobalMinMax( 
     680              i,  
     681              null, 
     682              null, 
     683              null 
     684              ); 
     685  } 
     686   
     687  private void setLogicalChannel(int i) throws FormatException, IOException { 
     688      getMetadataStore(currentId).setLogicalChannel( 
     689              i,  
     690              getChannelName(i),  
     691              getNdFilter(i),  
     692              getEmWave(i),  
     693              getExWave(i),  
     694              getPhotometricInterpretation(i), 
     695              getMode(i), // aquisition mode 
     696              null); 
     697  } 
     698 
     699  private String getChannelName(int i)  
     700  { 
     701      return null; 
     702  } 
     703   
     704  private Float getNdFilter(int i)  
     705  { 
     706      return null; 
     707  } 
     708   
     709  Integer getEmWave(int i)  
     710  { 
     711      return null; 
     712  } 
     713 
     714  private Integer getExWave(int i)  
     715  { 
     716      return null; 
     717  } 
     718   
     719  private String getPhotometricInterpretation(int i) throws FormatException, IOException  
     720  { 
     721      return (String) getMetadataValue(currentId, "MetaDataPhotometricInterpretation"); 
     722  } 
     723   
     724  private String getMode(int i)  
     725  { 
     726      return null; 
     727  } 
     728   
     729   
     730   
     731   
     732/** 
    670733   * Retrieves the image creation date. 
    671734   * @return the image creation date. 
  • trunk/loci/formats/in/MetamorphReader.java

    r1264 r1282  
    4444  private static final int METAMORPH_ID = 33629; 
    4545  private static final int UIC2TAG = 33629; 
     46  private static final int UIC3TAG = 33630; 
    4647  private static final int UIC4TAG = 33631; 
    4748 
     
    5354  /** The TIFF's creation date */ 
    5455  private String imageCreationDate; 
     56   
     57  //** The TIFF's emWavelength */ 
     58  private long[] emWavelength; 
    5559 
    5660  // -- Constructor -- 
     
    115119  public int getSizeT(String id) throws FormatException, IOException { 
    116120    if (!id.equals(currentId)) initFile(id); 
     121    if (separated) return getImageCount(id) / (getSizeZ(id) * getSizeC(id)); 
    117122    return getImageCount(id) / getSizeZ(id); 
    118   } 
    119  
    120   /** Initializes the given Metamorph file. */ 
    121   protected void initFile(String id) throws FormatException, IOException { 
    122     super.initFile(id); 
    123  
    124     long[] uic2 = TiffTools.getIFDLongArray(ifds[0], UIC2TAG, true); 
    125     numImages = uic2.length; 
    126  
    127     // copy ifds into a new array of Hashtables that will accomodate the 
    128     // additional image planes 
    129  
    130     Hashtable[] tempIFDs = new Hashtable[ifds.length + numImages]; 
    131     System.arraycopy(ifds, 0, tempIFDs, 0, ifds.length); 
    132     int pointer = ifds.length; 
    133  
    134     long[] oldOffsets = TiffTools.getIFDLongArray(ifds[0], 
    135       TiffTools.STRIP_OFFSETS, true); 
    136  
    137     long[] stripByteCounts = TiffTools.getIFDLongArray(ifds[0], 
    138       TiffTools.STRIP_BYTE_COUNTS, true); 
    139  
    140     int stripsPerImage = oldOffsets.length; 
    141  
    142     // for each image plane, construct an IFD hashtable 
    143  
    144     Hashtable temp; 
    145     for(int i=1; i<numImages; i++) { 
    146       temp = new Hashtable(); 
    147  
    148       // copy most of the data from 1st IFD 
    149       temp.put(new Integer(TiffTools.LITTLE_ENDIAN), ifds[0].get( 
    150         new Integer(TiffTools.LITTLE_ENDIAN))); 
    151       temp.put(new Integer(TiffTools.IMAGE_WIDTH), ifds[0].get( 
    152         new Integer(TiffTools.IMAGE_WIDTH))); 
    153       temp.put(new Integer(TiffTools.IMAGE_LENGTH), 
    154         ifds[0].get(new Integer(TiffTools.IMAGE_LENGTH))); 
    155       temp.put(new Integer(TiffTools.BITS_PER_SAMPLE), ifds[0].get( 
    156         new Integer(TiffTools.BITS_PER_SAMPLE))); 
    157       temp.put(new Integer(TiffTools.COMPRESSION), ifds[0].get( 
    158         new Integer(TiffTools.COMPRESSION))); 
    159       temp.put(new Integer(TiffTools.PHOTOMETRIC_INTERPRETATION), 
    160         ifds[0].get(new Integer(TiffTools.PHOTOMETRIC_INTERPRETATION))); 
    161       temp.put(new Integer(TiffTools.STRIP_BYTE_COUNTS), ifds[0].get( 
    162         new Integer(TiffTools.STRIP_BYTE_COUNTS))); 
    163       temp.put(new Integer(TiffTools.ROWS_PER_STRIP), ifds[0].get( 
    164         new Integer(TiffTools.ROWS_PER_STRIP))); 
    165       temp.put(new Integer(TiffTools.X_RESOLUTION), ifds[0].get( 
    166         new Integer(TiffTools.X_RESOLUTION))); 
    167       temp.put(new Integer(TiffTools.Y_RESOLUTION), ifds[0].get( 
    168         new Integer(TiffTools.Y_RESOLUTION))); 
    169       temp.put(new Integer(TiffTools.RESOLUTION_UNIT), ifds[0].get( 
    170         new Integer(TiffTools.RESOLUTION_UNIT))); 
    171       temp.put(new Integer(TiffTools.PREDICTOR), ifds[0].get( 
    172         new Integer(TiffTools.PREDICTOR))); 
    173  
    174       // now we need a StripOffsets entry 
    175  
    176       long planeOffset = i*(oldOffsets[stripsPerImage - 1] + 
    177         stripByteCounts[stripsPerImage - 1] - oldOffsets[0]); 
    178  
    179       long[] newOffsets = new long[oldOffsets.length]; 
    180       newOffsets[0] = planeOffset + oldOffsets[0]; 
    181  
    182       for(int j=1; j<newOffsets.length; j++) { 
    183         newOffsets[j] = newOffsets[j-1] + stripByteCounts[0]; 
    184       } 
    185  
    186       temp.put(new Integer(TiffTools.STRIP_OFFSETS), newOffsets); 
    187       tempIFDs[pointer] = temp; 
    188       pointer++; 
    189     } 
    190     ifds = tempIFDs; 
    191  
    192     super.initMetadataStore(); 
    193123  } 
    194124 
     
    197127  /** Populates the metadata hashtable. */ 
    198128  protected void initStandardMetadata() { 
    199     try { 
    200       Hashtable ifd = ifds[0]; 
    201129      super.initStandardMetadata(); 
    202  
    203       int offset; 
    204  
    205       Integer k = new Integer(UIC4TAG); 
    206       long[] temp = (long[]) ifd.get(k); 
    207  
    208       Long[] q = new Long[temp.length]; 
    209       for (int i=0; i<q.length; i++) q[i] = new Long(temp[i]); 
    210  
    211       if (q == null) offset = -1; 
    212       Integer w = new Integer(q[1].intValue()); 
    213       if (w == null) offset = -1; 
    214       else offset =  w.intValue(); 
    215  
    216       if (offset < 0) throw new FormatException("UIC4TAG not found"); 
    217       in.seek(offset); 
    218  
    219       int currentcode = -1; 
    220       byte[] toread; 
    221  
    222       TiffRational[] temp2 = (TiffRational[]) 
    223         ifd.get(new Integer(METAMORPH_ID)); 
    224       Long[] v = new Long[temp2.length]; 
    225       for (int i=0; i<v.length; i++) v[i] = new Long(temp2[i].longValue()); 
    226       if (v == null) throw new FormatException("Metamorph ID not found"); 
    227  
    228       int planes = v[1].intValue(); 
    229  
    230       while ((currentcode < 66) && ((in.length() - in.getFilePointer()) > 2)) { 
    231         currentcode = in.readShort(); 
    232  
     130       
     131      try { 
     132        // Now that the base TIFF standard metadata has been parsed, we need to 
     133        // parse out the STK metadata from the UIC4TAG. 
     134        TiffIFDEntry uic4tagEntry = TiffTools.getFirstIFDEntry(in, UIC4TAG); 
     135        in.seek(uic4tagEntry.getValueOffset()); 
     136        int planes = uic4tagEntry.getValueCount(); 
     137 
     138        // Loop through and parse out each field of the UIC4TAG. A field whose 
     139        // code is "0" represents the end of the UIC4TAG's fields so we'll stop 
     140        // when we reach that; much like a NULL terminated C string. 
     141        int currentcode = in.readShort(); 
     142        byte[] toread; 
     143        while (currentcode != 0) { 
    233144        // variable declarations, because switch is dumb 
    234145        int num, denom; 
     
    237148        String thedate, thetime; 
    238149        switch (currentcode) { 
    239           case 0: 
    240             String autoscale = in.readInt() == 0 ? 
    241               "no auto-scaling" : "16-bit to 8-bit scaling"; 
    242             put("AutoScale", autoscale); 
    243             break; 
    244150          case 1: 
    245151            put("MinScale", in.readInt()); 
     
    457363            break; 
    458364        } // end switch 
     365        currentcode = in.readShort(); 
     366        } 
     367         
     368        // copy ifds into a new array of Hashtables that will accomodate the 
     369        // additional image planes 
     370        long[] uic2 = TiffTools.getIFDLongArray(ifds[0], UIC2TAG, true); 
     371        numImages = uic2.length; 
     372 
     373        Hashtable[] tempIFDs = new Hashtable[ifds.length + numImages]; 
     374        System.arraycopy(ifds, 0, tempIFDs, 0, ifds.length); 
     375        int pointer = ifds.length; 
     376 
     377        long[] oldOffsets = TiffTools.getIFDLongArray(ifds[0], 
     378            TiffTools.STRIP_OFFSETS, true); 
     379 
     380        long[] stripByteCounts = TiffTools.getIFDLongArray(ifds[0], 
     381            TiffTools.STRIP_BYTE_COUNTS, true); 
     382 
     383        int stripsPerImage = oldOffsets.length; 
     384 
     385        emWavelength = TiffTools.getIFDLongArray(ifds[0], UIC3TAG, true); 
     386 
     387        // for each image plane, construct an IFD hashtable 
     388 
     389        Hashtable temp; 
     390        for(int i=1; i<numImages; i++) { 
     391          temp = new Hashtable(); 
     392 
     393          // copy most of the data from 1st IFD 
     394          temp.put(new Integer(TiffTools.LITTLE_ENDIAN), ifds[0].get( 
     395              new Integer(TiffTools.LITTLE_ENDIAN))); 
     396          temp.put(new Integer(TiffTools.IMAGE_WIDTH), ifds[0].get( 
     397              new Integer(TiffTools.IMAGE_WIDTH))); 
     398          temp.put(new Integer(TiffTools.IMAGE_LENGTH), 
     399              ifds[0].get(new Integer(TiffTools.IMAGE_LENGTH))); 
     400          temp.put(new Integer(TiffTools.BITS_PER_SAMPLE), ifds[0].get( 
     401              new Integer(TiffTools.BITS_PER_SAMPLE))); 
     402          temp.put(new Integer(TiffTools.COMPRESSION), ifds[0].get( 
     403              new Integer(TiffTools.COMPRESSION))); 
     404          temp.put(new Integer(TiffTools.PHOTOMETRIC_INTERPRETATION), 
     405              ifds[0].get(new Integer(TiffTools.PHOTOMETRIC_INTERPRETATION))); 
     406          temp.put(new Integer(TiffTools.STRIP_BYTE_COUNTS), ifds[0].get( 
     407              new Integer(TiffTools.STRIP_BYTE_COUNTS))); 
     408          temp.put(new Integer(TiffTools.ROWS_PER_STRIP), ifds[0].get( 
     409              new Integer(TiffTools.ROWS_PER_STRIP))); 
     410          temp.put(new Integer(TiffTools.X_RESOLUTION), ifds[0].get( 
     411              new Integer(TiffTools.X_RESOLUTION))); 
     412          temp.put(new Integer(TiffTools.Y_RESOLUTION), ifds[0].get( 
     413              new Integer(TiffTools.Y_RESOLUTION))); 
     414          temp.put(new Integer(TiffTools.RESOLUTION_UNIT), ifds[0].get( 
     415              new Integer(TiffTools.RESOLUTION_UNIT))); 
     416          temp.put(new Integer(TiffTools.PREDICTOR), ifds[0].get( 
     417              new Integer(TiffTools.PREDICTOR))); 
     418 
     419          // now we need a StripOffsets entry 
     420 
     421          long planeOffset = i*(oldOffsets[stripsPerImage - 1] + 
     422              stripByteCounts[stripsPerImage - 1] - oldOffsets[0]); 
     423 
     424          long[] newOffsets = new long[oldOffsets.length]; 
     425          newOffsets[0] = planeOffset + oldOffsets[0]; 
     426 
     427          for(int j=1; j<newOffsets.length; j++) { 
     428            newOffsets[j] = newOffsets[j-1] + stripByteCounts[0]; 
     429          } 
     430 
     431          temp.put(new Integer(TiffTools.STRIP_OFFSETS), newOffsets); 
     432          tempIFDs[pointer] = temp; 
     433          pointer++; 
     434        } 
     435        ifds = tempIFDs; 
    459436      } 
    460     } 
    461     catch (NullPointerException n) { n.printStackTrace(); } 
    462     catch (IOException io) { io.printStackTrace(); } 
    463     catch (FormatException e) { e.printStackTrace(); } 
    464  
    465     try { super.initStandardMetadata(); } 
    466     catch (Throwable t) { t.printStackTrace(); } 
    467  
    468     // parse (mangle) TIFF comment 
    469     String descr = (String) metadata.get("Comment"); 
    470     if (descr != null) { 
    471       StringTokenizer st = new StringTokenizer(descr, "\n"); 
    472       StringBuffer sb = new StringBuffer(); 
    473       boolean first = true; 
    474       while (st.hasMoreTokens()) { 
    475         String line = st.nextToken(); 
    476         int colon = line.indexOf(": "); 
    477  
    478         if (colon < 0) { 
    479           // normal line (not a key/value pair) 
    480           if (line.trim().length() > 0) { 
    481             // not a blank line 
    482             sb.append(line); 
    483             if (!line.endsWith(".")) sb.append("."); 
    484             sb.append("  "); 
     437      catch (NullPointerException n) { n.printStackTrace(); } 
     438      catch (IOException io) { io.printStackTrace(); } 
     439      catch (FormatException e) { e.printStackTrace(); } 
     440 
     441      try { super.initStandardMetadata(); } 
     442      catch (Throwable t) { t.printStackTrace(); } 
     443 
     444      // parse (mangle) TIFF comment 
     445      String descr = (String) metadata.get("Comment"); 
     446      if (descr != null) { 
     447        StringTokenizer st = new StringTokenizer(descr, "\n"); 
     448        StringBuffer sb = new StringBuffer(); 
     449        boolean first = true; 
     450        while (st.hasMoreTokens()) { 
     451          String line = st.nextToken(); 
     452          int colon = line.indexOf(": "); 
     453 
     454          if (colon < 0) { 
     455            // normal line (not a key/value pair) 
     456            if (line.trim().length() > 0) { 
     457              // not a blank line 
     458              sb.append(line); 
     459              if (!line.endsWith(".")) sb.append("."); 
     460              sb.append("  "); 
     461            } 
     462            first = false; 
     463            continue; 
    485464          } 
    486           first = false; 
    487           continue; 
     465 
     466          if (first) { 
     467            // first line could be mangled; make a reasonable guess 
     468            int dot = line.lastIndexOf(".", colon); 
     469            if (dot >= 0) { 
     470              String s = line.substring(0, dot + 1); 
     471              sb.append(s); 
     472              if (!s.endsWith(".")) sb.append("."); 
     473              sb.append("  "); 
     474            } 
     475            line = line.substring(dot + 1); 
     476            colon -= dot + 1; 
     477            first = false; 
     478          } 
     479 
     480          // add key/value pair embedded in comment as separate metadata 
     481          String key = line.substring(0, colon); 
     482          String value = line.substring(colon + 2); 
     483          put(key, value); 
    488484        } 
    489485 
    490         if (first) { 
    491           // first line could be mangled; make a reasonable guess 
    492           int dot = line.lastIndexOf(".", colon); 
    493           if (dot >= 0) { 
    494             String s = line.substring(0, dot + 1); 
    495             sb.append(s); 
    496             if (!s.endsWith(".")) sb.append("."); 
    497             sb.append("  "); 
    498           } 
    499           line = line.substring(dot + 1); 
    500           colon -= dot + 1; 
    501           first = false; 
    502         } 
    503  
    504         // add key/value pair embedded in comment as separate metadata 
    505         String key = line.substring(0, colon); 
    506         String value = line.substring(colon + 2); 
    507         put(key, value); 
     486        // replace comment with trimmed version 
     487        descr = sb.toString().trim(); 
     488        if (descr.equals("")) metadata.remove("Comment"); 
     489        else put("Comment", descr); 
    508490      } 
    509  
    510       // replace comment with trimmed version 
    511       descr = sb.toString().trim(); 
    512       if (descr.equals("")) metadata.remove("Comment"); 
    513       else put("Comment", descr); 
    514     } 
    515   } 
    516  
     491  } 
     492 
     493  // FIXME: Needs to be implemented. 
     494  protected void initMetadataStore() { 
     495      super.initMetadataStore(); 
     496       
     497      for (int i = 0; i < ifds.length; i++) 
     498      { 
     499      } 
     500  } 
     501   
    517502  /* 
    518503   * (non-Javadoc) 
     
    534519  } 
    535520 
     521  private void setChannelGlobalMinMax(int i) throws FormatException, IOException { 
     522      Double globalMin = (Double) metadata.get("grayMin"); 
     523      Double globalMax = (Double) metadata.get("grayMax"); 
     524      if (globalMin == null | globalMax == null)  
     525      { 
     526                throw new FormatException("No global min/max"); 
     527      } 
     528      getMetadataStore(currentId).setChannelGlobalMinMax( 
     529              i,  
     530              globalMin, 
     531              globalMax, 
     532              null 
     533              ); 
     534  } 
     535   
     536  Integer getEmWave(int i)  
     537  { 
     538      if (emWavelength[i] == 0)  return null; 
     539      return new Integer((int) emWavelength[i]); 
     540  } 
     541   
    536542  // -- Utility methods -- 
    537543 
Note: See TracChangeset for help on using the changeset viewer.