Changeset 6297


Ignore:
Timestamp:
05/12/10 17:36:06 (10 years ago)
Author:
bdezonia
Message:

partial impl of autoscale

File:
1 edited

Legend:

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

    r6291 r6297  
    2727// TODO 
    2828//  - flesh out existing tests 
    29 //      splits - see if for loops are in correct order by comparing to actual data 
    3029//      write tests for the color options : 4 cases - some mention was made that indexcolor is an issue in testing 
    3130//        merge - basic test in place but not passing. need to flesh out mergeOptions when BF code in place. 
    32 //        rgb colorize -  
    33 //        custom colorize -  
     31//        rgb colorize - need to do actual tests. see BF gui to get idea of how it works 
     32//        custom colorize - waiting for creation of API for setting r,g,b info 
    3433//        autoscale - code stubbed out but tests not in place for histogram testing. Its possible the histogram won't 
    3534//          change when base image is a fake file because the whole data range may already be in use. 
    3635//      open individual files: try to come up with a way to test without a disk file as source 
    37 //      concatenate - test order of images in stack? 
    3836//      swapped dims test needs to test cases other than from default swapping Z & T 
    3937//      output stack order - testing of iIndex? 
    40 //      range - more combos of ztc, more bad cases 
     38//      range - more combos of ztc? 
    4139//  - add some tests for combination of options 
     40//  - improve, comment, and generalize code for increased coverage 
    4241 
    4342public class ImporterTest { 
     
    174173  private int numInSeries(int from, int to, int by) 
    175174  { 
    176     /* 
    177     int spread = from - to + 1; 
    178      
    179     if (spread % by == 0) 
    180       return (spread / by); 
    181     else 
    182       return (spread / by) + 1; 
    183     */ 
    184175    // could calc this but simple loop suffices for our purposes 
    185176    int count = 0; 
     
    187178        count++; 
    188179    return count; 
    189     /* 
     180     
     181    /* calc'ed version : less clear 
     182    int spread = to - from + 1; 
     183     
     184    if (spread % by == 0) 
     185      return (spread / by); 
     186    else 
     187      return (spread / by) + 1; 
    190188    */ 
    191189  } 
     
    358356          //TODO - test iIndex too? : assertEquals(count,somethingOrOther(iIndex(proc))); 
    359357          //System.out.println("iIndex " + iIndex(proc) + " calc " + 
    360           //    ((maxJ*maxI*k) + (maxI*j) + i) 
    361           //    ); 
     358              // pre loop reorder ((maxJ*maxI*k) + (maxI*j) + i) 
     359              //((maxJ*maxK*i) + (maxK*j) + k) 
     360              //((value(middle,maxI,maxJ,maxK)*value(fastest,maxI,maxJ,maxK)*i) + (value(fastest,maxI,maxJ,maxK)*j) + (k)) 
     361              //((value(middle,maxK,maxJ,maxI)*value(fastest,maxK,maxJ,maxI)*i) + (value(fastest,maxK,maxJ,maxI)*j) + (k)) 
     362              //); 
     363          //System.out.println("maxI "+maxI+" maxJ "+maxJ+" maxK "+maxK+" number "+count+" (i"+i+" "+j+"j "+k+"k) = "+iIndex(proc)); 
    362364          assertEquals(i,index(slowest,proc)); 
    363365          assertEquals(j,index(middle,proc)); 
     
    492494    assertNotNull(imps); 
    493495    assertEquals(1,imps.length); 
    494  
    495496    ImageStack st = imps[0].getStack(); 
    496497 
    497     int numSlices = st.getSize(); 
    498      
    499498    // make sure the number of slices in stack is a sum of all series 
    500     assertEquals(z*c*t*s, numSlices); 
     499    assertEquals(z*c*t*s, st.getSize()); 
    501500     
    502501    int index = 0; 
     
    603602    assertEquals(y,imp.getHeight()); 
    604603    ImageStack st = imp.getStack(); 
    605      
    606     //System.out.println("SpecifyCRangeTest: slices below"); 
    607     //for (int i = 0; i < numSlices; i++) 
    608     //  printVals(st.getProcessor(i+1)); 
    609          
     604 
     605    // should be in correct order 
    610606    assertTrue(seriesInCorrectOrder(st,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy)); 
    611607  } 
     
    646642    defaultBehaviorTest(FormatTools.UINT16, 400, 300, 1, 1, 1); 
    647643    defaultBehaviorTest(FormatTools.INT16, 107, 414, 1, 1, 1); 
    648     defaultBehaviorTest(FormatTools.UINT32, 323, 206, 3, 2, 1);  // failure on last val = 1,5, 
     644    defaultBehaviorTest(FormatTools.UINT32, 323, 206, 3, 2, 1); 
    649645    defaultBehaviorTest(FormatTools.UINT8, 57, 78, 5, 4, 3); 
    650646    defaultBehaviorTest(FormatTools.INT32, 158, 99, 2, 3, 4); 
     
    694690    String path = "2channel_stack_raw01.pic"; 
    695691     
     692    // there is a second file called "2channel_stack_raw02.pic" present in the same directory 
     693    // if open indiv true should only load one of them, otherwise both 
     694     
    696695    // try ungrouped 
    697696     
     
    713712     
    714713    assertEquals(1,imps.length); 
    715     assertEquals(16,imps[0].getStack().getSize()); 
     714    assertEquals(16,imps[0].getStack().getSize());  // one loaded as one set with 16 slices 
    716715     
    717716    // try grouped 
     
    733732     
    734733    assertEquals(1,imps.length); 
    735     assertEquals(32,imps[0].getStack().getSize()); 
     734    assertEquals(32,imps[0].getStack().getSize());  // both loaded as one set of 32 slices 
    736735  } 
    737736 
     
    779778    // test when color merge false 
    780779 
     780    // open file 
    781781    try { 
    782782      ImporterOptions options = new ImporterOptions(); 
     
    792792    } 
    793793     
     794    // test results 
    794795    assertEquals(1,imps.length); 
    795796    imp = imps[0]; 
    796     assertEquals(3,getEffectiveSizeC(imp)); 
     797    assertEquals(3,getEffectiveSizeC(imp));  // unmerged 
    797798    assertEquals(7,getSizeZ(imp)); 
    798799    assertEquals(5,getSizeT(imp)); 
     
    800801    // test when color merge true 
    801802     
     803    // open file 
    802804    try { 
    803805      ImporterOptions options = new ImporterOptions(); 
     
    813815    } 
    814816     
     817    // test results 
    815818    assertEquals(1,imps.length); 
    816819    imp = imps[0]; 
    817     assertEquals(1, getEffectiveSizeC(imp)); 
     820    assertTrue(imp.getHeight() > 10);  // required for this test to work 
     821    assertEquals(1, getEffectiveSizeC(imp));  // merged 
    818822    assertEquals(7, getSizeZ(imp)); 
    819823    assertEquals(5, getSizeT(imp)); 
    820     assertTrue(imp.getHeight() > 10);  // required for this test to work 
    821824    for (int i = 0; i < 10; i++) 
    822825      assertEquals(mergedPixel(i),imp.getProcessor().get(i,10)); 
     
    849852      options.setId(path); 
    850853      imps = BF.openImagePlus(options); 
     854      // TODO - eventually fail() here but need BF support first I think 
    851855    } 
    852856    catch (IOException e) { 
     
    864868      options.setId(path); 
    865869      imps = BF.openImagePlus(options); 
     870      // TODO - eventually fail() here but need BF support first I think 
    866871    } 
    867872    catch (IOException e) { 
     
    904909    //   The color for each channel is chosen by the user. This option is not available when Merge channels to RGB or RGB 
    905910    //   colorize channels are set. 
     911     
     912    // TODO 
    906913    fail("to be implemented"); 
    907914  } 
    908915 
     916  private void autoscaleTrueTest(int pixType) 
     917  { 
     918    final int sizeZ = 5, sizeC = 3, sizeT = 7, sizeX = 63, sizeY = 35; 
     919    final String path = constructFakeFilename("autoscale",pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, -1); 
     920     
     921    ImagePlus[] imps = null; 
     922    ImagePlus imp = null; 
     923     
     924    try { 
     925      ImporterOptions options = new ImporterOptions(); 
     926      options.setAutoscale(true); 
     927      options.setId(path); 
     928      imps = BF.openImagePlus(options); 
     929    } 
     930    catch (IOException e) { 
     931      fail(e.getMessage()); 
     932    } 
     933    catch (FormatException e) { 
     934      fail(e.getMessage()); 
     935    } 
     936     
     937    assertEquals(1,imps.length); 
     938    imp = imps[0]; 
     939    assertEquals(sizeX,imp.getWidth()); 
     940    assertEquals(sizeY,imp.getHeight()); 
     941    assertEquals(sizeZ,getSizeZ(imp)); 
     942    assertEquals(sizeC,getEffectiveSizeC(imp)); 
     943    assertEquals(sizeT,getSizeT(imp)); 
     944 
     945    ImageStack st = imp.getStack(); 
     946    int numSlices = st.getSize(); 
     947 
     948    for (int i = 0; i < numSlices; i++) 
     949    { 
     950      ImageProcessor proc = st.getProcessor(i+1); 
     951      assertEquals(sizeX,proc.getMax(),0.1); 
     952      assertEquals(0,proc.getMin(),0.1); 
     953    } 
     954  } 
     955 
     956  private double maxPixelValue(int pixType) 
     957  { 
     958    if (FormatTools.isFloatingPoint(pixType)) 
     959      return Float.MAX_VALUE; 
     960  
     961    switch (pixType) 
     962    { 
     963      case FormatTools.INT8:    return Byte.MAX_VALUE;  
     964      case FormatTools.INT16:   return Short.MAX_VALUE;  
     965      case FormatTools.INT32:   return Integer.MAX_VALUE;  
     966      case FormatTools.UINT8:   return 255;  
     967      case FormatTools.UINT16:  return 65535;  
     968      case FormatTools.UINT32:  return 4294967295.0;  
     969 
     970      default: 
     971        throw new IllegalArgumentException("maxPixelValue() - unknown pixel type passed in: " + pixType); 
     972    } 
     973    /* 
     974    double maxUnsigned = Math.pow(2, FormatTools.getBytesPerPixel(pixType)*8) - 1; 
     975     
     976    // signed data type 
     977    if (FormatTools.isSigned(pixType)) 
     978       
     979      return Math.floor(maxUnsigned / 2); 
     980     
     981    else  // unsigned data type 
     982       
     983      return maxUnsigned; 
     984    */ 
     985  } 
     986   
     987  private void autoscaleFalseTest(int pixType) 
     988  { 
     989    final int sizeZ = 5, sizeC = 3, sizeT = 7, sizeX = 63, sizeY = 35; 
     990    final String path = constructFakeFilename("autoscale",pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, -1); 
     991     
     992    ImagePlus[] imps = null; 
     993    ImagePlus imp = null; 
     994     
     995    try { 
     996      ImporterOptions options = new ImporterOptions(); 
     997      options.setAutoscale(false); 
     998      options.setId(path); 
     999      imps = BF.openImagePlus(options); 
     1000    } 
     1001    catch (IOException e) { 
     1002      fail(e.getMessage()); 
     1003    } 
     1004    catch (FormatException e) { 
     1005      fail(e.getMessage()); 
     1006    } 
     1007     
     1008    assertEquals(1,imps.length); 
     1009    imp = imps[0]; 
     1010    assertEquals(sizeX,imp.getWidth()); 
     1011    assertEquals(sizeY,imp.getHeight()); 
     1012    assertEquals(sizeZ,getSizeZ(imp)); 
     1013    assertEquals(sizeC,getEffectiveSizeC(imp)); 
     1014    assertEquals(sizeT,getSizeT(imp)); 
     1015 
     1016    ImageStack st = imp.getStack(); 
     1017    int numSlices = st.getSize(); 
     1018 
     1019    for (int i = 0; i < numSlices; i++) 
     1020    { 
     1021      ImageProcessor proc = st.getProcessor(i+1); 
     1022      assertEquals(maxPixelValue(pixType),proc.getMax(),0.1); 
     1023      assertEquals(0,proc.getMin(),0.1); 
     1024    } 
     1025  } 
     1026   
    9091027  @Test 
    9101028  public void testColorAutoscale() 
     
    9151033    // throughout the stack. 
    9161034 
    917     // histogram stretched to match data vals that are present 
    918     // original image data unchanged 
    919  
    920     String path = FAKE_FILES[0]; 
    921      
    922     ImagePlus[] imps = null; 
    923     ImagePlus imp = null; 
    924     int[] h; 
    925      
    926     // test when autoscale false 
    927  
    928     try { 
    929       ImporterOptions options = new ImporterOptions(); 
    930       options.setAutoscale(false); 
    931       options.setId(path); 
    932       imps = BF.openImagePlus(options); 
    933     } 
    934     catch (IOException e) { 
    935       fail(e.getMessage()); 
    936     } 
    937     catch (FormatException e) { 
    938       fail(e.getMessage()); 
    939     } 
    940      
    941     assertEquals(1,imps.length); 
    942     imp = imps[0]; 
    943     assertEquals(3,getEffectiveSizeC(imp)); 
    944     assertEquals(7,getSizeZ(imp)); 
    945     assertEquals(5,getSizeT(imp)); 
    946      
    947     System.out.println("setAutoscale(false) results"); 
    948     h = imp.getStatistics().histogram; 
    949     // or? h = imp.getProcessor().getHistogram(); 
    950     for (int i = 0; i < h.length/8; i++) 
    951       System.out.println(h[i*8+0]+" "+h[i*8+1]+" "+h[i*8+2]+" "+h[i*8+3]+" "+h[i*8+4]+" "+h[i*8+5]+" "+h[i*8+6]+" "+h[i*8+7]); 
    952      
    953     // TODO - test histogram values 
    954      
    955     ImagePlus baseImage = imp; 
    956      
    957     // test when autoscale true 
    958  
    959     try { 
    960       ImporterOptions options = new ImporterOptions(); 
    961       options.setAutoscale(true); 
    962       options.setId(path); 
    963       imps = BF.openImagePlus(options); 
    964     } 
    965     catch (IOException e) { 
    966       fail(e.getMessage()); 
    967     } 
    968     catch (FormatException e) { 
    969       fail(e.getMessage()); 
    970     } 
    971      
    972     assertEquals(1,imps.length); 
    973     imp = imps[0]; 
    974     assertEquals(3,getEffectiveSizeC(imp)); 
    975     assertEquals(7,getSizeZ(imp)); 
    976     assertEquals(5,getSizeT(imp)); 
    977      
    978     System.out.println("setAutoscale(true) results"); 
    979     h = imp.getStatistics().histogram; 
    980     // or? h = imp.getProcessor().getHistogram(); 
    981     for (int i = 0; i < h.length/8; i++) 
    982       System.out.println(h[i*8+0]+" "+h[i*8+1]+" "+h[i*8+2]+" "+h[i*8+3]+" "+h[i*8+4]+" "+h[i*8+5]+" "+h[i*8+6]+" "+h[i*8+7]); 
    983      
    984     // TODO - test histogram values 
    985     // question on hist testing - do I need to test specific values or just that it changed? 
    986  
    987     // test that image data unchanged by autoscale 
    988      
    989     ImageStack st1 = baseImage.getStack(); 
    990     ImageStack st2 = imp.getStack(); 
    991      
    992     int st1Size = st1.getSize(); 
    993     assertEquals(st1Size,st2.getSize()); 
    994     for (int i = 0; i < st1Size; i++) 
    995       floatArraysEqual((float[])st1.getProcessor(i+1).getPixels(), (float[])st2.getProcessor(i+1).getPixels()); 
    996      
    997     fail("unfinished implementation"); 
     1035    // TODO : merge the two separate tests into one that takes passed boolean and tests it to determine correct test vals 
     1036     
     1037    autoscaleFalseTest(FormatTools.UINT8); 
     1038    autoscaleFalseTest(FormatTools.UINT16); 
     1039    //TODO: failing - max calc wrong? autoscaleFalseTest(FormatTools.UINT32); 
     1040    autoscaleFalseTest(FormatTools.INT8); 
     1041    autoscaleFalseTest(FormatTools.INT16); 
     1042    autoscaleFalseTest(FormatTools.INT32); 
     1043  
     1044    autoscaleTrueTest(FormatTools.UINT8); 
     1045    autoscaleTrueTest(FormatTools.UINT16); 
     1046    autoscaleTrueTest(FormatTools.UINT32); 
     1047    autoscaleTrueTest(FormatTools.INT8); 
     1048    autoscaleTrueTest(FormatTools.INT16); 
     1049    autoscaleTrueTest(FormatTools.INT32); 
    9981050  } 
    9991051 
Note: See TracChangeset for help on using the changeset viewer.