Changeset 7507


Ignore:
Timestamp:
01/11/11 14:27:55 (9 years ago)
Author:
melissa
Message:

Backported changes to Openlab reader for importing HCS data.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/4.2/components/bio-formats/src/loci/formats/in/OpenlabReader.java

    r7102 r7507  
    8686 
    8787  /** Helper reader to read PICT data. */ 
    88   private static PictReader pict = new PictReader(); 
     88  private PictReader pict = new PictReader(); 
    8989 
    9090  // -- Fields -- 
     
    108108 
    109109  private String gain, detectorOffset, xPos, yPos, zPos; 
     110  private boolean specialPlateNames = false; 
    110111 
    111112  // -- Constructor -- 
     
    142143    lastPlane = no; 
    143144 
    144     if (no >= planeOffsets[series].length) return buf; 
    145     int index = planeOffsets[series][no]; 
    146  
    147     long first = planes[index].planeOffset; 
    148     long last = no == planeOffsets[series].length - 1 || 
    149       planeOffsets[series][no + 1] >= planes.length ? in.length() : 
    150       planes[planeOffsets[series][no + 1]].planeOffset; 
    151     in.seek(first); 
     145    PlaneInfo planeInfo = null; 
     146    if (specialPlateNames) { 
     147      planeInfo = getPlane(getZCTCoords(no)); 
     148    } 
     149    else if (no < planeOffsets[series].length) { 
     150      int index = planeOffsets[series][no]; 
     151      planeInfo = planes[index]; 
     152    } 
     153    if (planeInfo == null) return buf; 
     154 
     155    long first = planeInfo.planeOffset; 
     156    long last = first + FormatTools.getPlaneSize(this) * 2; 
    152157 
    153158    int bpp = FormatTools.getBytesPerPixel(getPixelType()); 
    154159 
    155     if (!planes[index].pict) { 
     160    if (!planeInfo.pict) { 
    156161      if (version == 2) { 
     162        in.seek(first); 
    157163        readPlane(in, x, y, w, h, buf); 
    158164      } 
    159165      else { 
    160         in.skipBytes(16); 
     166        in.seek(first + 16); 
    161167        int bytes = bpp * getRGBChannelCount(); 
    162168        byte[] b = new byte[(int) (last - first)]; 
     
    188194        b = null; 
    189195      } 
    190       if (planes[index].volumeType == MAC_256_GREYS || 
    191         planes[index].volumeType == MAC_256_COLORS) 
     196      if (planeInfo.volumeType == MAC_256_GREYS || 
     197        planeInfo.volumeType == MAC_256_COLORS) 
    192198      { 
    193199        for (int i=0; i<buf.length; i++) { 
     
    198204    else { 
    199205      // PICT plane 
    200       byte[] b = new byte[(int) (last - first) + 512]; 
    201       in.read(b, 512, b.length - 512); 
    202206      Exception exc = null; 
    203       IFormatReader r = 
    204         getRGBChannelCount() == 1 ? new ChannelSeparator(pict) : pict; 
    205       try { 
    206         Location.mapFile("OPENLAB_PICT", new ByteArrayHandle(b)); 
    207         r.setId("OPENLAB_PICT"); 
    208  
    209         if (getPixelType() != pict.getPixelType()) { 
    210           throw new FormatException("Pixel type of inner PICT does not match " + 
    211             "pixel type of Openlab file"); 
    212         } 
    213  
    214         if (isIndexed()) { 
    215           luts.setElementAt(pict.get8BitLookupTable(), 
    216             planeOffsets[series][lastPlane]); 
    217         } 
    218  
    219         r.openBytes(0, buf, x, y, w, h); 
    220         r.close(); 
    221         // remove file from map 
    222         Location.mapFile("OPENLAB_PICT", null); 
    223       } 
    224       catch (FormatException e) { exc = e; } 
    225       catch (IOException e) { exc = e; } 
    226       b = null; 
    227  
    228       if (exc != null) { 
    229         r.close(); 
     207      if (getPixelType() == FormatTools.UINT8) { 
     208        in.seek(first); 
     209        byte[] b = new byte[(int) (last - first) + 512]; 
     210        in.read(b, 512, b.length - 512); 
     211 
     212        IFormatReader r = 
     213          getRGBChannelCount() == 1 ? new ChannelSeparator(pict) : pict; 
     214        try { 
     215          Location.mapFile("OPENLAB_PICT", new ByteArrayHandle(b)); 
     216          r.setId("OPENLAB_PICT"); 
     217 
     218          if (getPixelType() != r.getPixelType()) { 
     219            throw new FormatException("Pixel type of inner PICT does not " + 
     220              "match pixel type of Openlab file"); 
     221          } 
     222 
     223          if (isIndexed()) { 
     224            luts.setElementAt(pict.get8BitLookupTable(), 
     225              planeOffsets[series][lastPlane]); 
     226          } 
     227 
     228          r.openBytes(0, buf, x, y, w, h); 
     229        } 
     230        catch (FormatException e) { exc = e; } 
     231        catch (IOException e) { exc = e; } 
     232        finally { 
     233          r.close(); 
     234          // remove file from map 
     235          Location.mapFile("OPENLAB_PICT", null); 
     236        } 
     237        b = null; 
     238      } 
     239      if (exc != null || getPixelType() != FormatTools.UINT8) { 
    230240        LOGGER.debug("", exc); 
    231         in.seek(planes[index].planeOffset - 298); 
    232  
    233         if (in.readByte() == 1) in.skipBytes(128); 
    234         in.skipBytes(169); 
     241        in.seek(planeInfo.planeOffset - 298); 
     242 
     243        if (in.readByte() == 1) in.skipBytes(297); 
     244        else in.skipBytes(169); 
    235245 
    236246        int size = 0, expectedBlock = 0, totalBlocks = -1, pixPos = 0; 
     
    238248        byte[] plane = new byte[FormatTools.getPlaneSize(this)]; 
    239249 
    240         while (expectedBlock != totalBlocks && 
    241           in.getFilePointer() + 32 < in.length()) 
     250        while (expectedBlock != totalBlocks && pixPos < plane.length && 
     251          in.getFilePointer() + 32 < last) 
    242252        { 
    243           while (in.readLong() != 0x4956454164627071L && 
    244             in.getFilePointer() < in.length()) 
    245           { 
    246             in.seek(in.getFilePointer() - 7); 
    247           } 
     253          findNextBlock(); 
    248254 
    249255          if (in.getFilePointer() + 4 >= in.length()) break; 
     
    255261 
    256262          expectedBlock++; 
    257           if (totalBlocks == -1) totalBlocks = in.readInt(); 
    258           else in.skipBytes(4); 
    259  
    260           in.skipBytes(8); 
     263          if (totalBlocks == -1) { 
     264            totalBlocks = in.readInt(); 
     265            in.skipBytes(8); 
     266          } 
     267          else in.skipBytes(12); 
     268 
    261269          size = in.readInt(); 
    262270          in.skipBytes(4); 
     
    268276        } 
    269277 
    270         int srcRow = getSizeX() * bpp * getRGBChannelCount(); 
    271         int rowLen = w * bpp * getRGBChannelCount(); 
    272         for (int row=0; row<h; row++) { 
    273           System.arraycopy(plane, (row + y) * srcRow + 
    274             x * bpp * getRGBChannelCount(), buf, row*rowLen, rowLen); 
    275         } 
     278        RandomAccessInputStream pix = new RandomAccessInputStream(plane); 
     279        readPlane(pix, x, y, w, h, buf); 
     280        pix.close(); 
    276281        plane = null; 
    277282      } 
     
    298303      gain = detectorOffset = null; 
    299304      xPos = yPos = zPos = null; 
     305      specialPlateNames = false; 
    300306    } 
    301307  } 
     
    590596      String detectorID = MetadataTools.createLSID("Detector", 0, 0); 
    591597      store.setDetectorID(detectorID, 0, 0); 
    592       store.setDetectorSettingsID(detectorID, 0, 0); 
    593598 
    594599      store.setDetectorType(getDetectorType("Other"), 0, 0); 
     600 
     601      for (int c=0; c<getEffectiveSizeC(); c++) { 
     602        PlaneInfo plane = getPlane(new int[] {0, c, 0}); 
     603        if (plane != null) { 
     604          store.setChannelName(plane.channelName, 0, c); 
     605          store.setDetectorSettingsID(detectorID, 0, c); 
     606        } 
     607      } 
    595608 
    596609      Double stageX = xPos == null ? null : new Double(xPos); 
     
    598611      Double stageZ = zPos == null ? null : new Double(zPos); 
    599612 
    600       for (int series=0; series<getSeriesCount(); series++) { 
    601         setSeries(series); 
    602         for (int plane=0; plane<getImageCount(); plane++) { 
    603           if (stageX != null) { 
    604             store.setPlanePositionX(stageX, series, plane); 
    605           } 
    606           if (stageY != null) { 
    607             store.setPlanePositionY(stageY, series, plane); 
    608           } 
    609           if (stageZ != null) { 
    610             store.setPlanePositionZ(stageZ, series, plane); 
     613      if (stageX != null || stageY != null || stageZ != null) { 
     614        for (int series=0; series<getSeriesCount(); series++) { 
     615          setSeries(series); 
     616          for (int plane=0; plane<getImageCount(); plane++) { 
     617            if (stageX != null) { 
     618              store.setPlanePositionX(stageX, series, plane); 
     619            } 
     620            if (stageY != null) { 
     621              store.setPlanePositionY(stageY, series, plane); 
     622            } 
     623            if (stageZ != null) { 
     624              store.setPlanePositionZ(stageZ, series, plane); 
     625            } 
    611626          } 
    612627        } 
     
    684699    core[s].dimensionOrder = "XY"; 
    685700    for (PlaneInfo plane : planes) { 
    686       if (plane == null) continue; 
    687       if (plane.series == s) { 
    688         String name = plane.planeName; 
     701      if (plane == null || plane.series != s) continue; 
     702 
     703      String name = plane.planeName; 
     704 
     705      // check for a specific name format: 
     706      // <channel name><optional timepoint>_<plate>_<well>_<Z section> 
     707 
     708      String[] tokens = name.split("_"); 
     709      if (tokens.length == 4) { 
     710        specialPlateNames = true; 
     711 
     712        if (!uniqueZ.contains(tokens[3])) { 
     713          uniqueZ.add(tokens[3]); 
     714        } 
     715        plane.channelName = tokens[0]; 
     716        int endIndex = 0; 
     717        while (endIndex < plane.channelName.length() && 
     718          !Character.isDigit(plane.channelName.charAt(endIndex))) 
     719        { 
     720          endIndex++; 
     721        } 
     722        String timepoint = plane.channelName.substring(endIndex); 
     723        if (timepoint.equals("")) timepoint = "1"; 
     724        plane.channelName = plane.channelName.substring(0, endIndex); 
     725 
     726        if (!uniqueC.contains(plane.channelName)) { 
     727          uniqueC.add(plane.channelName); 
     728        } 
     729        if (!uniqueT.contains(timepoint)) { 
     730          uniqueT.add(timepoint); 
     731        } 
     732 
     733        core[s].dimensionOrder = "XYCTZ"; 
     734        plane.wavelength = uniqueC.indexOf(plane.channelName); 
     735        plane.timepoint = uniqueT.indexOf(timepoint); 
     736        plane.zPosition = uniqueZ.indexOf(tokens[3]); 
     737      } 
     738      else { 
    689739        for (String axis : axes) { 
    690740          Vector<String> unique = null; 
     
    717767    } 
    718768 
     769    if (specialPlateNames) { 
     770      core[s].sizeC *= uniqueC.size(); 
     771      core[s].sizeT = uniqueT.size(); 
     772      core[s].sizeZ = uniqueZ.size(); 
     773      core[s].imageCount = core[s].sizeC * core[s].sizeZ * core[s].sizeT; 
     774      return; 
     775    } 
     776 
    719777    if (core[s].rgb && uniqueC.size() <= 1) { 
    720778      core[s].dimensionOrder = core[s].dimensionOrder.replaceAll("C", ""); 
     
    750808  } 
    751809 
     810  private PlaneInfo getPlane(int[] zct) { 
     811    for (PlaneInfo plane : planes) { 
     812      if (plane != null && plane.zPosition == zct[0] && 
     813        plane.wavelength == zct[1] && plane.timepoint == zct[2] && 
     814        plane.series == getSeries()) 
     815      { 
     816        return plane; 
     817      } 
     818    } 
     819    return null; 
     820  } 
     821 
     822  private void findNextBlock() throws IOException { 
     823    byte[] buf = new byte[8192]; 
     824    in.read(buf); 
     825    boolean found = false; 
     826 
     827    while (!found) { 
     828      for (int i=0; i<buf.length-7; i++) { 
     829        if (buf[i] == 0x49 && buf[i + 1] == 0x56 && buf[i + 2] == 0x45 && 
     830          buf[i + 3] == 0x41 && buf[i + 4] == 0x64 && buf[i + 5] == 0x62 && 
     831          buf[i + 6] == 0x70 && buf[i + 7] == 0x71) 
     832        { 
     833          found = true; 
     834          in.seek(in.getFilePointer() - buf.length + i + 8); 
     835          break; 
     836        } 
     837      } 
     838      if (!found) { 
     839        for (int i=6; i>=0; i--) { 
     840          buf[6 - i] = buf[buf.length - i]; 
     841        } 
     842        in.read(buf, 7, buf.length - 7); 
     843      } 
     844    } 
     845  } 
     846 
    752847  // -- Helper classes -- 
    753848 
     
    757852    protected int zPosition; 
    758853    protected int wavelength; 
     854    protected int timepoint; 
    759855    protected String planeName; 
    760856    protected long timestamp; 
     
    765861    protected int height; 
    766862    protected int series = -1; 
     863    protected String channelName; 
    767864  } 
    768865 
Note: See TracChangeset for help on using the changeset viewer.