Changeset 1302


Ignore:
Timestamp:
08/18/06 18:40:39 (14 years ago)
Author:
curtis
Message:

Clean up formatting and whitespace.

Location:
trunk/loci/formats/in
Files:
3 edited

Legend:

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

    r1283 r1302  
    6060    super(name, suffixes); 
    6161  } 
    62  
    6362 
    6463  // -- BaseTiffReader API methods -- 
     
    7776  } 
    7877 
     78  /** 
     79   * Obtains an object which represents a given plane within the file. 
     80   * @param id The path to the file. 
     81   * @param no The plane or section within the file to obtain. 
     82   * @return an object which represents the plane. 
     83   * @throws FormatException if there is an error parsing the file. 
     84   * @throws IOException if there is an error reading from the file or acquiring 
     85   * permissions to read the file.. 
     86   */ 
     87  public Plane2D openPlane2D(String id, int no) 
     88    throws FormatException, IOException 
     89  { 
     90    return new Plane2D( 
     91      ByteBuffer.wrap(openBytes(id, no)), 
     92      Plane2D.typeFromString(getPixelType()), 
     93      isLittleEndian(id)); 
     94  } 
    7995 
    8096  // -- Internal BaseTiffReader API methods -- 
     
    123139      TiffTools.PHOTOMETRIC_INTERPRETATION); 
    124140    String photoInterp = null; 
    125     String MetaDataPhotoInterp = null; 
    126      
     141    String metaDataPhotoInterp = null; 
     142 
    127143    switch (photo) { 
    128144      case TiffTools.WHITE_IS_ZERO: 
    129         photoInterp = "WhiteIsZero";  
    130         MetaDataPhotoInterp = "Monochrome"; 
     145        photoInterp = "WhiteIsZero"; 
     146        metaDataPhotoInterp = "Monochrome"; 
    131147        break; 
    132148      case TiffTools.BLACK_IS_ZERO: 
    133         photoInterp = "BlackIsZero";  
    134         MetaDataPhotoInterp = "Monochrome";       
     149        photoInterp = "BlackIsZero"; 
     150        metaDataPhotoInterp = "Monochrome"; 
    135151        break; 
    136152      case TiffTools.RGB: 
    137         photoInterp = "RGB";  
    138         MetaDataPhotoInterp = "RGB"; 
    139         break;    
     153        photoInterp = "RGB"; 
     154        metaDataPhotoInterp = "RGB"; 
     155        break; 
    140156      case TiffTools.RGB_PALETTE: 
    141         photoInterp = "Palette";  
    142         MetaDataPhotoInterp = "Monochrome"; 
     157        photoInterp = "Palette"; 
     158        metaDataPhotoInterp = "Monochrome"; 
    143159        break; 
    144160      case TiffTools.TRANSPARENCY_MASK: 
    145         photoInterp = "Transparency Mask";  
    146         MetaDataPhotoInterp = "RGB"; 
     161        photoInterp = "Transparency Mask"; 
     162        metaDataPhotoInterp = "RGB"; 
    147163        break; 
    148164      case TiffTools.CMYK: 
    149         photoInterp = "CMYK";  
    150         MetaDataPhotoInterp = "CMYK"; 
     165        photoInterp = "CMYK"; 
     166        metaDataPhotoInterp = "CMYK"; 
    151167        break; 
    152168      case TiffTools.Y_CB_CR: 
    153         photoInterp = "YCbCr";  
    154         MetaDataPhotoInterp = "RGB"; 
     169        photoInterp = "YCbCr"; 
     170        metaDataPhotoInterp = "RGB"; 
    155171        break; 
    156172      case TiffTools.CIE_LAB: 
    157173        photoInterp = "CIELAB"; 
    158         MetaDataPhotoInterp = "RGB"; 
     174        metaDataPhotoInterp = "RGB"; 
    159175        break; 
    160176    } 
    161177    put("PhotometricInterpretation", photoInterp); 
    162     put("MetaDataPhotometricInterpretation", MetaDataPhotoInterp); 
     178    put("MetaDataPhotometricInterpretation", metaDataPhotoInterp); 
    163179 
    164180    putInt("CellWidth", ifd, TiffTools.CELL_WIDTH); 
     
    413429      // populate Image element 
    414430      setImage(); 
    415        
     431 
    416432      // populate Logical Channel elements 
    417433      for (int i=0; i < getSizeC(currentId); i++) 
     
    458474  } 
    459475 
    460  
    461   // -- FormatReader API methods -- 
    462  
    463   /** Checks if the given block is a valid header for a TIFF file. */ 
    464   public boolean isThisType(byte[] block) { 
    465     return TiffTools.isValidHeader(block); 
    466   } 
    467  
    468   /** Determines the number of images in the given TIFF file. */ 
    469   public int getImageCount(String id) throws FormatException, IOException { 
    470     if (!id.equals(currentId)) initFile(id); 
    471     return (!isRGB(id) || !separated) ? numImages : 3 * numImages; 
    472   } 
    473  
    474   /** Checks if the images in the file are RGB. */ 
    475   public boolean isRGB(String id) throws FormatException, IOException { 
    476     if (!id.equals(currentId)) initFile(id); 
    477     return (TiffTools.getIFDIntValue(ifds[0], 
    478       TiffTools.SAMPLES_PER_PIXEL, false, 1) > 1) || 
    479       (TiffTools.getIFDIntValue(ifds[0], TiffTools.PHOTOMETRIC_INTERPRETATION, 
    480       true, 0) == TiffTools.RGB_PALETTE); 
    481   } 
    482  
    483   /** 
    484    * Obtains the specified metadata field's value for the given file. 
    485    * 
    486    * @param field the name associated with the metadata field 
    487    * @return the value, or null if the field doesn't exist 
    488    */ 
    489   public Object getMetadataValue(String id, String field) 
    490     throws FormatException, IOException 
    491   { 
    492     if (!id.equals(currentId) && !DataTools.samePrefix(id, currentId)) { 
    493       initFile(id); 
    494     } 
    495     return metadata.get(field); 
    496   } 
    497  
    498   /** Get the size of the X dimension. */ 
    499   public int getSizeX(String id) throws FormatException, IOException { 
    500     if (!id.equals(currentId)) initFile(id); 
    501     return TiffTools.getIFDIntValue(ifds[0], TiffTools.IMAGE_WIDTH, false, 0); 
    502   } 
    503  
    504   /** Get the size of the Y dimension. */ 
    505   public int getSizeY(String id) throws FormatException, IOException { 
    506     if (!id.equals(currentId)) initFile(id); 
    507     return TiffTools.getIFDIntValue(ifds[0], TiffTools.IMAGE_LENGTH, false, 0); 
    508   } 
    509  
    510   /** Get the size of the Z dimension. */ 
    511   public int getSizeZ(String id) throws FormatException, IOException { 
    512     return 1; 
    513   } 
    514  
    515   /** Get the size of the C dimension. */ 
    516   public int getSizeC(String id) throws FormatException, IOException { 
    517     if (!id.equals(currentId)) initFile(id); 
    518     return isRGB(id) ? 3 : 1; 
    519   } 
    520  
    521   /** Get the size of the T dimension. */ 
    522   public int getSizeT(String id) throws FormatException, IOException { 
    523     if (!id.equals(currentId)) initFile(id); 
    524     return ifds.length; 
    525   } 
    526  
    527   /** Return true if the data is in little-endian format. */ 
    528   public boolean isLittleEndian(String id) throws FormatException, IOException { 
    529     if (!id.equals(currentId)) initFile(id); 
    530     return TiffTools.isLittleEndian(ifds[0]); 
    531   } 
    532  
    533   /** 
    534    * Return a five-character string representing the dimension order 
    535    * within the file. 
    536    */ 
    537   public String getDimensionOrder(String id) throws FormatException, IOException 
    538   { 
    539     return "XYCZT"; 
    540   } 
    541  
    542   /** 
    543    * Obtains an object which represents a given plane within the file. 
    544    * @param id The path to the file. 
    545    * @param no The plane or section within the file to obtain. 
    546    * @return an object which represents the plane. 
    547    * @throws FormatException if there is an error parsing the file. 
    548    * @throws IOException if there is an error reading from the file or acquiring 
    549    * permissions to read the file.. 
    550    */ 
    551   public Plane2D openPlane2D(String id, int no) 
    552     throws FormatException, IOException 
    553   { 
    554     return new Plane2D( 
    555         ByteBuffer.wrap(openBytes(id, no)), 
    556         Plane2D.typeFromString(getPixelType()), 
    557         isLittleEndian(id)); 
    558   } 
    559  
    560   /** Obtains the specified image from the given TIFF file as a byte array. */ 
    561   public byte[] openBytes(String id, int no) 
    562     throws FormatException, IOException 
    563   { 
    564     return ImageTools.getBytes(openImage(id, no), isRGB(id) && separated, 
    565       no % 3); 
    566   } 
    567  
    568   /** Obtains the specified image from the given TIFF file. */ 
    569   public BufferedImage openImage(String id, int no) 
    570     throws FormatException, IOException 
    571   { 
    572     if (!id.equals(currentId) && !DataTools.samePrefix(id, currentId)) { 
    573       initFile(id); 
    574     } 
    575  
    576     if (no < 0 || no >= getImageCount(id)) { 
    577       throw new FormatException("Invalid image number: " + no); 
    578     } 
    579  
    580     if (!isRGB(id) || !separated) { 
    581       return TiffTools.getImage(ifds[no], in); 
    582     } 
    583     else { 
    584       BufferedImage[] channels = 
    585         ImageTools.splitChannels(TiffTools.getImage(ifds[no / 3], in)); 
    586       return channels[no % channels.length]; 
    587     } 
    588   } 
    589  
    590   /** Closes any open files. */ 
    591   public void close() throws FormatException, IOException { 
    592     if (in != null) in.close(); 
    593     in = null; 
    594     currentId = null; 
    595   } 
    596  
    597   /** Initializes the given TIFF file. */ 
    598   protected void initFile(String id) throws FormatException, IOException { 
    599     super.initFile(id); 
    600     in = new RandomAccessStream(id); 
    601     if (in.readShort() == 0x4949) in.order(true); 
    602  
    603     ifds = TiffTools.getIFDs(in); 
    604     if (ifds == null) throw new FormatException("No IFDs found"); 
    605     numImages = ifds.length; 
    606     initMetadata(); 
    607   } 
    608  
    609476  /** 
    610477   * If the TIFF is big-endian. 
     
    629496      case 2: pixelType = "int"; break; 
    630497      case 3: pixelType = "float"; break; 
    631       // pixelType 4 is unknown but the tiff 6.0 specification (page 80) suggests 
    632       // to treat these unknowns as Uint. 
     498      // pixelType 4 is unknown but the tiff 6.0 specification (page 80) 
     499      // suggests to treat these unknowns as Uint. 
    633500      default: pixelType = "Uint"; 
    634501    } 
     
    640507 
    641508  /** 
    642    * Performs the actual setting of the pixels attributes in the active metadata 
    643    * store by calling: 
     509   * Retrieves the image name from the TIFF. 
     510   * @return the image name. 
     511   */ 
     512  protected String getImageName() { return currentId; } 
     513 
     514  /** 
     515   * Retrieves the image creation date. 
     516   * @return the image creation date. 
     517   */ 
     518  protected String getImageCreationDate() { 
     519    return (String) TiffTools.getIFDValue(ifds[0], TiffTools.DATE_TIME); 
     520  } 
     521 
     522  /** 
     523   * Retrieves the image description. 
     524   * @return the image description. 
     525   */ 
     526  protected String getImageDescription() { 
     527    return (String) metadata.get("Comment"); 
     528  } 
     529 
     530 
     531  // -- FormatReader API methods -- 
     532 
     533  /** Checks if the given block is a valid header for a TIFF file. */ 
     534  public boolean isThisType(byte[] block) { 
     535    return TiffTools.isValidHeader(block); 
     536  } 
     537 
     538  /** Determines the number of images in the given TIFF file. */ 
     539  public int getImageCount(String id) throws FormatException, IOException { 
     540    if (!id.equals(currentId)) initFile(id); 
     541    return (!isRGB(id) || !separated) ? numImages : 3 * numImages; 
     542  } 
     543 
     544  /** Checks if the images in the file are RGB. */ 
     545  public boolean isRGB(String id) throws FormatException, IOException { 
     546    if (!id.equals(currentId)) initFile(id); 
     547    return (TiffTools.getIFDIntValue(ifds[0], 
     548      TiffTools.SAMPLES_PER_PIXEL, false, 1) > 1) || 
     549      (TiffTools.getIFDIntValue(ifds[0], TiffTools.PHOTOMETRIC_INTERPRETATION, 
     550      true, 0) == TiffTools.RGB_PALETTE); 
     551  } 
     552 
     553  /** 
     554   * Obtains the specified metadata field's value for the given file. 
     555   * 
     556   * @param field the name associated with the metadata field 
     557   * @return the value, or null if the field doesn't exist 
     558   */ 
     559  public Object getMetadataValue(String id, String field) 
     560    throws FormatException, IOException 
     561  { 
     562    if (!id.equals(currentId) && !DataTools.samePrefix(id, currentId)) { 
     563      initFile(id); 
     564    } 
     565    return metadata.get(field); 
     566  } 
     567 
     568  /** Get the size of the X dimension. */ 
     569  public int getSizeX(String id) throws FormatException, IOException { 
     570    if (!id.equals(currentId)) initFile(id); 
     571    return TiffTools.getIFDIntValue(ifds[0], TiffTools.IMAGE_WIDTH, false, 0); 
     572  } 
     573 
     574  /** Get the size of the Y dimension. */ 
     575  public int getSizeY(String id) throws FormatException, IOException { 
     576    if (!id.equals(currentId)) initFile(id); 
     577    return TiffTools.getIFDIntValue(ifds[0], TiffTools.IMAGE_LENGTH, false, 0); 
     578  } 
     579 
     580  /** Get the size of the Z dimension. */ 
     581  public int getSizeZ(String id) throws FormatException, IOException { 
     582    return 1; 
     583  } 
     584 
     585  /** Get the size of the C dimension. */ 
     586  public int getSizeC(String id) throws FormatException, IOException { 
     587    if (!id.equals(currentId)) initFile(id); 
     588    return isRGB(id) ? 3 : 1; 
     589  } 
     590 
     591  /** Get the size of the T dimension. */ 
     592  public int getSizeT(String id) throws FormatException, IOException { 
     593    if (!id.equals(currentId)) initFile(id); 
     594    return ifds.length; 
     595  } 
     596 
     597  /** Return true if the data is in little-endian format. */ 
     598  public boolean isLittleEndian(String id) throws FormatException, IOException { 
     599    if (!id.equals(currentId)) initFile(id); 
     600    return TiffTools.isLittleEndian(ifds[0]); 
     601  } 
     602 
     603  /** 
     604   * Return a five-character string representing the dimension order 
     605   * within the file. 
     606   */ 
     607  public String getDimensionOrder(String id) throws FormatException, IOException 
     608  { 
     609    return "XYCZT"; 
     610  } 
     611 
     612  /** Obtains the specified image from the given TIFF file as a byte array. */ 
     613  public byte[] openBytes(String id, int no) 
     614    throws FormatException, IOException 
     615  { 
     616    return ImageTools.getBytes(openImage(id, no), isRGB(id) && separated, 
     617      no % 3); 
     618  } 
     619 
     620  /** Obtains the specified image from the given TIFF file. */ 
     621  public BufferedImage openImage(String id, int no) 
     622    throws FormatException, IOException 
     623  { 
     624    if (!id.equals(currentId) && !DataTools.samePrefix(id, currentId)) { 
     625      initFile(id); 
     626    } 
     627 
     628    if (no < 0 || no >= getImageCount(id)) { 
     629      throw new FormatException("Invalid image number: " + no); 
     630    } 
     631 
     632    if (!isRGB(id) || !separated) { 
     633      return TiffTools.getImage(ifds[no], in); 
     634    } 
     635    else { 
     636      BufferedImage[] channels = 
     637        ImageTools.splitChannels(TiffTools.getImage(ifds[no / 3], in)); 
     638      return channels[no % channels.length]; 
     639    } 
     640  } 
     641 
     642  /** Closes any open files. */ 
     643  public void close() throws FormatException, IOException { 
     644    if (in != null) in.close(); 
     645    in = null; 
     646    currentId = null; 
     647  } 
     648 
     649  /** Initializes the given TIFF file. */ 
     650  protected void initFile(String id) throws FormatException, IOException { 
     651    super.initFile(id); 
     652    in = new RandomAccessStream(id); 
     653    if (in.readShort() == 0x4949) in.order(true); 
     654 
     655    ifds = TiffTools.getIFDs(in); 
     656    if (ifds == null) throw new FormatException("No IFDs found"); 
     657    numImages = ifds.length; 
     658    initMetadata(); 
     659  } 
     660 
     661  // -- Helper methods -- 
     662 
     663  /** 
     664   * Performs the actual setting of the pixels attributes in the active 
     665   * metadata store by calling: 
    644666   * 
    645667   * <ul> 
     
    683705   */ 
    684706  private void setImage() throws FormatException, IOException { 
    685     getMetadataStore(currentId).setImage(getImageName(), getImageCreationDate(), 
    686                                 getImageDescription(), null); 
    687   } 
    688  
    689   /** 
    690    * Retrieves the image name from the TIFF. 
    691    * @return the image name. 
    692    */ 
    693   protected String getImageName() { 
    694     return currentId; 
    695   } 
    696  
    697   private void setChannelGlobalMinMax(int i) throws FormatException, IOException { 
    698       getMetadataStore(currentId).setChannelGlobalMinMax( 
    699               i,  
    700               null, 
    701               null, 
    702               null 
    703               ); 
    704   } 
    705    
     707    getMetadataStore(currentId).setImage(getImageName(), 
     708        getImageCreationDate(), getImageDescription(), null); 
     709  } 
     710 
     711  private void setChannelGlobalMinMax(int i) 
     712    throws FormatException, IOException 
     713  { 
     714    getMetadataStore(currentId).setChannelGlobalMinMax(i, null, null, null); 
     715  } 
     716 
    706717  private void setLogicalChannel(int i) throws FormatException, IOException { 
    707       getMetadataStore(currentId).setLogicalChannel( 
    708               i,  
    709               getChannelName(i),  
    710               getNdFilter(i),  
    711               getEmWave(i),  
    712               getExWave(i),  
    713               getPhotometricInterpretation(i), 
    714               getMode(i), // aquisition mode 
    715               null); 
    716   } 
    717  
    718   private String getChannelName(int i)  
     718    getMetadataStore(currentId).setLogicalChannel(i, getChannelName(i), 
     719      getNdFilter(i), getEmWave(i), getExWave(i), 
     720      getPhotometricInterpretation(i), getMode(i), null); 
     721  } 
     722 
     723  private String getChannelName(int i) { return null; } 
     724 
     725  private Float getNdFilter(int i) { return null; } 
     726 
     727  Integer getEmWave(int i) { return null; } 
     728 
     729  private Integer getExWave(int i) { return null; } 
     730 
     731  private String getPhotometricInterpretation(int i) 
     732    throws FormatException, IOException 
    719733  { 
    720       return null; 
    721   } 
    722    
    723   private Float getNdFilter(int i)  
    724   { 
    725       return null; 
    726   } 
    727    
    728   Integer getEmWave(int i)  
    729   { 
    730       return null; 
    731   } 
    732  
    733   private Integer getExWave(int i)  
    734   { 
    735       return null; 
    736   } 
    737    
    738   private String getPhotometricInterpretation(int i) throws FormatException, IOException  
    739   { 
    740       return (String) getMetadataValue(currentId, "MetaDataPhotometricInterpretation"); 
    741   } 
    742    
    743   private String getMode(int i)  
    744   { 
    745       return null; 
    746   } 
    747    
    748    
    749    
    750    
    751 /** 
    752    * Retrieves the image creation date. 
    753    * @return the image creation date. 
    754    */ 
    755   protected String getImageCreationDate() { 
    756     return (String) TiffTools.getIFDValue(ifds[0], TiffTools.DATE_TIME); 
    757   } 
    758  
    759   /** 
    760    * Retrieves the image description. 
    761    * @return the image description. 
    762    */ 
    763   protected String getImageDescription() { 
    764     return (String) metadata.get("Comment"); 
    765   } 
    766  
    767   // -- Helper methods -- 
     734    return (String) getMetadataValue(currentId, 
     735      "MetaDataPhotometricInterpretation"); 
     736  } 
     737 
     738  private String getMode(int i) { return null; } 
    768739 
    769740  protected void put(String key, Object value) { 
  • trunk/loci/formats/in/MetamorphReader.java

    r1283 r1302  
    5454  /** The TIFF's creation date */ 
    5555  private String imageCreationDate; 
    56    
     56 
    5757  //** The TIFF's emWavelength */ 
    5858  private long[] emWavelength; 
     
    124124 
    125125  // -- Internal BaseTiffReader API methods -- 
    126    
     126 
    127127  /** Populates the metadata hashtable. */ 
    128128  protected void initStandardMetadata() { 
    129       super.initStandardMetadata(); 
    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) { 
    144         // variable declarations, because switch is dumb 
    145         int num, denom; 
    146         int xnum, xdenom, ynum, ydenom; 
    147         double xpos, ypos; 
    148         String thedate, thetime; 
    149         switch (currentcode) { 
    150           case 1: 
    151             put("MinScale", in.readInt()); 
    152             break; 
    153           case 2: 
    154             put("MaxScale", in.readInt()); 
    155             break; 
    156           case 3: 
    157             int calib = in.readInt(); 
    158             String calibration = calib == 0 ? "on" : "off"; 
    159             put("Spatial Calibration", calibration); 
    160             break; 
    161           case 4: 
    162             num = in.readInt(); 
    163             denom = in.readInt(); 
    164             put("XCalibration", new TiffRational(num, denom)); 
    165             break; 
    166           case 5: 
    167             num = in.readInt(); 
    168             denom = in.readInt(); 
    169             put("YCalibration", new TiffRational(num, denom)); 
    170             break; 
    171           case 6: 
    172             num = in.readInt(); 
    173             toread = new byte[num]; 
    174             in.read(toread); 
    175             put("CalibrationUnits", new String(toread)); 
    176             break; 
    177           case 7: 
    178             num = in.readInt(); 
    179             toread = new byte[num]; 
    180             in.read(toread); 
    181             String name = new String(toread); 
    182             put("Name", name); 
    183             imageName = name; 
    184             break; 
    185           case 8: 
    186             int thresh = in.readInt(); 
    187             String threshState = "off"; 
    188             if (thresh == 1) threshState = "inside"; 
    189             else if (thresh == 2) threshState = "outside"; 
    190             put("ThreshState", threshState); 
    191             break; 
    192           case 9: 
    193             put("ThreshStateRed", in.readInt()); 
    194             break; 
    195           // there is no 10 
    196           case 11: 
    197             put("ThreshStateGreen", in.readInt()); 
    198             break; 
    199           case 12: 
    200             put("ThreshStateBlue", in.readInt()); 
    201             break; 
    202           case 13: 
    203             put("ThreshStateLo", in.readInt()); 
    204             break; 
    205           case 14: 
    206             put("ThreshStateHi", in.readInt()); 
    207             break; 
    208           case 15: 
    209             int zoom = in.readInt(); 
    210             put("Zoom", zoom); 
     129    super.initStandardMetadata(); 
     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) { 
     144      // variable declarations, because switch is dumb 
     145      int num, denom; 
     146      int xnum, xdenom, ynum, ydenom; 
     147      double xpos, ypos; 
     148      String thedate, thetime; 
     149      switch (currentcode) { 
     150        case 1: 
     151          put("MinScale", in.readInt()); 
     152          break; 
     153        case 2: 
     154          put("MaxScale", in.readInt()); 
     155          break; 
     156        case 3: 
     157          int calib = in.readInt(); 
     158          String calibration = calib == 0 ? "on" : "off"; 
     159          put("Spatial Calibration", calibration); 
     160          break; 
     161        case 4: 
     162          num = in.readInt(); 
     163          denom = in.readInt(); 
     164          put("XCalibration", new TiffRational(num, denom)); 
     165          break; 
     166        case 5: 
     167          num = in.readInt(); 
     168          denom = in.readInt(); 
     169          put("YCalibration", new TiffRational(num, denom)); 
     170          break; 
     171        case 6: 
     172          num = in.readInt(); 
     173          toread = new byte[num]; 
     174          in.read(toread); 
     175          put("CalibrationUnits", new String(toread)); 
     176          break; 
     177        case 7: 
     178          num = in.readInt(); 
     179          toread = new byte[num]; 
     180          in.read(toread); 
     181          String name = new String(toread); 
     182          put("Name", name); 
     183          imageName = name; 
     184          break; 
     185        case 8: 
     186          int thresh = in.readInt(); 
     187          String threshState = "off"; 
     188          if (thresh == 1) threshState = "inside"; 
     189          else if (thresh == 2) threshState = "outside"; 
     190          put("ThreshState", threshState); 
     191          break; 
     192        case 9: 
     193          put("ThreshStateRed", in.readInt()); 
     194          break; 
     195        // there is no 10 
     196        case 11: 
     197          put("ThreshStateGreen", in.readInt()); 
     198          break; 
     199        case 12: 
     200          put("ThreshStateBlue", in.readInt()); 
     201          break; 
     202        case 13: 
     203          put("ThreshStateLo", in.readInt()); 
     204          break; 
     205        case 14: 
     206          put("ThreshStateHi", in.readInt()); 
     207          break; 
     208        case 15: 
     209          int zoom = in.readInt(); 
     210          put("Zoom", zoom); 
    211211//            OMETools.setAttribute(ome, "DisplayOptions", "Zoom", "" + zoom); 
    212             break; 
    213           case 16: // oh how we hate you Julian format... 
    214             thedate = decodeDate(in.readInt()); 
    215             thetime = decodeTime(in.readInt()); 
    216             put("DateTime", thedate + " " + thetime); 
    217             imageCreationDate = thedate + " " + thetime; 
    218             break; 
    219           case 17: 
    220             thedate = decodeDate(in.readInt()); 
    221             thetime = decodeTime(in.readInt()); 
    222             put("LastSavedTime", thedate + " " + thetime); 
    223             break; 
    224           case 18: 
    225             put("currentBuffer", in.readInt()); 
    226             break; 
    227           case 19: 
    228             put("grayFit", in.readInt()); 
    229             break; 
    230           case 20: 
    231             put("grayPointCount", in.readInt()); 
    232             break; 
    233           case 21: 
    234             num = in.readInt(); 
    235             denom = in.readInt(); 
    236             put("grayX", new TiffRational(num, denom)); 
    237             break; 
    238           case 22: 
    239             num = in.readInt(); 
    240             denom = in.readInt(); 
    241             put("gray", new TiffRational(num, denom)); 
    242             break; 
    243           case 23: 
    244             num = in.readInt(); 
    245             denom = in.readInt(); 
    246             put("grayMin", new TiffRational(num, denom)); 
    247             break; 
    248           case 24: 
    249             num = in.readInt(); 
    250             denom = in.readInt(); 
    251             put("grayMax", new TiffRational(num, denom)); 
    252             break; 
    253           case 25: 
    254             num = in.readInt(); 
    255             toread = new byte[num]; 
    256             in.read(toread); 
    257             put("grayUnitName", new String(toread)); 
    258             break; 
    259           case 26: 
    260             int standardLUT = in.readInt(); 
    261             String standLUT; 
    262             switch (standardLUT) { 
    263               case 0: standLUT = "monochrome"; break; 
    264               case 1: standLUT = "pseudocolor"; break; 
    265               case 2: standLUT = "Red"; break; 
    266               case 3: standLUT = "Green"; break; 
    267               case 4: standLUT = "Blue"; break; 
    268               case 5: standLUT = "user-defined"; break; 
    269               default: standLUT = "monochrome"; break; 
    270             } 
    271             put("StandardLUT", standLUT); 
    272             break; 
    273           case 27: 
    274             put("Wavelength", in.readInt()); 
    275             break; 
    276           case 28: 
    277             for (int i = 0; i < planes; i++) { 
    278                 xnum = in.readInt(); 
    279                 xdenom = in.readInt(); 
    280                 ynum = in.readInt(); 
    281                 ydenom = in.readInt(); 
    282                 xpos = xnum / xdenom; 
    283                 ypos = ynum / ydenom; 
    284                 put("Stage Position Plane " + i, 
    285                   "(" + xpos + ", " + ypos + ")"); 
    286             } 
    287             break; 
    288           case 29: 
    289             for (int i = 0; i < planes; i++) { 
     212          break; 
     213        case 16: // oh how we hate you Julian format... 
     214          thedate = decodeDate(in.readInt()); 
     215          thetime = decodeTime(in.readInt()); 
     216          put("DateTime", thedate + " " + thetime); 
     217          imageCreationDate = thedate + " " + thetime; 
     218          break; 
     219        case 17: 
     220          thedate = decodeDate(in.readInt()); 
     221          thetime = decodeTime(in.readInt()); 
     222          put("LastSavedTime", thedate + " " + thetime); 
     223          break; 
     224        case 18: 
     225          put("currentBuffer", in.readInt()); 
     226          break; 
     227        case 19: 
     228          put("grayFit", in.readInt()); 
     229          break; 
     230        case 20: 
     231          put("grayPointCount", in.readInt()); 
     232          break; 
     233        case 21: 
     234          num = in.readInt(); 
     235          denom = in.readInt(); 
     236          put("grayX", new TiffRational(num, denom)); 
     237          break; 
     238        case 22: 
     239          num = in.readInt(); 
     240          denom = in.readInt(); 
     241          put("gray", new TiffRational(num, denom)); 
     242          break; 
     243        case 23: 
     244          num = in.readInt(); 
     245          denom = in.readInt(); 
     246          put("grayMin", new TiffRational(num, denom)); 
     247          break; 
     248        case 24: 
     249          num = in.readInt(); 
     250          denom = in.readInt(); 
     251          put("grayMax", new TiffRational(num, denom)); 
     252          break; 
     253        case 25: 
     254          num = in.readInt(); 
     255          toread = new byte[num]; 
     256          in.read(toread); 
     257          put("grayUnitName", new String(toread)); 
     258          break; 
     259        case 26: 
     260          int standardLUT = in.readInt(); 
     261          String standLUT; 
     262          switch (standardLUT) { 
     263            case 0: standLUT = "monochrome"; break; 
     264            case 1: standLUT = "pseudocolor"; break; 
     265            case 2: standLUT = "Red"; break; 
     266            case 3: standLUT = "Green"; break; 
     267            case 4: standLUT = "Blue"; break; 
     268            case 5: standLUT = "user-defined"; break; 
     269            default: standLUT = "monochrome"; break; 
     270          } 
     271          put("StandardLUT", standLUT); 
     272          break; 
     273        case 27: 
     274          put("Wavelength", in.readInt()); 
     275          break; 
     276        case 28: 
     277          for (int i = 0; i < planes; i++) { 
    290278              xnum = in.readInt(); 
    291279              xdenom = in.readInt(); 
     
    294282              xpos = xnum / xdenom; 
    295283              ypos = ynum / ydenom; 
    296               put("Camera Offset Plane " + i, 
     284              put("Stage Position Plane " + i, 
    297285                "(" + xpos + ", " + ypos + ")"); 
    298             } 
    299             break; 
    300           case 30: 
    301             put("OverlayMask", in.readInt()); 
    302             break; 
    303           case 31: 
    304             put("OverlayCompress", in.readInt()); 
    305             break; 
    306           case 32: 
    307             put("Overlay", in.readInt()); 
    308             break; 
    309           case 33: 
    310             put("SpecialOverlayMask", in.readInt()); 
    311             break; 
    312           case 34: 
    313             put("SpecialOverlayCompress", in.readInt()); 
    314             break; 
    315           case 35: 
    316             put("SpecialOverlay", in.readInt()); 
    317             break; 
    318           case 36: 
    319             put("ImageProperty", in.readInt()); 
    320             break; 
    321           case 37: 
    322             for (int i = 0; i<planes; i++) { 
    323               num = in.readInt(); 
    324               toread = new byte[num]; 
    325               in.read(toread); 
    326               String s = new String(toread); 
    327               put("StageLabel Plane " + i, s); 
    328             } 
    329             break; 
    330           case 38: 
     286          } 
     287          break; 
     288        case 29: 
     289          for (int i = 0; i < planes; i++) { 
     290            xnum = in.readInt(); 
     291            xdenom = in.readInt(); 
     292            ynum = in.readInt(); 
     293            ydenom = in.readInt(); 
     294            xpos = xnum / xdenom; 
     295            ypos = ynum / ydenom; 
     296            put("Camera Offset Plane " + i, 
     297              "(" + xpos + ", " + ypos + ")"); 
     298          } 
     299          break; 
     300        case 30: 
     301          put("OverlayMask", in.readInt()); 
     302          break; 
     303        case 31: 
     304          put("OverlayCompress", in.readInt()); 
     305          break; 
     306        case 32: 
     307          put("Overlay", in.readInt()); 
     308          break; 
     309        case 33: 
     310          put("SpecialOverlayMask", in.readInt()); 
     311          break; 
     312        case 34: 
     313          put("SpecialOverlayCompress", in.readInt()); 
     314          break; 
     315        case 35: 
     316          put("SpecialOverlay", in.readInt()); 
     317          break; 
     318        case 36: 
     319          put("ImageProperty", in.readInt()); 
     320          break; 
     321        case 37: 
     322          for (int i = 0; i<planes; i++) { 
     323            num = in.readInt(); 
     324            toread = new byte[num]; 
     325            in.read(toread); 
     326            String s = new String(toread); 
     327            put("StageLabel Plane " + i, s); 
     328          } 
     329          break; 
     330        case 38: 
     331          num = in.readInt(); 
     332          denom = in.readInt(); 
     333          put("AutoScaleLoInfo", new TiffRational(num, denom)); 
     334          break; 
     335        case 39: 
     336          num = in.readInt(); 
     337          denom = in.readInt(); 
     338          put("AutoScaleHiInfo", new TiffRational(num, denom)); 
     339          break; 
     340        case 40: 
     341          for (int i=0;i<planes;i++) { 
    331342            num = in.readInt(); 
    332343            denom = in.readInt(); 
    333             put("AutoScaleLoInfo", new TiffRational(num, denom)); 
    334             break; 
    335           case 39: 
    336             num = in.readInt(); 
    337             denom = in.readInt(); 
    338             put("AutoScaleHiInfo", new TiffRational(num, denom)); 
    339             break; 
    340           case 40: 
    341             for (int i=0;i<planes;i++) { 
    342               num = in.readInt(); 
    343               denom = in.readInt(); 
    344               put("AbsoluteZ Plane " + i, new TiffRational(num, denom)); 
    345             } 
    346             break; 
    347           case 41: 
    348             for (int i=0; i<planes; i++) { 
    349               put("AbsoluteZValid Plane " + i, in.readInt()); 
    350             } 
    351             break; 
    352           case 42: 
    353             put("Gamma", in.readInt()); 
    354             break; 
    355           case 43: 
    356             put("GammaRed", in.readInt()); 
    357             break; 
    358           case 44: 
    359             put("GammaGreen", in.readInt()); 
    360             break; 
    361           case 45: 
    362             put("GammaBlue", in.readInt()); 
    363             break; 
    364         } // end switch 
    365         currentcode = in.readShort(); 
     344            put("AbsoluteZ Plane " + i, new TiffRational(num, denom)); 
     345          } 
     346          break; 
     347        case 41: 
     348          for (int i=0; i<planes; i++) { 
     349            put("AbsoluteZValid Plane " + i, in.readInt()); 
     350          } 
     351          break; 
     352        case 42: 
     353          put("Gamma", in.readInt()); 
     354          break; 
     355        case 43: 
     356          put("GammaRed", in.readInt()); 
     357          break; 
     358        case 44: 
     359          put("GammaGreen", in.readInt()); 
     360          break; 
     361        case 45: 
     362          put("GammaBlue", in.readInt()); 
     363          break; 
     364      } // 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]; 
    366429        } 
    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++; 
     430 
     431        temp.put(new Integer(TiffTools.STRIP_OFFSETS), newOffsets); 
     432        tempIFDs[pointer] = temp; 
     433        pointer++; 
     434      } 
     435      ifds = tempIFDs; 
     436    } 
     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; 
    434464        } 
    435         ifds = tempIFDs; 
     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); 
    436484      } 
    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; 
    464           } 
    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); 
    484         } 
    485  
    486         // replace comment with trimmed version 
    487         descr = sb.toString().trim(); 
    488         if (descr.equals("")) metadata.remove("Comment"); 
    489         else put("Comment", descr); 
    490       } 
     485 
     486      // replace comment with trimmed version 
     487      descr = sb.toString().trim(); 
     488      if (descr.equals("")) metadata.remove("Comment"); 
     489      else put("Comment", descr); 
     490    } 
    491491  } 
    492492 
    493493  // FIXME: Needs to be implemented. 
    494494  protected void initMetadataStore() { 
    495       super.initMetadataStore(); 
    496        
    497       for (int i = 0; i < ifds.length; i++) 
    498       { 
    499       } 
    500   } 
    501    
     495    super.initMetadataStore(); 
     496    for (int i = 0; i < ifds.length; i++) { } 
     497  } 
     498 
    502499  /* 
    503500   * (non-Javadoc) 
    504501   * @see loci.formats.BaseTiffReader#getImageName() 
    505502   */ 
    506   protected String getImageName() {  
     503  protected String getImageName() { 
    507504    if (imageName == null) return super.getImageName(); 
    508505    return imageName; 
     
    513510   * @see loci.formats.BaseTiffReader#getImageCreationDate() 
    514511   */ 
    515   protected String getImageCreationDate()  
     512  protected String getImageCreationDate() { 
     513    if (imageCreationDate == null) return super.getImageCreationDate(); 
     514    return imageCreationDate; 
     515  } 
     516 
     517  private void setChannelGlobalMinMax(int i) 
     518    throws FormatException, IOException 
    516519  { 
    517     if (imageCreationDate == null) return super.getImageCreationDate(); 
    518     return imageCreationDate;  
    519   } 
    520  
    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    
     520    Double globalMin = (Double) metadata.get("grayMin"); 
     521    Double globalMax = (Double) metadata.get("grayMax"); 
     522    if (globalMin == null | globalMax == null) { 
     523      throw new FormatException("No global min/max"); 
     524    } 
     525    getMetadataStore(currentId).setChannelGlobalMinMax(i, 
     526      globalMin, globalMax, null); 
     527  } 
     528 
     529  Integer getEmWave(int i) { 
     530    if (emWavelength[i] == 0)  return null; 
     531    return new Integer((int) emWavelength[i]); 
     532  } 
     533 
    542534  // -- Utility methods -- 
    543535 
  • trunk/loci/formats/in/Plane2D.java

    r1283 r1302  
    3434 */ 
    3535public class Plane2D 
    36 {   
     36{ 
    3737  /** Contains the plane data. */ 
    3838  private ByteBuffer    data; 
     
    5555  /** Identifies the <i>UINT16</i> data type used to store pixel values. */ 
    5656  public static final int     UINT16 = 3; 
    57    
     57 
    5858  /** Identifies the <i>INT32</i> data type used to store pixel values. */ 
    5959  public static final int     INT32 = 4; 
     
    8484  /** 
    8585   * Default constructor. 
    86    *  
     86   * 
    8787   * @param data the raw pixels. 
    8888   * @param type the type of the pixel data from the constants in this class. 
     
    125125  /** 
    126126   * Returns the pixel intensity value of the pixel at <code>(x, y)</code>. 
    127    *  
     127   * 
    128128   * @param x The X coordinate. 
    129129   * @param y The Y coordinate. 
    130130   * @return The intensity value. 
    131131   */ 
    132   public double getPixelValue(int x, int y)  
     132  public double getPixelValue(int x, int y) 
    133133  { 
    134134    int offset = x * y * bytesPerPixel; 
     
    155155    throw new RuntimeException("Woah nelly! Something is very wrong."); 
    156156  } 
    157    
     157 
    158158  /** 
    159159   * Takes a string value and maps it to one of the pixel type enumerations. 
Note: See TracChangeset for help on using the changeset viewer.