Changeset 1385


Ignore:
Timestamp:
08/30/06 08:39:28 (14 years ago)
Author:
melissa
Message:
  • fixed a bug in how Zeiss LSM files are handled by TiffTools (files in zeiss-lsm/josh/ work now)
  • implemented new API methods for handling multiple series in Leica LIF reader
  • added logic to Bio-Formats importer to handle multiple series
Location:
trunk/loci
Files:
8 edited

Legend:

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

    r1358 r1385  
    4545  /** Number of planes between channels. */ 
    4646  private int between; 
    47  
    48   /** Number of images reported by reader. */ 
    49   private int readerImages; 
    50  
    51   /** Number of images reported by ChannelMerger. */ 
    52   private int ourImages; 
    5347 
    5448  // -- Constructors -- 
     
    7266    if (!id.equals(currentId)) initFile(id); 
    7367 
    74     int originalImages = readerImages; 
     68    int originalImages = reader.getImageCount(id); 
    7569 
    7670    if (canMerge(id)) { 
     
    197191    if (!id.equals(currentId)) initFile(id); 
    198192    return reader.getDimensionOrder(id); 
     193  } 
     194 
     195  /** Return the number of series in this file. */ 
     196  public int getSeriesCount(String id) throws FormatException, IOException { 
     197    if (!id.equals(currentId)) initFile(id); 
     198    return reader.getSeriesCount(id); 
     199  } 
     200 
     201  /** Activates the specified series. */ 
     202  public void setSeries(String id, int no) throws FormatException, IOException { 
     203    if (no < 0 || no >= getSeriesCount(id)) { 
     204      throw new FormatException("Invalid series: " + no); 
     205    } 
     206    series = no; 
     207    reader.setSeries(id, no); 
    199208  } 
    200209 
     
    290299    dimensions[2] = getSizeT(id); 
    291300 
    292     readerImages = reader.getImageCount(id); 
    293     ourImages = getImageCount(id); 
    294301    currentId = id; 
    295302 
     
    308315    throws FormatException, IOException 
    309316  { 
    310     int[] real = new int[readerImages / ourImages]; 
     317    int[] real = new int[reader.getImageCount(id) / getImageCount(id)]; 
    311318 
    312319    while (order.length() > 3) order = order.substring(1); 
  • trunk/loci/formats/FileStitcher.java

    r1358 r1385  
    156156  /** Determines the number of images in the given file. */ 
    157157  public int getImageCount(String id) throws FormatException, IOException { 
    158     if (!id.equals(currentId)) initFile(id); 
     158    initFile(id); 
    159159    return numImages; 
    160160  } 
     
    167167  /** Get the size of the X dimension. */ 
    168168  public int getSizeX(String id) throws FormatException, IOException { 
    169     if (!id.equals(currentId)) initFile(id); 
     169    initFile(id); 
    170170    return dimensions[0]; 
    171171  } 
     
    173173  /** Get the size of the Y dimension. */ 
    174174  public int getSizeY(String id) throws FormatException, IOException { 
    175     if (!id.equals(currentId)) initFile(id); 
     175    initFile(id); 
    176176    return dimensions[1]; 
    177177  } 
     
    179179  /** Get the size of the Z dimension. */ 
    180180  public int getSizeZ(String id) throws FormatException, IOException { 
    181     if (!id.equals(currentId)) initFile(id); 
     181    initFile(id); 
    182182    return dimensions[2]; 
    183183  } 
     
    185185  /** Get the size of the C dimension. */ 
    186186  public int getSizeC(String id) throws FormatException, IOException { 
    187     if (!id.equals(currentId)) initFile(id); 
     187    initFile(id); 
    188188    return dimensions[3]; 
    189189  } 
     
    191191  /** Get the size of the T dimension. */ 
    192192  public int getSizeT(String id) throws FormatException, IOException { 
    193     if (!id.equals(currentId)) initFile(id); 
     193    initFile(id); 
    194194    return dimensions[4]; 
    195195  } 
     
    209209    if (!id.equals(currentId)) initFile(id); 
    210210    return order; 
     211  } 
     212 
     213  /** Return the number of series in this file. */ 
     214  public int getSeriesCount(String id) throws FormatException, IOException { 
     215    if (!id.equals(currentId)) initFile(id); 
     216    return reader.getSeriesCount(id); 
     217  } 
     218 
     219  /** Activates the specified series. */ 
     220  public void setSeries(String id, int no) throws FormatException, IOException { 
     221    if (no < 0 || no >= getSeriesCount(id)) { 
     222      throw new FormatException("Invalid series: " + no); 
     223    } 
     224    series = no; 
     225    reader.setSeries(id, no); 
    211226  } 
    212227 
     
    308323 
    309324    MetadataStore s = reader.getMetadataStore(id); 
    310     s.setPixels(new Integer(getSizeX(id)), new Integer(getSizeY(id)), 
    311       new Integer(getSizeZ(id)), new Integer(getSizeC(id)), 
    312       new Integer(getSizeT(id)), null, null, null, null); 
     325    s.setPixels(new Integer(dimensions[0]), new Integer(dimensions[1]), 
     326      new Integer(dimensions[2]), new Integer(dimensions[3]), 
     327      new Integer(dimensions[3]), null, null, null, null); 
    313328    setMetadataStore(s); 
    314329  } 
  • trunk/loci/formats/FormatReader.java

    r1376 r1385  
    171171    return images; 
    172172  } 
    173   
     173 
    174174  /** Return the number of series in this file. */ 
    175175  public int getSeriesCount(String id) throws FormatException, IOException { 
     
    184184    } 
    185185    series = no; 
     186  } 
     187 
     188  /** Returns the currently active series. */ 
     189  public int getSeries(String id) throws FormatException, IOException { 
     190    if (!id.equals(currentId)) initFile(id); 
     191    return series; 
    186192  } 
    187193 
     
    420426    int start = 0; 
    421427    int end = 0; 
     428    int series = 0; 
    422429    if (args != null) { 
    423430      for (int i=0; i<args.length; i++) { 
     
    437444            catch (Exception e) { } 
    438445          } 
     446          else if (args[i].equals("-series")) { 
     447            try { 
     448              series = Integer.parseInt(args[i + 1]); 
     449              i++; 
     450            } 
     451            catch (Exception e) { } 
     452          } 
    439453          else System.out.println("Ignoring unknown command flag: " + args[i]); 
    440454        } 
     
    451465      System.out.println("  java " + className + " [-nopix]"); 
    452466      System.out.println("    [-merge] [-stitch] [-separate] [-omexml] " + 
    453         "[-range start [end]] file"); 
     467        "[-range start [end]] [-series num] file"); 
    454468      return false; 
    455469    } 
     
    477491      long s1 = System.currentTimeMillis(); 
    478492      reader.setSeparated(separate); 
     493      reader.setSeries(id, series); 
    479494      int num = reader.getImageCount(id); 
    480495      if (end == 0 || end > num) end = num; 
  • trunk/loci/formats/IFormatReader.java

    r1376 r1385  
    8181    throws FormatException, IOException; 
    8282 
     83  /** Obtains a thumbnail for the specified image from the given file. */ 
     84  //BufferedImage openThumbImage(String id, int no) 
     85  //  throws FormatException, IOException; 
     86 
     87  /** 
     88   * Obtains a thumbnail for the specified image from the given file, 
     89   * as a byte array. 
     90   */ 
     91  //byte[] openThumbBytes(String id, int no) 
     92  //  throws FormatException, IOException; 
     93 
    8394  /** Closes the currently open file. */ 
    8495  void close() throws FormatException, IOException; 
    85  
    8696 
    8797  /** 
     
    98108  /** Activates the specified series. */ 
    99109  void setSeries(String id, int no) throws FormatException, IOException; 
     110 
     111  /** Returns the currently active series. */ 
     112  int getSeries(String id) throws FormatException, IOException; 
    100113 
    101114  /** 
  • trunk/loci/formats/ImageReader.java

    r1376 r1385  
    247247    return readers[index].getDimensionOrder(id); 
    248248  } 
    249   
     249 
    250250  /** Return the number of series in the file. */ 
    251251  public int getSeriesCount(String id) throws FormatException, IOException { 
     
    258258    if (!id.equals(currentId)) initFile(id); 
    259259    readers[index].setSeries(id, no); 
     260  } 
     261 
     262  /** Returns the currently active series. */ 
     263  public int getSeries(String id) throws FormatException, IOException { 
     264    if (!id.equals(currentId)) initFile(id); 
     265    return readers[index].getSeries(id); 
    260266  } 
    261267 
  • trunk/loci/formats/TiffTools.java

    r1334 r1385  
    839839      // iterate through each item 
    840840 
    841       // for now, each array should only have one entry 
    842       // this is because we don't have support for planar formats, like 
    843       // Zeiss LSM 
    844  
    845       rowsPerStripArray = new long[1]; 
     841      if (bitsPerSample.length == 2 || 
     842        bitsPerSample[bitsPerSample.length - 1] == 0) 
     843      { 
     844        int t = bitsPerSample[0]; 
     845        bitsPerSample = new int[1]; 
     846        bitsPerSample[0] = t; 
     847      } 
     848 
     849      rowsPerStripArray = new long[bitsPerSample.length]; 
    846850 
    847851      long temp = stripByteCounts[0]; 
    848       stripByteCounts = new long[1]; 
    849       stripByteCounts[0] = temp; 
     852      stripByteCounts = new long[bitsPerSample.length]; 
     853      for (int i=0; i<stripByteCounts.length; i++) stripByteCounts[i] = temp; 
    850854      temp = bitsPerSample[0]; 
    851       bitsPerSample = new int[1]; 
    852       bitsPerSample[0] = (int) temp; 
     855      if (temp == 0) temp = 8; 
     856      bitsPerSample = new int[bitsPerSample.length]; 
     857      for (int i=0; i<bitsPerSample.length; i++) bitsPerSample[i] = (int) temp; 
    853858      temp = stripOffsets[0]; 
    854       stripOffsets = new long[1]; 
    855       stripOffsets[0] = temp; 
    856  
    857       if (bitsPerSample[0] == 0) bitsPerSample[0] = 8; 
     859      stripOffsets = new long[bitsPerSample.length]; 
     860      for (int i=0; i<bitsPerSample.length; i++) { 
     861        stripOffsets[i] = i == 0 ? temp : 
     862          stripOffsets[i - 1] + stripByteCounts[i]; 
     863      } 
    858864 
    859865      // we have two files that reverse the endianness for BitsPerSample, 
     
    906912        compression == UNCOMPRESSED) 
    907913      { 
    908         stripByteCounts[0] = imageWidth * imageLength * (bitsPerSample[0] / 8); 
    909         stripOffsets[0] = (int) (in.length() - stripByteCounts[0] - 
    910           48 * imageWidth); 
    911         byte[] row = new byte[(int) imageWidth]; 
    912         in.seek((int) stripOffsets[0]); 
    913         in.read(row); 
    914         boolean isZero = true; 
    915         for (int i=0; i<row.length; i++) { 
    916           if (row[i] != 0) { 
    917             isZero = false; 
    918             break; 
     914        for (int i=0; i<stripByteCounts.length; i++) { 
     915          stripByteCounts[i] = 
     916            imageWidth * imageLength * (bitsPerSample[i] / 8); 
     917          stripOffsets[0] = (int) (in.length() - stripByteCounts[0] - 
     918            48 * imageWidth); 
     919          if (i != 0) { 
     920            stripOffsets[i] = stripOffsets[i - 1] + stripByteCounts[i]; 
    919921          } 
    920         } 
    921  
    922         while (isZero) { 
    923           stripOffsets[0] -= row.length; 
    924           in.seek((int) stripOffsets[0]); 
     922 
     923          byte[] row = new byte[(int) imageWidth]; 
     924          in.seek((int) stripOffsets[i]); 
    925925          in.read(row); 
    926           for (int i=0; i<row.length; i++) { 
    927             if (row[i] != 0) { 
     926          boolean isZero = true; 
     927          for (int j=0; j<row.length; j++) { 
     928            if (row[j] != 0) { 
    928929              isZero = false; 
    929               stripOffsets[0] -= (stripByteCounts[0] - row.length); 
    930930              break; 
    931931            } 
    932932          } 
    933         } 
    934  
     933 
     934          while (isZero) { 
     935            stripOffsets[i] -= row.length; 
     936            in.seek((int) stripOffsets[i]); 
     937            in.read(row); 
     938            for (int j=0; j<row.length; j++) { 
     939              if (row[j] != 0) { 
     940                isZero = false; 
     941                stripOffsets[i] -= (stripByteCounts[i] - row.length); 
     942                break; 
     943              } 
     944            } 
     945          } 
     946        } 
    935947      } 
    936948 
  • trunk/loci/formats/in/LIFReader.java

    r1367 r1385  
    7171  private int bpp; 
    7272 
    73   private int maxZ, maxT, maxEx; 
    74    
    75  
    7673  // -- Constructor -- 
    7774 
     
    9087  public int getImageCount(String id) throws FormatException, IOException { 
    9188    if (!id.equals(currentId)) initFile(id); 
    92     return (!isRGB(id) || !separated) ? numImages : dims[0][4] * numImages; 
     89    numImages = dims[series][2]  * dims[series][3]; 
     90    return (!isRGB(id) || !separated) ? numImages : dims[series][4] * numImages; 
    9391  } 
    9492 
     
    9694  public boolean isRGB(String id) throws FormatException, IOException { 
    9795    if (!id.equals(currentId)) initFile(id); 
    98     return dims[0][4] > 1; 
     96    return dims[series][4] > 1; 
    9997  } 
    10098 
     
    102100  public int getSizeX(String id) throws FormatException, IOException { 
    103101    if (!id.equals(currentId)) initFile(id); 
    104  
    105     int max = 0; 
    106     int maxIndex = 0; 
    107     for (int i=0; i<dims.length; i++) { 
    108       if (dims[i][0] > max) { 
    109         max = dims[i][0]; 
    110         maxIndex = i; 
    111       } 
    112     } 
    113  
    114     return dims[maxIndex][0]; 
     102    return dims[series][0]; 
    115103  } 
    116104 
     
    118106  public int getSizeY(String id) throws FormatException, IOException { 
    119107    if (!id.equals(currentId)) initFile(id); 
    120     int max = 0; 
    121     int maxIndex = 0; 
    122     for (int i=0; i<dims.length; i++) { 
    123       if (dims[i][1] > max) { 
    124         max = dims[i][1]; 
    125         maxIndex = i; 
    126       } 
    127     } 
    128  
    129     return dims[maxIndex][1]; 
     108    return dims[series][1]; 
    130109  } 
    131110 
     
    133112  public int getSizeZ(String id) throws FormatException, IOException { 
    134113    if (!id.equals(currentId)) initFile(id); 
    135     if (maxZ == dims.length) maxT *= maxEx; 
    136     else if (maxT == dims.length) maxZ *= maxEx; 
    137     else { 
    138       maxZ *= maxT; 
    139       maxT = dims.length; 
    140     } 
    141     return maxZ == 1 ? dims.length : maxZ; 
     114    return dims[series][2]; 
    142115  } 
    143116 
     
    145118  public int getSizeC(String id) throws FormatException, IOException { 
    146119    if (!id.equals(currentId)) initFile(id); 
    147     return dims[0][4]; 
     120    return dims[series][4]; 
    148121  } 
    149122 
     
    151124  public int getSizeT(String id) throws FormatException, IOException { 
    152125    if (!id.equals(currentId)) initFile(id); 
    153     if (maxZ == dims.length) maxT *= maxEx; 
    154     else if (maxT == dims.length) maxZ *= maxEx; 
    155     else { 
    156       maxZ *= maxT; 
    157       maxT = dims.length; 
    158     } 
    159     return maxT == 1 ? dims.length : maxT; 
     126    return dims[series][3]; 
    160127  } 
    161128 
     
    179146  } 
    180147 
     148  /** Return the number of series in this file. */ 
     149  public int getSeriesCount(String id) throws FormatException, IOException { 
     150    if (!id.equals(currentId)) initFile(id); 
     151    return dims.length; 
     152  } 
     153 
    181154  /** Obtains the specified image from the given LIF file as a byte array. */ 
    182155  public byte[] openBytes(String id, int no) 
     
    194167    int t = getSizeT(id); 
    195168 
    196     int dataset = ((t == dims.length) ? no / z : no / t); 
    197  
    198     width = dims[dataset][0]; 
    199     height = dims[dataset][1]; 
    200     c = dims[dataset][4]; 
     169    width = dims[series][0]; 
     170    height = dims[series][1]; 
     171    c = dims[series][4]; 
    201172    if (c == 2) c--; 
    202     bpp = dims[dataset][5]; 
     173    bpp = dims[series][5]; 
    203174    while (bpp % 8 != 0) bpp++; 
    204175    int bytesPerPixel = bpp / 8; 
    205176 
    206     int offset = ((Long) offsets.get(dataset)).intValue(); 
     177    int offset = ((Long) offsets.get(series)).intValue(); 
    207178 
    208179    // get the image number within this dataset 
    209180 
    210     int imageNum = ((t == dims.length) ? no % z : no % t); 
    211  
    212     in.seek(offset + width * height * bytesPerPixel * imageNum * c); 
     181    in.seek(offset + width * height * bytesPerPixel * no * c); 
    213182 
    214183    byte[] data = new byte[(int) (width * height * bytesPerPixel * c)]; 
    215     if (imageNum < dims[dataset][2] * dims[dataset][3] * (separated ? c : 1)) { 
    216       in.read(data); 
    217     } 
     184    in.read(data); 
    218185 
    219186    if (isRGB(id) && separated) { 
     
    438405      dims[i][6] = ((Integer) extraDims.get(i)).intValue(); 
    439406 
     407      if (dims[i][6] > 1) { 
     408        if (dims[i][2] == 1) dims[i][2] = dims[i][6]; 
     409        else dims[i][3] *= dims[i][6]; 
     410        dims[i][6] = 1; 
     411      } 
     412 
    440413      numImages += (dims[i][2] * dims[i][3] * dims[i][6]); 
    441414    } 
    442  
    443     for (int i=0; i<numDatasets; i++) { 
    444       if (dims[i][2] > maxZ) maxZ = dims[i][2]; 
    445       if (dims[i][3] > maxT) maxT = dims[i][3]; 
    446       if (dims[i][6] > maxEx) maxEx = dims[i][6]; 
    447     }       
    448      
    449     if (maxEx > 1) { 
    450       if (maxT == 1) maxT = maxEx; 
    451       else if (maxZ == 1) maxZ = maxEx; 
    452       maxEx = 1; 
    453     } 
    454  
    455     numImages = maxZ * maxT * numDatasets; 
    456415 
    457416    // Populate metadata store 
     
    468427      } 
    469428 
    470       store.setPixels( 
    471         new Integer(getSizeX(currentId)), // SizeX 
    472         new Integer(getSizeY(currentId)), // SizeY 
    473         new Integer(getSizeZ(currentId)), // SizeZ 
    474         new Integer(getSizeC(currentId)), // SizeC 
    475         new Integer(getSizeT(currentId)), // SizeT 
    476         type, // PixelType 
    477         new Boolean(!littleEndian), // BigEndian 
    478         getDimensionOrder(currentId), // DimensionOrder 
    479         null); // Index 
     429      for (int i=0; i<numDatasets; i++) { 
     430        store.setPixels( 
     431          new Integer(dims[i][0]), // SizeX 
     432          new Integer(dims[i][1]), // SizeY 
     433          new Integer(dims[i][2]), // SizeZ 
     434          new Integer(dims[i][4]), // SizeC 
     435          new Integer(dims[i][3]), // SizeT 
     436          type, // PixelType 
     437          new Boolean(!littleEndian), // BigEndian 
     438          getDimensionOrder(currentId), // DimensionOrder 
     439          new Integer(i)); // Index 
     440      } 
    480441    } 
    481442    catch (Exception e) { } 
  • trunk/loci/plugins/LociImporter.java

    r1368 r1385  
    129129    try { 
    130130      FormatReader r = (FormatReader) reader.getReader(id); 
    131       FileStitcher fs = new FileStitcher(r); 
    132       ChannelMerger cm = new ChannelMerger(stitchFiles ? fs : r); 
    133       cm.setSeparated(!mergeChannels); 
     131      if (stitchFiles) r = new FileStitcher(r); 
     132      if (mergeChannels) r = new ChannelMerger(r); 
     133 
     134      // if necessary, prompt for the series to open 
     135 
     136      GenericDialog datasets = 
     137        new GenericDialog("LOCI Bio-Formats Series Chooser"); 
     138 
     139      for (int i=0; i<r.getSeriesCount(id); i++) { 
     140        datasets.addCheckbox("Series " + i, i == 0); 
     141      } 
     142      if (r.getSeriesCount(id) > 1) datasets.showDialog(); 
     143 
     144      boolean[] series = new boolean[r.getSeriesCount(id)]; 
     145      for (int i=0; i<series.length; i++) { 
     146        series[i] = datasets.getNextBoolean(); 
     147      } 
     148 
     149      r.setSeparated(!mergeChannels); 
    134150 
    135151      try { 
    136152        OMEXMLMetadataStore store = new OMEXMLMetadataStore(); 
    137153        store.createRoot(); 
    138         cm.setMetadataStore(store); 
     154        r.setMetadataStore(store); 
    139155      } 
    140156      catch (Throwable t) { } 
    141157 
    142       int num = cm.getImageCount(id); 
    143158      if (showMetadata) { 
    144         Hashtable meta = cm.getMetadata(id); 
     159        Hashtable meta = r.getMetadata(id); 
    145160        MetadataPane mp = new MetadataPane(meta); 
    146161        JFrame frame = new JFrame(id + " Metadata"); 
     
    150165        frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); 
    151166      } 
    152       ImageStack stackB = null, stackS = null, stackF = null, stackO = null; 
    153       long start = System.currentTimeMillis(); 
    154       long time = start; 
    155       int channels = cm.getSizeC(id); 
    156  
    157       FileInfo fi = new FileInfo(); 
    158       try { 
    159         fi.description = 
    160           ((OMEXMLMetadataStore) cm.getMetadataStore(id)).dumpXML(); 
    161       } 
    162       catch (Throwable t) { } 
    163  
    164       for (int i=0; i<num; i++) { 
    165         // limit message update rate 
    166         long clock = System.currentTimeMillis(); 
    167         if (clock - time >= 50) { 
    168           IJ.showStatus("Reading plane " + (i + 1) + "/" + num); 
    169           time = clock; 
    170         } 
    171         IJ.showProgress((double) i / num); 
    172         BufferedImage img = cm.openImage(id, i); 
    173         img = ImageTools.padImage(img, cm.getSizeX(id), cm.getSizeY(id)); 
    174  
    175         ImageProcessor ip = null; 
    176         WritableRaster raster = img.getRaster(); 
    177         int c = raster.getNumBands(); 
    178         int tt = raster.getTransferType(); 
    179         int w = img.getWidth(), h = img.getHeight(); 
    180         if (c == 1) { 
    181           if (tt == DataBuffer.TYPE_BYTE) { 
    182             byte[] b = ImageTools.getBytes(img)[0]; 
    183             if (b.length > w*h) { 
    184               byte[] tmp = b; 
    185               b = new byte[w*h]; 
    186               System.arraycopy(tmp, 0, b, 0, b.length); 
     167 
     168      for (int i=0; i<series.length; i++) { 
     169        while (!series[i] && i < series.length - 1) { i++; } 
     170        if (!series[i]) { break; } 
     171        r.setSeries(id, i); 
     172 
     173        FileInfo fi = new FileInfo(); 
     174        try { 
     175          fi.description = 
     176            ((OMEXMLMetadataStore) r.getMetadataStore(id)).dumpXML(); 
     177        } 
     178        catch (Throwable t) { } 
     179 
     180        long start = System.currentTimeMillis(); 
     181        long time = start; 
     182        int num = r.getImageCount(id); 
     183        ImageStack stackB = null, stackS = null, stackF = null, stackO = null; 
     184        int channels = r.getSizeC(id); 
     185 
     186        for (int j=0; j<num; j++) { 
     187          // limit message update rate 
     188          long clock = System.currentTimeMillis(); 
     189          if (clock - time >= 50) { 
     190            IJ.showStatus("Reading plane " + (j + 1) + "/" + num); 
     191            time = clock; 
     192          } 
     193          IJ.showProgress((double) j / num); 
     194          BufferedImage img = r.openImage(id, j); 
     195          img = ImageTools.padImage(img, r.getSizeX(id), r.getSizeY(id)); 
     196 
     197          ImageProcessor ip = null; 
     198          WritableRaster raster = img.getRaster(); 
     199          int c = raster.getNumBands(); 
     200          int tt = raster.getTransferType(); 
     201          int w = img.getWidth(), h = img.getHeight(); 
     202          if (c == 1) { 
     203            if (tt == DataBuffer.TYPE_BYTE) { 
     204              byte[] b = ImageTools.getBytes(img)[0]; 
     205              if (b.length > w*h) { 
     206                byte[] tmp = b; 
     207                b = new byte[w*h]; 
     208                System.arraycopy(tmp, 0, b, 0, b.length); 
     209              } 
     210              ip = new ByteProcessor(w, h, b, null); 
     211              if (stackB == null) stackB = new ImageStack(w, h); 
     212              stackB.addSlice(fileName + ":" + (j + 1), ip); 
    187213            } 
    188             ip = new ByteProcessor(w, h, b, null); 
    189             if (stackB == null) stackB = new ImageStack(w, h); 
    190             stackB.addSlice(fileName + ":" + (i + 1), ip); 
    191           } 
    192           else if (tt == DataBuffer.TYPE_USHORT) { 
    193             short[] s = ImageTools.getShorts(img)[0]; 
    194             if (s.length > w*h) { 
    195               short[] tmp = s; 
    196               s = new short[w*h]; 
    197               System.arraycopy(tmp, 0, s, 0, s.length); 
     214            else if (tt == DataBuffer.TYPE_USHORT) { 
     215              short[] s = ImageTools.getShorts(img)[0]; 
     216              if (s.length > w*h) { 
     217                short[] tmp = s; 
     218                s = new short[w*h]; 
     219                System.arraycopy(tmp, 0, s, 0, s.length); 
     220              } 
     221              ip = new ShortProcessor(w, h, s, null); 
     222              if (stackS == null) stackS = new ImageStack(w, h); 
     223              stackS.addSlice(fileName + ":" + (j + 1), ip); 
    198224            } 
    199             ip = new ShortProcessor(w, h, s, null); 
    200             if (stackS == null) stackS = new ImageStack(w, h); 
    201             stackS.addSlice(fileName + ":" + (i + 1), ip); 
    202           } 
    203           else if (tt == DataBuffer.TYPE_FLOAT) { 
    204             float[] f = ImageTools.getFloats(img)[0]; 
    205             if (f.length > w*h) { 
    206               float[] tmp = f; 
    207               f = new float[w*h]; 
    208               System.arraycopy(tmp, 0, f, 0, f.length); 
     225            else if (tt == DataBuffer.TYPE_FLOAT) { 
     226              float[] f = ImageTools.getFloats(img)[0]; 
     227              if (f.length > w*h) { 
     228                float[] tmp = f; 
     229                f = new float[w*h]; 
     230                System.arraycopy(tmp, 0, f, 0, f.length); 
     231              } 
     232              ip = new FloatProcessor(w, h, f, null); 
     233              if (stackF == null) stackF = new ImageStack(w, h); 
     234              stackF.addSlice(fileName + ":" + (j + 1), ip); 
    209235            } 
    210             ip = new FloatProcessor(w, h, f, null); 
    211             if (stackF == null) stackF = new ImageStack(w, h); 
    212             stackF.addSlice(fileName + ":" + (i + 1), ip); 
    213           } 
    214         } 
    215         if (ip == null) { 
    216           ip = new ImagePlus(null, img).getProcessor(); // slow 
    217           if (stackO == null) stackO = new ImageStack(w, h); 
    218           stackO.addSlice(fileName + ":" + (i + 1), ip); 
    219         } 
    220       } 
    221       IJ.showStatus("Creating image"); 
    222       IJ.showProgress(1); 
    223       ImagePlus ip = null; 
    224       if (stackB != null) { 
    225         if (!mergeChannels && splitWindows) { 
    226           slice(stackB, fileName, channels, fi); 
    227         } 
    228         else ip = new ImagePlus(fileName, stackB); 
    229       } 
    230       if (stackS != null) { 
    231         if (!mergeChannels && splitWindows) { 
    232           slice(stackS, fileName, channels, fi); 
    233         } 
    234         else ip = new ImagePlus(fileName, stackS); 
    235       } 
    236       if (stackF != null) { 
    237         if (!mergeChannels && splitWindows) { 
    238           slice(stackF, fileName, channels, fi); 
    239         } 
    240         else ip = new ImagePlus(fileName, stackF); 
    241       } 
    242       if (stackO != null) { 
    243         if (!mergeChannels && splitWindows) { 
    244           slice(stackO, fileName, channels, fi); 
    245         } 
    246         else ip = new ImagePlus(fileName, stackO); 
    247       } 
    248  
    249       if (ip != null) ip.setFileInfo(fi); 
    250       if (ip != null) ip.show(); 
    251  
    252       long end = System.currentTimeMillis(); 
    253       double elapsed = (end - start) / 1000.0; 
    254       if (num == 1) IJ.showStatus(elapsed + " seconds"); 
    255       else { 
    256         long average = (end - start) / num; 
    257         IJ.showStatus("LOCI Bio-Formats : " + elapsed + " seconds (" + 
    258           average + " ms per plane)"); 
     236          } 
     237          if (ip == null) { 
     238            ip = new ImagePlus(null, img).getProcessor(); // slow 
     239            if (stackO == null) stackO = new ImageStack(w, h); 
     240            stackO.addSlice(fileName + ":" + (j + 1), ip); 
     241          } 
     242        } 
     243        IJ.showStatus("Creating image"); 
     244        IJ.showProgress(1); 
     245        ImagePlus ip = null; 
     246        if (stackB != null) { 
     247          if (!mergeChannels && splitWindows) { 
     248            slice(stackB, fileName, channels, fi); 
     249          } 
     250          else ip = new ImagePlus(fileName, stackB); 
     251        } 
     252        if (stackS != null) { 
     253          if (!mergeChannels && splitWindows) { 
     254            slice(stackS, fileName, channels, fi); 
     255          } 
     256          else ip = new ImagePlus(fileName, stackS); 
     257        } 
     258        if (stackF != null) { 
     259          if (!mergeChannels && splitWindows) { 
     260            slice(stackF, fileName, channels, fi); 
     261          } 
     262          else ip = new ImagePlus(fileName, stackF); 
     263        } 
     264        if (stackO != null) { 
     265          if (!mergeChannels && splitWindows) { 
     266            slice(stackO, fileName, channels, fi); 
     267          } 
     268          else ip = new ImagePlus(fileName, stackO); 
     269        } 
     270 
     271        if (ip != null) ip.setFileInfo(fi); 
     272        if (ip != null) ip.show(); 
     273 
     274        long end = System.currentTimeMillis(); 
     275        double elapsed = (end - start) / 1000.0; 
     276        if (num == 1) IJ.showStatus(elapsed + " seconds"); 
     277        else { 
     278          long average = (end - start) / num; 
     279          IJ.showStatus("LOCI Bio-Formats : " + elapsed + " seconds (" + 
     280            average + " ms per plane)"); 
     281        } 
    259282      } 
    260283      success = true; 
Note: See TracChangeset for help on using the changeset viewer.