Changeset 2604


Ignore:
Timestamp:
04/12/07 11:55:31 (13 years ago)
Author:
curtis
Message:

Style fixes.

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

Legend:

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

    r2603 r2604  
    546546        try { 
    547547          SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss"); 
    548           SimpleDateFormat parse =  
     548          SimpleDateFormat parse = 
    549549            new SimpleDateFormat("dd/MM/yyyy HH:mm:ss.SS"); 
    550550          Date date = parse.parse(creationDate, new ParsePosition(0)); 
     
    554554          if (debug) ex.printStackTrace(); 
    555555          creationDate = null; 
    556         }  
     556        } 
    557557      } 
    558558 
  • trunk/loci/formats/in/MetamorphReader.java

    r2603 r2604  
    2626 
    2727import java.io.IOException; 
     28import java.text.DecimalFormat; 
    2829import java.util.Hashtable; 
    2930import java.util.StringTokenizer; 
    30 import java.text.DecimalFormat; 
    3131import loci.formats.DataTools; 
    3232import loci.formats.FormatException; 
     
    4141 * @author Melissa Linkert linkert at wisc.edu 
    4242 * @author Curtis Rueden ctrueden at wisc.edu 
    43  * @author Sebastien Huart Sebastien dot Huart at curie.fr  
     43 * @author Sebastien Huart Sebastien dot Huart at curie.fr 
    4444 */ 
    4545public class MetamorphReader extends BaseTiffReader { 
     
    7373  // -- FormatReader API methods -- 
    7474 
    75   /* @see loci.formats.IFormatReader#isThisType(byte[]) */  
     75  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
    7676  public boolean isThisType(byte[] block) { 
    7777    // If the file is a Metamorph STK file, it should have a specific IFD tag. 
     
    110110  // -- Internal BaseTiffReader API methods -- 
    111111 
    112   /* @see BaseTiffReader#initStandardMetadata() */  
     112  /* @see BaseTiffReader#initStandardMetadata() */ 
    113113  protected void initStandardMetadata() throws FormatException, IOException { 
    114114    super.initStandardMetadata(); 
     
    117117      // Now that the base TIFF standard metadata has been parsed, we need to 
    118118      // parse out the STK metadata from the UIC4TAG. 
    119         TiffIFDEntry uic1tagEntry= TiffTools.getFirstIFDEntry(in, UIC1TAG); 
    120         TiffIFDEntry uic2tagEntry=TiffTools.getFirstIFDEntry(in, UIC2TAG); 
    121         TiffIFDEntry uic3tagEntry=TiffTools.getFirstIFDEntry(in, UIC3TAG); 
    122         TiffIFDEntry uic4tagEntry = TiffTools.getFirstIFDEntry(in, UIC4TAG); 
    123         int planes = uic4tagEntry.getValueCount(); 
     119      TiffIFDEntry uic1tagEntry= TiffTools.getFirstIFDEntry(in, UIC1TAG); 
     120      TiffIFDEntry uic2tagEntry=TiffTools.getFirstIFDEntry(in, UIC2TAG); 
     121      TiffIFDEntry uic3tagEntry=TiffTools.getFirstIFDEntry(in, UIC3TAG); 
     122      TiffIFDEntry uic4tagEntry = TiffTools.getFirstIFDEntry(in, UIC4TAG); 
     123      int planes = uic4tagEntry.getValueCount(); 
    124124      mmPlanes = planes; 
    125         parseUIC2Tags(uic2tagEntry.getValueOffset()); 
    126         parseUIC4Tags(uic4tagEntry.getValueOffset()); 
    127         parseUIC1Tags(uic1tagEntry.getValueOffset(), 
     125      parseUIC2Tags(uic2tagEntry.getValueOffset()); 
     126      parseUIC4Tags(uic4tagEntry.getValueOffset()); 
     127      parseUIC1Tags(uic1tagEntry.getValueOffset(), 
    128128        uic1tagEntry.getValueCount()); 
    129129      in.seek(uic4tagEntry.getValueOffset()); 
    130        
    131       // copy ifds into a new array of Hashtables that will accomodate the 
     130 
     131      // copy ifds into a new array of Hashtables that will accommodate the 
    132132      // additional image planes 
    133133      long[] uic2 = TiffTools.getIFDLongArray(ifds[0], UIC2TAG, true); 
     
    137137      for (int i=0; i<uic3.length; i++) { 
    138138        in.seek(uic3[i]); 
    139         put("Wavelength [" + intFormatMax(i,mmPlanes) + "]",  
     139        put("Wavelength [" + intFormatMax(i, mmPlanes) + "]", 
    140140          in.readLong() / in.readLong()); 
    141141      } 
     
    220220      super.initStandardMetadata(); 
    221221    } 
    222     catch (Exception t) { 
    223       // CTR TODO - eliminate catch-all exception handling 
    224       if (debug) t.printStackTrace(); 
     222    catch (FormatException exc) { 
     223      if (debug) exc.printStackTrace(); 
     224    } 
     225    catch (IOException exc) { 
     226      if (debug) exc.printStackTrace(); 
    225227    } 
    226228 
     
    276278      core.sizeT[0] = getImageCount() / core.sizeZ[0]; 
    277279    } 
    278     catch (Exception e) { 
    279       // CTR TODO - eliminate catch-all exception handling 
    280       if (debug) e.printStackTrace(); 
     280    catch (FormatException exc) { 
     281      if (debug) exc.printStackTrace(); 
    281282    } 
    282283  } 
     
    300301 
    301302  // -- Utility methods -- 
    302                  
    303   /** Populates metadata fields with some contained in MetaMorph UIC2 Tag  
    304    * (for each plane:6 integers: 
    305    * zdistance numerator, zdistance denominator,  
     303 
     304  /** 
     305   * Populates metadata fields with some contained in MetaMorph UIC2 Tag. 
     306   * (for each plane: 6 integers: 
     307   * zdistance numerator, zdistance denominator, 
    306308   * creation date, creation time, modif date, modif time) 
    307    * @param long uic2offset: offset to UIC2 (33629) tag entries  
    308    *  
     309   * @param uic2offset offset to UIC2 (33629) tag entries 
     310   * 
    309311   * not a regular tiff tag (6*N entries, N being the tagCount) 
    310    * @throws IOException  
     312   * @throws IOException 
    311313   */ 
    312         void parseUIC2Tags(long uic2offset) throws IOException { 
    313  
    314                 int saveLoc = in.getFilePointer(); 
    315                 in.seek(uic2offset); 
    316  
    317                 /*number of days since the 1st of January 4713 B.C*/ 
    318                 int cDate; 
    319                 /*milliseconds since 0:00*/ 
    320                 int cTime; 
    321  
    322                 /*z step, distance separating previous slice from  current one*/ 
    323                 double zDistance; 
    324                 String iAsString; 
    325  
    326                 for (int i=0; i<mmPlanes; i++) { 
    327                         iAsString = intFormatMax(i, mmPlanes); 
    328                         int num = in.readInt(); 
    329                         int den = in.readInt(); 
    330                         zDistance = (double) num / den; 
    331                         put("zDistance[" + iAsString + "]", zDistance); 
    332                         cDate = in.readInt(); 
    333                         put("creationDate[" + iAsString + "]", decodeDate(cDate)); 
    334  
    335                         cTime = in.readInt(); 
    336                         put("creationTime[" + iAsString + "]", decodeTime(cTime)); 
    337                         /* modification date and time are skipped  
    338                                 as they all seem equal to 0...??? 
    339                          */ 
    340                         in.skip(8);  
    341                 } 
    342                 in.seek(saveLoc); 
    343         } 
    344  
    345         /** UIC4 metadata parser 
    346          *  
    347          * UIC4 Table contains per-plane blocks of metadata 
    348          * stage X/Y positions, 
    349          * camera chip offsets, 
    350          * stage labels... 
    351          * @param long uic4offset: offset of UIC4 table (not tiff-compliant) 
    352          * @throws IOException 
    353          *  
    354          */ 
    355         private void parseUIC4Tags(long uic4offset) throws IOException { 
    356                 long saveLoc = in.getFilePointer(); 
    357                 in.seek(uic4offset); 
    358                 boolean end=false; 
    359                 short id; 
    360                 while (!end) { 
    361                         id = in.readShort(); 
    362  
    363                         switch (id) { 
    364                         case 0: 
    365                                 end=true; 
    366                                 break; 
    367                         case 28: 
    368                                 readStagePositions(); 
    369                                 break; 
    370                         case 29: 
    371                                 readCameraChipOffsets(); 
    372                                 break; 
    373                         case 37: 
    374                                 readStageLabels(); 
    375                                 break; 
    376                         case 40: 
    377                                 readAbsoluteZ(); 
    378                                 break; 
    379                         case 41: 
    380                                 readAbsoluteZValid(); 
    381                                 break; 
    382                         default: 
    383                                 //unknown tags: do nothing 
    384                                 break; 
    385  
    386                         //28->stagePositions 
    387                         //29->cameraChipOffsets 
    388                         //30->stageLabel 
    389                         //40->AbsoluteZ 
    390                         //41AbsoluteZValid 
    391                         //0->end 
    392                         } 
    393  
    394                 } 
    395                 in.seek(saveLoc); 
    396         } 
    397          
     314  void parseUIC2Tags(long uic2offset) throws IOException { 
     315 
     316    int saveLoc = in.getFilePointer(); 
     317    in.seek(uic2offset); 
     318 
     319    /*number of days since the 1st of January 4713 B.C*/ 
     320    int cDate; 
     321    /*milliseconds since 0:00*/ 
     322    int cTime; 
     323 
     324    /*z step, distance separating previous slice from  current one*/ 
     325    double zDistance; 
     326    String iAsString; 
     327 
     328    for (int i=0; i<mmPlanes; i++) { 
     329      iAsString = intFormatMax(i, mmPlanes); 
     330      int num = in.readInt(); 
     331      int den = in.readInt(); 
     332      zDistance = (double) num / den; 
     333      put("zDistance[" + iAsString + "]", zDistance); 
     334      cDate = in.readInt(); 
     335      put("creationDate[" + iAsString + "]", decodeDate(cDate)); 
     336 
     337      cTime = in.readInt(); 
     338      put("creationTime[" + iAsString + "]", decodeTime(cTime)); 
     339      // modification date and time are skipped as they all seem equal to 0...? 
     340      in.skip(8); 
     341    } 
     342    in.seek(saveLoc); 
     343  } 
     344 
     345  /** 
     346   * UIC4 metadata parser 
     347   * 
     348   * UIC4 Table contains per-plane blocks of metadata 
     349   * stage X/Y positions, 
     350   * camera chip offsets, 
     351   * stage labels... 
     352   * @param long uic4offset: offset of UIC4 table (not tiff-compliant) 
     353   * @throws IOException 
     354   */ 
     355  private void parseUIC4Tags(long uic4offset) throws IOException { 
     356    long saveLoc = in.getFilePointer(); 
     357    in.seek(uic4offset); 
     358    boolean end=false; 
     359    short id; 
     360    while (!end) { 
     361      id = in.readShort(); 
     362 
     363      switch (id) { 
     364        case 0: 
     365          end=true; 
     366          break; 
     367        case 28: 
     368          readStagePositions(); 
     369          break; 
     370        case 29: 
     371          readCameraChipOffsets(); 
     372          break; 
     373        case 37: 
     374          readStageLabels(); 
     375          break; 
     376        case 40: 
     377          readAbsoluteZ(); 
     378          break; 
     379        case 41: 
     380          readAbsoluteZValid(); 
     381          break; 
     382        default: 
     383          //unknown tags: do nothing 
     384          break; 
     385        //28->stagePositions 
     386        //29->cameraChipOffsets 
     387        //30->stageLabel 
     388        //40->AbsoluteZ 
     389        //41AbsoluteZValid 
     390        //0->end 
     391      } 
     392    } 
     393    in.seek(saveLoc); 
     394  } 
     395 
    398396  void readStagePositions() throws IOException { 
    399                 int nx, dx, ny, dy; 
    400                 /* for each plane:  
    401            2 ints (rational:numerator,denominator) for stage X,  
    402           2 ints (idem) for stage Y position 
    403                  */ 
    404                 double xPosition, yPosition; 
    405                 String iAsString; 
    406                 for(int i=0; i<mmPlanes; i++) { 
    407                         nx = in.readInt(); 
    408                         dx = in.readInt(); 
    409                         ny = in.readInt(); 
    410                         dy = in.readInt(); 
    411                         xPosition = (dx == 0) ? Double.NaN : (double) nx / dx; 
    412                         yPosition = (dy == 0) ? Double.NaN : (double) ny / dy; 
    413                         iAsString = intFormatMax(i, mmPlanes); 
    414                         put("stageX[" + iAsString + "]", xPosition); 
    415                         put("stageY[" + iAsString + "]", yPosition); 
    416                 } 
    417  
    418         } 
    419  
    420         void readCameraChipOffsets() throws IOException { 
    421                 int nx, dx, ny, dy; 
    422                 double cameraXChipOffset, cameraYChipOffset; 
    423                 String iAsString; 
    424                 for(int i=0; i<mmPlanes; i++) { 
    425                         iAsString = intFormatMax(i, mmPlanes); 
    426                         nx = in.readInt(); 
    427                         dx = in.readInt(); 
    428                         ny = in.readInt(); 
    429                         dy = in.readInt(); 
    430                         cameraXChipOffset = (dx == 0) ? Double.NaN: (double) nx / dx; 
    431                         cameraYChipOffset = (dy == 0) ? Double.NaN: (double) ny/ dy; 
    432                         put("cameraXChipOffset[" + iAsString + "]", cameraXChipOffset); 
    433                         put("cameraYChipOffset[" + iAsString + "]", cameraYChipOffset); 
    434                 } 
    435         } 
    436  
    437         void readStageLabels() throws IOException { 
    438                 int strlen; 
    439                 byte[] curlabel; 
    440                 String iAsString; 
    441                 for (int i=0; i<mmPlanes; i++) { 
    442                         iAsString = intFormatMax(i, mmPlanes); 
    443                         strlen = in.readInt(); 
    444                         curlabel = new byte[strlen]; 
    445                         in.read(curlabel); 
    446                         put("stageLabel[" + iAsString + "]", new String(curlabel)); 
    447                 } 
    448         } 
    449  
    450         void readAbsoluteZ() throws IOException { 
    451                 int nz, dz; 
    452                 double absoluteZ; 
    453                 for(int i=0; i<mmPlanes; i++) { 
    454                         nz = in.readInt(); 
    455                         dz = in.readInt(); 
    456                         absoluteZ = (dz == 0) ? Double.NaN : (double) nz / dz; 
    457                         put("absoluteZ[" + intFormatMax(i, mmPlanes) + "]", absoluteZ); 
    458                 } 
    459         } 
    460  
    461         void readAbsoluteZValid() throws IOException { 
    462                 for (int i=0; i<mmPlanes; i++) { 
    463                         put("absoluteZValid[" + intFormatMax(i, mmPlanes) + "]", in.readInt()); 
    464     }    
    465   } 
    466  
    467         /** UIC1 entry parser  
    468         * @throws IOException 
    469         * @param long uic1offset : offset as found in the tiff tag 33628 (UIC1Tag) 
    470         * @param int uic1count : number of entries in UIC1 table (not tiff-compliant) 
    471          * */ 
    472         private void parseUIC1Tags(long uic1offset, int uic1count) throws IOException 
     397    int nx, dx, ny, dy; 
     398    // for each plane: 
     399    // 2 ints (rational:numerator,denominator) for stage X, 
     400    // 2 ints (idem) for stage Y position 
     401    double xPosition, yPosition; 
     402    String iAsString; 
     403    for(int i=0; i<mmPlanes; i++) { 
     404      nx = in.readInt(); 
     405      dx = in.readInt(); 
     406      ny = in.readInt(); 
     407      dy = in.readInt(); 
     408      xPosition = (dx == 0) ? Double.NaN : (double) nx / dx; 
     409      yPosition = (dy == 0) ? Double.NaN : (double) ny / dy; 
     410      iAsString = intFormatMax(i, mmPlanes); 
     411      put("stageX[" + iAsString + "]", xPosition); 
     412      put("stageY[" + iAsString + "]", yPosition); 
     413    } 
     414 
     415  } 
     416 
     417  void readCameraChipOffsets() throws IOException { 
     418    int nx, dx, ny, dy; 
     419    double cameraXChipOffset, cameraYChipOffset; 
     420    String iAsString; 
     421    for(int i=0; i<mmPlanes; i++) { 
     422      iAsString = intFormatMax(i, mmPlanes); 
     423      nx = in.readInt(); 
     424      dx = in.readInt(); 
     425      ny = in.readInt(); 
     426      dy = in.readInt(); 
     427      cameraXChipOffset = (dx == 0) ? Double.NaN: (double) nx / dx; 
     428      cameraYChipOffset = (dy == 0) ? Double.NaN: (double) ny/ dy; 
     429      put("cameraXChipOffset[" + iAsString + "]", cameraXChipOffset); 
     430      put("cameraYChipOffset[" + iAsString + "]", cameraYChipOffset); 
     431    } 
     432  } 
     433 
     434  void readStageLabels() throws IOException { 
     435    int strlen; 
     436    byte[] curlabel; 
     437    String iAsString; 
     438    for (int i=0; i<mmPlanes; i++) { 
     439      iAsString = intFormatMax(i, mmPlanes); 
     440      strlen = in.readInt(); 
     441      curlabel = new byte[strlen]; 
     442      in.read(curlabel); 
     443      put("stageLabel[" + iAsString + "]", new String(curlabel)); 
     444    } 
     445  } 
     446 
     447  void readAbsoluteZ() throws IOException { 
     448    int nz, dz; 
     449    double absoluteZ; 
     450    for(int i=0; i<mmPlanes; i++) { 
     451      nz = in.readInt(); 
     452      dz = in.readInt(); 
     453      absoluteZ = (dz == 0) ? Double.NaN : (double) nz / dz; 
     454      put("absoluteZ[" + intFormatMax(i, mmPlanes) + "]", absoluteZ); 
     455    } 
     456  } 
     457 
     458  void readAbsoluteZValid() throws IOException { 
     459    for (int i=0; i<mmPlanes; i++) { 
     460      put("absoluteZValid[" + intFormatMax(i, mmPlanes) + "]", in.readInt()); 
     461    } 
     462  } 
     463 
     464  /** 
     465   * UIC1 entry parser 
     466  * @throws IOException 
     467  * @param long uic1offset : offset as found in the tiff tag 33628 (UIC1Tag) 
     468  * @param int uic1count : number of entries in UIC1 table (not tiff-compliant) 
     469  */ 
     470  private void parseUIC1Tags(long uic1offset, int uic1count) throws IOException 
    473471  { 
    474                 // Loop through and parse out each field. A field whose 
    475                 // code is "0" represents the end of the fields so we'll stop 
    476                 // when we reach that; much like a NULL terminated C string. 
    477                 long saveLoc = in.getFilePointer(); 
    478                 in.seek(uic1offset); 
    479                 int currentID, valOrOffset; 
    480                 // variable declarations, because switch is dumb 
    481                 int num, denom; 
    482                 String thedate, thetime; 
    483                 long lastOffset; 
    484                 byte[] toread; 
    485                 for(int i=0; i<uic1count; i++) { 
    486                         currentID = in.readInt(); 
    487                         valOrOffset = in.readInt(); 
    488                                          
    489                         switch (currentID) { 
    490                         case 1: 
    491                                 put("MinScale", valOrOffset); 
    492                                 break; 
    493                         case 2: 
    494                                 put("MaxScale", valOrOffset); 
    495                                 break; 
    496                         case 3: 
    497                                 int calib = valOrOffset; 
    498                                 String calibration = calib != 0 ? "on" : "off"; 
    499                                 put("Spatial Calibration", calibration); 
    500                                 break; 
    501                         case 4: 
    502                                 lastOffset = in.getFilePointer(); 
    503                                 in.seek(valOrOffset); 
    504                                 num = in.readInt(); 
    505                                 denom = in.readInt(); 
    506                                 put("XCalibration", new TiffRational(num, denom)); 
    507                                 in.seek(lastOffset); 
    508                                 break; 
    509                         case 5: 
    510                                 lastOffset = in.getFilePointer(); 
    511                                 in.seek(valOrOffset); 
    512                                 num = in.readInt(); 
    513                                 denom = in.readInt(); 
    514                                 put("YCalibration", new TiffRational(num, denom)); 
    515                                 in.seek(lastOffset); 
    516                                 break; 
    517                         case 6: 
    518                                 lastOffset = in.getFilePointer(); 
    519                                 in.seek(valOrOffset); 
    520                                 num = in.readInt(); 
    521                                 toread = new byte[num]; 
    522                                 in.read(toread); 
    523                                 put("CalibrationUnits", new String(toread)); 
    524                                 in.seek(lastOffset); 
    525                                 break; 
    526                         case 7: 
    527                                 lastOffset = in.getFilePointer(); 
    528                                 in.seek(valOrOffset); 
    529                                 num = in.readInt(); 
    530                                 toread = new byte[num]; 
    531                                 in.read(toread); 
    532                                 String name = new String(toread); 
    533                                 put("Name", name); 
    534                                 imageName = name; 
    535                                 in.seek(lastOffset); 
    536                                 break; 
    537                                  
    538                         case 8: 
    539                                 int thresh = valOrOffset; 
    540                                 String threshState = "off"; 
    541                                 if (thresh == 1) threshState = "inside"; 
    542                                 else if (thresh == 2) threshState = "outside"; 
    543                                 put("ThreshState", threshState); 
    544                                 break; 
    545                         case 9: 
    546                                 put("ThreshStateRed", valOrOffset); 
    547                                 break; 
    548                                 // there is no 10 
    549                         case 11: 
    550                                 put("ThreshStateGreen", valOrOffset); 
    551                                 break; 
    552                         case 12: 
    553                                 put("ThreshStateBlue", valOrOffset); 
    554                                 break; 
    555                         case 13: 
    556                                 put("ThreshStateLo", valOrOffset); 
    557                                 break; 
    558                         case 14: 
    559                                 put("ThreshStateHi", valOrOffset); 
    560                                 break; 
    561                         case 15: 
    562                                 int zoom = valOrOffset; 
    563                                 put("Zoom", zoom); 
    564 //                              OMETools.setAttribute(ome, "DisplayOptions", "Zoom", "" + zoom); 
    565                                 break; 
    566                         case 16: // oh how we hate you Julian format... 
    567                                 lastOffset = in.getFilePointer(); 
    568                                 in.seek(valOrOffset); 
    569                                 thedate = decodeDate(in.readInt()); 
    570                                 thetime = decodeTime(in.readInt()); 
    571                                 put("DateTime", thedate + " " + thetime); 
    572                                 imageCreationDate = thedate + " " + thetime; 
    573                                 in.seek(lastOffset); 
    574                                 break; 
    575                         case 17: 
    576                                 lastOffset = in.getFilePointer(); 
    577                                 in.seek(valOrOffset); 
    578                                 thedate = decodeDate(in.readInt()); 
    579                                 thetime = decodeTime(in.readInt()); 
    580                                 put("LastSavedTime", thedate + " " + thetime); 
    581                                 in.seek(lastOffset); 
    582                                 break; 
    583                         case 18: 
    584                                 put("currentBuffer", valOrOffset); 
    585                                 break; 
    586                         case 19: 
    587                                 put("grayFit", valOrOffset); 
    588                                 break; 
    589                         case 20: 
    590                                 put("grayPointCount", valOrOffset); 
    591                                 break; 
    592                         case 21: 
    593                                 lastOffset = in.getFilePointer(); 
    594                                 in.seek(valOrOffset); 
    595                                 num = in.readInt(); 
    596                                 denom = in.readInt(); 
    597                                 put("grayX", new TiffRational(num, denom)); 
    598                                 in.seek(lastOffset); 
    599                                 break; 
    600                         case 22: 
    601                                 lastOffset = in.getFilePointer(); 
    602                                 in.seek(valOrOffset); 
    603                                 num = in.readInt(); 
    604                                 denom = in.readInt(); 
    605                                 put("gray", new TiffRational(num, denom)); 
    606                                 in.seek(lastOffset); 
    607                                 break; 
    608                         case 23: 
    609                                 lastOffset = in.getFilePointer(); 
    610                                 in.seek(valOrOffset); 
    611                                 num = in.readInt(); 
    612                                 denom = in.readInt(); 
    613                                 put("grayMin", new TiffRational(num, denom)); 
    614                                 in.seek(lastOffset); 
    615                                 break; 
    616                         case 24: 
    617                                 lastOffset = in.getFilePointer(); 
    618                                 in.seek(valOrOffset); 
    619                                 num = in.readInt(); 
    620                                 denom = in.readInt(); 
    621                                 put("grayMax", new TiffRational(num, denom)); 
    622                                 in.seek(lastOffset); 
    623                                 break; 
    624                                  
    625                         case 25: 
    626                                 lastOffset = in.getFilePointer(); 
    627                                 in.seek(valOrOffset); 
    628                                 num = in.readInt(); 
    629                                 toread = new byte[num]; 
    630                                 in.read(toread); 
    631                                 put("grayUnitName", new String(toread)); 
    632                                 in.seek(lastOffset); 
    633                                 break; 
    634                                  
    635                         case 26: 
    636                                 lastOffset = in.getFilePointer(); 
    637                                 in.seek(valOrOffset); 
    638                                 int standardLUT = in.readInt(); 
    639                                 in.seek(lastOffset); 
    640                                 String standLUT; 
    641                                 switch (standardLUT) { 
    642                                 case 0: 
    643                                         standLUT = "monochrome"; 
    644                                         break; 
    645                                 case 1: 
    646                                         standLUT = "pseudocolor"; 
    647                                         break; 
    648                                 case 2: 
    649                                         standLUT = "Red"; 
    650                                         break; 
    651                                 case 3: 
    652                                         standLUT = "Green"; 
    653                                         break; 
    654                                 case 4: 
    655                                         standLUT = "Blue"; 
    656                                         break; 
    657                                 case 5: 
    658                                         standLUT = "user-defined"; 
    659                                         break; 
    660                                 default: 
    661                                         standLUT = "monochrome"; break; 
    662                                 } 
    663                                 put("StandardLUT", standLUT); 
    664                                 break; 
    665                         case 27: 
    666                                 put("Wavelength", valOrOffset); 
    667                                 break; 
    668                         case 30: 
    669                                 put("OverlayMask", valOrOffset); 
    670                                 break; 
    671                         case 31: 
    672                                 put("OverlayCompress", valOrOffset); 
    673                                 break; 
    674                         case 32: 
    675                                 put("Overlay", valOrOffset); 
    676                                 break; 
    677                         case 33: 
    678                                 put("SpecialOverlayMask", valOrOffset); 
    679                                 break; 
    680                         case 34: 
    681                                 put("SpecialOverlayCompress", in.readInt()); 
    682                                 break; 
    683                         case 35: 
    684                                 put("SpecialOverlay", valOrOffset); 
    685                                 break; 
    686                         case 36: 
    687                                 put("ImageProperty", valOrOffset); 
    688                                 break; 
    689                         case 38: 
    690                                 lastOffset = in.getFilePointer(); 
    691                                 in.seek(valOrOffset); 
    692                                 num = in.readInt(); 
    693                                 denom = in.readInt(); 
    694                                 put("AutoScaleLoInfo", new TiffRational(num, denom)); 
    695                                 in.seek(lastOffset); 
    696                                 break; 
    697                         case 39: 
    698                                 lastOffset = in.getFilePointer(); 
    699                                 in.seek(valOrOffset); 
    700                                 num = in.readInt(); 
    701                                 denom = in.readInt(); 
    702                                 put("AutoScaleHiInfo", new TiffRational(num, denom)); 
    703                                 in.seek(lastOffset); 
    704                                 break; 
    705                         case 42: 
    706                                 put("Gamma", valOrOffset); 
    707                                 break; 
    708                         case 43: 
    709                                 put("GammaRed", valOrOffset); 
    710                                 break; 
    711                         case 44: 
    712                                 put("GammaGreen", valOrOffset); 
    713                                 break; 
    714                         case 45: 
    715                                 put("GammaBlue", valOrOffset); 
    716                                 break; 
    717                         case 46: 
    718                                 lastOffset = in.getFilePointer(); 
    719                                 in.seek(valOrOffset); 
    720                                 int xBin, yBin; 
    721                                 xBin = in.readInt(); 
    722                                 yBin = in.readInt(); 
    723                                 put("CameraBin", new String("(" + xBin + "," + yBin + ")")); 
    724                                 in.seek(lastOffset); 
    725                     break;       
    726       default: 
    727                                 break; 
    728                         } 
    729                 } 
    730                 in.seek(saveLoc); 
    731         } 
    732          
     472    // Loop through and parse out each field. A field whose 
     473    // code is "0" represents the end of the fields so we'll stop 
     474    // when we reach that; much like a NULL terminated C string. 
     475    long saveLoc = in.getFilePointer(); 
     476    in.seek(uic1offset); 
     477    int currentID, valOrOffset; 
     478    // variable declarations, because switch is dumb 
     479    int num, denom; 
     480    String thedate, thetime; 
     481    long lastOffset; 
     482    byte[] toread; 
     483    for (int i=0; i<uic1count; i++) { 
     484      currentID = in.readInt(); 
     485      valOrOffset = in.readInt(); 
     486 
     487      switch (currentID) { 
     488        case 1: 
     489          put("MinScale", valOrOffset); 
     490          break; 
     491        case 2: 
     492          put("MaxScale", valOrOffset); 
     493          break; 
     494        case 3: 
     495          int calib = valOrOffset; 
     496          String calibration = calib != 0 ? "on" : "off"; 
     497          put("Spatial Calibration", calibration); 
     498          break; 
     499        case 4: 
     500          lastOffset = in.getFilePointer(); 
     501          in.seek(valOrOffset); 
     502          num = in.readInt(); 
     503          denom = in.readInt(); 
     504          put("XCalibration", new TiffRational(num, denom)); 
     505          in.seek(lastOffset); 
     506          break; 
     507        case 5: 
     508          lastOffset = in.getFilePointer(); 
     509          in.seek(valOrOffset); 
     510          num = in.readInt(); 
     511          denom = in.readInt(); 
     512          put("YCalibration", new TiffRational(num, denom)); 
     513          in.seek(lastOffset); 
     514          break; 
     515        case 6: 
     516          lastOffset = in.getFilePointer(); 
     517          in.seek(valOrOffset); 
     518          num = in.readInt(); 
     519          toread = new byte[num]; 
     520          in.read(toread); 
     521          put("CalibrationUnits", new String(toread)); 
     522          in.seek(lastOffset); 
     523          break; 
     524        case 7: 
     525          lastOffset = in.getFilePointer(); 
     526          in.seek(valOrOffset); 
     527          num = in.readInt(); 
     528          toread = new byte[num]; 
     529          in.read(toread); 
     530          String name = new String(toread); 
     531          put("Name", name); 
     532          imageName = name; 
     533          in.seek(lastOffset); 
     534          break; 
     535 
     536        case 8: 
     537          int thresh = valOrOffset; 
     538          String threshState = "off"; 
     539          if (thresh == 1) threshState = "inside"; 
     540          else if (thresh == 2) threshState = "outside"; 
     541          put("ThreshState", threshState); 
     542          break; 
     543        case 9: 
     544          put("ThreshStateRed", valOrOffset); 
     545          break; 
     546          // there is no 10 
     547        case 11: 
     548          put("ThreshStateGreen", valOrOffset); 
     549          break; 
     550        case 12: 
     551          put("ThreshStateBlue", valOrOffset); 
     552          break; 
     553        case 13: 
     554          put("ThreshStateLo", valOrOffset); 
     555          break; 
     556        case 14: 
     557          put("ThreshStateHi", valOrOffset); 
     558          break; 
     559        case 15: 
     560          int zoom = valOrOffset; 
     561          put("Zoom", zoom); 
     562          //OMETools.setAttribute(ome, "DisplayOptions", "Zoom", "" + zoom); 
     563          break; 
     564        case 16: // oh how we hate you Julian format... 
     565          lastOffset = in.getFilePointer(); 
     566          in.seek(valOrOffset); 
     567          thedate = decodeDate(in.readInt()); 
     568          thetime = decodeTime(in.readInt()); 
     569          put("DateTime", thedate + " " + thetime); 
     570          imageCreationDate = thedate + " " + thetime; 
     571          in.seek(lastOffset); 
     572          break; 
     573        case 17: 
     574          lastOffset = in.getFilePointer(); 
     575          in.seek(valOrOffset); 
     576          thedate = decodeDate(in.readInt()); 
     577          thetime = decodeTime(in.readInt()); 
     578          put("LastSavedTime", thedate + " " + thetime); 
     579          in.seek(lastOffset); 
     580          break; 
     581        case 18: 
     582          put("currentBuffer", valOrOffset); 
     583          break; 
     584        case 19: 
     585          put("grayFit", valOrOffset); 
     586          break; 
     587        case 20: 
     588          put("grayPointCount", valOrOffset); 
     589          break; 
     590        case 21: 
     591          lastOffset = in.getFilePointer(); 
     592          in.seek(valOrOffset); 
     593          num = in.readInt(); 
     594          denom = in.readInt(); 
     595          put("grayX", new TiffRational(num, denom)); 
     596          in.seek(lastOffset); 
     597          break; 
     598        case 22: 
     599          lastOffset = in.getFilePointer(); 
     600          in.seek(valOrOffset); 
     601          num = in.readInt(); 
     602          denom = in.readInt(); 
     603          put("gray", new TiffRational(num, denom)); 
     604          in.seek(lastOffset); 
     605          break; 
     606        case 23: 
     607          lastOffset = in.getFilePointer(); 
     608          in.seek(valOrOffset); 
     609          num = in.readInt(); 
     610          denom = in.readInt(); 
     611          put("grayMin", new TiffRational(num, denom)); 
     612          in.seek(lastOffset); 
     613          break; 
     614        case 24: 
     615          lastOffset = in.getFilePointer(); 
     616          in.seek(valOrOffset); 
     617          num = in.readInt(); 
     618          denom = in.readInt(); 
     619          put("grayMax", new TiffRational(num, denom)); 
     620          in.seek(lastOffset); 
     621          break; 
     622        case 25: 
     623          lastOffset = in.getFilePointer(); 
     624          in.seek(valOrOffset); 
     625          num = in.readInt(); 
     626          toread = new byte[num]; 
     627          in.read(toread); 
     628          put("grayUnitName", new String(toread)); 
     629          in.seek(lastOffset); 
     630          break; 
     631        case 26: 
     632          lastOffset = in.getFilePointer(); 
     633          in.seek(valOrOffset); 
     634          int standardLUT = in.readInt(); 
     635          in.seek(lastOffset); 
     636          String standLUT; 
     637          switch (standardLUT) { 
     638            case 0: 
     639              standLUT = "monochrome"; 
     640              break; 
     641            case 1: 
     642              standLUT = "pseudocolor"; 
     643              break; 
     644            case 2: 
     645              standLUT = "Red"; 
     646              break; 
     647            case 3: 
     648              standLUT = "Green"; 
     649              break; 
     650            case 4: 
     651              standLUT = "Blue"; 
     652              break; 
     653            case 5: 
     654              standLUT = "user-defined"; 
     655              break; 
     656            default: 
     657              standLUT = "monochrome"; break; 
     658          } 
     659          put("StandardLUT", standLUT); 
     660          break; 
     661        case 27: 
     662          put("Wavelength", valOrOffset); 
     663          break; 
     664        case 30: 
     665          put("OverlayMask", valOrOffset); 
     666          break; 
     667        case 31: 
     668          put("OverlayCompress", valOrOffset); 
     669          break; 
     670        case 32: 
     671          put("Overlay", valOrOffset); 
     672          break; 
     673        case 33: 
     674          put("SpecialOverlayMask", valOrOffset); 
     675          break; 
     676        case 34: 
     677          put("SpecialOverlayCompress", in.readInt()); 
     678          break; 
     679        case 35: 
     680          put("SpecialOverlay", valOrOffset); 
     681          break; 
     682        case 36: 
     683          put("ImageProperty", valOrOffset); 
     684          break; 
     685        case 38: 
     686          lastOffset = in.getFilePointer(); 
     687          in.seek(valOrOffset); 
     688          num = in.readInt(); 
     689          denom = in.readInt(); 
     690          put("AutoScaleLoInfo", new TiffRational(num, denom)); 
     691          in.seek(lastOffset); 
     692          break; 
     693        case 39: 
     694          lastOffset = in.getFilePointer(); 
     695          in.seek(valOrOffset); 
     696          num = in.readInt(); 
     697          denom = in.readInt(); 
     698          put("AutoScaleHiInfo", new TiffRational(num, denom)); 
     699          in.seek(lastOffset); 
     700          break; 
     701        case 42: 
     702          put("Gamma", valOrOffset); 
     703          break; 
     704        case 43: 
     705          put("GammaRed", valOrOffset); 
     706          break; 
     707        case 44: 
     708          put("GammaGreen", valOrOffset); 
     709          break; 
     710        case 45: 
     711          put("GammaBlue", valOrOffset); 
     712          break; 
     713        case 46: 
     714          lastOffset = in.getFilePointer(); 
     715          in.seek(valOrOffset); 
     716          int xBin, yBin; 
     717          xBin = in.readInt(); 
     718          yBin = in.readInt(); 
     719          put("CameraBin", new String("(" + xBin + "," + yBin + ")")); 
     720          in.seek(lastOffset); 
     721          break; 
     722        default: 
     723          break; 
     724      } 
     725    } 
     726    in.seek(saveLoc); 
     727  } 
     728 
    733729  /** Converts a Julian date value into a human-readable string. */ 
    734730  public static String decodeDate(int julian) { 
     
    771767    millis /= 60; 
    772768    hours = millis; 
    773     return intFormat(hours, 2) + ":" + intFormat(minutes, 2) + ":" +  
     769    return intFormat(hours, 2) + ":" + intFormat(minutes, 2) + ":" + 
    774770      intFormat(seconds, 2) + "." + intFormat(ms, 3); 
    775771  } 
    776    
     772 
    777773  /** Formats an integer value with leading 0s if needed. */ 
    778         public static String intFormat(int myint, int digits) { 
    779                 String formatstring = "0"; 
    780                 while (formatstring.length() < digits) { 
    781                         formatstring += "0"; 
    782     } 
    783                 DecimalFormat df = new DecimalFormat(formatstring); 
    784                 return df.format(myint); 
    785         } 
    786    
     774  public static String intFormat(int myint, int digits) { 
     775    String formatstring = "0"; 
     776    while (formatstring.length() < digits) { 
     777      formatstring += "0"; 
     778    } 
     779    DecimalFormat df = new DecimalFormat(formatstring); 
     780    return df.format(myint); 
     781  } 
     782 
    787783  /** 
    788    * Formats an integer with leading 0 using maximum sequence number 
    789          *  
    790          * @param myint : integer to format 
    791          * @param maxint : max of "myint" 
    792         * @return String 
    793         */ 
    794         public static String intFormatMax(int myint, int maxint) { 
    795                 return intFormat(myint, new Integer(maxint).toString().length()); 
    796         } 
     784   * Formats an integer with leading 0 using maximum sequence number. 
     785   * 
     786   * @param myint integer to format 
     787   * @param maxint max of "myint" 
     788  * @return String 
     789  */ 
     790  public static String intFormatMax(int myint, int maxint) { 
     791    return intFormat(myint, new Integer(maxint).toString().length()); 
     792  } 
    797793 
    798794} 
  • trunk/loci/formats/in/QTReader.java

    r2602 r2604  
    245245  // -- FormatReader API methods -- 
    246246 
    247   /* @see loci.formats.IFormatReader#isThisType(byte[]) */  
     247  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
    248248  public boolean isThisType(byte[] block) { 
    249249    return false; 
     
    256256  } 
    257257 
    258   /* @see loci.formats.IFormatReader#openBytes(int) */  
     258  /* @see loci.formats.IFormatReader#openBytes(int) */ 
    259259  public byte[] openBytes(int no) throws FormatException, IOException { 
    260260    if (no < 0 || no >= getImageCount()) { 
     
    332332          for (int j=0; j<core.sizeY[0]; j++) { 
    333333            for (int k=0; k<b; k++) { 
    334               bytes[j*core.sizeX[0]*b + (core.sizeX[0] - i) + b] =  
    335                 tmp[i*core.sizeY[0]*b + j + b]; 
     334              int bndx = j * core.sizeX[0] * b + (core.sizeX[0] - i) + b; 
     335              int tndx = i * core.sizeY[0] * b + j + b; 
     336              bytes[bndx] = tmp[tndx]; 
    336337            } 
    337338          } 
     
    342343          for (int j=0; j<core.sizeX[0]; j++) { 
    343344            for (int k=0; k<core.sizeY[0]; k++) { 
    344               bytes[k*core.sizeX[0] +i*core.sizeX[0]*core.sizeY[0] +  
    345                (core.sizeX[0] - j - 1)] = tmp[j*core.sizeY[0] + k +  
    346                i*core.sizeX[0]*core.sizeY[0]]; 
     345              int q = i * core.sizeX[0] * core.sizeY[0]; 
     346              int bndx = k * core.sizeX[0] + q + (core.sizeX[0] - j - 1); 
     347              int tndx = j * core.sizeY[0] + k + q; 
     348              bytes[bndx] = tmp[tndx]; 
    347349            } 
    348350          } 
     
    359361    pad = (4 - pad) % 4; 
    360362 
    361     if (core.sizeX[0]*core.sizeY[0] * (bitsPerPixel / 8) == prevPixels.length) { 
    362       pad = 0; 
    363     } 
     363    int size = core.sizeX[0] * core.sizeY[0]; 
     364    if (size * (bitsPerPixel / 8) == prevPixels.length) pad = 0; 
    364365 
    365366    if (pad > 0 && !code.equals("rpza")) { 
     
    382383 
    383384        for (int j=0; j<cut; j++) { 
    384           redColumn[j] = prevPixels[(j+core.sizeY[0]-cut)*core.sizeX[0] + i]; 
    385           greenColumn[j] = prevPixels[(j+core.sizeY[0]-cut)*core.sizeX[0] + i +  
    386             core.sizeX[0]*core.sizeY[0]]; 
    387           blueColumn[j] = prevPixels[(j+core.sizeY[0]-cut)*core.sizeX[0] + i +  
    388             2*core.sizeX[0]*core.sizeY[0]]; 
     385          int ndx = (j + core.sizeY[0] - cut) * core.sizeX[0] + i; 
     386          redColumn[j] = prevPixels[ndx]; 
     387          greenColumn[j] = prevPixels[ndx + size]; 
     388          blueColumn[j] = prevPixels[ndx + 2 * size]; 
    389389        } 
    390390 
    391391        for (int j=cut; j<core.sizeY[0]; j++) { 
    392           redColumn[j] = prevPixels[j*core.sizeX[0] + i]; 
    393           greenColumn[j] =  
    394             prevPixels[j*core.sizeX[0] + i + core.sizeX[0]*core.sizeY[0]]; 
    395           blueColumn[j] =  
    396             prevPixels[j*core.sizeX[0] + i + 2*core.sizeX[0]*core.sizeY[0]]; 
     392          int ndx = j * core.sizeX[0] + i; 
     393          redColumn[j] = prevPixels[ndx]; 
     394          greenColumn[j] = prevPixels[ndx + size]; 
     395          blueColumn[j] = prevPixels[ndx + 2 * size]; 
    397396        } 
    398397 
     
    400399 
    401400        for (int j=0; j<core.sizeY[0]; j++) { 
    402           bytes[j*core.sizeX[0] + i] = redColumn[j]; 
    403           bytes[j*core.sizeX[0] + i + core.sizeX[0]*core.sizeY[0]] =  
    404             greenColumn[j]; 
    405           bytes[j*core.sizeX[0] + i + 2*core.sizeX[0]*core.sizeY[0]] =  
    406             blueColumn[j]; 
     401          int ndx = j * core.sizeX[0] + i; 
     402          bytes[ndx] = redColumn[j]; 
     403          bytes[ndx + size] = greenColumn[j]; 
     404          bytes[ndx + 2 * size] = blueColumn[j]; 
    407405        } 
    408406      } 
     
    411409    if (flip) { 
    412410      int t = core.sizeX[0]; 
    413       core.sizeX[0] = core.sizeY[0];  
     411      core.sizeX[0] = core.sizeY[0]; 
    414412      core.sizeY[0] = t; 
    415413    } 
     
    442440  } 
    443441 
    444   /* @See loci.formats.IFormatReader#openImage(int) */  
     442  /* @See loci.formats.IFormatReader#openImage(int) */ 
    445443  public BufferedImage openImage(int no) throws FormatException, IOException { 
    446444    if (no < 0 || no >= getImageCount()) { 
     
    512510  } 
    513511 
    514   /* @see loci.formats.IFormatReader#close() */  
     512  /* @see loci.formats.IFormatReader#close() */ 
    515513  public void close() throws FormatException, IOException { 
    516514    if (in != null) in.close(); 
     
    529527    offsets = new Vector(); 
    530528    chunkSizes = new Vector(); 
    531     status("Parsing tags");  
     529    status("Parsing tags"); 
    532530    parse(0, 0, in.length()); 
    533531    core.imageCount[0] = offsets.size(); 
     
    556554      core.sizeY[0] = tmp; 
    557555    } 
    558      
     556 
    559557    core.rgb[0] = bitsPerPixel < 40; 
    560558    core.sizeZ[0] = 1; 
     
    576574      new Integer(core.pixelType[0]), 
    577575      new Boolean(!core.littleEndian[0]), 
    578       core.currentOrder[0],  
     576      core.currentOrder[0], 
    579577      null, 
    580578      null); 
     
    681679 
    682680  /** Parse all of the atoms in the file. */ 
    683   public void parse(int depth, long offset, long length)  
    684     throws FormatException, IOException  
     681  public void parse(int depth, long offset, long length) 
     682    throws FormatException, IOException 
    685683  { 
    686684    while (offset < length) { 
     
    11141112 
    11151113      // offset to second field 
    1116       int offset =  
     1114      int offset = 
    11171115        DataTools.bytesToInt(input, pt, 4, core.littleEndian[0]) + extra; 
    11181116      pt += 4; 
    11191117 
    11201118      // offset to quantization table 
    1121       int quantOffset =  
     1119      int quantOffset = 
    11221120        DataTools.bytesToInt(input, pt, 4, core.littleEndian[0]) + extra; 
    11231121      pt += 4; 
    11241122 
    11251123      // offset to Huffman table 
    1126       int huffmanOffset =  
     1124      int huffmanOffset = 
    11271125        DataTools.bytesToInt(input, pt, 4, core.littleEndian[0]) + extra; 
    11281126      pt += 4; 
    11291127 
    11301128      // offset to start of frame 
    1131       int sof = DataTools.bytesToInt(input, pt, 4, core.littleEndian[0]) + extra; 
     1129      int sof = 
     1130        DataTools.bytesToInt(input, pt, 4, core.littleEndian[0]) + extra; 
    11321131      pt += 4; 
    11331132 
    11341133      // offset to start of scan 
    1135       int sos = DataTools.bytesToInt(input, pt, 4, core.littleEndian[0]) + extra; 
     1134      int sos = 
     1135        DataTools.bytesToInt(input, pt, 4, core.littleEndian[0]) + extra; 
    11361136      pt += 4; 
    11371137 
    11381138      // offset to start of data 
    1139       int sod = DataTools.bytesToInt(input, pt, 4, core.littleEndian[0]) + extra; 
     1139      int sod = 
     1140        DataTools.bytesToInt(input, pt, 4, core.littleEndian[0]) + extra; 
    11401141      pt += 4; 
    11411142 
     
    13041305    v.add((byte) (length & 0xff)); 
    13051306 
    1306     int fieldHeight = core.sizeY[0];  
     1307    int fieldHeight = core.sizeY[0]; 
    13071308    if (interlaced) fieldHeight /= 2; 
    13081309    if (core.sizeY[0] % 2 == 1) fieldHeight++; 
Note: See TracChangeset for help on using the changeset viewer.