Changeset 1985


Ignore:
Timestamp:
12/29/06 15:59:57 (13 years ago)
Author:
chris
Message:

Importer/Browser:
1) non-stitched files now work
2) actually passes the reader and stitcher (or null stitcher)
to browser now, and it works
3) metadata display function works
4) merging channels works except for the numbers (need to get
Curtis to fix this method reader.getEffectiveSizeC() or at least
telling me how it works if I'm just crazy).

Location:
trunk/loci/plugins
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/loci/plugins/Importer.java

    r1982 r1985  
    196196      // -- Step 4a: do some preparatory work -- 
    197197 
    198       if (stackFormat.equals(VIEW_BROWSER)) { 
    199         LociDataBrowser ldb = new LociDataBrowser(id,mergeChannels); 
    200         ldb.run(""); 
    201         return; 
    202       } 
     198//      if (stackFormat.equals(VIEW_BROWSER)) { 
     199//        LociDataBrowser ldb = new LociDataBrowser(id,mergeChannels); 
     200//        ldb.run(""); 
     201//        return; 
     202//      } 
    203203      if (stackFormat.equals(VIEW_IMAGE_5D)) mergeChannels = false; 
    204204 
     
    224224        if (mergeChannels) r = new ChannelMerger(fs); 
    225225        else r = new ChannelSeparator(fs); 
    226         IJ.showMessage("fs != null"); 
     226//        IJ.showMessage("fs != null"); 
    227227      } 
    228228      else { 
     
    447447 
    448448      // -- Step 4d: read pixel data -- 
    449  
    450       IJ.showStatus("Reading " + fileName); 
    451  
    452       for (int i=0; i<seriesCount; i++) { 
    453         if (!series[i]) continue; 
    454         r.setSeries(id, i); 
    455  
    456         String name = store.getImageName(new Integer(i)); 
    457         String imageName = fileName; 
    458         if (name != null && name.length() > 0) imageName += " - " + name; 
    459  
    460         boolean[] load = new boolean[num[i]]; 
    461         if (certain[i]) { 
    462           for (int c=cBegin[i]; c<=cEnd[i]; c+=cStep[i]) { 
    463             for (int z=zBegin[i]; z<=zEnd[i]; z+=zStep[i]) { 
    464               for (int t=tBegin[i]; t<=tEnd[i]; t+=tStep[i]) { 
    465                 int index = r.getIndex(id, z, c, t); 
    466                 load[index] = true; 
    467               } 
    468             } 
    469           } 
    470         } 
    471         else { 
    472           for (int j=cBegin[i]; j<=cEnd[i]; j+=cStep[i]) load[j] = true; 
    473         } 
    474         int total = 0; 
    475         for (int j=0; j<num[i]; j++) if (load[j]) total++; 
    476  
    477         // dump OME-XML to ImageJ's description field, if available 
    478         FileInfo fi = new FileInfo(); 
    479         fi.description = store.dumpXML(); 
    480  
    481         long startTime = System.currentTimeMillis(); 
    482         long time = startTime; 
    483         ImageStack stackB = null, stackS = null, stackF = null, stackO = null; 
    484  
    485         int q = 0; 
    486         for (int j=0; j<num[i]; j++) { 
    487           if (!load[j]) continue; 
    488  
    489           // limit message update rate 
    490           long clock = System.currentTimeMillis(); 
    491           if (clock - time >= 100) { 
    492             IJ.showStatus("Reading " + 
    493               (seriesCount > 1 ? ("series " + (i + 1) + ", ") : "") + 
    494               "plane " + (j + 1) + "/" + num[i]); 
    495             time = clock; 
    496           } 
    497           IJ.showProgress((double) q++ / total); 
    498  
    499           byte[] b = r.openBytes(id, j); 
    500  
    501           int w = r.getSizeX(id); 
    502           int h = r.getSizeY(id); 
    503           int c = r.isRGB(id) ? r.getSizeC(id) : 1; 
    504           int type = r.getPixelType(id); 
    505  
    506           // construct image processor and add to stack 
    507  
    508           ImageProcessor ip = null; 
    509  
    510           int bpp = 0; 
    511           switch (type) { 
    512             case FormatReader.INT8: 
    513             case FormatReader.UINT8: bpp = 1; break; 
    514             case FormatReader.INT16: 
    515             case FormatReader.UINT16: bpp = 2; break; 
    516             case FormatReader.INT32: 
    517             case FormatReader.UINT32: 
    518             case FormatReader.FLOAT: bpp = 4; break; 
    519             case FormatReader.DOUBLE: bpp = 8; break; 
    520           } 
    521  
    522           if (b.length != w * h * c * bpp) { 
    523             // HACK - byte array dimensions are incorrect - image is probably 
    524             // a different size, but we have no way of knowing what size; 
    525             // so open this plane as a BufferedImage instead 
    526             BufferedImage bi = r.openImage(id, j); 
    527             b = ImageTools.padImage(b, r.isInterleaved(id), c,  
    528               bi.getWidth() * bpp, w, h); 
    529           } 
    530            
    531           Object pixels = DataTools.makeDataArray(b, bpp, 
    532             type == FormatReader.FLOAT || type == FormatReader.DOUBLE, 
    533             r.isLittleEndian(id)); 
    534  
    535           if (pixels instanceof byte[]) { 
    536             byte[] bytes = (byte[]) pixels; 
    537             if (bytes.length > w*h*c) { 
    538               byte[] tmp = bytes; 
    539               bytes = new byte[w*h*c]; 
    540               System.arraycopy(tmp, 0, bytes, 0, bytes.length); 
    541             } 
    542             if (c == 1) { 
    543               ip = new ByteProcessor(w, h, bytes, null); 
    544               if (stackB == null) stackB = new ImageStack(w, h); 
    545               stackB.addSlice(imageName + ":" + (j + 1), ip); 
    546             } 
    547             else { 
    548               if (stackO == null) stackO = new ImageStack(w, h); 
    549               ip = new ColorProcessor(w, h); 
    550               byte[][] pix = new byte[c][w*h]; 
    551               for (int k=0; k<c; k++) { 
    552                 System.arraycopy(bytes, k*pix[k].length, pix[k], 0,  
    553                   pix[k].length); 
    554               } 
    555               ((ColorProcessor) ip).setRGB(pix[0], pix[1],  
    556                 pix.length >= 3 ? pix[2] : new byte[w*h]); 
    557               stackO.addSlice(imageName + ":" + (j + 1), ip); 
    558             } 
    559           } 
    560           else if (pixels instanceof short[]) { 
    561             short[] s = (short[]) pixels; 
    562             if (s.length > w*h*c) { 
    563               short[] tmp = s; 
    564               s = new short[w*h*c]; 
    565               System.arraycopy(tmp, 0, s, 0, s.length); 
    566             } 
    567             if (c == 1) { 
    568               ip = new ShortProcessor(w, h, s, null); 
    569               if (stackS == null) stackS = new ImageStack(w, h); 
    570               stackS.addSlice(imageName + ":" + (j + 1), ip); 
    571             } 
    572             else { 
    573               if (stackO == null) stackO = new ImageStack(w, h); 
    574               short[][] pix = new short[c][w*h]; 
    575               for (int k=0; k<c; k++) { 
    576                 System.arraycopy(s, k*pix[k].length, pix[k], 0,  
    577                   pix[k].length); 
    578               } 
    579               byte[][] bytes = new byte[c][w*h]; 
    580               for (int k=0; k<c; k++) { 
    581                 ip = new ShortProcessor(w, h, pix[k], null); 
    582                 ip = ip.convertToByte(true); 
    583                 bytes[k] = (byte[]) ip.getPixels(); 
    584               } 
    585               ip = new ColorProcessor(w, h); 
    586               ((ColorProcessor) ip).setRGB(bytes[0], bytes[1],  
    587                 pix.length >= 3 ? bytes[2] : new byte[w*h]); 
    588               stackO.addSlice(imageName + ":" + (j + 1), ip); 
    589             } 
    590           } 
    591           else if (pixels instanceof int[]) { 
    592             int[] s = (int[]) pixels; 
    593             if (s.length > w*h*c) { 
    594               int[] tmp = s; 
    595               s = new int[w*h*c]; 
    596               System.arraycopy(tmp, 0, s, 0, s.length); 
    597             } 
    598             if (c == 1) { 
    599               ip = new FloatProcessor(w, h, s); 
    600               if (stackF == null) stackF = new ImageStack(w, h); 
    601               stackF.addSlice(imageName + ":" + (j + 1), ip); 
    602             } 
    603             else { 
    604               if (stackO == null) stackO = new ImageStack(w, h); 
    605               int[][] pix = new int[c][w*h]; 
    606               for (int k=0; k<c; k++) { 
    607                 System.arraycopy(s, k*pix[k].length, pix[k], 0,  
    608                   pix[k].length); 
    609               } 
    610               byte[][] bytes = new byte[c][w*h]; 
    611               for (int k=0; k<c; k++) { 
    612                 ip = new FloatProcessor(w, h, pix[k]); 
    613                 ip = ip.convertToByte(true); 
    614                 bytes[k] = (byte[]) ip.getPixels(); 
    615               } 
    616               ip = new ColorProcessor(w, h); 
    617               ((ColorProcessor) ip).setRGB(bytes[0], bytes[1],  
    618                 pix.length >= 3 ? bytes[2] : new byte[w*h]); 
    619               stackO.addSlice(imageName + ":" + (j + 1), ip); 
    620             } 
    621           } 
    622           else if (pixels instanceof float[]) { 
    623             float[] f = (float[]) pixels; 
    624             if (f.length > w*h*c) { 
    625               float[] tmp = f; 
    626               f = new float[w*h*c]; 
    627               System.arraycopy(tmp, 0, f, 0, f.length); 
    628             } 
    629             if (c == 1) { 
    630               ip = new FloatProcessor(w, h, f, null); 
    631               if (stackF == null) stackF = new ImageStack(w, h); 
    632  
    633               if (stackB != null) { 
    634                 ip = ip.convertToByte(true); 
     449      if(!stackFormat.equals(VIEW_BROWSER)) { 
     450        IJ.showStatus("Reading " + fileName); 
     451   
     452        for (int i=0; i<seriesCount; i++) { 
     453          if (!series[i]) continue; 
     454          r.setSeries(id, i); 
     455   
     456          String name = store.getImageName(new Integer(i)); 
     457          String imageName = fileName; 
     458          if (name != null && name.length() > 0) imageName += " - " + name; 
     459   
     460          boolean[] load = new boolean[num[i]]; 
     461          if (certain[i]) { 
     462            for (int c=cBegin[i]; c<=cEnd[i]; c+=cStep[i]) { 
     463              for (int z=zBegin[i]; z<=zEnd[i]; z+=zStep[i]) { 
     464                for (int t=tBegin[i]; t<=tEnd[i]; t+=tStep[i]) { 
     465                  int index = r.getIndex(id, z, c, t); 
     466                  load[index] = true; 
     467                } 
     468              } 
     469            } 
     470          } 
     471          else { 
     472            for (int j=cBegin[i]; j<=cEnd[i]; j+=cStep[i]) load[j] = true; 
     473          } 
     474          int total = 0; 
     475          for (int j=0; j<num[i]; j++) if (load[j]) total++; 
     476   
     477          // dump OME-XML to ImageJ's description field, if available 
     478          FileInfo fi = new FileInfo(); 
     479          fi.description = store.dumpXML(); 
     480   
     481          long startTime = System.currentTimeMillis(); 
     482          long time = startTime; 
     483          ImageStack stackB = null, stackS = null, stackF = null, stackO = null; 
     484   
     485          int q = 0; 
     486          for (int j=0; j<num[i]; j++) { 
     487            if (!load[j]) continue; 
     488   
     489            // limit message update rate 
     490            long clock = System.currentTimeMillis(); 
     491            if (clock - time >= 100) { 
     492              IJ.showStatus("Reading " + 
     493                (seriesCount > 1 ? ("series " + (i + 1) + ", ") : "") + 
     494                "plane " + (j + 1) + "/" + num[i]); 
     495              time = clock; 
     496            } 
     497            IJ.showProgress((double) q++ / total); 
     498   
     499            byte[] b = r.openBytes(id, j); 
     500   
     501            int w = r.getSizeX(id); 
     502            int h = r.getSizeY(id); 
     503            int c = r.isRGB(id) ? r.getSizeC(id) : 1; 
     504            int type = r.getPixelType(id); 
     505   
     506            // construct image processor and add to stack 
     507            ImageProcessor ip = null; 
     508   
     509            int bpp = 0; 
     510            switch (type) { 
     511              case FormatReader.INT8: 
     512              case FormatReader.UINT8: bpp = 1; break; 
     513              case FormatReader.INT16: 
     514              case FormatReader.UINT16: bpp = 2; break; 
     515              case FormatReader.INT32: 
     516              case FormatReader.UINT32: 
     517              case FormatReader.FLOAT: bpp = 4; break; 
     518              case FormatReader.DOUBLE: bpp = 8; break; 
     519            } 
     520   
     521            if (b.length != w * h * c * bpp) { 
     522              // HACK - byte array dimensions are incorrect - image is probably 
     523              // a different size, but we have no way of knowing what size; 
     524              // so open this plane as a BufferedImage instead 
     525              BufferedImage bi = r.openImage(id, j); 
     526              b = ImageTools.padImage(b, r.isInterleaved(id), c,  
     527                bi.getWidth() * bpp, w, h); 
     528            } 
     529             
     530            Object pixels = DataTools.makeDataArray(b, bpp, 
     531              type == FormatReader.FLOAT || type == FormatReader.DOUBLE, 
     532              r.isLittleEndian(id)); 
     533   
     534            if (pixels instanceof byte[]) { 
     535              byte[] bytes = (byte[]) pixels; 
     536              if (bytes.length > w*h*c) { 
     537                byte[] tmp = bytes; 
     538                bytes = new byte[w*h*c]; 
     539                System.arraycopy(tmp, 0, bytes, 0, bytes.length); 
     540              } 
     541              if (c == 1) { 
     542                ip = new ByteProcessor(w, h, bytes, null); 
     543                if (stackB == null) stackB = new ImageStack(w, h); 
    635544                stackB.addSlice(imageName + ":" + (j + 1), ip); 
    636                 stackF = null; 
    637               } 
    638               else if (stackS != null) { 
    639                 ip = ip.convertToShort(true); 
     545              } 
     546              else { 
     547                if (stackO == null) stackO = new ImageStack(w, h); 
     548                ip = new ColorProcessor(w, h); 
     549                byte[][] pix = new byte[c][w*h]; 
     550                for (int k=0; k<c; k++) { 
     551                  System.arraycopy(bytes, k*pix[k].length, pix[k], 0,  
     552                    pix[k].length); 
     553                } 
     554                ((ColorProcessor) ip).setRGB(pix[0], pix[1],  
     555                  pix.length >= 3 ? pix[2] : new byte[w*h]); 
     556                stackO.addSlice(imageName + ":" + (j + 1), ip); 
     557              } 
     558            } 
     559            else if (pixels instanceof short[]) { 
     560              short[] s = (short[]) pixels; 
     561              if (s.length > w*h*c) { 
     562                short[] tmp = s; 
     563                s = new short[w*h*c]; 
     564                System.arraycopy(tmp, 0, s, 0, s.length); 
     565              } 
     566              if (c == 1) { 
     567                ip = new ShortProcessor(w, h, s, null); 
     568                if (stackS == null) stackS = new ImageStack(w, h); 
    640569                stackS.addSlice(imageName + ":" + (j + 1), ip); 
    641                 stackF = null; 
    642               } 
    643               else stackF.addSlice(imageName + ":" + (j + 1), ip); 
    644             } 
    645             else { 
    646               if (stackO == null) stackO = new ImageStack(w, h); 
    647               float[][] pix = new float[c][w*h]; 
    648               if (!r.isInterleaved(id)) { 
    649                 for (int k=0; k<f.length; k+=c) { 
    650                   for (int l=0; l<c; l++) { 
    651                     pix[l][k / 3] = f[k + l]; 
     570              } 
     571              else { 
     572                if (stackO == null) stackO = new ImageStack(w, h); 
     573                short[][] pix = new short[c][w*h]; 
     574                for (int k=0; k<c; k++) { 
     575                  System.arraycopy(s, k*pix[k].length, pix[k], 0,  
     576                    pix[k].length); 
     577                } 
     578                byte[][] bytes = new byte[c][w*h]; 
     579                for (int k=0; k<c; k++) { 
     580                  ip = new ShortProcessor(w, h, pix[k], null); 
     581                  ip = ip.convertToByte(true); 
     582                  bytes[k] = (byte[]) ip.getPixels(); 
     583                } 
     584                ip = new ColorProcessor(w, h); 
     585                ((ColorProcessor) ip).setRGB(bytes[0], bytes[1],  
     586                  pix.length >= 3 ? bytes[2] : new byte[w*h]); 
     587                stackO.addSlice(imageName + ":" + (j + 1), ip); 
     588              } 
     589            } 
     590            else if (pixels instanceof int[]) { 
     591              int[] s = (int[]) pixels; 
     592              if (s.length > w*h*c) { 
     593                int[] tmp = s; 
     594                s = new int[w*h*c]; 
     595                System.arraycopy(tmp, 0, s, 0, s.length); 
     596              } 
     597              if (c == 1) { 
     598                ip = new FloatProcessor(w, h, s); 
     599                if (stackF == null) stackF = new ImageStack(w, h); 
     600                stackF.addSlice(imageName + ":" + (j + 1), ip); 
     601              } 
     602              else { 
     603                if (stackO == null) stackO = new ImageStack(w, h); 
     604                int[][] pix = new int[c][w*h]; 
     605                for (int k=0; k<c; k++) { 
     606                  System.arraycopy(s, k*pix[k].length, pix[k], 0,  
     607                    pix[k].length); 
     608                } 
     609                byte[][] bytes = new byte[c][w*h]; 
     610                for (int k=0; k<c; k++) { 
     611                  ip = new FloatProcessor(w, h, pix[k]); 
     612                  ip = ip.convertToByte(true); 
     613                  bytes[k] = (byte[]) ip.getPixels(); 
     614                } 
     615                ip = new ColorProcessor(w, h); 
     616                ((ColorProcessor) ip).setRGB(bytes[0], bytes[1],  
     617                  pix.length >= 3 ? bytes[2] : new byte[w*h]); 
     618                stackO.addSlice(imageName + ":" + (j + 1), ip); 
     619              } 
     620            } 
     621            else if (pixels instanceof float[]) { 
     622              float[] f = (float[]) pixels; 
     623              if (f.length > w*h*c) { 
     624                float[] tmp = f; 
     625                f = new float[w*h*c]; 
     626                System.arraycopy(tmp, 0, f, 0, f.length); 
     627              } 
     628              if (c == 1) { 
     629                ip = new FloatProcessor(w, h, f, null); 
     630                if (stackF == null) stackF = new ImageStack(w, h); 
     631   
     632                if (stackB != null) { 
     633                  ip = ip.convertToByte(true); 
     634                  stackB.addSlice(imageName + ":" + (j + 1), ip); 
     635                  stackF = null; 
     636                } 
     637                else if (stackS != null) { 
     638                  ip = ip.convertToShort(true); 
     639                  stackS.addSlice(imageName + ":" + (j + 1), ip); 
     640                  stackF = null; 
     641                } 
     642                else stackF.addSlice(imageName + ":" + (j + 1), ip); 
     643              } 
     644              else { 
     645                if (stackO == null) stackO = new ImageStack(w, h); 
     646                float[][] pix = new float[c][w*h]; 
     647                if (!r.isInterleaved(id)) { 
     648                  for (int k=0; k<f.length; k+=c) { 
     649                    for (int l=0; l<c; l++) { 
     650                      pix[l][k / 3] = f[k + l]; 
     651                    } 
    652652                  } 
    653653                } 
     654                else { 
     655                  for (int k=0; k<c; k++) { 
     656                    System.arraycopy(f, k*pix[k].length, pix[k], 0,  
     657                      pix[k].length); 
     658                  } 
     659                } 
     660                byte[][] bytes = new byte[c][w*h]; 
     661                for (int k=0; k<c; k++) { 
     662                  ip = new FloatProcessor(w, h, pix[k], null); 
     663                  ip = ip.convertToByte(true); 
     664                  bytes[k] = (byte[]) ip.getPixels(); 
     665                } 
     666                ip = new ColorProcessor(w, h); 
     667                ((ColorProcessor) ip).setRGB(bytes[0], bytes[1],  
     668                  pix.length >= 3 ? bytes[2] : new byte[w*h]); 
     669                stackO.addSlice(imageName + ":" + (j + 1), ip); 
     670              } 
     671            } 
     672            else if (pixels instanceof double[]) { 
     673              double[] d = (double[]) pixels; 
     674              if (d.length > w*h*c) { 
     675                double[] tmp = d; 
     676                d = new double[w*h*c]; 
     677                System.arraycopy(tmp, 0, d, 0, d.length); 
     678              } 
     679              if (c == 1) { 
     680                ip = new FloatProcessor(w, h, d); 
     681                if (stackF == null) stackF = new ImageStack(w, h); 
     682                stackF.addSlice(imageName + ":" + (j + 1), ip); 
    654683              } 
    655684              else { 
     685                if (stackO == null) stackO = new ImageStack(w, h); 
     686                double[][] pix = new double[c][w*h]; 
    656687                for (int k=0; k<c; k++) { 
    657                   System.arraycopy(f, k*pix[k].length, pix[k], 0,  
     688                  System.arraycopy(d, k*pix[k].length, pix[k], 0,  
    658689                    pix[k].length); 
    659690                } 
    660               } 
    661               byte[][] bytes = new byte[c][w*h]; 
    662               for (int k=0; k<c; k++) { 
    663                 ip = new FloatProcessor(w, h, pix[k], null); 
    664                 ip = ip.convertToByte(true); 
    665                 bytes[k] = (byte[]) ip.getPixels(); 
    666               } 
    667               ip = new ColorProcessor(w, h); 
    668               ((ColorProcessor) ip).setRGB(bytes[0], bytes[1],  
    669                 pix.length >= 3 ? bytes[2] : new byte[w*h]); 
    670               stackO.addSlice(imageName + ":" + (j + 1), ip); 
    671             } 
    672           } 
    673           else if (pixels instanceof double[]) { 
    674             double[] d = (double[]) pixels; 
    675             if (d.length > w*h*c) { 
    676               double[] tmp = d; 
    677               d = new double[w*h*c]; 
    678               System.arraycopy(tmp, 0, d, 0, d.length); 
    679             } 
    680             if (c == 1) { 
    681               ip = new FloatProcessor(w, h, d); 
    682               if (stackF == null) stackF = new ImageStack(w, h); 
    683               stackF.addSlice(imageName + ":" + (j + 1), ip); 
    684             } 
    685             else { 
    686               if (stackO == null) stackO = new ImageStack(w, h); 
    687               double[][] pix = new double[c][w*h]; 
    688               for (int k=0; k<c; k++) { 
    689                 System.arraycopy(d, k*pix[k].length, pix[k], 0,  
    690                   pix[k].length); 
    691               } 
    692               byte[][] bytes = new byte[c][w*h]; 
    693               for (int k=0; k<c; k++) { 
    694                 ip = new FloatProcessor(w, h, pix[k]); 
    695                 ip = ip.convertToByte(true); 
    696                 bytes[k] = (byte[]) ip.getPixels(); 
    697               } 
    698               ip = new ColorProcessor(w, h); 
    699               ((ColorProcessor) ip).setRGB(bytes[0], bytes[1],  
    700                 pix.length >= 3 ? bytes[2] : new byte[w*h]); 
    701               stackO.addSlice(imageName + ":" + (j + 1), ip); 
    702             } 
    703           } 
    704         } 
    705  
    706         IJ.showStatus("Creating image"); 
    707         IJ.showProgress(1); 
    708         ImagePlus imp = null; 
    709         if (stackB != null) { 
    710           if (!mergeChannels && splitWindows) { 
    711             slice(stackB, id, sizeZ[i], sizeC[i], sizeT[i], 
    712               fi, r, fs, specifyRanges, colorize); 
    713           } 
    714           else imp = new ImagePlus(imageName, stackB); 
    715         } 
    716         if (stackS != null) { 
    717           if (!mergeChannels && splitWindows) { 
    718             slice(stackS, id, sizeZ[i], sizeC[i], sizeT[i], 
    719               fi, r, fs, specifyRanges, colorize); 
    720           } 
    721           else imp = new ImagePlus(imageName, stackS); 
    722         } 
    723         if (stackF != null) { 
    724           if (!mergeChannels && splitWindows) { 
    725             slice(stackF, id, sizeZ[i], sizeC[i], sizeT[i], 
    726               fi, r, fs, specifyRanges, colorize); 
    727           } 
    728           else imp = new ImagePlus(imageName, stackF); 
    729         } 
    730         if (stackO != null) { 
    731           if (!mergeChannels && splitWindows) { 
    732             slice(stackO, id, sizeZ[i], sizeC[i], sizeT[i], 
    733               fi, r, fs, specifyRanges, colorize); 
    734           } 
    735           else imp = new ImagePlus(imageName, stackO); 
    736         } 
    737  
    738         if (imp != null) { 
    739           // retrieve the spatial calibration information, if available 
    740  
    741           applyCalibration(store, imp, i); 
    742           imp.setFileInfo(fi); 
    743  
    744           int c = r.getSizeC(id); 
    745           displayStack(imp, r, fs, id); 
    746           r.close(); 
    747         } 
    748  
    749         long endTime = System.currentTimeMillis(); 
    750         double elapsed = (endTime - startTime) / 1000.0; 
    751         if (num[i] == 1) { 
    752           IJ.showStatus("LOCI Bio-Formats: " + elapsed + " seconds"); 
    753         } 
    754         else { 
    755           long average = (endTime - startTime) / num[i]; 
    756           IJ.showStatus("LOCI Bio-Formats: " + elapsed + " seconds (" + 
    757             average + " ms per plane)"); 
    758         } 
    759       } 
    760  
    761       r.close(); 
     691                byte[][] bytes = new byte[c][w*h]; 
     692                for (int k=0; k<c; k++) { 
     693                  ip = new FloatProcessor(w, h, pix[k]); 
     694                  ip = ip.convertToByte(true); 
     695                  bytes[k] = (byte[]) ip.getPixels(); 
     696                } 
     697                ip = new ColorProcessor(w, h); 
     698                ((ColorProcessor) ip).setRGB(bytes[0], bytes[1],  
     699                  pix.length >= 3 ? bytes[2] : new byte[w*h]); 
     700                stackO.addSlice(imageName + ":" + (j + 1), ip); 
     701              } 
     702            } 
     703          } 
     704   
     705          IJ.showStatus("Creating image"); 
     706          IJ.showProgress(1); 
     707          ImagePlus imp = null; 
     708          if (stackB != null) { 
     709            if (!mergeChannels && splitWindows) { 
     710              slice(stackB, id, sizeZ[i], sizeC[i], sizeT[i], 
     711                fi, r, fs, specifyRanges, colorize); 
     712            } 
     713            else imp = new ImagePlus(imageName, stackB); 
     714          } 
     715          if (stackS != null) { 
     716            if (!mergeChannels && splitWindows) { 
     717              slice(stackS, id, sizeZ[i], sizeC[i], sizeT[i], 
     718                fi, r, fs, specifyRanges, colorize); 
     719            } 
     720            else imp = new ImagePlus(imageName, stackS); 
     721          } 
     722          if (stackF != null) { 
     723            if (!mergeChannels && splitWindows) { 
     724              slice(stackF, id, sizeZ[i], sizeC[i], sizeT[i], 
     725                fi, r, fs, specifyRanges, colorize); 
     726            } 
     727            else imp = new ImagePlus(imageName, stackF); 
     728          } 
     729          if (stackO != null) { 
     730            if (!mergeChannels && splitWindows) { 
     731              slice(stackO, id, sizeZ[i], sizeC[i], sizeT[i], 
     732                fi, r, fs, specifyRanges, colorize); 
     733            } 
     734            else imp = new ImagePlus(imageName, stackO); 
     735          } 
     736   
     737          if (imp != null) { 
     738            // retrieve the spatial calibration information, if available 
     739   
     740            applyCalibration(store, imp, i); 
     741            imp.setFileInfo(fi); 
     742   
     743//            int c = r.getSizeC(id); 
     744            displayStack(imp, r, fs, id); 
     745            r.close(); 
     746          } 
     747   
     748          long endTime = System.currentTimeMillis(); 
     749          double elapsed = (endTime - startTime) / 1000.0; 
     750          if (num[i] == 1) { 
     751            IJ.showStatus("LOCI Bio-Formats: " + elapsed + " seconds"); 
     752          } 
     753          else { 
     754            long average = (endTime - startTime) / num[i]; 
     755            IJ.showStatus("LOCI Bio-Formats: " + elapsed + " seconds (" + 
     756              average + " ms per plane)"); 
     757          } 
     758        } 
     759   
     760        r.close(); 
     761         
     762      } 
     763 
    762764      plugin.success = true; 
    763765 
     
    771773      Prefs.set("bioformats.specifyRanges", specifyRanges); 
    772774      Prefs.set("bioformats.stackFormat", stackFormat); 
     775       
     776      if (stackFormat.equals(VIEW_BROWSER)) { 
     777        LociDataBrowser ldb = new LociDataBrowser(r,fs,id); 
     778        ldb.run(""); 
     779      } 
    773780    } 
    774781    catch (Exception exc) { 
  • trunk/loci/plugins/browser/CustomWindow.java

    r1983 r1985  
    9292    update = true; 
    9393     
    94     String id = db.id;     
     94    String id = db.id; 
     95     
    9596    FilePattern fp = null; 
    96     try { 
    97       fp = db.fStitch.getFilePattern(id);  
    98       patternTitle = fp.getPattern(); 
    99     } 
    100     catch (Exception exc) { 
    101       exc.printStackTrace(); 
    102       LociDataBrowser.exceptionMessage(exc); 
     97 
     98    if(db.fStitch != null) { 
     99      try { 
     100        fp = db.fStitch.getFilePattern(id);  
     101        patternTitle = fp.getPattern(); 
     102      } 
     103      catch (Exception exc) { 
     104        exc.printStackTrace(); 
     105        LociDataBrowser.exceptionMessage(exc); 
     106      } 
    103107    } 
    104108 
  • trunk/loci/plugins/browser/LociDataBrowser.java

    r1984 r1985  
    174174      try { 
    175175        numZ = fStitch.getSizeZ(id); 
    176         if(reader instanceof ChannelMerger) numC = fStitch.getEffectiveSizeC(id); 
     176        if(reader instanceof ChannelMerger) { 
     177          numC = fStitch.getEffectiveSizeC(id); 
     178//          IJ.showMessage("ChannelMerger Detected!! Size C = " + numC); 
     179        } 
    177180        else numC = fStitch.getSizeC(id); 
    178181        numT = fStitch.getSizeT(id); 
Note: See TracChangeset for help on using the changeset viewer.