Changeset 6331

Timestamp:

05/18/10 09:47:32 (10 years ago)

Author:

bdezonia

Message:

Stubbed out color tests

File:

• trunk/components/loci-plugins/test/loci/plugins/in/ImporterTest.java (modified) (31 diffs)

trunk/components/loci-plugins/test/loci/plugins/in/ImporterTest.java

@@ -6 +6 @@
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.fail;
 
+import ij.CompositeImage;
 import ij.ImagePlus;
 import ij.ImageStack;
 import ij.process.ImageProcessor;
 
+import java.awt.Color;
 import java.io.IOException;
 import java.lang.reflect.Field;
@@ -32 +36 @@
 //      mergeOptions BF api for finishing merge tests
 //      custom color BF api for doing that test
+//      coboCropAutoscale() - autoscale of a cropped image returning min of whole image
 //  - flesh out existing tests
 //      write tests for the color options : 4 cases - some mention was made that indexcolor is an issue in testing
@@ -37 +42 @@
 //        rgb colorize - need to do actual tests. see BF gui to get idea of how it works
 //        custom colorize - waiting for creation of API for setting r,g,b info
-//        autoscale - code written but failing
+//        autoscale - working
 //      open individual files: try to come up with a way to test without a disk file as source
 //      swapped dims test needs to test cases other than from default swapping Z & T
@@ -145 +150 @@
   }
 
+  private char axisChar(String order, int d)
+  {
+    if ((d < 0) || (d > 2))
+      throw new IllegalArgumentException("axisChar() - index out of bounds [0..2]: "+d);
+    
+    return order.charAt(2+d);
+  }
+  
   private Axis axis(String order, int d)
   {
-    if ((d < 0) || (d > 2))
-      throw new IllegalArgumentException("axis() - index out of bounds [0..2]: "+d);
-    
-    char dim = order.charAt(2+d);
-    
-    if (dim == 'Z') return Axis.Z;
-    if (dim == 'C') return Axis.C;
-    if (dim == 'T') return Axis.T;
-
-    throw new IllegalArgumentException("axis() - invalid image order specified: "+order);
+    char dimChar = axisChar(order,d);
+    
+    if (dimChar == 'Z') return Axis.Z;
+    if (dimChar == 'C') return Axis.C;
+    if (dimChar == 'T') return Axis.T;
+
+    throw new IllegalArgumentException("axis() - unknown dimension specified: ("+dimChar+")");
   }
 
@@ -184 +194 @@
         count++;
     return count;
-    
-    /* calc'ed version : less clear
-    int spread = to - from + 1;
-    
-    if (spread % by == 0)
-      return (spread / by);
-    else
-      return (spread / by) + 1;
-    */
   }
   
@@ -300 +301 @@
   }
   
-  
   private long minPixelValue(int pixType)
   {
@@ -333 +333 @@
     */
   }
-  
-  // ****** helper tests ****************************************************************************************
-  
-  private void defaultBehaviorTest(int pixType, int x, int y, int z, int c, int t)
-  {
-    String path = constructFakeFilename("default", pixType, x, y, z, c, t, -1);
-    ImagePlus[] imps = null;
-    
-    try {
-      imps = BF.openImagePlus(path);
-    }
-    catch (IOException e) {
-      fail(e.getMessage());
-    }
-    catch (FormatException e) {
-      fail(e.getMessage());
-    }
-    
-    assertNotNull(imps);
-    assertEquals(1,imps.length);
-    ImagePlus imp = imps[0];
+
+  private void xyzctTest(ImagePlus imp, int x, int y, int z, int c, int t)
+  {
     assertNotNull(imp);
     assertEquals(x,imp.getWidth());
     assertEquals(y,imp.getHeight());
-    /*
-    assertEquals(z,ip.getNSlices());    // tricky - these last 3 getters have side effects that change their output.
-    assertEquals(c,ip.getNChannels());
-    assertEquals(t,ip.getNFrames());
-    */
-    //if (z != getSizeZ(ip)) { new ij.ImageJ(); ip.show(); }//TEMP
     assertEquals(z,getSizeZ(imp));
+    assertEquals(c,getEffectiveSizeC(imp));
     assertEquals(t,getSizeT(imp));
-    assertEquals(c,getEffectiveSizeC(imp));
+  }
+  
+  // ****** helper tests ****************************************************************************************
+  
+  private void defaultBehaviorTest(int pixType, int x, int y, int z, int c, int t)
+  {
+    String path = constructFakeFilename("default", pixType, x, y, z, c, t, -1);
+    ImagePlus[] imps = null;
+    
+    try {
+      imps = BF.openImagePlus(path);
+    }
+    catch (IOException e) {
+      fail(e.getMessage());
+    }
+    catch (FormatException e) {
+      fail(e.getMessage());
+    }
+    
+    assertNotNull(imps);
+    assertEquals(1,imps.length);
+    ImagePlus imp = imps[0];
+    
+    xyzctTest(imp,x,y,z,c,t);
   }
   
@@ -391 +391 @@
     ImagePlus imp = imps[0];
     
+    xyzctTest(imp,x,y,z,c,t);
+
     ImageStack st = imp.getStack();
     int numSlices = st.getSize();
@@ -414 +416 @@
           assertEquals(y,proc.getHeight());
           assertEquals(0,sIndex(proc));
-          //TODO - test iIndex too? : assertEquals(count,somethingOrOther(iIndex(proc)));
-          //System.out.println("iIndex " + iIndex(proc) + " calc " +
-              // pre loop reorder ((maxJ*maxI*k) + (maxI*j) + i)
-              //((maxJ*maxK*i) + (maxK*j) + k)
-              //((value(middle,maxI,maxJ,maxK)*value(fastest,maxI,maxJ,maxK)*i) + (value(fastest,maxI,maxJ,maxK)*j) + (k))
-              //((value(middle,maxK,maxJ,maxI)*value(fastest,maxK,maxJ,maxI)*i) + (value(fastest,maxK,maxJ,maxI)*j) + (k))
-              //);
-          //System.out.println("maxI "+maxI+" maxJ "+maxJ+" maxK "+maxK+" number "+count+" (i"+i+" "+j+"j "+k+"k) = "+iIndex(proc));
           assertEquals(i,index(slowest,proc));
           assertEquals(j,index(middle,proc));
@@ -432 +426 @@
   {
     int c = 3; String origOrder = "XYZCT", swappedOrder = "XYTCZ";
-    String path = constructFakeFilename(origOrder, pixType, x, y, z, c, t, -1);
+    String path = constructFakeFilename("swapDims", pixType, x, y, z, c, t, -1);
     ImagePlus[] imps = null;
     try {
@@ -452 +446 @@
 
     ImagePlus imp = imps[0];
+    
+    xyzctTest(imp,x,y,t,c,z); // Z<->T swapped
+
     ImageStack st = imp.getStack();
     int numSlices = st.getSize();
     assertEquals(z*c*t,numSlices);
-
-    int actualZ = getSizeZ(imp);
-    int actualT = getSizeT(imp);
-    assertEquals(z,actualT); // Z<->T swapped
-    assertEquals(t,actualZ); // Z<->T swapped
 
     // make sure the dimensions were swapped correctly
@@ -497 +489 @@
     
     assertEquals(1,imps.length);
-    assertEquals(x,imps[0].getWidth());
-    assertEquals(y,imps[0].getHeight());
+    xyzctTest(imps[0],x,y,z,c,t);
     assertEquals(z*c*t, imps[0].getStack().getSize());
     
@@ -597 +588 @@
     
     assertEquals(1,imps.length);
+    
     imp = imps[0];
-    assertEquals(sizeX,imp.getWidth());
-    assertEquals(sizeY,imp.getHeight());
-    assertEquals(sizeZ,getSizeZ(imp));
-    assertEquals(sizeC,getEffectiveSizeC(imp));
-    assertEquals(sizeT,getSizeT(imp));
+
+    xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,sizeT);
 
     ImageStack st = imp.getStack();
@@ -611 +600 @@
     if (wantAutoscale)
     {
-      expectedMax = Math.max( minPixelValue(pixType)+sizeX-1, sizeZ*sizeC*sizeT - 1 );
+      expectedMax = Math.max( minPixelValue(pixType)+sizeX-1, sizeZ*sizeC*sizeT - 1 );  // series size always 1 so ignore
       expectedMin = minPixelValue(pixType);
     }
@@ -620 +609 @@
     }
 
-    // TODO : verify each slice? or just imp.getDisplayRangeMax/Min()?
-    
-    for (int i = 0; i < numSlices; i++)
-    {
-      ImageProcessor proc = st.getProcessor(i+1);
-      //if ((int)expectedMax != (int)proc.getMax())
-      //  System.out.println(FormatTools.getPixelTypeString(pixType) + " failed for proc #"+i+" exp "+expectedMax+" act "+(int)proc.getMax());
-      assertEquals(expectedMax,proc.getMax(),0.1);
-      assertEquals(expectedMin,proc.getMin(),0.1);
-    }
-  }
-  
-  // note - this test needs to rely on crop() to get predictable nonzero minimums
-  
-  private void cropAndAutoscaleTest(int pixType)
-  {
-    //TODO - this code set aside until crop/minMax stuff changed in BF. May be in a partially correct state
-    
-    //TODO: test more stringently final int sizeZ = 5, sizeC = 3, sizeT = 7, sizeX = 123, sizeY = 74;
-    final int sizeZ = 1, sizeC = 1, sizeT = 1, sizeX = 123, sizeY = 74;
-    final int cOriginX = 55, cOriginY = 15, cropSize = 24;
-    final String path = constructFakeFilename("autoscale",pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, -1);
-    
-    // needed for this test
-    assertTrue(cOriginX >= 50);
-    assertTrue(cOriginY >= 10); 
-    assertTrue(cOriginX + cropSize < sizeX);
-    assertTrue(cOriginY + cropSize < sizeY);
-    assertTrue(cOriginX + cropSize < 255);
-    
-    ImagePlus[] imps = null;
-    ImagePlus imp = null;
-    
-    try {
-      ImporterOptions options = new ImporterOptions();
-      options.setAutoscale(true);
-      options.setCrop(true);
-      options.setCropRegion(0,new Region(cOriginX,cOriginY,cropSize,cropSize));
-      options.setId(path);
-      imps = BF.openImagePlus(options);
-    }
-    catch (IOException e) {
-      fail(e.getMessage());
-    }
-    catch (FormatException e) {
-      fail(e.getMessage());
-    }
-    
-    assertEquals(1,imps.length);
-    imp = imps[0];
-    assertEquals(cropSize,imp.getWidth());
-    assertEquals(cropSize,imp.getHeight());
-    assertEquals(sizeZ,getSizeZ(imp));
-    assertEquals(sizeC,getEffectiveSizeC(imp));
-    assertEquals(sizeT,getSizeT(imp));
-
-    ImageStack st = imp.getStack();
-    int numSlices = st.getSize();
-
-    long expectedMax = cOriginX+cropSize-1;
-    long expectedMin = cOriginX;
-
-    // TODO : verify each slice? or just imp.getDisplayRangeMax/Min()?
-    
     for (int i = 0; i < numSlices; i++)
     {
@@ -692 +617 @@
   }
   
+  // note - this test needs to rely on crop() to get predictable nonzero minimums
+  
+  private void cropAndAutoscaleTest(int pixType, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT, int numSeries,
+      int originCropX, int originCropY, int sizeCrop)
+  {
+    final String path = constructFakeFilename("cropAutoscale",pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries);
+    
+    // needed for this test
+    assertTrue(originCropX >= 50);
+    assertTrue(originCropY >= 10); 
+    assertTrue(sizeCrop > 0);
+    assertTrue(originCropX + sizeCrop < sizeX);
+    assertTrue(originCropY + sizeCrop < sizeY);
+    assertTrue(originCropX + sizeCrop < 255);
+    
+    ImagePlus[] imps = null;
+    ImagePlus imp = null;
+    
+    try {
+      ImporterOptions options = new ImporterOptions();
+      options.setAutoscale(true);
+      options.setCrop(true);
+      options.setCropRegion(0,new Region(originCropX,originCropY,sizeCrop,sizeCrop));
+      options.setId(path);
+      imps = BF.openImagePlus(options);
+    }
+    catch (IOException e) {
+      fail(e.getMessage());
+    }
+    catch (FormatException e) {
+      fail(e.getMessage());
+    }
+    
+    assertEquals(1,imps.length);
+    imp = imps[0];
+    xyzctTest(imps[0],sizeCrop,sizeCrop,sizeZ,sizeC,sizeT);
+
+    ImageStack st = imp.getStack();
+    int numSlices = st.getSize();
+
+    long expectedMax = originCropX+sizeCrop-1;
+    long expectedMin = originCropX;
+
+    for (int i = 0; i < numSlices; i++)
+    {
+      ImageProcessor proc = st.getProcessor(i+1);
+      assertEquals(expectedMax,proc.getMax(),0.1);
+      assertEquals(expectedMin,proc.getMin(),0.1);
+    }
+  }
+  
   private void memoryVirtualStackTest(boolean desireVirtual)
   {
-      int x = 604, y = 531;
+      int x = 604, y = 531, z = 7, c = 1, t = 1;
       
-      String path = constructFakeFilename("vstack", FormatTools.UINT16, x, y, 7, 1, 1, -1);
+      String path = constructFakeFilename("vstack", FormatTools.UINT16, x, y, z, c, t, -1);
       
       // open stack
@@ -718 +694 @@
       ImagePlus imp = imps[0];
       assertNotNull(imp);
-      assertEquals(x,imp.getWidth());
-      assertEquals(y,imp.getHeight());
+      xyzctTest(imp,x,y,z,c,t);
   
       assertEquals(desireVirtual,imp.getStack().isVirtual());
@@ -726 +701 @@
   private void memoryRecordModificationsTest(boolean wantToRemember)
   {
-    int x = 444, y = 387;
-    String path = constructFakeFilename("memRec", FormatTools.UINT8, x, y, 7, 1, 1, -1);
+    int x = 444, y = 387, z = 7, c = 1, t = 1;
+    String path = constructFakeFilename("memRec", FormatTools.UINT8, x, y, z, c, t, -1);
     ImagePlus[] imps = null;
     ImagePlus imp = null;
@@ -753 +728 @@
     imp = imps[0];
     assertNotNull(imp);
-    assertEquals(x,imp.getWidth());
-    assertEquals(y,imp.getHeight());
+    xyzctTest(imp,x,y,z,c,t);
 
     // change data in slice 1, swap to slice 2, swap back, see whether data reverts
@@ -835 +809 @@
     assertEquals(1,imps.length);
     ImagePlus imp = imps[0];
-    assertNotNull(imp);
-    assertEquals(x,imp.getWidth());
-    assertEquals(y,imp.getHeight());
+    xyzctTest(imp,x,y,numInSeries(zFrom,zTo,zBy),numInSeries(cFrom,cTo,cBy),numInSeries(tFrom,tTo,tBy));
     ImageStack st = imp.getStack();
 
@@ -867 +839 @@
     assertNotNull(imps);
     assertEquals(1,imps.length);
-    assertNotNull(imps[0]);
-    assertEquals(cx,imps[0].getWidth());  // here is where we make sure we get back a cropped image
-    assertEquals(cy,imps[0].getHeight());
+    xyzctTest(imps[0],cx,cy,1,1,1);
   }
   
@@ -1001 +971 @@
   }
 
+  @Test
+  public void testColorDefault()
+  {
+    int sizeX = 100, sizeY = 120, sizeZ = 2, sizeC = 7, sizeT = 4, numSeries = 3;
+    
+    String path = constructFakeFilename("colorized", FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries);
+    
+    ImagePlus[] imps = null;
+    ImagePlus imp = null;
+    
+    try {
+      ImporterOptions options = new ImporterOptions();
+      options.setColorMode(ImporterOptions.COLOR_MODE_DEFAULT);
+      options.setId(path);
+      imps = BF.openImagePlus(options);
+    }
+    catch (IOException e) {
+      fail(e.getMessage());
+    }
+    catch (FormatException e) {
+      fail(e.getMessage());
+    }
+
+    assertEquals(1,imps.length);
+    
+    imp = imps[0];
+
+    xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,sizeT);
+    
+    assertFalse(imp.isComposite());
+    
+    fail("unfinished");
+  }
+  
+  @Test
+  public void testColorComposite()
+  {
+    int sizeX = 100, sizeY = 120, sizeZ = 2, sizeC = 7, sizeT = 4, numSeries = 3;
+    
+    String path = constructFakeFilename("colorized", FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries);
+    
+    ImagePlus[] imps = null;
+    ImagePlus imp = null;
+    CompositeImage ci = null;
+    
+    try {
+      ImporterOptions options = new ImporterOptions();
+      options.setColorMode(ImporterOptions.COLOR_MODE_COMPOSITE);
+      options.setId(path);
+      imps = BF.openImagePlus(options);
+    }
+    catch (IOException e) {
+      fail(e.getMessage());
+    }
+    catch (FormatException e) {
+      fail(e.getMessage());
+    }
+
+    assertEquals(1,imps.length);
+    
+    imp = imps[0];
+    
+    xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,sizeT);
+    
+    assertTrue(imp.isComposite());
+    
+    ci = (CompositeImage)imp;
+    
+    assertFalse(ci.hasCustomLuts());
+    assertArrayEquals(new int[]{0,0,0,0}, ci.getPixel(55,22));
+    fail("unfinished");
+  }
+  
+  @Test
+  public void testColorColorized()
+  {
+    int sizeX = 100, sizeY = 120, sizeZ = 2, sizeC = 7, sizeT = 4, numSeries = 3;
+    
+    String path = constructFakeFilename("colorized", FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries);
+    
+    ImagePlus[] imps = null;
+    ImagePlus imp = null;
+    CompositeImage ci = null;
+    
+    try {
+      ImporterOptions options = new ImporterOptions();
+      options.setColorMode(ImporterOptions.COLOR_MODE_COLORIZED);
+      options.setId(path);
+      imps = BF.openImagePlus(options);
+    }
+    catch (IOException e) {
+      fail(e.getMessage());
+    }
+    catch (FormatException e) {
+      fail(e.getMessage());
+    }
+
+    assertEquals(1,imps.length);
+    
+    imp = imps[0];
+    
+    xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,sizeT);
+    
+    assertTrue(imp.isComposite());
+    
+    ci = (CompositeImage)imp;
+    
+    assertFalse(ci.hasCustomLuts());
+    assertArrayEquals(new int[]{0,0,0,0}, ci.getPixel(55,22));
+    fail("unfinished");
+  }
+  
+  @Test
+  public void testColorGrayscale()
+  {
+    int sizeX = 100, sizeY = 120, sizeZ = 2, sizeC = 7, sizeT = 4, numSeries = 3;
+    
+    String path = constructFakeFilename("colorized", FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries);
+    
+    ImagePlus[] imps = null;
+    ImagePlus imp = null;
+    CompositeImage ci = null;
+    
+    try {
+      ImporterOptions options = new ImporterOptions();
+      options.setColorMode(ImporterOptions.COLOR_MODE_GRAYSCALE);
+      options.setId(path);
+      imps = BF.openImagePlus(options);
+    }
+    catch (IOException e) {
+      fail(e.getMessage());
+    }
+    catch (FormatException e) {
+      fail(e.getMessage());
+    }
+
+    assertEquals(1,imps.length);
+    
+    imp = imps[0];
+    
+    xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,sizeT);
+    
+    assertTrue(imp.isComposite());
+    
+    ci = (CompositeImage)imp;
+    
+    assertFalse(ci.hasCustomLuts());
+    assertArrayEquals(new int[]{0,0,0,0}, ci.getPixel(55,22));
+    fail("unfinished");
+  }
+  
+  @Test
+  public void testColorCustom()
+  {
+    int sizeX = 100, sizeY = 120, sizeZ = 2, sizeC = 7, sizeT = 4, numSeries = 3;
+    
+    String path = constructFakeFilename("colorized", FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries);
+    
+    ImagePlus[] imps = null;
+    ImagePlus imp = null;
+    CompositeImage ci = null;
+    
+    try {
+      ImporterOptions options = new ImporterOptions();
+      options.setColorMode(ImporterOptions.COLOR_MODE_CUSTOM);
+      int series = 0; int channel = 0;
+      options.setCustomColor(series, channel, Color.BLUE);
+      options.setId(path);
+      imps = BF.openImagePlus(options);
+    }
+    catch (IOException e) {
+      fail(e.getMessage());
+    }
+    catch (FormatException e) {
+      fail(e.getMessage());
+    }
+
+    assertEquals(1,imps.length);
+    
+    imp = imps[0];
+    
+    xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,sizeT);
+    
+    assertTrue(imp.isComposite());
+    
+    ci = (CompositeImage)imp;
+    
+    assertFalse(ci.hasCustomLuts());
+    assertArrayEquals(new int[]{0,0,0,0}, ci.getPixel(55,22));
+    fail("unfinished");
+  }
+  
   /*
   @Test
@@ -1269 +1431 @@
     memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy);
     
-    /* TODO - enable when step by 0 code fixed and remove extra tests above and below
+    // test bad combination of zct's - choosing beyond ends of ranges
+    
+    // z index before 0 begin
+    try {
+      z=7; c=7; t=7; zFrom=-1; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1;
+      memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy);
+      fail();
+    } catch (IllegalArgumentException e) {
+      assertTrue(true);
+    }
+
+    // z index after z-1 end
+    try {
+      z=7; c=7; t=7; zFrom=0; zTo=z; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1;
+      memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy);
+      fail();
+    } catch (IllegalArgumentException e) {
+      assertTrue(true);
+    }
+    
+    // z by < 1
+    try {
+      z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=0; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1;
+      // TODO - enable post fix
+      //memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy);
+      //fail();
+    } catch (IllegalArgumentException e) {
+      assertTrue(true);
+    }
+
+    // c index before 0 begin
+    try {
+      z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=-1; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1;
+      memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy);
+      fail();
+    } catch (IllegalArgumentException e) {
+      assertTrue(true);
+    }
+
+    // c index after c-1 end
+    try {
+      z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c; cBy=1; tFrom=0; tTo=t-1; tBy=1;
+      memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy);
+      fail();
+    } catch (IllegalArgumentException e) {
+      assertTrue(true);
+    }
+
+    // c by < 1
+    try {
+      z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=0; tFrom=0; tTo=t-1; tBy=1;
+      // TODO - enable post fix
+      //memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy);
+      //fail();
+    } catch (IllegalArgumentException e) {
+      assertTrue(true);
+    }
+
+    // t index before 0 begin
+    try {
+      z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=-1; tTo=t-1; tBy=1;
+      memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy);
+      fail();
+    } catch (IllegalArgumentException e) {
+      assertTrue(true);
+    }
+
+    // t index after t-1 end
+    try {
+      z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t; tBy=1;
+      memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy);
+      fail();
+    } catch (IllegalArgumentException e) {
+      assertTrue(true);
+    }
+
+    // t by < 1
+    try {
+      z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=0;
+      // TODO - enable post fix
+      //memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy);
+      //fail();
+    } catch (IllegalArgumentException e) {
+      assertTrue(true);
+    }
+    
+    /* TODO - enable when step by 0 code fixed and remove extra tests above
     // uber combo test
     z = 6; c = 5; t = 4;
@@ -1306 +1554 @@
     */
     
-    // test bad combination of zct's - choosing beyond ends of ranges
-    
-    // z index before 0 begin
-    try {
-      z=7; c=7; t=7; zFrom=-1; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1;
-      memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy);
-      fail();
-    } catch (IllegalArgumentException e) {
-      assertTrue(true);
-    }
-
-    // z index after z-1 end
-    try {
-      z=7; c=7; t=7; zFrom=0; zTo=z; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1;
-      memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy);
-      fail();
-    } catch (IllegalArgumentException e) {
-      assertTrue(true);
-    }
-    
-    // z by < 1
-    try {
-      z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=0; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1;
-      // TODO - enable post fix
-      //memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy);
-      //fail();
-    } catch (IllegalArgumentException e) {
-      assertTrue(true);
-    }
-
-    // c index before 0 begin
-    try {
-      z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=-1; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1;
-      memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy);
-      fail();
-    } catch (IllegalArgumentException e) {
-      assertTrue(true);
-    }
-
-    // c index after c-1 end
-    try {
-      z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c; cBy=1; tFrom=0; tTo=t-1; tBy=1;
-      memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy);
-      fail();
-    } catch (IllegalArgumentException e) {
-      assertTrue(true);
-    }
-
-    // c by < 1
-    try {
-      z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=0; tFrom=0; tTo=t-1; tBy=1;
-      // TODO - enable post fix
-      //memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy);
-      //fail();
-    } catch (IllegalArgumentException e) {
-      assertTrue(true);
-    }
-
-    // t index before 0 begin
-    try {
-      z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=-1; tTo=t-1; tBy=1;
-      memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy);
-      fail();
-    } catch (IllegalArgumentException e) {
-      assertTrue(true);
-    }
-
-    // t index after t-1 end
-    try {
-      z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t; tBy=1;
-      memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy);
-      fail();
-    } catch (IllegalArgumentException e) {
-      assertTrue(true);
-    }
-
-    // t by < 1
-    try {
-      z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=0;
-      // TODO - enable post fix
-      //memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy);
-      //fail();
-    } catch (IllegalArgumentException e) {
-      assertTrue(true);
-    }
   }
   
@@ -1405 +1568 @@
   public void testSplitChannels()
   {
-    final int sizeZ = 5, sizeC = 3, sizeT = 7;
+    final int sizeX = 50, sizeY = 20, sizeZ = 5, sizeC = 3, sizeT = 7;
     final String path = constructFakeFilename("splitC",
-      FormatTools.UINT8, 50, 20, sizeZ, sizeC, sizeT, -1);
+      FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, -1);
 
     // open image
@@ -1427 +1590 @@
     assertEquals(sizeC,imps.length);
     
-    // unwind ZCT loop : C pulled to front, ZT in order
+    // unwind ZCT loop : C pulled outside, ZT in order
     for (int c = 0; c < sizeC; c++) {
-      ImageStack st = imps[c].getStack();
+      ImagePlus imp = imps[c];
+      xyzctTest(imp,sizeX,sizeY,sizeZ,1,sizeT);
+      ImageStack st = imp.getStack();
       assertEquals(sizeZ * sizeT,st.getSize());
       int index = 0;
@@ -1447 +1612 @@
   public void testSplitFocalPlanes()
   {
-    final int sizeZ = 5, sizeC = 3, sizeT = 7;
+    final int sizeX = 50, sizeY = 20, sizeZ = 5, sizeC = 3, sizeT = 7;
     final String path = constructFakeFilename("splitZ",
-      FormatTools.UINT8, 50, 20, sizeZ, sizeC, sizeT, -1);
+      FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, -1);
 
     // open image
@@ -1469 +1634 @@
     assertEquals(sizeZ,imps.length);
 
-    // unwind ZCT loop : Z pulled to front, CT in order
+    // unwind ZCT loop : Z pulled outside, CT in order
     for (int z = 0; z < sizeZ; z++) {
-      ImageStack st = imps[z].getStack();
+      ImagePlus imp = imps[z];
+      xyzctTest(imp,sizeX,sizeY,1,sizeC,sizeT);
+      ImageStack st = imp.getStack();
       assertEquals(sizeC * sizeT,st.getSize());
       int index = 0;
@@ -1489 +1656 @@
   public void testSplitTimepoints()
   {
-    final int sizeZ = 5, sizeC = 3, sizeT = 7;
+    final int sizeX = 50, sizeY = 20, sizeZ = 5, sizeC = 3, sizeT = 7;
     final String path = constructFakeFilename("splitT",
       FormatTools.UINT8, 50, 20, sizeZ, sizeC, sizeT, -1);
@@ -1511 +1678 @@
     assertEquals(sizeT,imps.length);
     
-    // unwind ZTC loop : T pulled to front, ZC in order
+    // unwind ZTC loop : T pulled outside, ZC in order
     for (int t = 0; t < sizeT; t++) {
-      ImageStack st = imps[t].getStack();
+      ImagePlus imp = imps[t];
+      xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,1);
+      ImageStack st = imp.getStack();
       assertEquals(sizeZ * sizeC,st.getSize());
       int index = 0;
@@ -1531 +1700 @@
   public void testComboCropAutoscale()
   {
-    cropAndAutoscaleTest(FormatTools.UINT8);
-    
-    cropAndAutoscaleTest(FormatTools.UINT8);
-    cropAndAutoscaleTest(FormatTools.UINT16);
-    //TODO: UINT32 failing - bug in BF?
-    cropAndAutoscaleTest(FormatTools.UINT32);
-    //TODO: exp 127 act 255 
-    cropAndAutoscaleTest(FormatTools.INT8);
-    //TODO: exp 32767 act 65535
-    cropAndAutoscaleTest(FormatTools.INT16);
-    //TODO: signed max broken here too
-    cropAndAutoscaleTest(FormatTools.INT32);
- 
-    cropAndAutoscaleTest(FormatTools.UINT8);
-    cropAndAutoscaleTest(FormatTools.UINT16);
-    cropAndAutoscaleTest(FormatTools.UINT32);
-    cropAndAutoscaleTest(FormatTools.INT8);
-    cropAndAutoscaleTest(FormatTools.INT16);
-    cropAndAutoscaleTest(FormatTools.INT32);
+    // try a simple test: single small byte type image 
+    cropAndAutoscaleTest(FormatTools.UINT8,100,80,1,1,1,1,70,40,25);
+    
+    // try multiple dimensions
+    cropAndAutoscaleTest(FormatTools.UINT8,84,63,4,3,2,5,51,8,13);
+    
+    // try various pixTypes
+    for (int pixType : PixelTypes)
+      cropAndAutoscaleTest(pixType,96,96,2,2,2,2,70,60,10);
   }