Changeset 6250


Ignore:
Timestamp:
05/07/10 16:53:52 (10 years ago)
Author:
bdezonia
Message:

Further implementation

File:
1 edited

Legend:

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

    r6248 r6250  
    2323  private static final boolean debug = true; 
    2424 
    25   // TODO - in place to switch off tests that interface with gui 
    26   private static final boolean runAllTests = true; 
    27    
    2825  private enum Axis {Z,C,T}; 
    2926   
     
    126123    assertEquals(x,ip.getWidth()); 
    127124    assertEquals(y,ip.getHeight()); 
    128     assertEquals(z,ip.getNSlices()); 
    129     assertEquals(c,ip.getNChannels()); 
     125    assertEquals(z,ip.getNSlices());    // tricky - these last 3 getters have side effects that change their output. 
     126    assertEquals(c,ip.getNChannels());  // TODO - How to test? 
    130127    assertEquals(t,ip.getNFrames()); 
    131128  } 
     
    197194  } 
    198195   
    199   private void datasetSwapDimsTest(int pixType, String order, int x, int y, int z, int c, int t) 
    200   { 
     196  private void datasetSwapDimsTest(int pixType, int x, int y, int z, int t) 
     197  { 
     198    int c = 3; String order = "XYZCT"; 
    201199    String path = constructFakeFilename(order, pixType, x, y, z, c, t, -1); 
    202200    ImagePlus[] imps = null; 
     
    221219    assertEquals(z*c*t,numSlices); 
    222220 
    223     System.out.println("Numslices == " + numSlices); 
     221    System.out.println("datasetSwapDimsTest()"); 
     222    System.out.println("  Numslices == " + numSlices); 
     223     
     224    int maxZ = -1; 
     225    int maxT = -1; 
     226    int tmp; 
    224227    for (int i = 0; i < numSlices; i++) 
    225       printVals(st.getProcessor(i+1)); 
    226  
    227     // TODO - do some tests on order of dims of created images 
     228    { 
     229      ImageProcessor proc = st.getProcessor(i+1); 
     230      printVals(proc); 
     231      tmp = zIndex(proc)+1; 
     232      if (maxZ < tmp) maxZ = tmp; 
     233      tmp = tIndex(proc)+1; 
     234      if (maxT < tmp) maxT = tmp; 
     235    } 
     236    assertEquals(z,maxT); 
     237    assertEquals(t,maxZ); 
    228238  } 
    229239 
     
    297307  private void memorySpecifyZRangeTest() 
    298308  {  
    299     int pixType = FormatTools.UINT8, x=30, y=30, z=5, c=2, t=4, s=-1; 
     309    int pixType = FormatTools.UINT8, x=30, y=30, z=6, c=2, t=4, s=-1; 
    300310    String path = constructFakeFilename("range", pixType, x, y, z, c, t, s); 
    301311    ImagePlus[] imps = null; 
     
    303313      ImporterOptions options = new ImporterOptions(); 
    304314      options.setId(path); 
    305       options.setZBegin(0, 0); 
    306       options.setZEnd(0, 4); 
     315      options.setZBegin(0, 1); 
     316      options.setZEnd(0, 5); 
    307317      options.setZStep(0, 2); 
    308318      imps = BF.openImagePlus(options); 
     
    315325    } 
    316326     
    317     // should have the data: one series, all t's, all c's, z's from 1 to 3 by 2 
     327    // should have the data: one series, all t's, all c's, z's from 1 to 5 by 2 
    318328    assertNotNull(imps); 
    319329    assertTrue(imps.length == 1); 
     
    324334    ImageStack st = ip.getStack(); 
    325335    int numSlices = st.getSize(); 
    326     assertEquals(16,numSlices); 
     336    assertEquals(3*c*t,numSlices); 
     337 
    327338    System.out.println("SpecifyZRangeTest: slices below"); 
    328339    for (int i = 0; i < numSlices; i++) 
    329       printVals(st.getProcessor(i)); 
     340      printVals(st.getProcessor(i+1)); 
    330341     
    331342    //TODO - some assertions 
     343     
     344    // all t's present 
     345    // all c's present 
     346    // only specific z's present 
    332347     
    333348  } 
     
    353368    } 
    354369     
    355     // should have the data: one series, all t's, all c's, z's from 1 to 3 by 2 
     370    // should have the data: one series, all t's, all z's, c's from 3 to 9 by 3 
    356371    assertNotNull(imps); 
    357372    assertTrue(imps.length == 1); 
     
    362377    ImageStack st = ip.getStack(); 
    363378    int numSlices = st.getSize(); 
    364     assertEquals(48,numSlices); 
    365     System.out.println("SpecifyCRangeTest: slices below"); 
    366     for (int i = 0; i < numSlices; i++) 
    367       printVals(st.getProcessor(i)); 
     379    assertEquals(z*3*t,numSlices); 
     380    //System.out.println("SpecifyCRangeTest: slices below"); 
     381    //for (int i = 0; i < numSlices; i++) 
     382    //  printVals(st.getProcessor(i+1)); 
    368383     
    369384    //TODO - some assertions 
     385     
     386    // all z's present 
     387    // all t's present 
     388    // only specific c's present 
    370389     
    371390  } 
     
    379398      ImporterOptions options = new ImporterOptions(); 
    380399      options.setId(path); 
    381       options.setTBegin(0, 0); 
    382       options.setTEnd(0, 3); 
     400      options.setTBegin(0, 1); 
     401      options.setTEnd(0, 10); 
    383402      options.setTStep(0, 4); 
    384403      imps = BF.openImagePlus(options); 
     
    391410    } 
    392411     
    393     // should have the data: one series, all t's, all c's, z's from 1 to 3 by 2 
     412    // should have the data: one series, all z's, all c's, t's from 1 to 10 by 4 
    394413    assertNotNull(imps); 
    395414    assertTrue(imps.length == 1); 
     
    400419    ImageStack st = ip.getStack(); 
    401420    int numSlices = st.getSize(); 
    402     assertEquals(18,numSlices); 
    403     System.out.println("SpecifyTRangeTest: slices below"); 
    404     for (int i = 0; i < numSlices; i++) 
    405       printVals(st.getProcessor(i)); 
     421    assertEquals(z*c*3,numSlices); 
     422    //System.out.println("SpecifyTRangeTest: slices below"); 
     423    //for (int i = 0; i < numSlices; i++) 
     424    //  printVals(st.getProcessor(i+1)); 
    406425     
    407426    //TODO - some assertions 
    408427     
     428    // all z's present 
     429    // all c's present 
     430    // only specific t's present 
     431 
    409432  } 
    410433   
     
    439462  public void testDefaultBehavior() { 
    440463 
    441     if (runAllTests) 
    442     { 
    443       defaultBehaviorTest(FormatTools.UINT16, 400, 300, 1, 1, 1); 
    444       defaultBehaviorTest(FormatTools.INT16, 107, 414, 1, 1, 1); 
    445       defaultBehaviorTest(FormatTools.UINT32, 323, 206, 3, 2, 1); 
    446       defaultBehaviorTest(FormatTools.UINT8, 57, 78, 5, 4, 3); 
    447       defaultBehaviorTest(FormatTools.INT32, 158, 99, 2, 3, 4); 
    448       defaultBehaviorTest(FormatTools.INT8, 232, 153, 3, 7, 5); 
    449     } 
     464    defaultBehaviorTest(FormatTools.UINT16, 400, 300, 1, 1, 1); 
     465    defaultBehaviorTest(FormatTools.INT16, 107, 414, 1, 1, 1); 
     466    defaultBehaviorTest(FormatTools.UINT32, 323, 206, 3, 2, 1);  // failure on last val = 1,5, 
     467    defaultBehaviorTest(FormatTools.UINT8, 57, 78, 5, 4, 3); 
     468    defaultBehaviorTest(FormatTools.INT32, 158, 99, 2, 3, 4); 
     469    defaultBehaviorTest(FormatTools.INT8, 232, 153, 3, 7, 5); 
    450470  } 
    451471 
     
    453473  public void testOutputStackOrder() 
    454474  { 
    455     if (runAllTests) 
    456     { 
    457       outputStackOrderTest(FormatTools.UINT8, "XYZCT", 82, 47, 2, 3, 4); 
    458       outputStackOrderTest(FormatTools.UINT8, "XYZTC", 82, 47, 2, 3, 4); 
    459       outputStackOrderTest(FormatTools.UINT8, "XYCZT", 82, 47, 2, 3, 4); 
    460       outputStackOrderTest(FormatTools.UINT8, "XYCTZ", 82, 47, 2, 3, 4); 
    461       outputStackOrderTest(FormatTools.UINT8, "XYTCZ", 82, 47, 2, 3, 4); 
    462       outputStackOrderTest(FormatTools.UINT8, "XYTZC", 82, 47, 2, 3, 4); 
    463     } 
     475    outputStackOrderTest(FormatTools.UINT8, "XYZCT", 82, 47, 2, 3, 4); 
     476    outputStackOrderTest(FormatTools.UINT8, "XYZTC", 82, 47, 2, 3, 4); 
     477    outputStackOrderTest(FormatTools.UINT8, "XYCZT", 82, 47, 2, 3, 4); 
     478    outputStackOrderTest(FormatTools.UINT8, "XYCTZ", 82, 47, 2, 3, 4); 
     479    outputStackOrderTest(FormatTools.UINT8, "XYTCZ", 82, 47, 2, 3, 4); 
     480    outputStackOrderTest(FormatTools.UINT8, "XYTZC", 82, 47, 2, 3, 4); 
    464481  } 
    465482     
     
    477494    // TODO - can't really test this with fake files. It needs a series of files from grouping 
    478495    //   to reorder. 
    479     if (runAllTests) 
    480     { 
    481       datasetSwapDimsTest(FormatTools.UINT8, "XYZCT", 82, 47, 2, 3, 4); 
    482     } 
     496     
     497    // TODO - Curtis says I should be able to test this without grouping 
     498     
     499    datasetSwapDimsTest(FormatTools.UINT8, 82, 47, 1, 3); 
     500    datasetSwapDimsTest(FormatTools.UINT16, 82, 47, 3, 1); 
     501    datasetSwapDimsTest(FormatTools.UINT32, 82, 47, 5, 2); 
     502    datasetSwapDimsTest(FormatTools.INT8, 44, 109, 1, 4); 
     503    datasetSwapDimsTest(FormatTools.INT16, 44, 109, 2, 1); 
     504    datasetSwapDimsTest(FormatTools.INT32, 44, 109, 4, 3); 
    483505  } 
    484506   
     
    487509     
    488510    // TODO - Curtis says impl broken right now - will test later 
    489     if (runAllTests) 
    490     { 
    491       // open a dataset that has multiple series 
     511 
     512    // open a dataset that has multiple series 
    492513      //   and should get back a single series 
    493514      datasetConcatenateTest(FormatTools.UINT8, "XYZCT", 82, 47, 1, 1, 1, 1); 
    494515      datasetConcatenateTest(FormatTools.UINT8, "XYZCT", 82, 47, 1, 1, 1, 17); 
    495516      datasetConcatenateTest(FormatTools.UINT8, "XYZCT", 82, 47, 4, 5, 2, 9); 
    496     } 
    497517  } 
    498518   
     
    519539  @Test 
    520540  public void testMemoryVirtualStack() { 
    521     if (runAllTests) 
    522     { 
    523       memoryVirtualStackTest(false); 
    524       memoryVirtualStackTest(true); 
    525     } 
     541    memoryVirtualStackTest(false); 
     542    memoryVirtualStackTest(true); 
    526543  } 
    527544   
     
    537554    memorySpecifyTRangeTest(); 
    538555    //memorySpecifySRangeTest(); 
     556    // TODO : generalize other methods and call here with varying params 
    539557  } 
    540558   
     
    542560  public void testMemoryCrop() { 
    543561     
    544     // TODO - Curtis says impl broken right now - will test later 
    545      
    546     if (runAllTests) 
    547     { 
    548       memoryCropTest(FormatTools.UINT8, 203, 409, 185, 104); 
    549       // TODO - crop window too big or too small 
    550     } 
     562    //TODO - more tests 
     563    memoryCropTest(FormatTools.UINT8, 203, 409, 185, 104); 
    551564  } 
    552565   
     
    595608  } 
    596609} 
    597  
    598   // **************************************************************************************** 
    599   // * old code vault : working copies to be deleted once refactored code proven 
    600   // **************************************************************************************** 
    601    
    602   /* 
    603   @Test 
    604   public void testOutputStackOrderXYZCT() { 
    605     final int x = 82, y = 47, z = 2, c = 3, t = 4; 
    606     final int pixelType = FormatTools.UINT8; 
    607     final String path = constructFakeFilename("xyzct", pixelType, x, y, z, c, t, -1); 
    608     ImagePlus[] imps = null; 
    609     try { 
    610       final ImporterOptions options = new ImporterOptions(); 
    611       options.setId(path); 
    612       options.setStackOrder("XYZCT"); 
    613       imps = BF.openImagePlus(options); 
    614     } 
    615     catch (IOException e) { 
    616       fail(e.getMessage()); 
    617     } 
    618     catch (FormatException e) { 
    619       fail(e.getMessage()); 
    620     } 
    621  
    622     assertNotNull(imps); 
    623     assertEquals(1,imps.length); 
    624      
    625     ImageStack st = imps[0].getStack(); 
    626     int numSlices = st.getSize(); 
    627     assertEquals(z*c*t,numSlices); 
    628     int count = 0; 
    629     // order differs here from other cases 
    630     System.out.println("XYZCT"); 
    631     for (int k = 0; k < t; k++) 
    632       for (int j = 0; j < c; j++) 
    633         for (int i = 0; i < z; i++) 
    634         { 
    635           ImageProcessor proc = st.getProcessor(count+1); 
    636           printVals(proc); 
    637           assertNotNull(proc); 
    638           assertEquals(x,proc.getWidth()); 
    639           assertEquals(y,proc.getHeight()); 
    640           assertEquals(count,iIndex(proc)); 
    641           assertEquals(i,zIndex(proc)); 
    642           assertEquals(j,cIndex(proc)); 
    643           assertEquals(k,tIndex(proc)); 
    644           count++; 
    645         } 
    646   } 
    647    
    648   @Test 
    649   public void testOutputStackOrderXYZTC() { 
    650     final int x = 82, y = 47, z = 2, c = 3, t = 4; 
    651     final int pixelType = FormatTools.UINT8; 
    652     final String path = constructFakeFilename("xyztc", pixelType, x, y, z, c, t, -1); 
    653     ImagePlus[] imps = null; 
    654     try { 
    655       final ImporterOptions options = new ImporterOptions(); 
    656       options.setId(path); 
    657       options.setStackOrder("XYZTC"); 
    658       imps = BF.openImagePlus(options); 
    659     } 
    660     catch (IOException e) { 
    661       fail(e.getMessage()); 
    662     } 
    663     catch (FormatException e) { 
    664       fail(e.getMessage()); 
    665     } 
    666  
    667     assertNotNull(imps); 
    668     assertEquals(1,imps.length); 
    669      
    670     ImageStack st = imps[0].getStack(); 
    671     int numSlices = st.getSize(); 
    672     assertEquals(z*c*t,numSlices); 
    673     int count = 0; 
    674     // order differs here from other cases 
    675     System.out.println("XYZTC"); 
    676     for (int j = 0; j < c; j++) 
    677       for (int k = 0; k < t; k++) 
    678         for (int i = 0; i < z; i++) 
    679         { 
    680           ImageProcessor proc = st.getProcessor(count+1); 
    681           printVals(proc); 
    682           assertNotNull(proc); 
    683           assertEquals(x,proc.getWidth()); 
    684           assertEquals(y,proc.getHeight()); 
    685           //assertEquals(count,iIndex(proc)); 
    686           assertEquals(i,zIndex(proc)); 
    687           assertEquals(j,cIndex(proc)); 
    688           assertEquals(k,tIndex(proc)); 
    689           count++; 
    690         } 
    691   } 
    692    
    693   @Test 
    694   public void testOutputStackOrderXYCZT() { 
    695     final int x = 82, y = 47, z = 2, c = 3, t = 4; 
    696     final int pixelType = FormatTools.UINT8; 
    697     final String path = constructFakeFilename("xyczt", pixelType, x, y, z, c, t, -1); 
    698     ImagePlus[] imps = null; 
    699     try { 
    700       final ImporterOptions options = new ImporterOptions(); 
    701       options.setId(path); 
    702       options.setStackOrder("XYCZT"); 
    703       imps = BF.openImagePlus(options); 
    704     } 
    705     catch (IOException e) { 
    706       fail(e.getMessage()); 
    707     } 
    708     catch (FormatException e) { 
    709       fail(e.getMessage()); 
    710     } 
    711  
    712     assertNotNull(imps); 
    713     assertEquals(1,imps.length); 
    714      
    715     ImageStack st = imps[0].getStack(); 
    716     int numSlices = st.getSize(); 
    717     assertEquals(z*c*t,numSlices); 
    718     int count = 0; 
    719     // order differs here from other cases 
    720     System.out.println("XYCZT"); 
    721     for (int k = 0; k < t; k++) 
    722       for (int i = 0; i < z; i++) 
    723         for (int j = 0; j < c; j++) 
    724         { 
    725           ImageProcessor proc = st.getProcessor(count+1); 
    726           printVals(proc); 
    727           assertNotNull(proc); 
    728           assertEquals(x,proc.getWidth()); 
    729           assertEquals(y,proc.getHeight()); 
    730           //assertEquals(count,iIndex(proc)); 
    731           assertEquals(i,zIndex(proc)); 
    732           assertEquals(j,cIndex(proc)); 
    733           assertEquals(k,tIndex(proc)); 
    734           count++; 
    735         } 
    736   } 
    737    
    738   @Test 
    739   public void testOutputStackOrderXYCTZ() { 
    740     final int x = 82, y = 47, z = 2, c = 3, t = 4; 
    741     final int pixelType = FormatTools.UINT8; 
    742     final String path = constructFakeFilename("xyctz", pixelType, x, y, z, c, t, -1); 
    743     ImagePlus[] imps = null; 
    744     try { 
    745       final ImporterOptions options = new ImporterOptions(); 
    746       options.setId(path); 
    747       options.setStackOrder("XYCTZ"); 
    748       imps = BF.openImagePlus(options); 
    749     } 
    750     catch (IOException e) { 
    751       fail(e.getMessage()); 
    752     } 
    753     catch (FormatException e) { 
    754       fail(e.getMessage()); 
    755     } 
    756  
    757     assertNotNull(imps); 
    758     assertEquals(1,imps.length); 
    759      
    760     ImageStack st = imps[0].getStack(); 
    761     int numSlices = st.getSize(); 
    762     assertEquals(z*c*t,numSlices); 
    763     int count = 0; 
    764     // order differs here from other cases 
    765     System.out.println("XYCTZ"); 
    766     for (int i = 0; i < z; i++) 
    767       for (int k = 0; k < t; k++) 
    768         for (int j = 0; j < c; j++) 
    769         { 
    770           ImageProcessor proc = st.getProcessor(count+1); 
    771           printVals(proc); 
    772           assertNotNull(proc); 
    773           assertEquals(x,proc.getWidth()); 
    774           assertEquals(y,proc.getHeight()); 
    775           //assertEquals(count,iIndex(proc)); 
    776           assertEquals(i,zIndex(proc)); 
    777           assertEquals(j,cIndex(proc)); 
    778           assertEquals(k,tIndex(proc)); 
    779           count++; 
    780         } 
    781   } 
    782    
    783   @Test 
    784   public void testOutputStackOrderXYTZC() { 
    785     final int x = 82, y = 47, z = 2, c = 3, t = 4; 
    786     final int pixelType = FormatTools.UINT8; 
    787     final String path = constructFakeFilename("xytzc", pixelType, x, y, z, c, t, -1); 
    788     ImagePlus[] imps = null; 
    789     try { 
    790       final ImporterOptions options = new ImporterOptions(); 
    791       options.setId(path); 
    792       options.setStackOrder("XYTZC"); 
    793       imps = BF.openImagePlus(options); 
    794     } 
    795     catch (IOException e) { 
    796       fail(e.getMessage()); 
    797     } 
    798     catch (FormatException e) { 
    799       fail(e.getMessage()); 
    800     } 
    801  
    802     assertNotNull(imps); 
    803     assertEquals(1,imps.length); 
    804      
    805     ImageStack st = imps[0].getStack(); 
    806     int numSlices = st.getSize(); 
    807     assertEquals(z*c*t,numSlices); 
    808     int count = 0; 
    809     // order differs here from other cases 
    810     System.out.println("XYTZC"); 
    811     for (int j = 0; j < c; j++) 
    812       for (int i = 0; i < z; i++) 
    813         for (int k = 0; k < t; k++) 
    814         { 
    815           ImageProcessor proc = st.getProcessor(count+1); 
    816           printVals(proc); 
    817           assertNotNull(proc); 
    818           assertEquals(x,proc.getWidth()); 
    819           assertEquals(y,proc.getHeight()); 
    820           //assertEquals(count,iIndex(proc)); 
    821           assertEquals(i,zIndex(proc)); 
    822           assertEquals(j,cIndex(proc)); 
    823           assertEquals(k,tIndex(proc)); 
    824           count++; 
    825         } 
    826   } 
    827    
    828   @Test 
    829   public void testOutputStackOrderXYTCZ() { 
    830     final int x = 82, y = 47, z = 2, c = 3, t = 4; 
    831     final int pixelType = FormatTools.UINT8; 
    832     final String path = constructFakeFilename("xytcz", pixelType, x, y, z, c, t, -1); 
    833     ImagePlus[] imps = null; 
    834     try { 
    835       final ImporterOptions options = new ImporterOptions(); 
    836       options.setId(path); 
    837       options.setStackOrder("XYTCZ"); 
    838       imps = BF.openImagePlus(options); 
    839     } 
    840     catch (IOException e) { 
    841       fail(e.getMessage()); 
    842     } 
    843     catch (FormatException e) { 
    844       fail(e.getMessage()); 
    845     } 
    846  
    847     assertNotNull(imps); 
    848     assertEquals(1,imps.length); 
    849      
    850     ImageStack st = imps[0].getStack(); 
    851     int numSlices = st.getSize(); 
    852     assertEquals(z*c*t,numSlices); 
    853     int count = 0; 
    854     // order differs here from other cases 
    855     System.out.println("XYTCZ"); 
    856     for (int i = 0; i < z; i++) 
    857       for (int j = 0; j < c; j++) 
    858         for (int k = 0; k < t; k++) 
    859         { 
    860           ImageProcessor proc = st.getProcessor(count+1); 
    861           printVals(proc); 
    862           assertNotNull(proc); 
    863           assertEquals(x,proc.getWidth()); 
    864           assertEquals(y,proc.getHeight()); 
    865           //assertEquals(count,iIndex(proc)); 
    866           assertEquals(i,zIndex(proc)); 
    867           assertEquals(j,cIndex(proc)); 
    868           assertEquals(k,tIndex(proc)); 
    869           count++; 
    870         } 
    871   } 
    872 */ 
Note: See TracChangeset for help on using the changeset viewer.