Changeset 6654


Ignore:
Timestamp:
07/06/10 19:02:34 (9 years ago)
Author:
curtis
Message:

Progress on Bio-Formats Importer:

  • Readd support for Ext.openImage and Ext.openSubImage macro functions.
  • Add memory warning if imported data will be dangerously large.
  • Reorganize ImagePlusTools code to be more consistent.
  • Clean up warnings and whitespace.
Location:
trunk/components/loci-plugins
Files:
1 added
20 edited
1 moved

Legend:

Unmodified
Added
Removed
  • trunk/components/loci-plugins/src/loci/plugins/Slicer.java

    r6588 r6654  
    3838 
    3939import loci.formats.FormatTools; 
    40 import loci.plugins.util.ImagePlusTools; 
    4140import loci.plugins.util.LibraryChecker; 
    4241 
     
    6362  /** Current image stack. */ 
    6463  private ImagePlus imp; 
    65    
     64 
    6665  // -- Slicer methods -- 
    67    
     66 
    6867  public ImagePlus[] reslice(ImagePlus imp, 
    6968    boolean sliceC, boolean sliceZ, boolean sliceT, 
     
    132131      } 
    133132      if (imp.isComposite() && !sliceC) { 
    134         p = ImagePlusTools.reorder(p, stackOrder, "XYCZT"); 
     133        p = reorder(p, stackOrder, "XYCZT"); 
    135134        int mode = ((CompositeImage) imp).getMode(); 
    136135        newImps[i] = new CompositeImage(p, mode); 
     
    139138    } 
    140139    return newImps; 
     140  } 
     141 
     142  /** Reorder the given ImagePlus's stack. */ 
     143  public static ImagePlus reorder(ImagePlus imp, String origOrder, 
     144    String newOrder) 
     145  { 
     146    ImageStack s = imp.getStack(); 
     147    ImageStack newStack = new ImageStack(s.getWidth(), s.getHeight()); 
     148 
     149    int z = imp.getNSlices(); 
     150    int c = imp.getNChannels(); 
     151    int t = imp.getNFrames(); 
     152 
     153    int stackSize = s.getSize(); 
     154    for (int i=0; i<stackSize; i++) { 
     155      int ndx = FormatTools.getReorderedIndex( 
     156        origOrder, newOrder, z, c, t, stackSize, i); 
     157      newStack.addSlice(s.getSliceLabel(ndx + 1), s.getProcessor(ndx + 1)); 
     158    } 
     159    ImagePlus p = new ImagePlus(imp.getTitle(), newStack); 
     160    p.setDimensions(c, z, t); 
     161    p.setCalibration(imp.getCalibration()); 
     162    p.setFileInfo(imp.getOriginalFileInfo()); 
     163    return p; 
    141164  } 
    142165 
  • trunk/components/loci-plugins/src/loci/plugins/config/ConfigWindow.java

    r6588 r6654  
    452452  } 
    453453 
    454   public static void addEntry(final Comparable c, 
     454  public static void addEntry(final Comparable<Object> c, 
    455455    final DefaultListModel listModel) 
    456456  { 
     
    478478 
    479479  private void addProp(HashMap<String, String> props, 
    480     String key, String value, HashMap versions) 
     480    String key, String value, HashMap<String, String> versions) 
    481481  { 
    482482    if (key == null) return; 
     
    487487    if (key.equals("version")) { 
    488488      // get actual value from versions hashtable 
    489       value = (String) versions.get(value); 
     489      value = versions.get(value); 
    490490    } 
    491491    if (value != null) props.put(key, value); 
  • trunk/components/loci-plugins/src/loci/plugins/config/FlexWidgets.java

    r6588 r6654  
    8989 
    9090  public void changedUpdate(DocumentEvent e) { 
    91     documentUpdate(e); 
     91    documentUpdate(); 
    9292  } 
    9393  public void removeUpdate(DocumentEvent e) { 
    94     documentUpdate(e); 
     94    documentUpdate(); 
    9595  } 
    9696  public void insertUpdate(DocumentEvent e) { 
    97     documentUpdate(e); 
     97    documentUpdate(); 
    9898  } 
    9999 
     
    110110  // -- Helper methods -- 
    111111 
    112   private void documentUpdate(DocumentEvent e) { 
     112  private void documentUpdate() { 
    113113    String code = licenseBox.getText(); 
    114114    Prefs.set(LuraWaveServiceImpl.LICENSE_PROPERTY, code); 
  • trunk/components/loci-plugins/src/loci/plugins/config/FormatEntry.java

    r6588 r6654  
    3939 * @author Curtis Rueden ctrueden at wisc.edu 
    4040 */ 
    41 public class FormatEntry implements Comparable { 
     41public class FormatEntry implements Comparable<Object> { 
    4242 
    4343  // -- Fields -- 
     
    107107    if (o == null) return false; 
    108108    if (!(o instanceof FormatEntry)) return false; 
    109     return compareTo((FormatEntry) o) == 0; 
     109    return compareTo(o) == 0; 
    110110  } 
    111111 
  • trunk/components/loci-plugins/src/loci/plugins/config/InstallWizard.java

    r6588 r6654  
    3535 
    3636import javax.swing.JFrame; 
     37import javax.swing.WindowConstants; 
    3738 
    3839/** 
     
    5556  public InstallWizard() { 
    5657    setTitle("LOCI Plugins Library Installer"); 
    57     setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); 
     58    setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); 
    5859 
    5960    /* 
  • trunk/components/loci-plugins/src/loci/plugins/config/LibraryEntry.java

    r6588 r6654  
    4040 * @author Curtis Rueden ctrueden at wisc.edu 
    4141 */ 
    42 public class LibraryEntry implements Comparable { 
     42public class LibraryEntry implements Comparable<Object> { 
    4343 
    4444  // -- Constants -- 
     
    7171  public LibraryEntry(PrintWriter log, HashMap<String, String> props) { 
    7272    this(log, 
    73       (String) props.get("name"), 
    74       (String) props.get("type"), 
    75       (String) props.get("class"), 
    76       (String) props.get("version"), 
    77       (String) props.get("url"), 
    78       (String) props.get("license"), 
    79       (String) props.get("notes")); 
     73      props.get("name"), 
     74      props.get("type"), 
     75      props.get("class"), 
     76      props.get("version"), 
     77      props.get("url"), 
     78      props.get("license"), 
     79      props.get("notes")); 
    8080  } 
    8181 
  • trunk/components/loci-plugins/src/loci/plugins/in/Calibrator.java

    r6625 r6654  
    11// 
    2 // ImagePlusTools.java 
     2// Calibrator.java 
    33// 
    44 
     
    2424*/ 
    2525 
    26 package loci.plugins.util; 
     26package loci.plugins.in; 
    2727 
    2828import ij.ImagePlus; 
    29 import ij.ImageStack; 
    3029import ij.measure.Calibration; 
    31 import ij.process.ColorProcessor; 
    32 import ij.process.ImageProcessor; 
    3330 
    34 import java.io.IOException; 
    35  
    36 import loci.formats.FormatException; 
    3731import loci.formats.FormatTools; 
    38 import loci.formats.MinMaxCalculator; 
    39 import loci.formats.meta.MetadataRetrieve; 
     32import loci.formats.meta.IMetadata; 
    4033 
    4134/** 
    42  * Utility methods for working with ImagePlus objects. 
     35 * Logic for calibrating images. 
    4336 * 
    4437 * <dl><dt><b>Source code:</b></dt> 
    45  * <dd><a href="https://skyking.microscopy.wisc.edu/trac/java/browser/trunk/components/loci-plugins/src/loci/plugins/util/ImagePlusTools.java">Trac</a>, 
    46  * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/util/ImagePlusTools.java">SVN</a></dd></dl> 
     38 * <dd><a href="https://skyking.microscopy.wisc.edu/trac/java/browser/trunk/components/loci-plugins/src/loci/plugins/in/Calibrator.java">Trac</a>, 
     39 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/in/Calibrator.java">SVN</a></dd></dl> 
    4740 */ 
    48 public final class ImagePlusTools { 
     41public class Calibrator { 
     42 
     43  // -- Fields -- 
     44 
     45  private ImportProcess process; 
    4946 
    5047  // -- Constructor -- 
    5148 
    52   private ImagePlusTools() { } 
     49  public Calibrator(ImportProcess process) { 
     50    this.process = process; 
     51  } 
    5352 
    54   // -- Utility methods -- 
     53  // -- Calibrator methods -- 
    5554 
    5655  /** Applies spatial calibrations to an image stack. */ 
    57   public static void applyCalibration(MetadataRetrieve retrieve, 
    58     ImagePlus imp, int series) 
    59   { 
     56  public void applyCalibration(ImagePlus imp) { 
     57    final IMetadata meta = process.getOMEMetadata(); 
     58    final int series = (Integer) imp.getProperty(ImagePlusReader.PROP_SERIES); 
     59 
    6060    double xcal = Double.NaN, ycal = Double.NaN; 
    6161    double zcal = Double.NaN, tcal = Double.NaN; 
    6262 
    63     Double xd = retrieve.getPixelsPhysicalSizeX(series); 
     63    Double xd = meta.getPixelsPhysicalSizeX(series); 
    6464    if (xd != null) xcal = xd.floatValue(); 
    65     Double yd = retrieve.getPixelsPhysicalSizeY(series); 
     65    Double yd = meta.getPixelsPhysicalSizeY(series); 
    6666    if (yd != null) ycal = yd.floatValue(); 
    67     Double zd = retrieve.getPixelsPhysicalSizeZ(series); 
     67    Double zd = meta.getPixelsPhysicalSizeZ(series); 
    6868    if (zd != null) zcal = zd.floatValue(); 
    69     Double td = retrieve.getPixelsTimeIncrement(series); 
     69    Double td = meta.getPixelsTimeIncrement(series); 
    7070    if (td != null) tcal = td.floatValue(); 
    7171 
     
    9494    } 
    9595 
    96     String type = retrieve.getPixelsType(series).toString(); 
     96    String type = meta.getPixelsType(series).toString(); 
    9797    int pixelType = FormatTools.pixelTypeFromString(type); 
    9898 
     
    111111  } 
    112112 
    113   /** Reorder the given ImagePlus's stack. */ 
    114   public static ImagePlus reorder(ImagePlus imp, String origOrder, 
    115     String newOrder) 
    116   { 
    117     ImageStack s = imp.getStack(); 
    118     ImageStack newStack = new ImageStack(s.getWidth(), s.getHeight()); 
    119  
    120     int z = imp.getNSlices(); 
    121     int c = imp.getNChannels(); 
    122     int t = imp.getNFrames(); 
    123  
    124     int stackSize = s.getSize(); 
    125     for (int i=0; i<stackSize; i++) { 
    126       int ndx = FormatTools.getReorderedIndex( 
    127         origOrder, newOrder, z, c, t, stackSize, i); 
    128       newStack.addSlice(s.getSliceLabel(ndx + 1), s.getProcessor(ndx + 1)); 
    129     } 
    130     ImagePlus p = new ImagePlus(imp.getTitle(), newStack); 
    131     p.setDimensions(c, z, t); 
    132     p.setCalibration(imp.getCalibration()); 
    133     p.setFileInfo(imp.getOriginalFileInfo()); 
    134     return p; 
    135   } 
    136  
    137113} 
  • trunk/components/loci-plugins/src/loci/plugins/in/Colorizer.java

    r6625 r6654  
    5656 * 
    5757 * @author Melissa Linkert melissa at glencoesoftware.com 
     58 * @author Curtis Rueden ctrueden at wisc.edu 
    5859 */ 
    5960public class Colorizer { 
     
    192193      final MinMaxCalculator minMaxCalc = process.getMinMaxCalculator(); 
    193194      final int cBegin = process.getCBegin(series); 
    194       final int cEnd = process.getCEnd(series); 
    195195      final int cStep = process.getCStep(series); 
    196196      for (int c=0; c<cSize; c++) { 
  • trunk/components/loci-plugins/src/loci/plugins/in/Concatenator.java

    r6588 r6654  
    9999 
    100100        append = true; 
    101         break;         
     101        break; 
    102102      } 
    103103      if (!append) { 
  • trunk/components/loci-plugins/src/loci/plugins/in/CropDialog.java

    r6588 r6654  
    4747    super(process); 
    4848  } 
    49    
     49 
    5050  // -- ImporterDialog methods -- 
    5151 
     
    5454    return !process.isWindowless() && options.doCrop(); 
    5555  } 
    56    
     56 
    5757  @Override 
    5858  protected GenericDialog constructDialog() { 
    59     int seriesCount = process.getSeriesCount(); 
    60     IFormatReader r = process.getReader(); 
    61      
     59    final int seriesCount = process.getSeriesCount(); 
     60    final IFormatReader r = process.getReader(); 
     61 
    6262    // construct dialog 
    63     GenericDialog gd = new GenericDialog("Bio-Formats Crop Options"); 
     63    final GenericDialog gd = new GenericDialog("Bio-Formats Crop Options"); 
    6464    for (int s=0; s<seriesCount; s++) { 
    6565      if (!options.isSeriesOn(s)) continue; 
     
    7575    } 
    7676    WindowTools.addScrollBars(gd); 
    77   
     77 
    7878    return gd; 
    7979  } 
    80    
     80 
    8181  @Override 
    8282  protected boolean harvestResults(GenericDialog gd) { 
    83     int seriesCount = process.getSeriesCount(); 
    84     IFormatReader r = process.getReader(); 
     83    final int seriesCount = process.getSeriesCount(); 
     84    final IFormatReader r = process.getReader(); 
    8585 
    8686    for (int s=0; s<seriesCount; s++) { 
     
    112112    return true; 
    113113  } 
    114    
     114 
    115115} 
  • trunk/components/loci-plugins/src/loci/plugins/in/FilePatternDialog.java

    r6588 r6654  
    4747    super(process); 
    4848  } 
    49    
     49 
    5050  // -- ImporterDialog methods -- 
    5151 
     
    5454    return !process.isWindowless() && options.isGroupFiles(); 
    5555  } 
    56    
     56 
    5757  @Override 
    5858  protected GenericDialog constructDialog() { 
     
    8686    return gd; 
    8787  } 
    88    
     88 
    8989  @Override 
    9090  protected boolean harvestResults(GenericDialog gd) { 
  • trunk/components/loci-plugins/src/loci/plugins/in/IdDialog.java

    r6588 r6654  
    3939 */ 
    4040public class IdDialog extends ImporterDialog { 
    41    
     41 
    4242  // -- Fields -- 
    4343 
     
    5050    super(process); 
    5151  } 
    52    
     52 
    5353  // -- ImporterDialog methods -- 
    5454 
     
    5757    return !process.isWindowless() && options.getId() == null; 
    5858  } 
    59    
     59 
    6060  @Override 
    6161  protected GenericDialog constructDialog() { 
     
    6767    return gd; 
    6868  } 
    69    
     69 
    7070  /** 
    7171   * Asks user whether Bio-Formats should automatically check for upgrades, 
     
    113113      String dir = od.getDirectory(); 
    114114      String name = od.getFileName(); 
    115       if (dir != null || name == null)  
     115      if (dir != null || name == null) 
    116116      id = dir + name; 
    117        
     117 
    118118      // verify validity 
    119119      Location idLoc = new Location(id); 
     
    127127    } 
    128128    else if (options.isHTTP()) { 
    129             id = gd.getNextString(); 
     129      id = gd.getNextString(); 
    130130      if (id == null) { 
    131         if (!options.isQuiet()) IJ.error("Bio-Formats", "No URL was specified."); 
     131        if (!options.isQuiet()) { 
     132          IJ.error("Bio-Formats", "No URL was specified."); 
     133        } 
    132134        return false; 
    133135      } 
  • trunk/components/loci-plugins/src/loci/plugins/in/ImagePlusReader.java

    r6625 r6654  
    5555import loci.plugins.Slicer; 
    5656import loci.plugins.util.BFVirtualStack; 
    57 import loci.plugins.util.ImagePlusTools; 
    5857import loci.plugins.util.ImageProcessorReader; 
    5958import loci.plugins.util.VirtualImagePlus; 
     
    128127  } 
    129128 
     129  // -- Utility methods -- 
     130 
     131  /** 
     132   * Creates an {@link ImagePlus} from the given image processors. 
     133   * 
     134   * @param title The title for the image. 
     135   * @param procs List of image processors to compile into an image. 
     136   */ 
     137  public static ImagePlus createImage(String title, List<ImageProcessor> procs) { 
     138    final List<LUT> luts = new ArrayList<LUT>(); 
     139    final ImageStack stack = createStack(procs, null, luts); 
     140    return createImage(title, stack, luts); 
     141  } 
     142 
     143  /** 
     144   * Creates an {@link ImagePlus} from the given image stack. 
     145   * 
     146   * @param title The title for the image. 
     147   * @param stack The image stack containing the image planes. 
     148   * @param luts Optional list of plane-specific LUTs 
     149   *   to store as image properties, for later use. 
     150   */ 
     151  public static ImagePlus createImage(String title, 
     152    ImageStack stack, List<LUT> luts) 
     153  { 
     154    final ImagePlus imp = new ImagePlus(title, stack); 
     155 
     156    // NB: Save individual planar LUTs as properties, for later access. 
     157    // This step is necessary because ImageStack.addSlice only extracts the 
     158    // pixels from the ImageProcessor, and does not preserve the ColorModel. 
     159    // Later, Colorizer can use the LUTs when wrapping into a CompositeImage. 
     160    for (int i=0; i<luts.size(); i++) { 
     161      final LUT lut = luts.get(i); 
     162      if (lut != null) imp.setProperty(PROP_LUT + i, lut); 
     163    } 
     164 
     165    return imp; 
     166  } 
     167 
     168  /** 
     169   * Creates an image stack from the given image processors. 
     170   * 
     171   * @param procs List of image processors to compile into a stack. 
     172   * @param labels Optional list of labels, one per plane. 
     173   * @param luts Optional list for storing plane-specific LUTs, for later use. 
     174   */ 
     175  public static ImageStack createStack(List<ImageProcessor> procs, 
     176    List<String> labels, List<LUT> luts) 
     177  { 
     178    if (procs == null || procs.size() == 0) return null; 
     179 
     180    final ImageProcessor ip0 = procs.get(0); 
     181    final ImageStack stack = new ImageStack(ip0.getWidth(), ip0.getHeight()); 
     182 
     183    // construct image stack from list of image processors 
     184    for (int i=0; i<procs.size(); i++) { 
     185      final ImageProcessor ip = procs.get(i); 
     186      final String label = labels == null ? null : labels.get(i); 
     187 
     188      // HACK: ImageProcessorReader always assigns an ij.process.LUT object 
     189      // as the color model. If we don't get one, we know ImageJ created a 
     190      // default color model instead, which we can discard. 
     191      if (luts != null) { 
     192        final ColorModel cm = ip.getColorModel(); 
     193        final LUT lut = cm instanceof LUT ? (LUT) cm : null; 
     194        luts.add(lut); 
     195      } 
     196 
     197      // add plane to image stack 
     198      stack.addSlice(label, ip); 
     199    } 
     200 
     201    return stack; 
     202  } 
     203 
    130204  // -- Helper methods - image reading -- 
    131205 
    132   private List<ImagePlus> readImages() 
    133     throws FormatException, IOException 
    134   { 
     206  private List<ImagePlus> readImages() throws FormatException, IOException { 
     207    final ImageProcessorReader reader = process.getReader(); 
     208    final ImporterOptions options = process.getOptions(); 
     209 
    135210    List<ImagePlus> imps = new ArrayList<ImagePlus>(); 
    136211 
    137212    // beginning timing 
    138213    startTiming(); 
    139  
    140     ImageProcessorReader reader = process.getReader(); 
    141     ImporterOptions options = process.getOptions(); 
    142  
    143     if (options.isVirtual()) { 
    144       // set virtual stack's reference count to match # of image windows 
    145       // in this case, these is one window per enabled image series 
    146       // when all image windows are closed, the Bio-Formats reader is closed 
    147       int totalSeries = 0; 
    148       for (int s=0; s<reader.getSeriesCount(); s++) { 
    149         if (options.isSeriesOn(s)) totalSeries++; 
    150       } 
    151       process.getVirtualReader().setRefCount(totalSeries); 
    152     } 
    153214 
    154215    // read in each image series 
    155216    for (int s=0; s<reader.getSeriesCount(); s++) { 
    156217      if (!options.isSeriesOn(s)) continue; 
    157       readSeries(s, imps); 
     218      final ImagePlus imp = readImage(s); 
     219      imps.add(imp); 
    158220    } 
    159221 
     
    167229    imps = splitDims(imps); 
    168230 
     231    // set virtual stack's reference count to match # of image windows 
     232    // in this case, these is one window per enabled image series 
     233    // when all image windows are closed, the Bio-Formats reader is closed 
     234    if (options.isVirtual()) { 
     235      process.getVirtualReader().setRefCount(imps.size()); 
     236    } 
     237 
    169238    // end timing 
    170239    finishTiming(); 
     
    173242  } 
    174243 
    175   private void readSeries(int s, List<ImagePlus> imps) 
     244  private ImagePlus readImage(int s) 
     245    throws FormatException, IOException 
     246  { 
     247    final ImporterOptions options = process.getOptions(); 
     248    final int zCount = process.getZCount(s); 
     249    final int cCount = process.getCCount(s); 
     250    final int tCount = process.getTCount(s); 
     251 
     252    final List<LUT> luts = new ArrayList<LUT>(); 
     253 
     254    // create image stack 
     255    final ImageStack stack; 
     256    if (options.isVirtual()) stack = createVirtualStack(process, s); 
     257    else stack = readPlanes(process, s, luts); 
     258 
     259    notifyListeners(new StatusEvent(1, 1, "Creating image")); 
     260 
     261    // create title 
     262    final String seriesName = process.getOMEMetadata().getImageName(s); 
     263    final String file = process.getCurrentFile(); 
     264    final IFormatReader reader = process.getReader(); 
     265    final String title = constructImageTitle(reader, 
     266      file, seriesName, options.isGroupFiles()); 
     267 
     268    // create image 
     269    final ImagePlus imp; 
     270    if (stack.isVirtual()) { 
     271      VirtualImagePlus vip = new VirtualImagePlus(title, stack); 
     272      vip.setReader(reader); 
     273      imp = vip; 
     274    } 
     275    else { 
     276      imp = createImage(title, stack, luts); 
     277    } 
     278   
     279    // configure image 
     280 
     281    // place metadata key/value pairs in ImageJ's info field 
     282    final String metadata = process.getOriginalMetadata().toString(); 
     283    imp.setProperty("Info", metadata); 
     284    imp.setProperty(PROP_SERIES, s); 
     285 
     286    // retrieve the spatial calibration information, if available 
     287    final FileInfo fi = createFileInfo(); 
     288    new Calibrator(process).applyCalibration(imp); 
     289    imp.setFileInfo(fi); 
     290    imp.setDimensions(cCount, zCount, tCount); 
     291 
     292    // open as a hyperstack, as appropriate 
     293    final boolean hyper = !options.isViewStandard(); 
     294    imp.setOpenAsHyperStack(hyper); 
     295 
     296    return imp; 
     297  } 
     298 
     299  private ImageStack createVirtualStack(ImportProcess process, int s) 
    176300    throws FormatException, IOException 
    177301  { 
    178302    final ImageProcessorReader reader = process.getReader(); 
    179303    final ImporterOptions options = process.getOptions(); 
     304 
     305    final int zCount = process.getZCount(s); 
     306    final int cCount = process.getCCount(s); 
     307    final int tCount = process.getTCount(s); 
     308    final IMetadata meta = process.getOMEMetadata(); 
     309    final int imageCount = reader.getImageCount(); 
     310 
     311    // CTR FIXME: Make virtual stack work with different color modes? 
     312    final BFVirtualStack virtualStack = new BFVirtualStack(options.getId(), 
     313      reader, false, false, options.isRecord()); 
     314    for (int i=0; i<imageCount; i++) { 
     315      final String label = constructSliceLabel(i, 
     316        reader, meta, s, zCount, cCount, tCount); 
     317      virtualStack.addSlice(label); 
     318    } 
     319    return virtualStack; 
     320  } 
     321 
     322  private ImageStack readPlanes(ImportProcess process, int s, List<LUT> luts) 
     323    throws FormatException, IOException 
     324  { 
     325    final ImageProcessorReader reader = process.getReader(); 
    180326    reader.setSeries(s); 
    181327 
     328    final int zCount = process.getZCount(s); 
     329    final int cCount = process.getCCount(s); 
     330    final int tCount = process.getTCount(s); 
     331    final IMetadata meta = process.getOMEMetadata(); 
     332 
     333    // get list of planes to load 
    182334    final boolean[] load = getPlanesToLoad(s); 
    183335    int current = 0, total = 0; 
    184     for (int j=0; j<reader.getImageCount(); j++) if (load[j]) total++; 
    185  
    186     final FileInfo fi = createFileInfo(); 
     336    for (int j=0; j<load.length; j++) if (load[j]) total++; 
     337 
     338    final List<ImageProcessor> procs = new ArrayList<ImageProcessor>(); 
     339    final List<String> labels = new ArrayList<String>(); 
     340 
     341    // read applicable image planes 
    187342    final Region region = process.getCropRegion(s); 
    188  
    189     ImageStack stack = null; 
    190  
    191     final List<LUT> luts = new ArrayList<LUT>(); 
    192     if (options.isVirtual()) { 
    193       // CTR FIXME: Make virtual stack work with different color modes? 
    194       reader.setSeries(s); 
    195       BFVirtualStack virtualStack = new BFVirtualStack(options.getId(), 
    196         reader, false, false, options.isRecord()); 
    197       stack = virtualStack; 
    198       for (int j=0; j<reader.getImageCount(); j++) { 
    199         String label = constructSliceLabel(j, 
    200           reader, process.getOMEMetadata(), s, 
    201           process.getZCount(s), process.getCCount(s), process.getTCount(s)); 
    202         virtualStack.addSlice(label); 
    203       } 
    204     } 
    205     else { 
    206       for (int i=0; i<reader.getImageCount(); i++) { 
    207         if (!load[i]) continue; 
    208  
    209         // limit message update rate 
    210         updateTiming(s, i, current++, total); 
    211  
    212         final String label = constructSliceLabel(i, 
    213           reader, process.getOMEMetadata(), s, 
    214           process.getZCount(s), process.getCCount(s), process.getTCount(s)); 
    215  
    216         // get image processor for ith plane 
    217         final ImageProcessor[] p = reader.openProcessors(i, 
    218           region.x, region.y, region.width, region.height); 
    219         if (p == null || p.length == 0) { 
    220           throw new FormatException("Cannot read plane #" + i); 
    221         } 
    222  
    223         // add plane to image stack 
    224         final int w = region.width, h = region.height; 
    225         if (stack == null) stack = new ImageStack(w, h); 
    226  
    227         for (ImageProcessor ip : p) { 
    228           // HACK: ImageProcessorReader always assigns an ij.process.LUT object 
    229           // as the color model. If we don't get one, we know ImageJ created a 
    230           // default color model instead, which we can discard. 
    231           final ColorModel cm = ip.getColorModel(); 
    232           final LUT lut = cm instanceof LUT ? (LUT) cm : null; 
    233           luts.add(lut); 
    234  
    235           stack.addSlice(label, ip); 
    236         } 
    237       } 
    238     } 
    239  
    240     notifyListeners(new StatusEvent(1, 1, "Creating image")); 
    241  
    242     final ImagePlus imp = createImage(stack, s, fi); 
    243     imps.add(imp); 
    244  
    245     // NB: Save individual planar LUTs as properties, for later access. 
    246     // This step is necessary because ImageStack.addSlice only extracts the 
    247     // pixels from the ImageProcessor, and does not preserve the ColorModel. 
    248     for (int i=0; i<luts.size(); i++) { 
    249       final LUT lut = luts.get(i); 
    250       if (lut != null) imp.setProperty(PROP_LUT + i, lut); 
    251     } 
    252   } 
    253  
    254   // -- Helper methods - concatenation -- 
     343    for (int i=0; i<load.length; i++) { 
     344      if (!load[i]) continue; 
     345 
     346      // limit message update rate 
     347      updateTiming(s, i, current++, total); 
     348 
     349      // get image processor for ith plane 
     350      final ImageProcessor[] p = reader.openProcessors(i, 
     351        region.x, region.y, region.width, region.height); 
     352      if (p == null || p.length == 0) { 
     353        throw new FormatException("Cannot read plane #" + i); 
     354      } 
     355      // generate a label for ith plane 
     356      final String label = constructSliceLabel(i, 
     357        reader, meta, s, zCount, cCount, tCount); 
     358 
     359      for (ImageProcessor ip : p) { 
     360        procs.add(ip); 
     361        labels.add(label); 
     362      } 
     363    } 
     364     
     365    return createStack(procs, labels, luts); 
     366  } 
     367 
     368  // -- Helper methods - image post processing -- 
    255369 
    256370  private List<ImagePlus> concatenate(List<ImagePlus> imps) { 
     
    260374  } 
    261375 
    262   // -- Helper methods - colorization -- 
    263  
    264376  private List<ImagePlus> applyColors(List<ImagePlus> imps) { 
    265377    return new Colorizer(process).applyColors(imps); 
    266378  } 
    267379 
    268   // -- Helper methods - window splitting -- 
    269  
    270380  private List<ImagePlus> splitDims(List<ImagePlus> imps) { 
    271381    final ImporterOptions options = process.getOptions(); 
    272382 
    273     boolean sliceC = options.isSplitChannels(); 
    274     boolean sliceZ = options.isSplitFocalPlanes(); 
    275     boolean sliceT = options.isSplitTimepoints(); 
     383    final boolean sliceC = options.isSplitChannels(); 
     384    final boolean sliceZ = options.isSplitFocalPlanes(); 
     385    final boolean sliceT = options.isSplitTimepoints(); 
    276386    if (sliceC || sliceZ || sliceT) { 
    277       String stackOrder = process.getStackOrder(); 
    278       List<ImagePlus> slicedImps = new ArrayList<ImagePlus>(); 
     387      final String stackOrder = process.getStackOrder(); 
     388      final List<ImagePlus> slicedImps = new ArrayList<ImagePlus>(); 
     389      final Slicer slicer = new Slicer(); 
    279390      for (ImagePlus imp : imps) { 
    280         ImagePlus[] results = new Slicer().reslice(imp, 
     391        final ImagePlus[] results = slicer.reslice(imp, 
    281392          sliceC, sliceZ, sliceT, stackOrder); 
    282393        for (ImagePlus result : results) slicedImps.add(result); 
     
    327438 
    328439  private FileInfo createFileInfo() { 
    329     FileInfo fi = new FileInfo(); 
     440    final FileInfo fi = new FileInfo(); 
    330441 
    331442    // populate common FileInfo fields 
     
    351462 
    352463  private boolean[] getPlanesToLoad(int s) { 
    353     ImageProcessorReader reader = process.getReader(); 
    354     boolean[] load = new boolean[reader.getImageCount()]; 
    355     int cBegin = process.getCBegin(s); 
    356     int cEnd = process.getCEnd(s); 
    357     int cStep = process.getCStep(s); 
    358     int zBegin = process.getZBegin(s); 
    359     int zEnd = process.getZEnd(s); 
    360     int zStep = process.getZStep(s); 
    361     int tBegin = process.getTBegin(s); 
    362     int tEnd = process.getTEnd(s); 
    363     int tStep = process.getTStep(s); 
     464    final ImageProcessorReader reader = process.getReader(); 
     465    final boolean[] load = new boolean[reader.getImageCount()]; 
     466    final int cBegin = process.getCBegin(s); 
     467    final int cEnd = process.getCEnd(s); 
     468    final int cStep = process.getCStep(s); 
     469    final int zBegin = process.getZBegin(s); 
     470    final int zEnd = process.getZEnd(s); 
     471    final int zStep = process.getZStep(s); 
     472    final int tBegin = process.getTBegin(s); 
     473    final int tEnd = process.getTEnd(s); 
     474    final int tStep = process.getTStep(s); 
    364475    for (int c=cBegin; c<=cEnd; c+=cStep) { 
    365476      for (int z=zBegin; z<=zEnd; z+=zStep) { 
    366477        for (int t=tBegin; t<=tEnd; t+=tStep) { 
    367           //int index = r.isOrderCertain() ? r.getIndex(z, c, t) : c; 
    368478          int index = reader.getIndex(z, c, t); 
    369479          load[index] = true; 
     
    374484  } 
    375485 
    376   /** 
    377    * Displays the given image stack according to 
    378    * the specified parameters and import options. 
    379    */ 
    380   private ImagePlus createImage(ImageStack stack, int series, FileInfo fi) { 
    381     if (stack == null) return null; 
    382  
    383     ImporterOptions options = process.getOptions(); 
    384     String seriesName = process.getOMEMetadata().getImageName(series); 
    385     String file = process.getCurrentFile(); 
    386     IMetadata meta = process.getOMEMetadata(); 
    387     int cCount = process.getCCount(series); 
    388     int zCount = process.getZCount(series); 
    389     int tCount = process.getTCount(series); 
    390     IFormatReader reader = process.getReader(); 
    391  
    392     String title = getTitle(reader, file, seriesName, options.isGroupFiles()); 
    393     ImagePlus imp = null; 
    394     if (options.isVirtual()) { 
    395       VirtualImagePlus vip = new VirtualImagePlus(title, stack); 
    396       vip.setReader(reader); 
    397       imp = vip; 
    398     } 
    399     else imp = new ImagePlus(title, stack); 
    400  
    401     // place metadata key/value pairs in ImageJ's info field 
    402     String metadata = process.getOriginalMetadata().toString(); 
    403     imp.setProperty("Info", metadata); 
    404     imp.setProperty(PROP_SERIES, series); 
    405  
    406     // retrieve the spatial calibration information, if available 
    407     ImagePlusTools.applyCalibration(meta, imp, reader.getSeries()); 
    408     imp.setFileInfo(fi); 
    409     imp.setDimensions(cCount, zCount, tCount); 
    410  
    411     // open as a hyperstack, as appropriate 
    412     boolean hyper = !options.isViewStandard(); 
    413     imp.setOpenAsHyperStack(hyper); 
    414  
    415     return imp; 
    416   } 
    417  
    418   /** Get an appropriate stack title, given the file name. */ 
    419   private String getTitle(IFormatReader r, String file, String seriesName, 
    420     boolean groupFiles) 
     486  private String constructImageTitle(IFormatReader r, 
     487    String file, String seriesName, boolean groupFiles) 
    421488  { 
    422489    String[] used = r.getUsedFiles(); 
     
    450517  { 
    451518    r.setSeries(series); 
    452     int[] zct = r.getZCTCoords(ndx); 
    453     int[] subC = r.getChannelDimLengths(); 
    454     String[] subCTypes = r.getChannelDimTypes(); 
    455     StringBuffer sb = new StringBuffer(); 
     519 
     520    final int[] zct = r.getZCTCoords(ndx); 
     521    final int[] subC = r.getChannelDimLengths(); 
     522    final String[] subCTypes = r.getChannelDimTypes(); 
     523    final StringBuffer sb = new StringBuffer(); 
     524 
    456525    boolean first = true; 
    457526    if (cCount > 1) { 
  • trunk/components/loci-plugins/src/loci/plugins/in/ImportProcess.java

    r6588 r6654  
    4444import loci.formats.FileStitcher; 
    4545import loci.formats.FormatException; 
     46import loci.formats.FormatTools; 
    4647import loci.formats.IFormatReader; 
    4748import loci.formats.ImageReader; 
     
    6465/** 
    6566 * Manages the import preparation process. 
     67 * 
    6668 * After calling {@link #execute()}, the process will be ready to feed to 
    67  * an {@link ImagePlusReader} to read in the actual {@link ij.ImagePlus} objects. 
     69 * an {@link ImagePlusReader} to read in the actual {@link ij.ImagePlus} 
     70 * objects. 
    6871 * 
    6972 * <dl><dt><b>Source code:</b></dt> 
     
    120123 
    121124  /** 
    122    * Performs the import process, notifying status listeners at each step. 
     125   * Performs the import preparation process, 
     126   * notifying status listeners at each step. 
    123127   * 
    124    * @return true if the process completed successfully. 
     128   * @return true if the preparation process completed successfully. 
    125129   */ 
    126130  public boolean execute() throws FormatException, IOException { 
     
    348352    if (!options.isSeriesOn(s)) return 0; 
    349353    return (getTEnd(s) - getTBegin(s) + getTStep(s)) / getTStep(s); 
     354  } 
     355 
     356  /** 
     357   * Gets a projection of required memory in bytes. 
     358   * Valid only after {@link ImportStep#SERIES}. 
     359   */ 
     360  public long getMemoryUsage() { 
     361    final int seriesCount = getSeriesCount(); 
     362    long total = 0; 
     363    for (int s=0; s<seriesCount; s++) { 
     364      if (!options.isSeriesOn(s)) continue; 
     365      // determine size of one image plane 
     366      final Region cropRegion = getCropRegion(s); 
     367      final int bpp = FormatTools.getBytesPerPixel(reader.getPixelType()); 
     368      final long planeSize = bpp * cropRegion.width * cropRegion.height; 
     369      // determine total number of image planes 
     370      final int cCount = getCCount(s); 
     371      final int zCount = getZCount(s); 
     372      final int tCount = getTCount(s); 
     373      final long planeCount = cCount * zCount * tCount; 
     374      // determine active number of image planes 
     375      final boolean isVirtual = options.isVirtual(); 
     376      final long activeChannels = options.isColorModeComposite() ? cCount : 1; 
     377      final long activePlanes = isVirtual ? activeChannels : planeCount; 
     378      // compute total memory footprint for this series 
     379      final long seriesSize = planeSize * activePlanes; 
     380      total += seriesSize; 
     381    } 
     382    return total; 
    350383  } 
    351384 
  • trunk/components/loci-plugins/src/loci/plugins/in/ImporterPrompter.java

    r6588 r6654  
    3434 * Helper class for presenting the user with dialog boxes 
    3535 * for configuring importer options. 
    36  *  
     36 * 
    3737 * If running as a macro, gets parameter values from macro options; 
    3838 * if not, get parameter values from user input from dialog boxes. 
     
    100100        break; 
    101101      case COMPLETE: 
     102        if (!promptMemory()) process.cancel(); 
    102103        break; 
    103104      default: 
     
    162163    return dialog.showDialog() == OptionsDialog.STATUS_OK; 
    163164  } 
     165 
     166  /** Prompts for confirmation of memory usage, if necessary. */ 
     167  private boolean promptMemory() { 
     168    MemoryDialog dialog = new MemoryDialog(process); 
     169    return dialog.showDialog() == OptionsDialog.STATUS_OK; 
     170  } 
     171 
    164172} 
  • trunk/components/loci-plugins/src/loci/plugins/in/RangeDialog.java

    r6588 r6654  
    5050    super(process); 
    5151  } 
    52    
     52 
    5353  // -- ImporterDialog methods -- 
    5454 
    5555  protected boolean needPrompt() { 
    5656    if (process.isWindowless() || !options.isSpecifyRanges()) return false; 
    57      
     57 
    5858    ImageProcessorReader r = process.getReader(); 
    5959    int seriesCount = process.getSeriesCount(); 
     
    6363    return false; 
    6464  } 
    65    
     65 
    6666  protected GenericDialog constructDialog() { 
    6767    ImageProcessorReader r = process.getReader(); 
     
    102102    return gd; 
    103103  } 
    104    
     104 
    105105  protected boolean harvestResults(GenericDialog gd) { 
    106106    ImageProcessorReader r = process.getReader(); 
     
    177177    return true; 
    178178  } 
    179    
     179 
    180180} 
  • trunk/components/loci-plugins/src/loci/plugins/in/UpgradeDialog.java

    r6588 r6654  
    8787      } 
    8888    } 
    89    
     89 
    9090    return true; 
    9191  } 
  • trunk/components/loci-plugins/src/loci/plugins/macro/LociFunctions.java

    r6604 r6654  
    2727 
    2828import ij.IJ; 
     29import ij.ImagePlus; 
    2930import ij.process.ImageProcessor; 
    3031 
    3132import java.io.IOException; 
     33import java.util.Arrays; 
    3234 
    3335import loci.common.services.DependencyException; 
     
    4244import loci.formats.meta.MetadataRetrieve; 
    4345import loci.formats.services.OMEXMLService; 
     46import loci.plugins.BF; 
     47import loci.plugins.in.ImagePlusReader; 
    4448import loci.plugins.util.ImageProcessorReader; 
    4549import loci.plugins.util.LociPrefs; 
     
    151155  } 
    152156 
     157  public void openImagePlus(String path) { 
     158    ImagePlus[] imps = null; 
     159    try { 
     160      imps = BF.openImagePlus(path); 
     161      for (ImagePlus imp : imps) imp.show(); 
     162    } 
     163    catch (IOException exc) { 
     164      IJ.handleException(exc); 
     165    } 
     166    catch (FormatException exc) { 
     167      IJ.handleException(exc); 
     168    } 
     169  } 
     170 
    153171  public void openImage(String title, Double no) 
    154172    throws FormatException, IOException 
    155173  { 
    156     ImageProcessor[] ip = r.openProcessors(no.intValue()); 
    157     // CTR FIXME - Ext.openImage 
    158     //ImagePlusTools.makeRGB(title, ip).show(); 
     174    final ImageProcessor[] ip = r.openProcessors(no.intValue()); 
     175    final ImagePlus imp = ImagePlusReader.createImage(title, Arrays.asList(ip)); 
     176    imp.show(); 
    159177  } 
    160178 
     
    164182    ImageProcessor[] ip = r.openProcessors(no.intValue(), 
    165183      x.intValue(), y.intValue(), w.intValue(), h.intValue()); 
    166     // START HERE - add a method to create an ImagePlus from an ImageProcessor[] 
    167     // CTR FIXME - Ext.openSubImage 
    168     //ImagePlusTools.makeRGB(title, ip).show(); 
     184    final ImagePlus imp = ImagePlusReader.createImage(title, Arrays.asList(ip)); 
     185    imp.show();     
    169186  } 
    170187 
     
    348365      IJ.log("-= Usable any time =-"); 
    349366      IJ.log(""); 
     367      IJ.log("Ext.openImagePlus(path)"); 
     368      IJ.log("-- Opens the image at the given path with the default options."); 
    350369      IJ.log("Ext.getFormat(id, format)"); 
    351370      IJ.log("-- Retrieves the file format of the given id (filename)."); 
  • trunk/components/loci-plugins/src/loci/plugins/util/DataBrowser.java

    r6588 r6654  
    446446    syncPlane(); 
    447447  } 
    448    
     448 
    449449  // -- MouseWheelListener methods -- 
    450     
     450 
    451451  public void mouseWheelMoved(MouseWheelEvent event) { 
    452452    super.mouseWheelMoved(event); 
     
    490490  } 
    491491  */ 
    492    
     492 
    493493  /** Updates the ImagePlus's displayed plane to match the slider values. */ 
    494494  private void syncPlane() { 
  • trunk/components/loci-plugins/src/loci/plugins/util/RecordedImageProcessor.java

    r6588 r6654  
    10921092    proc.xor(value); 
    10931093  } 
    1094    
     1094 
    10951095  // -- Deprecated methods -- 
    10961096 
  • trunk/components/loci-plugins/test/loci/plugins/in/ImporterTest.java

    r6640 r6654  
    55package loci.plugins.in; 
    66 
    7 import org.junit.Test; 
    8  
    97import static org.junit.Assert.assertEquals; 
     8import static org.junit.Assert.assertFalse; 
    109import static org.junit.Assert.assertNotNull; 
    1110import static org.junit.Assert.assertTrue; 
    12 import static org.junit.Assert.assertFalse; 
    1311import static org.junit.Assert.fail; 
    1412 
    1513import ij.CompositeImage; 
    16 import ij.IJ; 
    1714import ij.ImagePlus; 
    1815import ij.ImageStack; 
    19 import ij.WindowManager; 
    2016import ij.measure.Calibration; 
    2117import ij.process.ImageProcessor; 
     
    3228import loci.formats.FormatTools; 
    3329import loci.plugins.BF; 
    34 import loci.plugins.in.ImporterOptions; 
     30 
     31import org.junit.Test; 
    3532 
    3633// TODO 
     
    9693 
    9794  private enum Axis {Z,C,T}; 
    98    
     95 
    9996  private enum ChannelOrder {ZCT, ZTC, CZT, CTZ, TZC, TCZ}; 
    10097 
     
    103100 
    104101  private static final boolean[] BOOLEAN_STATES = new boolean[] {false, true}; 
    105    
     102 
    106103  private static final int[] PIXEL_TYPES = new int[] { 
    107104      FormatTools.FLOAT, FormatTools.DOUBLE, 
     
    109106      FormatTools.INT8,  FormatTools.INT16,  FormatTools.INT32 
    110107      }; 
    111    
     108 
    112109  private static Color[] DEFAULT_COLOR_ORDER = 
    113110    new Color[] {Color.RED, Color.GREEN, Color.BLUE, Color.WHITE, Color.CYAN, Color.MAGENTA, Color.YELLOW}; 
    114    
     111 
    115112  private static Color[] CUSTOM_COLOR_ORDER = 
    116113    new Color[] {Color.BLUE, Color.RED, Color.GREEN, Color.MAGENTA, Color.YELLOW, Color.CYAN, Color.WHITE}; 
     
    121118  private static final boolean FALSE_COLOR = true; 
    122119  private static final boolean REAL_COLOR = false; 
    123    
     120 
    124121  private static final int ONE_SERIES = 1; 
    125122 
     
    132129  private static final int FAKE_SIZE_X = 50; 
    133130  private static final int FAKE_SIZE_Y = 50; 
    134    
     131 
    135132  static { 
    136133    //String template = "test_C%s_TP%s&sizeX=50&sizeY=20&sizeZ=7.fake"; 
    137134    String template = constructFakeFilename("test_C%s_TP%s", FormatTools.UINT8, FAKE_SIZE_X, FAKE_SIZE_Y, FAKE_PLANE_COUNT, 1, 1, 
    138135                        -1, false, -1, false, -1); 
    139      
     136 
    140137    FAKE_FILES = new String[] { 
    141138      String.format(template, "1", "1"), 
     
    161158    } 
    162159  } 
    163    
     160 
    164161  // ** Helper methods ******************************************************************* 
    165162 
     
    189186    if (lutLength > 0) fileName += "&lutLength=" + lutLength; 
    190187    fileName += ".fake"; 
    191      
     188 
    192189    return fileName; 
    193190  } 
     
    213210    return getPixelValue(0,0,imp,z,c,t,indexed,falseColor); 
    214211  } 
    215    
     212 
    216213  /** Image number of the given ImagePlus at z,c,t index */ 
     214  @SuppressWarnings("unused") 
    217215  private int iIndex(ImagePlus imp, int z, int c, int t, boolean indexed, boolean falseColor) 
    218216  { 
    219217    return getPixelValue(10,0,imp,z,c,t,indexed,falseColor); 
    220218  } 
    221    
     219 
    222220  /** Slice number of the given ImagePlus at z,c,t index */ 
    223221  private int zIndex(ImagePlus imp, int z, int c, int t, boolean indexed, boolean falseColor) 
     
    225223    return getPixelValue(20,0,imp,z,c,t,indexed,falseColor); 
    226224  } 
    227    
     225 
    228226  /** Channel number of the given ImagePlus at z,c,t index */ 
    229227  private int cIndex(ImagePlus imp, int z, int c, int t, boolean indexed, boolean falseColor) 
     
    231229    return getPixelValue(30,0,imp,z,c,t,indexed,falseColor); 
    232230  } 
    233    
     231 
    234232  /** Frame number of the given ImagePlus at z,c,t index */ 
    235233  private int tIndex(ImagePlus imp, int z, int c, int t, boolean indexed, boolean falseColor) 
     
    259257    if ((d < 0) || (d > 2)) 
    260258      throw new IllegalArgumentException("axisChar() - index out of bounds [0..2]: "+d); 
    261      
     259 
    262260    return order.charAt(d); 
    263261  } 
    264    
     262 
    265263  /** returns Axis given an order string and an index */ 
    266264  private Axis axis(String order, int d) 
    267265  { 
    268266    char dimChar = axisChar(order,d); 
    269      
     267 
    270268    if (dimChar == 'Z') return Axis.Z; 
    271269    if (dimChar == 'C') return Axis.C; 
     
    284282    throw new IllegalArgumentException("value() - unknown axis: "+axis); 
    285283  } 
    286    
     284 
    287285  /** returns z, c, or t index value given an ImageProcessor and an Axis selector */ 
    288286  private int index(Axis axis, ImageProcessor proc) 
     
    291289    if (axis == Axis.C) return cIndex(proc); 
    292290    if (axis == Axis.T) return tIndex(proc); 
    293      
     291 
    294292    throw new IllegalArgumentException("index() - unknown axis: "+axis); 
    295293  } 
     
    300298    return "XY" + order.toString(); 
    301299  } 
    302    
     300 
    303301  /** returns the number of of elements in a series given from, to, and by values */ 
    304302  private int numInSeries(int from, int to, int by) 
     
    306304    if (by < 1) 
    307305      throw new IllegalArgumentException("numInSeries passed a stepBy value < 1"); 
    308      
     306 
    309307    // could calc this but simple loop suffices for our purposes 
    310308    int count = 0; 
     
    313311    return count; 
    314312  } 
    315    
     313 
    316314  // this next method useful to avoid changes to instance vars of ImagePlus by query functions 
    317315  /** Gets values of private instance variable ints from an ImagePlus */ 
     
    331329    return -1; 
    332330  } 
    333    
     331 
    334332  /** The number of Z slices in an ImagePlus */ 
    335333  private int getSizeZ(ImagePlus imp) { return getField(imp, "nSlices"); } 
     
    347345    if (FormatTools.isFloatingPoint(pixType)) 
    348346      return 4294967296L; // expected Float.MAX_VALUE or maybe Double.MAX_VALUE 
    349   
     347 
    350348    switch (pixType) 
    351349    { 
    352       case FormatTools.INT8:    return 255; // expected: Byte.MAX_VALUE  
     350      case FormatTools.INT8:    return 255; // expected: Byte.MAX_VALUE 
    353351      case FormatTools.INT16:   return 65535;  // expected: Short.MAX_VALUE 
    354       case FormatTools.INT32:   return 4294967296L; // expected INTEGER.MAX_VALUE and also off by 1 from unsigned max  
    355       case FormatTools.UINT8:   return 255;  
    356       case FormatTools.UINT16:  return 65535;  
     352      case FormatTools.INT32:   return 4294967296L; // expected INTEGER.MAX_VALUE and also off by 1 from unsigned max 
     353      case FormatTools.UINT8:   return 255; 
     354      case FormatTools.UINT16:  return 65535; 
    357355      case FormatTools.UINT32:  return 4294967295L; // off by 1 from unsigned max 
    358356                                            // TODO : prev line modified to get autoscale working better. Off by 1 not true. 
     
    362360    } 
    363361  } 
    364    
     362 
    365363  /** returns the minimum pixel value for a given pixel type */ 
    366364  private long minPixelValue(int pixType) 
     
    368366    if (FormatTools.isFloatingPoint(pixType)) 
    369367      //return -4294967296L; // -2^32 (and also its not 2^32-1 !!!) 
    370       return 0;  // TODO this allows autoscale testing to work for floating types - makes sense cuz FakeReader only does unsigned float data  
    371   
     368      return 0;  // TODO this allows autoscale testing to work for floating types - makes sense cuz FakeReader only does unsigned float data 
     369 
    372370    switch (pixType) 
    373371    { 
    374       case FormatTools.INT8:    return Byte.MIN_VALUE;  
     372      case FormatTools.INT8:    return Byte.MIN_VALUE; 
    375373      case FormatTools.INT16:   return Short.MIN_VALUE; 
    376       case FormatTools.INT32:   return Integer.MIN_VALUE;  
    377       case FormatTools.UINT8:   return 0;  
    378       case FormatTools.UINT16:  return 0;  
     374      case FormatTools.INT32:   return Integer.MIN_VALUE; 
     375      case FormatTools.UINT8:   return 0; 
     376      case FormatTools.UINT16:  return 0; 
    379377      case FormatTools.UINT32:  return 0; 
    380378 
     
    388386  { 
    389387    long min; 
    390      
     388 
    391389    if (wantAutoscale || (FormatTools.isFloatingPoint(pixType))) 
    392390      min = minPixelValue(pixType); 
     
    400398    return min; 
    401399  } 
    402    
     400 
    403401  /** returns the expected max value within a FakeFile plane based on pixel type and if autoscale desired */ 
    404402  private long expectedMax(int pixType, boolean wantAutoscale, long maxPixVal, long maxIndex) 
    405403  {                     // TODO - call Math.max() at point of call. Simplify this method to take a maxVal. 
    406404    long max; 
    407      
     405 
    408406    if (wantAutoscale || (FormatTools.isFloatingPoint(pixType))) 
    409407      max = Math.max( maxPixVal, maxIndex); 
     
    414412      if (max > 65535) 
    415413        max = 65535; 
    416      
     414 
    417415    return max; 
    418416  } 
     
    425423    imp.setSlice(sliceNumber+1); 
    426424  } 
    427    
     425 
    428426  /** set an ImagePlus' position relative to ZCT ordering (rather than default CZT) */ 
    429427  private void setZctPosition(ImagePlus imp, int z, int c, int t) 
     
    433431    imp.setSlice(sliceNumber+1); 
    434432  } 
    435    
     433 
    436434  // note - the following code relies on setZctPosition() being called previously. Otherwise regular ImagePlus case 
    437435  //   won't work. In general this method not designed for general use but actually just for use by getPixelValue(). 
    438    
     436 
    439437  /** gets the color table from any kind of ImagePlus (composite or not) - not for general use */ 
    440438  private LUT getColorTable(ImagePlus imp, int channel) 
     
    442440    if (imp instanceof CompositeImage) 
    443441      return ((CompositeImage)imp).getChannelLut(channel+1); 
    444      
     442 
    445443    // else a regular ImagePlus 
    446      
     444 
    447445    //if (DEBUG) log("  getting color table from a regular ImagePlus."); 
    448      
     446 
    449447    IndexColorModel icm = (IndexColorModel)imp.getProcessor().getColorModel(); 
    450      
     448 
    451449    // TODO - maybe I can cast from IndexColorModel to LUT here - depends what IJ did. 
    452450    // otherwise make a LUT 
    453      
     451 
    454452    byte[] reds = new byte[256], greens = new byte[256], blues = new byte[256]; 
    455      
     453 
    456454    icm.getReds(reds); 
    457455    icm.getGreens(greens); 
    458456    icm.getBlues(blues); 
    459      
     457 
    460458    return new LUT(reds,greens,blues); 
    461459  } 
    462    
     460 
    463461  /** get the actual pixel value (lookup when data is indexed) of the index of a fake image at a given z,c,t */ 
    464462  private int getPixelValue(int x,int y, ImagePlus imp, int z, int c, int t, boolean indexed, boolean falseColor) 
     
    466464    //TODO - restore - changed for compositeTest debugging setZctPosition(imp,z,c,t); 
    467465    setCztPosition(imp,z,c,t); 
    468      
     466 
    469467    int rawValue = (int) (imp.getProcessor().getPixelValue(x, y)); 
    470      
     468 
    471469    if ((!indexed) || (falseColor)) // TODO - disabling falseColor test here improves 3/1/indexed/falseColor 
    472470      return rawValue; 
    473471 
    474472    // otherwise indexed - lookup pixel value in LUT 
    475      
     473 
    476474    LUT lut = getColorTable(imp,c); 
    477475    int value = lut.getRed(rawValue);  // since r g and b vals should be the same choose one arbitrarily. 
    478476      // OR Use red in case lut len < 3 and zero fills other channels 
    479      
     477 
    480478    //if (DEBUG) log("  did a lut lookup in getPixelValue("+z+","+c+","+t+") = "+value+" (rawValue = "+rawValue+")"); 
    481      
     479 
    482480    return value; 
    483481  } 
    484   
     482 
    485483  /** calculate the effective size C of an image given various params */ 
    486484  private int effectiveC(int sizeC, int rgb, int lutLen, boolean indexed, boolean falseColor) 
    487485  { 
    488486    int effC = sizeC; 
    489      
     487 
    490488    if (indexed)  // this is from Melissa 
    491489    { 
     
    495493        effC *= lutLen; 
    496494    } 
    497      
     495 
    498496    return effC; 
    499497  } 
    500    
     498 
    501499  // ****** helper tests **************************************************************************************** 
    502    
     500 
    503501  /** tests that the correct number of ImagePluses exist */ 
    504502  private void impsCountTest(ImagePlus[] imps, int numExpected) 
     
    507505    assertEquals(numExpected,imps.length); 
    508506  } 
    509    
     507 
    510508  /** tests that the stack of an ImagePlus is of a given size */ 
    511509  private void stackTest(ImagePlus imp, int expectedSize) 
     
    514512    assertEquals(expectedSize,imp.getStack().getSize()); 
    515513  } 
    516    
     514 
    517515  /** tests that the dimensions of an ImagePlus match passed in x,y,z,c,t values */ 
    518516  private void xyzctTest(ImagePlus imp, int x, int y, int z, int c, int t) 
     
    525523    assertEquals(t,getSizeT(imp)); 
    526524  } 
    527    
     525 
    528526  /** tests that the first and last entries of a lut match expected values */ 
    529527  private void lutTest(CompositeImage ci, int channel, int minR, int minG, int minB, int maxR, int maxG, int maxB) 
     
    531529    // channel is 0-based 
    532530    LUT lut = ci.getChannelLut(channel+1);  // IJ is 1-based 
    533      
     531 
    534532    byte[] reds = new byte[256]; 
    535533    byte[] blues = new byte[256]; 
    536534    byte[] greens = new byte[256]; 
    537      
     535 
    538536    lut.getReds(reds); 
    539537    lut.getGreens(greens); 
    540538    lut.getBlues(blues); 
    541      
     539 
    542540    /* TODO - helper for testing falseColor problems 
    543541    if (DEBUG) log("  expected min rgb : "+minR+" "+minG+" "+minB); 
     
    546544    if (DEBUG) log("  actual max rgb : "+(reds[255]&0xff)+" "+(greens[255]&0xff)+" "+(blues[255]&0xff)); 
    547545    */ 
    548      
     546 
    549547    assertEquals((byte)minR,reds[0]); 
    550548    assertEquals((byte)maxR,reds[255]); 
     
    564562    } 
    565563  } 
    566    
     564 
    567565  /** tests that input to the crop tests is valid */ 
    568566  private void verifyCropInput(int sizeX, int sizeY, int originCropX, int originCropY, int sizeCrop) 
     
    578576    assertTrue(originCropY + sizeCrop <= sizeY); 
    579577  } 
    580    
     578 
    581579  /** tests that the indices of a FakeFile[z,c,t] match passed in values*/ 
    582580  private boolean indexValuesTest(ImagePlus imp, int z, int c, int t, boolean indexed, boolean falseColor, 
    583                                   int expS, int expI, int expZ, int expC, int expT) 
     581                                  int expS, /*int expI,*/ int expZ, int expC, int expT) 
    584582  { 
    585583    // TODO - returns a boolean so we can print out all values before asserting failure. Could be changed if desired. 
    586      
     584 
    587585    int tempS = sIndex(imp, z, c, t, indexed, falseColor); 
    588     int tempI = iIndex(imp, z, c, t, indexed, falseColor); 
     586    //int tempI = iIndex(imp, z, c, t, indexed, falseColor); 
    589587    int tempZ = zIndex(imp, z, c, t, indexed, falseColor); 
    590588    int tempC = cIndex(imp, z, c, t, indexed, falseColor); 
    591589    int tempT = tIndex(imp, z, c, t, indexed, falseColor); 
    592      
     590 
    593591    //if (DEBUG) log("actual CZT "+tempC+" "+tempZ+" "+tempT); 
    594      
     592 
    595593    //if (DEBUG) log("  indices test (I forced to 0)"); 
    596594    //if (DEBUG) log("    expected (sizct): "+expS+" "+0+" "+expZ+" "+expC+" "+expT); 
    597595    //if (DEBUG) log("    actual (sizct):   "+tempS+" "+0+" "+tempZ+" "+tempC+" "+tempT); 
    598      
     596 
    599597    //TODO - remove this debugging code 
    600598    if ((expS != tempS) || /*(expI != tempI) ||*/ (expZ != tempZ) || (expC != tempC) || (expT != tempT)) 
     
    606604      return false; 
    607605    } 
    608     else 
    609     { 
    610       assertEquals(expS,tempS); 
    611       //assertEquals(expI,tempI);  // not so important we test this 
    612       assertEquals(expZ,tempZ); 
    613       assertEquals(expC,tempC); 
    614       assertEquals(expT,tempT); 
    615       return true; 
    616     } 
    617   } 
    618    
     606    assertEquals(expS,tempS); 
     607    //assertEquals(expI,tempI);  // not so important we test this 
     608    assertEquals(expZ,tempZ); 
     609    assertEquals(expC,tempC); 
     610    assertEquals(expT,tempT); 
     611    return true; 
     612  } 
     613 
    619614  /** tests that a FakeFile dataset has index values in ZCT order */ 
    620615  private void stackInZctOrderTest(ImagePlus imp, int maxZ, int maxC, int maxT, boolean indexed, boolean falseColor) 
    621616  { 
    622617    if (DEBUG) log("stackInZctOrderTest()"); 
    623      
     618 
    624619    boolean success = true; 
    625      
     620 
    626621    stackTest(imp,(maxZ * maxC * maxT)); 
    627622 
     
    632627 
    633628          int expectedS = 0; 
    634           int expectedI = iIndex; 
     629          //int expectedI = iIndex; 
    635630          int expectedZ = z; 
    636631          int expectedC = c; 
    637632          int expectedT = t; 
    638            
     633 
    639634          iIndex++; 
    640            
    641           success &= indexValuesTest(imp,z,c,t,indexed,falseColor,expectedS,expectedI,expectedZ,expectedC,expectedT); 
     635 
     636          success &= indexValuesTest(imp,z,c,t,indexed,falseColor,expectedS,expectedZ,expectedC,expectedT); 
    642637        } 
    643638      } 
    644639    } 
    645      
     640 
    646641    if (!success) 
    647642      fail("indexValuesTest() failed for some values"); 
    648643  } 
    649    
     644 
    650645  /** tests that a FakeFile dataset has index values in CZT order */ 
    651   private void stackInCztOrderTest(ImagePlus imp, int maxZ, int maxC, int maxT, boolean indexed, boolean falseColor,int inputChan, int inputChanPerPlane) 
     646  private void stackInCztOrderTest(ImagePlus imp, int maxZ, int maxC, int maxT, boolean indexed, boolean falseColor) 
    652647  { 
    653648    if (DEBUG) log("stackInCztOrderTest()"); 
    654      
     649 
    655650    boolean success = true; 
    656651 
     
    663658 
    664659          int expectedS = 0; 
    665           int expectedI = 0;  // won't test anymore : some tricky cases arise 
     660          //int expectedI = 0;  // won't test anymore : some tricky cases arise 
    666661          int expectedZ = z; 
    667662          int expectedC = c; 
    668663          int expectedT = t; 
    669            
     664 
    670665          iIndex++; 
    671            
    672           success &= indexValuesTest(imp,z,c,t,indexed,falseColor,expectedS,expectedI,expectedZ,expectedC,expectedT); 
     666 
     667          success &= indexValuesTest(imp,z,c,t,indexed,falseColor,expectedS,expectedZ,expectedC,expectedT); 
    673668        } 
    674669      } 
    675670    } 
    676      
     671 
    677672    if (!success) 
    678673      fail("indexValuesTest() failed for some values"); 
    679674  } 
    680    
     675 
    681676  /** tests that a FakeFile dataset has index values in CZT order repeated once per series */ 
    682677  private void multipleSeriesInCztOrderTest(ImagePlus imp, int numSeries, int maxZ, int maxC, int maxT) 
     
    692687        for (int zIndex = 0; zIndex < maxZ; zIndex++) { 
    693688          for (int cIndex = 0; cIndex < maxC; cIndex++) { 
    694             ImageProcessor proc = st.getProcessor(++slice);  
     689            ImageProcessor proc = st.getProcessor(++slice); 
    695690            assertEquals(sIndex, sIndex(proc)); 
    696691            assertEquals(zIndex, zIndex(proc)); 
     
    717712    Axis middle = axis(chOrder,1); 
    718713    Axis slowest = axis(chOrder,2); 
    719      
     714 
    720715    int maxI = value(slowest,z,c,t); 
    721716    int maxJ = value(middle,z,c,t); 
    722717    int maxK = value(fastest,z,c,t); 
    723      
     718 
    724719    int slice = 0; 
    725720    for (int i = 0; i < maxI; i++) { 
     
    740735    } 
    741736  } 
    742    
     737 
    743738  /** tests that the pixel values of a FakeFile are as expected */ 
    744739  private void pixelsTest(ImagePlus imp, int pixType, boolean indexed, boolean falseColor) 
     
    746741    assertTrue(pixType == FormatTools.UINT8);  // TODO - for now 
    747742    assertTrue(imp.getHeight() > 10); 
    748      
     743 
    749744    int max = imp.getWidth(); 
    750745    if (max > 255) max = 255; 
    751      
     746 
    752747    for (int t = 0; t < imp.getNFrames(); t++) 
    753748      for (int c = 0; c < imp.getNChannels(); c++) 
     
    761756  { 
    762757    ImageProcessor proc = imp.getProcessor(); 
    763      
     758 
    764759    for (int ix = 0; ix < cropSize; ix++) 
    765760      for (int iy = 0; iy < cropSize; iy++) 
    766761        assertEquals(ox+ix,proc.getPixelValue(ix, iy),0); 
    767762  } 
    768    
     763 
    769764  /** tests that multiple file groups are pulled into one dataset */ 
    770765  private void groupedFilesTest(ImagePlus imp, int expNumZ, int expNumC, int expNumT) 
    771766  { 
    772767    stackTest(imp,expNumZ*expNumC*expNumT); 
    773      
     768 
    774769    ImageStack st = imp.getStack(); 
    775      
     770 
    776771    //if (DEBUG) log("groupedFilesTest"); 
    777772    int slice = 0; 
     
    791786    } 
    792787  } 
    793    
     788 
    794789  /** tests that a dataset has had its Z & T dimensions swapped */ 
    795790  private void swappedZtTest(ImagePlus imp, int pixType, boolean virtual, int originalZ, int originalC, int originalT) 
    796791  { 
    797792    if (DEBUG) log("swappedZtTest() : virtual "+virtual+" pixType "+FormatTools.getPixelTypeString(pixType)); 
    798      
     793 
    799794    stackTest(imp,(originalZ*originalC*originalT)); 
    800795 
     
    804799    if (pixType == FormatTools.INT32)  // note - since INT32 represented internally as float the signedness is ignored by IJ 
    805800      offset = 0; 
    806      
     801 
    807802    // verify that the dimensional extents were swapped 
    808803    final int actualSizeZ = imp.getNSlices(); 
     
    821816          int actualZ, actualC, actualT; 
    822817          ImageProcessor proc = st.getProcessor(++slice); 
    823            
     818 
    824819          // TODO - hack in place to clarify an underlying BF bug. Remove when bug fixed. Also remove virtual & pixType params. 
    825           if (true)  // TODO - temp until I confirm with Curtis that he has fixed underlying BF bug. 
    826           { 
     820//          if (true)  // TODO - temp until I confirm with Curtis that he has fixed underlying BF bug. 
     821//          { 
    827822            actualZ = (int)(offset + tIndex(proc)); // Z<->T swapped 
    828823            actualC = (int)(offset + cIndex(proc)); 
    829824            actualT = (int)(offset + zIndex(proc)); // Z<->T swapped 
    830           } 
    831           else 
    832           { 
    833             actualZ = tIndex(proc); // Z<->T swapped 
    834             actualC = cIndex(proc); 
    835             actualT = zIndex(proc); // Z<->T swapped 
    836           } 
     825//          } 
     826//          else 
     827//          { 
     828//            actualZ = tIndex(proc); // Z<->T swapped 
     829//            actualC = cIndex(proc); 
     830//            actualT = zIndex(proc); // Z<->T swapped 
     831//          } 
    837832          //if (DEBUG) log("--\nexp CZT "+cIndex+" "+zIndex+" "+tIndex); 
    838833          //if (DEBUG) log("act CZT "+actualC+" "+actualZ+" "+actualT); 
     
    844839    } 
    845840  } 
    846    
     841 
    847842  /** Tests that an ImageStack is ordered ZCT according to specified from/to/by points of z/c/t */ 
    848843  private void seriesInZctOrderTest(ImagePlus imp, boolean indexed, boolean falseColor, 
     
    854849    int cs = numInSeries(cFrom,cTo,cBy); 
    855850    int ts = numInSeries(tFrom,tTo,tBy); 
    856     
     851 
    857852    stackTest(imp,(zs * cs * ts)); 
    858      
     853 
    859854    for (int t = 0; t < ts; t++) { 
    860855      for (int c = 0; c < cs; c++) { 
     
    864859          int cIndex = cIndex(imp,z,c,t,indexed,falseColor); 
    865860          int tIndex = tIndex(imp,z,c,t,indexed,falseColor); 
    866            
     861 
    867862          int zVal = zFrom + z*zBy; 
    868863          int cVal = cFrom + c*cBy; 
     
    883878    if (pixType == FormatTools.INT32) 
    884879      return; 
    885      
     880 
    886881    if (FormatTools.isSigned(pixType) && !FormatTools.isFloatingPoint(pixType)) 
    887882    { 
     
    902897      for (int c = 0; c < ci.getNChannels(); c++) { 
    903898        LUT lut = ci.getChannelLut(c + 1); 
     899if (expectedMax != lut.max) {//TEMP 
     900  log("expected=" + expectedMax +", actual=" + lut.max);//TEMP 
     901  log("imp=" + imp + ", sizeC=" + imp.getNChannels());//TEMP 
     902}//TEMP 
    904903        assertEquals(expectedMax,lut.max,0.1); 
    905904        assertEquals(expectedMin,lut.min,0.1); 
     
    939938    } 
    940939  } 
    941    
     940 
    942941  /** tests if images split on C are ordered correctly */ 
    943942  private void imagesCInZtOrderTest(ImagePlus[] imps, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT) 
     
    961960    } 
    962961  } 
    963    
     962 
    964963  /** tests if images split on T are ordered correctly */ 
    965964  private void imagesTInCzOrderTest(ImagePlus[] imps, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT) 
     
    983982    } 
    984983  } 
    985    
     984 
    986985  /** tests that a set of images is ordered via Z first - used by concatSplit tests */ 
    987986  private void imageSeriesZInCtOrderTest(ImagePlus[] imps, int numSeries, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT) 
     
    10131012    } 
    10141013  } 
    1015    
     1014 
    10161015  /** tests that a set of images is ordered via C first - used by concatSplit tests */ 
    10171016  private void imageSeriesCInZtOrderTest(ImagePlus[] imps, int numSeries, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT) 
     
    10411040    } 
    10421041  } 
    1043    
     1042 
    10441043  // this one will be different from the previous two as we concat along T by default for FakeFiles as all dims compatible. 
    10451044  //   Then we're splitting on T. Logic will need to be different from others. 
     
    10741073    } 
    10751074  } 
    1076    
     1075 
    10771076  /** tests that an image stack is correctly ordered after swapping and cropping */ 
    10781077  private void stackCtzSwappedAndCroppedTest(ImagePlus[] imps, int cropSizeX, int cropSizeY, int origSizeZ, int origSizeC, int origSizeT, int start, int stepBy) 
    10791078  { 
    10801079    // note orig data is ZCT. swapping order is CTZ (all dims swapped). 
    1081      
     1080 
    10821081    int newMaxT = origSizeC; 
    1083      
     1082 
    10841083    int numC = numInSeries(start,origSizeC-1,stepBy); 
    10851084 
     
    10871086    int newC = origSizeZ; 
    10881087    int newT = numC; 
    1089      
     1088 
    10901089    for (int zIndex = 0; zIndex < newZ; zIndex++) { 
    1091        
     1090 
    10921091      ImagePlus imp = imps[zIndex]; 
    1093        
     1092 
    10941093      xyzctTest(imp,cropSizeX,cropSizeY,1,newC,newT); // all dims changed 
    1095    
     1094 
    10961095      stackTest(imp,newC*newT); 
    1097        
     1096 
    10981097      ImageStack st = imp.getStack(); 
    1099        
     1098 
    11001099      int slice = 0; 
    11011100      for (int tIndex = start; tIndex < newMaxT; tIndex += stepBy) { 
     
    11031102        { 
    11041103          ImageProcessor proc = st.getProcessor(++slice); 
    1105            
     1104 
    11061105          assertEquals(cropSizeX,proc.getWidth()); 
    11071106          assertEquals(cropSizeY,proc.getHeight()); 
     
    11101109          final int actualC = zIndex(proc); 
    11111110          final int actualT = cIndex(proc); 
    1112            
     1111 
    11131112          assertEquals(zIndex, actualZ); 
    11141113          assertEquals(cIndex, actualC); 
     
    11181117    } 
    11191118  } 
    1120    
     1119 
    11211120  // ******** specific testers  ********************************** 
    1122    
     1121 
    11231122  /** tests BioFormats when directly calling BF.openImagePlus(path) (no options set) */ 
    11241123  private void defaultBehaviorTester(int pixType, int x, int y, int z, int c, int t) 
     
    11261125    String path = constructFakeFilename("default", pixType, x, y, z, c, t, -1, false, -1, false, -1); 
    11271126    ImagePlus[] imps = null; 
    1128      
     1127 
    11291128    try { 
    11301129      imps = BF.openImagePlus(path); 
     
    11361135      fail(e.getMessage()); 
    11371136    } 
    1138      
     1137 
    11391138    impsCountTest(imps,1); 
    11401139 
    11411140    ImagePlus imp = imps[0]; 
    1142      
     1141 
    11431142    xyzctTest(imp,x,y,z,c,t); 
    11441143  } 
    1145    
     1144 
    11461145  /** tests BF's options.setStackOrder() */ 
    11471146  private void outputStackOrderTester(boolean virtual, int pixType, ChannelOrder order, int x, int y, int z, int c, int t) 
     
    11491148    String bfChOrder = bfChanOrd(order); 
    11501149    String chOrder = order.toString(); 
    1151      
     1150 
    11521151    String path = constructFakeFilename("stack", pixType, x, y, z, c, t, -1, false, -1, false, -1); 
    1153      
     1152 
    11541153    ImagePlus[] imps = null; 
    11551154    try { 
     
    11681167 
    11691168    impsCountTest(imps,1); 
    1170      
     1169 
    11711170    ImagePlus imp = imps[0]; 
    1172      
     1171 
    11731172    xyzctTest(imp,x,y,z,c,t); 
    11741173 
    11751174    stackTest(imp,z*c*t); 
    1176      
     1175 
    11771176    stackInSpecificOrderTest(imp, chOrder); 
    11781177  } 
     
    11841183 
    11851184    ImagePlus[] imps = null; 
    1186      
     1185 
    11871186    try { 
    11881187      ImporterOptions options = new ImporterOptions(); 
     
    11991198      fail(e.getMessage()); 
    12001199    } 
    1201      
     1200 
    12021201    impsCountTest(imps,1); 
    1203      
     1202 
    12041203    xyzctTest(imps[0], FAKE_SIZE_X, FAKE_SIZE_Y, FAKE_PLANE_COUNT, FAKE_CHANNEL_COUNT, FAKE_TIMEPOINT_COUNT); 
    1205    
     1204 
    12061205    groupedFilesTest(imps[0], FAKE_PLANE_COUNT, FAKE_CHANNEL_COUNT, FAKE_TIMEPOINT_COUNT); 
    12071206  } 
    1208    
     1207 
    12091208  /** tests BF's options.setUngroupFiles() */ 
    12101209  private void datsetOpenFilesIndividuallyTester(boolean virtual) 
    12111210  { 
    12121211    // TODO - try to remove file dependency 
    1213      
     1212 
    12141213    String path = "2channel_stack_raw01.pic"; 
    1215      
     1214 
    12161215    // there is a second file called "2channel_stack_raw02.pic" present in the same directory 
    12171216    // if open indiv true should only load one of them, otherwise both 
    1218      
     1217 
    12191218    // try ungrouped 
    1220      
     1219 
    12211220    ImagePlus[] imps = null; 
    1222      
     1221 
    12231222    try { 
    12241223      ImporterOptions options = new ImporterOptions(); 
     
    12341233      fail(e.getMessage()); 
    12351234    } 
    1236      
     1235 
    12371236    // test results 
    1238      
     1237 
    12391238    impsCountTest(imps,1); 
    1240      
     1239 
    12411240    stackTest(imps[0],16); // one loaded as one set with 16 slices 
    1242      
     1241 
    12431242    // try grouped 
    1244      
     1243 
    12451244    try { 
    12461245      ImporterOptions options = new ImporterOptions(); 
     
    12581257 
    12591258    // test results 
    1260      
     1259 
    12611260    impsCountTest(imps,1); 
    1262      
     1261 
    12631262    stackTest(imps[0],32); // both loaded as one set of 32 slices 
    12641263  } 
     
    12701269    int c = 3; 
    12711270    ChannelOrder swappedOrder = ChannelOrder.TCZ; // original order is ZCT 
    1272      
     1271 
    12731272    String path = constructFakeFilename("swapDims", pixType, x, y, z, c, t, -1, false, -1, false, -1); 
    12741273 
    12751274    ImagePlus[] imps = null; 
    1276      
     1275 
    12771276    try { 
    12781277      ImporterOptions options = new ImporterOptions(); 
     
    12931292 
    12941293    ImagePlus imp = imps[0]; 
    1295      
     1294 
    12961295    xyzctTest(imp,x,y,t,c,z); // Z<->T swapped 
    12971296 
     
    13031302  { 
    13041303    ImagePlus[] imps = null; 
    1305      
     1304 
    13061305    try { 
    13071306      ImporterOptions options = new ImporterOptions(); 
     
    13171316      fail(e.getMessage()); 
    13181317    } 
    1319      
     1318 
    13201319    return imps; 
    13211320  } 
    1322    
     1321 
    13231322  /** tests BF's options.setOpenAllSeries() */ 
    13241323  private void datasetOpenAllSeriesTester(boolean virtual, boolean openAll) 
    13251324  { 
    13261325    int x = 55, y = 20, z = 2, c = 3, t = 4, numSeries = 5; 
    1327      
     1326 
    13281327    String path = constructFakeFilename("openAllSeries", FormatTools.UINT32, x, y, z, c, t, numSeries, false, -1, false, -1); 
    1329      
     1328 
    13301329    int expectedNumImps = 1; 
    13311330    if (openAll) 
    13321331      expectedNumImps = numSeries; 
    1333      
     1332 
    13341333    ImagePlus[] imps = openSeriesTest(path,virtual,openAll); 
    13351334    impsCountTest(imps,expectedNumImps); 
     
    13371336      xyzctTest(imps[i],x,y,z,c,t); 
    13381337  } 
    1339    
     1338 
    13401339  /** tests BF's options.setOpenAllSeries() and options.setConcatenate() */ 
    13411340  private void datasetConcatenateTester(int pixType, int x, int y, int z, int c, int t, int s) 
    13421341  { 
    13431342    assertTrue(s >= 1);  // necessary for this test 
    1344      
     1343 
    13451344    // open all series as one 
    1346      
     1345 
    13471346    String path = constructFakeFilename("concat", pixType, x, y, z, c, t, s, false, -1, false, -1); 
    1348      
     1347 
    13491348    ImagePlus[] imps = null; 
    1350      
     1349 
    13511350    try { 
    13521351      ImporterOptions options = new ImporterOptions(); 
     
    13641363 
    13651364    // test results 
    1366      
     1365 
    13671366    impsCountTest(imps,1); 
    13681367 
    13691368    ImagePlus imp = imps[0]; 
    1370      
     1369 
    13711370    // with FakeFiles all dims compatible for concat, BF will concat along T. Thus t*s in next test. 
    13721371    xyzctTest(imp,x,y,z,c,t*s); 
    1373      
     1372 
    13741373    multipleSeriesInCztOrderTest(imp,s,z,c,t); 
    13751374  } 
    1376    
     1375 
    13771376  /** tests BF's options.setAutoscale() */ 
    13781377  private void autoscaleTester(int pixType, boolean wantAutoscale) 
     
    13821381    if ((pixType == FormatTools.UINT8) && (wantAutoscale)) 
    13831382      if (DEBUG) log("  broken case"); 
    1384      
     1383 
    13851384    final int sizeZ = 2, sizeC = 3, sizeT = 4, sizeX = 51, sizeY = 16; 
    13861385    final String path = constructFakeFilename("autoscale",pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, -1, false, -1, false, -1); 
    1387      
     1386 
    13881387    ImagePlus[] imps = null; 
    1389      
     1388 
    13901389    try { 
    13911390      ImporterOptions options = new ImporterOptions(); 
     
    14001399      fail(e.getMessage()); 
    14011400    } 
    1402      
     1401 
    14031402    impsCountTest(imps,1); 
    1404      
     1403 
    14051404    ImagePlus imp = imps[0]; 
    14061405 
    14071406    xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,sizeT); 
    1408      
     1407 
    14091408    stackTest(imp,sizeZ*sizeC*sizeT); 
    14101409 
    14111410    calibrationTest(imp,pixType); 
    1412      
     1411 
    14131412    long maxPixVal = minPixelValue(pixType)+sizeX-1; 
    14141413    long maxIndex = sizeZ*sizeC*sizeT - 1; 
    1415      
     1414 
    14161415    long expectedMax = expectedMax(pixType,wantAutoscale,maxPixVal,maxIndex); 
    14171416    long expectedMin = expectedMin(pixType,wantAutoscale); 
    1418      
     1417 
    14191418    minMaxTest(imp,expectedMin,expectedMax); 
    14201419  } 
    1421    
     1420 
    14221421  private void ascendingValuesTest(byte[] data, int expectedLength) 
    14231422  { 
     
    14261425      assertEquals(i,data[i]&0xff); 
    14271426  } 
    1428    
     1427 
    14291428  // TODO : can I replace all calls to this to colorTests() passing numChannels == 1. Another way: modify lutTest() to 
    14301429  //   use a standard ImagePlus rather than a CompImg and have it call getColorTable(). Then pass in just RED ramped 
     
    14351434    // Therefore it creates a one channel ImagePlus with a LUT that only ramps the red channel. Test this to be 
    14361435    // the case. 
    1437      
     1436 
    14381437    assertFalse(imp instanceof CompositeImage); 
    1439      
     1438 
    14401439    if (indexed) 
    14411440    { 
     
    14441443        ; 
    14451444    } 
    1446      
     1445 
    14471446    LUT lut = getColorTable(imp,0); 
    1448      
     1447 
    14491448    byte[] data = new byte[256]; 
    1450      
     1449 
    14511450    if (color.getRed() > 0) 
    14521451    { 
     
    14651464    } 
    14661465  } 
    1467    
     1466 
    14681467  /** tests BF's options.setColorMode(composite) */ 
    14691468  private void colorDefaultTester(boolean virtual, int pixType, boolean indexed, int channels, int chanPerPlane, 
     
    14721471    if (DEBUG) log("colorDefaultTester(): pixType "+FormatTools.getPixelTypeString(pixType)+" indexed "+indexed+" channels "+ 
    14731472        channels+" chanPerPlane "+chanPerPlane+" falseColor "+falseColor+" numSeries "+numSeries+" defineLut "+wantLutDefined); 
    1474      
     1473 
    14751474    int sizeX = 55, sizeY = 71, sizeZ = 3, sizeT = 4; 
    1476      
     1475 
    14771476    // reportedly works in BF as long as numSeries*sizeC*3 <= 25 
    1478      
     1477 
    14791478    String path = constructFakeFilename("colorDefault", pixType, sizeX, sizeY, sizeZ, channels, sizeT, numSeries, 
    14801479        indexed, chanPerPlane, falseColor, -1); 
    1481      
     1480 
    14821481    ImagePlus[] imps = null; 
    1483      
     1482 
    14841483    try { 
    14851484      ImporterOptions options = new ImporterOptions(); 
     
    15021501 
    15031502    impsCountTest(imps,1); 
    1504      
     1503 
    15051504    ImagePlus imp = imps[0]; 
    15061505 
    15071506    int lutLen = 3; 
    1508      
     1507 
    15091508    int expectedSizeC = effectiveC(channels, chanPerPlane, lutLen, indexed, falseColor); 
    1510     
     1509 
    15111510    xyzctTest(imp,sizeX,sizeY,sizeZ,expectedSizeC,sizeT); 
    1512      
     1511 
    15131512    if ((expectedSizeC >= 2) && (expectedSizeC <= 7)) 
    15141513    { 
    15151514      assertTrue(imp.isComposite()); 
    1516        
     1515 
    15171516      CompositeImage ci = (CompositeImage)imp; 
    1518        
     1517 
    15191518      assertFalse(ci.hasCustomLuts()); 
    15201519 
     
    15381537        colorOrder = DEFAULT_COLOR_ORDER; 
    15391538      } 
    1540        
     1539 
    15411540      assertEquals(expectedType, ci.getMode()); 
    15421541      colorTests(ci,expectedSizeC,colorOrder); 
     
    15481547      imagePlusLutTest(imp,indexed,falseColor,DEFAULT_COLOR_ORDER[0]); 
    15491548    } 
    1550      
    1551     stackInCztOrderTest(imp,sizeZ,expectedSizeC,sizeT,indexed,falseColor,channels,chanPerPlane); 
    1552      
     1549 
     1550    stackInCztOrderTest(imp,sizeZ,expectedSizeC,sizeT,indexed,falseColor); 
     1551 
    15531552    // TODO : i've done no pixel testing 
    15541553  } 
    1555    
     1554 
    15561555  /** tests BF's options.setColorMode(composite) */ 
    15571556  private void colorCompositeTester(boolean virtual, int pixType, boolean indexed, int channels, int chanPerPlane, 
     
    15591558  { 
    15601559    if (DEBUG) log("colorCompositeTester(): pixType "+FormatTools.getPixelTypeString(pixType)+" indexed "+indexed+" channels "+channels+" chanPerPlane "+chanPerPlane+" falseColor "+falseColor+" numSeries "+numSeries); 
    1561      
     1560 
    15621561    int sizeX = 55, sizeY = 71, sizeZ = 3, sizeT = 4; 
    1563      
     1562 
    15641563    // reportedly works in BF as long as numSeries*sizeC*3 <= 25 
    1565      
     1564 
    15661565    String path = constructFakeFilename("colorComposite", pixType, sizeX, sizeY, sizeZ, channels, sizeT, numSeries, 
    15671566        indexed, chanPerPlane, falseColor, -1); 
    1568      
     1567 
    15691568    ImagePlus[] imps = null; 
    1570      
     1569 
    15711570    try { 
    15721571      ImporterOptions options = new ImporterOptions(); 
     
    15841583 
    15851584    impsCountTest(imps,1); 
    1586      
     1585 
    15871586    ImagePlus imp = imps[0]; 
    15881587 
    15891588    int lutLen = 3; 
    1590      
     1589 
    15911590    int expectedSizeC = effectiveC(channels, chanPerPlane, lutLen, indexed, falseColor); 
    1592     
     1591 
    15931592    xyzctTest(imp,sizeX,sizeY,sizeZ,expectedSizeC,sizeT); 
    1594      
     1593 
    15951594    if ((expectedSizeC >= 2) && (expectedSizeC <= 7)) 
    15961595    { 
    15971596      assertTrue(imp.isComposite()); 
    1598        
     1597 
    15991598      CompositeImage ci = (CompositeImage)imp; 
    1600        
     1599 
    16011600      assertFalse(ci.hasCustomLuts()); 
    16021601 
    16031602      assertEquals(CompositeImage.COMPOSITE, ci.getMode()); 
    1604        
     1603 
    16051604      colorTests(ci,expectedSizeC,DEFAULT_COLOR_ORDER); 
    16061605    } 
     
    16111610      imagePlusLutTest(imp,indexed,falseColor,DEFAULT_COLOR_ORDER[0]); 
    16121611    } 
    1613      
    1614     stackInCztOrderTest(imp,sizeZ,expectedSizeC,sizeT,indexed,falseColor,channels,chanPerPlane); 
    1615      
     1612 
     1613    stackInCztOrderTest(imp,sizeZ,expectedSizeC,sizeT,indexed,falseColor); 
     1614 
    16161615    // TODO : i've done no pixel testing 
    16171616  } 
     
    16221621  { 
    16231622    if (DEBUG) log("colorColorizedTester(): pixType "+FormatTools.getPixelTypeString(pixType)+" indexed "+indexed+" channels "+channels+" chanPerPlane "+chanPerPlane+" falseColor "+falseColor+" numSeries "+numSeries); 
    1624      
     1623 
    16251624    int sizeX = 55, sizeY = 71, sizeZ = 3, sizeT = 4; 
    1626      
     1625 
    16271626    String path = constructFakeFilename("colorColorized", pixType, sizeX, sizeY, sizeZ, channels, sizeT, numSeries, 
    16281627        indexed, chanPerPlane, falseColor, -1); 
    1629      
     1628 
    16301629    ImagePlus[] imps = null; 
    1631      
     1630 
    16321631    try { 
    16331632      ImporterOptions options = new ImporterOptions(); 
     
    16461645 
    16471646    impsCountTest(imps,1); 
    1648      
     1647 
    16491648    ImagePlus imp = imps[0]; 
    16501649 
    16511650    int lutLen = 3; 
    1652      
     1651 
    16531652    int expectedSizeC = effectiveC(channels, chanPerPlane, lutLen, indexed, falseColor); 
    1654     
     1653 
    16551654    xyzctTest(imp,sizeX,sizeY,sizeZ,expectedSizeC,sizeT); 
    1656      
     1655 
    16571656    if ((expectedSizeC >= 2) && (expectedSizeC <= 7)) 
    16581657    { 
    16591658      assertTrue(imp.isComposite()); 
    1660        
     1659 
    16611660      CompositeImage ci = (CompositeImage)imp; 
    1662        
     1661 
    16631662      assertFalse(ci.hasCustomLuts()); 
    16641663 
    16651664      assertEquals(CompositeImage.COLOR, ci.getMode()); 
    1666        
     1665 
    16671666      colorTests(ci,expectedSizeC,DEFAULT_COLOR_ORDER); 
    16681667    } 
     
    16731672      imagePlusLutTest(imp,indexed,falseColor,DEFAULT_COLOR_ORDER[0]); 
    16741673    } 
    1675      
    1676     stackInCztOrderTest(imp,sizeZ,expectedSizeC,sizeT,indexed,falseColor,channels,chanPerPlane); 
    1677      
     1674 
     1675    stackInCztOrderTest(imp,sizeZ,expectedSizeC,sizeT,indexed,falseColor); 
     1676 
    16781677    // TODO : i've done no pixel testing 
    16791678  } 
     
    16841683  { 
    16851684    if (DEBUG) log("colorGrayscaleTester(): pixType "+FormatTools.getPixelTypeString(pixType)+" indexed "+indexed+" channels "+channels+" chanPerPlane "+chanPerPlane+" falseColor "+falseColor+" numSeries "+numSeries); 
    1686    
     1685 
    16871686    int sizeX = 55, sizeY = 71, sizeZ = 3, sizeT = 4; 
    1688    
     1687 
    16891688    String path = constructFakeFilename("colorGrayscale", pixType, sizeX, sizeY, sizeZ, channels, sizeT, numSeries, 
    16901689    indexed, chanPerPlane, falseColor, -1); 
    1691    
     1690 
    16921691    ImagePlus[] imps = null; 
    1693    
     1692 
    16941693    try { 
    16951694      ImporterOptions options = new ImporterOptions(); 
     
    17051704      fail(e.getMessage()); 
    17061705    } 
    1707    
     1706 
    17081707    impsCountTest(imps,1); 
    1709    
     1708 
    17101709    ImagePlus imp = imps[0]; 
    1711    
     1710 
    17121711    int lutLen = 3; 
    1713    
     1712 
    17141713    int expectedSizeC = effectiveC(channels, chanPerPlane, lutLen, indexed, falseColor); 
    1715    
     1714 
    17161715    xyzctTest(imp,sizeX,sizeY,sizeZ,expectedSizeC,sizeT); 
    1717    
     1716 
    17181717    if ((expectedSizeC >= 2) && (expectedSizeC <= 7)) 
    17191718    { 
    17201719      assertTrue(imp.isComposite()); 
    1721    
     1720 
    17221721      CompositeImage ci = (CompositeImage)imp; 
    1723    
     1722 
    17241723      assertFalse(ci.hasCustomLuts()); 
    1725    
     1724 
    17261725      assertEquals(CompositeImage.GRAYSCALE, ci.getMode()); 
    1727    
     1726 
    17281727      colorTests(ci,expectedSizeC,DEFAULT_COLOR_ORDER); 
    17291728    } 
     
    17311730    { 
    17321731      assertFalse(imp.isComposite()); 
    1733    
     1732 
    17341733      imagePlusLutTest(imp,indexed,falseColor,DEFAULT_COLOR_ORDER[0]); 
    17351734    } 
    1736    
    1737     stackInCztOrderTest(imp,sizeZ,expectedSizeC,sizeT,indexed,falseColor,channels,chanPerPlane); 
    1738    
     1735 
     1736    stackInCztOrderTest(imp,sizeZ,expectedSizeC,sizeT,indexed,falseColor); 
     1737 
    17391738    // TODO : i've done no pixel testing 
    17401739  } 
     
    17451744  { 
    17461745    if (DEBUG) log("colorCustomTester(): pixType "+FormatTools.getPixelTypeString(pixType)+" indexed "+indexed+" channels "+channels+" chanPerPlane "+chanPerPlane+" falseColor "+falseColor+" numSeries "+numSeries); 
    1747    
     1746 
    17481747    int sizeX = 55, sizeY = 71, sizeZ = 3, sizeT = 4; 
    1749    
     1748 
    17501749    String path = constructFakeFilename("colorCustom", pixType, sizeX, sizeY, sizeZ, channels, sizeT, numSeries, 
    17511750    indexed, chanPerPlane, falseColor, -1); 
    1752    
     1751 
    17531752    ImagePlus[] imps = null; 
    1754    
     1753 
    17551754    try { 
    17561755      ImporterOptions options = new ImporterOptions(); 
     
    17701769      fail(e.getMessage()); 
    17711770    } 
    1772    
     1771 
    17731772    impsCountTest(imps,1); 
    1774    
     1773 
    17751774    ImagePlus imp = imps[0]; 
    1776    
     1775 
    17771776    int lutLen = 3; 
    1778    
     1777 
    17791778    int expectedSizeC = effectiveC(channels, chanPerPlane, lutLen, indexed, falseColor); 
    1780    
     1779 
    17811780    xyzctTest(imp,sizeX,sizeY,sizeZ,expectedSizeC,sizeT); 
    1782    
     1781 
    17831782    if ((expectedSizeC >= 2) && (expectedSizeC <= 7)) 
    17841783    { 
    17851784      assertTrue(imp.isComposite()); 
    1786    
     1785 
    17871786      CompositeImage ci = (CompositeImage)imp; 
    1788    
     1787 
    17891788      assertFalse(ci.hasCustomLuts()); 
    1790    
     1789 
    17911790      assertEquals(CompositeImage.COLOR, ci.getMode()); 
    1792    
     1791 
    17931792      colorTests(ci,expectedSizeC,CUSTOM_COLOR_ORDER); 
    17941793    } 
     
    17961795    { 
    17971796      assertFalse(imp.isComposite()); 
    1798    
     1797 
    17991798      imagePlusLutTest(imp,indexed,falseColor,CUSTOM_COLOR_ORDER[0]); 
    18001799    } 
    1801    
    1802     stackInCztOrderTest(imp,sizeZ,expectedSizeC,sizeT,indexed,falseColor,channels,chanPerPlane); 
    1803    
     1800 
     1801    stackInCztOrderTest(imp,sizeZ,expectedSizeC,sizeT,indexed,falseColor); 
     1802 
    18041803    // TODO : i've done no pixel testing 
    18051804  } 
    1806    
     1805 
    18071806  /** tests BF's options.setVirtual() */ 
    18081807  private void memoryVirtualStackTester(boolean desireVirtual) 
    18091808  { 
    18101809      int x = 604, y = 531, z = 7, c = 1, t = 1; 
    1811        
     1810 
    18121811      String path = constructFakeFilename("vstack", FormatTools.UINT16, x, y, z, c, t, -1, false, -1, false, -1); 
    1813        
     1812 
    18141813      // open stack 
    18151814      ImagePlus[] imps = null; 
    1816      
     1815 
    18171816      try { 
    18181817        ImporterOptions options = new ImporterOptions(); 
     
    18271826        fail(e.getMessage()); 
    18281827      } 
    1829    
     1828 
    18301829      // test results 
    18311830      impsCountTest(imps,1); 
    1832        
     1831 
    18331832      ImagePlus imp = imps[0]; 
    1834        
     1833 
    18351834      xyzctTest(imp,x,y,z,c,t); 
    1836    
     1835 
    18371836      assertEquals(desireVirtual,imp.getStack().isVirtual()); 
    18381837  } 
    18391838 
    18401839  /** tests BF's options.setVirtual() with options.setRecord() */ 
     1840  /* TODO - underlying BF code is not working. Comment out for now 
    18411841  private void memoryRecordModificationsTester(boolean wantToRemember) 
    18421842  { 
    18431843    int x = 50, y = 15, z = 3, c = 1, t = 1; 
    1844      
     1844 
    18451845    String path = constructFakeFilename("memRec", FormatTools.UINT8, x, y, z, c, t, -1, false, -1, false, -1); 
    1846      
     1846 
    18471847    ImagePlus[] imps = null; 
    1848      
     1848 
    18491849    assertTrue(y > 10);  // needed for this test 
    18501850    assertTrue(z > 1); 
    1851      
     1851 
    18521852    // open file 
    18531853    try { 
     
    18671867    // basic tests 
    18681868    impsCountTest(imps,1); 
    1869      
     1869 
    18701870    ImagePlus imp = imps[0]; 
    1871      
     1871 
    18721872    xyzctTest(imp,x,y,z,c,t); 
    18731873 
     
    18811881    IJ.run("Invert","slice"); 
    18821882    assertEquals(254,(int)imp.getProcessor().getPixelValue(1,10)); 
    1883      
     1883 
    18841884    imp.setSlice(2); 
    18851885    assertEquals(1,(int)imp.getProcessor().getPixelValue(1,10)); 
    1886      
     1886 
    18871887    imp.setSlice(1); 
    18881888    int expectedVal = wantToRemember ? 254 : 1; 
    18891889    assertEquals(expectedVal,(int)imp.getProcessor().getPixelValue(1,10)); 
    18901890  } 
    1891    
     1891  */ 
     1892 
    18921893  /** tests BF's options.set?Begin(), options.set?End(), and options.set?Step() */ 
    18931894  private void memorySpecifyRangeTester(int z, int c, int t, 
     
    18951896      int cFrom, int cTo, int cBy, 
    18961897      int tFrom, int tTo, int tBy) 
    1897   {  
     1898  { 
    18981899    int pixType = FormatTools.UINT8, x=50, y=5; 
    18991900 
    19001901    String path = constructFakeFilename("range", pixType, x, y, z, c, t, -1, false, -1, false, -1); 
    1901      
     1902 
    19021903    ImagePlus[] imps = null; 
    19031904 
     
    19051906      ImporterOptions options = new ImporterOptions(); 
    19061907      options.setId(path); 
    1907        
     1908 
    19081909      // only set values when nondefault behavior specified 
    1909        
     1910 
    19101911      // z's 
    19111912      if (zFrom != 0) 
     
    19151916      if (zBy != 1) 
    19161917        options.setZStep(0, zBy); 
    1917        
     1918 
    19181919      // c's 
    19191920      if (cFrom != 0) 
     
    19231924      if (cBy != 1) 
    19241925        options.setCStep(0, cBy); 
    1925        
     1926 
    19261927      // t's 
    19271928      if (tFrom != 0) 
     
    19311932      if (tBy != 1) 
    19321933        options.setTStep(0, tBy); 
    1933          
     1934 
    19341935      imps = BF.openImagePlus(options); 
    19351936    } 
     
    19401941      fail(e.getMessage()); 
    19411942    } 
    1942      
     1943 
    19431944    // should have the data in one series 
    19441945    impsCountTest(imps,1); 
    1945      
     1946 
    19461947    ImagePlus imp = imps[0]; 
    1947      
     1948 
    19481949    xyzctTest(imp,x,y,numInSeries(zFrom,zTo,zBy),numInSeries(cFrom,cTo,cBy),numInSeries(tFrom,tTo,tBy)); 
    19491950 
     
    19511952    seriesInZctOrderTest(imp,false,false,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    19521953  } 
    1953    
     1954 
    19541955  /** tests BF's options.setCrop() and options.setCropRegion() */ 
    19551956  private void memoryCropTester(int x, int y, int ox, int oy, int cropSize) 
     
    19581959 
    19591960    String path = constructFakeFilename("crop", FormatTools.UINT8, x, y, 1, 1, 1, -1, false, -1, false, -1); 
    1960      
     1961 
    19611962    // open image 
    19621963    ImagePlus[] imps = null; 
    1963      
     1964 
    19641965    try { 
    19651966      ImporterOptions options = new ImporterOptions(); 
     
    19801981 
    19811982    ImagePlus imp = imps[0]; 
    1982      
     1983 
    19831984    xyzctTest(imp,cropSize,cropSize,1,1,1); 
    1984      
     1985 
    19851986    // test we got the right pixels 
    19861987    croppedPixelsTest(imp,ox,cropSize); 
     
    19971998    // open image 
    19981999    ImagePlus[] imps = null; 
    1999      
     2000 
    20002001    try { 
    20012002      ImporterOptions options = new ImporterOptions(); 
     
    20132014    // one image per channel 
    20142015    impsCountTest(imps,sizeC); 
    2015      
     2016 
    20162017    imagesCInZtOrderTest(imps,sizeX,sizeY,sizeZ,sizeC,sizeT); 
    20172018  } 
     
    20212022  { 
    20222023    final int sizeX = 50, sizeY = 20, sizeZ = 5, sizeC = 3, sizeT = 7; 
    2023      
     2024 
    20242025    final String path = constructFakeFilename("splitZ", 
    20252026      FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, -1, false, -1, false, -1); 
     
    20272028    // open image 
    20282029    ImagePlus[] imps = null; 
    2029      
     2030 
    20302031    try { 
    20312032      ImporterOptions options = new ImporterOptions(); 
     
    20402041      fail(e.getMessage()); 
    20412042    } 
    2042      
     2043 
    20432044    // one image per focal plane 
    20442045    impsCountTest(imps,sizeZ); 
     
    20462047    imagesZInCtOrderTest(imps,sizeX,sizeY,sizeZ,sizeC,sizeT); 
    20472048  } 
    2048    
     2049 
    20492050  /** tests BF's options.setSplitTimepoints() */ 
    20502051  private void splitTimepointsTester() 
    20512052  { 
    20522053    final int sizeX = 50, sizeY = 20, sizeZ = 5, sizeC = 3, sizeT = 7; 
    2053    
     2054 
    20542055    final String path = constructFakeFilename("splitT", 
    20552056      FormatTools.UINT8, 50, 20, sizeZ, sizeC, sizeT, -1, false, -1, false, -1); 
     
    20572058    // open image 
    20582059    ImagePlus[] imps = null; 
    2059      
     2060 
    20602061    try { 
    20612062      ImporterOptions options = new ImporterOptions(); 
     
    20702071      fail(e.getMessage()); 
    20712072    } 
    2072      
     2073 
    20732074    // one image per time point 
    20742075    impsCountTest(imps,sizeT); 
     
    20782079 
    20792080  // note - this test needs to rely on crop() to get predictable nonzero minimums 
    2080    
     2081 
    20812082  /** tests BF's options.setCrop() and options.setCropRegion() with options.setAutoscale() */ 
    20822083  private void comboCropAndAutoscaleTester(int pixType, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT, 
     
    20842085  { 
    20852086    final String path = constructFakeFilename("cropAutoscale",pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, -1, false, -1, false, -1); 
    2086      
     2087 
    20872088    // needed for this test 
    20882089    verifyCropInput(sizeX,sizeY,originCropX,originCropY,sizeCrop); 
    2089      
     2090 
    20902091    ImagePlus[] imps = null; 
    2091      
     2092 
    20922093    try { 
    20932094      ImporterOptions options = new ImporterOptions(); 
     
    21042105      fail(e.getMessage()); 
    21052106    } 
    2106      
     2107 
    21072108    impsCountTest(imps,1); 
    2108      
     2109 
    21092110    ImagePlus imp = imps[0]; 
    2110      
     2111 
    21112112    xyzctTest(imps[0],sizeCrop,sizeCrop,sizeZ,sizeC,sizeT); 
    21122113 
    21132114    stackTest(imp,(sizeZ*sizeC*sizeT)); 
    2114      
     2115 
    21152116    calibrationTest(imp,pixType); 
    2116      
     2117 
    21172118    long expectedMax = minPixelValue(pixType) + originCropX + sizeCrop - 1; 
    21182119    long expectedMin = minPixelValue(pixType) + originCropX; 
     
    21302131      minMaxTest(imp,expectedMin,expectedMax); 
    21312132  } 
    2132    
     2133 
    21332134  /** tests BF's options.setConcatenate() with options.setSplitFocalPlanes() */ 
    21342135  private void comboConcatSplitFocalPlanesTester() 
     
    21382139 
    21392140    final int sizeX = 50, sizeY = 20, sizeZ = 3, sizeC = 5, sizeT = 7, series = 4; 
    2140      
     2141 
    21412142    final String path = constructFakeFilename("concatSplitZ", 
    21422143      FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, series, false, -1, false, -1); 
     
    21592160      fail(e.getMessage()); 
    21602161    } 
    2161      
     2162 
    21622163    // one image per focal plane 
    21632164    impsCountTest(imps,sizeZ); 
     
    21652166    imageSeriesZInCtOrderTest(imps,series,sizeX,sizeY,sizeZ,sizeC,sizeT); 
    21662167  } 
    2167    
     2168 
    21682169  /** tests BF's options.setConcatenate() with options.setSplitChannels() */ 
    21692170  private void comboConcatSplitChannelsTester() 
     
    21732174 
    21742175    final int sizeX = 50, sizeY = 20, sizeZ = 3, sizeC = 5, sizeT = 7, series = 4; 
    2175      
     2176 
    21762177    final String path = constructFakeFilename("concatSplitC", 
    21772178      FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, series, false, -1, false, -1); 
     
    21792180    // open image 
    21802181    ImagePlus[] imps = null; 
    2181      
     2182 
    21822183    try { 
    21832184      ImporterOptions options = new ImporterOptions(); 
     
    21942195      fail(e.getMessage()); 
    21952196    } 
    2196      
     2197 
    21972198    // one image per channel 
    21982199    impsCountTest(imps,sizeC); 
    2199      
     2200 
    22002201    imageSeriesCInZtOrderTest(imps,series,sizeX,sizeY,sizeZ,sizeC,sizeT); 
    22012202  } 
    2202    
     2203 
    22032204  /** tests BF's options.setConcatenate() with options.setSplitTimepoints() */ 
    22042205  private void comboConcatSplitTimepointsTester() 
     
    22082209 
    22092210    final int sizeX = 50, sizeY = 20, sizeZ = 3, sizeC = 5, sizeT = 7, numSeries = 4; 
    2210    
     2211 
    22112212    final String path = constructFakeFilename("concatSplitT", 
    22122213      FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries, false, -1, false, -1); 
     
    22142215    // open image 
    22152216    ImagePlus[] imps = null; 
    2216      
     2217 
    22172218    try { 
    22182219      ImporterOptions options = new ImporterOptions(); 
     
    22292230      fail(e.getMessage()); 
    22302231    } 
    2231      
     2232 
    22322233    // numSeries images per timepoint 
    22332234    impsCountTest(imps,sizeT*numSeries); 
    2234      
     2235 
    22352236    imageSeriesTInCzOrderTest(imps,numSeries,sizeX,sizeY,sizeZ,sizeC,sizeT); 
    22362237  } 
    2237    
     2238 
    22382239  /** tests BF's options.setColormode(composite) - alternate, later definition */ 
    22392240  private void compositeSubcaseTester(int sizeC, boolean indexed) 
     
    22412242    int pixType = FormatTools.UINT8, sizeX = 60, sizeY = 30, sizeZ = 2, sizeT = 3, numSeries = 1, rgb = -1, lutLen = -1; 
    22422243    boolean falseColor = false; 
    2243      
     2244 
    22442245    String path = constructFakeFilename("colorComposite", pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries, indexed, 
    22452246                                          rgb, falseColor, lutLen); 
    22462247 
    22472248    ImagePlus[] imps = null; 
    2248      
     2249 
    22492250    try { 
    22502251      ImporterOptions options = new ImporterOptions(); 
     
    22612262 
    22622263    impsCountTest(imps,1); 
    2263      
     2264 
    22642265    ImagePlus imp = imps[0]; 
    22652266 
     
    22692270 
    22702271    CompositeImage ci = (CompositeImage)imp; 
    2271      
     2272 
    22722273    assertFalse(ci.hasCustomLuts()); 
    22732274 
    22742275    assertEquals(CompositeImage.COMPOSITE, ci.getMode()); 
    2275      
     2276 
    22762277    colorTests(ci,sizeC,DEFAULT_COLOR_ORDER); 
    2277        
     2278 
    22782279    stackInZctOrderTest(imp,sizeZ,sizeC,sizeT,indexed,falseColor); 
    2279      
     2280 
    22802281    pixelsTest(imp,pixType,indexed,falseColor); 
    22812282  } 
    2282    
     2283 
    22832284// ** ImporterTest methods ************************************************************** 
    22842285 
     
    23172318      datsetOpenFilesIndividuallyTester(virtual); 
    23182319  } 
    2319    
     2320 
    23202321  @Test 
    23212322  public void testDatasetSwapDims() 
     
    23532354  { 
    23542355    // NOTE: for now we will not use a virtual boolean with datasetConcatenateTester() as that combo not a legal one in BF 
    2355      
     2356 
    23562357    // open a dataset that has multiple series and should get back a single series 
    23572358    datasetConcatenateTester(FormatTools.UINT8, 82, 47, 1, 1, 1, 1); 
     
    23672368        for (boolean defineLutEntry : BOOLEAN_STATES) { 
    23682369      // these here to simplify debugging 
    2369    
     2370 
    23702371          // edge cases in number of channels nonindexed in one series 
    23712372          colorDefaultTester(virtual,pixType,NOT_INDEXED,1,1,REAL_COLOR,ONE_SERIES,defineLutEntry); 
     
    23732374          colorDefaultTester(virtual,pixType,NOT_INDEXED,7,7,REAL_COLOR,ONE_SERIES,defineLutEntry); 
    23742375          colorDefaultTester(virtual,pixType,NOT_INDEXED,8,8,REAL_COLOR,ONE_SERIES,defineLutEntry); 
    2375        
     2376 
    23762377          // edge cases in number of channels nonindexed in one series 
    23772378          colorDefaultTester(virtual,pixType,NOT_INDEXED,4,4,REAL_COLOR,ONE_SERIES,defineLutEntry); 
    23782379          colorDefaultTester(virtual,pixType,NOT_INDEXED,6,3,REAL_COLOR,ONE_SERIES,defineLutEntry); 
    23792380          colorDefaultTester(virtual,pixType,NOT_INDEXED,12,3,REAL_COLOR,ONE_SERIES,defineLutEntry); 
    2380        
     2381 
    23812382          // edge case : standard 3 chan planar layout 
    23822383          colorDefaultTester(virtual,pixType,NOT_INDEXED,3,1,REAL_COLOR,ONE_SERIES,defineLutEntry); 
    2383        
     2384 
    23842385          // edge case 1 channel indexed 
    23852386          // TODO - this one fails UINT8 before I used general pixTypes. With gen pix types indexed does not make sense. 
     
    23892390    } 
    23902391  } 
    2391    
     2392 
    23922393  @Test 
    23932394  public void testColorComposite() 
    23942395  { 
    23952396    for (boolean virtual : new boolean[]{false,true}) { 
    2396        
     2397 
    23972398      // these here to simplify debugging 
    2398    
     2399 
    23992400      // edge cases in number of channels nonindexed in one series 
    24002401      // TODO : next one fails when virtual true 
     
    24042405      // TODO : next one fails when virtual true 
    24052406      colorCompositeTester(virtual,FormatTools.UINT8,NOT_INDEXED,8,8,REAL_COLOR,ONE_SERIES); 
    2406    
     2407 
    24072408      // edge cases in number of channels nonindexed in one series 
    24082409      colorCompositeTester(virtual,FormatTools.UINT8,NOT_INDEXED,4,4,REAL_COLOR,ONE_SERIES); 
     
    24102411      // TODO : next one fails when virtual true 
    24112412      colorCompositeTester(virtual,FormatTools.UINT8,NOT_INDEXED,12,3,REAL_COLOR,ONE_SERIES); 
    2412    
     2413 
    24132414      // edge case : standard 3 chan planar layout 
    24142415      colorCompositeTester(virtual,FormatTools.UINT8,NOT_INDEXED,3,1,REAL_COLOR,ONE_SERIES); 
    2415    
     2416 
    24162417      // edge case 1 channel indexed 
    24172418      // TODO - this one fails. Actual czt vals back from code are all zeroes 2/3 of the time (1 chan goes to 3) 
    24182419      //colorCompositeTester(FormatTools.UINT8,INDEXED,1,1,REAL_COLOR,ONE_SERIES); 
    2419    
     2420 
    24202421      // general test loop 
    24212422      int[] pixTypes = new int[] {FormatTools.UINT8,FormatTools.UINT16}; 
     
    24232424      int[] series = new int[] {1,2,3,4}; 
    24242425      int[] channelsPerPlaneVals = new int[]{1,2,3}; 
    2425        
     2426 
    24262427      for (int pixFormat : pixTypes) { 
    24272428        for (int chanCount : channels) { 
     
    24302431              for (boolean indexed : new boolean[]{false}) {  // TODO - indexed not test right now : replace with BOOLEAN_STATES 
    24312432                for (boolean falseColor : BOOLEAN_STATES) { 
    2432    
     2433 
    24332434                  //if (DEBUG) log(" format "+pixFormat+"indexed "+indexed+" rgb "+rgb+" fasleColor "+falseColor+" c "+c+" s "+s); 
    2434                    
     2435 
    24352436                  // TODO see what happens when we remove this 
    24362437                  //if ((chanCount*numSeries*3) > 25)  // IJ slider limitation 
     
    24392440                  //  continue; 
    24402441                  //} 
    2441                    
     2442 
    24422443                  if (!indexed && falseColor)  // invalid combo - skip 
    24432444                    continue; 
    2444                    
     2445 
    24452446                  if ((chanCount % channelsPerPlane) != 0)  // invalid combo - skip 
    24462447                    continue; 
    2447                    
     2448 
    24482449                  colorCompositeTester(virtual,pixFormat,indexed,chanCount,channelsPerPlane,falseColor,numSeries); 
    24492450                } 
     
    24552456    } 
    24562457  } 
    2457    
     2458 
    24582459  @Test 
    24592460  public void testColorColorized() 
     
    24622463      for (boolean virtual : new boolean[]{false,true}) { 
    24632464        // these here to simplify debugging 
    2464      
     2465 
    24652466        // edge cases in number of channels nonindexed in one series 
    24662467        colorColorizedTester(virtual,pixType,NOT_INDEXED,1,1,REAL_COLOR,ONE_SERIES); 
     
    24682469        colorColorizedTester(virtual,pixType,NOT_INDEXED,7,7,REAL_COLOR,ONE_SERIES); 
    24692470        colorColorizedTester(virtual,pixType,NOT_INDEXED,8,8,REAL_COLOR,ONE_SERIES); 
    2470      
     2471 
    24712472        // edge cases in number of channels nonindexed in one series 
    24722473        colorColorizedTester(virtual,pixType,NOT_INDEXED,4,4,REAL_COLOR,ONE_SERIES); 
    24732474        colorColorizedTester(virtual,pixType,NOT_INDEXED,6,3,REAL_COLOR,ONE_SERIES); 
    24742475        colorColorizedTester(virtual,pixType,NOT_INDEXED,12,3,REAL_COLOR,ONE_SERIES); 
    2475      
     2476 
    24762477        // edge case : standard 3 chan planar layout 
    24772478        colorColorizedTester(virtual,pixType,NOT_INDEXED,3,1,REAL_COLOR,ONE_SERIES); 
    2478      
     2479 
    24792480        // edge case 1 channel indexed 
    24802481        // TODO - this one fails UINT8 before I used general pixTypes. With gen pix types indexed does not make sense. 
     
    24832484    } 
    24842485  } 
    2485    
     2486 
    24862487  @Test 
    24872488  public void testColorGrayscale() 
     
    24902491      for (boolean virtual : new boolean[]{false,true}) { 
    24912492        // these here to simplify debugging 
    2492      
     2493 
    24932494        // edge cases in number of channels nonindexed in one series 
    24942495        colorGrayscaleTester(virtual,pixType,NOT_INDEXED,1,1,REAL_COLOR,ONE_SERIES); 
     
    24962497        colorGrayscaleTester(virtual,pixType,NOT_INDEXED,7,7,REAL_COLOR,ONE_SERIES); 
    24972498        colorGrayscaleTester(virtual,pixType,NOT_INDEXED,8,8,REAL_COLOR,ONE_SERIES); 
    2498      
     2499 
    24992500        // edge cases in number of channels nonindexed in one series 
    25002501        colorGrayscaleTester(virtual,pixType,NOT_INDEXED,4,4,REAL_COLOR,ONE_SERIES); 
    25012502        colorGrayscaleTester(virtual,pixType,NOT_INDEXED,6,3,REAL_COLOR,ONE_SERIES); 
    25022503        colorGrayscaleTester(virtual,pixType,NOT_INDEXED,12,3,REAL_COLOR,ONE_SERIES); 
    2503      
     2504 
    25042505        // edge case : standard 3 chan planar layout 
    25052506        colorGrayscaleTester(virtual,pixType,NOT_INDEXED,3,1,REAL_COLOR,ONE_SERIES); 
    2506      
     2507 
    25072508        // edge case 1 channel indexed 
    25082509        // TODO - this one fails UINT8 before I used general pixTypes. With gen pix types indexed does not make sense. 
     
    25112512    } 
    25122513  } 
    2513    
     2514 
    25142515  @Test 
    25152516  public void testColorCustom() 
     
    25182519      for (boolean virtual : new boolean[]{false,true}) { 
    25192520        // these here to simplify debugging 
    2520      
     2521 
    25212522        // edge cases in number of channels nonindexed in one series 
    25222523        colorCustomTester(virtual,pixType,NOT_INDEXED,1,1,REAL_COLOR,ONE_SERIES); 
     
    25242525        colorCustomTester(virtual,pixType,NOT_INDEXED,7,7,REAL_COLOR,ONE_SERIES); 
    25252526        colorCustomTester(virtual,pixType,NOT_INDEXED,8,8,REAL_COLOR,ONE_SERIES); 
    2526      
     2527 
    25272528        // edge cases in number of channels nonindexed in one series 
    25282529        colorCustomTester(virtual,pixType,NOT_INDEXED,4,4,REAL_COLOR,ONE_SERIES); 
    25292530        colorCustomTester(virtual,pixType,NOT_INDEXED,6,3,REAL_COLOR,ONE_SERIES); 
    25302531        colorCustomTester(virtual,pixType,NOT_INDEXED,12,3,REAL_COLOR,ONE_SERIES); 
    2531      
     2532 
    25322533        // edge case : standard 3 chan planar layout 
    25332534        colorCustomTester(virtual,pixType,NOT_INDEXED,3,1,REAL_COLOR,ONE_SERIES); 
    2534      
     2535 
    25352536        // edge case 1 channel indexed 
    25362537        // TODO - this one fails UINT8 before I used general pixTypes. With gen pix types indexed does not make sense. 
     
    25392540    } 
    25402541 
    2541     /* old way     
     2542    /* old way 
    25422543    int[] pixTypes = new int[]{FormatTools.UINT8, FormatTools.UINT16, FormatTools.FLOAT}; 
    25432544    int[] xs = new int[] {45}; 
     
    25472548    int[] ts = new int[] {1,2}; 
    25482549    int[] series = new int[] {1,2,3,4}; 
    2549      
     2550 
    25502551    for (int pixFormat : pixTypes) 
    25512552      for (int x : xs) 
     
    25622563    */ 
    25632564  } 
    2564    
     2565 
    25652566  @Test 
    25662567  public void testColorAutoscale() 
    25672568  { 
    25682569    // note - can't autoscale a virtualStack. No need to test it. 
    2569      
     2570 
    25702571    for (int pixType : PIXEL_TYPES) { 
    25712572      for (boolean autoscale : BOOLEAN_STATES) { 
    2572         log("testColorAutoscale(): pixType = "+FormatTools.getPixelTypeString(pixType)+" autoscale = "+autoscale); 
     2573        if (DEBUG) log("testColorAutoscale(): pixType = "+FormatTools.getPixelTypeString(pixType)+" autoscale = "+autoscale); 
    25732574        autoscaleTester(pixType,autoscale); 
    25742575      } 
     
    25842585 
    25852586/* TODO - underlying BF code is not working. Comment out for now 
    2586    
     2587 
    25872588  @Test 
    25882589  public void testMemoryRecordModifications() 
    25892590  { 
    25902591    // recordMemory has virtual always set to true. no need to do any other virtual testing 
    2591      
     2592 
    25922593    for (boolean rememberChanges : BOOLEAN_STATES) 
    25932594      memoryRecordModificationsTester(rememberChanges); 
    25942595  } 
    25952596*/ 
    2596    
     2597 
    25972598  @Test 
    25982599  public void testMemorySpecifyRange() 
    25992600  { 
    26002601    // note - can't specify range in a virtualStack - no need to test 
    2601      
     2602 
    26022603    int z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy; 
    26032604 
     
    26052606    z=8; c=3; t=2; zFrom=2; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
    26062607    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2607      
     2608 
    26082609    // test partial z: to 
    26092610    z=8; c=3; t=2; zFrom=0; zTo=4; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
     
    26172618    z=8; c=3; t=2; zFrom=2; zTo=7; zBy=3; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
    26182619    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2619      
     2620 
    26202621    // test partial c: from 
    26212622    z=6; c=14; t=4; zFrom=0; zTo=z-1; zBy=1; cFrom=3; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
    26222623    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2623      
     2624 
    26242625    // test partial c: to 
    26252626    z=6; c=14; t=4; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=6; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
    26262627    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2627      
     2628 
    26282629    // test partial c: by 
    26292630    z=6; c=14; t=4; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=4; tFrom=0; tTo=t-1; tBy=1; 
    26302631    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2631      
     2632 
    26322633    // test full c 
    26332634    z=6; c=14; t=4; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=12; cBy=4; tFrom=0; tTo=t-1; tBy=1; 
    26342635    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2635      
     2636 
    26362637    // test partial t: from 
    26372638    z=3; c=5; t=13; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=4; tTo=t-1; tBy=1; 
    26382639    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2639      
     2640 
    26402641    // test partial t: to 
    26412642    z=3; c=5; t=13; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=8; tBy=1; 
    26422643    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2643      
     2644 
    26442645    // test partial t: by 
    26452646    z=3; c=5; t=13; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=2; 
    26462647    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2647      
     2648 
    26482649    // test full t 
    26492650    z=3; c=5; t=13; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=4; tTo=13; tBy=2; 
    26502651    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2651      
     2652 
    26522653    // test edge case combo with an invalid by 
    26532654    z=2; c=2; t=2; zFrom=0; zTo=0; zBy=2; cFrom=1; cTo=1; cBy=1; tFrom=0; tTo=1; tBy=1; 
     
    26572658    z=5; c=4; t=6; zFrom=1; zTo=4; zBy=2; cFrom=1; cTo=3; cBy=1; tFrom=2; tTo=5; tBy=2; 
    26582659    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2659      
     2660 
    26602661    // test another combination of zct's 
    26612662    z=7; c=7; t=7; zFrom=3; zTo=6; zBy=4; cFrom=1; cTo=6; cBy=3; tFrom=0; tTo=2; tBy=2; 
    26622663    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2663      
     2664 
    26642665    // test bad combination of zct's - choosing beyond ends of ranges 
    2665      
     2666 
    26662667    // z index before 0 begin 
    26672668    try { 
     
    26812682      assertTrue(true); 
    26822683    } 
    2683      
     2684 
    26842685    // z by < 1 
    26852686    try { 
     
    27442745      assertTrue(true); 
    27452746    } 
    2746      
     2747 
    27472748    /* TODO - could replace above code with this uber combo test 
    27482749    // comprehensive but probably WAY too much computation to finish in reasonable time 
     
    27852786    */ 
    27862787  } 
    2787    
     2788 
    27882789  @Test 
    27892790  public void testMemoryCrop() 
    27902791  { 
    27912792    // note - can't crop a virtualStack. therefore no need to test it. 
    2792      
     2793 
    27932794    memoryCropTester(203, 255, 55, 20, 3); 
    27942795    memoryCropTester(203, 184, 55, 40, 2); 
     
    27962797    memoryCropTester(100, 122, 0, 15, 3); 
    27972798  } 
    2798    
     2799 
    27992800  @Test 
    28002801  public void testSplitChannels() 
     
    28152816    splitTimepointsTester(); 
    28162817  } 
    2817    
     2818 
    28182819  @Test 
    28192820  public void testComboCropAutoscale() 
    28202821  { 
    28212822    // note - crop and autoscale both don't work with virtualStacks. No need to test virtual here. 
    2822      
    2823     // try a simple test: single small byte type image  
     2823 
     2824    // try a simple test: single small byte type image 
    28242825    comboCropAndAutoscaleTester(FormatTools.UINT8,240,240,1,1,1,70,40,25); 
    2825      
     2826 
    28262827    // try multiple dimensions 
    28272828    comboCropAndAutoscaleTester(FormatTools.UINT8,240,240,4,3,2,51,15,13); 
    2828      
     2829 
    28292830    // try various pixTypes 
    28302831    for (int pixType : PIXEL_TYPES) 
    28312832      comboCropAndAutoscaleTester(pixType,240,240,2,2,2,225,225,10); 
    28322833  } 
    2833    
     2834 
    28342835  /* 
    28352836  @Test 
     
    28372838  { 
    28382839    // note - concat doesn't work with virtualStacks. No need to test virtual here. 
    2839      
     2840 
    28402841    fail("unimplemented"); 
    28412842  } 
    28422843  */ 
    2843    
     2844 
    28442845  @Test 
    28452846  public void testComboConcatSplitFocalPlanes() 
    28462847  { 
    28472848    // note - concat and split both don't work with virtualStacks. No need to test virtual here. 
    2848      
     2849 
    28492850    comboConcatSplitFocalPlanesTester(); 
    28502851  } 
     
    28712872  { 
    28722873    // note - split both doesn't work with virtualStacks. No need to test virtual here. 
    2873      
     2874 
    28742875    fail("unimplemented"); 
    28752876  } 
    28762877  */ 
    2877    
     2878 
    28782879  /* 
    28792880  @Test 
     
    28812882  { 
    28822883    // note - concat and split both don't work with virtualStacks. No need to test virtual here. 
    2883     
     2884 
    28842885    fail("unimplemented"); 
    28852886  } 
    28862887  */ 
    2887    
     2888 
    28882889  @Test 
    28892890  public void testComboManyOptions() 
     
    28962897 
    28972898    // note - to reuse existing code it is necessary that the crop origin is (0,0) 
    2898      
     2899 
    28992900    String path = constructFakeFilename("superCombo", pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, 1, false, -1, false, -1); 
    2900    
     2901 
    29012902    ImagePlus[] imps = null; 
    29022903 
     
    29332934      throw new IllegalArgumentException("colorizeSubcaseTester() passed a bad combo of sizeC and rgb: "+sizeC+" "+rgb); 
    29342935 
    2935     int totalChannels = sizeC; 
     2936    //int totalChannels = sizeC; 
    29362937    int channelsPerPlane = rgb; 
    2937     int totalPlanes = totalChannels / channelsPerPlane; 
     2938    //int totalPlanes = totalChannels / channelsPerPlane; 
    29382939 
    29392940    if (channelsPerPlane > 7) 
    29402941      throw new IllegalArgumentException("colorizeSubcaseTester() passed bad sizeC - channelsPerPlane > 7 : "+channelsPerPlane); 
    2941      
     2942 
    29422943    int sizeX = 60, sizeY = 30, sizeZ = 1, sizeT = 1, numSeries = 1; 
    2943      
     2944 
    29442945    String path = constructFakeFilename("colorColorized", pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries, indexed, rgb, falseColor, lutLen); 
    29452946 
    29462947    ImagePlus[] imps = null; 
    2947      
     2948 
    29482949    try { 
    29492950      ImporterOptions options = new ImporterOptions(); 
     
    29602961 
    29612962    impsCountTest(imps,1); 
    2962      
     2963 
    29632964    ImagePlus imp = imps[0]; 
    2964     
     2965 
    29652966    if (DEBUG) log("  Returned imp: Z = " +imp.getNSlices()+ " C = " +imp.getNChannels()+" T = "+imp.getNFrames()); 
    29662967    for (int tIndex = 0; tIndex < imp.getNFrames(); tIndex++) { 
     
    29732974      } 
    29742975    } 
    2975      
     2976 
    29762977    if (lutLen == -1) 
    29772978      lutLen = 3; 
    29782979 
    29792980    int expectedSizeC = effectiveC(sizeC, rgb, lutLen, indexed, falseColor); 
    2980        
     2981 
    29812982    //if (DEBUG) log("  chans channsPerPlane planes expectedSizeC "+totalChannels+" "+channelsPerPlane+" "+totalPlanes+" "+expectedSizeC); 
    29822983 
     
    29852986    // TODO: the following code conditional as BF sometimes does not return a CompositeImage. Handle better after BF 
    29862987    //   changed and after I've handled all special cases. 
    2987    
     2988 
    29882989    if (imp.isComposite()) 
    29892990    { 
    29902991      CompositeImage ci = (CompositeImage)imp; 
    2991      
     2992 
    29922993      assertFalse(ci.hasCustomLuts()); 
    29932994 
    29942995      assertEquals(CompositeImage.COLOR, ci.getMode()); 
    2995      
     2996 
    29962997      // TODO - falseColor stuff needs to be impl 
    29972998      if (!falseColor) 
    29982999        colorTests(ci,expectedSizeC,DEFAULT_COLOR_ORDER); 
    2999        
     3000 
    30003001    } 
    30013002    else 
    30023003      if (DEBUG) log("  Not a composite image"); 
    30033004 
    3004     /* 
    3005     */ 
    3006     int iIndex = 0; 
     3005    //int iIndex = 0; 
    30073006    for (int cIndex = 0; cIndex < expectedSizeC; cIndex++) 
    30083007      for (int tIndex = 0; tIndex < sizeT; tIndex++) 
     
    30223021  { 
    30233022    if (DEBUG) log("testColorizeSubcases() - begin special cases"); 
    3024      
     3023 
    30253024    // INDEXED and sizeC == 1,2,3,anything bigger than 3 
    3026      
     3025 
    30273026    // sizeC == 1, rgb == 1, indexed, 8 bit, implicit lut length of 3 - KEY test to do, also note can vary lut len 
    30283027    if (DEBUG) log("1/1 indexed"); 
     
    30323031    if (DEBUG) log("1/1/indexed lutLen==2"); 
    30333032    colorizeSubcaseTester(FormatTools.UINT8,1,1,INDEXED,REAL_COLOR,2); 
    3034      
     3033 
    30353034    // sizeC == 1, rgb == 1, indexed, 16 bit, implicit lut length of 3 - 2nd important test to do, also note can vary lut len 
    30363035    if (DEBUG) log("1/1 indexed (16-bit)"); 
     
    30553054 
    30563055    // NOT INDEXED 
    3057      
     3056 
    30583057    // sizeC == 1 : don't test yet 
    30593058    // TODO - is this limitation now fixed in BF? Do we need to test here? 
    3060      
     3059 
    30613060    // sizeC = 4 and rgb = 4 : interleaved including alpha 
    30623061    // if indexed == true this combo throws exception in CompositeImage constructor 
     
    30683067    if (DEBUG) log("6/3 nonindexed"); 
    30693068    colorizeSubcaseTester(FormatTools.UINT8,6,3,NOT_INDEXED,REAL_COLOR,-1); 
    3070     
     3069 
    30713070    // sizeC = 12, rgb = 3, indexed = false 
    30723071    if (DEBUG) log("12/3 nonindexed"); 
     
    30903089    if (DEBUG) log("testColorizeSubcases() - past all cases"); 
    30913090    */ 
    3092      
     3091 
    30933092    if (DEBUG) log("testColorizeSubcases() : numerous failures : actual tests commented out to see all print statements."); 
    30943093  } 
Note: See TracChangeset for help on using the changeset viewer.