Changeset 6910


Ignore:
Timestamp:
09/09/10 16:02:34 (9 years ago)
Author:
callan
Message:

Merging commits (r6690, r6692, r6735, r6784, r6786) from Trunk with addition of and changes for CellWorxReader. Left out TillVisionReader changes from r6786.

Location:
branches/4.2
Files:
23 edited
1 copied

Legend:

Unmodified
Added
Removed
  • branches/4.2

  • branches/4.2/components/bio-formats/src/loci/formats/FormatReader.java

    r6663 r6910  
    238238    key = key.trim(); 
    239239 
    240     boolean string = value instanceof String; 
     240    boolean string = value instanceof String || value instanceof Character; 
    241241    boolean simple = string || 
    242242      value instanceof Number || 
    243       value instanceof Boolean || 
    244       value instanceof Character; 
     243      value instanceof Boolean; 
    245244 
    246245    // string value, if passed in value is a string 
    247     String val = string ? (String) value : null; 
    248  
    249     if (filterMetadata) { 
     246    String val = string ? String.valueOf(value) : null; 
     247 
     248    if (filterMetadata || 
     249      (saveOriginalMetadata && (getMetadataStore() instanceof OMEXMLMetadata))) 
     250    { 
    250251      // filter out complex data types 
    251252      if (!simple) return; 
  • branches/4.2/components/bio-formats/src/loci/formats/in

  • branches/4.2/components/bio-formats/src/loci/formats/in/APLReader.java

    r6663 r6910  
    4949public class APLReader extends FormatReader { 
    5050 
     51  // -- Constants -- 
     52 
     53  private static final String[] METADATA_SUFFIXES = 
     54    new String[] {"apl", "tnb", "mtb" }; 
     55 
    5156  // -- Fields -- 
    5257 
     
    6065  /** Constructs a new APL reader. */ 
    6166  public APLReader() { 
    62     super("Olympus APL", new String[] {"apl", "tnb", "mtb"}); 
     67    super("Olympus APL", new String[] {"apl", "tnb", "mtb", "tif"}); 
    6368    domains = new String[] {FormatTools.LM_DOMAIN}; 
    6469    hasCompanionFiles = true; 
     70    suffixSufficient = false; 
    6571  } 
    6672 
    6773  // -- IFormatReader API methods -- 
     74 
     75  /* @see loci.formats.IFormatReader#isThisType(String, boolean) */ 
     76  public boolean isThisType(String name, boolean open) { 
     77    if (checkSuffix(name, METADATA_SUFFIXES)) return true; 
     78    if (checkSuffix(name, "tif")) { 
     79      Location file = new Location(name).getAbsoluteFile(); 
     80      Location parent = file.getParentFile(); 
     81      if (parent != null) { 
     82        parent = parent.getParentFile(); 
     83        if (parent != null) { 
     84          String[] list = parent.list(true); 
     85          for (String f : list) { 
     86            if (checkSuffix(f, "mtb")) return true; 
     87          } 
     88        } 
     89      } 
     90    } 
     91    return false; 
     92  } 
    6893 
    6994  /* @see loci.formats.IFormatReader#isSingleFile(String) */ 
     
    77102    Vector<String> files = new Vector<String>(); 
    78103    files.addAll(used); 
    79     if (getSeries() < xmlFiles.length) files.add(xmlFiles[getSeries()]); 
    80     if (!noPixels && getSeries() < tiffFiles.length) { 
     104    if (getSeries() < xmlFiles.length && 
     105      new Location(xmlFiles[getSeries()]).exists()) 
     106    { 
     107      files.add(xmlFiles[getSeries()]); 
     108    } 
     109    if (!noPixels && getSeries() < tiffFiles.length && 
     110      new Location(tiffFiles[getSeries()]).exists()) 
     111    { 
    81112      files.add(tiffFiles[getSeries()]); 
    82113    } 
     
    121152 
    122153    // find the corresponding .mtb file 
    123     String name = id.toLowerCase(); 
    124     if (!name.endsWith(".mtb")) { 
    125       int separator = id.lastIndexOf(File.separator); 
    126       if (separator < 0) separator = 0; 
    127       int underscore = id.lastIndexOf("_"); 
    128       if (underscore < separator) underscore = id.lastIndexOf("."); 
    129       String mtbFile = id.substring(0, underscore) + "_d.mtb"; 
    130       if (!new Location(mtbFile).exists()) { 
    131         throw new FormatException(".mtb file not found"); 
    132       } 
    133       currentId = new Location(mtbFile).getAbsolutePath(); 
     154    if (!checkSuffix(id, "mtb")) { 
     155      if (checkSuffix(id, METADATA_SUFFIXES)) { 
     156        int separator = id.lastIndexOf(File.separator); 
     157        if (separator < 0) separator = 0; 
     158        int underscore = id.lastIndexOf("_"); 
     159        if (underscore < separator) underscore = id.lastIndexOf("."); 
     160        String mtbFile = id.substring(0, underscore) + "_d.mtb"; 
     161        if (!new Location(mtbFile).exists()) { 
     162          throw new FormatException(".mtb file not found"); 
     163        } 
     164        currentId = new Location(mtbFile).getAbsolutePath(); 
     165      } 
     166      else { 
     167        Location parent = new Location(id).getAbsoluteFile().getParentFile(); 
     168        parent = parent.getParentFile(); 
     169        String[] list = parent.list(true); 
     170        for (String f : list) { 
     171          if (checkSuffix(f, "mtb")) { 
     172            currentId = new Location(parent, f).getAbsolutePath(); 
     173            break; 
     174          } 
     175        } 
     176        if (!checkSuffix(currentId, "mtb")) { 
     177          throw new FormatException(".mtb file not found"); 
     178        } 
     179      } 
    134180    } 
    135181 
     
    165211 
    166212    used = new Vector<String>(); 
    167     used.add(id); 
    168     if (!id.equals(mtb)) used.add(mtb); 
    169     String tnb = id.substring(0, id.lastIndexOf(".")); 
     213    used.add(mtb); 
     214    String tnb = mtb.substring(0, mtb.lastIndexOf(".")); 
    170215    if (tnb.lastIndexOf("_") > tnb.lastIndexOf(File.separator)) { 
    171216      tnb = tnb.substring(0, tnb.lastIndexOf("_")); 
    172217    } 
    173218    used.add(tnb + "_1.tnb"); 
     219    used.add(tnb + ".apl"); 
     220    String idPath = new Location(id).getAbsolutePath(); 
     221    if (!used.contains(idPath)) used.add(idPath); 
    174222 
    175223    // calculate indexes to relevant metadata 
  • branches/4.2/components/bio-formats/src/loci/formats/in/BioRadReader.java

    r6681 r6910  
    640640              } 
    641641              else if (key.equals("LENS_MAGNIFICATION")) { 
    642                 store.setObjectiveNominalMagnification( 
    643                   new PositiveInteger((int) Float.parseFloat(value)), 0, 0); 
     642                int magnification = (int) Float.parseFloat(value); 
     643                if (magnification > 0) { 
     644                  store.setObjectiveNominalMagnification( 
     645                    new PositiveInteger(magnification), 0, 0); 
     646                } 
    644647              } 
    645648              else if (key.startsWith("SETTING")) { 
     
    893896                  addGlobalMeta("Time Course - experiment type", values[2]); 
    894897                  addGlobalMeta("Time Course - kd factor", values[3]); 
     898                  String experimentID = 
     899                    MetadataTools.createLSID("Experiment", 0); 
     900                  store.setExperimentID(experimentID, 0); 
    895901                  store.setExperimentType(getExperimentType(values[2]), 0); 
    896902                  break; 
  • branches/4.2/components/bio-formats/src/loci/formats/in/CellWorxReader.java

    r6690 r6910  
    6868  /** Constructs a new CellWorx reader. */ 
    6969  public CellWorxReader() { 
    70     super("CellWorx", new String[] {"pnl", "htd"}); 
     70    super("CellWorx", new String[] {"pnl", "htd", "log"}); 
    7171    domains = new String[] {FormatTools.HCS_DOMAIN}; 
    7272  } 
    7373 
    7474  // -- IFormatReader API methods -- 
     75 
     76  /* @see loci.formats.IFormatReader#isThisType(String, boolean) */ 
     77  public boolean isThisType(String name, boolean open) { 
     78    if (checkSuffix(name, "pnl") || checkSuffix(name, "htd")) { 
     79      return super.isThisType(name, open); 
     80    } 
     81 
     82    boolean foundHTD = false; 
     83    boolean foundPNL = false; 
     84 
     85    Location parent = new Location(name).getAbsoluteFile().getParentFile(); 
     86    String[] list = parent.list(true); 
     87    for (String file : list) { 
     88      if (checkSuffix(file, "htd")) foundHTD = true; 
     89      if (checkSuffix(file, "pnl")) foundPNL = true; 
     90    } 
     91    return foundHTD && foundPNL; 
     92  } 
    7593 
    7694  /* @see loci.formats.IFormatReader#getSeriesUsedFiles(boolean) */ 
     
    102120 
    103121    String file = getPNLFile(getSeries()); 
    104     RandomAccessInputStream pnl = new RandomAccessInputStream(file); 
    105  
    106     long headerLength = pnl.length() - (fieldCount * fieldSize); 
    107     pnl.seek(headerLength + fieldIndex * fieldSize + no * planeSize); 
    108     readPlane(pnl, x, y, w, h, buf); 
     122    DeltavisionReader pnl = new DeltavisionReader(); 
     123    pnl.setId(file); 
     124    pnl.openBytes(fieldIndex * fieldCount + no, buf, x, y, w, h); 
    109125    pnl.close(); 
    110126    return buf; 
     
    115131    super.close(fileOnly); 
    116132    if (!fileOnly) { 
     133      fieldMap = null; 
     134      wellFiles = null; 
     135      logFiles = null; 
     136      fieldCount = 0; 
     137      plateLogFile = null; 
     138      zMapFile = null; 
    117139    } 
    118140  } 
     
    129151      base = base.substring(0, base.lastIndexOf("_")); 
    130152      id = base + ".HTD"; 
     153 
     154      if (!new Location(id).exists()) { 
     155        Location parent = new Location(id).getAbsoluteFile().getParentFile(); 
     156        String[] list = parent.list(true); 
     157        for (String f : list) { 
     158          if (checkSuffix(f, "htd")) { 
     159            id = new Location(parent, f).getAbsolutePath(); 
     160            break; 
     161          } 
     162        } 
     163      } 
    131164    } 
    132165 
     
    215248        if (line.trim().startsWith("Z Map File")) { 
    216249          String file = line.substring(line.indexOf(":") + 1); 
    217           file = file.substring(file.lastIndexOf("/") + 1); 
     250          file = file.substring(file.lastIndexOf("/") + 1).trim(); 
    218251          String parent = new Location(id).getAbsoluteFile().getParent(); 
    219252          zMapFile = new Location(parent, file).getAbsolutePath(); 
     
    225258 
    226259    String file = getPNLFile(0); 
    227     RandomAccessInputStream pnl = new RandomAccessInputStream(file); 
    228     pnl.order(true); 
    229     int x = pnl.readInt(); 
    230     int y = pnl.readInt(); 
    231     pnl.skipBytes(4); 
    232     int pixelType = pnl.readInt(); 
    233     pnl.close(); 
     260    DeltavisionReader pnl = new DeltavisionReader(); 
     261    pnl.setId(file); 
    234262 
    235263    for (int i=0; i<core.length; i++) { 
    236264      setSeries(i); 
    237265      core[i] = new CoreMetadata(); 
    238       core[i].littleEndian = true; 
    239       core[i].sizeX = x; 
    240       core[i].sizeY = y; 
    241  
    242       switch (pixelType) { 
    243         case 2: 
    244           core[i].pixelType = FormatTools.UINT32; 
    245           break; 
    246         case 6: 
    247           core[i].pixelType = FormatTools.UINT16; 
    248           break; 
    249         default: 
    250           throw new FormatException("Unsupported pixel type: " + pixelType); 
    251       } 
    252  
     266      core[i].littleEndian = pnl.isLittleEndian(); 
     267      core[i].sizeX = pnl.getSizeX(); 
     268      core[i].sizeY = pnl.getSizeY(); 
     269      core[i].pixelType = pnl.getPixelType(); 
    253270      core[i].sizeZ = 1; 
    254271      core[i].sizeT = 1; 
     
    257274      core[i].dimensionOrder = "XYCZT"; 
    258275      core[i].rgb = false; 
    259       core[i].interleaved = false; 
     276      core[i].interleaved = pnl.isInterleaved(); 
    260277    } 
    261278 
     
    282299              int fieldIndex = fieldRow * fieldMap[fieldRow].length + fieldCol; 
    283300 
    284               String wellSampleID = 
    285                 MetadataTools.createLSID("WellSample", 0, wellIndex, fieldIndex); 
     301              String wellSampleID = MetadataTools.createLSID("WellSample", 
     302                0, wellIndex, fieldIndex); 
    286303              store.setWellSampleID(wellSampleID, 0, wellIndex, fieldIndex); 
    287304              String imageID = MetadataTools.createLSID("Image", nextImage); 
    288305              store.setWellSampleImageRef(imageID, 0, wellIndex, fieldIndex); 
    289               store.setWellSampleIndex( 
    290                 new NonNegativeInteger(fieldIndex), 0, wellIndex, fieldIndex); 
     306              store.setWellSampleIndex(new NonNegativeInteger( 
     307                wellIndex * fieldCount + fieldIndex), 0, wellIndex, fieldIndex); 
    291308 
    292309              String well = (char) (row + 'A') + String.format("%02d", col + 1); 
     
    353370    int row = getWellRow(seriesIndex); 
    354371    int col = getWellColumn(seriesIndex); 
     372    int well = row * wellFiles[0].length + col; 
    355373    String logFile = logFiles[row][col]; 
    356374    LOGGER.debug("Parsing log file for well {}{}", (char) (row + 'A'), col + 1); 
     
    378396      else if (key.equals("Scan Origin")) { 
    379397        String[] axes = value.split(","); 
    380         for (int field=0; field<fieldCount; field++) { 
    381           store.setWellSamplePositionX(new Double(axes[0]), 0, wellIndex, field); 
    382           store.setWellSamplePositionY(new Double(axes[1]), 0, wellIndex, field); 
     398        for (int fieldRow=0; fieldRow<fieldMap.length; fieldRow++) { 
     399          for (int fieldCol=0; fieldCol<fieldMap[fieldRow].length; fieldCol++) { 
     400            if (fieldMap[fieldRow][fieldCol] && wellFiles[row][col] != null) { 
     401              int field = fieldRow * fieldMap[fieldRow].length + fieldCol; 
     402              store.setWellSamplePositionX(new Double(axes[0]), 0, well, field); 
     403              store.setWellSamplePositionY(new Double(axes[1]), 0, well, field); 
     404            } 
     405          } 
    383406        } 
    384407      } 
     
    390413          Double ySize = new Double(value.substring(s + 1, end).trim()); 
    391414          for (int field=0; field<fieldCount; field++) { 
    392             store.setPixelsPhysicalSizeX(xSize / getSizeX(), seriesIndex + field); 
    393             store.setPixelsPhysicalSizeY(ySize / getSizeY(), seriesIndex + field); 
     415            int index = seriesIndex + field; 
     416            store.setPixelsPhysicalSizeX(xSize / getSizeX(), index); 
     417            store.setPixelsPhysicalSizeY(ySize / getSizeY(), index); 
    394418          } 
    395419        } 
  • branches/4.2/components/bio-formats/src/loci/formats/in/DeltavisionReader.java

    r6691 r6910  
    116116  public boolean isThisType(String name, boolean open) { 
    117117    if (checkSuffix(name, "dv.log") || name.endsWith("_log.txt")) return true; 
     118    if (checkSuffix(name, "pnl")) return false; 
    118119    return super.isThisType(name, open); 
    119120  } 
  • branches/4.2/components/bio-formats/src/loci/formats/in/FV1000Reader.java

    r6663 r6910  
    10481048          } 
    10491049 
     1050          String shapeID = MetadataTools.createLSID("Shape", nextROI, shape); 
     1051 
    10501052          if (shapeType == POINT) { 
     1053            store.setPointID(shapeID, nextROI, shape); 
    10511054            store.setPointTheZ(new NonNegativeInteger(zIndex), nextROI, shape); 
    10521055            store.setPointTheT(new NonNegativeInteger(tIndex), nextROI, shape); 
     
    10671070                double realY = y + row * height; 
    10681071 
     1072                shapeID = MetadataTools.createLSID("Shape", nextROI, shape); 
     1073                store.setRectangleID(shapeID, nextROI, shape); 
    10691074                store.setRectangleX(realX, nextROI, shape); 
    10701075                store.setRectangleY(realY, nextROI, shape); 
     
    10921097          } 
    10931098          else if (shapeType == LINE) { 
     1099            store.setLineID(shapeID, nextROI, shape); 
    10941100            store.setLineX1(new Double(x), nextROI, shape); 
    10951101            store.setLineY1(new Double(y), nextROI, shape); 
     
    11121118            double rx = width / 2; 
    11131119            double ry = shapeType == CIRCLE ? rx : height / 2; 
     1120            store.setEllipseID(shapeID, nextROI, shape); 
    11141121            store.setEllipseX(x + rx, nextROI, shape); 
    11151122            store.setEllipseY(y + ry, nextROI, shape); 
     
    11371144              if (point < xc.length - 1) points.append(" "); 
    11381145            } 
     1146            store.setPolylineID(shapeID, nextROI, shape); 
    11391147            store.setPolylinePoints(points.toString(), nextROI, shape); 
    11401148            store.setPolylineTransform("rotate(" + angle + ")", nextROI, shape); 
     
    14211429  { 
    14221430    RandomAccessInputStream stream = getFile(filename); 
    1423     stream.skipBytes(2); 
    1424     String data = stream.readString((int) stream.length() - 2); 
     1431    String data = stream.readString((int) stream.length()); 
     1432    if (!data.startsWith("[")) data = data.substring(2, data.length()); 
    14251433    data = DataTools.stripString(data); 
    14261434    BufferedReader reader = new BufferedReader(new StringReader(data)); 
  • branches/4.2/components/bio-formats/src/loci/formats/in/ICSReader.java

    r6710 r6910  
    222222    int[] prevCoordinates = getZCTCoords(prevImage); 
    223223 
    224     in.seek(offset + no * (long) len); 
     224    if (!gzip) in.seek(offset + no * (long) len); 
    225225 
    226226    int sizeC = lifetime ? 1 : getSizeC(); 
     
    721721    offset = in.getFilePointer(); 
    722722 
     723    int bytes = bitsPerPixel / 8; 
     724 
    723725    if (gzip) { 
    724726      data = new byte[(int) (in.length() - in.getFilePointer())]; 
     
    726728      in.read(data); 
    727729      byte[] buf = new byte[8192]; 
    728       ByteArrayHandle v = new ByteArrayHandle(); 
     730      int nBytes = getImageCount() * getSizeX() * getSizeY() * bytes; 
     731      ByteArrayHandle v = new ByteArrayHandle(nBytes); 
    729732      try { 
    730733        GZIPInputStream r = new GZIPInputStream(new ByteArrayInputStream(data)); 
     
    736739        r.close(); 
    737740        data = v.getBytes(); 
     741        v.close(); 
    738742      } 
    739743      catch (IOException dfe) { 
    740744        throw new FormatException("Error uncompressing gzip'ed data", dfe); 
    741745      } 
     746      buf = null; 
    742747    } 
    743748 
     
    745750 
    746751    boolean fp = rFormat.equals("real"); 
    747     int bytes = bitsPerPixel / 8; 
    748752    core[0].pixelType = FormatTools.pixelTypeFromBytes(bytes, signed, fp); 
    749753 
     
    821825      Integer[] lasers = wavelengths.keySet().toArray(new Integer[0]); 
    822826      for (int i=0; i<lasers.length; i++) { 
     827        store.setLaserID(MetadataTools.createLSID("LightSource", 0, i), 0, i); 
    823828        store.setLaserWavelength( 
    824829          new PositiveInteger(wavelengths.get(lasers[i])), 0, i); 
     
    859864      // populate Experimenter data 
    860865 
    861       if (lastName != null) store.setExperimenterLastName(lastName, 0); 
     866      if (lastName != null) { 
     867        String experimenterID = MetadataTools.createLSID("Experimenter", 0); 
     868        store.setExperimenterID(experimenterID, 0); 
     869        store.setExperimenterLastName(lastName, 0); 
     870        store.setExperimenterDisplayName(lastName, 0); 
     871      } 
    862872 
    863873      // populate StagePosition data 
  • branches/4.2/components/bio-formats/src/loci/formats/in/IPLabReader.java

    r6663 r6910  
    289289        int numRoiPts = in.readInt(); 
    290290 
     291        store.setRectangleID(MetadataTools.createLSID("Shape", 0, 0), 0, 0); 
    291292        store.setRectangleX(new Double(roiLeft), 0, 0); 
    292293        store.setRectangleY(new Double(roiTop), 0, 0); 
  • branches/4.2/components/bio-formats/src/loci/formats/in/LeicaReader.java

    r6663 r6910  
    164164  private boolean[][] cutOutPopulated; 
    165165  private boolean[][] filterRefPopulated; 
     166 
     167  private Double detectorOffset, detectorVoltage; 
    166168 
    167169  // -- Constructor -- 
     
    11371139          try { 
    11381140            if (tokens[2].equals("VideoOffset")) { 
    1139               store.setDetectorOffset(new Double(data), series, nextDetector); 
     1141              detectorOffset = new Double(data); 
    11401142            } 
    11411143            else if (tokens[2].equals("HighVoltage")) { 
    1142               store.setDetectorVoltage(new Double(data), series, nextDetector); 
     1144              detectorVoltage = new Double(data); 
    11431145              nextDetector++; 
    11441146            } 
    11451147            else if (tokens[2].equals("State")) { 
    1146               store.setDetectorType( 
    1147                 getDetectorType("PMT"), series, nextDetector); 
    11481148              // link Detector to Image, if the detector was actually used 
    11491149              if (data.equals("Active")) { 
     1150                store.setDetectorOffset(detectorOffset, series, nextDetector); 
     1151                store.setDetectorVoltage(detectorVoltage, series, nextDetector); 
     1152                store.setDetectorType( 
     1153                  getDetectorType("PMT"), series, nextDetector); 
    11501154                String index = tokens[1].substring(tokens[1].indexOf(" ") + 1); 
    11511155                int channelIndex = -1; 
  • branches/4.2/components/bio-formats/src/loci/formats/in/MicromanagerReader.java

    r6663 r6910  
    411411    MetadataTools.populatePixels(store, this, true); 
    412412    if (time != null) { 
    413       long stamp = DateTools.getTime(time, DATE_FORMAT); 
    414       String date = DateTools.convertDate(stamp, DateTools.UNIX); 
     413      String date = DateTools.formatDate(time, DATE_FORMAT); 
    415414      store.setImageAcquiredDate(date, 0); 
    416415    } 
     
    440439      } 
    441440 
    442       if (detectorID == null) { 
    443         detectorID = MetadataTools.createLSID("Detector", 0, 0); 
    444       } 
    445       else { 
    446         detectorID = detectorID.substring(detectorID.lastIndexOf(":") + 1); 
    447         detectorID = "Detector:" + detectorID.trim(); 
    448       } 
     441      String serialNumber = detectorID; 
     442      detectorID = MetadataTools.createLSID("Detector", 0, 0); 
    449443 
    450444      for (int i=0; i<channels.length; i++) { 
     
    460454      if (detectorModel != null) { 
    461455        store.setDetectorModel(detectorModel, 0, 0); 
     456      } 
     457 
     458      if (serialNumber != null) { 
     459        store.setDetectorSerialNumber(serialNumber, 0, 0); 
    462460      } 
    463461 
  • branches/4.2/components/bio-formats/src/loci/formats/in/NikonReader.java

    r6663 r6910  
    3232import loci.formats.FormatTools; 
    3333import loci.formats.ImageTools; 
     34import loci.formats.MetadataTools; 
    3435import loci.formats.codec.BitBuffer; 
    3536import loci.formats.codec.NikonCodec; 
    3637import loci.formats.codec.NikonCodecOptions; 
     38import loci.formats.meta.MetadataStore; 
    3739import loci.formats.tiff.IFD; 
    3840import loci.formats.tiff.IFDList; 
     
    419421      core[0].interleaved = true; 
    420422    } 
     423 
     424    MetadataStore store = makeFilterMetadata(); 
     425    MetadataTools.populatePixels(store, this); 
    421426  } 
    422427 
  • branches/4.2/components/bio-formats/src/loci/formats/in/NikonTiffReader.java

    r6663 r6910  
    227227      store.setObjectiveID(objectiveID, 0, 0); 
    228228      store.setImageObjectiveSettingsID(objectiveID, 0); 
    229       store.setObjectiveNominalMagnification( 
     229      if (magnification > 0) { 
     230        store.setObjectiveNominalMagnification( 
    230231          new PositiveInteger(magnification), 0, 0); 
     232      } 
    231233 
    232234      if (correction == null) correction = "Other"; 
     
    247249 
    248250      for (int i=0; i<gain.size(); i++) { 
     251        store.setDetectorID(MetadataTools.createLSID("Detector", 0, i), 0, i); 
    249252        store.setDetectorGain(gain.get(i), 0, i); 
    250253        store.setDetectorType(getDetectorType("Other"), 0, i); 
  • branches/4.2/components/bio-formats/src/loci/formats/in/ScanrReader.java

    r6663 r6910  
    423423    MetadataTools.populatePixels(store, this); 
    424424 
     425    store.setPlateID(MetadataTools.createLSID("Plate", 0), 0); 
     426 
    425427    int nFields = fieldRows * fieldColumns; 
    426428 
     
    434436      int wellCol = well % wellColumns; 
    435437 
     438      store.setWellID(MetadataTools.createLSID("Well", 0, well), 0, well); 
    436439      store.setWellColumn(new NonNegativeInteger(wellCol), 0, well); 
    437440      store.setWellRow(new NonNegativeInteger(wellRow), 0, well); 
    438441 
     442      String wellSample = 
     443        MetadataTools.createLSID("WellSample", 0, well, field); 
     444      store.setWellSampleID(wellSample, 0, well, field); 
    439445      store.setWellSampleIndex(new NonNegativeInteger(i), 0, well, field); 
    440446      String imageID = MetadataTools.createLSID("Image", i); 
  • branches/4.2/components/bio-formats/src/loci/formats/in/ZeissLSMReader.java

    r6765 r6910  
    409409    MetadataTools.populatePixels(store, this, true); 
    410410    for (int series=0; series<ifdsList.size(); series++) { 
     411      setSeries(series); 
    411412      store.setImageName(imageNames.get(series), series); 
    412413      store.setPixelsBinDataBigEndian(!isLittleEndian(), series, 0); 
     
    11041105      in.skipBytes(34); 
    11051106 
     1107      String roiID = MetadataTools.createLSID("ROI", i); 
     1108      String shapeID = MetadataTools.createLSID("Shape", i, 0); 
     1109 
    11061110      switch (type) { 
    11071111        case TEXT: 
     
    11121116          store.setTextFontSize(new NonNegativeInteger(fontHeight), i, 0); 
    11131117          store.setTextStrokeWidth(lineWidth, i, 0); 
     1118          store.setROIID(roiID, i); 
     1119          store.setTextID(shapeID, i, 0); 
    11141120          break; 
    11151121        case LINE: 
     
    11261132          store.setLineFontSize(new NonNegativeInteger(fontHeight), i, 0); 
    11271133          store.setLineStrokeWidth(lineWidth, i, 0); 
     1134          store.setROIID(roiID, i); 
     1135          store.setLineID(shapeID, i, 0); 
    11281136          break; 
    11291137        case SCALE_BAR: 
     
    11511159          store.setRectangleFontSize(new NonNegativeInteger(fontHeight), i, 0); 
    11521160          store.setRectangleStrokeWidth(lineWidth, i, 0); 
     1161          store.setROIID(roiID, i); 
     1162          store.setRectangleID(shapeID, i, 0); 
    11531163 
    11541164          break; 
     
    12071217          store.setEllipseFontSize(new NonNegativeInteger(fontHeight), i, 0); 
    12081218          store.setEllipseStrokeWidth(lineWidth, i, 0); 
     1219          store.setROIID(roiID, i); 
     1220          store.setEllipseID(shapeID, i, 0); 
    12091221 
    12101222          break; 
     
    12251237          store.setEllipseFontSize(new NonNegativeInteger(fontHeight), i, 0); 
    12261238          store.setEllipseStrokeWidth(lineWidth, i, 0); 
     1239          store.setROIID(roiID, i); 
     1240          store.setEllipseID(shapeID, i, 0); 
    12271241 
    12281242          break; 
     
    12601274          store.setEllipseFontSize(new NonNegativeInteger(fontHeight), i, 0); 
    12611275          store.setEllipseStrokeWidth(lineWidth, i, 0); 
     1276          store.setROIID(roiID, i); 
     1277          store.setEllipseID(shapeID, i, 0); 
    12621278 
    12631279          break; 
     
    12821298          store.setPolylineFontSize(new NonNegativeInteger(fontHeight), i, 0); 
    12831299          store.setPolylineStrokeWidth(lineWidth, i, 0); 
     1300          store.setROIID(roiID, i); 
     1301          store.setPolylineID(shapeID, i, 0); 
    12841302 
    12851303          break; 
     
    13071325          store.setPolylineFontSize(new NonNegativeInteger(fontHeight), i, 0); 
    13081326          store.setPolylineStrokeWidth(lineWidth, i, 0); 
     1327          store.setROIID(roiID, i); 
     1328          store.setPolylineID(shapeID, i, 0); 
    13091329 
    13101330          break; 
     
    13321352          store.setPolylineFontSize(new NonNegativeInteger(fontHeight), i, 0); 
    13331353          store.setPolylineStrokeWidth(lineWidth, i, 0); 
     1354          store.setROIID(roiID, i); 
     1355          store.setPolylineID(shapeID, i, 0); 
    13341356 
    13351357          break; 
  • branches/4.2/components/bio-formats/src/loci/formats/in/ZeissZVIReader.java

    r6834 r6910  
    11001100      s.skipBytes(6); 
    11011101 
     1102      String roiID = MetadataTools.createLSID("ROI", imageNum); 
     1103      String shapeID = MetadataTools.createLSID("Shape", imageNum, shapeIndex); 
     1104 
    11021105      if (roiType == ELLIPSE) { 
     1106        store.setROIID(roiID, imageNum); 
     1107        store.setEllipseID(shapeID, imageNum, shapeIndex); 
    11031108        store.setEllipseX(new Double(x + (w / 2)), imageNum, shapeIndex); 
    11041109        store.setEllipseY(new Double(y + (h / 2)), imageNum, shapeIndex); 
     
    11101115        roiType == OUTLINE_SPLINE) 
    11111116      { 
     1117        store.setROIID(roiID, imageNum); 
    11121118        StringBuffer points = new StringBuffer(); 
    11131119        for (int p=0; p<nPoints; p++) { 
     
    11201126        } 
    11211127 
     1128        store.setPolylineID(shapeID, imageNum, shapeIndex); 
    11221129        store.setPolylinePoints(points.toString(), imageNum, shapeIndex); 
    11231130        store.setPolylineClosed(roiType != CURVE, imageNum, shapeIndex); 
     
    11251132      } 
    11261133      else if (roiType == RECTANGLE || roiType == TEXT) { 
     1134        store.setROIID(roiID, imageNum); 
     1135        store.setRectangleID(shapeID, imageNum, shapeIndex); 
    11271136        store.setRectangleX(new Double(x), imageNum, shapeIndex); 
    11281137        store.setRectangleY(new Double(y), imageNum, shapeIndex); 
     
    11321141      } 
    11331142      else if (roiType == LINE || roiType == SCALE_BAR) { 
     1143        store.setROIID(roiID, imageNum); 
    11341144        double x1 = s.readDouble(); 
    11351145        double y1 = s.readDouble(); 
    11361146        double x2 = s.readDouble(); 
    11371147        double y2 = s.readDouble(); 
     1148        store.setLineID(shapeID, imageNum, shapeIndex); 
    11381149        store.setLineX1(x1, imageNum, shapeIndex); 
    11391150        store.setLineY1(y1, imageNum, shapeIndex); 
  • branches/4.2/components/bio-formats/src/loci/formats/readers.txt

    r6490 r6910  
    8181loci.formats.in.RHKReader             # sm2, sm3 
    8282loci.formats.in.MolecularImagingReader # stp 
     83loci.formats.in.CellWorxReader        # pnl, htd 
    8384loci.formats.in.FakeReader            # fake 
    8485 
  • branches/4.2/components/bio-formats/src/loci/formats/tiff

  • branches/4.2/components/loci-plugins

  • branches/4.2/components/loci-plugins/src/loci/plugins

  • branches/4.2/components/loci-plugins/src/loci/plugins/in/Calibrator.java

  • branches/4.2/components/ome-xml

  • branches/4.2/components/test-suite/src/loci/tests/testng/FormatReaderTest.java

    r6663 r6910  
    5555import loci.formats.in.BioRadReader; 
    5656import loci.formats.in.NRRDReader; 
     57import loci.formats.in.OMETiffReader; 
    5758import loci.formats.in.TiffReader; 
    5859import loci.formats.meta.MetadataRetrieve; 
     
    387388          msg = "SizeT"; 
    388389        } 
    389         if (reader.isLittleEndian() == 
    390           retrieve.getPixelsBinDataBigEndian(i, 0).booleanValue()) 
    391         { 
    392           msg = "BigEndian"; 
     390 
     391        // NB: OME-TIFF files do not have a BinData element under Pixels 
     392        IFormatReader r = reader.unwrap(); 
     393        if (r instanceof FileStitcher) r = ((FileStitcher) r).getReader(); 
     394        if (r instanceof ReaderWrapper) r = ((ReaderWrapper) r).unwrap(); 
     395        if (!(r instanceof OMETiffReader)) { 
     396          if (reader.isLittleEndian() == 
     397            retrieve.getPixelsBinDataBigEndian(i, 0).booleanValue()) 
     398          { 
     399            msg = "BigEndian"; 
     400          } 
    393401        } 
    394402        if (!reader.getDimensionOrder().equals( 
Note: See TracChangeset for help on using the changeset viewer.