Changeset 3362


Ignore:
Timestamp:
11/12/07 11:13:53 (12 years ago)
Author:
melissa
Message:
  • Lots of work on data browser; it now uses the caching logic in loci.formats.cache.
  • Split importer's merging logic into a separate plugin. This plugin also allows colorizing (which had recently disappeared from the importer).
  • More thoroughly check for incompatible importer options.

Note that the data browser still does not support merging >8 bit or >3 channel data - this makes me very sad.

Location:
trunk/loci/plugins
Files:
1 added
2 deleted
9 edited

Legend:

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

    r3337 r3362  
    2828import ij.*; 
    2929import ij.io.FileInfo; 
    30 import ij.measure.Calibration; 
    3130import ij.process.*; 
    3231import java.io.*; 
     
    150149 
    151150      if (groupFiles) { 
    152         status = options.promptFilePattern(); 
    153         if (!statusOk(status)) return; 
     151        try { 
     152          status = options.promptFilePattern(); 
     153          if (!statusOk(status)) return; 
     154        } 
     155        catch (NullPointerException e) { } 
    154156        id = options.getId(); 
    155157      } 
     
    556558            imp.show(); 
    557559            if (splitC || splitZ || splitT) { 
    558               IJ.runPlugIn("loci.plugins.Slicer", "sliceZ=" + splitZ + 
    559                 ", sliceC=" + splitC + ", sliceT=" + splitT + ", stackOrder=" + 
    560                 stackOrder + ", keepOriginal=false"); 
     560              IJ.runPlugIn("loci.plugins.Slicer", "slice_z=" + splitZ + 
     561                ", slice_c=" + splitC + ", slice_t=" + splitT + 
     562                ", stack_order=" + stackOrder + ", keep_original=false"); 
    561563            } 
    562564          } 
     
    575577          if (!series[i]) continue; 
    576578          IFormatReader reader = first ? r : null; 
    577           FileStitcher stitcher = first ? fs : null; 
    578           //new LociDataBrowser(reader, id, i, mergeChannels).run(); 
    579           new LociDataBrowser(reader, stitcher, id, i, mergeChannels).run(); 
     579          new LociDataBrowser(reader, id, i, mergeChannels, colorize).run(); 
    580580          first = false; 
    581581        } 
     
    619619 
    620620    // retrieve the spatial calibration information, if available 
    621     applyCalibration(store, imp, r.getSeries()); 
     621    Util.applyCalibration(store, imp, r.getSeries()); 
    622622    imp.setFileInfo(fi); 
    623623    imp.setDimensions(cCount, zCount, tCount); 
     
    630630  { 
    631631    boolean mergeChannels = options.isMergeChannels(); 
     632    boolean colorize = options.isColorize(); 
    632633    boolean concatenate = options.isConcatenate(); 
    633634    int nChannels = imp.getNChannels(); 
     
    636637    if (options.isAutoscale()) Util.adjustColorRange(imp); 
    637638 
    638     // convert to RGB if needed 
    639     int pixelType = r.getPixelType(); 
    640     if (mergeChannels && r.getSizeC() > 1 && r.getSizeC() < 4 && 
    641       (pixelType == FormatTools.UINT8 || pixelType == FormatTools.INT8) && 
    642       !r.isIndexed()) 
    643     { 
    644       makeRGB(imp, r, r.getSizeC(), options.isAutoscale()); 
    645     } 
    646     else if (mergeChannels && r.getSizeC() > 1 && r.getSizeC() <= 4 && 
    647       !r.isIndexed()) 
    648     { 
    649       // use compareTo instead of IJ.versionLessThan(...), because we want 
    650       // to suppress the error message 
    651       if (imp.getStackSize() == r.getSizeC() && 
    652         ImageJ.VERSION.compareTo("1.38n") < 0) 
    653       { 
    654         // use reflection to construct CompositeImage, 
    655         // in case ImageJ version is too old 
    656         ReflectedUniverse ru = new ReflectedUniverse(); 
    657         try { 
    658           ru.exec("import ij.CompositeImage"); 
    659           ru.setVar("imp", imp); 
    660           ru.setVar("sizeC", r.getSizeC()); 
    661           imp = (ImagePlus) ru.exec("new CompositeImage(imp, sizeC)"); 
    662         } 
    663         catch (ReflectException exc) { 
    664           imp = new CustomImage(imp, stackOrder, r.getSizeZ(), 
    665             r.getSizeT(), r.getSizeC(), options.isAutoscale()); 
    666         } 
    667       } 
    668       else { 
    669         imp = new CustomImage(imp, stackOrder, r.getSizeZ(), 
    670           r.getSizeT(), r.getSizeC(), options.isAutoscale()); 
    671       } 
    672     } 
    673     else if (mergeChannels && r.getSizeC() > 4) { 
    674       // ask the user what they would like to do... 
    675       // CTR FIXME -- migrate into ImporterOptions? 
    676       // also test with macros, and merging multiple image stacks 
    677       // (i.e., what happens if this code executes more than once?) 
    678  
    679       int planes1 = r.getImageCount() / 2; 
    680       if (planes1 * 2 < r.getImageCount()) planes1++; 
    681       int planes2 = r.getImageCount() / 3; 
    682       if (planes2 * 3 < r.getImageCount()) planes2++; 
    683       int planes3 = r.getImageCount() / 4; 
    684       if (planes3 * 4 < r.getImageCount()) planes3++; 
    685  
    686       if (options.promptMergeOption(planes1, planes2, planes3) == 
    687         ImporterOptions.STATUS_OK) 
    688       { 
    689         String option = options.getMergeOption(); 
    690         if (option.indexOf("2 channels") != -1) { 
    691           makeRGB(imp, r, 2, options.isAutoscale()); 
    692         } 
    693         else if (option.indexOf("3 channels") != -1) { 
    694           makeRGB(imp, r, 3, options.isAutoscale()); 
    695         } 
    696         else if (option.indexOf("4 channels") != -1) { 
    697           imp = new CustomImage(imp, stackOrder, r.getSizeZ(), 
    698             r.getSizeT() * planes3, 4, options.isAutoscale()); 
    699         } 
    700       } 
    701     } 
    702  
    703639    boolean splitC = options.isSplitChannels(); 
    704640    boolean splitZ = options.isSplitFocalPlanes(); 
    705641    boolean splitT = options.isSplitTimepoints(); 
     642 
     643    if (!concatenate && mergeChannels) imp.show(); 
     644 
     645    if (mergeChannels) { 
     646      IJ.runPlugIn("loci.plugins.Colorizer", "stack_order=" + stackOrder + 
     647        " merge=true"); 
     648    } 
    706649 
    707650    imp.setDimensions(imp.getStackSize() / (nSlices * nFrames), 
     
    743686            " slice_c=" + splitC + " slice_t=" + splitT + 
    744687            " stack_order=" + stackOrder + " keep_original=false"); 
     688          if (colorize) { 
     689            int[] openImages = WindowManager.getIDList(); 
     690            for (int i=0; i<openImages.length; i++) { 
     691              ImagePlus p = WindowManager.getImage(openImages[i]); 
     692              String title = p.getTitle(); 
     693              if (title.startsWith(imp.getTitle()) && 
     694                title.indexOf("C=") != -1) 
     695              { 
     696                int channel = 
     697                  Integer.parseInt(title.substring(title.indexOf("C=") + 2)); 
     698                WindowManager.setCurrentWindow(p.getWindow()); 
     699                IJ.runPlugIn("loci.plugins.Colorizer", 
     700                  "stack_order=" + stackOrder + " merge=false colorize=true" + 
     701                  " ndx=" + (channel % 3) + " "); 
     702              } 
     703            } 
     704          } 
     705        } 
     706        else if (colorize) { 
     707          IJ.runPlugIn("loci.plugins.Colorizer", "stack_order=" + stackOrder + 
     708            " merge=false colorize=true ndx=0 "); 
    745709        } 
    746710      } 
    747711      else imps.add(imp); 
    748712    } 
    749   } 
    750  
    751   /** Applies spatial calibrations to an image stack. */ 
    752   private void applyCalibration(OMEXMLMetadata store, 
    753     ImagePlus imp, int series) 
    754   { 
    755     double xcal = Double.NaN, ycal = Double.NaN, zcal = Double.NaN; 
    756     Integer ii = new Integer(series); 
    757  
    758     Float xf = store.getPixelSizeX(ii); 
    759     if (xf != null) xcal = xf.floatValue(); 
    760     Float yf = store.getPixelSizeY(ii); 
    761     if (yf != null) ycal = yf.floatValue(); 
    762     Float zf = store.getPixelSizeZ(ii); 
    763     if (zf != null) zcal = zf.floatValue(); 
    764  
    765     if (xcal == xcal || ycal == ycal || zcal == zcal) { 
    766       Calibration cal = new Calibration(); 
    767       cal.setUnit("micron"); 
    768       cal.pixelWidth = xcal; 
    769       cal.pixelHeight = ycal; 
    770       cal.pixelDepth = zcal; 
    771       imp.setCalibration(cal); 
    772     } 
    773   } 
    774  
    775   private void makeRGB(ImagePlus imp, IFormatReader r, int c, boolean scale) { 
    776     ImageStack s = imp.getStack(); 
    777     ImageStack newStack = new ImageStack(s.getWidth(), s.getHeight()); 
    778     for (int i=0; i<s.getSize(); i++) { 
    779       ImageProcessor p = s.getProcessor(i + 1).convertToByte(true); 
    780       newStack.addSlice(s.getSliceLabel(i + 1), p); 
    781     } 
    782     imp.setStack(imp.getTitle(), newStack); 
    783     if (scale) Util.adjustColorRange(imp); 
    784  
    785     s = imp.getStack(); 
    786     newStack = new ImageStack(s.getWidth(), s.getHeight()); 
    787  
    788     int sizeZ = r.getSizeZ(); 
    789     int sizeT = r.getSizeT(); 
    790  
    791     int[][] indices = new int[c][s.getSize() / c]; 
    792     int[] pt = new int[c]; 
    793     Arrays.fill(pt, 0); 
    794  
    795     for (int i=0; i<s.getSize(); i++) { 
    796       int[] zct = FormatTools.getZCTCoords(stackOrder, sizeZ, 
    797         c, sizeT, r.getImageCount() / (r.getSizeC() / c), i % c); 
    798       int cndx = zct[1]; 
    799       indices[cndx][pt[cndx]++] = i; 
    800     } 
    801  
    802     for (int i=0; i<indices[0].length; i++) { 
    803       ColorProcessor cp = new ColorProcessor(s.getWidth(), s.getHeight()); 
    804       byte[][] bytes = new byte[indices.length][]; 
    805       for (int j=0; j<indices.length; j++) { 
    806         bytes[j] = (byte[]) s.getProcessor(indices[j][i] + 1).getPixels(); 
    807       } 
    808       cp.setRGB(bytes[0], bytes[1], bytes.length == 3 ? bytes[2] : 
    809         new byte[s.getWidth() * s.getHeight()]); 
    810       newStack.addSlice(s.getSliceLabel( 
    811         indices[indices.length - 1][i] + 1), cp); 
    812     } 
    813  
    814     imp.setStack(imp.getTitle(), newStack); 
    815713  } 
    816714 
  • trunk/loci/plugins/ImporterOptions.java

    r3344 r3362  
    9898  public static final String PREF_Z = "bioformats.splitFocalPlanes"; 
    9999  public static final String PREF_T = "bioformats.splitTimepoints"; 
    100   public static final String PREF_SWAP = "bioformats.swapDimensions"; 
    101100  public static final String PREF_METADATA = "bioformats.showMetadata"; 
    102101  public static final String PREF_GROUP = "bioformats.groupFiles"; 
     
    116115    "Split_focal planes into separate windows"; 
    117116  public static final String LABEL_T = "Split_timepoints into separate windows"; 
    118   public static final String LABEL_SWAP = "Specify_stack organization"; 
    119117  public static final String LABEL_METADATA = 
    120118    "Display_metadata in results window"; 
     
    138136  private Checkbox splitZBox; 
    139137  private Checkbox splitTBox; 
    140   private Checkbox swapBox; 
    141138  private Checkbox metadataBox; 
    142139  private Checkbox groupBox; 
     
    156153  private boolean splitFocalPlanes; 
    157154  private boolean splitTimepoints; 
    158   private boolean swapDimensions; 
    159155  private boolean showMetadata; 
    160156  private boolean groupFiles; 
     
    183179  public boolean isSplitFocalPlanes() { return splitFocalPlanes; } 
    184180  public boolean isSplitTimepoints() { return splitTimepoints; } 
    185   public boolean isSwapDimensions() { return swapDimensions; } 
    186181  public boolean isShowMetadata() { return showMetadata; } 
    187182  public boolean isGroupFiles() { return groupFiles; } 
     
    219214  public void setSplitFocalPlanes(boolean b) { splitFocalPlanes = b; } 
    220215  public void setSplitTimepoints(boolean b) { splitTimepoints = b; } 
    221   public void setSwapDimensions(boolean b) { swapDimensions = b; } 
    222216  public void setShowMetadata(boolean b) { showMetadata = b; } 
    223217  public void setGroupFiles(boolean b) { groupFiles = b; } 
     
    237231    splitFocalPlanes = Prefs.get(PREF_Z, false); 
    238232    splitTimepoints = Prefs.get(PREF_T, false); 
    239     swapDimensions = Prefs.get(PREF_SWAP, false); 
    240233    showMetadata = Prefs.get(PREF_METADATA, false); 
    241234    groupFiles = Prefs.get(PREF_GROUP, false); 
     
    257250    Prefs.set(PREF_Z, splitFocalPlanes); 
    258251    Prefs.set(PREF_T, splitTimepoints); 
    259     Prefs.set(PREF_SWAP, swapDimensions); 
    260252    Prefs.set(PREF_METADATA, showMetadata); 
    261253    Prefs.set(PREF_GROUP, groupFiles); 
     
    296288      splitFocalPlanes = getMacroValue(arg, LABEL_Z, splitFocalPlanes); 
    297289      splitTimepoints = getMacroValue(arg, LABEL_T, splitTimepoints); 
    298       swapDimensions = getMacroValue(arg, LABEL_SWAP, swapDimensions); 
    299290      showMetadata = getMacroValue(arg, LABEL_METADATA, showMetadata); 
    300291      groupFiles = getMacroValue(arg, LABEL_GROUP, groupFiles); 
     
    475466    gd.addCheckbox(LABEL_Z, splitFocalPlanes); 
    476467    gd.addCheckbox(LABEL_T, splitTimepoints); 
    477     gd.addCheckbox(LABEL_SWAP, swapDimensions); 
    478468    gd.addCheckbox(LABEL_METADATA, showMetadata); 
    479469    gd.addCheckbox(LABEL_GROUP, groupFiles); 
     
    498488      splitZBox = (Checkbox) boxes.get(3); 
    499489      splitTBox = (Checkbox) boxes.get(4); 
    500       swapBox = (Checkbox) boxes.get(5); 
    501       metadataBox = (Checkbox) boxes.get(6); 
    502       groupBox = (Checkbox) boxes.get(7); 
    503       concatenateBox = (Checkbox) boxes.get(8); 
    504       rangeBox = (Checkbox) boxes.get(9); 
    505       autoscaleBox = (Checkbox) boxes.get(10); 
     490      metadataBox = (Checkbox) boxes.get(5); 
     491      groupBox = (Checkbox) boxes.get(6); 
     492      concatenateBox = (Checkbox) boxes.get(7); 
     493      rangeBox = (Checkbox) boxes.get(8); 
     494      autoscaleBox = (Checkbox) boxes.get(9); 
    506495      for (int i=0; i<boxes.size(); i++) { 
    507496        ((Checkbox) boxes.get(i)).addItemListener(this); 
     
    519508    splitFocalPlanes = gd.getNextBoolean(); 
    520509    splitTimepoints = gd.getNextBoolean(); 
    521     swapDimensions = gd.getNextBoolean(); 
    522510    showMetadata = gd.getNextBoolean(); 
    523511    groupFiles = gd.getNextBoolean(); 
     
    756744      } 
    757745      else if (s.equals(VIEW_BROWSER)) { 
    758         colorizeBox.setState(false); // NB: temporary 
    759746        splitCBox.setState(false); 
     747        splitZBox.setState(false); 
     748        splitTBox.setState(false); 
    760749        rangeBox.setState(false); 
     750        concatenateBox.setState(false); // TEMPORARY 
    761751      } 
    762752      else if (s.equals(VIEW_IMAGE_5D)) { 
     
    777767      if (colorizeBox.getState()) { 
    778768        mergeBox.setState(false); 
    779         splitCBox.setState(true); 
    780         // NB: temporary 
    781         String s = stackChoice.getSelectedItem(); 
    782         if (s.equals(VIEW_BROWSER)) stackChoice.select(VIEW_STANDARD); 
     769        splitCBox.setState(!stackChoice.getSelectedItem().equals(VIEW_BROWSER)); 
    783770      } 
    784771    } 
     
    797784    } 
    798785    else if (src == groupBox) { 
     786      if (groupBox.getState() && getLocation().equals(LOCATION_OME)) { 
     787        groupBox.setState(false); 
     788      } 
    799789    } 
    800790    else if (src == concatenateBox) { 
     791      if (concatenateBox.getState()) { 
     792        // TEMPORARY 
     793        String s = stackChoice.getSelectedItem(); 
     794        if (s.equals(VIEW_BROWSER)) stackChoice.select(VIEW_STANDARD); 
     795      } 
    801796    } 
    802797    else if (src == rangeBox) { 
  • trunk/loci/plugins/Util.java

    r3281 r3362  
    2828import ij.*; 
    2929import ij.gui.GenericDialog; 
     30import ij.measure.Calibration; 
    3031import ij.process.*; 
    3132import java.awt.*; 
     
    216217  } 
    217218 
     219  /** 
     220   * Converts the given array of ImageProcessors into a single-slice 
     221   * RGB ImagePlus. 
     222   */ 
     223  public static ImagePlus makeRGB(ImageProcessor[] p) { 
     224    if (p.length == 1) return new ImagePlus("", p[0]); 
     225 
     226    // check that all processors are of the same type and size 
     227    boolean sameType = true; 
     228    int width = p[0].getWidth(); 
     229    int height = p[0].getHeight(); 
     230    boolean byteProc = p[0] instanceof ByteProcessor; 
     231    boolean shortProc = p[0] instanceof ShortProcessor; 
     232    boolean floatProc = p[0] instanceof FloatProcessor; 
     233    for (int i=1; i<p.length; i++) { 
     234      int w = p[i].getWidth(); 
     235      int h = p[i].getHeight(); 
     236      boolean b = p[i] instanceof ByteProcessor; 
     237      boolean s = p[i] instanceof ShortProcessor; 
     238      boolean f = p[i] instanceof FloatProcessor; 
     239      if (w != width || h != height || b != byteProc || s != shortProc || 
     240        f != floatProc) 
     241      { 
     242        sameType = false; 
     243        break; 
     244      } 
     245    } 
     246 
     247    if (!sameType || p.length > 4 || p[0] instanceof ColorProcessor) { 
     248      return null; 
     249    } 
     250 
     251    ImagePlus imp = null; 
     252 
     253    if (p.length < 4 && byteProc) { 
     254      ColorProcessor cp = new ColorProcessor(width, height); 
     255      byte[][] bytes = new byte[p.length][]; 
     256      for (int i=0; i<p.length; i++) { 
     257        bytes[i] = (byte[]) p[i].getPixels(); 
     258      } 
     259      cp.setRGB(bytes[0], bytes[1], bytes.length == 3 ? bytes[2] : 
     260        new byte[width * height]); 
     261      imp = new ImagePlus("", cp); 
     262    } 
     263    else if (p.length <= 4) { 
     264      ImageStack tmpStack = new ImageStack(width, height); 
     265      for (int i=0; i<p.length; i++) { 
     266        tmpStack.addSlice("", p[i]); 
     267      } 
     268      imp = new CustomImage(new ImagePlus("", tmpStack), "XYCZT", 1, 1, 
     269        p.length, true); 
     270    } 
     271 
     272    return imp; 
     273  } 
     274 
     275  /** Applies spatial calibrations to an image stack. */ 
     276  public static void applyCalibration(MetadataRetrieve store, 
     277    ImagePlus imp, int series) 
     278  { 
     279    double xcal = Double.NaN, ycal = Double.NaN, zcal = Double.NaN; 
     280    Integer ii = new Integer(series); 
     281 
     282    Float xf = store.getPixelSizeX(ii); 
     283    if (xf != null) xcal = xf.floatValue(); 
     284    Float yf = store.getPixelSizeY(ii); 
     285    if (yf != null) ycal = yf.floatValue(); 
     286    Float zf = store.getPixelSizeZ(ii); 
     287    if (zf != null) zcal = zf.floatValue(); 
     288 
     289    if (xcal == xcal || ycal == ycal || zcal == zcal) { 
     290      Calibration cal = new Calibration(); 
     291      cal.setUnit("micron"); 
     292      cal.pixelWidth = xcal; 
     293      cal.pixelHeight = ycal; 
     294      cal.pixelDepth = zcal; 
     295      imp.setCalibration(cal); 
     296    } 
     297  } 
     298 
    218299  /** Adds AWT scroll bars to the given container. */ 
    219300  public static void addScrollBars(Container pane) { 
  • trunk/loci/plugins/browser/CacheIndicator.java

    r2672 r3362  
    2727import javax.swing.*; 
    2828import java.awt.*; 
    29 import java.util.Arrays; 
     29import loci.formats.cache.*; 
    3030 
    3131public class CacheIndicator extends JComponent { 
     
    3434 
    3535  private static final int COMPONENT_HEIGHT = 5; 
    36   private static final boolean DEBUG = false; 
    3736 
    3837  // -- Fields -- 
    3938 
    40   protected int[] cache, loadList; 
    41   protected int cacheLength; 
    42   protected double ratio; 
    43   protected JScrollBar scroll; 
    44   protected boolean doUpdate; 
     39  private Cache cache; 
     40  private int cacheLength, axis, numAxes; 
     41  private JScrollBar scroll; 
     42  private boolean doUpdate; 
    4543 
    4644  // -- Constructor -- 
     
    4947    doUpdate = true; 
    5048    this.scroll = scroll; 
    51     setBackground(Color.white); 
     49    setBackground(Color.WHITE); 
    5250    cache = null; 
    53     loadList = null; 
    5451    cacheLength = 0; 
     52    axis = -1; 
    5553  } 
    5654 
    5755  // -- CacheIndicator API methods -- 
    5856 
    59   public void setIndicator(int[] someCache, int[] someLoadList, int length) { 
     57  public void setIndicator(Cache cache, int length, int axis) { 
    6058    doUpdate = false; 
    61     cache = someCache; 
    62     loadList = someLoadList; 
     59    this.cache = cache; 
    6360    cacheLength = length; 
    64     int setRatio = translate(0); 
     61    this.axis = axis; 
     62    numAxes = cache.getCurrentPos().length; 
    6563    doUpdate = true; 
    6664    repaint(); 
     
    7371    if (!doUpdate) return; 
    7472 
    75     g.setColor(Color.black); 
     73    g.setColor(Color.BLACK); 
    7674    g.drawRect(0, 0, getWidth() - 1, COMPONENT_HEIGHT - 1); 
    7775 
    78     if (ratio < 1 && ratio != 0) { 
    79       int[] loadCount = new int[getWidth()]; 
    80       int[] cacheCount = new int[getWidth()]; 
     76    if (cacheLength == 0) return; 
    8177 
    82       for (int i=0; i<loadCount.length; i++) { 
    83         loadCount[i] = 0; 
    84         cacheCount[i] = 0; 
    85       } 
     78    int pixelsPerIndex = getWidth() / cacheLength; 
    8679 
    87       // find how many entries of the cache are handled per pixel of indicator 
    88       double integers = 2; 
    89       double dPerPixel = ratio * integers; 
     80    try { 
     81      int[] currentPos = cache.getCurrentPos(); 
     82      int[][] loadList = cache.getStrategy().getLoadList(currentPos); 
    9083 
    91       if (DEBUG) System.out.println("Ratio: " + ratio); 
    92       while (dPerPixel < 1) { 
    93         integers++; 
    94         dPerPixel = ratio * integers; 
    95       } 
     84      int[] pos = new int[currentPos.length]; 
     85      System.arraycopy(currentPos, 0, pos, 0, pos.length); 
    9686 
    97       int perPixel = (int) integers; 
     87      for (int i=0; i<cacheLength; i++) { 
     88        pos[axis] = i; 
    9889 
    99       if (DEBUG) System.out.println("PerPixel: " + perPixel); 
     90        boolean inLoadList = false; 
     91        for (int j=0; j<loadList.length; j++) { 
     92          boolean equal = true; 
     93          for (int k=0; k<loadList[j].length; k++) { 
     94            if (loadList[j][k] != pos[k]) { 
     95              equal = false; 
     96              break; 
     97            } 
     98          } 
     99          if (equal) { 
     100            inLoadList = true; 
     101            break; 
     102          } 
     103        } 
    100104 
    101       int colorAmount = 255 / perPixel; 
    102       if (DEBUG) System.out.println("ColorAmount: " + colorAmount); 
    103  
    104       for (int i=0; i<loadList.length; i++) { 
    105         boolean isLoaded = false; 
    106         if (Arrays.binarySearch(cache, loadList[i]) >= 0) isLoaded = true; 
    107         int index = translate(loadList[i]); 
    108         if (!isLoaded) loadCount[index]++; 
    109       } 
    110       for (int i=0; i<cache.length; i++) { 
    111         int index = translate(cache[i]); 
    112         cacheCount[index]++; 
    113       } 
    114  
    115       for (int i=0; i<getWidth(); i++) { 
    116         int loadColor, cacheColor; 
    117         loadColor = colorAmount * loadCount[i]; 
    118         cacheColor = colorAmount * cacheCount[i]; 
    119         if (loadColor != 0 || cacheColor != 0) { 
    120           g.setColor(new Color(loadColor, 0, cacheColor)); 
    121           g.drawLine(i, 1, i, COMPONENT_HEIGHT - 2); 
    122         } 
     105        if (cache.isInCache(pos)) g.setColor(Color.BLUE); 
     106        else if (inLoadList) g.setColor(Color.RED); 
     107        else g.setColor(Color.WHITE); 
     108        g.fillRect(i*pixelsPerIndex + 1, 1, pixelsPerIndex, getHeight() - 2); 
    123109      } 
    124110    } 
    125     else if (ratio >= 1) { 
    126       int prevLoad = -1; 
    127       int startLoad = -1; 
    128       g.setColor(Color.red); 
    129       for (int i=0; i<loadList.length; i++) { 
    130         if (!doUpdate) break; 
    131         int toLoad = loadList[i]; 
    132  
    133         // correct for bug with length 1 
    134         if (loadList.length == 1) { 
    135           startLoad = toLoad; 
    136           prevLoad = toLoad; 
    137         } 
    138  
    139         if (startLoad == -1) { 
    140           startLoad = toLoad; 
    141           prevLoad = toLoad; 
    142         } 
    143         else if (toLoad == prevLoad + 1 && startLoad != -1) { 
    144           prevLoad = toLoad; 
    145         } 
    146         else if (toLoad != prevLoad + 1 && 
    147           startLoad != -1 && cache.length - 1 != i) 
    148         { 
    149           prevLoad = prevLoad + 1; 
    150           int x = translate(startLoad); 
    151           int wid = translate(prevLoad) - x; 
    152           g.fillRect(x, 1, wid, COMPONENT_HEIGHT - 2); 
    153           startLoad = -1; 
    154         } 
    155  
    156         if (i == loadList.length - 1) { 
    157           prevLoad = prevLoad + 1; 
    158           int x = translate(startLoad); 
    159           int wid = translate(prevLoad) - x; 
    160           g.fillRect(x, 1, wid, COMPONENT_HEIGHT - 2); 
    161           startLoad = -1; 
    162         } 
    163       } 
    164  
    165       prevLoad = -1; 
    166       startLoad = -1; 
    167       g.setColor(Color.blue); 
    168       for (int i=0; i<cache.length; i++) { 
    169         if (!doUpdate) break; 
    170         int toLoad = cache[i]; 
    171  
    172         // correct for bug with length 1 
    173         if (loadList.length == 1) { 
    174           startLoad = toLoad; 
    175           prevLoad = toLoad; 
    176         } 
    177  
    178         if (startLoad == -1) { 
    179           startLoad = toLoad; 
    180           prevLoad = toLoad; 
    181         } 
    182         else if (toLoad == prevLoad + 1 && startLoad != -1) { 
    183           prevLoad = toLoad; 
    184         } 
    185         else if (toLoad != prevLoad + 1 && 
    186           startLoad != -1 && cache.length - 1 != i) 
    187         { 
    188           prevLoad = prevLoad + 1; 
    189           int x = translate(startLoad); 
    190           int wid = translate(prevLoad) - x; 
    191           g.fillRect(x, 1, wid, COMPONENT_HEIGHT - 2); 
    192           startLoad = -1; 
    193         } 
    194  
    195         if (i == cache.length - 1) { 
    196           prevLoad = prevLoad + 1; 
    197           int x = translate(startLoad); 
    198           int wid = translate(prevLoad) - x; 
    199           g.fillRect(x, 1, wid, COMPONENT_HEIGHT - 2); 
    200           startLoad = -1; 
    201         } 
    202       } 
    203     } 
     111    catch (CacheException e) { } 
    204112  } 
    205113 
     
    218126  } 
    219127 
    220   // -- Helper methods -- 
    221  
    222   private int translate(int cacheIndex) { 
    223     Integer width = new Integer(scroll.getWidth()); 
    224     double compSize = width.doubleValue(); 
    225     if (cacheLength == 0) return -1; 
    226     Integer length = new Integer(cacheLength); 
    227     double cLength = length.doubleValue(); 
    228     Integer thisIndex = new Integer(cacheIndex); 
    229     double dIndex = thisIndex.doubleValue(); 
    230  
    231     ratio = compSize / cLength; 
    232     double dPixel = ratio * dIndex; 
    233  
    234     Double pixel = new Double(dPixel); 
    235     return pixel.intValue(); 
    236   } 
    237  
    238   // -- Main method -- 
    239  
    240   /** Tests the cache indicator GUI component. */ 
    241   public static void main(String[] args) { 
    242     JFrame frame = new JFrame("Cache indicator test"); 
    243     JPanel pane = new JPanel(); 
    244     frame.setContentPane(pane); 
    245     frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
    246     pane.setLayout(new BoxLayout(pane, BoxLayout.Y_AXIS)); 
    247     JScrollBar scroll = new JScrollBar(JScrollBar.HORIZONTAL); 
    248     pane.add(scroll); 
    249     int len = 2000; 
    250     CacheIndicator[] ci = new CacheIndicator[len]; 
    251     for (int i=0; i<len; i++) { 
    252       ci[i] = new CacheIndicator(scroll); 
    253       pane.add(ci[i]); 
    254     } 
    255     frame.pack(); 
    256     frame.setBounds(100, 100, 500, frame.getHeight()); 
    257     frame.setVisible(true); 
    258     for (int i=0; i<len; i++) { 
    259       int[] cache = new int[len / 10]; 
    260       for (int j=i; j<i+len/10; j++) cache[j-i] = j % len; 
    261       int[] load = new int[len / 10]; 
    262       for (int j=i+len/10; j<i+len/5; j++) load[j-i-len/10] = j % len; 
    263       ci[i].setIndicator(cache, load, len); 
    264     } 
    265   } 
    266  
    267128} 
  • trunk/loci/plugins/browser/CustomWindow.java

    r3203 r3362  
    2525package loci.plugins.browser; 
    2626 
    27 import com.jgoodies.forms.layout.CellConstraints; 
    28 import com.jgoodies.forms.layout.FormLayout; 
     27import com.jgoodies.forms.layout.*; 
    2928import ij.*; 
    3029import ij.gui.*; 
    31 //import ij.macro.MacroRunner; 
    3230import ij.measure.Calibration; 
    3331import ij.process.*; 
    3432import java.awt.*; 
    3533import java.awt.event.*; 
    36 //import java.util.Vector; 
     34import java.awt.image.IndexColorModel; 
    3735import javax.swing.*; 
    38 import javax.swing.event.ChangeEvent; 
    39 import javax.swing.event.ChangeListener; 
     36import javax.swing.event.*; 
    4037import loci.formats.*; 
    41 //import loci.ome.notes.Notes; 
     38import loci.formats.cache.*; 
     39import loci.plugins.Util; 
    4240import org.openmicroscopy.xml.OMENode; 
    4341 
     
    6361  protected OptionsWindow ow; 
    6462 
    65   private String zString = Z_STRING; 
    66   private String tString = T_STRING; 
    6763  private int fps = 10; 
    6864  private int z = 1, t = 1, c = 1; 
     65  private byte[] lut; 
     66  private byte[] nullLut; 
    6967 
    7068  // -- Fields - widgets -- 
     
    9593    update = true; 
    9694 
     95    lut = new byte[256]; 
     96    nullLut = new byte[256]; 
     97    for (int i=0; i<lut.length; i++) { 
     98      lut[i] = (byte) i; 
     99      nullLut[i] = 0; 
     100    } 
     101 
    97102    String id = db.id; 
    98103 
    99     FilePattern fp = null; 
    100  
    101     if (db.fStitch != null) { 
    102       try { 
    103         fp = db.fStitch.getFilePattern(); 
    104         patternTitle = fp.getPattern(); 
    105       } 
    106       catch (Exception exc) { 
    107         exc.printStackTrace(); 
    108         LociDataBrowser.dumpException(exc); 
    109       } 
    110     } 
    111  
    112     if (fp == null) { 
    113       patternTitle = db.reader == null ? id : db.reader.getCurrentFile(); 
    114     } 
     104    patternTitle = db.reader == null ? id : db.reader.getCurrentFile(); 
    115105    setTitle(patternTitle); 
    116106 
     
    130120 
    131121    // Z scroll bar label 
    132     zLabel = new JLabel(zString); 
     122    zLabel = new JLabel(Z_STRING); 
    133123    zLabel.setHorizontalTextPosition(JLabel.LEFT); 
    134     if (!db.hasZ) zLabel.setEnabled(false); 
     124    zLabel.setEnabled(db.numZ > 1); 
    135125 
    136126    // T scroll bar label 
    137     tLabel = new JLabel(tString); 
     127    tLabel = new JLabel(T_STRING); 
    138128    tLabel.setHorizontalTextPosition(JLabel.LEFT); 
    139     if (!db.hasT) tLabel.setEnabled(false); 
     129    tLabel.setEnabled(db.numT > 1); 
    140130 
    141131    // Z scroll bar 
    142     zSliceSel = new JScrollBar(JScrollBar.HORIZONTAL, 
    143       1, 1, 1, db.hasZ ? db.numZ + 1 : 2); 
    144     if (!db.hasZ) zSliceSel.setEnabled(false); 
     132    zSliceSel = new JScrollBar(JScrollBar.HORIZONTAL, 1, 1, 1, db.numZ + 1); 
     133    zSliceSel.setEnabled(db.numZ > 1); 
    145134    zSliceSel.addAdjustmentListener(this); 
    146135    zSliceSel.setUnitIncrement(1); 
     
    148137 
    149138    // T scroll bar 
    150     tSliceSel = new JScrollBar(JScrollBar.HORIZONTAL, 
    151       1, 1, 1, db.hasT ? db.numT + 1 : 2); 
    152     if (!db.hasT) tSliceSel.setEnabled(false); 
     139    tSliceSel = new JScrollBar(JScrollBar.HORIZONTAL, 1, 1, 1, db.numT + 1); 
     140    tSliceSel.setEnabled(db.numT > 1); 
    153141    tSliceSel.addAdjustmentListener(this); 
    154142    tSliceSel.setUnitIncrement(1); 
     
    157145    // animate button 
    158146    animate = new JButton(ANIM_STRING); 
    159     if (!db.hasT && !db.hasZ) animate.setEnabled(false); 
     147    animate.setEnabled(db.numT * db.numZ > 1); 
    160148    animate.addActionListener(this); 
    161149 
     
    191179 
    192180    channelBox = new JCheckBox("Transmitted", true); 
    193     channelBox.setBackground(Color.white); 
     181    channelBox.setBackground(Color.WHITE); 
    194182    channelPanel.add("one", channelBox); 
    195183    channelBox.addItemListener(this); 
    196184 
    197185    JPanel subPane = new JPanel(new FlowLayout()); 
    198     subPane.setBackground(Color.white); 
     186    subPane.setBackground(Color.WHITE); 
    199187    cLabel = new JLabel("channel"); 
    200188    SpinnerModel model = new SpinnerNumberModel(1, 1, db.numC, 1); 
     
    207195 
    208196    // repack to take extra panel into account 
    209     c = db.numC * db.numT * db.numZ == imp.getStackSize() ? db.numC : 1; 
     197    c = db.numC; 
    210198    setC(); 
    211199 
     
    248236    lowPane.add(fpsSpin, cc.xy(12, 4)); 
    249237    lowPane.add(options, cc.xy(6, 6)); 
    250     if(xml != null) lowPane.add(xml, cc.xy(8, 6)); 
     238    if (xml != null) lowPane.add(xml, cc.xy(8, 6)); 
    251239    lowPane.add(animate, cc.xyw(10, 6, 3, "right,center")); 
    252240 
    253241    setBackground(Color.white); 
    254     FormLayout layout2 = new FormLayout( 
    255       TAB + ",pref:grow," + TAB, 
     242    FormLayout layout2 = new FormLayout(TAB + ",pref:grow," + TAB, 
    256243      TAB + "," + TAB + ",pref:grow," + TAB + ",pref," + TAB); 
    257244    setLayout(layout2); 
     
    260247    add(lowPane, cc2.xy(2, 5)); 
    261248 
    262     //final GUI tasks 
    263249    pack(); 
    264  
    265     showSlice(z, t, c); 
    266  
     250    showSlice(z, t, c, false); 
    267251    updateControls(); 
    268252 
     
    270254    addKeyListener(this); 
    271255    ic.addKeyListener(this); 
    272  
    273256  } 
    274257 
     
    278261    update = false; 
    279262    zSliceSel.setMinimum(1); 
    280     zSliceSel.setMaximum(db.hasZ ? db.numZ + 1 : 2); 
    281     zSliceSel.setEnabled(db.hasZ); 
    282     if(zIndicator != null) { 
    283       zIndicator.setVisible(db.hasZ); 
     263    zSliceSel.setMaximum(db.numZ + 1); 
     264    zSliceSel.setEnabled(db.numZ > 1); 
     265    zLabel.setEnabled(db.numZ > 1); 
     266    if (zIndicator != null) { 
     267      zIndicator.setVisible(db.numZ > 1); 
    284268      zIndicator.repaint(); 
    285269    } 
    286270    tSliceSel.setMinimum(1); 
    287     tSliceSel.setMaximum(db.hasT ? db.numT + 1 : 2); 
    288     tSliceSel.setEnabled(db.hasT); 
    289     if(tIndicator != null) { 
    290       tIndicator.setVisible(db.hasT); 
     271    tSliceSel.setMaximum(db.numT + 1); 
     272    tSliceSel.setEnabled(db.numT > 1); 
     273    tLabel.setEnabled(db.numT > 1); 
     274    if (tIndicator != null) { 
     275      tIndicator.setVisible(db.numT > 1); 
    291276      tIndicator.repaint(); 
    292277    } 
     
    308293      snm.setValue(new Integer(c)); 
    309294      c = ((Integer) channelSpin.getValue()).intValue(); 
    310       if (!db.hasC) { 
     295      if (db.numC == 1) { 
    311296        channelSpin.setEnabled(false); 
    312297        cLabel.setEnabled(false); 
     
    318303      switcher.first(channelPanel); 
    319304      c = channelBox.isSelected() ? 1 : 2; 
    320       if (!db.hasC) { 
     305      if (db.numC == 1) { 
    321306        channelBox.setEnabled(false); 
    322307        c = 1; 
     
    326311 
    327312  /** Selects and shows slice defined by z, t and c. */ 
    328   public synchronized void showSlice(int zVal, int tVal, int cVal) { 
     313  public synchronized void showSlice(int zVal, int tVal, int cVal, 
     314    boolean temp) 
     315  { 
    329316    int index = db.getIndex(zVal - 1, tVal - 1, cVal - 1); 
    330317    if (LociDataBrowser.DEBUG) { 
     
    332319        "; z=" + zVal + "; t=" + tVal + "; c=" + cVal); 
    333320    } 
    334     showSlice(index); 
     321    showSlice(index, temp); 
    335322  } 
    336323 
    337324  /** Selects and shows slice defined by index. */ 
    338   public void showSlice(int index) { 
    339     index++; 
    340  
    341     if (db.manager != null) { 
    342       index--; 
    343       ImageProcessor clone = db.manager.getSlice(index).duplicate(); 
    344       double bits = 255; 
    345       if (clone instanceof ShortProcessor) bits = 65535; 
    346       else if (clone instanceof FloatProcessor) bits = Float.MAX_VALUE - 1; 
    347  
    348       clone.setMinAndMax(0, bits); 
    349       imp.setProcessor(patternTitle, clone); 
    350  
    351       // now execute macros as needed 
    352 // TODO: macros 
    353 //      Vector macros = db.macro.getMacros(); 
    354 //      for (int i=0; i<macros.size(); i++) { 
    355 //        MacroRunner runner = new MacroRunner((String) macros.get(i)); 
    356 //      } 
    357  
    358       index = 1; 
    359       return; 
    360     } 
    361  
    362     if (index >= 1 && index <= imp.getStackSize()) { 
    363       synchronized (imp) { 
    364         imp.setSlice(index); 
    365       } 
    366       imp.updateAndDraw(); 
    367     } 
    368     else if (LociDataBrowser.DEBUG) { 
    369       IJ.log("invalid index: " + index + " (size = " + imp.getStackSize() + 
    370         "; zSliceSel = " + zSliceSel.getValue() + 
    371         "; tSliceSel = " + tSliceSel.getValue() + ")"); 
    372     } 
    373  
    374     // now execute macros as needed 
    375 // TODO: macros 
    376 //    Vector macros = db.macro.getMacros(); 
    377 //    for (int i=0; i<macros.size(); i++) { 
    378 //      MacroRunner runner = new MacroRunner((String) macros.get(i)); 
    379 //    } 
    380  
    381     repaint(); 
    382   } 
    383  
    384   /** Selects and shows slice defined by z, t and c. */ 
    385   public synchronized void showTempSlice(int zVal, int tVal, int cVal) { 
    386     int index = db.getIndex(zVal - 1, tVal - 1, cVal - 1); 
    387     if (LociDataBrowser.DEBUG) { 
    388       IJ.log("showSlice: index=" + index + 
    389         "; z=" + zVal + "; t=" + tVal + "; c=" + cVal); 
    390     } 
    391     showTempSlice(index); 
    392   } 
    393  
    394   public void showTempSlice(int index) { 
    395     imp.setProcessor(patternTitle, db.manager.getTempSlice(index)); 
     325  public void showSlice(int index, boolean temp) { 
     326    if (db.cache != null || temp) { 
     327      int numPlanes = db.merged ? db.reader.getSizeC() : 1; 
     328      int[][] zct = new int[numPlanes][3]; 
     329      ImageProcessor[] processors = new ImageProcessor[numPlanes]; 
     330      for (int i=0; i<numPlanes; i++) { 
     331        if (i == 0) zct[i] = FormatTools.getZCTCoords(db.reader, index); 
     332        else { 
     333          System.arraycopy(zct[i - 1], 0, zct[i], 0, zct[i].length); 
     334          zct[i][1]++; 
     335        } 
     336 
     337        int zIndex = -1; 
     338        int tIndex = -1; 
     339        int cIndex = -1; 
     340 
     341        int zv = zct[i][0]; 
     342        int cv = zct[i][1]; 
     343        int tv = zct[i][2]; 
     344 
     345        int[] newZCT = new int[3]; 
     346 
     347        for (int j=0; j<zct[i].length; j++) { 
     348          char ch = db.reader.getDimensionOrder().charAt(j + 2); 
     349          newZCT[j] = ch == 'Z' ? zv : ch == 'C' ? cv : tv; 
     350          if (ch == 'Z') zIndex = j; 
     351          else if (ch == 'T') tIndex = j; 
     352          else cIndex = j; 
     353        } 
     354 
     355        try { 
     356          db.cache.setCurrentPos(newZCT); 
     357 
     358          // update cache indicators 
     359          if (zIndicator != null) { 
     360            zIndicator.setIndicator(db.cache, db.reader.getSizeZ(), zIndex); 
     361          } 
     362          if (tIndicator != null) { 
     363            tIndicator.setIndicator(db.cache, db.reader.getSizeT(), tIndex); 
     364          } 
     365 
     366          processors[i] = (ImageProcessor) db.cache.getObject(newZCT); 
     367          if (!temp) { 
     368            double bits = 255; 
     369            if (processors[i] instanceof ShortProcessor) bits = 65535; 
     370            else if (processors[i] instanceof FloatProcessor) { 
     371              bits = Float.MAX_VALUE - 1; 
     372            } 
     373          } 
     374          if (i == numPlanes - 1) { 
     375            newZCT[cIndex] -= (numPlanes - 1); 
     376            db.cache.setCurrentPos(newZCT); 
     377          } 
     378        } 
     379        catch (CacheException e) { 
     380          LociDataBrowser.dumpException(e); 
     381        } 
     382        catch (FormatException e) { 
     383          LociDataBrowser.dumpException(e); 
     384        } 
     385      } 
     386 
     387      ImagePlus p = Util.makeRGB(processors); 
     388      ImageProcessor proc = p.getProcessor(); 
     389      if (db.colorize && processors.length == 1) { 
     390        int[] coords = FormatTools.getZCTCoords(db.reader, index); 
     391        proc.setColorModel(new IndexColorModel(8, 256, 
     392          coords[1] == 0 ? lut : nullLut, coords[1] == 1 ? lut : nullLut, 
     393          coords[1] == 2 ? lut : nullLut)); 
     394      } 
     395      imp.setProcessor(patternTitle, proc); 
     396    } 
     397 
    396398    imp.updateAndDraw(); 
    397  
    398     if (LociDataBrowser.DEBUG) { 
    399       IJ.log("invalid index: " + index + " (size = " + imp.getStackSize() + 
    400         "; zSliceSel = " + zSliceSel.getValue() + 
    401         "; tSliceSel = " + tSliceSel.getValue() + ")"); 
    402     } 
    403399    repaint(); 
    404400  } 
     
    408404  /** Adds 3rd and 4th dimension slice position. */ 
    409405  public void drawInfo(Graphics g) { 
    410     if(update) { 
    411       if (db == null) return; 
    412       int zVal = zSliceSel == null ? 1 : zSliceSel.getValue(); 
    413       int tVal = tSliceSel == null ? 1 : tSliceSel.getValue(); 
    414  
    415       int textGap = 0; 
    416  
    417       int nSlices = db.numZ * db.numT * db.numC; 
    418       int current = imp.getCurrentSlice(); 
    419       if (db.manager != null) { 
    420         current = db.manager.getSlice(); 
    421         current++; 
    422       } 
    423  
    424       StringBuffer sb = new StringBuffer(); 
    425       sb.append(current); 
    426       sb.append("/"); 
    427       sb.append(nSlices); 
    428       sb.append("; "); 
    429       if (db.hasZ) { 
    430         sb.append(zString); 
    431         sb.append(": "); 
    432         sb.append(zVal); 
    433         sb.append("/"); 
    434         sb.append(db.numZ); 
    435         sb.append("; "); 
    436       } 
    437       if (db.hasT) { 
    438         sb.append(tString); 
    439         sb.append(": "); 
    440         sb.append(tVal); 
    441         sb.append("/"); 
    442         sb.append(db.numT); 
    443         sb.append("; "); 
    444       } 
    445       if (db.names != null) { 
    446         String name = db.names[current - 1]; 
    447         if (name != null) { 
    448           sb.append(name); 
    449           sb.append("; "); 
    450         } 
    451       } 
    452  
    453       int width = imp.getWidth(), height = imp.getHeight(); 
    454       Calibration cal = imp.getCalibration(); 
    455       if (cal.pixelWidth != 1.0 || cal.pixelHeight != 1.0) { 
    456         sb.append(IJ.d2s(width * cal.pixelWidth, 2)); 
    457         sb.append("x"); 
    458         sb.append(IJ.d2s(height * cal.pixelHeight, 2)); 
    459         sb.append(" "); 
    460         sb.append(cal.getUnits()); 
    461         sb.append(" ("); 
    462         sb.append(width); 
    463         sb.append("x"); 
    464         sb.append(height); 
    465         sb.append("); "); 
    466       } 
    467       else { 
    468         sb.append(width); 
    469         sb.append("x"); 
    470         sb.append(height); 
    471         sb.append(" pixels; "); 
    472       } 
    473       int type = imp.getType(); 
    474       int stackSize = imp.getStackSize(); 
    475       if (db.manager != null) stackSize = db.manager.getSize(); 
    476       int size = (width * height * stackSize) / 1048576; 
    477       switch (type) { 
    478         case ImagePlus.GRAY8: 
    479           sb.append("8-bit grayscale"); 
    480           break; 
    481         case ImagePlus.GRAY16: 
    482           sb.append("16-bit grayscale"); 
    483           size *= 2; 
    484           break; 
    485         case ImagePlus.GRAY32: 
    486           sb.append("32-bit grayscale"); 
    487           size *= 4; 
    488           break; 
    489         case ImagePlus.COLOR_256: 
    490           sb.append("8-bit color"); 
    491           break; 
    492         case ImagePlus.COLOR_RGB: 
    493           sb.append("RGB"); 
    494           size *= 4; 
    495           break; 
    496       } 
    497       sb.append("; "); 
    498       sb.append(size); 
    499       sb.append("M"); 
    500  
    501       Insets insets = super.getInsets(); 
    502       g.drawString(sb.toString(), 5, insets.top + textGap); 
    503     } 
     406    if (!update || db == null) return; 
     407    super.drawInfo(g); 
    504408  } 
    505409 
     
    508412    fps = value; 
    509413    if (animationTimer != null) animationTimer.setDelay(1000 / fps); 
     414  } 
     415 
     416  public String createSubtitle() { 
     417    int zVal = zSliceSel == null ? 1 : zSliceSel.getValue(); 
     418    int tVal = tSliceSel == null ? 1 : tSliceSel.getValue(); 
     419 
     420    int textGap = 0; 
     421 
     422    int nSlices = db.numZ * db.numT * db.numC; 
     423    int current = imp.getCurrentSlice(); 
     424    if (db.cache != null) { 
     425      int[] zct = db.cache.getCurrentPos(); 
     426      current = FormatTools.positionToRaster( 
     427        db.cache.getStrategy().getLengths(), zct); 
     428      current++; 
     429    } 
     430    if (db.merged) { 
     431      current--; 
     432      current /= db.reader.getSizeC(); 
     433      current++; 
     434    } 
     435 
     436    StringBuffer sb = new StringBuffer(); 
     437    sb.append(current); 
     438    sb.append("/"); 
     439    sb.append(nSlices); 
     440    sb.append("; "); 
     441    if (db.numZ > 1) { 
     442      sb.append(Z_STRING); 
     443      sb.append(": "); 
     444      sb.append(zVal); 
     445      sb.append("/"); 
     446      sb.append(db.numZ); 
     447      sb.append("; "); 
     448    } 
     449    if (db.numT > 1) { 
     450      sb.append(T_STRING); 
     451      sb.append(": "); 
     452      sb.append(tVal); 
     453      sb.append("/"); 
     454      sb.append(db.numT); 
     455      sb.append("; "); 
     456    } 
     457    if (db.names != null) { 
     458      String name = db.names[current - 1]; 
     459      if (name != null) { 
     460        sb.append(name); 
     461        sb.append("; "); 
     462      } 
     463    } 
     464 
     465    int width = imp.getWidth(), height = imp.getHeight(); 
     466    Calibration cal = imp.getCalibration(); 
     467    if (cal.pixelWidth != 1.0 || cal.pixelHeight != 1.0) { 
     468      sb.append(IJ.d2s(width * cal.pixelWidth, 2)); 
     469      sb.append("x"); 
     470      sb.append(IJ.d2s(height * cal.pixelHeight, 2)); 
     471      sb.append(" "); 
     472      sb.append(cal.getUnits()); 
     473      sb.append(" ("); 
     474      sb.append(width); 
     475      sb.append("x"); 
     476      sb.append(height); 
     477      sb.append("); "); 
     478    } 
     479    else { 
     480      sb.append(width); 
     481      sb.append("x"); 
     482      sb.append(height); 
     483      sb.append(" pixels; "); 
     484    } 
     485    int type = imp.getType(); 
     486    int stackSize = imp.getStackSize(); 
     487    if (db.cache != null) { 
     488      try { 
     489        stackSize = db.cache.getStrategy().getLoadList( 
     490          db.cache.getCurrentPos()).length; 
     491      } 
     492      catch (CacheException exc) { 
     493        LociDataBrowser.dumpException(exc); 
     494      } 
     495    } 
     496    int size = (width * height * stackSize) / 1048576; 
     497    switch (type) { 
     498      case ImagePlus.GRAY8: 
     499        sb.append("8-bit grayscale"); 
     500        break; 
     501      case ImagePlus.GRAY16: 
     502        sb.append("16-bit grayscale"); 
     503        size *= 2; 
     504        break; 
     505      case ImagePlus.GRAY32: 
     506        sb.append("32-bit grayscale"); 
     507        size *= 4; 
     508        break; 
     509      case ImagePlus.COLOR_256: 
     510        sb.append("8-bit color"); 
     511        break; 
     512      case ImagePlus.COLOR_RGB: 
     513        sb.append("RGB"); 
     514        size *= 3; 
     515      break; 
     516    } 
     517    sb.append("; "); 
     518    if (size > 0) { 
     519      sb.append(size); 
     520      sb.append("M"); 
     521    } 
     522    else { 
     523      size = (width * height * stackSize) / 1024; 
     524      sb.append(size); 
     525      sb.append("K"); 
     526    } 
     527    return sb.toString(); 
    510528  } 
    511529 
     
    531549      } 
    532550      catch (ReflectException exc) { 
    533         JOptionPane.showMessageDialog(this, 
    534           "Sorry, there has been an error creating the metadata window.", 
    535           "4D Data Browser", JOptionPane.ERROR_MESSAGE); 
    536551        LociDataBrowser.dumpException(exc); 
    537552      } 
    538553    } 
    539554    else if ("options".equals(cmd)) { 
    540       if (ow == null) { 
    541         ow = new OptionsWindow(db.hasZ ? db.numZ : 1, 
    542           db.hasT ? db.numT : 1, this); 
    543       } 
     555      if (ow == null) ow = new OptionsWindow(db.numZ, db.numT, this); 
    544556      ow.setVisible(true); 
    545557    } 
    546558    else if (src instanceof Timer) { 
    547559      t = tSliceSel.getValue() + 1; 
    548       if ((t > db.numT)) t = 1; 
     560      if (t > db.numT) t = 1; 
    549561      tSliceSel.setValue(t); 
    550562    } 
     
    566578 
    567579  public void adjustmentValueChanged(AdjustmentEvent adjustmentEvent) { 
    568     if(update) { 
    569       JScrollBar src = (JScrollBar) adjustmentEvent.getSource(); 
    570  
     580    if (!update) return; 
     581    JScrollBar src = (JScrollBar) adjustmentEvent.getSource(); 
     582 
     583    z = zSliceSel.getValue(); 
     584    t = tSliceSel.getValue(); 
     585 
     586    showSlice(z, t, c, src.getValueIsAdjusting() || db.cache != null); 
     587  } 
     588 
     589  // -- ItemListener methods -- 
     590 
     591  public synchronized void itemStateChanged(ItemEvent e) { 
     592    if (!update) return; 
     593    JCheckBox channels = (JCheckBox) e.getSource(); 
     594 
     595    z = zSliceSel.getValue(); 
     596    t = tSliceSel.getValue(); 
     597    c = channels.isSelected() ? 1 : 2; 
     598 
     599    showSlice(z, t, c, false); 
     600  } 
     601 
     602  // -- ChangeListener methods -- 
     603 
     604  public void stateChanged(ChangeEvent e) { 
     605    if (!update) return; 
     606    Object src = e.getSource(); 
     607    if (src == channelSpin) { 
     608      c = ((Integer) channelSpin.getValue()).intValue(); 
    571609      z = zSliceSel.getValue(); 
    572610      t = tSliceSel.getValue(); 
    573  
    574       if (!src.getValueIsAdjusting() || db.manager == null) showSlice(z, t, c); 
    575       else showTempSlice(z, t, c); 
    576     } 
    577   } 
    578  
    579   // -- ItemListener methods -- 
    580  
    581   public synchronized void itemStateChanged(ItemEvent e) { 
    582     if(update) { 
    583       JCheckBox channels = (JCheckBox) e.getSource(); 
    584  
    585       z = zSliceSel.getValue(); 
    586       t = tSliceSel.getValue(); 
    587       c = channels.isSelected() ? 1 : 2; 
    588  
    589       showSlice(z, t, c); 
    590     } 
    591   } 
    592  
    593   // -- ChangeListener methods -- 
    594  
    595   public void stateChanged(ChangeEvent e) { 
    596     if (update) { 
    597       Object src = e.getSource(); 
    598       if (src == channelSpin) { 
    599         c = ((Integer) channelSpin.getValue()).intValue(); 
    600         z = zSliceSel.getValue(); 
    601         t = tSliceSel.getValue(); 
    602         showSlice(z, t, c); 
    603       } 
    604       else if (src == fpsSpin) { 
    605         setFps(((Integer) fpsSpin.getValue()).intValue()); 
    606       } 
     611      showSlice(z, t, c, false); 
     612    } 
     613    else if (src == fpsSpin) { 
     614      setFps(((Integer) fpsSpin.getValue()).intValue()); 
    607615    } 
    608616  } 
     
    642650  public void windowClosed(WindowEvent e) { 
    643651    if (animationTimer != null) animationTimer.stop(); 
    644     if (db.manager != null) db.manager.finish(); 
    645652    super.windowClosed(e); 
    646653  } 
  • trunk/loci/plugins/browser/ImagePlusWrapper.java

    r3171 r3362  
    2727import ij.*; 
    2828import ij.process.*; 
    29 import java.awt.image.*; 
    3029import java.io.IOException; 
    3130import loci.formats.*; 
    3231import loci.formats.ome.OMEXMLMetadata; 
     32import loci.plugins.Util; 
    3333 
    3434public class ImagePlusWrapper { 
    3535 
    36   protected ImagePlus imp; 
    37   protected int sizeX, sizeY, sizeZ, sizeT, sizeC; 
    38   protected String dim; 
     36  // -- Fields -- 
     37 
    3938  protected MetadataStore store; 
    40   private int numTotal; // total number of images (across all stitched files) 
     39  private ImagePlus imp; 
     40  private int numTotal; // total number of images 
    4141 
    42   /** 
    43    * Constructor. 
    44    * @param name file name, or any one 
    45    *   of the file names if you use file stitching 
    46    * @param stitch true if use file stitching 
    47    */ 
    48   public ImagePlusWrapper(String name, IFormatReader r, FileStitcher fs, 
    49     boolean stitch) throws IOException, FormatException 
     42  // -- Constructor -- 
     43 
     44  public ImagePlusWrapper(String name, IFormatReader r) 
     45    throws IOException, FormatException 
    5046  { 
    5147    store = new OMEXMLMetadata(); 
    5248    synchronized (r) { 
    53       try { 
    54         r.setMetadataStore(store); 
    55       } 
    56       catch (Exception e) { 
    57         e.printStackTrace(); 
    58         LociDataBrowser.dumpException(e); 
     49      r.setMetadataStore(store); 
     50 
     51      // retrieve core metadata 
     52 
     53      r.setId(name); 
     54      r.setSeries(r.getSeries()); 
     55 
     56      numTotal = r.getImageCount(); 
     57      String dim = r.getDimensionOrder(); 
     58      int sizeX = r.getSizeX(); 
     59      int sizeY = r.getSizeY(); 
     60      int sizeZ = r.getSizeZ(); 
     61      int sizeT = r.getSizeT(); 
     62      int sizeC = r.getSizeC(); 
     63 
     64      if (LociDataBrowser.DEBUG) { 
     65        LogTools.println("numTotal = "+numTotal); 
    5966      } 
    6067 
    61       // get # images in all matching files 
    62  
    63       fs.setId(name); 
    64       fs.setSeries(r.getSeries()); 
    65  
    66       try { 
    67         if (stitch && fs == null) fs = new FileStitcher(r); 
    68  
    69         numTotal = fs.getImageCount(); 
    70         dim = fs.getDimensionOrder(); 
    71         sizeX = fs.getSizeX(); 
    72         sizeY = fs.getSizeY(); 
    73         sizeZ = fs.getSizeZ(); 
    74         sizeT = fs.getSizeT(); 
    75         sizeC = fs.getSizeC(); 
    76  
    77         if (LociDataBrowser.DEBUG) { 
    78           System.err.println("numTotal = "+numTotal); 
    79         } 
    80       } 
    81       catch(Exception exc) { 
    82         exc.printStackTrace(); 
    83         LociDataBrowser.dumpException(exc); 
    84       } 
    85  
    86       int num = fs.getImageCount(); 
    87       ImageStack stackB = null, stackS = null, 
    88         stackF = null, stackO = null; 
     68      int num = r.getImageCount(); 
     69      ImageStack stackB = null, stackS = null, stackF = null, stackO = null; 
    8970      long start = System.currentTimeMillis(); 
    9071      long time = start; 
     
    9677          time = clock; 
    9778        } 
    98         IJ.showProgress((double) i/num); 
    99         BufferedImage img = fs.openImage(i); 
     79        IJ.showProgress((double) i / num); 
     80        ImageProcessor ip = Util.openProcessor(r, i); 
    10081 
    101         // scale image if it is the wrong size 
    102         int w = img.getWidth(), h = img.getHeight(); 
    103         if (w != sizeX || h != sizeY) { 
    104           System.out.println("Warning: image size " + w + "x" + h + 
    105             " does not match expected size of " + sizeX + "x" + sizeY + "."); 
    106           img = ImageTools.scale(img, sizeX, sizeY, false); 
    107           w = sizeX; 
    108           h = sizeY; 
     82        int[] zct = r.getZCTCoords(i); 
     83        StringBuffer sb = new StringBuffer(); 
     84        sb.append("ch:"); 
     85        sb.append(zct[1] + 1); 
     86        sb.append("/"); 
     87        sb.append(r.getSizeC()); 
     88        sb.append("; z:"); 
     89        sb.append(zct[0] + 1); 
     90        sb.append("/"); 
     91        sb.append(r.getSizeZ()); 
     92        sb.append("; t:"); 
     93        sb.append(zct[2] + 1); 
     94        sb.append("/"); 
     95        sb.append(r.getSizeT()); 
     96        String label = sb.toString(); 
     97 
     98        if (ip instanceof ByteProcessor) { 
     99          if (stackB == null) stackB = new ImageStack(sizeX, sizeY); 
     100          stackB.addSlice(label, ip); 
    109101        } 
    110  
    111         ImageProcessor ip = null; 
    112         WritableRaster raster = img.getRaster(); 
    113         int c = raster.getNumBands(); 
    114         int tt = raster.getTransferType(); 
    115  
    116         if (c == 1) { 
    117           if (tt == DataBuffer.TYPE_BYTE) { 
    118             byte[] b = ImageTools.getBytes(img)[0]; 
    119             if (b.length > w*h) { 
    120               byte[] tmp = b; 
    121               b = new byte[w*h]; 
    122               System.arraycopy(tmp, 0, b, 0, b.length); 
    123             } 
    124             ip = new ByteProcessor(w, h, b, null); 
    125             if (stackB == null) { 
    126               stackB = new ImageStack(w, h); 
    127             } 
    128             stackB.addSlice(name + ":" + (i + 1), ip); 
     102        else if (ip instanceof ShortProcessor) { 
     103          if (stackS == null) stackB = new ImageStack(sizeX, sizeY); 
     104          stackS.addSlice(label, ip); 
     105        } 
     106        else if (ip instanceof FloatProcessor) { 
     107          if (stackB != null) stackB.addSlice(label, ip.convertToByte(true)); 
     108          else if (stackS != null) { 
     109            stackS.addSlice(label, ip.convertToShort(true)); 
    129110          } 
    130           else if (tt == DataBuffer.TYPE_USHORT) { 
    131             short[] s = ImageTools.getShorts(img)[0]; 
    132             if (s.length > w*h) { 
    133               short[] tmp = s; 
    134               s = new short[w*h]; 
    135               System.arraycopy(tmp, 0, s, 0, s.length); 
    136             } 
    137             ip = new ShortProcessor(w, h, s, null); 
    138             if (stackS == null) { 
    139               stackS = new ImageStack(w, h); 
    140             } 
    141             stackS.addSlice(name + ":" + (i + 1), ip); 
    142           } 
    143           else if (tt == DataBuffer.TYPE_FLOAT) { 
    144             float[] f = ImageTools.getFloats(img)[0]; 
    145             if (f.length > w*h) { 
    146               float[] tmp = f; 
    147               f = new float[w*h]; 
    148               System.arraycopy(tmp, 0, f, 0, f.length); 
    149             } 
    150             ip = new FloatProcessor(w, h, f, null); 
    151             if (stackF == null) { 
    152               stackF = new ImageStack(w, h); 
    153             } 
    154             stackF.addSlice(name + ":" + (i + 1), ip); 
     111          else { 
     112            if (stackF == null) stackF = new ImageStack(sizeX, sizeY); 
     113            stackF.addSlice(label, ip); 
    155114          } 
    156115        } 
    157         if (ip == null) { 
    158           ip = new ImagePlus(name, img).getProcessor(); // slow 
    159           if (stackO == null) { 
    160             stackO = new ImageStack(w, h); 
    161           } 
    162           stackO.addSlice(name + ":" + (i + 1), ip); 
     116        else if (ip instanceof ColorProcessor) { 
     117          if (stackO == null) stackO = new ImageStack(sizeX, sizeY); 
     118          stackO.addSlice(label, ip); 
    163119        } 
    164120      } 
    165121      IJ.showStatus("Creating image"); 
    166122      IJ.showProgress(1); 
    167       if (stackB != null) { 
    168         imp = new ImagePlus(name, stackB); 
    169       } 
    170       if (stackS != null) { 
    171         imp = new ImagePlus(name, stackS); 
    172       } 
    173       if (stackF != null) { 
    174         imp = new ImagePlus(name, stackF); 
    175       } 
    176       if (stackO != null) { 
    177         imp = new ImagePlus(name, stackO); 
    178       } 
     123      if (stackB != null) imp = new ImagePlus(name, stackB); 
     124      if (stackS != null) imp = new ImagePlus(name, stackS); 
     125      if (stackF != null) imp = new ImagePlus(name, stackF); 
     126      if (stackO != null) imp = new ImagePlus(name, stackO); 
     127 
    179128      long end = System.currentTimeMillis(); 
    180129      double elapsed = (end - start) / 1000.0; 
     
    188137  } 
    189138 
     139  // -- ImagePlusWrapper API methods -- 
     140 
    190141  public ImagePlus getImagePlus() { return imp; } 
    191142 
    192143  public int getNumTotal() { return numTotal; } 
    193144 
    194   public static ImageProcessor getImageProcessor( 
    195     String name, IFormatReader read, int index) 
    196   { 
    197     BufferedImage img = null; 
    198     String dim = null; 
    199     int sizeX = 0, sizeY = 0, sizeZ = 0, sizeT = 0, sizeC = 0; 
    200     synchronized (read) { 
    201       Exception problem = null; 
    202       try { 
    203         int series = read.getSeries(); 
    204         read.setId(name); 
    205         read.setSeries(series); 
    206         dim = read.getDimensionOrder(); 
    207         sizeX = read.getSizeX(); 
    208         sizeY = read.getSizeY(); 
    209         sizeZ = read.getSizeZ(); 
    210         sizeT = read.getSizeT(); 
    211         sizeC = read.getSizeC(); 
    212       } 
    213       catch (FormatException exc) { 
    214         problem = exc; 
    215         LociDataBrowser.dumpException(exc); 
    216       } 
    217       catch (IOException exc) { 
    218         problem = exc; 
    219         LociDataBrowser.dumpException(exc); 
    220       } 
    221       if (problem != null) { 
    222         problem.printStackTrace(); 
    223         return null; 
    224       } 
    225  
    226       // read image from disk 
    227       try { 
    228         img = read.openImage(index); 
    229       } 
    230       catch (FormatException exc) { 
    231         exc.printStackTrace(); 
    232         LociDataBrowser.dumpException(exc); 
    233       } 
    234       catch (IOException exc) { 
    235         exc.printStackTrace(); 
    236         LociDataBrowser.dumpException(exc); 
    237       } 
    238     } 
    239  
    240     if (img == null) { 
    241       System.out.println("Sorry, but there was a problem reading image '" + 
    242         name + "' at index " + index + " (sizeX=" + sizeX + ", sizeY=" + 
    243         sizeY + ", sizeZ=" + sizeZ + ", sizeT=" + sizeT + ", sizeC=" + sizeC + 
    244         ", dim=" + dim + ")."); 
    245       return null; 
    246     } 
    247  
    248     // scale image if it is the wrong size 
    249     int w = img.getWidth(), h = img.getHeight(); 
    250     if (w != sizeX || h != sizeY) { 
    251       System.out.println("Warning: image size " + w + "x" + h + 
    252         " does not match expected size of " + sizeX + "x" + sizeY + "."); 
    253       img = ImageTools.scale(img, sizeX, sizeY, false); 
    254       w = sizeX; 
    255       h = sizeY; 
    256     } 
    257  
    258     // convert BufferedImage to ImageProcessor 
    259     ImageProcessor ip = null; 
    260     WritableRaster raster = img.getRaster(); 
    261     int c = raster.getNumBands(); 
    262     int tt = raster.getTransferType(); 
    263     if (c == 1) { 
    264       if (tt == DataBuffer.TYPE_BYTE) { 
    265         byte[] b = ImageTools.getBytes(img)[0]; 
    266         if (b.length > w*h) { 
    267           byte[] tmp = b; 
    268           b = new byte[w*h]; 
    269           System.arraycopy(tmp, 0, b, 0, b.length); 
    270         } 
    271         ip = new ByteProcessor(w, h, b, null); 
    272       } 
    273       else if (tt == DataBuffer.TYPE_USHORT) { 
    274         short[] s = ImageTools.getShorts(img)[0]; 
    275         if (s.length > w*h) { 
    276           short[] tmp = s; 
    277           s = new short[w*h]; 
    278           System.arraycopy(tmp, 0, s, 0, s.length); 
    279         } 
    280         ip = new ShortProcessor(w, h, s, null); 
    281       } 
    282       else if (tt == DataBuffer.TYPE_FLOAT) { 
    283         float[] f = ImageTools.getFloats(img)[0]; 
    284         if (f.length > w*h) { 
    285           float[] tmp = f; 
    286           f = new float[w*h]; 
    287           System.arraycopy(tmp, 0, f, 0, f.length); 
    288         } 
    289         ip = new FloatProcessor(w, h, f, null); 
    290       } 
    291     } 
    292     if (ip == null) { 
    293       ip = new ImagePlus(name, img).getProcessor(); // slow 
    294     } 
    295  
    296     return ip; 
    297   } 
    298  
    299145} 
  • trunk/loci/plugins/browser/LociDataBrowser.java

    r3171 r3362  
    2828import ij.gui.ImageCanvas; 
    2929import ij.io.FileInfo; 
    30 import java.awt.event.WindowAdapter; 
    31 import java.awt.event.WindowEvent; 
     30import ij.process.ImageProcessor; 
    3231import java.io.ByteArrayOutputStream; 
    33 import java.io.PrintStream; 
     32import loci.plugins.Util; 
    3433import loci.formats.*; 
     34import loci.formats.cache.*; 
    3535import loci.formats.ome.OMEXMLMetadata; 
    3636 
     
    6363  protected DimensionSwapper reader; 
    6464 
    65   /** The file stitcher used by the reader. */ 
    66   protected FileStitcher fStitch; 
    67  
    6865  /** The CustomWindow used to display data. */ 
    6966  protected CustomWindow cw; 
     
    7269  protected String id; 
    7370 
    74   /** Whether dataset has multiple Z, T and C positions. */ 
    75   protected boolean hasZ, hasT, hasC; 
    76  
    7771  /** Number of Z, T and C positions. */ 
    7872  protected int numZ, numT, numC; 
     
    8781  protected boolean virtual; 
    8882 
    89   /** Cache manager (if virtual stack is used). */ 
    90   protected CacheManager manager; 
    91  
    92 //  /** Macro manager - allows us to perform operations on a virtual stack. */ 
    93 //  protected MacroManager macro; 
    94  
    95 //  /** Macro manager thread. */ 
    96 //  protected Thread macroThread; 
    97  
    9883  /** Series to use in a multi-series file. */ 
    9984  protected int series; 
    10085 
     86  protected Cache cache; 
    10187  private ImageStack stack; 
     88  protected boolean merged; 
     89  protected boolean colorize; 
    10290 
    10391  // -- Constructors -- 
    10492 
    105   public LociDataBrowser(String name) { 
    106     this(null, null, name, 0, false); 
    107   } 
    108  
    109   public LociDataBrowser(String name, boolean merged) { 
    110     this(null, null, name, 0, merged); 
    111   } 
    112  
    113   public LociDataBrowser(IFormatReader r, 
    114     FileStitcher fs, String name, int seriesNo, boolean merged) 
     93  public LociDataBrowser(IFormatReader r, String name, int seriesNo, 
     94    boolean merged, boolean colorize) 
    11595  { 
    116     fStitch = fs; 
    117     if (r == null) { 
    118       if (fStitch == null) { 
    119         r = merged ? (IFormatReader) new ChannelMerger() : 
    120           new ChannelSeparator(); 
    121       } 
    122       else { 
    123         r = merged ? (IFormatReader) 
    124           new ChannelMerger(fStitch) : new ChannelSeparator(fStitch); 
    125       } 
    126     } 
     96    this.merged = merged; 
     97    this.colorize = colorize; 
     98 
     99    if (r == null) r = new ChannelSeparator(); 
    127100    reader = new DimensionSwapper(r); 
    128101    id = name; 
     
    132105      reader.setId(id); 
    133106      reader.setSeries(series); 
    134       if (fStitch != null) { 
    135         fStitch.setId(id); 
    136         fStitch.setSeries(series); 
     107    } 
     108    catch (Exception exc) { 
     109      dumpException(exc); 
     110    } 
     111 
     112    if (this.merged) { 
     113      int c = reader.getSizeC(); 
     114      int type = reader.getPixelType(); 
     115 
     116      if (c > 3 || (type != FormatTools.INT8 && type != FormatTools.UINT8)) { 
     117        this.merged = false; 
    137118      } 
    138119    } 
    139     catch (Exception exc) { 
    140       exc.printStackTrace(); 
    141       dumpException(exc); 
    142       String msg = exc.getMessage(); 
    143       IJ.showMessage("4D Data Browser", "Sorry, there was a problem " + 
    144         "reading the data" + (msg == null ? "." : (": " + msg))); 
    145     } 
    146  
    147 // TODO: macros 
    148 //    macro = new MacroManager(); 
    149 //    macroThread = new Thread(macro, "MacroRecorder"); 
    150 //    macroThread.start(); 
    151120  } 
    152121 
     
    184153    numT = sizeT; 
    185154 
    186     hasZ = numZ > 1; 
    187     hasC = numC > 1; 
    188     hasT = numT > 1; 
    189  
    190155    lengths = new int[3]; 
    191156    lengths[z] = numZ; 
     
    200165  /** Resets all dimensional data in case they've switched. */ 
    201166  public void setDimensions() { 
    202     String order = null; 
    203167    try { 
    204       numZ = reader.getSizeZ(); 
    205       numC = reader.getEffectiveSizeC(); 
    206       numT = reader.getSizeT(); 
    207       order = reader.getDimensionOrder(); 
    208       if (DEBUG) { 
    209         System.out.println("setDimensions: numZ=" + numZ + 
    210           ", numC=" + numC + ", numT=" + numT + ", order=" + order); 
    211       } 
     168      String order = reader.getDimensionOrder().substring(2); 
     169      setDimensions(reader.getSizeZ(), merged ? 1 : reader.getEffectiveSizeC(), 
     170        reader.getSizeT(), order.indexOf("Z"), order.indexOf("C"), 
     171        order.indexOf("T")); 
    212172    } 
    213173    catch (Exception exc) { 
    214174      dumpException(exc); 
    215       return; 
    216     } 
    217  
    218     hasZ = numZ > 1; 
    219     hasC = numC > 1; 
    220     hasT = numT > 1; 
    221  
    222     zIndex = order.indexOf("Z") - 2; 
    223     cIndex = order.indexOf("C") - 2; 
    224     tIndex = order.indexOf("T") - 2; 
    225  
    226     lengths[zIndex] = numZ; 
    227     lengths[tIndex] = numT; 
    228     lengths[cIndex] = numC; 
     175    } 
    229176  } 
    230177 
     
    239186 
    240187  public static void dumpException(Exception exc) { 
    241     exc.printStackTrace(); 
     188    LogTools.trace(exc); 
    242189    ByteArrayOutputStream out = new ByteArrayOutputStream(); 
    243     exc.printStackTrace(new PrintStream(out)); 
    244190    String dump = new String(out.toByteArray()); 
    245191    String msg = "Sorry, there was a problem:\n\n" + dump; 
     
    255201 
    256202  public void toggleMerge() { 
    257     if (reader.getReader() instanceof ChannelMerger) { 
    258       IFormatReader parent = ((ReaderWrapper) reader).getReader(); 
    259       reader = new DimensionSwapper(new ChannelSeparator(parent)); 
    260       run(); 
    261     } 
    262     else if (reader.getReader() instanceof ChannelSeparator) { 
    263       IFormatReader parent = ((ReaderWrapper) reader).getReader(); 
    264       reader = new DimensionSwapper(new ChannelMerger(parent)); 
    265       run(); 
    266     } 
    267     else { 
    268       throw new RuntimeException("Unsupported reader class: " + 
    269         reader.getClass().getName()); 
    270     } 
     203    if (numC <= 3 && (reader.getPixelType() == FormatTools.INT8 || 
     204      reader.getPixelType() == FormatTools.UINT8)) 
     205    { 
     206      merged = !merged; 
     207    } 
     208    else merged = false; 
     209    run(); 
    271210  } 
    272211 
    273212  public boolean isMerged() { 
    274     return reader.getReader() instanceof ChannelMerger; 
     213    return merged; 
    275214  } 
    276215 
    277216  public void run() { 
    278 // TODO: macros 
    279 //    macro = new MacroManager(); 
    280 //    macroThread = new Thread(macro, "MacroRecorder"); 
    281 //    macroThread.start(); 
    282  
    283217    stack = null; 
    284218    try { 
     
    288222      lengths = new int[3]; 
    289223 
     224      ImagePlus imp = null; 
     225 
    290226      if (virtual) { 
    291227        synchronized (reader) { 
    292228          int num = reader.getImageCount(); 
    293           if (manager != null) { 
    294             manager.finish(); 
    295             manager = null; 
     229 
     230          // assemble axis lengths in the proper order 
     231          int z = reader.getSizeZ(); 
     232          int c = reader.getSizeC(); 
     233          int t = reader.getSizeT(); 
     234          int tAxis = -1; 
     235          int zAxis = -1; 
     236          int cAxis = -1; 
     237          String order = reader.getDimensionOrder(); 
     238          for (int i=0; i<lengths.length; i++) { 
     239            char ch = order.charAt(i + 2); 
     240            lengths[i] = ch == 'Z' ? z : ch == 'C' ? c : t; 
     241            if (ch == 'T') tAxis = i; 
     242            else if (ch == 'Z') zAxis = i; 
     243            else cAxis = i; 
    296244          } 
    297           manager = new CacheManager(0, 0, 0, 0, 0, 0, 20, 0, 0, 
    298             this, id, CacheManager.T_AXIS, 
    299             CacheManager.CROSS_MODE, CacheManager.FORWARD_FIRST); 
     245 
     246          ImageProcessorSource source = new ImageProcessorSource(reader); 
     247          CrosshairStrategy strategy = new CrosshairStrategy(lengths); 
     248 
     249          strategy.setRange(100, tAxis); 
     250          for (int i=0; i<lengths.length; i++) { 
     251            strategy.setOrder(ICacheStrategy.FORWARD_ORDER, i); 
     252          } 
     253          strategy.setPriority(ICacheStrategy.MAX_PRIORITY, tAxis); 
     254          strategy.setPriority(ICacheStrategy.NORMAL_PRIORITY, zAxis); 
     255          strategy.setPriority(ICacheStrategy.MIN_PRIORITY, cAxis); 
     256 
     257          cache = new Cache(strategy, source); 
     258          cache.setCurrentPos(new int[] {0, 0, 0}); 
    300259 
    301260          try { 
     
    307266            stack = new ImageStack(sizeX, sizeY); 
    308267            // CTR: must add at least one image to the stack 
    309             stack.addSlice(id + " : 1", manager.getSlice(0, 0, 0)); 
     268            stack.addSlice(id + " : 1", 
     269              (ImageProcessor) cache.getObject(new int[] {0, 0, 0})); 
    310270          } 
    311271          catch (OutOfMemoryError e) { 
     
    319279          return; 
    320280        } 
    321         ImagePlus imp = new ImagePlus(id, stack); 
    322  
    323         FileInfo fi = new FileInfo(); 
    324  
    325         MetadataStore store = reader.getMetadataStore(); 
    326         if (store instanceof OMEXMLMetadata) { 
    327           fi.description = ((OMEXMLMetadata) store).dumpXML(); 
    328         } 
    329  
    330         imp.setFileInfo(fi); 
    331         show(imp); 
     281        imp = new ImagePlus(id, stack); 
    332282      } 
    333283      else { 
    334         manager = null; 
    335         ipw = new ImagePlusWrapper(id, reader, fStitch, true); 
     284        cache = null; 
     285        ipw = new ImagePlusWrapper(id, reader); 
    336286        setDimensions(); 
    337  
    338         int stackSize = ipw.getImagePlus().getStackSize(); 
    339         if (stackSize != numZ * numT * numC) { 
    340           System.err.println("Error, stack size mismatch with dimension " + 
    341             "sizes: stackSize=" + stackSize + ", numZ=" + numZ + 
     287        imp = ipw.getImagePlus(); 
     288 
     289        if (imp.getStackSize() != numZ * numT * numC) { 
     290          LogTools.println("Error, stack size mismatch with dimension " + 
     291            "sizes: stackSize=" + imp.getStackSize() + ", numZ=" + numZ + 
    342292            ", numT=" + numT + ", numC=" + numC); 
    343293        } 
    344  
    345         FileInfo fi = ipw.getImagePlus().getOriginalFileInfo(); 
    346         if (fi == null) fi = new FileInfo(); 
    347  
    348         MetadataStore store = ipw.store; 
    349         if (store instanceof OMEXMLMetadata) { 
    350           fi.description = ((OMEXMLMetadata) store).dumpXML(); 
    351         } 
    352  
    353         ipw.getImagePlus().setFileInfo(fi); 
    354         show(ipw.getImagePlus()); 
    355294      } 
     295 
     296      FileInfo fi = imp.getOriginalFileInfo(); 
     297      if (fi == null) fi = new FileInfo(); 
     298 
     299      MetadataStore store = virtual ? reader.getMetadataStore() : ipw.store; 
     300      if (store instanceof OMEXMLMetadata) { 
     301        fi.description = ((OMEXMLMetadata) store).dumpXML(); 
     302        Util.applyCalibration((MetadataRetrieve) store, imp, series); 
     303      } 
     304 
     305      imp.setFileInfo(fi); 
     306      show(imp); 
    356307    } 
    357308    catch (Exception exc) { dumpException(exc); } 
    358309  } 
    359310 
    360   // -- Main method -- 
    361  
    362   /** Main method, for testing. */ 
    363   public static void main(String[] args) { 
    364     if (args.length < 1) { 
    365       System.out.println("Please specify a filename on the command line."); 
    366       System.exit(1); 
    367     } 
    368     ImageJ ij = new ImageJ(null); 
    369     LociDataBrowser ldb = new LociDataBrowser(args[0]); 
    370     ldb.run(); 
    371     WindowAdapter closer = new WindowAdapter() { 
    372       public void windowClosing(WindowEvent e) { 
    373         System.exit(0); 
    374       } 
    375     }; 
    376     ij.addWindowListener(closer); 
    377     ldb.cw.addWindowListener(closer); 
    378   } 
    379  
    380311} 
  • trunk/loci/plugins/browser/OptionsWindow.java

    r3171 r3362  
    2525package loci.plugins.browser; 
    2626 
     27import com.jgoodies.forms.layout.CellConstraints; 
     28import com.jgoodies.forms.layout.FormLayout; 
    2729import java.awt.*; 
    2830import java.awt.event.*; 
     31import java.io.IOException; 
    2932import javax.swing.*; 
     33import javax.swing.border.*; 
    3034import javax.swing.event.*; 
    31 import javax.swing.border.*; 
    3235import loci.formats.*; 
    33 import java.util.Vector; 
    34  
    35 import com.jgoodies.forms.layout.CellConstraints; 
    36 import com.jgoodies.forms.layout.FormLayout; 
     36import loci.formats.cache.*; 
    3737 
    3838/** 
     
    4646  ActionListener, ChangeListener, ItemListener 
    4747{ 
    48   // -- Fields -- 
     48  // -- Constants -- 
    4949 
    5050  /** Constant dlu size for indents in GUI. */ 
     
    5454  private static final int DEFAULT = 100; 
    5555 
     56  // -- Fields -- 
     57 
    5658  /** Parent window. */ 
    5759  private CustomWindow cw; 
    5860 
    59   /** The CacheManager for this instance of data browser. */ 
    60   private CacheManager manager; 
    61  
    62   /** The FileStitcher used to stich files together. */ 
    63   private FileStitcher fs; 
    64  
    65   /** CheckBoxes to indicate which axes to store. */ 
    66   private JCheckBox zCheck, tCheck, cCheck; 
    67  
    6861  /** CheckBoxes to control if caching is on or off. */ 
    6962  private JCheckBox cacheToggle, mergeCheck; 
    7063 
    7164  /** Spinners for slice storage. */ 
    72   private JSpinner zFSpin, zBSpin, tFSpin, tBSpin, cFSpin, cBSpin; 
     65  private JSpinner zSpin, tSpin, cSpin; 
    7366 
    7467  /** Combo Boxes for cache mode selection. */ 
     
    7871  private JComboBox topBox, midBox, lowBox; 
    7972 
    80   /** Button to reset CacheManager to default modes. */ 
     73  /** Button to reset cache to default modes. */ 
    8174  private JButton resetBtn; 
    8275 
     
    8780  private int oldTop, oldMid, oldLow; 
    8881 
    89   JComboBox[] blockBoxes; 
    9082  String id = null, order = null, suffix = null; 
    91   String[] prefixes = null, blocks = null; 
     83  String[] prefixes = null; 
    9284  int sizeZ = -1, sizeT = -1, sizeC = -1; 
    9385  int[] axes = null; 
     
    9991  public OptionsWindow(int numZ, int numT, CustomWindow c) { 
    10092    super("4D Data Browser - Options"); 
    101     setBackground(Color.gray); 
     93    setBackground(Color.GRAY); 
    10294 
    10395    cw = c; 
    10496 
    105     manager = cw.db.manager; 
    106  
    107     fs = cw.db.fStitch; 
    108  
    10997    update = false; 
    11098 
     
    112100 
    113101    // get FilePattern Data 
    114     if (fs != null) { 
    115       try { 
    116         id = cw.db.id; 
    117         fs.setId(id); 
    118         fs.setSeries(cw.db.series); 
    119         order = fs.getDimensionOrder().substring(2); 
    120         sizeZ = fs.getSizeZ(); 
    121         sizeT = fs.getSizeT(); 
    122         sizeC = fs.getSizeC(); 
    123         axes = fs.getAxisTypes(); 
    124         fp = fs.getFilePattern(); 
    125         prefixes = fp.getPrefixes(); 
    126         blocks = fp.getBlocks(); 
    127         suffix = fp.getSuffix(); 
    128       } 
    129       catch (Exception exc) { 
    130         exc.printStackTrace(); 
    131         LociDataBrowser.dumpException(exc); 
    132       } 
    133     } 
    134     else { 
    135       try { 
    136         id = cw.db.id; 
    137         cw.db.reader.setId(id); 
    138         cw.db.reader.setSeries(cw.db.series); 
    139         order = cw.db.reader.getDimensionOrder().substring(2); 
    140         sizeZ = cw.db.reader.getSizeZ(); 
    141         sizeT = cw.db.reader.getSizeT(); 
    142         sizeC = cw.db.reader.getSizeC(); 
    143       } 
    144       catch (Exception exc) { 
    145         exc.printStackTrace(); 
    146         LociDataBrowser.dumpException(exc); 
    147       } 
     102    try { 
     103      id = cw.db.id; 
     104      cw.db.reader.setId(id); 
     105      cw.db.reader.setSeries(cw.db.series); 
     106      order = cw.db.reader.getDimensionOrder().substring(2); 
     107      sizeZ = cw.db.reader.getSizeZ(); 
     108      sizeT = cw.db.reader.getSizeT(); 
     109      sizeC = cw.db.reader.getSizeC(); 
     110    } 
     111    catch (FormatException exc) { 
     112      LociDataBrowser.dumpException(exc); 
     113    } 
     114    catch (IOException exc) { 
     115      LociDataBrowser.dumpException(exc); 
    148116    } 
    149117 
     
    151119 
    152120    JPanel disPane = new JPanel(); 
    153     TitledBorder disB = BorderFactory.createTitledBorder(etchB, 
    154       "Custom Axes"); 
     121    TitledBorder disB = BorderFactory.createTitledBorder(etchB, "Custom Axes"); 
    155122 
    156123    disPane.setBorder(disB); 
    157124 
    158125    JLabel sliceLab = new JLabel("\u00B7" + "Slice-Groups in File" + "\u00B7"); 
    159     JLabel blockLab = new JLabel("\u00B7" + "Blocks in Filenames" + "\u00B7"); 
    160  
    161     Vector blockLabelsV = new Vector(); 
    162     JLabel[] blockLabels = {new JLabel()}; 
    163     if (fs != null) { 
    164       for (int i = 0;i<blocks.length;i++) { 
    165         JLabel temp = new JLabel("Block " + blocks[i] + ":"); 
    166         blockLabelsV.add(temp); 
    167       } 
    168       Object[] blockLabelsO = blockLabelsV.toArray(); 
    169       blockLabels = new JLabel[blockLabelsO.length]; 
    170       for (int i = 0;i<blockLabelsO.length;i++) { 
    171         blockLabels[i] = (JLabel) blockLabelsO[i]; 
    172         blockLabels[i].setForeground(getColor(i)); 
    173       } 
     126 
     127    int left = id.indexOf("<"); 
     128    int right = id.indexOf(">"); 
     129    if (left != -1 && right != -1 && left < right) fp = new FilePattern(id); 
     130    else fp = new FilePattern(new Location(id)); 
     131 
     132    try { 
     133      prefixes = fp.getPrefixes(); 
     134      suffix = fp.getSuffix(); 
     135    } 
     136    catch (NullPointerException exc) { 
     137      // eat this exception, as it's only generated by images downloaded from 
     138      // an OME server 
    174139    } 
    175140 
     
    185150    cGroup.addActionListener(this); 
    186151 
    187     if (fs != null) { 
    188       Vector blockBoxesV = new Vector(); 
    189       for (int i = 0;i<blocks.length;i++) { 
    190         JComboBox temp = new JComboBox(choices); 
    191         if (axes[i] == AxisGuesser.Z_AXIS) temp.setSelectedIndex(0); 
    192         else if (axes[i] == AxisGuesser.T_AXIS) temp.setSelectedIndex(1); 
    193         else temp.setSelectedIndex(2); 
    194         temp.setActionCommand("Block1"); 
    195         temp.addActionListener(this); 
    196         blockBoxesV.add(temp); 
    197       } 
    198       Object[] blockBoxesO = blockBoxesV.toArray(); 
    199       blockBoxes = new JComboBox[blockBoxesO.length]; 
    200       for (int i = 0;i<blockBoxesO.length;i++) { 
    201         JComboBox temp = (JComboBox) blockBoxesO[i]; 
    202         temp.setForeground(getColor(i)); 
    203         blockBoxes[i] = temp; 
    204       } 
    205     } 
    206  
    207152    JPanel slicePanel = new JPanel(); 
    208153    slicePanel.add(sliceLab); 
    209     slicePanel.setBackground(Color.darkGray); 
    210     sliceLab.setForeground(Color.lightGray); 
    211     JPanel blockPanel = new JPanel(); 
    212     blockPanel.add(blockLab); 
    213     blockPanel.setBackground(Color.darkGray); 
    214     blockLab.setForeground(Color.lightGray); 
    215  
    216     JPanel filePane = new JPanel(); 
    217     if (fs!=null) { 
    218       filePane = new JPanel(new FlowLayout()); 
    219       for (int i = 0;i<prefixes.length;i++) { 
    220         JLabel prefLab = new JLabel(prefixes[i]); 
    221         JLabel blokLab = new JLabel(blocks[i]); 
    222         blokLab.setForeground(getColor(i)); 
    223         filePane.add(prefLab); 
    224         filePane.add(blokLab); 
    225       } 
    226       JLabel sufLab = new JLabel(suffix); 
    227       filePane.add(sufLab); 
    228     } 
     154    slicePanel.setBackground(Color.DARK_GRAY); 
     155    sliceLab.setForeground(Color.LIGHT_GRAY); 
    229156 
    230157    JLabel zLab, tLab, cLab, fileLab; 
    231     int[] internalSizes = null; 
    232  
    233     internalSizes = new int[3]; 
    234     for (int i = 0;i<internalSizes.length;i++) { 
     158    int[] internalSizes = new int[3]; 
     159    for (int i=0; i<internalSizes.length; i++) { 
    235160      internalSizes[i] = getOrderSize(i); 
    236161    } 
     
    242167 
    243168    String rowString = "pref," + TAB + ",pref,pref,pref," + TAB + ",pref,pref"; 
    244     for (int i = 0; i<blockLabels.length;i++) { 
     169    for (int i=0; i<internalSizes.length; i++) { 
    245170      rowString += ",pref"; 
    246171    } 
    247172 
    248     FormLayout layout = new FormLayout( 
    249         TAB + ",pref," + TAB + ",pref:grow," + TAB, 
    250         rowString); 
     173    String colString = TAB + ",pref," + TAB + ",pref:grow," + TAB; 
     174    FormLayout layout = new FormLayout(colString, rowString); 
    251175    disPane.setLayout(layout); 
    252176    CellConstraints cc = new CellConstraints(); 
     
    263187      disPane.add(cGroup, cc.xy(4, 5)); 
    264188    } 
    265     if (fs != null) { 
    266       disPane.add(blockPanel, cc.xyw(1, 7, 5)); 
    267       disPane.add(fileLab, cc.xy(2, 8)); 
    268       disPane.add(filePane, cc.xy(4, 8)); 
    269       for (int i = 0;i<blockLabels.length;i++) { 
    270         disPane.add(blockLabels[i], cc.xy(2, 9+i)); 
    271         disPane.add(blockBoxes[i], cc.xy(4, 9+i)); 
    272       } 
    273     } 
    274189 
    275190    //set up animation options pane 
     
    285200    JLabel stratL = new JLabel("Loading Strategy:"); 
    286201    JLabel sizeL = new JLabel("\u00B7" + "Slices to Store" + "\u00B7"); 
    287     JLabel forL = new JLabel("Forward"); 
    288     JLabel backL = new JLabel("Backward"); 
    289202    JLabel zL = new JLabel("Z:"); 
    290203    JLabel tL = new JLabel("T:"); 
     
    298211    JPanel typePanel = new JPanel(); 
    299212    typePanel.add(typeL); 
    300     typePanel.setBackground(Color.darkGray); 
    301     typeL.setForeground(Color.lightGray); 
     213    typePanel.setBackground(Color.DARK_GRAY); 
     214    typeL.setForeground(Color.LIGHT_GRAY); 
    302215    JPanel sizePanel = new JPanel(); 
    303216    sizePanel.add(sizeL); 
    304     sizePanel.setBackground(Color.darkGray); 
    305     sizeL.setForeground(Color.lightGray); 
     217    sizePanel.setBackground(Color.DARK_GRAY); 
     218    sizeL.setForeground(Color.LIGHT_GRAY); 
    306219    JPanel priorPanel = new JPanel(); 
    307220    priorPanel.add(priorL); 
    308     priorPanel.setBackground(Color.darkGray); 
    309     priorL.setForeground(Color.lightGray); 
     221    priorPanel.setBackground(Color.DARK_GRAY); 
     222    priorL.setForeground(Color.LIGHT_GRAY); 
    310223    JPanel genPanel = new JPanel(); 
    311224    genPanel.add(genL); 
    312     genPanel.setBackground(Color.darkGray); 
    313     genL.setForeground(Color.lightGray); 
    314  
    315     zCheck = new JCheckBox("Z"); 
    316     tCheck = new JCheckBox("T"); 
    317     tCheck.setSelected(true); 
    318     cCheck = new JCheckBox("C"); 
    319     JPanel checkPanel = new JPanel(new GridLayout(1, 3)); 
    320     checkPanel.add(zCheck); 
    321     checkPanel.add(tCheck); 
    322     checkPanel.add(cCheck); 
    323     zCheck.addItemListener(this); 
    324     tCheck.addItemListener(this); 
    325     cCheck.addItemListener(this); 
     225    genPanel.setBackground(Color.DARK_GRAY); 
     226    genL.setForeground(Color.LIGHT_GRAY); 
    326227 
    327228    cacheToggle = new JCheckBox("Cache Images (on/off)"); 
     
    329230    cacheToggle.addItemListener(this); 
    330231 
    331     String[] modes = {"Crosshair", "Rectangle", "Cross/Rect"}; 
     232    String[] modes = {"Crosshair", "Rectangle"}; 
    332233    modeBox = new JComboBox(modes); 
    333234    String[] strats = {"Forward", "Surround"}; 
     
    345246    lowBox.addActionListener(this); 
    346247 
    347     SpinnerNumberModel zFMod = new SpinnerNumberModel(0, 0, 9999, 1); 
    348     zFSpin = new JSpinner(zFMod); 
    349     SpinnerNumberModel zBMod = new SpinnerNumberModel(0, 0, 9999, 1); 
    350     zBSpin = new JSpinner(zBMod); 
    351     SpinnerNumberModel tFMod = new SpinnerNumberModel(DEFAULT, 0, 9999, 1); 
    352     tFSpin = new JSpinner(tFMod); 
    353     SpinnerNumberModel tBMod = new SpinnerNumberModel(0, 0, 9999, 1); 
    354     tBSpin = new JSpinner(tBMod); 
    355     SpinnerNumberModel cFMod = new SpinnerNumberModel(0, 0, 9999, 1); 
    356     cFSpin = new JSpinner(cFMod); 
    357     SpinnerNumberModel cBMod = new SpinnerNumberModel(0, 0, 9999, 1); 
    358     cBSpin = new JSpinner(cBMod); 
    359     zFSpin.addChangeListener(this); 
    360     zBSpin.addChangeListener(this); 
    361     tFSpin.addChangeListener(this); 
    362     tBSpin.addChangeListener(this); 
    363     cFSpin.addChangeListener(this); 
    364     cBSpin.addChangeListener(this); 
    365  
    366     resetBtn = new JButton("Reset CacheManager to Default"); 
     248    SpinnerNumberModel zMod = new SpinnerNumberModel(0, 0, 9999, 1); 
     249    zSpin = new JSpinner(zMod); 
     250    SpinnerNumberModel tMod = new SpinnerNumberModel(DEFAULT, 0, 9999, 1); 
     251    tSpin = new JSpinner(tMod); 
     252    SpinnerNumberModel cMod = new SpinnerNumberModel(0, 0, 9999, 1); 
     253    cSpin = new JSpinner(cMod); 
     254    zSpin.addChangeListener(this); 
     255    tSpin.addChangeListener(this); 
     256    cSpin.addChangeListener(this); 
     257 
     258    resetBtn = new JButton("Reset cache to default"); 
    367259    resetBtn.addActionListener(this); 
    368260 
     
    377269    cachePane.add(typePanel, cc3.xyw(1, 1, 7)); 
    378270    cachePane.add(axesL, cc3.xyw(2, 2, 3)); 
    379     cachePane.add(checkPanel, cc3.xy(6, 2)); 
    380271    cachePane.add(modeL, cc3.xyw(2, 3, 3)); 
    381272    cachePane.add(modeBox, cc3.xy(6, 3)); 
     
    383274    cachePane.add(stratBox, cc3.xy(6, 4)); 
    384275    cachePane.add(sizePanel, cc3.xyw(1, 6, 7)); 
    385     cachePane.add(forL, cc3.xy(4, 7)); 
    386     cachePane.add(backL, cc3.xy(6, 7)); 
    387276    cachePane.add(zL, cc3.xy(2, 8)); 
    388     cachePane.add(zFSpin, cc3.xy(4, 8)); 
    389     cachePane.add(zBSpin, cc3.xy(6, 8)); 
     277    cachePane.add(zSpin, cc3.xy(4, 8)); 
    390278    cachePane.add(tL, cc3.xy(2, 9)); 
    391     cachePane.add(tFSpin, cc3.xy(4, 9)); 
    392     cachePane.add(tBSpin, cc3.xy(6, 9)); 
     279    cachePane.add(tSpin, cc3.xy(4, 9)); 
    393280    cachePane.add(cL, cc3.xy(2, 10)); 
    394     cachePane.add(cFSpin, cc3.xy(4, 10)); 
    395     cachePane.add(cBSpin, cc3.xy(6, 10)); 
     281    cachePane.add(cSpin, cc3.xy(4, 10)); 
    396282    cachePane.add(priorPanel, cc3.xyw(1, 12, 7)); 
    397283    cachePane.add(topL, cc3.xyw(2, 14, 3)); 
     
    418304    mergeCheck.addItemListener(this); 
    419305 
    420     FormLayout inputLayout = new FormLayout( 
    421       TAB + ",pref:grow," + TAB, "pref"); 
     306    FormLayout inputLayout = new FormLayout(TAB + ",pref:grow," + TAB, "pref"); 
    422307    inputPane.setLayout(inputLayout); 
    423308    CellConstraints cci = new CellConstraints(); 
     
    427312    //configure/layout content pane 
    428313 
    429     JPanel viewPanel = new JPanel(); 
    430  
    431     FormLayout lastLayout = new FormLayout( 
    432       "pref:grow", 
    433       "pref,pref,pref"); 
    434     viewPanel.setLayout(lastLayout); 
     314    FormLayout lastLayout = new FormLayout("pref:grow", "pref,pref,pref"); 
     315    JPanel viewPanel = new JPanel(lastLayout); 
     316 
    435317    CellConstraints ccs = new CellConstraints(); 
    436318 
     
    443325    oldLow = lowBox.getSelectedIndex(); 
    444326 
    445     JScrollPane jsp = new JScrollPane((Component)viewPanel); 
     327    JScrollPane jsp = new JScrollPane((Component) viewPanel); 
    446328    Dimension viewSize = viewPanel.getPreferredSize(); 
    447329    jsp.setPreferredSize(new Dimension(viewSize.width + 20, 600)); 
     
    458340  } 
    459341 
    460   private int getBoxIndex(JComboBox jcb) { 
    461     for (int i = 0;i<blockBoxes.length;i++) { 
    462       if (jcb == blockBoxes[i]) return i; 
    463     } 
    464     return -1; 
    465   } 
    466  
    467342  public static Color getColor(int i) { 
    468343    switch (i) { 
    469344      case 0: 
    470         return Color.blue; 
     345        return Color.BLUE; 
    471346      case 1: 
    472         return Color.green; 
     347        return Color.GREEN; 
    473348      case 2: 
    474         return Color.red; 
     349        return Color.RED; 
    475350      case 3: 
    476         return Color.magenta; 
     351        return Color.MAGENTA; 
    477352      case 4: 
    478         return Color.orange; 
     353        return Color.ORANGE; 
    479354      default: 
    480         int next = i; 
    481         Color tempColor = getColor(i%5); 
    482         while (next > 4) { 
    483           next -= 5; 
    484           tempColor = tempColor.darker(); 
     355        Color tempColor = getColor(i % 5); 
     356        for (int j=0; j<i/5; j++) { 
     357          tempColor.darker(); 
    485358        } 
    486359        return tempColor; 
     
    488361  } 
    489362 
    490   /** 
    491   * Converts a combo box index into a CacheManager constant 
    492   * signifying an axis. 
    493   */ 
    494   private int getConv(int index) { 
    495     switch (index) { 
    496       case 0: 
    497         return CacheManager.Z_AXIS; 
    498       case 1: 
    499         return CacheManager.T_AXIS; 
    500       case 2: 
    501         return CacheManager.C_AXIS; 
    502     } 
    503     return -1; 
    504   } 
    505  
    506363  /** Set up the combo box to reflect appropriate axis. */ 
    507364  private void setBox(JComboBox thisBox, int index) { 
    508     switch (order.charAt(index)) { 
    509       case 'Z': 
    510         thisBox.setSelectedIndex(0); 
    511         break; 
    512       case 'T': 
    513         thisBox.setSelectedIndex(1); 
    514         break; 
    515       case 'C': 
    516         thisBox.setSelectedIndex(2); 
    517         break; 
    518     } 
     365    thisBox.setSelectedIndex(convertChar(order.charAt(index))); 
    519366  } 
    520367 
     
    527374      case 2: 
    528375        return 'C'; 
    529       default: 
    530         return 'Q'; 
    531     } 
     376    } 
     377    return 'Q'; 
    532378  } 
    533379 
    534380  private int convertChar(char c) { 
    535     switch (c) { 
    536       case 'Z': 
    537         return 0; 
    538       case 'T': 
    539         return 1; 
    540       case 'C': 
    541         return 2; 
    542       default: 
    543         return 'Q'; 
    544     } 
     381    return c == 'Z' ? 0 : c == 'T' ? 1 : c == 'C' ? 2 : -1; 
    545382  } 
    546383 
    547384  private int getOrderSize(int i) { 
    548     int thisSize = 1; 
    549     switch (order.charAt(i)) { 
    550       case 'Z': 
    551         thisSize = sizeZ; 
    552         if (fs != null) thisSize /= getBlockCount(0); 
    553         break; 
    554       case 'T': 
    555         thisSize = sizeT; 
    556         if (fs != null) thisSize /= getBlockCount(1); 
    557         break; 
    558       case 'C': 
    559         thisSize = sizeC; 
    560         if (fs != null) thisSize /= getBlockCount(2); 
    561         break; 
    562     } 
    563     return thisSize; 
    564   } 
    565  
    566   private int getBlockCount(int index) { 
    567     int total = 0; 
    568     int[] blockSizes = fp.getCount(); 
    569     for (int i = 0;i<blockBoxes.length;i++) { 
    570       if (blockBoxes[i].getSelectedIndex() == index) { 
    571         total += blockSizes[i]; 
    572       } 
    573     } 
    574     if (total == 0) total = 1; 
    575     return total; 
     385    char c = order.charAt(i); 
     386    return c == 'Z' ? sizeZ : c == 'T' ? sizeT : c == 'C' ? sizeC : 1; 
     387  } 
     388 
     389  private int convert(int ndx) { 
     390    return order.indexOf(convertInt(ndx)); 
    576391  } 
    577392 
     
    584399      case 2: 
    585400        return AxisGuesser.C_AXIS; 
    586       default: 
    587         return -55555; 
    588     } 
    589   } 
    590  
    591   /** Enables/Disables CacheManager options in option window. */ 
     401    } 
     402    return -55555; 
     403  } 
     404 
     405  /** Enables/Disables cache options in option window. */ 
    592406  private void enableCache(boolean enable) { 
    593     zCheck.setEnabled(enable); 
    594     tCheck.setEnabled(enable); 
    595     cCheck.setEnabled(enable); 
    596  
    597407    modeBox.setEnabled(enable); 
    598408    stratBox.setEnabled(enable); 
     
    601411    lowBox.setEnabled(enable); 
    602412 
    603     zBSpin.setEnabled(enable); 
    604     zFSpin.setEnabled(enable); 
    605     tBSpin.setEnabled(enable); 
    606     tFSpin.setEnabled(enable); 
    607     cBSpin.setEnabled(enable); 
    608     cFSpin.setEnabled(enable); 
     413    zSpin.setEnabled(enable); 
     414    tSpin.setEnabled(enable); 
     415    cSpin.setEnabled(enable); 
    609416 
    610417    resetBtn.setEnabled(enable); 
     
    614421 
    615422  public void actionPerformed(ActionEvent e) { 
    616     if (update) { 
    617       Object source = e.getSource(); 
    618  
    619       if (source == modeBox) { 
    620         if (modeBox.getSelectedIndex() == 0) 
    621           manager.setMode(CacheManager.CROSS_MODE); 
    622         else if (modeBox.getSelectedIndex() == 1) 
    623           manager.setMode(CacheManager.RECT_MODE); 
    624         else //modeBox.getSelectedIndex() == 2 
    625           manager.setMode(CacheManager.CROSS_MODE | CacheManager.RECT_MODE); 
    626       } 
    627       else if (source == stratBox) { 
    628         if (stratBox.getSelectedIndex() == 0) 
    629           manager.setStrategy(CacheManager.FORWARD_FIRST); 
    630         else //stratBox.getSelectedIndex() == 1 
    631           manager.setStrategy(CacheManager.SURROUND_FIRST); 
    632       } 
    633       else if (source == resetBtn) { 
     423    if (!update) return; 
     424    Object source = e.getSource(); 
     425 
     426    if (source == modeBox) { 
     427      // change cache strategy 
     428 
     429      int[] lengths = cw.db.cache.getStrategy().getLengths(); 
     430      int ndx = modeBox.getSelectedIndex(); 
     431      try { 
     432        CacheStrategy strategy = ndx == 0 ? 
     433          (CacheStrategy) new CrosshairStrategy(lengths) : 
     434          (CacheStrategy) new RectangleStrategy(lengths); 
     435        cw.db.cache.setStrategy(strategy); 
     436      } 
     437      catch (CacheException exc) { 
     438        LociDataBrowser.dumpException(exc); 
     439      } 
     440 
     441      // set ranges, priorities, order 
     442      updatePriorities(); 
     443      updateRanges(); 
     444      updateOrder(); 
     445      updateCacheIndicators(); 
     446    } 
     447    else if (source == stratBox) { 
     448      // change order in which axes are cached 
     449      updateOrder(); 
     450    } 
     451    else if (source == resetBtn) { 
     452      // reset cache parameters to default values 
     453      update = false; 
     454      modeBox.setSelectedIndex(0); 
     455      stratBox.setSelectedIndex(0); 
     456 
     457      int[] lengths = cw.db.cache.getStrategy().getLengths(); 
     458      try { 
     459        cw.db.cache.setStrategy(new CrosshairStrategy(lengths)); 
     460      } 
     461      catch (CacheException exc) { 
     462        LociDataBrowser.dumpException(exc); 
     463      } 
     464 
     465      int[] priorities = new int[] {ICacheStrategy.NORMAL_PRIORITY, 
     466        ICacheStrategy.MAX_PRIORITY, ICacheStrategy.MIN_PRIORITY}; 
     467      int[] ranges = new int[] {0, 100, 0}; 
     468 
     469      for (int i=0; i<lengths.length; i++) { 
     470        cw.db.cache.getStrategy().setOrder(ICacheStrategy.FORWARD_ORDER, i); 
     471        cw.db.cache.getStrategy().setPriority(priorities[i], convert(i)); 
     472        cw.db.cache.getStrategy().setRange(ranges[i], convert(i)); 
     473      } 
     474 
     475      topBox.setSelectedIndex(1); 
     476      midBox.setSelectedIndex(0); 
     477      lowBox.setSelectedIndex(2); 
     478 
     479      Integer zeroI = new Integer(0); 
     480      Integer defaultI = new Integer(DEFAULT); 
     481      zSpin.setValue(zeroI); 
     482      tSpin.setValue(defaultI); 
     483      cSpin.setValue(zeroI); 
     484 
     485      oldTop = topBox.getSelectedIndex(); 
     486      oldMid = midBox.getSelectedIndex(); 
     487      oldLow = lowBox.getSelectedIndex(); 
     488      update = true; 
     489    } 
     490    else if (source == topBox) { 
     491      // update priorities, based on change to "top priority" 
     492      int newTop = topBox.getSelectedIndex(); 
     493      if (newTop == oldTop) return; 
     494      if (newTop == oldMid) { 
    634495        update = false; 
    635         zCheck.setSelected(false); 
    636         tCheck.setSelected(true); 
    637         cCheck.setSelected(false); 
    638         manager.setAxis(CacheManager.T_AXIS); 
    639         modeBox.setSelectedIndex(0); 
    640         manager.setMode(CacheManager.CROSS_MODE); 
    641         stratBox.setSelectedIndex(0); 
    642         manager.setStrategy(CacheManager.FORWARD_FIRST); 
    643         topBox.setSelectedIndex(1); 
    644         midBox.setSelectedIndex(0); 
    645         lowBox.setSelectedIndex(2); 
    646         manager.setPriority(CacheManager.T_AXIS, CacheManager.Z_AXIS, 
    647           CacheManager.C_AXIS); 
    648  
    649         Integer zeroI = new Integer(0); 
    650         Integer defaultI = new Integer(DEFAULT); 
    651         zFSpin.setValue(zeroI); 
    652         zBSpin.setValue(zeroI); 
    653         tFSpin.setValue(defaultI); 
    654         tBSpin.setValue(zeroI); 
    655         cFSpin.setValue(zeroI); 
    656         cBSpin.setValue(zeroI); 
    657         manager.setSize(0, 0, 0, DEFAULT, 0, 0); 
    658  
    659         oldTop = topBox.getSelectedIndex(); 
    660         oldMid = midBox.getSelectedIndex(); 
    661         oldLow = lowBox.getSelectedIndex(); 
     496        midBox.setSelectedIndex(oldTop); 
     497        oldMid = oldTop; 
    662498        update = true; 
    663499      } 
    664       else if (source == topBox) { 
    665         int newTop = topBox.getSelectedIndex(); 
    666         if (newTop == oldTop) return; 
    667         if (newTop == oldMid) { 
    668           update = false; 
    669           midBox.setSelectedIndex(oldTop); 
    670           oldMid = oldTop; 
    671           update = true; 
    672         } 
    673         if (newTop == oldLow) { 
    674           update = false; 
    675           lowBox.setSelectedIndex(oldTop); 
    676           oldLow = oldTop; 
    677           update = true; 
    678         } 
    679  
    680         oldTop = newTop; 
    681         manager.setPriority(getConv(topBox.getSelectedIndex()), 
    682          getConv(midBox.getSelectedIndex()), 
    683          getConv(lowBox.getSelectedIndex())); 
    684       } 
    685       else if (source == midBox) { 
    686         int newMid = midBox.getSelectedIndex(); 
    687         if (newMid == oldMid) return; 
    688         if (newMid == oldTop) { 
    689           update = false; 
    690           topBox.setSelectedIndex(oldMid); 
    691           oldTop = oldMid; 
    692           update = true; 
    693         } 
    694         if (newMid == oldLow) { 
    695           update = false; 
    696           lowBox.setSelectedIndex(oldMid); 
    697           oldLow = oldMid; 
    698           update = true; 
    699         } 
    700  
    701         oldMid = newMid; 
    702         manager.setPriority(getConv(topBox.getSelectedIndex()), 
    703          getConv(midBox.getSelectedIndex()), 
    704          getConv(lowBox.getSelectedIndex())); 
    705       } 
    706       else if (source == lowBox) { 
    707         int newLow = lowBox.getSelectedIndex(); 
    708         if (newLow == oldLow) return; 
    709         if (newLow == oldTop) { 
    710           update = false; 
    711           topBox.setSelectedIndex(oldLow); 
    712           oldTop = oldLow; 
    713           update = true; 
    714         } 
    715         if (newLow == oldMid) { 
    716           update = false; 
    717           midBox.setSelectedIndex(oldLow); 
    718           oldMid = oldLow; 
    719           update = true; 
    720         } 
    721  
    722         oldLow = newLow; 
    723         manager.setPriority(getConv(topBox.getSelectedIndex()), 
    724          getConv(midBox.getSelectedIndex()), 
    725          getConv(lowBox.getSelectedIndex())); 
    726       } 
    727       else if (source == zGroup) { 
    728         char oldChar = order.charAt(0); 
    729         int sel = zGroup.getSelectedIndex(); 
    730         char zChar = convertInt(sel); 
    731  
    732         sel = tGroup.getSelectedIndex(); 
    733         char tChar = convertInt(sel); 
    734         if (tChar == zChar) tChar = oldChar; 
    735  
    736         sel = cGroup.getSelectedIndex(); 
    737         char cChar = convertInt(sel); 
    738         if (cChar == zChar) cChar = oldChar; 
    739  
    740         order = String.valueOf(zChar) + String.valueOf(tChar) 
    741           + String.valueOf(cChar); 
    742         try { 
    743           cw.db.reader.setId(id); 
    744           cw.db.reader.setSeries(cw.db.series); 
    745           cw.db.reader.swapDimensions("XY" + order); 
    746           sizeZ = cw.db.reader.getSizeZ(); 
    747           sizeT = cw.db.reader.getSizeT(); 
    748           sizeC = cw.db.reader.getSizeC(); 
    749         } 
    750         catch (Exception exc) { 
    751           exc.printStackTrace(); 
    752           LociDataBrowser.dumpException(exc); 
    753         } 
     500      if (newTop == oldLow) { 
    754501        update = false; 
    755         setBox(zGroup, 0); 
    756         setBox(tGroup, 1); 
    757         setBox(cGroup, 2); 
     502        lowBox.setSelectedIndex(oldTop); 
     503        oldLow = oldTop; 
    758504        update = true; 
    759         cw.db.setDimensions(); 
    760         if (cw.db.virtual) cw.db.manager.dimChange(); 
    761         cw.updateControls(); 
    762       } 
    763       else if (source == tGroup) { 
    764         char oldChar = order.charAt(1); 
    765         int sel = tGroup.getSelectedIndex(); 
    766         char tChar = convertInt(sel); 
    767  
    768         sel = zGroup.getSelectedIndex(); 
    769         char zChar = convertInt(sel); 
    770         if (zChar == tChar) zChar = oldChar; 
    771  
    772         sel = cGroup.getSelectedIndex(); 
    773         char cChar = convertInt(sel); 
    774         if (cChar == tChar) cChar = oldChar; 
    775  
    776         order = String.valueOf(zChar) + String.valueOf(tChar) 
    777           + String.valueOf(cChar); 
    778         try { 
    779           cw.db.reader.setId(id); 
    780           cw.db.reader.setSeries(cw.db.series); 
    781           cw.db.reader.swapDimensions("XY" + order); 
    782           sizeZ = cw.db.reader.getSizeZ(); 
    783           sizeT = cw.db.reader.getSizeT(); 
    784           sizeC = cw.db.reader.getSizeC(); 
    785         } 
    786         catch (Exception exc) { 
    787           exc.printStackTrace(); 
    788           LociDataBrowser.dumpException(exc); 
    789         } 
     505      } 
     506 
     507      oldTop = newTop; 
     508      updatePriorities(); 
     509    } 
     510    else if (source == midBox) { 
     511      // update priorities, based on change to "medium priority" 
     512      int newMid = midBox.getSelectedIndex(); 
     513      if (newMid == oldMid) return; 
     514      if (newMid == oldTop) { 
    790515        update = false; 
    791         setBox(zGroup, 0); 
    792         setBox(tGroup, 1); 
    793         setBox(cGroup, 2); 
     516        topBox.setSelectedIndex(oldMid); 
     517        oldTop = oldMid; 
    794518        update = true; 
    795         cw.db.setDimensions(); 
    796         if (cw.db.virtual) cw.db.manager.dimChange(); 
    797         cw.updateControls(); 
    798       } 
    799       else if (source == cGroup) { 
    800         char oldChar = order.charAt(2); 
    801         int sel = cGroup.getSelectedIndex(); 
    802         char cChar = convertInt(sel); 
    803  
    804         sel = zGroup.getSelectedIndex(); 
    805         char zChar = convertInt(sel); 
    806         if (zChar == cChar) zChar = oldChar; 
    807  
    808         sel = tGroup.getSelectedIndex(); 
    809         char tChar = convertInt(sel); 
    810         if (tChar == cChar) tChar = oldChar; 
    811  
    812         order = String.valueOf(zChar) + String.valueOf(tChar) 
    813           + String.valueOf(cChar); 
    814         try { 
    815           cw.db.reader.setId(id); 
    816           cw.db.reader.setSeries(cw.db.series); 
    817           cw.db.reader.swapDimensions("XY" + order); 
    818           sizeZ = cw.db.reader.getSizeZ(); 
    819           sizeT = cw.db.reader.getSizeT(); 
    820           sizeC = cw.db.reader.getSizeC(); 
    821         } 
    822         catch (Exception exc) { 
    823           exc.printStackTrace(); 
    824           LociDataBrowser.dumpException(exc); 
    825         } 
     519      } 
     520      if (newMid == oldLow) { 
    826521        update = false; 
    827         setBox(zGroup, 0); 
    828         setBox(tGroup, 1); 
    829         setBox(cGroup, 2); 
     522        lowBox.setSelectedIndex(oldMid); 
     523        oldLow = oldMid; 
    830524        update = true; 
    831         cw.db.setDimensions(); 
    832         if (cw.db.virtual) cw.db.manager.dimChange(); 
    833         cw.updateControls(); 
    834       } 
    835       else if (getBoxIndex((JComboBox)source) >= 0) { 
    836         cw.update = false; 
    837         int index = getBoxIndex((JComboBox)source); 
    838         axes[index] = getAxis(blockBoxes[index].getSelectedIndex()); 
    839         try { 
    840           fs.setAxisTypes(axes); 
    841         } 
    842         catch (Exception exc) { 
    843           exc.printStackTrace(); 
    844           LociDataBrowser.dumpException(exc); 
    845         } 
    846         cw.db.setDimensions(); 
    847         if (cw.db.virtual) cw.db.manager.dimChange(); 
    848         cw.updateControls(); 
    849         cw.update = true; 
    850       } 
    851     } 
     525      } 
     526 
     527      oldMid = newMid; 
     528      updatePriorities(); 
     529    } 
     530    else if (source == lowBox) { 
     531      // update priorities, based on change to "low priority" 
     532      int newLow = lowBox.getSelectedIndex(); 
     533      if (newLow == oldLow) return; 
     534      if (newLow == oldTop) { 
     535        update = false; 
     536        topBox.setSelectedIndex(oldLow); 
     537        oldTop = oldLow; 
     538        update = true; 
     539      } 
     540      if (newLow == oldMid) { 
     541        update = false; 
     542        midBox.setSelectedIndex(oldLow); 
     543        oldMid = oldLow; 
     544        update = true; 
     545      } 
     546 
     547      oldLow = newLow; 
     548      updatePriorities(); 
     549    } 
     550    else if (source == zGroup) { 
     551      char oldChar = order.charAt(0); 
     552      int sel = zGroup.getSelectedIndex(); 
     553      char zChar = convertInt(sel); 
     554 
     555      sel = tGroup.getSelectedIndex(); 
     556      char tChar = convertInt(sel); 
     557      if (tChar == zChar) tChar = oldChar; 
     558 
     559      sel = cGroup.getSelectedIndex(); 
     560      char cChar = convertInt(sel); 
     561      if (cChar == zChar) cChar = oldChar; 
     562 
     563      updateGroups(zChar, tChar, cChar); 
     564    } 
     565    else if (source == tGroup) { 
     566      char oldChar = order.charAt(1); 
     567      int sel = tGroup.getSelectedIndex(); 
     568      char tChar = convertInt(sel); 
     569 
     570      sel = zGroup.getSelectedIndex(); 
     571      char zChar = convertInt(sel); 
     572      if (zChar == tChar) zChar = oldChar; 
     573 
     574      sel = cGroup.getSelectedIndex(); 
     575      char cChar = convertInt(sel); 
     576      if (cChar == tChar) cChar = oldChar; 
     577 
     578      updateGroups(zChar, tChar, cChar); 
     579    } 
     580    else if (source == cGroup) { 
     581      char oldChar = order.charAt(2); 
     582      int sel = cGroup.getSelectedIndex(); 
     583      char cChar = convertInt(sel); 
     584 
     585      sel = zGroup.getSelectedIndex(); 
     586      char zChar = convertInt(sel); 
     587      if (zChar == cChar) zChar = oldChar; 
     588 
     589      sel = tGroup.getSelectedIndex(); 
     590      char tChar = convertInt(sel); 
     591      if (tChar == cChar) tChar = oldChar; 
     592      updateGroups(zChar, tChar, cChar); 
     593    } 
     594    updateCacheIndicators(); 
    852595  } 
    853596 
    854597  public void itemStateChanged(ItemEvent e) { 
    855     if (update) { 
    856       Object source = e.getItemSelectable(); 
    857  
    858       //if this is the only selected checkbox, leave it selected 
    859       if (source == zCheck && e.getStateChange() == ItemEvent.DESELECTED && 
    860         !tCheck.isSelected() && !cCheck.isSelected()) 
    861       { 
    862         update = false; 
    863         zCheck.setSelected(true); 
    864         update = true; 
    865         return; 
    866       } 
    867       else if (source == tCheck && e.getStateChange() == ItemEvent.DESELECTED && 
    868         !zCheck.isSelected() && !cCheck.isSelected()) 
    869       { 
    870         update = false; 
    871         tCheck.setSelected(true); 
    872         update = true; 
    873         return; 
    874       } 
    875       else if (source == cCheck && e.getStateChange() == ItemEvent.DESELECTED && 
    876         !tCheck.isSelected() && !zCheck.isSelected()) 
    877       { 
    878         update = false; 
    879         cCheck.setSelected(true); 
    880         update = true; 
    881         return; 
    882       } 
    883       else if (source == cacheToggle) { 
    884         if (e.getStateChange() == ItemEvent.DESELECTED) { 
    885           cw.db.toggleCache(false); 
    886         } 
    887         else { 
    888           cw.db.toggleCache(true); 
    889         } 
    890       } 
    891       else if (source == mergeCheck) { 
    892         cw.db.toggleMerge(); 
    893       } 
    894  
    895       int zState = 0x00, tState = 0x00, cState = 0x00; 
    896  
    897       if (zCheck.isSelected()) zState = CacheManager.Z_AXIS; 
    898       if (tCheck.isSelected()) tState = CacheManager.T_AXIS; 
    899       if (cCheck.isSelected()) cState = CacheManager.C_AXIS; 
    900  
    901       int finalState = (zState | tState | cState); 
    902       if (manager != null) manager.setAxis(finalState); 
    903     } 
     598    if (!update) return; 
     599    Object source = e.getItemSelectable(); 
     600 
     601    if (source == cacheToggle) { 
     602      cw.db.toggleCache(e.getStateChange() != ItemEvent.DESELECTED); 
     603    } 
     604    else if (source == mergeCheck) { 
     605      cw.db.toggleMerge(); 
     606    } 
     607    updateCacheIndicators(); 
    904608  } 
    905609 
     
    907611 
    908612  public void stateChanged(ChangeEvent e) { 
    909     if (update) { 
    910       int zF = ((Integer) zFSpin.getValue()).intValue(); 
    911       int zB = ((Integer) zBSpin.getValue()).intValue(); 
    912       int tF = ((Integer) tFSpin.getValue()).intValue(); 
    913       int tB = ((Integer) tBSpin.getValue()).intValue(); 
    914       int cF = ((Integer) cFSpin.getValue()).intValue(); 
    915       int cB = ((Integer) cBSpin.getValue()).intValue(); 
    916       manager.setSize(zB, zF, tB, tF, cB, cF); 
    917     } 
    918   } 
     613    if (!update) return; 
     614    updateRanges(); 
     615    updateCacheIndicators(); 
     616  } 
     617 
     618  // -- Helper methods -- 
     619 
     620  private void updateRanges() { 
     621    int z = ((Integer) zSpin.getValue()).intValue(); 
     622    int t = ((Integer) tSpin.getValue()).intValue(); 
     623    int c = ((Integer) cSpin.getValue()).intValue(); 
     624 
     625    int[] ranges = new int[] {z, t, c}; 
     626 
     627    ICacheStrategy strategy = cw.db.cache.getStrategy(); 
     628    for (int i=0; i<strategy.getLengths().length; i++) { 
     629      strategy.setRange(ranges[i], convert(i)); 
     630    } 
     631  } 
     632 
     633  private void updatePriorities() { 
     634    cw.db.cache.getStrategy().setPriority(ICacheStrategy.MAX_PRIORITY, 
     635      convert(topBox.getSelectedIndex())); 
     636    cw.db.cache.getStrategy().setPriority(ICacheStrategy.NORMAL_PRIORITY, 
     637      convert(midBox.getSelectedIndex())); 
     638    cw.db.cache.getStrategy().setPriority(ICacheStrategy.MIN_PRIORITY, 
     639      convert(lowBox.getSelectedIndex())); 
     640  } 
     641 
     642  private void updateOrder() { 
     643    int cacheOrder = stratBox.getSelectedIndex() == 0 ? 
     644      ICacheStrategy.FORWARD_ORDER : ICacheStrategy.CENTERED_ORDER; 
     645    for (int i=0; i<cw.db.cache.getStrategy().getLengths().length; i++) { 
     646      cw.db.cache.getStrategy().setOrder(cacheOrder, i); 
     647    } 
     648  } 
     649 
     650  private void updateGroups(char zChar, char tChar, char cChar) { 
     651    order = new String(new char[] {zChar, tChar, cChar}); 
     652    try { 
     653      cw.db.reader.setId(id); 
     654      cw.db.reader.setSeries(cw.db.series); 
     655      cw.db.reader.swapDimensions("XY" + order); 
     656      sizeZ = cw.db.reader.getSizeZ(); 
     657      sizeT = cw.db.reader.getSizeT(); 
     658      sizeC = cw.db.reader.getSizeC(); 
     659    } 
     660    catch (Exception exc) { 
     661      LociDataBrowser.dumpException(exc); 
     662    } 
     663    update = false; 
     664    setBox(zGroup, 0); 
     665    setBox(tGroup, 1); 
     666    setBox(cGroup, 2); 
     667    update = true; 
     668    cw.db.setDimensions(); 
     669    cw.updateControls(); 
     670  } 
     671 
     672  private void updateCacheIndicators() { 
     673    if (cw.zIndicator != null) { 
     674      cw.zIndicator.setIndicator(cw.db.cache, sizeZ, order.indexOf("Z")); 
     675    } 
     676    if (cw.tIndicator != null) { 
     677      cw.tIndicator.setIndicator(cw.db.cache, sizeT, order.indexOf("T")); 
     678    } 
     679  } 
     680 
    919681} 
  • trunk/loci/plugins/plugins.config

    r3305 r3362  
    2323 
    2424#Plugins>LOCI, "Bio-Formats Master Importer", loci.plugins.LociImporter("") 
     25Plugins>LOCI, "Stack Colorizer", loci.plugins.Colorizer("") 
    2526Plugins>LOCI, "Stack Slicer", loci.plugins.Slicer("") 
    2627Plugins>LOCI, "4D Data Browser", loci.plugins.LociImporter("location=[Local machine] group=true view=[4D Data Browser]") 
Note: See TracChangeset for help on using the changeset viewer.