Changeset 1903


Ignore:
Timestamp:
12/06/06 11:08:29 (13 years ago)
Author:
melissa
Message:
  • Fixed ND2/JPEG-2000 bug. This required switching from JJ2000 to JAI; be sure to remove JJ2000 from the classpath before using the new ND2 reader.
  • Added "int getEffectiveSizeC(String)" to IFormatReader API. This returns 1 if isRGB(String) returns true, and getSizeC(String) otherwise.
  • Removed old OME uploader.
Location:
trunk
Files:
1 added
2 deleted
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/loci/formats/ChannelMerger.java

    r1843 r1903  
    5959  public boolean isRGB(String id) throws FormatException, IOException { 
    6060    return canMerge(id) || reader.isRGB(id); 
     61  } 
     62 
     63  /* @see IFormatReader#getEffectiveSizeC(String) */ 
     64  public int getEffectiveSizeC(String id) throws FormatException, IOException { 
     65    return isRGB(id) ? (getSizeC(id) + 2) / 3 : getSizeC(id); 
    6166  } 
    6267 
  • trunk/loci/formats/ChannelSeparator.java

    r1868 r1903  
    6767  public boolean isRGB(String id) { 
    6868    return false; 
     69  } 
     70 
     71  /* @see IFormatReader#getEffectiveSizeC(String) */ 
     72  public int getEffectiveSizeC(String id) throws FormatException, IOException { 
     73    return getSizeC(id); 
    6974  } 
    7075 
  • trunk/loci/formats/FileStitcher.java

    r1868 r1903  
    257257  } 
    258258 
     259  /* @see IFormatReader#getEffectiveSizeC(String) */ 
     260  public int getEffectiveSizeC(String id) throws FormatException, IOException { 
     261    if (!id.equals(currentId)) initFile(id); 
     262    return isRGB(id) ? (getSizeC(id) + 2) / 3 : getSizeC(id); 
     263  } 
     264  
    259265  /* @see IFormatReader#getChannelGlobalMinimum(String, int) */ 
    260266  public Double getChannelGlobalMinimum(String id, int theC) 
  • trunk/loci/formats/FormatReader.java

    r1897 r1903  
    4141 
    4242  /** Debugging flag. */ 
    43   protected static final boolean DEBUG = false; 
     43  protected static final boolean DEBUG = true; 
    4444 
    4545  /** Debugging level. 1=basic, 2=extended, 3=everything. */ 
     
    213213    if (!id.equals(currentId)) initFile(id); 
    214214    return pixelType[series]; 
     215  } 
     216 
     217  /* @see IFormatReader#getEffectiveSizeC(String) */ 
     218  public int getEffectiveSizeC(String id) throws FormatException, IOException { 
     219    if (!id.equals(currentId)) initFile(id); 
     220    return isRGB(id) ? (getSizeC(id) + 2) / 3 : getSizeC(id); 
    215221  } 
    216222 
  • trunk/loci/formats/IFormatReader.java

    r1812 r1903  
    6565   */ 
    6666  int getPixelType(String id) throws FormatException, IOException; 
     67 
     68  /**  
     69   * Get the effective size of the C dimension.  If isRGB(String) returns 
     70   * true, this will return 1; otherwise, it returns the value of getSizeC. 
     71   */ 
     72  int getEffectiveSizeC(String id) throws FormatException, IOException; 
    6773 
    6874  /** 
  • trunk/loci/formats/ImageReader.java

    r1812 r1903  
    229229  } 
    230230 
    231   /* @see IFormatReader#getPixelType() */ 
     231  /* @see IFormatReader#getPixelType(String) */ 
    232232  public int getPixelType(String id) throws FormatException, IOException { 
    233233    return getReader(id).getPixelType(id); 
     234  } 
     235 
     236  /* @see IFormatReader#getEffectiveSizeC(String) */ 
     237  public int getEffectiveSizeC(String id) throws FormatException, IOException { 
     238    return getReader(id).getEffectiveSizeC(id); 
    234239  } 
    235240 
  • trunk/loci/formats/ImageViewer.java

    r1868 r1903  
    187187      sizeZ = myReader.getSizeZ(id); 
    188188      sizeT = myReader.getSizeT(id); 
    189       sizeC = myReader.getSizeC(id); 
    190       if (myReader.isRGB(id)) sizeC = (sizeC + 2) / 3; // adjust for RGB 
     189      sizeC = myReader.getEffectiveSizeC(id); 
     190      //if (myReader.isRGB(id)) sizeC = (sizeC + 2) / 3; // adjust for RGB 
    191191      progress.setProgress(1); 
    192192      BufferedImage[] img = new BufferedImage[num]; 
     
    245245      sizeZ = reader.getSizeZ(id); 
    246246      sizeT = reader.getSizeT(id); 
    247       sizeC = reader.getSizeC(id); 
    248       if (reader.isRGB(id)) sizeC = (sizeC + 2) / 3; // adjust for RGB 
     247      sizeC = reader.getEffectiveSizeC(id); 
     248      //if (reader.isRGB(id)) sizeC = (sizeC + 2) / 3; // adjust for RGB 
    249249    } 
    250250    catch (Exception exc) { exc.printStackTrace(); } 
  • trunk/loci/formats/ReaderWrapper.java

    r1812 r1903  
    9898  } 
    9999 
     100  public int getEffectiveSizeC(String id) throws FormatException, IOException { 
     101    return reader.getEffectiveSizeC(id); 
     102  } 
     103 
    100104  public Double getChannelGlobalMinimum(String id, int theC) 
    101105    throws FormatException, IOException 
  • trunk/loci/formats/in/ND2Reader.java

    r1887 r1903  
    2525package loci.formats.in; 
    2626 
    27 import java.awt.Image; 
    2827import java.awt.image.*; 
    2928import java.io.*; 
    3029import java.util.StringTokenizer; 
     30import javax.imageio.*; 
    3131import loci.formats.*; 
    3232 
    33 /** ND2Reader is the file format reader for Nikon ND2 files. */ 
     33/**  
     34 * ND2Reader is the file format reader for Nikon ND2 files. 
     35 * The JAI library is required to use this reader; it is available from 
     36 * http://jai-imageio.dev.java.net.  Note that JAI is bundled with a version 
     37 * of the JJ2000 library, so it is important that either (1) the JJ2000 jar 
     38 * file is *not* in the classpath; or (2) the JAI jar file precedes JJ2000 in 
     39 * the classpath. 
     40 */ 
    3441public class ND2Reader extends FormatReader { 
    3542 
    3643  // -- Constants -- 
    3744 
    38   private static final String NO_JJ2000_MSG = 
    39     "You need to install JJ2000 from http://jj2000.epfl.ch"; 
     45  private static final String NO_JAI_MSG = 
     46    "You need to install JAI from http://jai-imageio.dev.java.net"; 
    4047 
    4148  // -- Static fields -- 
    42  
    43   private static boolean noJJ2000 = false; 
     49  
     50  private static boolean noJAI = false; 
    4451  private static ReflectedUniverse r = createReflectedUniverse(); 
    4552 
     
    4855    try { 
    4956      r = new ReflectedUniverse(); 
    50       r.exec("import colorspace.ColorSpace"); 
    51       r.exec("import jj2000.disp.BlkImgDataSrcImageProducer"); 
    52       r.exec("import jj2000.j2k.codestream.HeaderInfo"); 
    53       r.exec("import jj2000.j2k.codestream.reader.BitstreamReaderAgent"); 
    54       r.exec("import jj2000.j2k.codestream.reader.HeaderDecoder"); 
    55       r.exec("import jj2000.j2k.decoder.Decoder"); 
    56       r.exec("import jj2000.j2k.decoder.DecoderSpecs"); 
    57       r.exec("import jj2000.j2k.entropy.decoder.EntropyDecoder"); 
    5857      r.exec("import jj2000.j2k.fileformat.reader.FileFormatReader"); 
    59       r.exec("import jj2000.j2k.image.BlkImgDataSrc"); 
    60       r.exec("import jj2000.j2k.image.ImgDataConverter"); 
    61       r.exec("import jj2000.j2k.image.invcomptransf.InvCompTransf"); 
    6258      r.exec("import jj2000.j2k.io.BEBufferedRandomAccessFile"); 
    63       r.exec("import jj2000.j2k.quantization.dequantizer.Dequantizer"); 
    64       r.exec("import jj2000.j2k.roi.ROIDeScaler"); 
    65       r.exec("import jj2000.j2k.util.ParameterList"); 
    66       r.exec("import jj2000.j2k.wavelet.synthesis.InverseWT"); 
    67     } 
    68     catch (Throwable exc) { noJJ2000 = true; } 
     59    } 
     60    catch (Throwable exc) { noJAI = true; } 
    6961    return r; 
    7062  } 
    7163 
    7264  // -- Fields -- 
     65 
     66  /** Current file */ 
     67  private RandomAccessStream in; 
    7368 
    7469  /** Number of image planes in the file. */ 
     
    8075  /** Number of valid bits per pixel */ 
    8176  private int[] validBits; 
     77 
     78  private boolean rgb; 
    8279 
    8380  // -- Constructor -- 
     
    104101  public boolean isRGB(String id) throws FormatException, IOException { 
    105102    if (!id.equals(currentId)) initFile(id); 
    106     return sizeC[0] > 1; 
     103    return rgb; 
    107104  } 
    108105 
     
    114111  /** Returns whether or not the channels are interleaved. */ 
    115112  public boolean isInterleaved(String id) throws FormatException, IOException { 
    116     return false; 
     113    return true; 
    117114  } 
    118115 
     
    124121    throws FormatException, IOException 
    125122  { 
    126     if (noJJ2000) throw new FormatException(NO_JJ2000_MSG); 
    127123    if (!id.equals(currentId)) initFile(id); 
    128124 
     
    148144    throws FormatException, IOException 
    149145  { 
    150     if (noJJ2000) throw new FormatException(NO_JJ2000_MSG); 
    151146    if (!id.equals(currentId)) initFile(id); 
    152147    if (no < 0 || no >= getImageCount(id)) { 
     
    154149    } 
    155150 
    156     try { 
    157       r.exec("defpl = new ParameterList()"); 
    158       r.exec("tmpDec = new Decoder(defpl)"); 
    159       r.exec("param = tmpDec.getAllParameters()"); 
    160  
    161       String[][] param = (String[][]) r.getVar("param"); 
    162       for (int i=param.length-1; i>=0; i--) { 
    163         if (param[i][3] != null) { 
    164           r.setVar("key", param[i][0]); 
    165           r.setVar("value", param[i][3]); 
    166           r.exec("defpl.put(key, value)"); 
    167         } 
    168       } 
    169  
    170       r.exec("pl = new ParameterList(defpl)"); 
    171  
    172       int off = (int) offsets[no]; 
    173       r.setVar("off", off); 
    174  
    175       r.exec("in.seek(off)"); 
    176  
    177       r.exec("hi = new HeaderInfo()"); 
    178       r.exec("hd = new HeaderDecoder(in, pl, hi)"); 
    179  
    180       r.exec("numComponents = hd.getNumComps()"); 
    181       r.setVar("siz", r.getVar("hi.siz")); 
    182       r.exec("numTiles = siz.getNumTiles()"); 
    183       r.exec("specs = hd.getDecoderSpecs()"); 
    184  
    185       int[] depth = new int[((Integer) r.getVar("numComponents")).intValue()]; 
    186       for (int i=0; i<depth.length; i++) { 
    187         r.setVar("i", i); 
    188         r.exec("val = hd.getOriginalBitDepth(i)"); 
    189         depth[i] = ((Integer) r.getVar("val")).intValue(); 
    190       } 
    191  
    192       r.setVar("depth", depth); 
    193  
    194       r.setVar("false", false); 
    195       r.exec("breader = " + 
    196         "BitstreamReaderAgent.createInstance(in, hd, pl, specs, false, hi)"); 
    197       r.exec("entdec = hd.createEntropyDecoder(breader, pl)"); 
    198       r.exec("roi = hd.createROIDeScaler(entdec, pl, specs)"); 
    199       r.exec("deq = hd.createDequantizer(roi, depth, specs)"); 
    200  
    201       r.exec("invWT = InverseWT.createInstance(deq, specs)"); 
    202       r.exec("res = breader.getImgRes()"); 
    203       r.exec("invWT.setImgResLevel(res)"); 
    204       r.setVar("zero", 0); 
    205       r.exec("converter = new ImgDataConverter(invWT, zero)"); 
    206       r.exec("ictransf = new InvCompTransf(converter, specs, depth, pl)"); 
    207  
    208       boolean jpg2ff = ((Boolean) r.getVar("ff.JP2FFUsed")).booleanValue(); 
    209  
    210       if (jpg2ff) { 
    211         r.exec("csMap = new ColorSpace(in, hd, pl)"); 
    212         r.exec("channels = hd.createChannelDefinitionMapper(ictransf, csMap)"); 
    213         r.exec("resampled = hd.createResampler(channels, csMap)"); 
    214         r.exec("palettized = " + 
    215           "hd.createPalettizedColorSpaceMapper(resampled, csMap)"); 
    216         r.exec("color = hd.createColorSpaceMapper(palettized, csMap)"); 
    217       } 
    218       else r.exec("color = ictransf"); 
    219  
    220       r.setVar("decodedImage", r.getVar("color")); 
    221       if (r.getVar("color") == null) { 
    222         r.setVar("decodedImage", r.getVar("ictransf")); 
    223       } 
    224  
    225       r.exec("img = BlkImgDataSrcImageProducer.createImage(decodedImage)"); 
    226  
    227       Image img = (Image) r.getVar("img"); 
    228  
    229       int dataType = 0; 
    230       switch (pixelType[0]) { 
    231         case FormatReader.INT8: 
    232           throw new FormatException("Unsupported pixel type: int8"); 
    233         case FormatReader.UINT8: 
    234           dataType = DataBuffer.TYPE_BYTE; 
    235           break; 
    236         case FormatReader.INT16: 
    237           dataType = DataBuffer.TYPE_SHORT; 
    238           break; 
    239         case FormatReader.UINT16: 
    240           dataType = DataBuffer.TYPE_USHORT; 
    241           break; 
    242         case FormatReader.INT32: 
    243         case FormatReader.UINT32: 
    244           dataType = DataBuffer.TYPE_INT; 
    245           break; 
    246         case FormatReader.FLOAT: 
    247           dataType = DataBuffer.TYPE_FLOAT; 
    248           break; 
    249         case FormatReader.DOUBLE: 
    250           dataType = DataBuffer.TYPE_DOUBLE; 
    251           break; 
    252       } 
    253  
    254       ColorModel cm = ImageTools.makeColorModel(sizeC[0], dataType, validBits); 
    255       return ImageTools.makeBuffered(img); 
    256     } 
    257     catch (ReflectException e) { 
    258       throw new FormatException(e); 
    259     } 
     151    in.seek(offsets[no]); 
     152 
     153    byte[] b = new byte[0]; 
     154    
     155    if (no < getImageCount(id) - 1) { 
     156      b = new byte[(int) (offsets[no + 1] - offsets[no])]; 
     157    } 
     158    else b = new byte[(int) (in.length() - offsets[no])];  
     159    in.read(b); 
     160 
     161    BufferedImage img = ImageIO.read(new ByteArrayInputStream(b)); 
     162 
     163    int dataType = 0; 
     164    switch (pixelType[0]) { 
     165      case FormatReader.INT8: 
     166        throw new FormatException("Unsupported pixel type: int8"); 
     167      case FormatReader.UINT8: 
     168        dataType = DataBuffer.TYPE_BYTE; 
     169        break; 
     170      case FormatReader.INT16: 
     171        dataType = DataBuffer.TYPE_SHORT; 
     172        break; 
     173      case FormatReader.UINT16: 
     174        dataType = DataBuffer.TYPE_USHORT; 
     175        break; 
     176      case FormatReader.INT32: 
     177      case FormatReader.UINT32: 
     178        dataType = DataBuffer.TYPE_INT; 
     179        break; 
     180      case FormatReader.FLOAT: 
     181        dataType = DataBuffer.TYPE_FLOAT; 
     182        break; 
     183      case FormatReader.DOUBLE: 
     184        dataType = DataBuffer.TYPE_DOUBLE; 
     185        break; 
     186    } 
     187 
     188    ColorModel cm = ImageTools.makeColorModel(sizeC[0], dataType, validBits); 
     189    return ImageTools.makeBuffered(img); 
    260190  } 
    261191 
     
    267197  /** Initializes the given ND2 file. */ 
    268198  protected void initFile(String id) throws FormatException, IOException { 
    269     if (noJJ2000) throw new FormatException(NO_JJ2000_MSG); 
     199    if (noJAI) throw new FormatException(NO_JAI_MSG); 
    270200    super.initFile(id); 
     201 
     202    // make sure that a JPEG 2000 reader is available 
     203    String[] fnames = ImageIO.getReaderFormatNames(); 
     204    boolean foundReader = false; 
     205    for (int i=0; i<fnames.length; i++) { 
     206      foundReader = fnames[i].equals("JPEG 2000"); 
     207      if (foundReader) i = fnames.length; 
     208    } 
     209    if (!foundReader) throw new FormatException(NO_JAI_MSG); 
     210 
     211    in = new RandomAccessStream(getMappedId(id)); 
    271212 
    272213    try { 
     
    274215      r.setVar("read", "r"); 
    275216      r.exec("in = new BEBufferedRandomAccessFile(id, read)"); 
    276       r.exec("ff = new FileFormatReader(in)"); 
     217      r.setVar("j2kMetadata", null); 
     218      r.exec("ff = new FileFormatReader(in, j2kMetadata)"); 
    277219 
    278220      r.exec("ff.readFileFormat()"); 
     
    281223    } 
    282224    catch (ReflectException e) { throw new FormatException(e); } 
     225 
    283226    numImages = offsets.length; 
    284227 
    285228    pixelType[0] = FormatReader.UINT8; 
     229 
    286230    BufferedImage img = openImage(id, 0); 
    287  
    288231    sizeX[0] = img.getWidth(); 
    289232    sizeY[0] = img.getHeight(); 
     233    rgb = img.getRaster().getNumBands() > 1; 
    290234 
    291235    int numInvalid = 0; 
     
    311255    // read XML metadata from the end of the file 
    312256 
    313     RandomAccessStream ras = new RandomAccessStream(getMappedId(id)); 
    314     ras.seek(offsets[offsets.length - 1]); 
     257    in.seek(offsets[offsets.length - 1]); 
    315258 
    316259    boolean found = false; 
     
    319262    while (!found) { 
    320263      int read = 0; 
    321       if (ras.getFilePointer() == offsets[offsets.length - 1]) { 
    322         read = ras.read(buf); 
     264      if (in.getFilePointer() == offsets[offsets.length - 1]) { 
     265        read = in.read(buf); 
    323266      } 
    324267      else { 
    325268        System.arraycopy(buf, buf.length - 10, buf, 0, 10); 
    326         read = ras.read(buf, 10, buf.length - 10); 
     269        read = in.read(buf, 10, buf.length - 10); 
    327270      } 
    328271 
     
    331274        if (buf[i] == (byte) 0xff && buf[i+1] == (byte) 0xd9) { 
    332275          found = true; 
    333           off = (int) (ras.getFilePointer() - (read+10) + i); 
     276          off = (int) (in.getFilePointer() - (read+10) + i); 
    334277          i = buf.length; 
    335278          break; 
     
    338281    } 
    339282 
    340     if (off > 0 && off < ras.length() - 5) { 
    341       ras.seek(off + 5); 
    342       byte[] b = new byte[(int) (ras.length() - off)]; 
    343       ras.read(b); 
     283    if (off > 0 && off < in.length() - 5) { 
     284      in.seek(off + 5); 
     285      byte[] b = new byte[(int) (in.length() - off)]; 
     286      in.read(b); 
    344287      String xml = new String(b); 
    345288 
     
    428371    else sizeC[0] = img.getRaster().getNumBands(); 
    429372 
    430     sizeT[0] = numImages; 
     373    sizeT[0] = numImages / (!rgb ? sizeC[0] : 1); 
    431374    sizeZ[0] = 1; 
    432375    orderCertain[0] = false; 
    433     currentOrder[0] = sizeC[0] == 3 ? "XYCTZ" : "XYTZC"; 
     376    currentOrder[0] = sizeC[0] > 1 ? "XYCTZ" : "XYTZC"; 
    434377    pixelType[0] = ImageTools.getPixelType(img); 
    435378 
     379    if (!rgb) { 
     380      while (sizeC[0] * sizeT[0] * sizeZ[0] < numImages) numImages--; 
     381    } 
     382 
    436383    if (bits != 0) { 
    437       validBits = new int[sizeC[0]]; 
     384      validBits = new int[sizeC[0] == 2 ? 3 : sizeC[0]]; 
    438385      for (int i=0; i<validBits.length; i++) validBits[i] = bits; 
    439386    } 
  • trunk/loci/formats/in/ZeissZVIReader.java

    r1884 r1903  
    486486      r.setVar("dir", dir); 
    487487      r.exec("dirName = dir.getName()"); 
     488       
    488489      if (isInstance)  { 
    489490        parseDir(depth + 1, r.getVar("entry")); 
     
    503504        String entryName = (String) r.getVar("entryName"); 
    504505        String dirName = (String) r.getVar("dirName"); 
     506 
     507        /* debug */ System.out.println(dirName + " - " + entryName); 
    505508 
    506509        boolean isContents = entryName.toUpperCase().equals("CONTENTS"); 
     
    699702          pt += 4; 
    700703 
     704          /* debug */ System.out.println("version : " + version); 
     705 
    701706          int vt = DataTools.bytesToInt(data, pt, 2, true); 
    702707          pt += 2; 
     
    730735          pt += 6; 
    731736 
     737          /* debug */ System.out.println("dimensions : (" + width + "x" +  
     738            height + ")"); 
     739 
    732740          int zDepth = DataTools.bytesToInt(data, pt, 4, true); 
    733741          pt += 6; 
     
    739747          pt += 4; 
    740748 
     749          /* debug */ System.out.println("num images : " + numImageContainers); 
     750 
    741751          // VT_CLSID - PluginCLSID 
    742752          while (DataTools.bytesToInt(data, pt, 2, true) != 65) { 
     
    773783 
    774784          pt = oldPt + 4 + len; 
    775  
     785       
    776786          boolean foundWidth = DataTools.bytesToInt(data, pt, 4, true) == width; 
    777787          boolean foundHeight = 
    778788            DataTools.bytesToInt(data, pt + 4, 4, true) == height; 
    779           while (!foundWidth || !foundHeight) { 
    780             pt++; 
    781             foundWidth = DataTools.bytesToInt(data, pt, 4, true) == width; 
    782             foundHeight = DataTools.bytesToInt(data, pt + 4, 4, true) == height; 
     789          try { 
     790            while (!foundWidth || !foundHeight) { 
     791              pt++; 
     792              foundWidth = DataTools.bytesToInt(data, pt, 4, true) == width; 
     793              foundHeight =  
     794                DataTools.bytesToInt(data, pt + 4, 4, true) == height; 
     795            } 
    783796          } 
     797          catch (Exception e) { }  
    784798          pt -= 8; 
    785799 
     
    789803            (dirName.equals("Image") && numImageContainers == 0)) 
    790804          { 
     805            if (data.length - pt <= 0) pt = oldPt + 4 + len; 
    791806            byte[] o = new byte[data.length - pt]; 
    792807            System.arraycopy(data, pt, o, 0, o.length); 
Note: See TracChangeset for help on using the changeset viewer.