Changeset 6251


Ignore:
Timestamp:
05/10/10 12:58:43 (10 years ago)
Author:
bdezonia
Message:

Further test implementation

File:
1 edited

Legend:

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

    r6250 r6251  
    2121public class ImporterTest { 
    2222 
    23   private static final boolean debug = true; 
    24  
    2523  private enum Axis {Z,C,T}; 
    2624   
     
    3028      int pixelType, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT, int numSeries) 
    3129  { 
     30    // some tests rely on each image being large enough to get the s,i,z,t,c index pixels of a 
     31    // FakeFile. This requires the x value of tested images to be somewhat large. Assert 
     32    // the input image fits the bill 
     33    if (sizeX < 41) 
     34      throw new IllegalArgumentException("constructFakeFilename() - width < 41 : can break some of our tests"); 
     35     
    3236    String fileName = ""; 
    3337     
     
    102106  } 
    103107 
     108  private int numInSeries(int from, int to, int by) 
     109  { 
     110    // could calc this but simple loop suffices for our purposes 
     111    int count = 0; 
     112    for (int i = from; i <= to; i += by) 
     113        count++; 
     114    return count; 
     115  } 
     116   
     117  // note : for now assumes default ZCT ordering 
     118   
     119  private boolean seriesInCorrectOrder(ImageStack st, 
     120      int zFrom, int zTo, int zBy, 
     121      int cFrom, int cTo, int cBy, 
     122      int tFrom, int tTo, int tBy) 
     123  { 
     124    int zs = numInSeries(zFrom,zTo,zBy); 
     125    int cs = numInSeries(cFrom,cTo,cBy); 
     126    int ts = numInSeries(tFrom,tTo,tBy); 
     127     
     128    if ((zs * cs * ts) != st.getSize()) 
     129    { 
     130      System.out.println("seriesInCorrectOrder() - slices don't add up: z"+zs+" X c"+cs+" X t"+ts+" != "+st.getSize()); 
     131      return false; 
     132    } 
     133     
     134    int procNum = 1; 
     135    for (int k = tFrom; k <= tTo; k += tBy) 
     136      for (int j = cFrom; j <= cTo; j += cBy) 
     137        for (int i = zFrom; i <= zTo; i += zBy) 
     138        { 
     139          ImageProcessor proc = st.getProcessor(procNum); 
     140          if ((zIndex(proc) != i) || (cIndex(proc) != j) || (tIndex(proc) != k)) 
     141          { 
     142            System.out.println("seriesInCorrectOrder() - slices out of order: exp i"+i+" j"+j+" k"+k+" != act z"+ 
     143                zIndex(proc)+" c"+cIndex(proc)+" t"+tIndex(proc)+" for proc number "+procNum); 
     144            return false; 
     145          } 
     146          procNum++; 
     147        } 
     148     
     149    return true; 
     150  } 
     151   
    104152  private void defaultBehaviorTest(int pixType, int x, int y, int z, int c, int t) 
    105153  { 
     
    150198     
    151199    ImagePlus ip = imps[0]; 
    152      
    153     // these tests rely on each image being large enough to get the siztc index pixels of a 
    154     // FakeFile. This requires the x value of tested images to be somewhat large. Assert 
    155     // the input image fits the bill 
    156      
    157     assertTrue(ip.getWidth() >= 41); 
    158     assertTrue(ip.getHeight() >= 1); 
    159200     
    160201    ImageStack st = ip.getStack(); 
     
    304345      assertEquals(desireVirtual,ip.getStack().isVirtual()); 
    305346  } 
    306    
    307   private void memorySpecifyZRangeTest() 
     347 
     348  private void memorySpecifyRangeTest(int z, int c, int t, 
     349      int zFrom, int zTo, int zBy, 
     350      int cFrom, int cTo, int cBy, 
     351      int tFrom, int tTo, int tBy) 
    308352  {  
    309     int pixType = FormatTools.UINT8, x=30, y=30, z=6, c=2, t=4, s=-1; 
     353    int pixType = FormatTools.UINT8, x=50, y=5, s=-1; 
    310354    String path = constructFakeFilename("range", pixType, x, y, z, c, t, s); 
    311355    ImagePlus[] imps = null; 
     
    313357      ImporterOptions options = new ImporterOptions(); 
    314358      options.setId(path); 
    315       options.setZBegin(0, 1); 
    316       options.setZEnd(0, 5); 
    317       options.setZStep(0, 2); 
     359      // only set z if nondefault behavior specified 
     360      if ((zFrom != 0) || (zTo != z-1) || (zBy != 1)) 
     361      { 
     362        options.setZBegin(0, zFrom); 
     363        options.setZEnd(0, zTo); 
     364        options.setZStep(0, zBy); 
     365      } 
     366      // only set c if nondefault behavior specified 
     367      if ((cFrom != 0) || (cTo != c-1) || (cBy != 1)) 
     368      { 
     369        options.setCBegin(0, cFrom); 
     370        options.setCEnd(0, cTo); 
     371        options.setCStep(0, cBy); 
     372      } 
     373      // only set t if nondefault behavior specified 
     374      if ((tFrom != 0) || (tTo != t-1) || (tBy != 1)) 
     375      { 
     376        options.setTBegin(0, tFrom); 
     377        options.setTEnd(0, tTo); 
     378        options.setTStep(0, tBy); 
     379      } 
    318380      imps = BF.openImagePlus(options); 
    319381    } 
     
    325387    } 
    326388     
    327     // should have the data: one series, all t's, all c's, z's from 1 to 5 by 2 
     389    // should have the data in one series 
    328390    assertNotNull(imps); 
    329391    assertTrue(imps.length == 1); 
     
    333395    assertTrue(ip.getHeight() == y); 
    334396    ImageStack st = ip.getStack(); 
    335     int numSlices = st.getSize(); 
    336     assertEquals(3*c*t,numSlices); 
    337  
    338     System.out.println("SpecifyZRangeTest: slices below"); 
    339     for (int i = 0; i < numSlices; i++) 
    340       printVals(st.getProcessor(i+1)); 
    341      
    342     //TODO - some assertions 
    343      
    344     // all t's present 
    345     // all c's present 
    346     // only specific z's present 
    347      
    348   } 
    349    
    350   private void memorySpecifyCRangeTest() 
    351   {  
    352     int pixType = FormatTools.UINT8, x=30, y=30, z=4, c=11, t=4, s=-1; 
    353     String path = constructFakeFilename("range", pixType, x, y, z, c, t, s); 
    354     ImagePlus[] imps = null; 
    355     try { 
    356       ImporterOptions options = new ImporterOptions(); 
    357       options.setId(path); 
    358       options.setCBegin(0, 3); 
    359       options.setCEnd(0, 9); 
    360       options.setCStep(0, 3); 
    361       imps = BF.openImagePlus(options); 
    362     } 
    363     catch (IOException e) { 
    364       fail(e.getMessage()); 
    365     } 
    366     catch (FormatException e) { 
    367       fail(e.getMessage()); 
    368     } 
    369      
    370     // should have the data: one series, all t's, all z's, c's from 3 to 9 by 3 
    371     assertNotNull(imps); 
    372     assertTrue(imps.length == 1); 
    373     ImagePlus ip = imps[0]; 
    374     assertNotNull(ip); 
    375     assertTrue(ip.getWidth() == x); 
    376     assertTrue(ip.getHeight() == y); 
    377     ImageStack st = ip.getStack(); 
    378     int numSlices = st.getSize(); 
    379     assertEquals(z*3*t,numSlices); 
     397     
    380398    //System.out.println("SpecifyCRangeTest: slices below"); 
    381399    //for (int i = 0; i < numSlices; i++) 
    382400    //  printVals(st.getProcessor(i+1)); 
    383      
    384     //TODO - some assertions 
    385      
    386     // all z's present 
    387     // all t's present 
    388     // only specific c's present 
    389      
    390   } 
    391    
    392   private void memorySpecifyTRangeTest() 
    393   {  
    394     int pixType = FormatTools.UINT8, x=30, y=30, z=3, c=2, t=12, s=-1; 
    395     String path = constructFakeFilename("range", pixType, x, y, z, c, t, s); 
    396     ImagePlus[] imps = null; 
    397     try { 
    398       ImporterOptions options = new ImporterOptions(); 
    399       options.setId(path); 
    400       options.setTBegin(0, 1); 
    401       options.setTEnd(0, 10); 
    402       options.setTStep(0, 4); 
    403       imps = BF.openImagePlus(options); 
    404     } 
    405     catch (IOException e) { 
    406       fail(e.getMessage()); 
    407     } 
    408     catch (FormatException e) { 
    409       fail(e.getMessage()); 
    410     } 
    411      
    412     // should have the data: one series, all z's, all c's, t's from 1 to 10 by 4 
    413     assertNotNull(imps); 
    414     assertTrue(imps.length == 1); 
    415     ImagePlus ip = imps[0]; 
    416     assertNotNull(ip); 
    417     assertTrue(ip.getWidth() == x); 
    418     assertTrue(ip.getHeight() == y); 
    419     ImageStack st = ip.getStack(); 
    420     int numSlices = st.getSize(); 
    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)); 
    425      
    426     //TODO - some assertions 
    427      
    428     // all z's present 
    429     // all c's present 
    430     // only specific t's present 
    431  
     401         
     402    assertTrue(seriesInCorrectOrder(st,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy)); 
    432403  } 
    433404   
     
    460431 
    461432  @Test 
    462   public void testDefaultBehavior() { 
    463  
     433  public void testDefaultBehavior() 
     434  { 
    464435    defaultBehaviorTest(FormatTools.UINT16, 400, 300, 1, 1, 1); 
    465436    defaultBehaviorTest(FormatTools.INT16, 107, 414, 1, 1, 1); 
     
    482453     
    483454  @Test 
    484   public void testDatasetGroupFiles() { 
     455  public void testDatasetGroupFiles() 
     456  { 
    485457    // TODO - need to enhance FakeFiles first I think 
    486458    //   This option kicks in when you have similarly named files. all the files get loaded 
     
    491463 
    492464  @Test 
    493   public void testDatasetSwapDims() { 
     465  public void testDatasetSwapDims() 
     466  { 
    494467    // TODO - can't really test this with fake files. It needs a series of files from grouping 
    495468    //   to reorder. 
     
    506479   
    507480  @Test 
    508   public void testDatasetConcatenate() { 
     481  public void testDatasetConcatenate() 
     482  { 
    509483     
    510484    // TODO - Curtis says impl broken right now - will test later 
    511485 
    512     // open a dataset that has multiple series 
    513       //   and should get back a single series 
    514       datasetConcatenateTest(FormatTools.UINT8, "XYZCT", 82, 47, 1, 1, 1, 1); 
    515       datasetConcatenateTest(FormatTools.UINT8, "XYZCT", 82, 47, 1, 1, 1, 17); 
    516       datasetConcatenateTest(FormatTools.UINT8, "XYZCT", 82, 47, 4, 5, 2, 9); 
    517   } 
    518    
    519   @Test 
    520   public void testColorMerge() { 
     486    // open a dataset that has multiple series and should get back a single series 
     487    datasetConcatenateTest(FormatTools.UINT8, "XYZCT", 82, 47, 1, 1, 1, 1); 
     488    datasetConcatenateTest(FormatTools.UINT8, "XYZCT", 82, 47, 1, 1, 1, 17); 
     489    datasetConcatenateTest(FormatTools.UINT8, "XYZCT", 82, 47, 4, 5, 2, 9); 
     490  } 
     491   
     492  @Test 
     493  public void testColorMerge() 
     494  { 
    521495    // TODO - Curtis says impl broken right now - will test later 
    522496  } 
    523497   
    524498  @Test 
    525   public void testColorRgbColorize() { 
     499  public void testColorRgbColorize() 
     500  { 
    526501    // TODO - Curtis says impl broken right now - will test later 
    527502  } 
    528503   
    529504  @Test 
    530   public void testColorCustomColorize() { 
     505  public void testColorCustomColorize() 
     506  { 
    531507    // TODO - Curtis says impl broken right now - will test later 
    532508  } 
    533509   
    534510  @Test 
    535   public void testColorAutoscale() { 
     511  public void testColorAutoscale() 
     512  { 
    536513    // TODO - Curtis says impl broken right now - will test later 
    537514  } 
    538515   
    539516  @Test 
    540   public void testMemoryVirtualStack() { 
     517  public void testMemoryVirtualStack() 
     518  { 
    541519    memoryVirtualStackTest(false); 
    542520    memoryVirtualStackTest(true); 
     
    544522   
    545523  @Test 
    546   public void testMemoryRecordModifications() { 
     524  public void testMemoryRecordModifications() 
     525  { 
    547526    // TODO - how to test this? 
    548527  } 
    549528   
    550529  @Test 
    551   public void testMemorySpecifyRange() { 
    552     memorySpecifyZRangeTest(); 
    553     memorySpecifyCRangeTest(); 
    554     memorySpecifyTRangeTest(); 
    555     //memorySpecifySRangeTest(); 
    556     // TODO : generalize other methods and call here with varying params 
    557   } 
    558    
    559   @Test 
    560   public void testMemoryCrop() { 
    561      
    562     //TODO - more tests 
     530  public void testMemorySpecifyRange() 
     531  { 
     532    int z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy; 
     533     
     534    // test z 
     535    z=8; c=3; t=2; zFrom=2; zTo=7; zBy=3; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
     536    memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     537     
     538    // test c 
     539    z=6; c=14; t=4; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=12; cBy=4; tFrom=0; tTo=t-1; tBy=1; 
     540    memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     541     
     542    // test t 
     543    z=3; c=5; t=13; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=4; tTo=13; tBy=2; 
     544    memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     545     
     546    // test a combination of zct's 
     547    z=5; c=4; t=6; zFrom=1; zTo=4; zBy=2; cFrom=1; cTo=3; cBy=1; tFrom=2; tTo=6; tBy=2; 
     548    memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     549  } 
     550   
     551  @Test 
     552  public void testMemoryCrop() 
     553  { 
    563554    memoryCropTest(FormatTools.UINT8, 203, 409, 185, 104); 
    564   } 
    565    
    566   @Test 
    567   public void testSplitChannels() { 
     555    memoryCropTest(FormatTools.UINT8, 203, 409, 203, 409); 
     556    memoryCropTest(FormatTools.UINT8, 100, 30, 3, 3); 
     557    memoryCropTest(FormatTools.INT32, 100, 30, 3, 3); 
     558  } 
     559   
     560  @Test 
     561  public void testSplitChannels() 
     562  { 
    568563    // TODO - Curtis says impl broken right now - will test later 
    569564  } 
    570565   
    571566  @Test 
    572   public void testSplitFocalPlanes() { 
     567  public void testSplitFocalPlanes() 
     568  { 
    573569    // TODO - Curtis says impl broken right now - will test later 
    574570  } 
    575571   
    576572  @Test 
    577   public void testSplitTimepoints() { 
     573  public void testSplitTimepoints() 
     574  { 
    578575    // TODO - Curtis says impl broken right now - will test later 
    579576  } 
     
    581578  // ** Main method ***************************************************************** 
    582579 
    583   public static void main(String[] args) { 
     580  public static void main(String[] args) 
     581  { 
    584582    ImporterTest tester = new ImporterTest(); 
    585583  
    586584    //TODO - we could use reflection to discover all test methods, loop, and run them 
    587      
     585   
     586    // tests of single features 
    588587    tester.testDefaultBehavior(); 
    589588    tester.testOutputStackOrder(); 
     
    603602    tester.testSplitTimepoints(); 
    604603     
    605     // TODO - add combination tests 
     604    // TODO - add tests involving combinations of features 
    606605     
    607606    System.exit(0); 
    608607  } 
    609608} 
     609 
     610 
     611/*  old stuff - keep until replacement code tested 
     612 
     613  private int numPresent(ImageStack st, Axis axis) 
     614  { 
     615    List<Integer> indices = new ArrayList<Integer>(); 
     616     
     617    int count = 0; 
     618    for (int i = 0; i < st.getSize(); i++) 
     619    { 
     620      int currVal = this.index(axis, st.getProcessor(i+1)); 
     621 
     622      //fails 
     623      // (!indices.contains(new Integer(currVal))) 
     624      // 
     625      //  indices.add(new Integer(currVal)); 
     626      //  count++; 
     627      //} 
     628 
     629      boolean found = false; 
     630      for (int j = 0; j < indices.size(); j++) 
     631        if (currVal == indices.get(j)) 
     632        { 
     633          found = true; 
     634          break; 
     635        } 
     636      if (!found) 
     637      { 
     638        count++; 
     639        indices.add(currVal); 
     640      } 
     641    } 
     642    return count; 
     643  } 
     644   
     645private void memorySpecifyZRangeTest() 
     646{  
     647  int pixType = FormatTools.UINT8, x=30, y=30, z=6, c=2, t=4, s=-1; 
     648  int from = 1, to = 5, by = 2; 
     649  String path = constructFakeFilename("range", pixType, x, y, z, c, t, s); 
     650  ImagePlus[] imps = null; 
     651  try { 
     652    ImporterOptions options = new ImporterOptions(); 
     653    options.setId(path); 
     654    options.setZBegin(0, from); 
     655    options.setZEnd(0, to); 
     656    options.setZStep(0, by); 
     657    imps = BF.openImagePlus(options); 
     658  } 
     659  catch (IOException e) { 
     660    fail(e.getMessage()); 
     661  } 
     662  catch (FormatException e) { 
     663    fail(e.getMessage()); 
     664  } 
     665   
     666  // should have the data: one series, all t's, all c's, z's from 1 to 5 by 2 
     667  assertNotNull(imps); 
     668  assertTrue(imps.length == 1); 
     669  ImagePlus ip = imps[0]; 
     670  assertNotNull(ip); 
     671  assertTrue(ip.getWidth() == x); 
     672  assertTrue(ip.getHeight() == y); 
     673  ImageStack st = ip.getStack(); 
     674  int numSlices = st.getSize(); 
     675  assertEquals(numInSeries(from,to,by)*c*t,numSlices); 
     676 
     677  System.out.println("SpecifyZRangeTest: slices below"); 
     678  for (int i = 0; i < numSlices; i++) 
     679  { 
     680    ImageProcessor proc = st.getProcessor(i+1);  
     681    printVals(proc); 
     682  } 
     683   
     684  // all t's present 
     685  //assertEquals(numInSeries(1,t,1), numPresent(st,Axis.T)); 
     686   
     687  // all c's present 
     688  //assertEquals(numInSeries(1,c,1), numPresent(st,Axis.C)); 
     689 
     690  // only specific z's present 
     691  //assertEquals(numInSeries(from,to,by), numPresent(st,Axis.Z)); 
     692   
     693  assertTrue(seriesInCorrectOrder(st,from,to,by,0,c-1,1,0,t-1,1)); 
     694} 
     695 
     696private void memorySpecifyCRangeTest() 
     697{  
     698  int pixType = FormatTools.UINT8, x=30, y=30, z=4, c=11, t=4, s=-1; 
     699  int from = 3, to = 9, by = 3; 
     700  String path = constructFakeFilename("range", pixType, x, y, z, c, t, s); 
     701  ImagePlus[] imps = null; 
     702  try { 
     703    ImporterOptions options = new ImporterOptions(); 
     704    options.setId(path); 
     705    options.setCBegin(0, from); 
     706    options.setCEnd(0, to); 
     707    options.setCStep(0, by); 
     708    imps = BF.openImagePlus(options); 
     709  } 
     710  catch (IOException e) { 
     711    fail(e.getMessage()); 
     712  } 
     713  catch (FormatException e) { 
     714    fail(e.getMessage()); 
     715  } 
     716   
     717  // should have the data: one series, all t's, all z's, c's from 3 to 9 by 3 
     718  assertNotNull(imps); 
     719  assertTrue(imps.length == 1); 
     720  ImagePlus ip = imps[0]; 
     721  assertNotNull(ip); 
     722  assertTrue(ip.getWidth() == x); 
     723  assertTrue(ip.getHeight() == y); 
     724  ImageStack st = ip.getStack(); 
     725  int numSlices = st.getSize(); 
     726  assertEquals(z*numInSeries(from,to,by)*t,numSlices); 
     727  //System.out.println("SpecifyCRangeTest: slices below"); 
     728  //for (int i = 0; i < numSlices; i++) 
     729  //  printVals(st.getProcessor(i+1)); 
     730       
     731  // all t's present 
     732  //assertEquals(numInSeries(1,t,1), numPresent(st,Axis.T)); 
     733   
     734  // all z's present 
     735  //assertEquals(numInSeries(1,z,1), numPresent(st,Axis.Z)); 
     736 
     737  // only specific c's present 
     738  //assertEquals(numInSeries(from,to,by), numPresent(st,Axis.C)); 
     739 
     740  assertTrue(seriesInCorrectOrder(st,0,z-1,1,from,to,by,0,t-1,1)); 
     741} 
     742 
     743private void memorySpecifyTRangeTest() 
     744{  
     745  int pixType = FormatTools.UINT8, x=30, y=30, z=3, c=2, t=12, s=-1; 
     746  int from = 1, to = 10, by = 4; 
     747  String path = constructFakeFilename("range", pixType, x, y, z, c, t, s); 
     748  ImagePlus[] imps = null; 
     749  try { 
     750    ImporterOptions options = new ImporterOptions(); 
     751    options.setId(path); 
     752    options.setTBegin(0, from); 
     753    options.setTEnd(0, to); 
     754    options.setTStep(0, by); 
     755    imps = BF.openImagePlus(options); 
     756  } 
     757  catch (IOException e) { 
     758    fail(e.getMessage()); 
     759  } 
     760  catch (FormatException e) { 
     761    fail(e.getMessage()); 
     762  } 
     763   
     764  // should have the data: one series, all z's, all c's, t's from 1 to 10 by 4 
     765  assertNotNull(imps); 
     766  assertTrue(imps.length == 1); 
     767  ImagePlus ip = imps[0]; 
     768  assertNotNull(ip); 
     769  assertTrue(ip.getWidth() == x); 
     770  assertTrue(ip.getHeight() == y); 
     771  ImageStack st = ip.getStack(); 
     772  int numSlices = st.getSize(); 
     773  assertEquals(z*c*numInSeries(from,to,by),numSlices); 
     774  //System.out.println("SpecifyTRangeTest: slices below"); 
     775  //for (int i = 0; i < numSlices; i++) 
     776  //  printVals(st.getProcessor(i+1)); 
     777   
     778  // all z's present 
     779  //assertEquals(numInSeries(1,z,1), numPresent(st,Axis.Z)); 
     780   
     781  // all c's present 
     782  //assertEquals(numInSeries(1,c,1), numPresent(st,Axis.C)); 
     783 
     784  // only specific t's present 
     785  //assertEquals(numInSeries(from,to,by), numPresent(st,Axis.T)); 
     786   
     787  assertTrue(seriesInCorrectOrder(st,0,z-1,1,0,c-1,1,from,to,by)); 
     788} 
     789 
     790*/ 
Note: See TracChangeset for help on using the changeset viewer.