Changeset 6449


Ignore:
Timestamp:
06/02/10 16:56:29 (9 years ago)
Author:
bdezonia
Message:

testComboManyOptions - temp/wrong implementation. Various other changes.

File:
1 edited

Legend:

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

    r6447 r6449  
    1818import ij.ImageStack; 
    1919import ij.WindowManager; 
     20import ij.measure.Calibration; 
    2021import ij.process.ImageProcessor; 
    2122import ij.process.LUT; 
     
    3031import loci.formats.FormatTools; 
    3132import loci.plugins.BF; 
     33import loci.plugins.in.ImporterOptions; 
    3234 
    3335 
    3436// TODO 
     37 
     38// waiting on BF implementations for 
     39//   - indexed color support 
     40//   - changes to concat 
    3541 
    3642// must address before release 
     
    4450//     custom 
    4551//  - add some tests for combination of options 
     52//      comboConcatSplit() - done but not passing 
     53//      comboManyOptions 
     54//      other combo tests - rely on color code working. Waiting for BF. 
    4655//  - comboCropAutoscale() - autoscale of a cropped image returning min of whole image 
    47 //  - autoscale of signed images an issue (INT16 gets clamped 0..65535 by ImageJ also) 
    4856 
    4957// would be nice to address before release 
    5058 
    51 //  waiting on BF implementations for 
    52 //    - autoscale failing (when off?) for Float and Double - need to decide on correct behavior in BF 
    5359//    - BF/imageJ returning wrong values of max num pixels (UINT32 off by one - IJ bug, float weird too, etc.) 
    54 //    - memoryRecord failure needs BF code fix 
     60//    - memoryRecord failure (needs BF code fix) 
    5561//    - open individual files: try to come up with a way to test without a disk file as source 
    5662//    - swapped dims test needs to test cases other than from default swapping Z & T 
     
    314320        throw new IllegalArgumentException("maxPixelValue() - unknown pixel type passed in: " + pixType); 
    315321    } 
    316     /* 
    317      
    318     long maxUnsigned = (1L << FormatTools.getBytesPerPixel(pixType)*8) - 1; 
    319      
    320     // signed data type 
    321     if (FormatTools.isSigned(pixType)) 
    322        
    323       return maxUnsigned / 2; 
    324      
    325     else  // unsigned data type 
    326        
    327       return maxUnsigned; 
    328     */ 
    329  
    330322  } 
    331323   
     
    333325  { 
    334326    if (FormatTools.isFloatingPoint(pixType)) 
    335       //return -4294967296L; // expected -Float.MAX_VALUE or maybe -Double.MAX_VALUE rather than -2^32 (and also its not 2^32-1 !!!) 
    336       return 0;  // TODO this allows autoscale testing to work for floating types _ makes sense cuz FakeReader only does unsigned float data  
     327      //return -4294967296L; // -2^32 (and also its not 2^32-1 !!!) 
     328      return 0;  // TODO this allows autoscale testing to work for floating types - makes sense cuz FakeReader only does unsigned float data  
    337329  
    338330    switch (pixType) 
     
    348340        throw new IllegalArgumentException("minPixelValue() - unknown pixel type passed in: " + pixType); 
    349341    } 
    350     /* 
    351     if (FormatTools.isFloatingPoint(pixType)) 
    352       return (long)-Float.MAX_VALUE; 
    353   
    354     // signed data type 
    355     if (FormatTools.isSigned(pixType)) 
    356  
    357       return - (1L << ((FormatTools.getBytesPerPixel(pixType)*8)-1));  // -1 accounts for use of sign bit 
    358        
    359     else  // unsigned data type 
    360        
    361       return 0; 
    362     */ 
    363342  } 
    364343 
     
    551530    int p = 1; 
    552531    for (int tIndex = 0; tIndex < actualSizeT; tIndex++) 
    553       for (int cIndex = 0; cIndex < c; cIndex++) 
     532      for (int cIndex = 0; cIndex < actualSizeC; cIndex++) 
    554533        for (int zIndex = 0; zIndex < actualSizeZ; zIndex++) 
    555534        { 
     
    705684    } 
    706685 
    707     //System.out.println("Checking max/min of each processor"); 
    708     for (int i = 0; i < numSlices; i++) 
     686    // workaround for IJ nonsupport of signed data 
     687    if (FormatTools.isSigned(pixType) && !FormatTools.isFloatingPoint(pixType)) 
    709688    { 
    710       //System.out.println("Trying proc #"+i+" of "+numSlices); 
    711       ImageProcessor proc = st.getProcessor(i+1); 
    712       assertEquals(expectedMax,proc.getMax(),0.1); 
    713       assertEquals(expectedMin,proc.getMin(),0.1); 
    714     } 
    715   } 
    716    
    717   private void colorCompositeTest(boolean indexed, int pixType, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT, int numSeries) 
     689      Calibration cal = imp.getCalibration(); 
     690      assertEquals(Calibration.STRAIGHT_LINE,cal.getFunction()); 
     691      double[] coeffs = cal.getCoefficients(); 
     692      int bitsPerPix = FormatTools.getBytesPerPixel(pixType) * 8; 
     693      assertEquals(-(Math.pow(2, (bitsPerPix-1))),coeffs[0],0); 
     694      assertEquals(1,coeffs[1],0); 
     695    } 
     696    else // regular case 
     697    { 
     698      //System.out.println("Checking max/min of each processor"); 
     699      for (int i = 0; i < numSlices; i++) 
     700      { 
     701        //System.out.println("Trying proc #"+i+" of "+numSlices); 
     702        ImageProcessor proc = st.getProcessor(i+1); 
     703        assertEquals(expectedMax,proc.getMax(),0.1); 
     704        assertEquals(expectedMin,proc.getMin(),0.1); 
     705      } 
     706    } 
     707  } 
     708   
     709  private void colorCompositeTest(int pixType, boolean indexed, int rgb, boolean falseColor, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT, int numSeries) 
    718710  { 
    719711    // reportedly works in BF for 2<=sizeC<=7 and also numSeries*sizeC*3 <= 25 
     
    723715    assertTrue(numSeries*sizeC*3 <= 25);  // slider limit in IJ 
    724716     
    725     int rgb = -1; 
    726     if (indexed) rgb = 1;  // TEMP 
    727      
    728717    String path = constructFakeFilename("colorComposite", pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries, 
    729         indexed, rgb, false); 
     718        indexed, rgb, falseColor); 
    730719     
    731720    ImagePlus[] imps = null; 
     
    776765        for (int t = 0; t < ci.getNFrames(); t++) 
    777766        { 
    778           //getIndexPixelValue(ci,z,c,t,indexed); 
    779767          assertEquals((maxZ*maxC*t + maxC*z + c), getIndexPixelValue(ci,z,c,t,indexed));  // CZT order 
    780768        } 
     
    12111199    defaultBehaviorTest(FormatTools.INT32, 158, 99, 2, 3, 4); 
    12121200    defaultBehaviorTest(FormatTools.INT8, 232, 153, 3, 7, 5); 
     1201    defaultBehaviorTest(FormatTools.FLOAT, 73, 99, 3, 4, 5); 
     1202    defaultBehaviorTest(FormatTools.DOUBLE, 106, 44, 5, 5, 4); 
    12131203  } 
    12141204 
     
    13051295    datasetSwapDimsTest(FormatTools.UINT16, 82, 47, 5, 2); 
    13061296    datasetSwapDimsTest(FormatTools.UINT32, 82, 47, 5, 2); 
    1307     datasetSwapDimsTest(FormatTools.INT8, 44, 109, 1, 4); 
    1308     datasetSwapDimsTest(FormatTools.INT16, 44, 109, 2, 1); 
    1309     datasetSwapDimsTest(FormatTools.INT32, 44, 109, 4, 3); 
    1310     datasetSwapDimsTest(FormatTools.UINT8, 82, 47, 3, 2); 
     1297    datasetSwapDimsTest(FormatTools.INT8, 44, 108, 1, 4); 
     1298    datasetSwapDimsTest(FormatTools.INT16, 44, 108, 2, 1); 
     1299    datasetSwapDimsTest(FormatTools.INT32, 44, 108, 4, 3); 
     1300    datasetSwapDimsTest(FormatTools.FLOAT, 67, 109, 4, 3); 
     1301    datasetSwapDimsTest(FormatTools.DOUBLE, 67, 100, 3, 2); 
    13111302  } 
    13121303 
     
    13691360    // BF only supporting C from 2 to 7 and due to IJ's slider limitation (C*numSeries*3) <= 25 
    13701361 
    1371     colorCompositeTest(false,FormatTools.UINT8,55,44,2,3,4,1); 
    1372     colorCompositeTest(true,FormatTools.UINT8,55,44,2,3,4,1); 
     1362    // these here to simplify debugging 
     1363    colorCompositeTest(FormatTools.UINT8,false,1,false,55,44,2,3,4,1); 
     1364    colorCompositeTest(FormatTools.UINT8,true,1,false,55,44,2,3,4,1); 
    13731365 
    13741366    int[] pixTypes = new int[] {FormatTools.UINT8}; 
     
    13911383                    { 
    13921384                      //System.out.println("indexed "+indexed+" format "+pixFormat+" x "+x+" y "+y+" z "+z+" c "+c+" t "+t+" s "+s); 
    1393                       colorCompositeTest(indexed,pixFormat,x,y,z,c,t,s); 
     1385                      //colorCompositeTest(indexed,pixFormat,x,y,z,c,t,s); 
    13941386                    } 
    13951387  } 
    13961388   
    1397   @Test 
    1398   public void testColorColorized() 
    1399   { 
    1400     int sizeX = 100, sizeY = 120, sizeZ = 2, sizeC = 7, sizeT = 4, numSeries = 3; 
    1401      
    1402     String path = constructFakeFilename("colorColorized", FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries, false, -1, false); 
     1389  private void colorColorizedTest() 
     1390  { 
     1391    // TODO: temp first attempt: sizeC == 1 and rgb matches 
     1392     
     1393    int sizeX = 100, sizeY = 120, sizeZ = 1, sizeC = 1, sizeT = 1, numSeries = 1, rgb = 1; 
     1394    boolean indexed = true; 
     1395     
     1396    String path = constructFakeFilename("colorColorized", FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries, indexed, rgb, false); 
    14031397     
    14041398    ImagePlus[] imps = null; 
     
    14361430 
    14371431    fail("unfinished"); 
     1432  } 
     1433   
     1434  @Test 
     1435  public void testColorColorized() 
     1436  { 
     1437    colorColorizedTest(); 
    14381438  } 
    14391439   
     
    15171517    // throughout the stack. 
    15181518 
    1519     autoscaleTest(FormatTools.DOUBLE,false); 
    1520     autoscaleTest(FormatTools.FLOAT,false); 
    1521     autoscaleTest(FormatTools.UINT8,false); 
    1522     autoscaleTest(FormatTools.UINT16,false); 
    1523     autoscaleTest(FormatTools.UINT32,false); 
    1524     autoscaleTest(FormatTools.INT8,false); 
    1525     autoscaleTest(FormatTools.INT16,false); 
    1526     autoscaleTest(FormatTools.INT32,false); 
    1527      
    1528     autoscaleTest(FormatTools.DOUBLE,true); 
    1529     autoscaleTest(FormatTools.FLOAT,true); 
    1530     autoscaleTest(FormatTools.UINT8,true); 
    1531     autoscaleTest(FormatTools.UINT16,true); 
    1532     autoscaleTest(FormatTools.UINT32,true); 
    1533     autoscaleTest(FormatTools.INT8,true); 
    1534     autoscaleTest(FormatTools.INT32,true); 
    1535     autoscaleTest(FormatTools.INT16,true);  // TODO in this case IJ via ShortProcessor::setMinAndMax() clamps the min value to 0 : bug due to obliviousness to sign? 
    1536  
    1537     /* 
    1538     // TODO - delete above code when tests are passing 
    15391519    for (int pixType : PixelTypes) 
    15401520    { 
     
    15451525      } 
    15461526    } 
    1547     */ 
    15481527  } 
    15491528 
     
    19391918    fail("unimplemented"); 
    19401919  } 
     1920   
     1921  @Test 
     1922  public void testComboManyOptions() 
     1923  { 
     1924    int pixType = FormatTools.UINT16, sizeX = 106, sizeY = 33, sizeZ = 3, sizeC = 5, sizeT = 7; 
     1925    int cropOriginX = 0, cropOriginY = 0, cropSizeX = 55, cropSizeY = 16, tStepBy = 2; 
     1926    ChannelOrder swappedOrder = ChannelOrder.CTZ;  // orig is ZCT : this is a deadly swap of all dims 
     1927 
     1928    String path = constructFakeFilename("superCombo", pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, 1, false, -1, false); 
     1929   
     1930    ImagePlus[] imps = null; 
     1931    try { 
     1932      ImporterOptions options = new ImporterOptions(); 
     1933      options.setId(path); 
     1934      options.setSwapDimensions(true); 
     1935      options.setInputOrder(0, bfChanOrd(swappedOrder)); 
     1936      options.setCrop(true); 
     1937      options.setCropRegion(0, new Region(cropOriginX,cropOriginY,cropSizeX,cropSizeY)); 
     1938      options.setTStep(0, tStepBy); 
     1939      options.setSplitFocalPlanes(true); 
     1940      imps = BF.openImagePlus(options); 
     1941    } 
     1942    catch (IOException e) { 
     1943      fail(e.getMessage()); 
     1944    } 
     1945    catch (FormatException e) { 
     1946      fail(e.getMessage()); 
     1947    } 
     1948 
     1949    impsCountTest(imps,sizeT); 
     1950 
     1951    for (int z = 0; z < sizeT; z++) 
     1952    { 
     1953     
     1954      ImagePlus imp = imps[z]; 
     1955       
     1956      final int actualSizeZ = imp.getNSlices(); 
     1957      final int actualSizeC = imp.getNChannels(); 
     1958      final int actualSizeT = imp.getNFrames(); 
     1959 
     1960      System.out.println("Actual z c t "+actualSizeZ+" "+actualSizeC+" "+actualSizeT); 
     1961      xyzctTest(imp,cropSizeX,cropSizeY,1,3,3); // all dims swapped 
     1962   
     1963      int numT = numInSeries(0,actualSizeT,tStepBy); 
     1964       
     1965      ImageStack st = imp.getStack(); 
     1966      assertEquals(sizeC*numT,st.getSize()); 
     1967       
     1968      int p = 1; 
     1969      for (int tIndex = 0; tIndex < actualSizeT; tIndex += tStepBy) 
     1970        for (int cIndex = 0; cIndex < actualSizeC; cIndex++) 
     1971          for (int zIndex = 0; zIndex < actualSizeZ; zIndex++) 
     1972          { 
     1973            ImageProcessor proc = st.getProcessor(p++); 
     1974            final int actualZ = cIndex(proc); 
     1975            final int actualC = tIndex(proc); 
     1976            final int actualT = zIndex(proc); 
     1977            assertEquals(zIndex, actualZ); 
     1978            assertEquals(cIndex, actualC); 
     1979            assertEquals(tIndex, actualT); 
     1980          } 
     1981       
     1982    } 
     1983  } 
    19411984} 
Note: See TracChangeset for help on using the changeset viewer.