Changeset 6188


Ignore:
Timestamp:
04/23/10 15:46:02 (10 years ago)
Author:
melissa
Message:
  • Updated a few more readers to respect MetadataOptions.
  • Fixed a couple of bugs in RandomAccessInputStream.findString(...) that caused the returned String to be truncated.
Location:
trunk/components
Files:
7 edited

Legend:

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

    r6118 r6188  
    424424 
    425425    LOGGER.info("Verifying DICOM format"); 
     426    MetadataLevel level = getMetadataOptions().getMetadataLevel(); 
    426427 
    427428    in.seek(128); 
    428429    if (in.readString(4).equals("DICM")) { 
    429       // header exists, so we'll read it 
    430       in.seek(0); 
    431       addSeriesMeta("Header information", in.readString(128)); 
    432       in.skipBytes(4); 
     430      if (level == MetadataLevel.ALL) { 
     431        // header exists, so we'll read it 
     432        in.seek(0); 
     433        addSeriesMeta("Header information", in.readString(128)); 
     434        in.skipBytes(4); 
     435      } 
    433436      location = 128; 
    434437    } 
     
    467470          else if (s.equals("1.2.8.10008.1.2.1.99")) isDeflate = true; 
    468471          else if (s.indexOf("1.2.4") > -1 || s.indexOf("1.2.5") > -1) { 
    469             throw new FormatException("Sorry, compressed DICOM images not " + 
    470               "supported"); 
     472            throw new FormatException("Sorry, compression type " + s + 
     473              " not supported"); 
    471474          } 
    472475          if (s.indexOf("1.2.840.10008.1.2.2") >= 0) { 
     
    482485        case SAMPLES_PER_PIXEL: 
    483486          addInfo(tag, in.readShort()); 
    484           break; 
    485         case PHOTOMETRIC_INTERPRETATION: 
    486           addInfo(tag, in.readString(elementLength)); 
    487487          break; 
    488488        case PLANAR_CONFIGURATION: 
     
    501501          addInfo(tag, getSizeX()); 
    502502          break; 
     503        case PHOTOMETRIC_INTERPRETATION: 
    503504        case PIXEL_SPACING: 
    504           addInfo(tag, in.readString(elementLength)); 
    505           break; 
    506505        case SLICE_SPACING: 
     506        case RESCALE_INTERCEPT: 
     507        case WINDOW_CENTER: 
     508        case RESCALE_SLOPE: 
    507509          addInfo(tag, in.readString(elementLength)); 
    508510          break; 
     
    516518          signed = ss == 1; 
    517519          addInfo(tag, ss); 
    518           break; 
    519         case RESCALE_INTERCEPT: 
    520           addInfo(tag, in.readString(elementLength)); 
    521520          break; 
    522521        case 537262910: 
     
    533532          } 
    534533          addInfo(tag, t); 
    535           break; 
    536         case WINDOW_CENTER: 
    537         case RESCALE_SLOPE: 
    538           addInfo(tag, in.readString(elementLength)); 
    539534          break; 
    540535        case PIXEL_DATA: 
     
    647642    } 
    648643 
    649     LOGGER.info("Building file list"); 
    650  
    651     if (fileList == null && originalInstance != null && originalDate != null && 
    652       originalTime != null && isGroupFiles()) 
    653     { 
    654       currentId = new Location(currentId).getAbsolutePath(); 
    655       fileList = new Hashtable<Integer, Vector<String>>(); 
    656       Integer s = new Integer(originalSeries); 
    657       fileList.put(s, new Vector<String>()); 
    658  
    659       int instanceNumber = Integer.parseInt(originalInstance) - 1; 
    660       if (instanceNumber == 0) fileList.get(s).add(currentId); 
    661       else { 
    662         while (instanceNumber > fileList.get(s).size()) { 
    663           fileList.get(s).add(null); 
    664         } 
    665         fileList.get(s).add(currentId); 
    666       } 
    667  
    668       // look for matching files in the current directory 
    669       Location currentFile = new Location(currentId).getAbsoluteFile(); 
    670       Location directory = currentFile.getParentFile(); 
    671       scanDirectory(directory, false); 
    672  
    673       // move up a directory and look for other directories that 
    674       // could contain matching files 
    675  
    676       directory = directory.getParentFile(); 
    677       String[] subdirs = directory.list(true); 
    678       if (subdirs != null) { 
    679         for (String subdir : subdirs) { 
    680           Location f = new Location(directory, subdir).getAbsoluteFile(); 
    681           if (!f.isDirectory()) continue; 
    682           scanDirectory(f, true); 
    683         } 
    684       } 
    685  
    686       Integer[] keys = fileList.keySet().toArray(new Integer[0]); 
    687       Arrays.sort(keys); 
    688       for (Integer key : keys) { 
    689         for (int j=0; j<fileList.get(key).size(); j++) { 
    690           if (fileList.get(key).get(j) == null) { 
    691             fileList.get(key).remove(j); 
    692             j--; 
    693           } 
    694         } 
    695       } 
    696     } 
    697     else if (fileList == null) { 
    698       fileList = new Hashtable<Integer, Vector<String>>(); 
    699       fileList.put(new Integer(0), new Vector<String>()); 
    700       fileList.get(0).add(currentId); 
    701     } 
     644    makeFileList(); 
    702645 
    703646    LOGGER.info("Populating metadata"); 
     
    746689      if (stamp != null) store.setImageCreationDate(stamp, i); 
    747690      else MetadataTools.setDefaultCreationDate(store, id, i); 
    748       store.setImageDescription(imageType, i); 
    749691      store.setImageName("Series " + i, i); 
    750  
    751       if (pixelSizeX != null) { 
    752         store.setDimensionsPhysicalSizeX(new Double(pixelSizeX), i, 0); 
    753       } 
    754       if (pixelSizeY != null) { 
    755         store.setDimensionsPhysicalSizeY(new Double(pixelSizeY), i, 0); 
    756       } 
    757     } 
    758  
    759     // CTR CHECK 
    760     //store.setInstrumentManufacturer((String) getMeta("Manufacturer"), 0); 
    761     //store.setInstrumentModel((String) 
    762     //  getMeta("Manufacturer's Model Name"), 0); 
     692    } 
     693 
     694    if (level == MetadataLevel.ALL) { 
     695      for (int i=0; i<core.length; i++) { 
     696        store.setImageDescription(imageType, i); 
     697 
     698        if (pixelSizeX != null) { 
     699          store.setDimensionsPhysicalSizeX(new Double(pixelSizeX), i, 0); 
     700        } 
     701        if (pixelSizeY != null) { 
     702          store.setDimensionsPhysicalSizeY(new Double(pixelSizeY), i, 0); 
     703        } 
     704      } 
     705    } 
    763706  } 
    764707 
     
    773716      if (info.equals("")) info = oldValue == null ? "" : oldValue.trim(); 
    774717 
    775       String key = TYPES.get(new Integer(tag)); 
     718      String key = TYPES.get(tag); 
    776719      if (key == null) { 
    777         key = Integer.toHexString((tag >> 16) & 0xffff) + "," + 
    778           Integer.toHexString(tag & 0xffff); 
     720        key = formatTag(tag); 
    779721      } 
    780722      if (key.equals("Samples per pixel")) { 
     
    10611003  } 
    10621004 
     1005  private void makeFileList() throws FormatException, IOException { 
     1006    LOGGER.info("Building file list"); 
     1007 
     1008    if (fileList == null && originalInstance != null && originalDate != null && 
     1009      originalTime != null && isGroupFiles()) 
     1010    { 
     1011      currentId = new Location(currentId).getAbsolutePath(); 
     1012      fileList = new Hashtable<Integer, Vector<String>>(); 
     1013      Integer s = new Integer(originalSeries); 
     1014      fileList.put(s, new Vector<String>()); 
     1015 
     1016      int instanceNumber = Integer.parseInt(originalInstance) - 1; 
     1017      if (instanceNumber == 0) fileList.get(s).add(currentId); 
     1018      else { 
     1019        while (instanceNumber > fileList.get(s).size()) { 
     1020          fileList.get(s).add(null); 
     1021        } 
     1022        fileList.get(s).add(currentId); 
     1023      } 
     1024 
     1025      // look for matching files in the current directory 
     1026      Location currentFile = new Location(currentId).getAbsoluteFile(); 
     1027      Location directory = currentFile.getParentFile(); 
     1028      scanDirectory(directory, false); 
     1029 
     1030      // move up a directory and look for other directories that 
     1031      // could contain matching files 
     1032 
     1033      directory = directory.getParentFile(); 
     1034      String[] subdirs = directory.list(true); 
     1035      if (subdirs != null) { 
     1036        for (String subdir : subdirs) { 
     1037          Location f = new Location(directory, subdir).getAbsoluteFile(); 
     1038          if (!f.isDirectory()) continue; 
     1039          scanDirectory(f, true); 
     1040        } 
     1041      } 
     1042 
     1043      Integer[] keys = fileList.keySet().toArray(new Integer[0]); 
     1044      Arrays.sort(keys); 
     1045      for (Integer key : keys) { 
     1046        for (int j=0; j<fileList.get(key).size(); j++) { 
     1047          if (fileList.get(key).get(j) == null) { 
     1048            fileList.get(key).remove(j); 
     1049            j--; 
     1050          } 
     1051        } 
     1052      } 
     1053    } 
     1054    else if (fileList == null) { 
     1055      fileList = new Hashtable<Integer, Vector<String>>(); 
     1056      fileList.put(new Integer(0), new Vector<String>()); 
     1057      fileList.get(0).add(currentId); 
     1058    } 
     1059  } 
     1060 
    10631061  // -- Utility methods -- 
    10641062 
     
    10781076    if (files == null) return; 
    10791077    Arrays.sort(files); 
    1080     for (int i=0; i<files.length; i++) { 
    1081       String file = new Location(dir, files[i]).getAbsolutePath(); 
     1078    for (String f : files) { 
     1079      String file = new Location(dir, f).getAbsolutePath(); 
    10821080      LOGGER.debug("Checking file {}", file); 
    1083       if (!files[i].equals(currentId) && !file.equals(currentId) && 
     1081      if (!f.equals(currentId) && !file.equals(currentId) && 
    10841082        isThisType(file) && Arrays.binarySearch(patternFiles, file) >= 0) 
    10851083      { 
     
    10961094  { 
    10971095    RandomAccessInputStream stream = new RandomAccessInputStream(file); 
    1098     if (!isThisType(stream)) return; 
     1096    if (!isThisType(stream)) { 
     1097      stream.close(); 
     1098      return; 
     1099    } 
    10991100    stream.order(true); 
    11001101 
     
    11471148    catch (NumberFormatException e) { } 
    11481149 
    1149     if (date.equals(originalDate) && (Math.abs(stamp - timestamp) < 150)) 
    1150     { 
     1150    if (date.equals(originalDate) && (Math.abs(stamp - timestamp) < 150)) { 
    11511151      int position = Integer.parseInt(instance) - 1; 
    11521152      if (position < 0) position = 0; 
  • trunk/components/bio-formats/src/loci/formats/in/MINCReader.java

    r6026 r6188  
    109109    } 
    110110 
    111     Vector<String> variableList = netcdf.getVariableList(); 
     111    if (getMetadataOptions().getMetadataLevel() == MetadataLevel.ALL) { 
     112      Vector<String> variableList = netcdf.getVariableList(); 
    112113 
    113     for (int i=0; i<variableList.size(); i++) { 
    114       String variable = (String) variableList.get(i); 
    115       Hashtable<String, Object> attributes = netcdf.getVariableAttributes(variable); 
    116       String[] keys = attributes.keySet().toArray(new String[0]); 
    117       Arrays.sort(keys); 
     114      for (String variable : variableList) { 
     115        Hashtable<String, Object> attributes = 
     116          netcdf.getVariableAttributes(variable); 
     117        String[] keys = attributes.keySet().toArray(new String[0]); 
     118        Arrays.sort(keys); 
    118119 
    119       for (int j=0; j<keys.length; j++) { 
    120         if (attributes.get(keys[j]) instanceof Object[]) { 
    121           StringBuffer sb = new StringBuffer(); 
    122           Object[] o = (Object[]) attributes.get(keys[j]); 
    123           for (int q=0; q<o.length; q++) { 
    124             sb.append(o[q].toString()); 
     120        for (String key : keys) { 
     121          if (attributes.get(key) instanceof Object[]) { 
     122            StringBuffer sb = new StringBuffer(); 
     123            Object[] o = (Object[]) attributes.get(key); 
     124            for (Object q : o) { 
     125              sb.append(q.toString()); 
     126            } 
     127            addGlobalMeta(variable + " " + key, sb.toString()); 
    125128          } 
    126           addGlobalMeta(variable + " " + keys[j], sb.toString()); 
    127129        } 
    128130      } 
     
    154156    MetadataTools.populatePixels(store, this); 
    155157    MetadataTools.setDefaultCreationDate(store, id, 0); 
    156     store.setImageDescription(netcdf.getAttributeValue("/history"), 0); 
     158 
     159    if (getMetadataOptions().getMetadataLevel() == MetadataLevel.ALL) { 
     160      store.setImageDescription(netcdf.getAttributeValue("/history"), 0); 
     161    } 
    157162  } 
    158163 
  • trunk/components/bio-formats/src/loci/formats/in/MetamorphTiffReader.java

    r6068 r6188  
    3535import loci.formats.meta.FilterMetadata; 
    3636import loci.formats.meta.MetadataStore; 
     37import loci.formats.tiff.IFD; 
    3738import loci.formats.tiff.TiffParser; 
    3839 
     
    4950 */ 
    5051public class MetamorphTiffReader extends BaseTiffReader { 
     52 
     53  // -- Constants -- 
     54 
     55  private static final String DATE_FORMAT = "yyyyMMdd HH:mm:ss.SSS"; 
    5156 
    5257  // -- Constructor -- 
     
    7681    super.initFile(id); 
    7782 
    78     String[] comments = new String[ifds.size()]; 
    79  
    8083    // parse XML comment 
    8184 
    8285    MetamorphHandler handler = new MetamorphHandler(getGlobalMetadata()); 
    83     for (int i=0; i<comments.length; i++) { 
    84       comments[i] = ifds.get(i).getComment(); 
    85       XMLTools.parseXML(comments[i], handler); 
     86    for (IFD ifd : ifds) { 
     87      XMLTools.parseXML(ifd.getComment(), handler); 
    8688    } 
    8789 
     
    9698 
    9799    Vector<Integer> uniqueC = new Vector<Integer>(); 
    98     for (int i=0; i<wavelengths.size(); i++) { 
    99       Integer c = wavelengths.get(i); 
     100    for (Integer c : wavelengths) { 
    100101      if (!uniqueC.contains(c)) { 
    101102        uniqueC.add(c); 
     
    107108 
    108109    Vector<Double> uniqueZ = new Vector<Double>(); 
    109     for (int i=0; i<zPositions.size(); i++) { 
    110       Double z = zPositions.get(i); 
     110    for (Double z : zPositions) { 
    111111      if (!uniqueZ.contains(z)) uniqueZ.add(z); 
    112112    } 
     
    118118    MetadataTools.populatePixels(store, this, true); 
    119119    store.setImageName(handler.getImageName(), 0); 
    120     store.setImageDescription("", 0); 
    121  
    122     String parse = "yyyyMMdd HH:mm:ss.SSS"; 
    123  
    124     for (int i=0; i<timestamps.size(); i++) { 
    125       long timestamp = DateTools.getTime(timestamps.get(i), parse); 
    126       addGlobalMeta("timestamp " + i, timestamp); 
    127     } 
    128     for (int i=0; i<exposures.size(); i++) { 
    129       addGlobalMeta("exposure time " + i + " (ms)", 
    130         exposures.get(i).floatValue() * 1000); 
    131     } 
    132  
    133     long startDate = 0; 
    134     if (timestamps.size() > 0) { 
    135       startDate = DateTools.getTime(timestamps.get(0), parse); 
    136     } 
    137  
    138     for (int i=0; i<getImageCount(); i++) { 
    139       int[] coords = getZCTCoords(i); 
    140       if (coords[2] < timestamps.size()) { 
    141         String stamp = timestamps.get(coords[2]); 
    142         long ms = DateTools.getTime(stamp, parse); 
    143         store.setPlaneTimingDeltaT((ms - startDate) / 1000.0, 0, 0, i); 
    144       } 
    145       if (i < exposures.size()) { 
    146         store.setPlaneTimingExposureTime(exposures.get(i), 0, 0, i); 
    147       } 
    148     } 
    149120 
    150121    String date = 
     
    152123    store.setImageCreationDate(date, 0); 
    153124 
    154     store.setImagingEnvironmentTemperature( 
    155       handler.getTemperature(), 0); 
    156     store.setDimensionsPhysicalSizeX(handler.getPixelSizeX(), 0, 0); 
    157     store.setDimensionsPhysicalSizeY(handler.getPixelSizeY(), 0, 0); 
     125    if (getMetadataOptions().getMetadataLevel() == MetadataLevel.ALL) { 
     126      for (int i=0; i<timestamps.size(); i++) { 
     127        long timestamp = DateTools.getTime(timestamps.get(i), DATE_FORMAT); 
     128        addGlobalMeta("timestamp " + i, timestamp); 
     129      } 
     130      for (int i=0; i<exposures.size(); i++) { 
     131        addGlobalMeta("exposure time " + i + " (ms)", 
     132          exposures.get(i).floatValue() * 1000); 
     133      } 
     134 
     135      long startDate = 0; 
     136      if (timestamps.size() > 0) { 
     137        startDate = DateTools.getTime(timestamps.get(0), DATE_FORMAT); 
     138      } 
     139 
     140      store.setImageDescription("", 0); 
     141 
     142      for (int i=0; i<getImageCount(); i++) { 
     143        int[] coords = getZCTCoords(i); 
     144        if (coords[2] < timestamps.size()) { 
     145          String stamp = timestamps.get(coords[2]); 
     146          long ms = DateTools.getTime(stamp, DATE_FORMAT); 
     147          store.setPlaneTimingDeltaT((ms - startDate) / 1000.0, 0, 0, i); 
     148        } 
     149        if (i < exposures.size()) { 
     150          store.setPlaneTimingExposureTime(exposures.get(i), 0, 0, i); 
     151        } 
     152      } 
     153 
     154      store.setImagingEnvironmentTemperature(handler.getTemperature(), 0); 
     155      store.setDimensionsPhysicalSizeX(handler.getPixelSizeX(), 0, 0); 
     156      store.setDimensionsPhysicalSizeY(handler.getPixelSizeY(), 0, 0); 
     157    } 
    158158  } 
    159159} 
  • trunk/components/bio-formats/src/loci/formats/in/MinimalTiffReader.java

    r6034 r6188  
    286286    in = new RandomAccessInputStream(id); 
    287287    tiffParser = new TiffParser(in); 
    288     boolean little = in.readShort() == 0x4949; 
     288    boolean little = tiffParser.checkHeader().booleanValue(); 
    289289    in.order(little); 
    290290 
  • trunk/components/bio-formats/src/loci/formats/in/NRRDReader.java

    r5624 r6188  
    162162    helper = new ImageReader(); 
    163163 
    164     boolean finished = false; 
    165     String line, key, v; 
     164    String key, v; 
    166165 
    167166    int numDimensions = 0; 
     
    174173    core[0].dimensionOrder = "XYCZT"; 
    175174 
    176     while (!finished) { 
    177       line = in.readLine().trim(); 
    178       if (!line.startsWith("#") && line.length() > 0 && 
    179         !line.startsWith("NRRD")) 
    180       { 
     175    String line = in.readLine(); 
     176    while (line != null && line.length() > 0) { 
     177      if (!line.startsWith("#") && !line.startsWith("NRRD")) { 
    181178        // parse key/value pair 
    182179        key = line.substring(0, line.indexOf(":")).trim(); 
     
    240237      } 
    241238 
    242       if ((line.length() == 0 && dataFile == null) || line == null) { 
    243         finished = true; 
    244       } 
    245       if (dataFile != null && (in.length() - in.getFilePointer() < 2)) { 
    246         finished = true; 
    247       } 
     239      line = in.readLine(); 
     240      if (line != null) line = line.trim(); 
    248241    } 
    249242 
     
    254247    if (dataFile == null) offset = in.getFilePointer(); 
    255248    else { 
    256       File f = new File(currentId); 
    257       if (f.exists() && f.getParentFile() != null) { 
    258         dataFile = 
    259           f.getParentFile().getAbsolutePath() + File.separator + dataFile; 
    260       } 
     249      offset = 0; 
     250      Location f = new Location(currentId).getAbsoluteFile(); 
     251      Location parent = f.getParentFile(); 
     252      if (f.exists() && parent != null) { 
     253        dataFile = new Location(parent, dataFile).getAbsolutePath(); 
     254      } 
     255      // calling setId on dataFile will cause this reader to pick up 
     256      // the data file 
    261257      String name = dataFile.substring(dataFile.lastIndexOf(File.separator)); 
    262258      Location.mapId(name, dataFile); 
     
    276272    MetadataTools.setDefaultCreationDate(store, id, 0); 
    277273 
    278     for (int i=0; i<pixelSizes.length; i++) { 
    279       Double d = new Double(pixelSizes[i].trim()); 
    280       if (i == 0) store.setDimensionsPhysicalSizeX(d, 0, 0); 
    281       else if (i == 1) store.setDimensionsPhysicalSizeY(d, 0, 0); 
    282       else if (i == 2) store.setDimensionsPhysicalSizeZ(d, 0, 0); 
     274    if (getMetadataOptions().getMetadataLevel() == MetadataLevel.ALL) { 
     275      for (int i=0; i<pixelSizes.length; i++) { 
     276        Double d = new Double(pixelSizes[i].trim()); 
     277        if (i == 0) store.setDimensionsPhysicalSizeX(d, 0, 0); 
     278        else if (i == 1) store.setDimensionsPhysicalSizeY(d, 0, 0); 
     279        else if (i == 2) store.setDimensionsPhysicalSizeZ(d, 0, 0); 
     280      } 
    283281    } 
    284282  } 
  • trunk/components/bio-formats/src/loci/formats/in/NiftiReader.java

    r6026 r6188  
    7171  private String pixelsFilename; 
    7272  private short nDimensions; 
     73  private String description; 
     74  private double voxelWidth, voxelHeight, sliceThickness, deltaT; 
    7375 
    7476  // -- Constructor -- 
     
    9193  /* @see loci.formats.IFormatReader#isThisType(String, boolean) */ 
    9294  public boolean isThisType(String name, boolean open) { 
    93     int dot = name.lastIndexOf(".") + 1; 
    94     if (dot == 0) dot = name.length(); 
    95     String extension = name.substring(dot, name.length()).toLowerCase(); 
    96     if (extension.equals("nii")) return true; 
    97     String headerFile = name.substring(0, dot - 1) + ".hdr"; 
     95    if (checkSuffix(name, "nii")) return true; 
     96    int dot = name.lastIndexOf("."); 
     97    if (dot == 0) dot = name.length() - 1; 
     98    String headerFile = name.substring(0, dot) + ".hdr"; 
    9899    try { 
    99100      RandomAccessInputStream header = new RandomAccessInputStream(headerFile); 
     
    164165      pixelsFilename = null; 
    165166      nDimensions = 0; 
     167      description = null; 
     168      voxelWidth = voxelHeight = sliceThickness = deltaT = 0d; 
    166169    } 
    167170  } 
     
    188191    short check = in.readShort(); 
    189192    boolean little = check < 1 || check > 7; 
    190     in.seek(0); 
     193    in.seek(40); 
    191194 
    192195    if (id.endsWith(".hdr")) { 
     
    204207    LOGGER.info("Reading header"); 
    205208 
    206     int fileSize = in.readInt(); 
    207  
    208     in.skipBytes(35); 
    209  
     209    nDimensions = in.readShort(); 
     210    core[0].sizeX = in.readShort(); 
     211    core[0].sizeY = in.readShort(); 
     212    core[0].sizeZ = in.readShort(); 
     213    core[0].sizeT = in.readShort(); 
     214 
     215    in.skipBytes(20); 
     216    short dataType = in.readShort(); 
     217    in.skipBytes(36); 
     218    pixelOffset = (int) in.readFloat(); 
     219 
     220    if (getMetadataOptions().getMetadataLevel() == MetadataLevel.ALL) { 
     221      populateExtendedMetadata(); 
     222    } 
     223 
     224    LOGGER.info("Populating core metadata"); 
     225 
     226    core[0].sizeC = 1; 
     227    if (getSizeZ() == 0) core[0].sizeZ = 1; 
     228    if (getSizeT() == 0) core[0].sizeT = 1; 
     229 
     230    core[0].imageCount = getSizeZ() * getSizeT(); 
     231    core[0].indexed = false; 
     232    core[0].dimensionOrder = "XYCZT"; 
     233 
     234    populatePixelType(dataType); 
     235    core[0].rgb = getSizeC() > 1; 
     236    core[0].interleaved = isRGB(); 
     237 
     238    LOGGER.info("Populating MetadataStore"); 
     239 
     240    MetadataStore store = 
     241      new FilterMetadata(getMetadataStore(), isMetadataFiltered()); 
     242    MetadataTools.populatePixels(store, this); 
     243 
     244    if (getMetadataOptions().getMetadataLevel() == MetadataLevel.ALL) { 
     245      store.setImageDescription(description, 0); 
     246      store.setDimensionsPhysicalSizeX(new Double(voxelWidth), 0, 0); 
     247      store.setDimensionsPhysicalSizeY(new Double(voxelHeight), 0, 0); 
     248      store.setDimensionsPhysicalSizeZ(new Double(sliceThickness), 0, 0); 
     249      store.setDimensionsTimeIncrement(new Double(deltaT), 0, 0); 
     250    } 
     251  } 
     252 
     253  // -- Helper methods -- 
     254 
     255  private void populatePixelType(int dataType) throws FormatException { 
     256    switch (dataType) { 
     257      case 1: 
     258      case 2: 
     259        core[0].pixelType = FormatTools.UINT8; 
     260        break; 
     261      case 4: 
     262        core[0].pixelType = FormatTools.INT16; 
     263        break; 
     264      case 8: 
     265        core[0].pixelType = FormatTools.INT32; 
     266        break; 
     267      case 16: 
     268        core[0].pixelType = FormatTools.FLOAT; 
     269        break; 
     270      case 64: 
     271        core[0].pixelType = FormatTools.DOUBLE; 
     272        break; 
     273      case 128: 
     274        core[0].pixelType = FormatTools.UINT8; 
     275        core[0].sizeC = 3; 
     276      case 256: 
     277        core[0].pixelType = FormatTools.INT8; 
     278        break; 
     279      case 512: 
     280        core[0].pixelType = FormatTools.UINT16; 
     281        break; 
     282      case 768: 
     283        core[0].pixelType = FormatTools.UINT32; 
     284        break; 
     285      case 2304: 
     286        core[0].pixelType = FormatTools.UINT8; 
     287        core[0].sizeC = 4; 
     288      default: 
     289        throw new FormatException("Unsupported data type: " + dataType); 
     290    } 
     291  } 
     292 
     293  private void populateExtendedMetadata() throws IOException { 
     294    in.seek(40); 
    210295    char sliceOrdering = in.readChar(); 
    211  
    212     nDimensions = in.readShort(); 
    213     short x = in.readShort(); 
    214     short y = in.readShort(); 
    215     short z = in.readShort(); 
    216     short t = in.readShort(); 
     296    in.skipBytes(8); 
    217297    short dim5 = in.readShort(); 
    218298    short dim6 = in.readShort(); 
     
    225305    short intentCode = in.readShort(); 
    226306    short dataType = in.readShort(); 
     307 
    227308    short bitpix = in.readShort(); 
    228309    short sliceStart = in.readShort(); 
     
    230311    in.skipBytes(4); 
    231312 
    232     float voxelWidth = in.readFloat(); 
    233     float voxelHeight = in.readFloat(); 
    234     float sliceThickness = in.readFloat(); 
    235     float deltaT = in.readFloat(); 
    236     in.skipBytes(12); 
    237  
    238     pixelOffset = (int) in.readFloat(); 
     313    voxelWidth = in.readFloat(); 
     314    voxelHeight = in.readFloat(); 
     315    sliceThickness = in.readFloat(); 
     316    deltaT = in.readFloat(); 
     317    in.skipBytes(16); 
     318 
    239319    float scaleSlope = in.readFloat(); 
    240320    float scaleIntercept = in.readFloat(); 
     
    283363    in.skipBytes(8); 
    284364 
    285     String description = in.readString(80); 
     365    description = in.readString(80); 
    286366    in.skipBytes(24); 
    287367 
     
    305385    String intentName = in.readString(16); 
    306386 
    307     in.skipBytes(4); 
    308  
    309     if (in.getFilePointer() < in.length()) { 
     387    if (in.getFilePointer() + 4 < in.length()) { 
     388      in.skipBytes(4); 
    310389      byte extension = in.readByte(); 
    311390      in.skipBytes(3); 
     
    342421    addGlobalMeta("Slice Ordering", sliceOrdering); 
    343422    addGlobalMeta("Number of dimensions", nDimensions); 
    344     addGlobalMeta("Width", x); 
    345     addGlobalMeta("Height", y); 
    346     addGlobalMeta("Number of Z slices", z); 
    347     addGlobalMeta("Number of time points", t); 
     423    addGlobalMeta("Width", getSizeX()); 
     424    addGlobalMeta("Height", getSizeY()); 
     425    addGlobalMeta("Number of Z slices", getSizeZ()); 
     426    addGlobalMeta("Number of time points", getSizeT()); 
    348427    addGlobalMeta("Dimension 5", dim5); 
    349428    addGlobalMeta("Dimension 6", dim6); 
     
    376455    addGlobalMeta("Quaternion y parameter", quaternionY); 
    377456    addGlobalMeta("Quaternion z parameter", quaternionZ); 
    378  
    379     LOGGER.info("Populating core metadata"); 
    380  
    381     core[0].sizeX = x; 
    382     core[0].sizeY = y; 
    383     core[0].sizeZ = z; 
    384     core[0].sizeT = t; 
    385     core[0].sizeC = 1; 
    386     if (getSizeZ() == 0) core[0].sizeZ = 1; 
    387     if (getSizeT() == 0) core[0].sizeT = 1; 
    388  
    389     core[0].imageCount = getSizeZ() * getSizeT(); 
    390     core[0].rgb = false; 
    391     core[0].interleaved = false; 
    392     core[0].indexed = false; 
    393     core[0].dimensionOrder = "XYZTC"; 
    394  
    395     switch (dataType) { 
    396       case 1: 
    397       case 2: 
    398         core[0].pixelType = FormatTools.UINT8; 
    399         break; 
    400       case 4: 
    401         core[0].pixelType = FormatTools.INT16; 
    402         break; 
    403       case 8: 
    404         core[0].pixelType = FormatTools.INT32; 
    405         break; 
    406       case 16: 
    407         core[0].pixelType = FormatTools.FLOAT; 
    408         break; 
    409       case 64: 
    410         core[0].pixelType = FormatTools.DOUBLE; 
    411         break; 
    412       case 128: 
    413         core[0].pixelType = FormatTools.UINT8; 
    414         core[0].sizeC = 3; 
    415         core[0].rgb = true; 
    416         core[0].interleaved = true; 
    417         core[0].dimensionOrder = "XYCZT"; 
    418       case 256: 
    419         core[0].pixelType = FormatTools.INT8; 
    420         break; 
    421       case 512: 
    422         core[0].pixelType = FormatTools.UINT16; 
    423         break; 
    424       case 768: 
    425         core[0].pixelType = FormatTools.UINT32; 
    426         break; 
    427       case 2304: 
    428         core[0].pixelType = FormatTools.UINT8; 
    429         core[0].sizeC = 4; 
    430         core[0].rgb = true; 
    431         core[0].interleaved = true; 
    432         core[0].dimensionOrder = "XYCZT"; 
    433       default: 
    434         throw new FormatException("Unsupported data type: " + dataType); 
    435     } 
    436  
    437     LOGGER.info("Populating MetadataStore"); 
    438  
    439     MetadataStore store = 
    440       new FilterMetadata(getMetadataStore(), isMetadataFiltered()); 
    441     MetadataTools.populatePixels(store, this); 
    442  
    443     store.setImageDescription(description, 0); 
    444  
    445     store.setDimensionsPhysicalSizeX(new Double(voxelWidth), 0, 0); 
    446     store.setDimensionsPhysicalSizeY(new Double(voxelHeight), 0, 0); 
    447     store.setDimensionsPhysicalSizeZ(new Double(sliceThickness), 0, 0); 
    448     store.setDimensionsTimeIncrement(new Double(deltaT), 0, 0); 
    449457  } 
    450458 
  • trunk/components/common/src/loci/common/RandomAccessInputStream.java

    r6155 r6188  
    220220 
    221221    // ensure that we don't try to read more bytes than are in the file 
    222     if (blockSize > maxLen / 2) { 
    223       blockSize = (int) (maxLen / 2); 
     222    if (blockSize > maxLen) { 
     223      blockSize = (int) maxLen; 
    224224    } 
    225225 
     
    227227    char[] buf = new char[blockSize]; 
    228228    long loc = 0; 
    229     while (loc < maxLen && getFilePointer() < length()) { 
     229    while (loc < maxLen && getFilePointer() < length() - 1) { 
    230230      // if we're not saving the string, drop any old, unnecessary output 
    231231      if (!saveString) { 
     
    249249      // check output, returning smallest possible string 
    250250      int min = Integer.MAX_VALUE, tagLen = 0; 
    251       for (int t=0; t<terminators.length; t++) { 
    252         int len = terminators[t].length(); 
     251      for (String t : terminators) { 
     252        int len = t.length(); 
    253253        int start = (int) (loc - bytesDropped - len); 
    254         int value = out.indexOf(terminators[t], start < 0 ? 0 : start); 
     254        int value = out.indexOf(t, start < 0 ? 0 : start); 
    255255        if (value >= 0 && value < min) { 
    256256          match = true; 
     
    277277    // no match 
    278278    if (tooLong) throw new IOException("Maximum search length reached."); 
    279     return null; 
     279    return saveString ? out.toString() : null; 
    280280  } 
    281281 
Note: See TracChangeset for help on using the changeset viewer.