Changeset 6535


Ignore:
Timestamp:
06/18/10 13:40:38 (9 years ago)
Author:
bdezonia
Message:

refactoring

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/components/loci-plugins/test/loci/plugins/in/ImporterTest.java

    r6533 r6535  
    4242//   finish the colorize tests 
    4343//   implement more combo tests 
     44//   perhaps refactor the various imageSeriesIn... and ImagesIn... order tests into a general tester and an orderBy param 
    4445 
    4546// seem broken but don't know status from Curtis 
     
    219220    return getPixelValue(40,0,imp,z,c,t,indexed); 
    220221  } 
    221    
    222 @SuppressWarnings("unused") 
     222 
     223  /** a debug routine for printing the SIZCT indices of a slice in a FakeFile stack */ 
    223224  private void printVals(ImageProcessor proc) 
    224225  { 
     
    365366     
    366367    if (wantAutoscale || (FormatTools.isFloatingPoint(pixType))) 
    367     { 
    368368      min = minPixelValue(pixType); 
    369     } 
    370369    else // not autoscaling - get min/max of pixel type 
    371     { 
    372370      min = 0; 
    373     } 
    374371 
    375372    if (pixType == FormatTools.INT16)  // hack : clamp like IJ does 
     
    385382     
    386383    if (wantAutoscale || (FormatTools.isFloatingPoint(pixType))) 
    387     { 
    388384      max = Math.max( maxPixVal, maxIndex); 
    389     } 
    390385    else // not autoscaling - get min/max of pixel type 
    391     { 
    392386      max = maxPixelValue(pixType); 
    393     } 
    394387 
    395388    if (pixType == FormatTools.INT16)  // hack : clamp like IJ does 
     
    613606    } 
    614607  } 
     608 
     609  /** tests that an ImagePlus stack is in a specified order */ 
     610  private void stackInSpecificOrderTest(ImagePlus imp, String chOrder) 
     611  { 
     612    ImageStack st = imp.getStack(); 
     613 
     614    int x = imp.getWidth(); 
     615    int y = imp.getHeight(); 
     616    int z = imp.getNSlices(); 
     617    int c = imp.getNChannels(); 
     618    int t = imp.getNFrames(); 
     619 
     620    Axis fastest = axis(chOrder,0); 
     621    Axis middle = axis(chOrder,1); 
     622    Axis slowest = axis(chOrder,2); 
     623     
     624    int maxI = value(slowest,z,c,t); 
     625    int maxJ = value(middle,z,c,t); 
     626    int maxK = value(fastest,z,c,t); 
     627     
     628    int slice = 0; 
     629    for (int i = 0; i < maxI; i++) 
     630      for (int j = 0; j < maxJ; j++) 
     631        for (int k = 0; k < maxK; k++) 
     632        { 
     633          ImageProcessor proc = st.getProcessor(++slice); 
     634          //printVals(proc); 
     635          assertNotNull(proc); 
     636          assertEquals(x,proc.getWidth()); 
     637          assertEquals(y,proc.getHeight()); 
     638          assertEquals(0,sIndex(proc)); 
     639          assertEquals(i,index(slowest,proc)); 
     640          assertEquals(j,index(middle,proc)); 
     641          assertEquals(k,index(fastest,proc)); 
     642        } 
     643  } 
    615644   
    616645  /** tests that the pixel values of a FakeFile are as expected */ 
     
    628657          for (int i = 0; i < max; i++) 
    629658            assertEquals(i,getPixelValue(i,10,imp,z,c,t,indexed)); 
     659  } 
     660 
     661  /** tests that the pixels values of a cropped FakeFile are correct */ 
     662  private void croppedPixelsTest(ImagePlus imp, int ox, int cropSize) 
     663  { 
     664    ImageProcessor proc = imp.getProcessor(); 
     665     
     666    for (int ix = 0; ix < cropSize; ix++) 
     667      for (int iy = 0; iy < cropSize; iy++) 
     668        assertEquals(ox+ix,proc.getPixelValue(ix, iy),0); 
    630669  } 
    631670   
     
    696735    stackTest(imp,(zs * cs * ts)); 
    697736     
    698     ImageStack st = imp.getStack(); 
    699      
    700737    for (int t = 0; t < ts; t++) 
    701738      for (int c = 0; c < cs; c++) 
     
    729766    } 
    730767  } 
    731    
    732   // ******** specific testers  ********************************** 
    733    
    734   /** tests BioFormats when directly calling BF.openImagePlus(path) (no options set) */ 
    735   private void defaultBehaviorTester(int pixType, int x, int y, int z, int c, int t) 
    736   { 
    737     String path = constructFakeFilename("default", pixType, x, y, z, c, t, -1, false, -1, false, -1); 
    738     ImagePlus[] imps = null; 
    739      
    740     try { 
    741       imps = BF.openImagePlus(path); 
    742     } 
    743     catch (IOException e) { 
    744       fail(e.getMessage()); 
    745     } 
    746     catch (FormatException e) { 
    747       fail(e.getMessage()); 
    748     } 
    749      
    750     impsCountTest(imps,1); 
    751  
    752     ImagePlus imp = imps[0]; 
    753      
    754     xyzctTest(imp,x,y,z,c,t); 
    755   } 
    756    
    757   private void outputStackOrderTester(int pixType, ChannelOrder order, int x, int y, int z, int c, int t) 
    758   { 
    759     String bfChOrder = bfChanOrd(order); 
    760     String chOrder = order.toString(); 
    761      
    762     String path = constructFakeFilename("stack", pixType, x, y, z, c, t, -1, false, -1, false, -1); 
    763      
    764     ImagePlus[] imps = null; 
    765     try { 
    766       ImporterOptions options = new ImporterOptions(); 
    767       options.setId(path); 
    768       options.setStackOrder(bfChOrder); 
    769       imps = BF.openImagePlus(options); 
    770     } 
    771     catch (IOException e) { 
    772       fail(e.getMessage()); 
    773     } 
    774     catch (FormatException e) { 
    775       fail(e.getMessage()); 
    776     } 
    777  
    778     impsCountTest(imps,1); 
    779      
    780     ImagePlus imp = imps[0]; 
    781      
    782     xyzctTest(imp,x,y,z,c,t); 
    783  
    784     stackTest(imp,z*c*t); 
    785      
    786     ImageStack st = imp.getStack(); 
    787  
    788     int slice = 0; 
    789     //System.out.println(order); 
    790     Axis fastest = axis(chOrder,0); 
    791     Axis middle = axis(chOrder,1); 
    792     Axis slowest = axis(chOrder,2); 
    793     int maxI = value(slowest,z,c,t); 
    794     int maxJ = value(middle,z,c,t); 
    795     int maxK = value(fastest,z,c,t); 
    796     for (int i = 0; i < maxI; i++) 
    797       for (int j = 0; j < maxJ; j++) 
    798         for (int k = 0; k < maxK; k++) 
    799         { 
    800           ImageProcessor proc = st.getProcessor(++slice); 
    801           //printVals(proc); 
    802           assertNotNull(proc); 
    803           assertEquals(x,proc.getWidth()); 
    804           assertEquals(y,proc.getHeight()); 
    805           assertEquals(0,sIndex(proc)); 
    806           assertEquals(i,index(slowest,proc)); 
    807           assertEquals(j,index(middle,proc)); 
    808           assertEquals(k,index(fastest,proc)); 
    809         } 
    810   } 
    811    
    812   private void datasetSwapDimsTester(int pixType, int x, int y, int z, int t) 
    813   { 
    814     int c = 3; 
    815     ChannelOrder swappedOrder = ChannelOrder.TCZ; // original order is ZCT 
    816     String path = constructFakeFilename("swapDims", pixType, x, y, z, c, t, -1, false, -1, false, -1); 
    817     ImagePlus[] imps = null; 
    818     try { 
    819       ImporterOptions options = new ImporterOptions(); 
    820       options.setId(path); 
    821       options.setSwapDimensions(true); 
    822       options.setInputOrder(0, bfChanOrd(swappedOrder)); 
    823       imps = BF.openImagePlus(options); 
    824     } 
    825     catch (IOException e) { 
    826       fail(e.getMessage()); 
    827     } 
    828     catch (FormatException e) { 
    829       fail(e.getMessage()); 
    830     } 
    831  
    832     impsCountTest(imps,1); 
    833  
    834     ImagePlus imp = imps[0]; 
    835      
    836     xyzctTest(imp,x,y,t,c,z); // Z<->T swapped 
    837  
    838     swappedZtTest(imp,z,c,t); 
    839   } 
    840  
    841   /** open a fakefile series either as separate ImagePluses or as one ImagePlus depending on input flag allOfThem */ 
    842   private ImagePlus[] openSeriesTest(String fakeFileName, boolean allOfThem) 
    843   { 
    844     ImagePlus[] imps = null; 
    845      
    846     try { 
    847       ImporterOptions options = new ImporterOptions(); 
    848       options.setId(fakeFileName); 
    849       options.setOpenAllSeries(allOfThem); 
    850       imps = BF.openImagePlus(options); 
    851     } 
    852     catch (IOException e) { 
    853       fail(e.getMessage()); 
    854     } 
    855     catch (FormatException e) { 
    856       fail(e.getMessage()); 
    857     } 
    858      
    859     return imps; 
    860   } 
    861    
    862   private void datasetOpenAllSeriesTester(boolean allOfThem) 
    863   { 
    864     int x = 55, y = 20, z = 2, c = 3, t = 4, s = 5; 
    865      
    866     String path = constructFakeFilename("openAllSeries", FormatTools.UINT32, x, y, z, c, t, s, false, -1, false, -1); 
    867      
    868     int expectedNumSeries = 1; 
    869     if (allOfThem) 
    870       expectedNumSeries = s; 
    871      
    872     ImagePlus[] imps = openSeriesTest(path,allOfThem); 
    873     impsCountTest(imps,expectedNumSeries); 
    874     for (int i = 0; i < expectedNumSeries; i++) 
    875       xyzctTest(imps[i],x,y,z,c,t); 
    876   } 
    877    
    878   private void datasetConcatenateTester(int pixType, int x, int y, int z, int c, int t, int s) 
    879   { 
    880     assertTrue(s >= 1);  // necessary for this test 
    881      
    882     // open all series as one 
    883      
    884     String path = constructFakeFilename("concat", pixType, x, y, z, c, t, s, false, -1, false, -1); 
    885     ImagePlus[] imps = null; 
    886     try { 
    887       ImporterOptions options = new ImporterOptions(); 
    888       options.setId(path); 
    889       options.setOpenAllSeries(true); 
    890       options.setConcatenate(true); 
    891       imps = BF.openImagePlus(options); 
    892     } 
    893     catch (IOException e) { 
    894       fail(e.getMessage()); 
    895     } 
    896     catch (FormatException e) { 
    897       fail(e.getMessage()); 
    898     } 
    899  
    900     // test results 
    901      
    902     impsCountTest(imps,1); 
    903  
    904     multipleSeriesInZtcOrderTest(imps[0],s,z,c,t); 
    905   } 
    906    
    907   private void autoscaleTester(int pixType, boolean wantAutoscale) 
    908   { 
    909     final int sizeZ = 2, sizeC = 3, sizeT = 4, sizeX = 51, sizeY = 16; 
    910     final String path = constructFakeFilename("autoscale",pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, -1, false, -1, false, -1); 
    911      
    912     ImagePlus[] imps = null; 
    913     ImagePlus imp = null; 
    914      
    915     try { 
    916       ImporterOptions options = new ImporterOptions(); 
    917       options.setAutoscale(wantAutoscale); 
    918       options.setId(path); 
    919       imps = BF.openImagePlus(options); 
    920     } 
    921     catch (IOException e) { 
    922       fail(e.getMessage()); 
    923     } 
    924     catch (FormatException e) { 
    925       fail(e.getMessage()); 
    926     } 
    927      
    928     impsCountTest(imps,1); 
    929      
    930     imp = imps[0]; 
    931  
    932     xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,sizeT); 
    933      
    934     stackTest(imp,sizeZ*sizeC*sizeT); 
    935  
    936     calibrationTest(imp,pixType); 
    937      
    938     long maxPixVal = minPixelValue(pixType)+sizeX-1; 
    939     long maxIndex = sizeZ*sizeC*sizeT - 1; 
    940      
    941     long expectedMax = expectedMax(pixType,wantAutoscale,maxPixVal,maxIndex); 
    942     long expectedMin = expectedMin(pixType,wantAutoscale); 
    943      
     768 
     769  /** tests that an ImagePlus' set of ImageProcessors have their mins and maxes set appropriately */ 
     770  private void minMaxTest(ImagePlus imp, long expectedMin, long expectedMax) 
     771  { 
    944772    ImageStack st = imp.getStack(); 
    945773    int numSlices = st.getSize(); 
     
    951779    } 
    952780  } 
     781 
     782  /** tests if images split on Z are ordered correctly */ 
     783  private void imagesInZctOrderTest(ImagePlus[] imps, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT) 
     784  { 
     785    // unwind ZCT loop : Z pulled outside, CT in order 
     786    for (int z = 0; z < sizeZ; z++) { 
     787      ImagePlus imp = imps[z]; 
     788      xyzctTest(imp,sizeX,sizeY,1,sizeC,sizeT); 
     789      stackTest(imp,sizeC * sizeT); 
     790      ImageStack st = imp.getStack(); 
     791      int slice = 0; 
     792      for (int t = 0; t < sizeT; t++) { 
     793        for (int c = 0; c < sizeC; c++) { 
     794          ImageProcessor proc = st.getProcessor(++slice); 
     795          // test the values 
     796          assertEquals(z,zIndex(proc)); 
     797          assertEquals(c,cIndex(proc)); 
     798          assertEquals(t,tIndex(proc)); 
     799        } 
     800      } 
     801    } 
     802  } 
     803   
     804  /** tests if images split on C are ordered correctly */ 
     805  private void imagesInCztOrderTest(ImagePlus[] imps, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT) 
     806  { 
     807    // unwind ZCT loop : C pulled outside, ZT in order 
     808    for (int c = 0; c < sizeC; c++) { 
     809      ImagePlus imp = imps[c]; 
     810      xyzctTest(imp,sizeX,sizeY,sizeZ,1,sizeT); 
     811      stackTest(imp,sizeZ * sizeT); 
     812      ImageStack st = imp.getStack(); 
     813      int slice = 0; 
     814      for (int t = 0; t < sizeT; t++) { 
     815        for (int z = 0; z < sizeZ; z++) { 
     816          ImageProcessor proc = st.getProcessor(++slice); 
     817          // test the values 
     818          assertEquals(z,zIndex(proc)); 
     819          assertEquals(c,cIndex(proc)); 
     820          assertEquals(t,tIndex(proc)); 
     821        } 
     822      } 
     823    } 
     824  } 
     825   
     826  /** tests if images split on T are ordered correctly */ 
     827  private void imagesInTzcOrderTest(ImagePlus[] imps, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT) 
     828  { 
     829    // unwind ZTC loop : T pulled outside, ZC in order 
     830    for (int t = 0; t < sizeT; t++) { 
     831      ImagePlus imp = imps[t]; 
     832      xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,1); 
     833      stackTest(imp,sizeZ * sizeC); 
     834      ImageStack st = imp.getStack(); 
     835      int slice = 0; 
     836      for (int c = 0; c < sizeC; c++) { 
     837        for (int z = 0; z < sizeZ; z++) { 
     838          ImageProcessor proc = st.getProcessor(++slice); 
     839          // test the values 
     840          assertEquals(z,zIndex(proc)); 
     841          assertEquals(c,cIndex(proc)); 
     842          assertEquals(t,tIndex(proc)); 
     843        } 
     844      } 
     845    } 
     846  } 
     847   
     848  /** tests that a set of images is ordered via Z first - used by concatSplit tests */ 
     849  private void imageSeriesInZctOrderTest(ImagePlus[] imps, int numSeries, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT) 
     850  { 
     851    // from ZCT order: Z pulled out, CT in order 
     852    for (int z = 0; z < sizeZ; z++) 
     853    { 
     854      ImagePlus imp = imps[z]; 
     855      xyzctTest(imp,sizeX,sizeY,1,sizeC,sizeT); 
     856      stackTest(imp,numSeries*sizeC*sizeT); 
     857      ImageStack st = imp.getStack(); 
     858      for (int s = 0; s < numSeries; s++) { 
     859        int slice = s*sizeC*sizeT; 
     860        for (int t = 0; t < sizeT; t++) { 
     861          for (int c = 0; c < sizeC; c++) { 
     862            //System.out.println("index "+index); 
     863            ImageProcessor proc = st.getProcessor(++slice); 
     864            //System.out.println("s z c t "+s+" "+z+" "+c+" "+t); 
     865            //System.out.println("z c t "+z+" "+c+" "+t); 
     866            //System.out.println("is iz ic it "+sIndex(proc)+" "+zIndex(proc)+" "+cIndex(proc)+" "+tIndex(proc)); 
     867            // test the values 
     868            assertEquals(z,zIndex(proc)); 
     869            assertEquals(c,cIndex(proc)); 
     870            assertEquals(t,tIndex(proc)); 
     871            assertEquals(s,sIndex(proc)); 
     872          } 
     873        } 
     874      } 
     875    } 
     876  } 
     877   
     878  /** tests that a set of images is ordered via C first - used by concatSplit tests */ 
     879  private void imageSeriesInCztOrderTest(ImagePlus[] imps, int numSeries, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT) 
     880  { 
     881    // from ZCT order: C pulled out, ZT in order 
     882    for (int c = 0; c < sizeC; c++) 
     883    { 
     884      ImagePlus imp = imps[c]; 
     885      xyzctTest(imp,sizeX,sizeY,sizeZ,1,sizeT); 
     886      stackTest(imp,numSeries*sizeZ*sizeT); 
     887      ImageStack st = imp.getStack(); 
     888      for (int s = 0; s < numSeries; s++) { 
     889        int slice = s*sizeZ*sizeT; 
     890        for (int t = 0; t < sizeT; t++) { 
     891          for (int z = 0; z < sizeZ; z++) { 
     892            ImageProcessor proc = st.getProcessor(++slice); 
     893            //System.out.println("index "+index); 
     894            //System.out.println("s z c t "+s+" "+z+" "+c+" "+t); 
     895            //System.out.println("iz ic it "+zIndex(proc)+" "+cIndex(proc)+" "+tIndex(proc)); 
     896            // test the values 
     897            assertEquals(z,zIndex(proc)); 
     898            assertEquals(c,cIndex(proc)); 
     899            assertEquals(t,tIndex(proc)); 
     900            assertEquals(s,sIndex(proc)); 
     901          } 
     902        } 
     903      } 
     904    } 
     905  } 
     906   
     907  /** tests that a set of images is ordered via T first - used by concatSplit tests */ 
     908  private void imageSeriesInTzcOrderTest(ImagePlus[] imps, int numSeries, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT) 
     909  { 
     910    // from ZCT order: T pulled out, ZC in order 
     911    for (int t = 0; t < sizeT; t++) 
     912    { 
     913      ImagePlus imp = imps[t]; 
     914      xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,1); 
     915      stackTest(imp,numSeries*sizeZ*sizeC); 
     916      ImageStack st = imp.getStack(); 
     917      for (int s = 0; s < numSeries; s++) { 
     918        int slice = s*sizeZ*sizeC; 
     919        for (int c = 0; c < sizeC; c++) { 
     920          for (int z = 0; z < sizeZ; z++) { 
     921            ImageProcessor proc = st.getProcessor(++slice); 
     922            //System.out.println("index "+index); 
     923            //System.out.println("s z c t "+s+" "+z+" "+c+" "+t); 
     924            //System.out.println("iz ic it "+zIndex(proc)+" "+cIndex(proc)+" "+tIndex(proc)); 
     925            // test the values 
     926            assertEquals(z,zIndex(proc)); 
     927            assertEquals(c,cIndex(proc)); 
     928            assertEquals(t,tIndex(proc)); 
     929            assertEquals(s,sIndex(proc)); 
     930          } 
     931        } 
     932      } 
     933    } 
     934  } 
     935   
     936  /** tests that an image stack is correctly ordered after swapping and cropping */ 
     937  private void stackCtzSwappedAndCroppedTest(ImagePlus[] imps, int cropSizeX, int cropSizeY, int origSizeZ, int origSizeC, int origSizeT, int start, int stepBy) 
     938  { 
     939    // note orig data is ZCT. swapping order is CTZ (all dims swapped). 
     940     
     941    int newMaxT = origSizeC; 
     942     
     943    int numC = numInSeries(start,origSizeC-1,stepBy); 
     944 
     945    int newZ = origSizeT; 
     946    int newC = origSizeZ; 
     947    int newT = numC; 
     948     
     949    for (int zIndex = 0; zIndex < newZ; zIndex++) 
     950    { 
     951      ImagePlus imp = imps[zIndex]; 
     952       
     953      xyzctTest(imp,cropSizeX,cropSizeY,1,newC,newT); // all dims changed 
     954   
     955      stackTest(imp,newC*newT); 
     956       
     957      ImageStack st = imp.getStack(); 
     958       
     959      int slice = 0; 
     960      for (int tIndex = start; tIndex < newMaxT; tIndex += stepBy) 
     961        for (int cIndex = 0; cIndex < newC; cIndex++) 
     962        { 
     963          ImageProcessor proc = st.getProcessor(++slice); 
     964           
     965          assertEquals(cropSizeX,proc.getWidth()); 
     966          assertEquals(cropSizeY,proc.getHeight()); 
     967 
     968          final int actualZ = tIndex(proc); 
     969          final int actualC = zIndex(proc); 
     970          final int actualT = cIndex(proc); 
     971           
     972          assertEquals(zIndex, actualZ); 
     973          assertEquals(cIndex, actualC); 
     974          assertEquals(tIndex, actualT); 
     975        } 
     976    } 
     977  } 
     978   
     979  // ******** specific testers  ********************************** 
     980   
     981  /** tests BioFormats when directly calling BF.openImagePlus(path) (no options set) */ 
     982  private void defaultBehaviorTester(int pixType, int x, int y, int z, int c, int t) 
     983  { 
     984    String path = constructFakeFilename("default", pixType, x, y, z, c, t, -1, false, -1, false, -1); 
     985    ImagePlus[] imps = null; 
     986     
     987    try { 
     988      imps = BF.openImagePlus(path); 
     989    } 
     990    catch (IOException e) { 
     991      fail(e.getMessage()); 
     992    } 
     993    catch (FormatException e) { 
     994      fail(e.getMessage()); 
     995    } 
     996     
     997    impsCountTest(imps,1); 
     998 
     999    ImagePlus imp = imps[0]; 
     1000     
     1001    xyzctTest(imp,x,y,z,c,t); 
     1002  } 
     1003   
     1004  private void outputStackOrderTester(int pixType, ChannelOrder order, int x, int y, int z, int c, int t) 
     1005  { 
     1006    String bfChOrder = bfChanOrd(order); 
     1007    String chOrder = order.toString(); 
     1008     
     1009    String path = constructFakeFilename("stack", pixType, x, y, z, c, t, -1, false, -1, false, -1); 
     1010     
     1011    ImagePlus[] imps = null; 
     1012    try { 
     1013      ImporterOptions options = new ImporterOptions(); 
     1014      options.setId(path); 
     1015      options.setStackOrder(bfChOrder); 
     1016      imps = BF.openImagePlus(options); 
     1017    } 
     1018    catch (IOException e) { 
     1019      fail(e.getMessage()); 
     1020    } 
     1021    catch (FormatException e) { 
     1022      fail(e.getMessage()); 
     1023    } 
     1024 
     1025    impsCountTest(imps,1); 
     1026     
     1027    ImagePlus imp = imps[0]; 
     1028     
     1029    xyzctTest(imp,x,y,z,c,t); 
     1030 
     1031    stackTest(imp,z*c*t); 
     1032     
     1033    stackInSpecificOrderTest(imp, chOrder); 
     1034  } 
     1035 
     1036  private void datasetSwapDimsTester(int pixType, int x, int y, int z, int t) 
     1037  { 
     1038    int c = 3; 
     1039    ChannelOrder swappedOrder = ChannelOrder.TCZ; // original order is ZCT 
     1040     
     1041    String path = constructFakeFilename("swapDims", pixType, x, y, z, c, t, -1, false, -1, false, -1); 
     1042 
     1043    ImagePlus[] imps = null; 
     1044     
     1045    try { 
     1046      ImporterOptions options = new ImporterOptions(); 
     1047      options.setId(path); 
     1048      options.setSwapDimensions(true); 
     1049      options.setInputOrder(0, bfChanOrd(swappedOrder)); 
     1050      imps = BF.openImagePlus(options); 
     1051    } 
     1052    catch (IOException e) { 
     1053      fail(e.getMessage()); 
     1054    } 
     1055    catch (FormatException e) { 
     1056      fail(e.getMessage()); 
     1057    } 
     1058 
     1059    impsCountTest(imps,1); 
     1060 
     1061    ImagePlus imp = imps[0]; 
     1062     
     1063    xyzctTest(imp,x,y,t,c,z); // Z<->T swapped 
     1064 
     1065    swappedZtTest(imp,z,c,t); 
     1066  } 
     1067 
     1068  /** open a fakefile series either as separate ImagePluses or as one ImagePlus depending on input flag allOfThem */ 
     1069  private ImagePlus[] openSeriesTest(String fakeFileName, boolean allOfThem) 
     1070  { 
     1071    ImagePlus[] imps = null; 
     1072     
     1073    try { 
     1074      ImporterOptions options = new ImporterOptions(); 
     1075      options.setId(fakeFileName); 
     1076      options.setOpenAllSeries(allOfThem); 
     1077      imps = BF.openImagePlus(options); 
     1078    } 
     1079    catch (IOException e) { 
     1080      fail(e.getMessage()); 
     1081    } 
     1082    catch (FormatException e) { 
     1083      fail(e.getMessage()); 
     1084    } 
     1085     
     1086    return imps; 
     1087  } 
     1088   
     1089  private void datasetOpenAllSeriesTester(boolean allOfThem) 
     1090  { 
     1091    int x = 55, y = 20, z = 2, c = 3, t = 4, s = 5; 
     1092     
     1093    String path = constructFakeFilename("openAllSeries", FormatTools.UINT32, x, y, z, c, t, s, false, -1, false, -1); 
     1094     
     1095    int expectedNumSeries = 1; 
     1096    if (allOfThem) 
     1097      expectedNumSeries = s; 
     1098     
     1099    ImagePlus[] imps = openSeriesTest(path,allOfThem); 
     1100    impsCountTest(imps,expectedNumSeries); 
     1101    for (int i = 0; i < expectedNumSeries; i++) 
     1102      xyzctTest(imps[i],x,y,z,c,t); 
     1103  } 
     1104   
     1105  private void datasetConcatenateTester(int pixType, int x, int y, int z, int c, int t, int s) 
     1106  { 
     1107    assertTrue(s >= 1);  // necessary for this test 
     1108     
     1109    // open all series as one 
     1110     
     1111    String path = constructFakeFilename("concat", pixType, x, y, z, c, t, s, false, -1, false, -1); 
     1112     
     1113    ImagePlus[] imps = null; 
     1114     
     1115    try { 
     1116      ImporterOptions options = new ImporterOptions(); 
     1117      options.setId(path); 
     1118      options.setOpenAllSeries(true); 
     1119      options.setConcatenate(true); 
     1120      imps = BF.openImagePlus(options); 
     1121    } 
     1122    catch (IOException e) { 
     1123      fail(e.getMessage()); 
     1124    } 
     1125    catch (FormatException e) { 
     1126      fail(e.getMessage()); 
     1127    } 
     1128 
     1129    // test results 
     1130     
     1131    impsCountTest(imps,1); 
     1132 
     1133    multipleSeriesInZtcOrderTest(imps[0],s,z,c,t); 
     1134  } 
     1135   
     1136  private void autoscaleTester(int pixType, boolean wantAutoscale) 
     1137  { 
     1138    final int sizeZ = 2, sizeC = 3, sizeT = 4, sizeX = 51, sizeY = 16; 
     1139    final String path = constructFakeFilename("autoscale",pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, -1, false, -1, false, -1); 
     1140     
     1141    ImagePlus[] imps = null; 
     1142     
     1143    try { 
     1144      ImporterOptions options = new ImporterOptions(); 
     1145      options.setAutoscale(wantAutoscale); 
     1146      options.setId(path); 
     1147      imps = BF.openImagePlus(options); 
     1148    } 
     1149    catch (IOException e) { 
     1150      fail(e.getMessage()); 
     1151    } 
     1152    catch (FormatException e) { 
     1153      fail(e.getMessage()); 
     1154    } 
     1155     
     1156    impsCountTest(imps,1); 
     1157     
     1158    ImagePlus imp = imps[0]; 
     1159 
     1160    xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,sizeT); 
     1161     
     1162    stackTest(imp,sizeZ*sizeC*sizeT); 
     1163 
     1164    calibrationTest(imp,pixType); 
     1165     
     1166    long maxPixVal = minPixelValue(pixType)+sizeX-1; 
     1167    long maxIndex = sizeZ*sizeC*sizeT - 1; 
     1168     
     1169    long expectedMax = expectedMax(pixType,wantAutoscale,maxPixVal,maxIndex); 
     1170    long expectedMin = expectedMin(pixType,wantAutoscale); 
     1171     
     1172    minMaxTest(imp,expectedMin,expectedMax); 
     1173  } 
    9531174   
    9541175  private void colorCompositeTester(int pixType, boolean indexed, int rgb, boolean falseColor, int sizeC, int numSeries) 
     
    9661187     
    9671188    ImagePlus[] imps = null; 
    968     ImagePlus imp = null; 
    969     CompositeImage ci = null; 
    9701189     
    9711190    try { 
     
    9861205    impsCountTest(imps,1); 
    9871206     
    988     imp = imps[0]; 
     1207    ImagePlus imp = imps[0]; 
    9891208 
    9901209    int lutLen = 3; 
     
    9961215    assertTrue(imp.isComposite()); 
    9971216     
    998     ci = (CompositeImage)imp; 
     1217    CompositeImage ci = (CompositeImage)imp; 
    9991218     
    10001219    assertFalse(ci.hasCustomLuts()); 
     
    10351254     
    10361255    ImagePlus[] imps = null; 
    1037     ImagePlus imp = null; 
    1038     CompositeImage ci = null; 
    10391256     
    10401257    try { 
     
    10531270    impsCountTest(imps,1); 
    10541271     
    1055     imp = imps[0]; 
     1272    ImagePlus imp = imps[0]; 
    10561273     
    10571274    int lutLen = 3; 
     
    10631280    assertTrue(imp.isComposite()); 
    10641281     
    1065     ci = (CompositeImage)imp; 
     1282    CompositeImage ci = (CompositeImage)imp; 
    10661283     
    10671284    assertFalse(ci.hasCustomLuts()); 
     
    10811298     
    10821299    ImagePlus[] imps = null; 
    1083     ImagePlus imp = null; 
    1084     CompositeImage ci = null; 
    10851300     
    10861301    try { 
     
    10991314    impsCountTest(imps,1); 
    11001315     
    1101     imp = imps[0]; 
     1316    ImagePlus imp = imps[0]; 
    11021317     
    11031318    xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,sizeT); 
     
    11051320    assertTrue(imp.isComposite()); 
    11061321     
    1107     ci = (CompositeImage)imp; 
     1322    CompositeImage ci = (CompositeImage)imp; 
    11081323     
    11091324    assertFalse(ci.hasCustomLuts()); 
     
    11251340     
    11261341    String path = constructFakeFilename("colorCustom", pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries, false, -1, false, -1); 
     1342     
    11271343    ImagePlus[] imps = null; 
    1128     ImagePlus imp = null; 
    1129     CompositeImage ci = null; 
    11301344     
    11311345    try { 
     
    11491363    impsCountTest(imps,1); 
    11501364     
    1151     imp = imps[0]; 
     1365    ImagePlus imp = imps[0]; 
    11521366     
    11531367    xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,sizeT); 
     
    11551369    assertTrue(imp.isComposite()); 
    11561370     
    1157     ci = (CompositeImage)imp; 
     1371    CompositeImage ci = (CompositeImage)imp; 
    11581372     
    11591373    assertFalse(ci.hasCustomLuts()); 
     
    11721386      // open stack 
    11731387      ImagePlus[] imps = null; 
     1388     
    11741389      try { 
    11751390        ImporterOptions options = new ImporterOptions(); 
     
    11871402      // test results 
    11881403      impsCountTest(imps,1); 
     1404       
    11891405      ImagePlus imp = imps[0]; 
     1406       
    11901407      xyzctTest(imp,x,y,z,c,t); 
    11911408   
     
    11961413  { 
    11971414    int x = 50, y = 15, z = 3, c = 1, t = 1; 
     1415     
    11981416    String path = constructFakeFilename("memRec", FormatTools.UINT8, x, y, z, c, t, -1, false, -1, false, -1); 
     1417     
    11991418    ImagePlus[] imps = null; 
    1200     ImagePlus imp = null; 
    12011419     
    12021420    assertTrue(y > 10);  // needed for this test 
     
    12201438    // basic tests 
    12211439    impsCountTest(imps,1); 
    1222     imp = imps[0]; 
     1440     
     1441    ImagePlus imp = imps[0]; 
     1442     
    12231443    xyzctTest(imp,x,y,z,c,t); 
    12241444 
     
    12471467  {  
    12481468    int pixType = FormatTools.UINT8, x=50, y=5; 
     1469 
    12491470    String path = constructFakeFilename("range", pixType, x, y, z, c, t, -1, false, -1, false, -1); 
     1471     
    12501472    ImagePlus[] imps = null; 
     1473 
    12511474    try { 
    12521475      ImporterOptions options = new ImporterOptions(); 
     
    13071530    // open image 
    13081531    ImagePlus[] imps = null; 
     1532     
    13091533    try { 
    13101534      ImporterOptions options = new ImporterOptions(); 
     
    13231547    // test results 
    13241548    impsCountTest(imps,1); 
    1325     xyzctTest(imps[0],cropSize,cropSize,1,1,1); 
     1549 
     1550    ImagePlus imp = imps[0]; 
     1551     
     1552    xyzctTest(imp,cropSize,cropSize,1,1,1); 
    13261553     
    13271554    // test we got the right pixels 
    1328     ImageProcessor proc = imps[0].getProcessor(); 
    1329      
    1330     for (int ix = 0; ix < cropSize; ix++) 
    1331       for (int iy = 0; iy < cropSize; iy++) 
    1332         assertEquals(ox+ix,proc.getPixelValue(ix, iy),0); 
     1555    croppedPixelsTest(imp,ox,cropSize); 
    13331556  } 
    13341557 
     
    13441567     
    13451568    ImagePlus[] imps = null; 
    1346     ImagePlus imp = null; 
    13471569     
    13481570    try { 
     
    13621584     
    13631585    impsCountTest(imps,1); 
    1364     imp = imps[0]; 
     1586     
     1587    ImagePlus imp = imps[0]; 
     1588     
    13651589    xyzctTest(imps[0],sizeCrop,sizeCrop,sizeZ,sizeC,sizeT); 
    13661590 
     
    13801604    } 
    13811605 
    1382     /* 
    1383     System.out.println("comboCropAutoScale :: PixType("+FormatTools.getPixelTypeString(pixType)+")"); 
    1384     System.out.println("  imp max min "+(long)imp.getProcessor().getMax()+" "+(long)imp.getProcessor().getMin()); 
    1385     System.out.println("  exp max min "+expectedMax+" "+expectedMin); 
    1386     */ 
    1387      
    1388     ImageStack st = imp.getStack(); 
    1389     int numSlices = st.getSize(); 
    1390     for (int i = 0; i < numSlices; i++) 
    1391     { 
    1392       ImageProcessor proc = st.getProcessor(i+1); 
    1393       assertEquals(expectedMin,proc.getMin(),0.1); 
    1394       assertEquals(expectedMax,proc.getMax(),0.1); 
    1395     } 
     1606    minMaxTest(imp,expectedMin,expectedMax); 
    13961607  } 
    13971608   
     
    14021613 
    14031614    final int sizeX = 50, sizeY = 20, sizeZ = 5, sizeC = 3, sizeT = 7, series = 4; 
     1615     
    14041616    final String path = constructFakeFilename("concatSplitZ", 
    14051617      FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, series, false, -1, false, -1); 
     
    14071619    // open image 
    14081620    ImagePlus[] imps = null; 
     1621 
    14091622    try { 
    14101623      ImporterOptions options = new ImporterOptions(); 
     
    14191632    catch (FormatException e) { 
    14201633      fail(e.getMessage()); 
    1421       } 
     1634    } 
    14221635     
    14231636    // one image per focal plane 
    14241637    impsCountTest(imps,sizeZ); 
    14251638 
    1426     // from ZCT order: Z pulled out, CT in order 
    1427     for (int z = 0; z < sizeZ; z++) 
    1428     { 
    1429       ImagePlus imp = imps[z]; 
    1430       xyzctTest(imp,sizeX,sizeY,1,sizeC,sizeT); 
    1431       stackTest(imp,series*sizeC*sizeT); 
    1432       ImageStack st = imp.getStack(); 
    1433       for (int s = 0; s < series; s++) { 
    1434         int slice = s*sizeC*sizeT; 
    1435         for (int t = 0; t < sizeT; t++) { 
    1436           for (int c = 0; c < sizeC; c++) { 
    1437             //System.out.println("index "+index); 
    1438             ImageProcessor proc = st.getProcessor(++slice); 
    1439             //System.out.println("s z c t "+s+" "+z+" "+c+" "+t); 
    1440             //System.out.println("z c t "+z+" "+c+" "+t); 
    1441             //System.out.println("is iz ic it "+sIndex(proc)+" "+zIndex(proc)+" "+cIndex(proc)+" "+tIndex(proc)); 
    1442             // test the values 
    1443             assertEquals(z,zIndex(proc)); 
    1444             assertEquals(c,cIndex(proc)); 
    1445             assertEquals(t,tIndex(proc)); 
    1446             assertEquals(s,sIndex(proc)); 
    1447           } 
    1448         } 
    1449       } 
    1450     } 
     1639    imageSeriesInZctOrderTest(imps,series,sizeX,sizeY,sizeZ,sizeC,sizeT); 
    14511640  } 
    14521641   
     
    14571646 
    14581647    final int sizeX = 50, sizeY = 20, sizeZ = 5, sizeC = 3, sizeT = 7, series = 4; 
     1648     
    14591649    final String path = constructFakeFilename("concatSplitC", 
    14601650      FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, series, false, -1, false, -1); 
     
    14621652    // open image 
    14631653    ImagePlus[] imps = null; 
     1654     
    14641655    try { 
    14651656      ImporterOptions options = new ImporterOptions(); 
     
    14741665    catch (FormatException e) { 
    14751666      fail(e.getMessage()); 
    1476       } 
     1667    } 
    14771668     
    14781669    // one image per channel 
    14791670    impsCountTest(imps,sizeC); 
    14801671     
    1481     // from ZCT order: C pulled out, ZT in order 
    1482     for (int c = 0; c < sizeC; c++) 
    1483     { 
    1484       ImagePlus imp = imps[c]; 
    1485       xyzctTest(imp,sizeX,sizeY,sizeZ,1,sizeT); 
    1486       stackTest(imp,series*sizeZ*sizeT); 
    1487       ImageStack st = imp.getStack(); 
    1488       for (int s = 0; s < series; s++) { 
    1489         int slice = s*sizeZ*sizeT; 
    1490         for (int t = 0; t < sizeT; t++) { 
    1491           for (int z = 0; z < sizeZ; z++) { 
    1492             ImageProcessor proc = st.getProcessor(++slice); 
    1493             //System.out.println("index "+index); 
    1494             //System.out.println("s z c t "+s+" "+z+" "+c+" "+t); 
    1495             //System.out.println("iz ic it "+zIndex(proc)+" "+cIndex(proc)+" "+tIndex(proc)); 
    1496             // test the values 
    1497             assertEquals(z,zIndex(proc)); 
    1498             assertEquals(c,cIndex(proc)); 
    1499             assertEquals(t,tIndex(proc)); 
    1500             assertEquals(s,sIndex(proc)); 
    1501           } 
    1502         } 
    1503       } 
    1504     } 
     1672    imageSeriesInCztOrderTest(imps,series,sizeX,sizeY,sizeZ,sizeC,sizeT); 
    15051673  } 
    15061674   
     
    15111679 
    15121680    final int sizeX = 50, sizeY = 20, sizeZ = 5, sizeC = 3, sizeT = 7, series = 4; 
     1681   
    15131682    final String path = constructFakeFilename("concatSplitT", 
    15141683      FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, series, false, -1, false, -1); 
     
    15161685    // open image 
    15171686    ImagePlus[] imps = null; 
     1687     
    15181688    try { 
    15191689      ImporterOptions options = new ImporterOptions(); 
     
    15281698    catch (FormatException e) { 
    15291699      fail(e.getMessage()); 
    1530       } 
     1700    } 
    15311701     
    15321702    // one image per time point 
    15331703    impsCountTest(imps,sizeT); 
    15341704     
    1535     // from ZCT order: T pulled out, ZC in order 
    1536     for (int t = 0; t < sizeT; t++) 
    1537     { 
    1538       ImagePlus imp = imps[t]; 
    1539       xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,1); 
    1540       stackTest(imp,series*sizeZ*sizeC); 
    1541       ImageStack st = imp.getStack(); 
    1542       for (int s = 0; s < series; s++) { 
    1543         int slice = s*sizeZ*sizeC; 
    1544         for (int c = 0; c < sizeC; c++) { 
    1545           for (int z = 0; z < sizeZ; z++) { 
    1546             ImageProcessor proc = st.getProcessor(++slice); 
    1547             //System.out.println("index "+index); 
    1548             //System.out.println("s z c t "+s+" "+z+" "+c+" "+t); 
    1549             //System.out.println("iz ic it "+zIndex(proc)+" "+cIndex(proc)+" "+tIndex(proc)); 
    1550             // test the values 
    1551             assertEquals(z,zIndex(proc)); 
    1552             assertEquals(c,cIndex(proc)); 
    1553             assertEquals(t,tIndex(proc)); 
    1554             assertEquals(s,sIndex(proc)); 
    1555           } 
    1556         } 
    1557       } 
    1558     } 
     1705    imageSeriesInTzcOrderTest(imps,series,sizeX,sizeY,sizeZ,sizeC,sizeT); 
    15591706  } 
    15601707   
     
    15681715 
    15691716    ImagePlus[] imps = null; 
    1570     ImagePlus imp = null; 
    1571     CompositeImage ci = null; 
    15721717     
    15731718    try { 
     
    15861731    impsCountTest(imps,1); 
    15871732     
    1588     imp = imps[0]; 
     1733    ImagePlus imp = imps[0]; 
    15891734 
    15901735    xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,sizeT); 
     
    15921737    assertTrue(imp.isComposite()); 
    15931738 
    1594     ci = (CompositeImage)imp; 
     1739    CompositeImage ci = (CompositeImage)imp; 
    15951740     
    15961741    assertFalse(ci.hasCustomLuts()); 
     
    16331778 
    16341779    ImagePlus[] imps = null; 
     1780     
    16351781    try { 
    16361782      ImporterOptions options = new ImporterOptions(); 
     
    16451791    catch (FormatException e) { 
    16461792      fail(e.getMessage()); 
    1647       } 
     1793    } 
    16481794     
    16491795    impsCountTest(imps,1); 
     
    16651811     
    16661812    ImagePlus[] imps = null; 
     1813     
    16671814    try { 
    16681815      ImporterOptions options = new ImporterOptions(); 
     
    16811828     
    16821829    impsCountTest(imps,1); 
     1830     
    16831831    stackTest(imps[0],16); // one loaded as one set with 16 slices 
    16841832     
     
    17011849     
    17021850    impsCountTest(imps,1); 
     1851     
    17031852    stackTest(imps[0],32); // both loaded as one set of 32 slices 
    17041853  } 
     
    17451894     
    17461895    ImagePlus[] imps = null; 
    1747     ImagePlus imp = null; 
    17481896     
    17491897    try { 
     
    17621910    impsCountTest(imps,1); 
    17631911     
    1764     imp = imps[0]; 
     1912    ImagePlus imp = imps[0]; 
    17651913 
    17661914    xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,sizeT); 
     
    20712219  { 
    20722220    final int sizeX = 50, sizeY = 20, sizeZ = 5, sizeC = 3, sizeT = 7; 
     2221 
    20732222    final String path = constructFakeFilename("splitC", 
    20742223      FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, -1, false, -1, false, -1); 
     
    20762225    // open image 
    20772226    ImagePlus[] imps = null; 
     2227     
    20782228    try { 
    20792229      ImporterOptions options = new ImporterOptions(); 
     
    20922242    impsCountTest(imps,sizeC); 
    20932243     
    2094     // unwind ZCT loop : C pulled outside, ZT in order 
    2095     for (int c = 0; c < sizeC; c++) { 
    2096       ImagePlus imp = imps[c]; 
    2097       xyzctTest(imp,sizeX,sizeY,sizeZ,1,sizeT); 
    2098       stackTest(imp,sizeZ * sizeT); 
    2099       ImageStack st = imp.getStack(); 
    2100       int slice = 0; 
    2101       for (int t = 0; t < sizeT; t++) { 
    2102         for (int z = 0; z < sizeZ; z++) { 
    2103           ImageProcessor proc = st.getProcessor(++slice); 
    2104           // test the values 
    2105           assertEquals(z,zIndex(proc)); 
    2106           assertEquals(c,cIndex(proc)); 
    2107           assertEquals(t,tIndex(proc)); 
    2108         } 
    2109       } 
    2110     } 
     2244    imagesInCztOrderTest(imps,sizeX,sizeY,sizeZ,sizeC,sizeT); 
    21112245  } 
    21122246   
     
    21152249  { 
    21162250    final int sizeX = 50, sizeY = 20, sizeZ = 5, sizeC = 3, sizeT = 7; 
     2251     
    21172252    final String path = constructFakeFilename("splitZ", 
    21182253      FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, -1, false, -1, false, -1); 
     
    21202255    // open image 
    21212256    ImagePlus[] imps = null; 
     2257     
    21222258    try { 
    21232259      ImporterOptions options = new ImporterOptions(); 
     
    21312267    catch (FormatException e) { 
    21322268      fail(e.getMessage()); 
    2133       } 
     2269    } 
    21342270     
    21352271    // one image per focal plane 
    21362272    impsCountTest(imps,sizeZ); 
    21372273 
    2138     // unwind ZCT loop : Z pulled outside, CT in order 
    2139     for (int z = 0; z < sizeZ; z++) { 
    2140       ImagePlus imp = imps[z]; 
    2141       xyzctTest(imp,sizeX,sizeY,1,sizeC,sizeT); 
    2142       stackTest(imp,sizeC * sizeT); 
    2143       ImageStack st = imp.getStack(); 
    2144       int slice = 0; 
    2145       for (int t = 0; t < sizeT; t++) { 
    2146         for (int c = 0; c < sizeC; c++) { 
    2147           ImageProcessor proc = st.getProcessor(++slice); 
    2148           // test the values 
    2149           assertEquals(z,zIndex(proc)); 
    2150           assertEquals(c,cIndex(proc)); 
    2151           assertEquals(t,tIndex(proc)); 
    2152         } 
    2153       } 
    2154     } 
     2274    imagesInZctOrderTest(imps,sizeX,sizeY,sizeZ,sizeC,sizeT); 
    21552275  } 
    21562276   
     
    21592279  { 
    21602280    final int sizeX = 50, sizeY = 20, sizeZ = 5, sizeC = 3, sizeT = 7; 
     2281   
    21612282    final String path = constructFakeFilename("splitT", 
    21622283      FormatTools.UINT8, 50, 20, sizeZ, sizeC, sizeT, -1, false, -1, false, -1); 
     
    21642285    // open image 
    21652286    ImagePlus[] imps = null; 
     2287     
    21662288    try { 
    21672289      ImporterOptions options = new ImporterOptions(); 
     
    21752297    catch (FormatException e) { 
    21762298      fail(e.getMessage()); 
    2177       } 
     2299    } 
    21782300     
    21792301    // one image per time point 
    21802302    impsCountTest(imps,sizeT); 
    2181      
    2182     // unwind ZTC loop : T pulled outside, ZC in order 
    2183     for (int t = 0; t < sizeT; t++) { 
    2184       ImagePlus imp = imps[t]; 
    2185       xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,1); 
    2186       stackTest(imp,sizeZ * sizeC); 
    2187       ImageStack st = imp.getStack(); 
    2188       int slice = 0; 
    2189       for (int c = 0; c < sizeC; c++) { 
    2190         for (int z = 0; z < sizeZ; z++) { 
    2191           ImageProcessor proc = st.getProcessor(++slice); 
    2192           // test the values 
    2193           assertEquals(z,zIndex(proc)); 
    2194           assertEquals(c,cIndex(proc)); 
    2195           assertEquals(t,tIndex(proc)); 
    2196         } 
    2197       } 
    2198     } 
     2303 
     2304    imagesInTzcOrderTest(imps,sizeX,sizeY,sizeZ,sizeC,sizeT); 
    21992305  } 
    22002306 
     
    22352341 
    22362342  @Test 
    2237   public void testComboConcatSplitZ() 
     2343  public void testComboConcatSplitFocalPlanes() 
    22382344  { 
    22392345    comboConcatSplitFocalPlanesTester(); 
     
    22412347 
    22422348  @Test 
    2243   public void testComboConcatSplitC() 
     2349  public void testComboConcatSplitChannels() 
    22442350  { 
    22452351    comboConcatSplitChannelsTester(); 
     
    22472353 
    22482354  @Test 
    2249   public void testComboConcatSplitT() 
     2355  public void testComboConcatSplitTimepoints() 
    22502356  { 
    22512357    comboConcatSplitTimepointsTester(); 
     
    22762382   
    22772383    ImagePlus[] imps = null; 
     2384 
    22782385    try { 
    22792386      ImporterOptions options = new ImporterOptions(); 
     
    22972404    impsCountTest(imps,sizeT);  // we split on Z but that dim was swapped with T 
    22982405 
    2299     for (int zIndex = 0; zIndex < sizeT; zIndex++)  // sizeT = Z 
    2300     { 
    2301       ImagePlus imp = imps[zIndex]; 
    2302        
    2303       int numC = numInSeries(start,sizeC-1,stepBy); 
    2304  
    2305       xyzctTest(imp,cropSizeX,cropSizeY,1,sizeZ,numC); // all dims changed 
    2306    
    2307       stackTest(imp,sizeZ*numC);  // sizeZ = C, numC = T 
    2308        
    2309       ImageStack st = imp.getStack(); 
    2310        
    2311       int slice = 0; 
    2312       for (int tIndex = start; tIndex < sizeC; tIndex += stepBy) 
    2313         for (int cIndex = 0; cIndex < sizeZ; cIndex++) 
    2314         { 
    2315           ImageProcessor proc = st.getProcessor(++slice); 
    2316            
    2317           assertEquals(cropSizeX,proc.getWidth()); 
    2318           assertEquals(cropSizeY,proc.getHeight()); 
    2319  
    2320           final int actualZ = tIndex(proc); 
    2321           final int actualC = zIndex(proc); 
    2322           final int actualT = cIndex(proc); 
    2323            
    2324           assertEquals(zIndex, actualZ); 
    2325           assertEquals(cIndex, actualC); 
    2326           assertEquals(tIndex, actualT); 
    2327         } 
    2328     } 
     2406    stackCtzSwappedAndCroppedTest(imps,cropSizeX,cropSizeY,sizeZ,sizeC,sizeT,start,stepBy); 
    23292407  } 
    23302408 
     
    23492427 
    23502428    ImagePlus[] imps = null; 
    2351     ImagePlus imp = null; 
    2352     CompositeImage ci = null; 
    23532429     
    23542430    try { 
     
    23672443    impsCountTest(imps,1); 
    23682444     
    2369     imp = imps[0]; 
     2445    ImagePlus imp = imps[0]; 
    23702446    
    23712447    System.out.println("  Returned imp: Z = " +imp.getNSlices()+ " C = " +imp.getNChannels()+" T = "+imp.getNFrames()); 
     
    23932469    if (imp.isComposite()) 
    23942470    { 
    2395       ci = (CompositeImage)imp; 
     2471      CompositeImage ci = (CompositeImage)imp; 
    23962472     
    23972473      assertFalse(ci.hasCustomLuts()); 
Note: See TracChangeset for help on using the changeset viewer.