Changeset 6348


Ignore:
Timestamp:
05/19/10 14:56:47 (10 years ago)
Author:
bdezonia
Message:

minor edits

File:
1 edited

Legend:

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

    r6347 r6348  
    3737//      BF/imageJ returning wrong max num pixels for UINT32 - off by one 
    3838//      memoryRecord failure needs BF code fix 
    39 //      mergeOptions BF api for finishing merge tests 
    40 //      custom color BF api for doing that test 
    41 //      coboCropAutoscale() - autoscale of a cropped image returning min of whole image 
     39//      comboCropAutoscale() - autoscale of a cropped image returning min of whole image 
    4240//  - flesh out existing tests 
    43 //      write tests for the color options : 4 cases - some mention was made that indexcolor is an issue in testing 
    44 //        merge - basic test in place but not passing. need to flesh out mergeOptions when BF code in place. 
     41//      write tests for the color options : some mention was made that indexcolor is an issue in testing 
     42//        default 
     43//        custom 
    4544//        rgb colorize - need to do actual tests. see BF gui to get idea of how it works 
    4645//        custom colorize - waiting for creation of API for setting r,g,b info 
     
    4948//      swapped dims test needs to test cases other than from default swapping Z & T 
    5049//      output stack order - testing of iIndex? 
    51 //      range - more combos of ztc? uncomment the by 0 tests 
     50//      range - uncomment the by 0 tests when BF fixed 
    5251//  - add some tests for combination of options 
    5352//  - improve, comment, and generalize code for increased coverage 
     
    5756  private enum Axis {Z,C,T}; 
    5857   
    59   private enum ChannelOrder {XYZTC, XYZCT, XYTZC, XYTCZ, XYCTZ, XYCZT}; 
     58  private enum ChannelOrder {XYZTC, XYZCT, XYCZT, XYCTZ, XYTZC, XYTCZ}; 
    6059   
    6160  private static final boolean[] BooleanStates = new boolean[] {false, true}; 
     
    341340  } 
    342341 
     342  // ****** helper tests **************************************************************************************** 
     343   
     344  private void impsTest(ImagePlus[] imps, int numExpected) 
     345  { 
     346    assertNotNull(imps); 
     347    assertEquals(numExpected,imps.length); 
     348  } 
     349   
    343350  private void xyzctTest(ImagePlus imp, int x, int y, int z, int c, int t) 
    344351  { 
     
    351358  } 
    352359   
    353   // ****** helper tests **************************************************************************************** 
     360  // channel is 0-based 
     361  private void lutTest(CompositeImage ci, int channel, int minR, int minG, int minB, int maxR, int maxG, int maxB) 
     362  { 
     363    LUT lut = null; 
     364     
     365    byte[] reds = new byte[256]; 
     366    byte[] blues = new byte[256]; 
     367    byte[] greens = new byte[256]; 
     368     
     369    lut = ci.getChannelLut(channel+1);  // IJ is 1-based 
     370    lut.getReds(reds); 
     371    lut.getGreens(greens); 
     372    lut.getBlues(blues); 
     373     
     374    assertEquals((byte)minR,reds[0]); 
     375    assertEquals((byte)maxR,reds[255]); 
     376    assertEquals((byte)minG,greens[0]); 
     377    assertEquals((byte)maxG,greens[255]); 
     378    assertEquals((byte)minB,blues[0]); 
     379    assertEquals((byte)maxB,blues[255]); 
     380  } 
    354381   
    355382  private void defaultBehaviorTest(int pixType, int x, int y, int z, int c, int t) 
     
    368395    } 
    369396     
    370     assertNotNull(imps); 
    371     assertEquals(1,imps.length); 
     397    impsTest(imps,1); 
     398 
    372399    ImagePlus imp = imps[0]; 
    373400     
     
    393420    } 
    394421 
    395     assertNotNull(imps); 
    396     assertEquals(1,imps.length); 
     422    impsTest(imps,1); 
    397423     
    398424    ImagePlus imp = imps[0]; 
     
    449475    } 
    450476 
    451     assertNotNull(imps); 
    452     assertEquals(1,imps.length); 
     477    impsTest(imps,1); 
    453478 
    454479    ImagePlus imp = imps[0]; 
     
    495520    // test results 
    496521     
    497     assertEquals(1,imps.length); 
     522    impsTest(imps,1); 
    498523    xyzctTest(imps[0],x,y,z,c,t); 
    499524    assertEquals(z*c*t, imps[0].getStack().getSize()); 
     
    550575    // test results 
    551576     
    552     assertNotNull(imps); 
    553     assertEquals(1,imps.length); 
     577    impsTest(imps,1); 
    554578    ImageStack st = imps[0].getStack(); 
    555579 
     
    594618    } 
    595619     
    596     assertEquals(1,imps.length); 
     620    impsTest(imps,1); 
    597621     
    598622    imp = imps[0]; 
     
    616640    } 
    617641 
     642    //System.out.println("Checking max/min of each processor"); 
    618643    for (int i = 0; i < numSlices; i++) 
    619644    { 
     645      //System.out.println("Trying proc #"+i+" of "+numSlices); 
    620646      ImageProcessor proc = st.getProcessor(i+1); 
    621647      assertEquals(expectedMax,proc.getMax(),0.1); 
     
    657683    } 
    658684     
    659     assertEquals(1,imps.length); 
     685    impsTest(imps,1); 
    660686    imp = imps[0]; 
    661687    xyzctTest(imps[0],sizeCrop,sizeCrop,sizeZ,sizeC,sizeT); 
     
    697723   
    698724      // test results 
    699       assertNotNull(imps); 
    700       assertEquals(1,imps.length); 
     725      impsTest(imps,1); 
    701726      ImagePlus imp = imps[0]; 
    702       assertNotNull(imp); 
    703727      xyzctTest(imp,x,y,z,c,t); 
    704728   
     
    732756 
    733757    // basic tests 
    734     assertNotNull(imps); 
    735     assertEquals(1,imps.length); 
     758    impsTest(imps,1); 
    736759    imp = imps[0]; 
    737760    xyzctTest(imp,x,y,z,c,t); 
     
    803826     
    804827    // should have the data in one series 
    805     assertNotNull(imps); 
    806     assertEquals(1,imps.length); 
     828    impsTest(imps,1); 
    807829    ImagePlus imp = imps[0]; 
    808830    xyzctTest(imp,x,y,numInSeries(zFrom,zTo,zBy),numInSeries(cFrom,cTo,cBy),numInSeries(tFrom,tTo,tBy)); 
     
    834856 
    835857    // test results 
    836     assertNotNull(imps); 
    837     assertEquals(1,imps.length); 
     858    impsTest(imps,1); 
    838859    xyzctTest(imps[0],cx,cy,1,1,1); 
    839860  } 
     
    880901      } 
    881902     
    882     assertEquals(1,imps.length); 
     903    impsTest(imps,1); 
    883904    assertEquals(105,imps[0].getStack().getSize()); 
    884905  } 
     
    912933    // test results 
    913934     
    914     assertEquals(1,imps.length); 
     935    impsTest(imps,1); 
    915936    assertEquals(16,imps[0].getStack().getSize());  // one loaded as one set with 16 slices 
    916937     
     
    932953    // test results 
    933954     
    934     assertEquals(1,imps.length); 
     955    impsTest(imps,1); 
    935956    assertEquals(32,imps[0].getStack().getSize());  // both loaded as one set of 32 slices 
    936957  } 
     
    9911012    } 
    9921013 
    993     assertEquals(1,imps.length); 
     1014    impsTest(imps,1); 
    9941015     
    9951016    imp = imps[0]; 
     
    10021023     
    10031024    fail("unfinished"); 
    1004   } 
    1005    
    1006   // channel is 0-based 
    1007   private void lutTest(CompositeImage ci, int channel, int minR, int minG, int minB, int maxR, int maxG, int maxB) 
    1008   { 
    1009     LUT lut = null; 
    1010      
    1011     byte[] reds = new byte[256]; 
    1012     byte[] blues = new byte[256]; 
    1013     byte[] greens = new byte[256]; 
    1014      
    1015     lut = ci.getChannelLut(channel+1);  // IJ is 1-based 
    1016     lut.getReds(reds); 
    1017     lut.getGreens(greens); 
    1018     lut.getBlues(blues); 
    1019      
    1020     assertEquals((byte)minR,reds[0]); 
    1021     assertEquals((byte)maxR,reds[255]); 
    1022     assertEquals((byte)minG,greens[0]); 
    1023     assertEquals((byte)maxG,greens[255]); 
    1024     assertEquals((byte)minB,blues[0]); 
    1025     assertEquals((byte)maxB,blues[255]); 
    10261025  } 
    10271026   
     
    10501049    } 
    10511050 
    1052     assertEquals(1,imps.length); 
     1051    impsTest(imps,1); 
    10531052     
    10541053    imp = imps[0]; 
     
    11051104    } 
    11061105 
    1107     assertEquals(1,imps.length); 
     1106    impsTest(imps,1); 
    11081107     
    11091108    imp = imps[0]; 
     
    11601159    } 
    11611160 
    1162     assertEquals(1,imps.length); 
     1161    impsTest(imps,1); 
    11631162     
    11641163    imp = imps[0]; 
     
    12311230    } 
    12321231 
    1233     assertEquals(1,imps.length); 
     1232    impsTest(imps,1); 
    12341233     
    12351234    imp = imps[0]; 
     
    12451244    assertEquals(CompositeImage.COLOR, ci.getMode()); 
    12461245 
    1247     lutTest(ci,0,0,0,0,0,0,255);        // blue 
     1246    lutTest(ci,0,0,0,0,0,0,254);        // blue 
    12481247    if (sizeC >= 2) 
    1249       lutTest(ci,1,0,0,0,255,0,0);      // red 
     1248      lutTest(ci,1,0,0,0,254,0,0);      // red 
    12501249    if (sizeC >= 3) 
    1251       lutTest(ci,2,0,0,0,0,255,0);      // green 
     1250      lutTest(ci,2,0,0,0,0,254,0);      // green 
    12521251    if (sizeC >= 4) 
    1253       lutTest(ci,3,0,0,0,255,0,255);    // magenta 
     1252      lutTest(ci,3,0,0,0,254,0,254);    // magenta 
    12541253    if (sizeC >= 5) 
    1255       lutTest(ci,4,0,0,0,0,255,255);    // cyan 
     1254      lutTest(ci,4,0,0,0,0,254,254);    // cyan 
    12561255    if (sizeC >= 7) 
    1257       lutTest(ci,5,0,0,0,255,255,0);    // yellow 
     1256      lutTest(ci,5,0,0,0,254,254,0);    // yellow 
    12581257    if (sizeC >= 7) 
    1259       lutTest(ci,6,0,0,0,255,255,255);  // gray 
     1258      lutTest(ci,6,0,0,0,127,127,127);  // gray 
    12601259 
    12611260    fail("unfinished"); 
     
    12891288     
    12901289    // test results 
    1291     assertEquals(1,imps.length); 
     1290    impsTest(imps,1); 
    12921291    imp = imps[0]; 
    12931292    assertEquals(3,getEffectiveSizeC(imp));  // unmerged 
     
    13121311     
    13131312    // test results 
    1314     assertEquals(1,imps.length); 
     1313    impsTest(imps,1); 
    13151314    imp = imps[0]; 
    13161315    assertTrue(imp.getHeight() > 10);  // required for this test to work 
     
    13881387    } 
    13891388     
    1390     assertEquals(1,imps.length); 
     1389    impsTest(imps,1); 
    13911390    imp = imps[0]; 
    13921391    assertEquals(7,getSizeZ(imp)); 
     
    16281627                  for (int tEnd = -1; tEnd < t+2; tEnd++) 
    16291628                    for (int tInc = -1; tInc < t+2; tInc++) 
     1629                      // if an invalid index of some kind 
    16301630                      if ((zStart < 0) || (zStart >= z) || 
    1631                           (zEnd < 0) || (zEnd >= z) || (zEnd < zStart) || 
     1631                          (zEnd < 0) || (zEnd >= z) || // ignored by BF (zEnd < zStart) || 
    16321632                          (zInc < 1) || 
    16331633                          (cStart < 0) || (cStart >= c) || 
    1634                           (cEnd < 0) || (cEnd >= c) || (cEnd < cStart) || 
     1634                          (cEnd < 0) || (cEnd >= c) || // ignored by BF (cEnd < cStart) || 
    16351635                          (cInc < 1) || 
    16361636                          (tStart < 0) || (tStart >= t) || 
    1637                           (tEnd < 0) || (tEnd >= z) || (tEnd < tStart) || 
     1637                          (tEnd < 0) || (tEnd >= t) || // ignored by BF (tEnd < tStart) || 
    16381638                          (tInc < 1)) 
    16391639                      { 
     1640                        // expect failure 
    16401641                        try { 
    16411642                          memorySpecifyRangeTest(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     
    16501651                      } 
    16511652                      else 
     1653                        // expect success 
    16521654                        memorySpecifyRangeTest(z,c,t,zStart,zEnd,zInc,cStart,cEnd,cInc,tStart,tEnd,tInc); 
    16531655    */ 
     
    16871689 
    16881690    // one channel per image 
    1689     assertEquals(sizeC,imps.length); 
     1691    impsTest(imps,sizeC); 
    16901692     
    16911693    // unwind ZCT loop : C pulled outside, ZT in order 
     
    17311733     
    17321734    // one focal plane per image 
    1733     assertEquals(sizeZ,imps.length); 
     1735    impsTest(imps,sizeZ); 
    17341736 
    17351737    // unwind ZCT loop : Z pulled outside, CT in order 
     
    17751777     
    17761778    // one time point per image 
    1777     assertEquals(sizeT,imps.length); 
     1779    impsTest(imps,sizeT); 
    17781780     
    17791781    // unwind ZTC loop : T pulled outside, ZC in order 
     
    18101812  } 
    18111813   
     1814  @Test 
     1815  public void testComboConcatColorize() 
     1816  { 
     1817    fail("unimplemented"); 
     1818  } 
     1819 
     1820  @Test 
     1821  public void testComboConcatSplit() 
     1822  { 
     1823    fail("unimplemented"); 
     1824  } 
     1825 
     1826  @Test 
     1827  public void testComboColorizeSplit() 
     1828  { 
     1829    fail("unimplemented"); 
     1830  } 
     1831   
     1832  @Test 
     1833  public void testComboConcatColorizeSplit() 
     1834  { 
     1835    fail("unimplemented"); 
     1836  } 
    18121837} 
Note: See TracChangeset for help on using the changeset viewer.