Changeset 6156


Ignore:
Timestamp:
04/20/10 19:47:33 (10 years ago)
Author:
melissa
Message:

Updated several more readers to respect MetadataOptions.

Location:
trunk/components/bio-formats/src/loci/formats/in
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/components/bio-formats/src/loci/formats/in/LeicaReader.java

    r6122 r6156  
    706706    } 
    707707    else { 
    708       listing = 
    709         (String[]) Location.getIdMap().keySet().toArray(new String[0]); 
     708      listing = Location.getIdMap().keySet().toArray(new String[0]); 
    710709    } 
    711710 
  • trunk/components/bio-formats/src/loci/formats/in/LiFlimReader.java

    r6026 r6156  
    6060  // -- Constants -- 
    6161 
    62   // INI keys 
    63   public static final String VERSION_KEY = "FLIMIMAGE: INFO - version"; 
    64   public static final String COMPRESSION_KEY = "FLIMIMAGE: INFO - compression"; 
    65   public static final String DATATYPE_KEY = "FLIMIMAGE: LAYOUT - datatype"; 
    66   public static final String C_KEY = "FLIMIMAGE: LAYOUT - channels"; 
    67   public static final String X_KEY = "FLIMIMAGE: LAYOUT - x"; 
    68   public static final String Y_KEY = "FLIMIMAGE: LAYOUT - y"; 
    69   public static final String Z_KEY = "FLIMIMAGE: LAYOUT - z"; 
    70   public static final String P_KEY = "FLIMIMAGE: LAYOUT - phases"; 
    71   public static final String F_KEY = "FLIMIMAGE: LAYOUT - frequencies"; 
    72   public static final String T_KEY = "FLIMIMAGE: LAYOUT - timestamps"; 
    73  
     62  // INI tables 
     63  public static final String INFO_TABLE = "FLIMIMAGE: INFO"; 
     64  public static final String LAYOUT_TABLE = "FLIMIMAGE: LAYOUT"; 
     65  public static final String BACKGROUND_TABLE = "FLIMIMAGE: BACKGROUND"; 
     66 
     67  // relevant keys in info table 
     68  public static final String VERSION_KEY = "version"; 
     69  public static final String COMPRESSION_KEY = "compression"; 
     70 
     71  // relevant keys in layout and background tables 
     72  public static final String DATATYPE_KEY = "datatype"; 
     73  public static final String C_KEY = "channels"; 
     74  public static final String X_KEY = "x"; 
     75  public static final String Y_KEY = "y"; 
     76  public static final String Z_KEY = "z"; 
     77  public static final String P_KEY = "phases"; 
     78  public static final String F_KEY = "frequencies"; 
     79  public static final String T_KEY = "timestamps"; 
     80 
     81  // relevant keys in timestamp table 
    7482  public static final String TIMESTAMP_KEY = "FLIMIMAGE: TIMESTAMPS - t"; 
    75  
    76   // INI keys for the background image 
    77   public static final String BG_DATATYPE_KEY = 
    78     "FLIMIMAGE: BACKGROUND - datatype"; 
    79   public static final String BG_C_KEY = "FLIMIMAGE: BACKGROUND - channels"; 
    80   public static final String BG_X_KEY = "FLIMIMAGE: BACKGROUND - x"; 
    81   public static final String BG_Y_KEY = "FLIMIMAGE: BACKGROUND - y"; 
    82   public static final String BG_Z_KEY = "FLIMIMAGE: BACKGROUND - z"; 
    83   public static final String BG_P_KEY = "FLIMIMAGE: BACKGROUND - phases"; 
    84   public static final String BG_F_KEY = "FLIMIMAGE: BACKGROUND - frequencies"; 
    85   public static final String BG_T_KEY = "FLIMIMAGE: BACKGROUND - timestamps"; 
    8683 
    8784  // supported versions 
     
    258255    stampValues = new Hashtable<Integer, String>(); 
    259256 
    260     // add all INI entries to the global metadata list 
    261     for (IniTable table : ini) { 
    262       String name = table.get(IniTable.HEADER_KEY); 
    263       for (String key : table.keySet()) { 
    264         if (key.equals(IniTable.HEADER_KEY)) continue; 
    265         String value = table.get(key); 
    266         String metaKey = name + " - " + key; 
    267         addGlobalMeta(metaKey, value); 
    268  
    269         // save important values regardless of isMetadataCollected() 
    270         if (metaKey.equals(VERSION_KEY)) version = value; 
    271         else if (metaKey.equals(COMPRESSION_KEY)) compression = value; 
    272         else if (metaKey.equals(DATATYPE_KEY)) datatype = value; 
    273         else if (metaKey.equals(C_KEY)) channels = value; 
    274         else if (metaKey.equals(X_KEY)) xLen = value; 
    275         else if (metaKey.equals(Y_KEY)) yLen = value; 
    276         else if (metaKey.equals(Z_KEY)) zLen = value; 
    277         else if (metaKey.equals(P_KEY)) phases = value; 
    278         else if (metaKey.equals(F_KEY)) frequencies = value; 
    279         else if (metaKey.equals(T_KEY)) timestamps = value; 
    280         else if (metaKey.equals(BG_DATATYPE_KEY)) backgroundDatatype = value; 
    281         else if (metaKey.equals(BG_C_KEY)) backgroundC = value; 
    282         else if (metaKey.equals(BG_X_KEY)) backgroundX = value; 
    283         else if (metaKey.equals(BG_Y_KEY)) backgroundY = value; 
    284         else if (metaKey.equals(BG_Z_KEY)) backgroundZ = value; 
    285         else if (metaKey.equals(BG_T_KEY)) backgroundT = value; 
    286         else if (metaKey.equals(BG_P_KEY)) backgroundP = value; 
    287         else if (metaKey.equals(BG_F_KEY)) backgroundF = value; 
    288         else if (metaKey.startsWith(TIMESTAMP_KEY)) { 
    289           int index = Integer.parseInt(metaKey.replaceAll(TIMESTAMP_KEY, "")); 
    290           stampValues.put(new Integer(index), value); 
    291         } 
    292         else if (metaKey.equals("ROI: INFO - numregions")) { 
    293           numRegions = Integer.parseInt(value); 
    294         } 
    295         else if (metaKey.startsWith("ROI: ROI")) { 
    296           int start = metaKey.lastIndexOf("ROI") + 3; 
    297           int end = metaKey.indexOf(" ", start); 
    298           Integer index = new Integer(metaKey.substring(start, end)); 
    299           ROI roi = rois.get(index); 
    300           if (roi == null) roi = new ROI(); 
    301  
    302           if (metaKey.endsWith("name")) { 
    303             roi.name = value; 
     257    IniTable layoutTable = ini.getTable(LAYOUT_TABLE); 
     258    datatype = layoutTable.get(DATATYPE_KEY); 
     259    channels = layoutTable.get(C_KEY); 
     260    xLen = layoutTable.get(X_KEY); 
     261    yLen = layoutTable.get(Y_KEY); 
     262    zLen = layoutTable.get(Z_KEY); 
     263    phases = layoutTable.get(P_KEY); 
     264    frequencies = layoutTable.get(F_KEY); 
     265    timestamps = layoutTable.get(T_KEY); 
     266 
     267    IniTable backgroundTable = ini.getTable(BACKGROUND_TABLE); 
     268    if (backgroundTable != null) { 
     269      backgroundDatatype = backgroundTable.get(DATATYPE_KEY); 
     270      backgroundC = backgroundTable.get(C_KEY); 
     271      backgroundX = backgroundTable.get(X_KEY); 
     272      backgroundY = backgroundTable.get(Y_KEY); 
     273      backgroundZ = backgroundTable.get(Z_KEY); 
     274      backgroundT = backgroundTable.get(T_KEY); 
     275      backgroundP = backgroundTable.get(P_KEY); 
     276      backgroundF = backgroundTable.get(F_KEY); 
     277    } 
     278 
     279    IniTable infoTable = ini.getTable(INFO_TABLE); 
     280    version = infoTable.get(VERSION_KEY); 
     281    compression = infoTable.get(COMPRESSION_KEY); 
     282 
     283    if (getMetadataOptions().getMetadataLevel() == MetadataLevel.ALL) { 
     284      // add all INI entries to the global metadata list 
     285      for (IniTable table : ini) { 
     286        String name = table.get(IniTable.HEADER_KEY); 
     287        for (String key : table.keySet()) { 
     288          if (key.equals(IniTable.HEADER_KEY)) continue; 
     289          String value = table.get(key); 
     290          String metaKey = name + " - " + key; 
     291          addGlobalMeta(metaKey, value); 
     292 
     293          if (metaKey.startsWith(TIMESTAMP_KEY)) { 
     294            Integer index = new Integer(metaKey.replaceAll(TIMESTAMP_KEY, "")); 
     295            stampValues.put(index, value); 
    304296          } 
    305           else if (metaKey.indexOf(" - p") >= 0) { 
    306             String p = metaKey.substring(metaKey.indexOf(" - p") + 4); 
    307             Integer pointIndex = new Integer(p); 
    308             roi.points.put(pointIndex, value.replaceAll(" ", ",")); 
     297          else if (metaKey.equals("ROI: INFO - numregions")) { 
     298            numRegions = Integer.parseInt(value); 
    309299          } 
    310           rois.put(index, roi); 
    311         } 
    312         else if (metaKey.endsWith("ExposureTime")) { 
    313           String exp = value; 
    314           double expTime = 
    315             Double.parseDouble(exp.substring(0, exp.indexOf(" "))); 
    316           String units = exp.substring(exp.indexOf(" ") + 1).toLowerCase(); 
    317           if (units.equals("ms")) { 
    318             expTime /= 1000; 
     300          else if (metaKey.startsWith("ROI: ROI")) { 
     301            int start = metaKey.lastIndexOf("ROI") + 3; 
     302            int end = metaKey.indexOf(" ", start); 
     303            Integer index = new Integer(metaKey.substring(start, end)); 
     304            ROI roi = rois.get(index); 
     305            if (roi == null) roi = new ROI(); 
     306 
     307            if (metaKey.endsWith("name")) { 
     308              roi.name = value; 
     309            } 
     310            else if (metaKey.indexOf(" - p") >= 0) { 
     311              String p = metaKey.substring(metaKey.indexOf(" - p") + 4); 
     312              roi.points.put(new Integer(p), value.replaceAll(" ", ",")); 
     313            } 
     314            rois.put(index, roi); 
    319315          } 
    320           exposureTime = new Double(expTime); 
     316          else if (metaKey.endsWith("ExposureTime")) { 
     317            int space = value.indexOf(" "); 
     318            double expTime = Double.parseDouble(value.substring(0, space)); 
     319            String units = value.substring(space + 1).toLowerCase(); 
     320            if (units.equals("ms")) { 
     321              expTime /= 1000; 
     322            } 
     323            exposureTime = new Double(expTime); 
     324          } 
    321325        } 
    322326      } 
     
    398402      new FilterMetadata(getMetadataStore(), isMetadataFiltered()); 
    399403    MetadataTools.populatePixels(store, this, times > 0); 
     404    MetadataTools.setDefaultCreationDate(store, currentId, 0); 
    400405 
    401406    // image data 
     
    403408    if (getSeriesCount() > 1) { 
    404409      store.setImageName(getCurrentFile() + " Background Image", 1); 
     410      MetadataTools.setDefaultCreationDate(store, currentId, 1); 
     411    } 
     412 
     413    if (getMetadataOptions().getMetadataLevel() != MetadataLevel.ALL) { 
     414      return; 
    405415    } 
    406416 
     
    438448 
    439449    // regions of interest 
    440     StringBuilder points = new StringBuilder(); 
    441450    Integer[] roiIndices = rois.keySet().toArray(new Integer[rois.size()]); 
    442451    Arrays.sort(roiIndices); 
    443452    for (int roi=0; roi<roiIndices.length; roi++) { 
    444       points.setLength(0); 
    445453      ROI r = rois.get(roiIndices[roi]); 
    446       Integer[] pointIndices = r.points.keySet().toArray(new Integer[0]); 
    447       Arrays.sort(pointIndices); 
    448       for (Integer point : pointIndices) { 
    449         if (point == null) continue; 
    450         String p = r.points.get(point); 
    451         if (points.length() > 0) points.append(" "); 
    452         points.append(p); 
    453       } 
    454       store.setPolygonPoints(points.toString(), 0, roi, 0); 
     454      store.setPolygonPoints(r.pointsToString(), 0, roi, 0); 
    455455    } 
    456456  } 
     
    517517    public String name; 
    518518    public Hashtable<Integer, String> points = new Hashtable<Integer, String>(); 
     519   
     520    public String pointsToString() { 
     521      StringBuilder s = new StringBuilder(); 
     522      Integer[] pointIndices = points.keySet().toArray(new Integer[0]); 
     523      Arrays.sort(pointIndices); 
     524      for (Integer point : pointIndices) { 
     525        if (point == null) continue; 
     526        String p = points.get(point); 
     527        if (s.length() > 0) s.append(" "); 
     528        s.append(p); 
     529      } 
     530      return s.toString(); 
     531    } 
    519532  } 
    520533 
  • trunk/components/bio-formats/src/loci/formats/in/MRCReader.java

    r6055 r6156  
    5656  private static final String[] MRC_SUFFIXES = {"mrc", "st", "ali", "map"}; 
    5757 
     58  private static final int HEADER_SIZE = 1024; 
     59  private static final int ENDIANNESS_OFFSET = 212; 
     60 
    5861  // -- Fields -- 
    59  
    60   /** Number of bytes per pixel */ 
    61   private int bpp = 0; 
    6262 
    6363  /** Size of extended header */ 
    6464  private int extHeaderSize = 0; 
    65  
    66   /** Flag set to true if we are using float data. */ 
    67   private boolean isFloat = false; 
    6865 
    6966  // -- Constructor -- 
     
    8582    FormatTools.checkPlaneParameters(this, no, buf.length, x, y, w, h); 
    8683 
    87     in.seek(1024 + extHeaderSize + no * FormatTools.getPlaneSize(this)); 
     84    in.seek(HEADER_SIZE + extHeaderSize + no * FormatTools.getPlaneSize(this)); 
    8885    readPlane(in, x, y, w, h, buf); 
    8986 
     
    9592    super.close(fileOnly); 
    9693    if (!fileOnly) { 
    97       bpp = extHeaderSize = 0; 
    98       isFloat = false; 
     94      extHeaderSize = 0; 
    9995    } 
    10096  } 
     
    106102    super.initFile(id); 
    107103    in = new RandomAccessInputStream(id); 
     104    MetadataLevel level = getMetadataOptions().getMetadataLevel(); 
    108105 
    109106    LOGGER.info("Reading header"); 
     
    111108    // check endianness 
    112109 
    113     in.seek(212); 
     110    in.seek(ENDIANNESS_OFFSET); 
    114111    core[0].littleEndian = in.read() == 68; 
    115112 
     
    117114 
    118115    in.seek(0); 
    119     in.order(core[0].littleEndian); 
     116    in.order(isLittleEndian()); 
    120117 
    121118    core[0].sizeX = in.readInt(); 
     
    137134        break; 
    138135      case 2: 
    139         isFloat = true; 
    140136        core[0].pixelType = FormatTools.FLOAT; 
    141137        break; 
     
    144140        break; 
    145141      case 4: 
    146         isFloat = true; 
    147142        core[0].pixelType = FormatTools.DOUBLE; 
    148143        break; 
     
    153148    } 
    154149 
    155     bpp = FormatTools.getBytesPerPixel(getPixelType()); 
    156  
    157150    in.skipBytes(12); 
    158151 
    159152    // pixel size = xlen / mx 
    160153 
    161     int mx = in.readInt(); 
    162     int my = in.readInt(); 
    163     int mz = in.readInt(); 
    164  
    165     float xlen = in.readFloat(); 
    166     float ylen = in.readFloat(); 
    167     float zlen = in.readFloat(); 
    168  
    169     addGlobalMeta("Pixel size (X)", xlen / mx); 
    170     addGlobalMeta("Pixel size (Y)", ylen / my); 
    171     addGlobalMeta("Pixel size (Z)", zlen / mz); 
    172  
    173     addGlobalMeta("Alpha angle", in.readFloat()); 
    174     addGlobalMeta("Beta angle", in.readFloat()); 
    175     addGlobalMeta("Gamma angle", in.readFloat()); 
    176  
    177     in.skipBytes(12); 
    178  
    179     // min, max and mean pixel values 
    180  
    181     addGlobalMeta("Minimum pixel value", in.readFloat()); 
    182     addGlobalMeta("Maximum pixel value", in.readFloat()); 
    183     addGlobalMeta("Mean pixel value", in.readFloat()); 
    184  
    185     in.skipBytes(4); 
     154    double xSize = 0d, ySize = 0d, zSize = 0d; 
     155 
     156    if (level == MetadataLevel.ALL) { 
     157      int mx = in.readInt(); 
     158      int my = in.readInt(); 
     159      int mz = in.readInt(); 
     160 
     161      xSize = in.readFloat() / mx; 
     162      ySize = in.readFloat() / my; 
     163      zSize = in.readFloat() / mz; 
     164 
     165      if (xSize == Double.POSITIVE_INFINITY) xSize = 1; 
     166      if (ySize == Double.POSITIVE_INFINITY) ySize = 1; 
     167      if (zSize == Double.POSITIVE_INFINITY) zSize = 1; 
     168 
     169      addGlobalMeta("Pixel size (X)", xSize); 
     170      addGlobalMeta("Pixel size (Y)", ySize); 
     171      addGlobalMeta("Pixel size (Z)", zSize); 
     172 
     173      addGlobalMeta("Alpha angle", in.readFloat()); 
     174      addGlobalMeta("Beta angle", in.readFloat()); 
     175      addGlobalMeta("Gamma angle", in.readFloat()); 
     176 
     177      in.skipBytes(12); 
     178 
     179      // min, max and mean pixel values 
     180 
     181      addGlobalMeta("Minimum pixel value", in.readFloat()); 
     182      addGlobalMeta("Maximum pixel value", in.readFloat()); 
     183      addGlobalMeta("Mean pixel value", in.readFloat()); 
     184 
     185      in.skipBytes(4); 
     186    } 
     187    else in.skipBytes(64); 
     188 
    186189    extHeaderSize = in.readInt(); 
    187190 
    188     in.skipBytes(64); 
    189  
    190     int idtype = in.readShort(); 
    191  
    192     String type = (idtype >= 0 && idtype < TYPES.length) ? TYPES[idtype] : 
    193       "unknown"; 
    194  
    195     addGlobalMeta("Series type", type); 
    196     addGlobalMeta("Lens", in.readShort()); 
    197     addGlobalMeta("ND1", in.readShort()); 
    198     addGlobalMeta("ND2", in.readShort()); 
    199     addGlobalMeta("VD1", in.readShort()); 
    200     addGlobalMeta("VD2", in.readShort()); 
    201  
    202     for (int i=0; i<6; i++) { 
    203       addGlobalMeta("Angle " + (i + 1), in.readFloat()); 
    204     } 
    205  
    206     in.skipBytes(24); 
    207  
    208     addGlobalMeta("Number of useful labels", in.readInt()); 
    209  
    210     for (int i=0; i<10; i++) { 
    211       addGlobalMeta("Label " + (i + 1), in.readString(80)); 
    212     } 
    213  
    214     in.skipBytes(extHeaderSize); 
     191    if (level == MetadataLevel.ALL) { 
     192      in.skipBytes(64); 
     193 
     194      int idtype = in.readShort(); 
     195 
     196      String type = "unknown"; 
     197      if (idtype >= 0 && idtype < TYPES.length) type = TYPES[idtype]; 
     198 
     199      addGlobalMeta("Series type", type); 
     200      addGlobalMeta("Lens", in.readShort()); 
     201      addGlobalMeta("ND1", in.readShort()); 
     202      addGlobalMeta("ND2", in.readShort()); 
     203      addGlobalMeta("VD1", in.readShort()); 
     204      addGlobalMeta("VD2", in.readShort()); 
     205 
     206      for (int i=0; i<6; i++) { 
     207        addGlobalMeta("Angle " + (i + 1), in.readFloat()); 
     208      } 
     209 
     210      in.skipBytes(24); 
     211 
     212      addGlobalMeta("Number of useful labels", in.readInt()); 
     213 
     214      for (int i=0; i<10; i++) { 
     215        addGlobalMeta("Label " + (i + 1), in.readString(80)); 
     216      } 
     217    } 
    215218 
    216219    LOGGER.info("Populating metadata"); 
     
    230233    MetadataTools.setDefaultCreationDate(store, id, 0); 
    231234 
    232     double x = (xlen / mx) == Double.POSITIVE_INFINITY ? 1 : (xlen / mx); 
    233     double y = (ylen / my) == Double.POSITIVE_INFINITY ? 1 : (ylen / my); 
    234     double z = (zlen / mz) == Double.POSITIVE_INFINITY ? 1 : (zlen / mz); 
    235  
    236     store.setDimensionsPhysicalSizeX(x, 0, 0); 
    237     store.setDimensionsPhysicalSizeY(y, 0, 0); 
    238     store.setDimensionsPhysicalSizeZ(z, 0, 0); 
     235    if (level == MetadataLevel.ALL) { 
     236      store.setDimensionsPhysicalSizeX(xSize, 0, 0); 
     237      store.setDimensionsPhysicalSizeY(ySize, 0, 0); 
     238      store.setDimensionsPhysicalSizeZ(zSize, 0, 0); 
     239    } 
    239240  } 
    240241 
  • trunk/components/bio-formats/src/loci/formats/in/NAFReader.java

    r6118 r6156  
    7373    FormatTools.checkPlaneParameters(this, no, buf.length, x, y, w, h); 
    7474 
    75     if (in.getFilePointer() + buf.length > in.length()) { 
     75    if (compressed) { 
    7676      throw new FormatException("Sorry, compressed data is not supported."); 
    7777    } 
    7878 
    7979    in.seek(offsets[series] + no * FormatTools.getPlaneSize(this)); 
    80  
    8180    readPlane(in, x, y, w, h, buf); 
    8281    return buf; 
  • trunk/components/bio-formats/src/loci/formats/in/PCIReader.java

    r6118 r6156  
    9393    FormatTools.checkPlaneParameters(this, no, buf.length, x, y, w, h); 
    9494 
    95     RandomAccessInputStream s = 
    96       poi.getDocumentStream(imageFiles.get(new Integer(no))); 
     95    RandomAccessInputStream s = poi.getDocumentStream(imageFiles.get(no)); 
    9796    TiffParser tp = new TiffParser(s); 
    9897 
     
    158157      String parent = name.substring(0, separator); 
    159158      String relativePath = name.substring(separator + 1); 
     159      RandomAccessInputStream stream = poi.getDocumentStream(name); 
     160      stream.order(true); 
    160161 
    161162      if (relativePath.equals("Field Count")) { 
    162         byte[] b = poi.getDocumentBytes(name, 4); 
    163         core[0].imageCount = DataTools.bytesToInt(b, true); 
     163        core[0].imageCount = stream.readInt(); 
    164164      } 
    165165      else if (relativePath.equals("File Has Image")) { 
    166         byte[] b = poi.getDocumentBytes(name, 2); 
    167         if (DataTools.bytesToInt(b, true) == 0) { 
     166        if (stream.readShort() == 0) { 
    168167          throw new FormatException("This file does not contain image data."); 
    169         } 
    170       } 
    171       else if (relativePath.equals("Comments")) { 
    172         String comments = new String(poi.getDocumentBytes(name)); 
    173         String[] lines = comments.split("\n"); 
    174         for (String line : lines) { 
    175           int eq = line.indexOf("="); 
    176           if (eq != -1) { 
    177             String key = line.substring(0, eq).trim(); 
    178             String value = line.substring(eq + 1).trim(); 
    179             addGlobalMeta(key, value); 
    180  
    181             if (key.equals("factor")) { 
    182               if (value.indexOf(";") != -1) { 
    183                 value = value.substring(0, value.indexOf(";")); 
    184               } 
    185               scaleFactor = Double.parseDouble(value.trim()); 
    186             } 
    187           } 
    188168        } 
    189169      } 
    190170      else if (relativePath.startsWith("Bitmap") || relativePath.equals("Data")) 
    191171      { 
    192         int space = parent.lastIndexOf(" ") + 1; 
    193         if (space >= parent.length()) continue; 
    194         int num = Integer.parseInt(parent.substring(space, 
    195           parent.indexOf(File.separator, space))) - 1; 
    196         imageFiles.put(new Integer(num), name); 
     172        Integer index = getImageIndex(parent); 
     173        if (index == null) continue; 
     174        imageFiles.put(index, name); 
    197175 
    198176        if (getSizeX() != 0 && getSizeY() != 0) { 
     
    208186      } 
    209187      else if (relativePath.indexOf("Image_Depth") != -1) { 
    210         byte[] b = poi.getDocumentBytes(name, 8); 
    211         int bits = (int) DataTools.bytesToDouble(b, true); 
     188        int bits = (int) stream.readDouble(); 
     189        core[0].bitsPerPixel = bits; 
    212190        while (bits % 8 != 0 || bits == 0) bits++; 
    213191        if (bits % 3 == 0) { 
    214192          core[0].sizeC = 3; 
    215193          bits /= 3; 
     194          core[0].bitsPerPixel /= 3; 
    216195        } 
    217196        bits /= 8; 
     
    219198      } 
    220199      else if (relativePath.indexOf("Image_Height") != -1 && getSizeY() == 0) { 
    221         byte[] b = poi.getDocumentBytes(name, 8); 
    222         core[0].sizeY = (int) DataTools.bytesToDouble(b, true); 
     200        core[0].sizeY = (int) stream.readDouble(); 
    223201      } 
    224202      else if (relativePath.indexOf("Image_Width") != -1 && getSizeX() == 0) { 
    225         byte[] b = poi.getDocumentBytes(name, 8); 
    226         core[0].sizeX = (int) DataTools.bytesToDouble(b, true); 
     203        core[0].sizeX = (int) stream.readDouble(); 
    227204      } 
    228205      else if (relativePath.indexOf("Time_From_Start") != -1) { 
    229         byte[] b = poi.getDocumentBytes(name, 8); 
    230         Double v = new Double(DataTools.bytesToDouble(b, true)); 
    231  
    232         int space = parent.lastIndexOf(" ") + 1; 
    233         if (space >= parent.length()) continue; 
    234         int num = Integer.parseInt(parent.substring(space, 
    235           parent.indexOf(File.separator, space))) - 1; 
    236         timestamps.put(new Integer(num), v); 
     206        Integer index = getImageIndex(parent); 
     207        if (index == null) continue; 
     208        timestamps.put(index, stream.readDouble()); 
    237209      } 
    238210      else if (relativePath.equals("First Field Date & Time")) { 
    239         byte[] b = poi.getDocumentBytes(name); 
    240         long date = (long) DataTools.bytesToDouble(b, true) * 1000; 
     211        long date = (long) stream.readDouble() * 1000; 
    241212        creationDate = DateTools.convertDate(date, DateTools.COBOL); 
    242213      } 
    243       else if (relativePath.equals("First Field Start Clock")) { 
    244         byte[] b = poi.getDocumentBytes(name); 
    245         double v = DataTools.bytesToDouble(b, true); 
    246       } 
    247       else if (relativePath.equals("Binning")) { 
    248         byte[] b = poi.getDocumentBytes(name, 8); 
    249         binning = (int) DataTools.bytesToDouble(b, true); 
    250       } 
     214      else if (getMetadataOptions().getMetadataLevel() == MetadataLevel.ALL) { 
     215        if (relativePath.equals("Binning")) { 
     216          binning = (int) stream.readDouble(); 
     217        } 
     218        else if (relativePath.equals("Comments")) { 
     219          String comments = stream.readString((int) stream.length()); 
     220          String[] lines = comments.split("\n"); 
     221          for (String line : lines) { 
     222            int eq = line.indexOf("="); 
     223            if (eq != -1) { 
     224              String key = line.substring(0, eq).trim(); 
     225              String value = line.substring(eq + 1).trim(); 
     226              addGlobalMeta(key, value); 
     227 
     228              if (key.equals("factor")) { 
     229                if (value.indexOf(";") != -1) { 
     230                  value = value.substring(0, value.indexOf(";")); 
     231                } 
     232                scaleFactor = Double.parseDouble(value.trim()); 
     233              } 
     234            } 
     235          } 
     236        } 
     237      } 
     238      stream.close(); 
    251239    } 
    252240 
     
    277265    } 
    278266    else MetadataTools.setDefaultCreationDate(store, id, 0); 
    279     store.setDimensionsPhysicalSizeX(scaleFactor, 0, 0); 
    280     store.setDimensionsPhysicalSizeY(scaleFactor, 0, 0); 
    281  
    282     for (int i=0; i<timestamps.size(); i++) { 
    283       Double timestamp = new Double( 
    284         timestamps.get(new Integer(i)).doubleValue()); 
    285       store.setPlaneTimingDeltaT(timestamp, 0, 0, i); 
    286       if (i == 2) { 
    287         double first = timestamps.get(new Integer(1)).doubleValue(); 
    288         Double increment = new Double(timestamp.doubleValue() - first); 
    289         store.setDimensionsTimeIncrement(increment, 0, 0); 
    290       } 
    291     } 
    292  
    293     if (binning > 0) { 
    294       String instrumentID = MetadataTools.createLSID("Instrument", 0); 
    295       String detectorID = MetadataTools.createLSID("Detector", 0); 
    296       store.setInstrumentID(instrumentID, 0); 
    297       store.setDetectorID(detectorID, 0, 0); 
    298       store.setDetectorType("Unknown", 0, 0); 
    299       store.setImageInstrumentRef(instrumentID, 0); 
    300  
    301       for (int c=0; c<getEffectiveSizeC(); c++) { 
    302         store.setDetectorSettingsDetector(detectorID, 0, c); 
    303         store.setDetectorSettingsBinning(binning + "x" + binning, 0, c); 
    304       } 
    305     } 
     267 
     268    if (getMetadataOptions().getMetadataLevel() == MetadataLevel.ALL) { 
     269      store.setDimensionsPhysicalSizeX(scaleFactor, 0, 0); 
     270      store.setDimensionsPhysicalSizeY(scaleFactor, 0, 0); 
     271 
     272      for (int i=0; i<timestamps.size(); i++) { 
     273        Double timestamp = new Double(timestamps.get(i).doubleValue()); 
     274        store.setPlaneTimingDeltaT(timestamp, 0, 0, i); 
     275        if (i == 2) { 
     276          double first = timestamps.get(1).doubleValue(); 
     277          Double increment = new Double(timestamp.doubleValue() - first); 
     278          store.setDimensionsTimeIncrement(increment, 0, 0); 
     279        } 
     280      } 
     281 
     282      if (binning > 0) { 
     283        String instrumentID = MetadataTools.createLSID("Instrument", 0); 
     284        String detectorID = MetadataTools.createLSID("Detector", 0); 
     285        store.setInstrumentID(instrumentID, 0); 
     286        store.setDetectorID(detectorID, 0, 0); 
     287        store.setDetectorType("Unknown", 0, 0); 
     288        store.setImageInstrumentRef(instrumentID, 0); 
     289 
     290        for (int c=0; c<getEffectiveSizeC(); c++) { 
     291          store.setDetectorSettingsDetector(detectorID, 0, c); 
     292          store.setDetectorSettingsBinning(binning + "x" + binning, 0, c); 
     293        } 
     294      } 
     295    } 
     296  } 
     297 
     298  // -- Helper methods -- 
     299 
     300  /** Get the image index from the image file name. */ 
     301  private Integer getImageIndex(String path) { 
     302    int space = path.lastIndexOf(" ") + 1; 
     303    if (space >= path.length()) return null; 
     304    int end = path.indexOf(File.separator, space); 
     305    String s = path.substring(space, end); 
     306    return Integer.parseInt(s) - 1; 
    306307  } 
    307308 
  • trunk/components/bio-formats/src/loci/formats/in/PerkinElmerReader.java

    r6055 r6156  
    7474  protected MinimalTiffReader tiff; 
    7575 
    76   /** Tiff files to open. */ 
     76  /** TIFF files to open. */ 
    7777  protected String[] files; 
    7878 
     
    184184      Vector<String> files = new Vector<String>(); 
    185185      if (isTiff) { 
    186         for (int i=0; i<allFiles.size(); i++) { 
    187           String f = allFiles.get(i).toLowerCase(); 
    188           if (!f.endsWith(".tif") && !f.endsWith(".tiff")) { 
    189             files.add(allFiles.get(i)); 
     186        for (String f : allFiles) { 
     187          if (!checkSuffix(f, new String[] {"tif", "tiff"})) { 
     188            files.add(f); 
    190189          } 
    191190        } 
    192191      } 
    193192      else { 
    194         for (int i=0; i<allFiles.size(); i++) { 
    195           String f = allFiles.get(i); 
     193        for (String f : allFiles) { 
    196194          String ext = f.substring(f.lastIndexOf(".") + 1); 
    197195          try { 
     
    201199        } 
    202200      } 
    203       return files.toArray(new String[0]); 
    204     } 
    205     return allFiles.toArray(new String[0]); 
     201      return files.toArray(new String[files.size()]); 
     202    } 
     203    return allFiles.toArray(new String[allFiles.size()]); 
    206204  } 
    207205 
     
    254252    String workingDirPath = workingDir.getPath(); 
    255253    if (!workingDirPath.equals("")) workingDirPath += File.separator; 
    256     String[] ls = workingDir.list(); 
     254    String[] ls = workingDir.list(true); 
    257255    if (!new Location(id).exists()) { 
    258       ls = (String[]) Location.getIdMap().keySet().toArray(new String[0]); 
     256      ls = Location.getIdMap().keySet().toArray(new String[0]); 
    259257      workingDirPath = ""; 
    260258    } 
    261  
    262     // remove files that start with '.' 
    263  
    264     Vector<String> v = new Vector<String>(); 
    265     for (int i=0; i<ls.length; i++) { 
    266       String file = ls[i]; 
    267       if (file.indexOf(File.separator) != -1) { 
    268         file = file.substring(file.lastIndexOf(File.separator) + 1); 
    269       } 
    270       if (!file.startsWith(".")) { 
    271         v.add(ls[i]); 
    272       } 
    273     } 
    274     ls = v.toArray(new String[0]); 
    275259 
    276260    LOGGER.info("Searching for all metadata companion files"); 
     
    341325    LOGGER.info("Finding image files"); 
    342326 
    343     int extCount = 0; 
    344327    Vector<String> foundExts = new Vector<String>(); 
    345328    for (int i=0; i<filesPt; i++) { 
    346329      String ext = tempFiles[i].substring(tempFiles[i].lastIndexOf(".") + 1); 
    347330      if (!foundExts.contains(ext)) { 
    348         extCount++; 
    349331        foundExts.add(ext); 
    350332      } 
    351333    } 
     334    int extCount = foundExts.size(); 
    352335    foundExts = null; 
    353336 
     337    Vector<String> extSet = new Vector<String>(); 
    354338    for (int i=0; i<filesPt; i+=extCount) { 
    355       Vector<String> extSet = new Vector<String>(); 
    356339      for (int j=0; j<extCount; j++) { 
    357340        String file = tempFiles[i + j]; 
     
    365348          int pos = 0; 
    366349          while (insert == -1 && pos < extSet.size()) { 
    367             String posString = (String) extSet.get(pos); 
     350            String posString = extSet.get(pos); 
    368351            posString = posString.substring(posString.lastIndexOf(".") + 1); 
    369352            int posNum = Integer.parseInt(posString, 16); 
     
    372355            pos++; 
    373356          } 
    374           if (insert == -1) extSet.add(tempFiles[i+j]); 
     357          if (insert == -1) extSet.add(tempFiles[i + j]); 
    375358          else extSet.add(insert, tempFiles[i + j]); 
    376359        } 
     
    379362      int length = (int) Math.min(extCount, extSet.size()); 
    380363      for (int j=0; j<length; j++) { 
    381         files[i+j] = (String) extSet.get(j); 
    382       } 
     364        files[i + j] = extSet.get(j); 
     365      } 
     366      extSet.clear(); 
    383367    } 
    384368 
    385369    allFiles.addAll(Arrays.asList(files)); 
    386370 
    387     if (isTiff) Arrays.sort(files); 
    388     else { 
    389       Comparator<String> c = new Comparator<String>() { 
    390         public int compare(String s1, String s2) { 
    391           String prefix1 = s1, prefix2 = s2, suffix1 = s1, suffix2 = s2; 
    392           if (s1.indexOf(".") != -1) { 
    393             prefix1 = s1.substring(0, s1.lastIndexOf(".")); 
    394             suffix1 = s1.substring(s1.lastIndexOf(".") + 1); 
    395           } 
    396           if (s2.indexOf(".") != -1) { 
    397             prefix2 = s2.substring(0, s2.lastIndexOf(".")); 
    398             suffix2 = s2.substring(s2.lastIndexOf(".") + 1); 
    399           } 
    400           int cmp = prefix1.compareTo(prefix2); 
    401           if (cmp != 0) return cmp; 
    402           return Integer.parseInt(suffix1, 16) - Integer.parseInt(suffix2, 16); 
    403         } 
    404       }; 
    405       Arrays.sort(files, c); 
    406     } 
     371    sortFiles(); 
    407372 
    408373    core[0].imageCount = files.length; 
     
    427392    if (htmFile != null) htmFile = allFiles.get(allFiles.size() - 1); 
    428393 
    429     if (timFile != null) { 
    430       String[] tokens = DataTools.readFile(timFile).split("\\s"); 
    431       int tNum = 0; 
    432       // can ignore "Zero x" and "Extra int" 
    433       String[] hashKeys = {"Number of Wavelengths/Timepoints", "Zero 1", 
    434         "Zero 2", "Number of slices", "Extra int", "Calibration Unit", 
    435         "Pixel Size Y", "Pixel Size X", "Image Width", "Image Length", 
    436         "Origin X", "SubfileType X", "Dimension Label X", "Origin Y", 
    437         "SubfileType Y", "Dimension Label Y", "Origin Z", 
    438         "SubfileType Z", "Dimension Label Z"}; 
    439  
    440       // there are 9 additional tokens, but I don't know what they're for 
    441  
    442       for (String token : tokens) { 
    443         if (token.trim().length() == 0) continue; 
    444         if (tNum >= hashKeys.length) break; 
    445         if (token.equals("um")) tNum = 5; 
    446         while ((tNum == 1 || tNum == 2) && !token.trim().equals("0")) { 
    447           tNum++; 
    448         } 
    449         if (tNum == 4) { 
    450           try { 
    451             Integer.parseInt(token); 
    452           } 
    453           catch (NumberFormatException e) { 
    454             tNum++; 
    455           } 
    456         } 
    457         parseKeyValue(hashKeys[tNum++], token); 
    458       } 
    459     } 
    460  
    461     if (csvFile != null) { 
    462       String[] tokens = DataTools.readFile(csvFile).split("\\s"); 
    463       Vector<String> tmp = new Vector<String>(); 
    464       for (String token : tokens) { 
    465         if (token.trim().length() > 0) tmp.add(token.trim()); 
    466       } 
    467       tokens = tmp.toArray(new String[0]); 
    468  
    469       int tNum = 0; 
    470       String[] hashKeys = {"Calibration Unit", "Pixel Size X", "Pixel Size Y", 
    471         "Z slice space"}; 
    472       int pt = 0; 
    473       for (int j=0; j<tokens.length;) { 
    474         String key = null, value = null; 
    475         if (tNum < 7) { j++; } 
    476         else if ((tNum > 7 && tNum < 12) || 
    477           (tNum > 12 && tNum < 18) || (tNum > 18 && tNum < 22)) 
    478         { 
    479           j++; 
    480         } 
    481         else if (pt < hashKeys.length) { 
    482           key = hashKeys[pt++]; 
    483           value = tokens[j++]; 
    484         } 
    485         else { 
    486           key = tokens[j++] + tokens[j++]; 
    487           value = tokens[j++]; 
    488         } 
    489  
    490         parseKeyValue(key, value); 
    491         tNum++; 
    492       } 
    493     } 
    494  
    495     if (zpoFile != null && csvFile == null) { 
    496       // parse .zpo only if no .csv is available 
    497       String[] tokens = DataTools.readFile(zpoFile).split("\\s"); 
    498       for (int t=0; t<tokens.length; t++) { 
    499         addGlobalMeta("Z slice #" + t + " position", tokens[t]); 
    500       } 
    501     } 
     394    if (timFile != null) parseTimFile(timFile); 
     395    if (csvFile != null) parseCSVFile(csvFile); 
     396    if (zpoFile != null && csvFile == null) parseZpoFile(zpoFile); 
    502397 
    503398    // be aggressive about parsing the HTML file, since it's the only one that 
     
    598493      int bpp = (int) (tmp.length() - 6) / (getSizeX() * getSizeY()); 
    599494      tmp.close(); 
    600       switch (bpp) { 
    601         case 1: 
    602         case 3: 
    603           core[0].pixelType = FormatTools.UINT8; 
    604           break; 
    605         case 2: 
    606           core[0].pixelType = FormatTools.UINT16; 
    607           break; 
    608         case 4: 
    609           core[0].pixelType = FormatTools.UINT32; 
    610           break; 
    611       } 
     495      if (bpp % 3 == 0) bpp /= 3; 
     496      core[0].pixelType = FormatTools.pixelTypeFromBytes(bpp, false, false); 
    612497    } 
    613498 
     
    627512 
    628513    // throw away files, if necessary 
    629  
     514    removeExtraFiles(); 
     515 
     516    core[0].dimensionOrder = "XYCTZ"; 
     517    core[0].rgb = isTiff ? tiff.isRGB() : false; 
     518    core[0].interleaved = false; 
     519    core[0].littleEndian = isTiff ? tiff.isLittleEndian() : true; 
     520    core[0].metadataComplete = true; 
     521    core[0].indexed = isTiff ? tiff.isIndexed() : false; 
     522    core[0].falseColor = false; 
     523 
     524    // Populate metadata store 
     525 
     526    // The metadata store we're working with. 
     527    MetadataStore store = 
     528      new FilterMetadata(getMetadataStore(), isMetadataFiltered()); 
     529    MetadataTools.populatePixels(store, this, true); 
     530 
     531    // populate Image element 
     532    if (finishTime != null) { 
     533      finishTime = DateTools.formatDate(finishTime, DATE_FORMAT); 
     534      store.setImageCreationDate(finishTime, 0); 
     535    } 
     536    else MetadataTools.setDefaultCreationDate(store, id, 0); 
     537 
     538    if (getMetadataOptions().getMetadataLevel() == MetadataLevel.ALL) { 
     539      // populate Dimensions element 
     540      store.setDimensionsPhysicalSizeX(pixelSizeX, 0, 0); 
     541      store.setDimensionsPhysicalSizeY(pixelSizeY, 0, 0); 
     542 
     543      // link Instrument and Image 
     544      String instrumentID = MetadataTools.createLSID("Instrument", 0); 
     545      store.setInstrumentID(instrumentID, 0); 
     546      store.setImageInstrumentRef(instrumentID, 0); 
     547 
     548      // populate LogicalChannel element 
     549      for (int i=0; i<getEffectiveSizeC(); i++) { 
     550        if (i < emWaves.size()) { 
     551          store.setLogicalChannelEmWave(emWaves.get(i), 0, i); 
     552        } 
     553        if (i < exWaves.size()) { 
     554          store.setLogicalChannelExWave(exWaves.get(i), 0, i); 
     555        } 
     556      } 
     557 
     558      // populate PlaneTiming and StagePosition 
     559 
     560      long start = 0, end = 0; 
     561      if (startTime != null) { 
     562        start = DateTools.getTime(startTime, DATE_FORMAT); 
     563      } 
     564      if (finishTime != null) { 
     565        end = DateTools.getTime(finishTime, DateTools.ISO8601_FORMAT); 
     566      } 
     567 
     568      double secondsPerPlane = (double) (end - start) / getImageCount() / 1000; 
     569 
     570      for (int i=0; i<getImageCount(); i++) { 
     571        int[] zct = getZCTCoords(i); 
     572        store.setPlaneTimingDeltaT(i * secondsPerPlane, 0, 0, i); 
     573        if (zct[1] < exposureTimes.size()) { 
     574          store.setPlaneTimingExposureTime(exposureTimes.get(zct[1]), 0, 0, i); 
     575        } 
     576 
     577        if (zct[0] < zPositions.size()) { 
     578          store.setStagePositionPositionX(0.0, 0, 0, i); 
     579          store.setStagePositionPositionY(0.0, 0, 0, i); 
     580          store.setStagePositionPositionZ(zPositions.get(zct[0]), 0, 0, i); 
     581        } 
     582      } 
     583    } 
     584  } 
     585 
     586  // -- Helper methods -- 
     587 
     588  private void parseKeyValue(String key, String value) { 
     589    if (key == null || value == null) return; 
     590    addGlobalMeta(key, value); 
     591    try { 
     592      if (key.equals("Image Width")) { 
     593        core[0].sizeX = Integer.parseInt(value); 
     594      } 
     595      else if (key.equals("Image Length")) { 
     596        core[0].sizeY = Integer.parseInt(value); 
     597      } 
     598      else if (key.equals("Number of slices")) { 
     599        core[0].sizeZ = Integer.parseInt(value); 
     600      } 
     601      else if (key.equals("Experiment details:")) details = value; 
     602      else if (key.equals("Z slice space")) sliceSpace = value; 
     603      else if (key.equals("Pixel Size X")) { 
     604        pixelSizeX = Double.parseDouble(value); 
     605      } 
     606      else if (key.equals("Pixel Size Y")) { 
     607        pixelSizeY = Double.parseDouble(value); 
     608      } 
     609      else if (key.equals("Finish Time:")) finishTime = value; 
     610      else if (key.equals("Start Time:")) startTime = value; 
     611      else if (key.equals("Origin X")) { 
     612        originX = Double.parseDouble(value); 
     613      } 
     614      else if (key.equals("Origin Y")) { 
     615        originY = Double.parseDouble(value); 
     616      } 
     617      else if (key.equals("Origin Z")) { 
     618        originZ = Double.parseDouble(value); 
     619      } 
     620      else if (key.equals("SubfileType X")) { 
     621        core[0].bitsPerPixel = Integer.parseInt(value); 
     622      } 
     623    } 
     624    catch (NumberFormatException exc) { 
     625      LOGGER.debug("", exc); 
     626    } 
     627  } 
     628 
     629  /** Add the given file to the used files list. */ 
     630  private void addUsedFile(String workingDirPath, String file) { 
     631    if (file == null) return; 
     632    Location f = new Location(workingDirPath, file); 
     633    if (!workingDirPath.equals("")) allFiles.add(f.getAbsolutePath()); 
     634    else allFiles.add(file); 
     635  } 
     636 
     637  private void sortFiles() { 
     638   if (isTiff) Arrays.sort(files); 
     639    else { 
     640      Comparator<String> c = new Comparator<String>() { 
     641        public int compare(String s1, String s2) { 
     642          String prefix1 = s1, prefix2 = s2, suffix1 = s1, suffix2 = s2; 
     643          if (s1.indexOf(".") != -1) { 
     644            prefix1 = s1.substring(0, s1.lastIndexOf(".")); 
     645            suffix1 = s1.substring(s1.lastIndexOf(".") + 1); 
     646          } 
     647          if (s2.indexOf(".") != -1) { 
     648            prefix2 = s2.substring(0, s2.lastIndexOf(".")); 
     649            suffix2 = s2.substring(s2.lastIndexOf(".") + 1); 
     650          } 
     651          int cmp = prefix1.compareTo(prefix2); 
     652          if (cmp != 0) return cmp; 
     653          return Integer.parseInt(suffix1, 16) - Integer.parseInt(suffix2, 16); 
     654        } 
     655      }; 
     656      Arrays.sort(files, c); 
     657    } 
     658  } 
     659 
     660  private void removeExtraFiles() { 
    630661    int calcCount = getSizeZ() * getEffectiveSizeC() * getSizeT(); 
    631662    if (files.length > getImageCount() || getImageCount() != calcCount) { 
     
    652683      String[] keys = zSections.keySet().toArray(new String[0]); 
    653684      Arrays.sort(keys); 
    654       for (int i=0; i<keys.length; i++) { 
    655         int oldCount = zSections.get(keys[i]).intValue(); 
    656         int nPlanes = 
    657           (isTiff ? tiff.getEffectiveSizeC() : getSizeC()) * getSizeT(); 
     685      for (String key : keys) { 
     686        int oldCount = zSections.get(key).intValue(); 
     687        int sizeC = isTiff ? tiff.getEffectiveSizeC() : getSizeC(); 
     688        int nPlanes = sizeC * getSizeT(); 
    658689        int count = (int) Math.min(oldCount, nPlanes); 
    659         for (int j=0; j<count; j++) { 
    660           files[nextFile++] = tmpFiles[oldFile++]; 
    661         } 
     690        System.arraycopy(tmpFiles, oldFile, files, nextFile, count); 
    662691        if (count < oldCount) oldFile += (oldCount - count); 
    663692      } 
    664693      core[0].imageCount = getSizeZ() * getEffectiveSizeC() * getSizeT(); 
    665694    } 
    666  
    667     core[0].dimensionOrder = "XYCTZ"; 
    668     core[0].rgb = isTiff ? tiff.isRGB() : false; 
    669     core[0].interleaved = false; 
    670     core[0].littleEndian = isTiff ? tiff.isLittleEndian() : true; 
    671     core[0].metadataComplete = true; 
    672     core[0].indexed = isTiff ? tiff.isIndexed() : false; 
    673     core[0].falseColor = false; 
    674  
    675     // Populate metadata store 
    676  
    677     // The metadata store we're working with. 
    678     MetadataStore store = 
    679       new FilterMetadata(getMetadataStore(), isMetadataFiltered()); 
    680     MetadataTools.populatePixels(store, this, true); 
    681  
    682     // populate Dimensions element 
    683     store.setDimensionsPhysicalSizeX(pixelSizeX, 0, 0); 
    684     store.setDimensionsPhysicalSizeY(pixelSizeY, 0, 0); 
    685  
    686     // populate Image element 
    687     if (finishTime != null) { 
    688       finishTime = DateTools.formatDate(finishTime, DATE_FORMAT); 
    689       store.setImageCreationDate(finishTime, 0); 
    690     } 
    691     else MetadataTools.setDefaultCreationDate(store, id, 0); 
    692  
    693     // link Instrument and Image 
    694     String instrumentID = MetadataTools.createLSID("Instrument", 0); 
    695     store.setInstrumentID(instrumentID, 0); 
    696     store.setImageInstrumentRef(instrumentID, 0); 
    697  
    698     // populate LogicalChannel element 
    699     for (int i=0; i<getEffectiveSizeC(); i++) { 
    700       if (i < emWaves.size()) { 
    701         store.setLogicalChannelEmWave(emWaves.get(i), 0, i); 
    702       } 
    703       if (i < exWaves.size()) { 
    704         store.setLogicalChannelExWave(exWaves.get(i), 0, i); 
    705       } 
    706     } 
    707  
    708     // populate PlaneTiming and StagePosition 
    709  
    710     long start = 0, end = 0; 
    711     if (startTime != null) { 
    712       start = DateTools.getTime(startTime, DATE_FORMAT); 
    713     } 
    714     if (finishTime != null) { 
    715       end = DateTools.getTime(finishTime, DateTools.ISO8601_FORMAT); 
    716     } 
    717  
    718     double secondsPerPlane = (double) (end - start) / getImageCount() / 1000; 
    719  
    720     for (int i=0; i<getImageCount(); i++) { 
    721       int[] zct = getZCTCoords(i); 
    722       store.setPlaneTimingDeltaT(i * secondsPerPlane, 0, 0, i); 
    723       if (zct[1] < exposureTimes.size()) { 
    724         store.setPlaneTimingExposureTime(exposureTimes.get(zct[1]), 0, 0, i); 
    725       } 
    726  
    727       if (zct[0] < zPositions.size()) { 
    728         store.setStagePositionPositionX(0.0, 0, 0, i); 
    729         store.setStagePositionPositionY(0.0, 0, 0, i); 
    730         store.setStagePositionPositionZ(zPositions.get(zct[0]), 0, 0, i); 
    731       } 
    732     } 
    733   } 
    734  
    735   // -- Helper methods -- 
    736  
    737   private void parseKeyValue(String key, String value) { 
    738     if (key == null || value == null) return; 
    739     addGlobalMeta(key, value); 
    740     try { 
    741       if (key.equals("Image Width")) { 
    742         core[0].sizeX = Integer.parseInt(value); 
    743       } 
    744       else if (key.equals("Image Length")) { 
    745         core[0].sizeY = Integer.parseInt(value); 
    746       } 
    747       else if (key.equals("Number of slices")) { 
    748         core[0].sizeZ = Integer.parseInt(value); 
    749       } 
    750       else if (key.equals("Experiment details:")) details = value; 
    751       else if (key.equals("Z slice space")) sliceSpace = value; 
    752       else if (key.equals("Pixel Size X")) { 
    753         pixelSizeX = Double.parseDouble(value); 
    754       } 
    755       else if (key.equals("Pixel Size Y")) { 
    756         pixelSizeY = Double.parseDouble(value); 
    757       } 
    758       else if (key.equals("Finish Time:")) finishTime = value; 
    759       else if (key.equals("Start Time:")) startTime = value; 
    760       else if (key.equals("Origin X")) { 
    761         originX = Double.parseDouble(value); 
    762       } 
    763       else if (key.equals("Origin Y")) { 
    764         originY = Double.parseDouble(value); 
    765       } 
    766       else if (key.equals("Origin Z")) { 
    767         originZ = Double.parseDouble(value); 
    768       } 
    769       else if (key.equals("SubfileType X")) { 
    770         core[0].bitsPerPixel = Integer.parseInt(value); 
    771       } 
    772     } 
    773     catch (NumberFormatException exc) { 
    774       LOGGER.debug("", exc); 
    775     } 
    776   } 
    777  
    778   /** Add the given file to the used files list. */ 
    779   private void addUsedFile(String workingDirPath, String file) { 
    780     if (file == null) return; 
    781     Location f = new Location(workingDirPath, file); 
    782     if (!workingDirPath.equals("")) allFiles.add(f.getAbsolutePath()); 
    783     else allFiles.add(file); 
     695  } 
     696 
     697  private void parseTimFile(String timFile) throws IOException { 
     698    String[] tokens = DataTools.readFile(timFile).split("\\s"); 
     699    int tNum = 0; 
     700    // can ignore "Zero x" and "Extra int" 
     701    String[] hashKeys = {"Number of Wavelengths/Timepoints", "Zero 1", 
     702      "Zero 2", "Number of slices", "Extra int", "Calibration Unit", 
     703      "Pixel Size Y", "Pixel Size X", "Image Width", "Image Length", 
     704      "Origin X", "SubfileType X", "Dimension Label X", "Origin Y", 
     705      "SubfileType Y", "Dimension Label Y", "Origin Z", 
     706      "SubfileType Z", "Dimension Label Z"}; 
     707 
     708    // there are 9 additional tokens, but I don't know what they're for 
     709 
     710    for (String token : tokens) { 
     711      if (token.trim().length() == 0) continue; 
     712      if (tNum >= hashKeys.length) break; 
     713      if (token.equals("um")) tNum = 5; 
     714      while ((tNum == 1 || tNum == 2) && !token.trim().equals("0")) { 
     715        tNum++; 
     716      } 
     717      if (tNum == 4) { 
     718        try { 
     719          Integer.parseInt(token); 
     720        } 
     721        catch (NumberFormatException e) { 
     722          tNum++; 
     723        } 
     724      } 
     725      parseKeyValue(hashKeys[tNum++], token); 
     726    } 
     727  } 
     728 
     729  private void parseCSVFile(String csvFile) throws IOException { 
     730    if (getMetadataOptions().getMetadataLevel() != MetadataLevel.ALL) return; 
     731    String[] tokens = DataTools.readFile(csvFile).split("\\s"); 
     732    Vector<String> tmp = new Vector<String>(); 
     733    for (String token : tokens) { 
     734      if (token.trim().length() > 0) tmp.add(token.trim()); 
     735    } 
     736    tokens = tmp.toArray(new String[0]); 
     737 
     738    int tNum = 0; 
     739    String[] hashKeys = {"Calibration Unit", "Pixel Size X", "Pixel Size Y", 
     740      "Z slice space"}; 
     741    int pt = 0; 
     742    for (int j=0; j<tokens.length;) { 
     743      String key = null, value = null; 
     744      if (tNum < 7) { j++; } 
     745      else if ((tNum > 7 && tNum < 12) || 
     746        (tNum > 12 && tNum < 18) || (tNum > 18 && tNum < 22)) 
     747      { 
     748        j++; 
     749      } 
     750      else if (pt < hashKeys.length) { 
     751        key = hashKeys[pt++]; 
     752        value = tokens[j++]; 
     753      } 
     754      else { 
     755        key = tokens[j++] + tokens[j++]; 
     756        value = tokens[j++]; 
     757      } 
     758 
     759      parseKeyValue(key, value); 
     760      tNum++; 
     761    } 
     762  } 
     763 
     764  private void parseZpoFile(String zpoFile) throws IOException { 
     765    if (getMetadataOptions().getMetadataLevel() != MetadataLevel.ALL) return; 
     766    String[] tokens = DataTools.readFile(zpoFile).split("\\s"); 
     767    for (int t=0; t<tokens.length; t++) { 
     768      addGlobalMeta("Z slice #" + t + " position", tokens[t]); 
     769    } 
    784770  } 
    785771 
  • trunk/components/bio-formats/src/loci/formats/in/PictReader.java

    r6042 r6156  
    2727import java.util.Vector; 
    2828 
     29import loci.common.ByteArrayHandle; 
    2930import loci.common.DataTools; 
    3031import loci.common.RandomAccessInputStream; 
     
    133134 
    134135    if (jpegOffsets.size() > 0) { 
    135       ByteVector v = new ByteVector(); 
     136      ByteArrayHandle v = new ByteArrayHandle(); 
    136137      in.seek(jpegOffsets.get(0)); 
    137138      byte[] b = new byte[(int) (in.length() - in.getFilePointer())]; 
     
    145146        options.littleEndian = isLittleEndian(); 
    146147 
    147         v.add(new JPEGCodec().decompress(s, options)); 
    148       } 
    149  
    150       s = new RandomAccessInputStream(v.toByteArray()); 
     148        v.write(new JPEGCodec().decompress(s, options)); 
     149      } 
     150 
     151      s = new RandomAccessInputStream(v); 
     152      s.seek(0); 
    151153      readPlane(s, x, y, w, h, buf); 
    152154      s.close(); 
     
    264266    strips = new Vector(); 
    265267    rowBytes = 0; 
    266     versionOne = false; 
    267268    lookup = null; 
    268269 
     
    292293    } 
    293294    else throw new FormatException("Invalid PICT file"); 
     295 
     296    addGlobalMeta("Version", versionOne ? 1 : 2); 
    294297 
    295298    do { 
     
    393396 
    394397  /** Extract the image data in a PICT bitmap structure. */ 
    395   private void handleBitmap(int opcode) 
    396     throws FormatException, IOException 
    397   { 
     398  private void handleBitmap(int opcode) throws FormatException, IOException { 
    398399    readImageHeader(opcode); 
    399     handlePixmap(rowBytes, 1, 1); 
     400    handlePixmap(1, 1); 
    400401  } 
    401402 
    402403  /** Extracts the image data in a PICT pixmap structure. */ 
    403   private void handlePixmap(int opcode) 
    404     throws FormatException, IOException 
    405   { 
     404  private void handlePixmap(int opcode) throws FormatException, IOException { 
    406405    readImageHeader(opcode); 
    407406    LOGGER.debug("handlePixmap({})", opcode); 
     
    450449    if (opcode == PICT_BITSRGN || opcode == PICT_PACKBITSRGN) in.skipBytes(2); 
    451450 
    452     handlePixmap(rowBytes, pixelSize, compCount); 
     451    handlePixmap(pixelSize, compCount); 
    453452  } 
    454453 
    455454  /** Handles the unpacking of the image data. */ 
    456   private void handlePixmap(int rBytes, int pixelSize, int compCount) 
     455  private void handlePixmap(int pixelSize, int compCount) 
    457456    throws FormatException, IOException 
    458457  { 
    459458    LOGGER.debug("handlePixmap({}, {}, {})", 
    460       new Object[] {rBytes, pixelSize, compCount}); 
     459      new Object[] {rowBytes, pixelSize, compCount}); 
    461460    int rawLen; 
    462461    byte[] buf;  // row raw bytes 
    463462    byte[] uBuf = null;  // row uncompressed data 
    464463    int[] uBufI = null;  // row uncompressed data - 16+ bit pixels 
    465     int bufSize; 
    466     int outBufSize; 
     464    int bufSize = rowBytes; 
     465    int outBufSize = getSizeX(); 
    467466    byte[] outBuf = null;  // used to expand pixel data 
    468467 
    469     boolean compressed = (rBytes >= 8) || (pixelSize == 32); 
    470  
    471     bufSize = rBytes; 
    472  
    473     outBufSize = getSizeX(); 
     468    boolean compressed = (rowBytes >= 8) || (pixelSize == 32); 
    474469 
    475470    // allocate buffers 
     
    496491      buf = new byte[bufSize]; 
    497492      for (int row=0; row<getSizeY(); row++) { 
    498         in.read(buf, 0, rBytes); 
     493        in.read(buf, 0, rowBytes); 
    499494 
    500495        switch (pixelSize) { 
     
    522517      buf = new byte[bufSize + 1 + bufSize / 128]; 
    523518      for (int row=0; row<getSizeY(); row++) { 
    524         if (rBytes > 250) rawLen = in.readShort(); 
     519        if (rowBytes > 250) rawLen = in.readShort(); 
    525520        else rawLen = in.read(); 
    526521 
  • trunk/components/bio-formats/src/loci/formats/in/PrairieReader.java

    r6058 r6156  
    2929import java.util.Vector; 
    3030 
     31import loci.common.DataTools; 
    3132import loci.common.DateTools; 
    3233import loci.common.Location; 
     
    240241      zt = 0; 
    241242 
    242       RandomAccessInputStream is = new RandomAccessInputStream(id); 
    243       byte[] b = new byte[(int) is.length()]; 
    244       is.read(b); 
    245       is.close(); 
     243      String xml = DataTools.readFile(id); 
    246244 
    247245      if (checkSuffix(id, XML_SUFFIX)) { 
     
    250248 
    251249      DefaultHandler handler = new PrairieHandler(); 
    252       XMLTools.parseXML(b, handler); 
     250      XMLTools.parseXML(xml, handler); 
    253251 
    254252      if (checkSuffix(id, XML_SUFFIX)) { 
     
    280278        MetadataTools.populatePixels(store, this); 
    281279 
    282         // link Instrument and Image 
    283         String instrumentID = MetadataTools.createLSID("Instrument", 0); 
    284         store.setInstrumentID(instrumentID, 0); 
    285         store.setImageInstrumentRef(instrumentID, 0); 
    286  
    287         store.setDimensionsPhysicalSizeX(pixelSizeX, 0, 0); 
    288         store.setDimensionsPhysicalSizeY(pixelSizeY, 0, 0); 
    289         for (int i=0; i<getSizeC(); i++) { 
    290           String gain = i < gains.size() ? gains.get(i) : null; 
    291           String offset = i < offsets.size() ? offsets.get(i) : null; 
    292  
    293           if (offset != null) { 
    294             store.setDetectorSettingsOffset(new Double(offset), 0, i); 
    295           } 
    296           if (gain != null) { 
    297             store.setDetectorSettingsGain(new Double(gain), 0, i); 
    298           } 
    299  
    300           // link DetectorSettings to an actual Detector 
    301           String detectorID = MetadataTools.createLSID("Detector", 0, i); 
    302           store.setDetectorID(detectorID, 0, i); 
    303           store.setDetectorSettingsDetector(detectorID, 0, i); 
    304           store.setDetectorType("Unknown", 0, i); 
    305         } 
    306  
    307280        if (date != null) { 
    308281          date = DateTools.formatDate(date, "MM/dd/yyyy h:mm:ss a"); 
     
    311284        else MetadataTools.setDefaultCreationDate(store, id, 0); 
    312285 
    313         /* TODO : check if this is correct 
    314         if (laserPower != null) { 
    315           store.setLaserPower(new Double(laserPower), 0, 0); 
    316         } 
    317         */ 
     286        if (getMetadataOptions().getMetadataLevel() == MetadataLevel.ALL) { 
     287          // link Instrument and Image 
     288          String instrumentID = MetadataTools.createLSID("Instrument", 0); 
     289          store.setInstrumentID(instrumentID, 0); 
     290          store.setImageInstrumentRef(instrumentID, 0); 
     291 
     292          store.setDimensionsPhysicalSizeX(pixelSizeX, 0, 0); 
     293          store.setDimensionsPhysicalSizeY(pixelSizeY, 0, 0); 
     294          for (int i=0; i<getSizeC(); i++) { 
     295            String gain = i < gains.size() ? gains.get(i) : null; 
     296            String offset = i < offsets.size() ? offsets.get(i) : null; 
     297 
     298            if (offset != null) { 
     299              store.setDetectorSettingsOffset(new Double(offset), 0, i); 
     300            } 
     301            if (gain != null) { 
     302              store.setDetectorSettingsGain(new Double(gain), 0, i); 
     303            } 
     304 
     305            // link DetectorSettings to an actual Detector 
     306            String detectorID = MetadataTools.createLSID("Detector", 0, i); 
     307            store.setDetectorID(detectorID, 0, i); 
     308            store.setDetectorSettingsDetector(detectorID, 0, i); 
     309            store.setDetectorType("Unknown", 0, i); 
     310          } 
     311 
     312          /* TODO : check if this is correct 
     313          if (laserPower != null) { 
     314            store.setLaserPower(new Double(laserPower), 0, 0); 
     315          } 
     316          */ 
     317        } 
    318318      } 
    319319 
     
    322322        File parent = file.getParentFile(); 
    323323        String[] listing = file.exists() ? parent.list() : 
    324           (String[]) Location.getIdMap().keySet().toArray(new String[0]); 
    325         for (int i=0; i<listing.length; i++) { 
    326           if ((!readXML && checkSuffix(listing[i], XML_SUFFIX)) || 
    327             (readXML && checkSuffix(listing[i], CFG_SUFFIX))) 
     324          Location.getIdMap().keySet().toArray(new String[0]); 
     325        for (String name : listing) { 
     326          if ((!readXML && checkSuffix(name, XML_SUFFIX)) || 
     327            (readXML && checkSuffix(name, CFG_SUFFIX))) 
    328328          { 
    329329            String dir = ""; 
     
    332332              if (!dir.endsWith(File.separator)) dir += File.separator; 
    333333            } 
    334             initFile(dir + listing[i]); 
     334            initFile(dir + name); 
    335335          } 
    336336        } 
     
    343343        LOGGER.info("Finding XML file"); 
    344344 
    345         Location file = new Location(id); 
    346         file = file.getAbsoluteFile(); 
     345        Location file = new Location(id).getAbsoluteFile(); 
    347346        Location parent = file.getParentFile(); 
    348347        String[] listing = parent.list(); 
    349         for (int i=0; i<listing.length; i++) { 
    350           if (checkSuffix(listing[i], PRAIRIE_SUFFIXES)) { 
    351             initFile(new Location(parent, listing[i]).getAbsolutePath()); 
     348        for (String name : listing) { 
     349          if (checkSuffix(name, PRAIRIE_SUFFIXES)) { 
     350            initFile(new Location(parent, name).getAbsolutePath()); 
    352351            return; 
    353352          } 
Note: See TracChangeset for help on using the changeset viewer.