Changeset 6493


Ignore:
Timestamp:
06/04/10 15:41:40 (9 years ago)
Author:
bdezonia
Message:

improved a number of methods (testComboCropAutoscale, testDatasetGroup, testMemoryCrop), got testRecordMemory failing at same point as before, further work on testColorizeSubcases

File:
1 edited

Legend:

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

    r6471 r6493  
    5252//      comboManyOptions - done and passing 
    5353//      other combo tests - rely on color code working. Waiting for BF. 
    54 //  - comboCropAutoscale() - done but not passing : autoscale of a cropped image returning min of whole image 
    5554 
    5655// would be nice to address before release 
     
    8483  private static final String[] FAKE_FILES; 
    8584  private static final String FAKE_PATTERN; 
    86   
     85 
     86  private static final int FakePlaneCount = 7; 
     87   
    8788  static { 
    8889 
    8990    //String template = "test_C%s_TP%s&sizeX=50&sizeY=20&sizeZ=7.fake"; 
    90     String template = constructFakeFilename("test_C%s_TP%s", FormatTools.INT32, 50, 20, 7, 1, 1, -1, false, -1, false, -1); 
     91    String template = constructFakeFilename("test_C%s_TP%s", FormatTools.INT32, 50, 20, FakePlaneCount, 1, 1, -1, false, -1, false, -1); 
    9192                                                                        // BDZ - INT32 is desirable for the color tests 
    9293     
     
    106107      String.format(template, "1", "5"), 
    107108      String.format(template, "2", "5"), 
    108       String.format(template, "3", "5"), 
    109       "outlier.txt" // optional 
     109      String.format(template, "3", "5") 
    110110    }; 
    111111    FAKE_PATTERN = String.format(template, "<1-3>", "<1-5>"); 
     
    355355    if (indexed) 
    356356    { 
    357       LUT lut = ci.getChannelLut(c+1); 
    358        
    359       int retVal = lut.getRGB(rawValue) & 0xffffff; 
     357      //LUT lut = ci.getChannelLut(c+1); 
     358      LUT lut = ci.getChannelLut(); 
    360359       
    361360      System.out.println("    zct "+z+" "+c+" "+t+" rawVal "+rawValue); 
    362       System.out.println("    A "+lut.getAlpha(rawValue)+" R "+lut.getRed(rawValue)+" G "+lut.getGreen(rawValue)+" B "+lut.getBlue(rawValue)); 
     361      System.out.println("    raw value A "+lut.getAlpha(rawValue)+" R "+lut.getRed(rawValue)+" G "+lut.getGreen(rawValue)+" B "+lut.getBlue(rawValue)); 
     362      int retVal = lut.getRGB(rawValue); 
     363      System.out.println("    retVal binary A "+((retVal&0xff000000L)>>24)+" R "+((retVal&0x00ff0000L)>>16)+" G "+((retVal&0x0000ff00L)>>8)+" B "+((retVal&0x000000ffL)>>0)); 
     364      retVal &= 0xffffff; // strip off alpha 
     365      System.out.println("    retVal after & binary A "+((retVal&0xff000000L)>>24)+" R "+((retVal&0x00ff0000L)>>16)+" G "+((retVal&0x0000ff00L)>>8)+" B "+((retVal&0x000000ffL)>>0)); 
     366      System.out.println("    retVal via funcs() A "+lut.getAlpha(retVal)+" R "+lut.getRed(retVal)+" G "+lut.getGreen(retVal)+" B "+lut.getBlue(retVal)); 
     367       
     368      System.out.println("    returning "+retVal); 
    363369       
    364370      return retVal; 
     
    980986    // run a plugin whose changes are recorded 
    981987    WindowManager.setTempCurrentImage(imp); 
    982     IJ.run("Flip Horizontally","slice"); 
    983     assertEquals(x-2,(int)imp.getProcessor().getPixelValue(1,10)); 
     988    IJ.run("Invert","slice"); 
     989    assertEquals(254,(int)imp.getProcessor().getPixelValue(1,10)); 
    984990     
    985991    imp.setSlice(2); 
     
    987993     
    988994    imp.setSlice(1); 
    989     int expectedVal = wantToRemember ? x-2 : 1; 
     995    int expectedVal = wantToRemember ? 254 : 1; 
    990996    assertEquals(expectedVal,(int)imp.getProcessor().getPixelValue(1,10)); 
    991997  } 
     
    10481054  } 
    10491055   
    1050   private void memoryCropTest(int pixType, int x, int y, int cx, int cy) 
    1051   { 
    1052     String path = constructFakeFilename("crop", pixType, x, y, 1, 1, 1, 1, false, -1, false, -1); 
     1056  private void memoryCropTest(int x, int y, int ox, int oy, int cropSize) 
     1057  { 
     1058    assertTrue((x > 50) || (y > 10)); 
     1059    assertTrue(x < 256); 
     1060    assertTrue(y < 256); 
     1061    assertTrue(cropSize > 0); 
     1062    assertTrue(ox >= 0); 
     1063    assertTrue(oy >= 0); 
     1064    assertTrue((ox > 50) || (oy > 10)); 
     1065    assertTrue(ox + cropSize <= x); 
     1066    assertTrue(oy + cropSize <= y); 
     1067     
     1068    String path = constructFakeFilename("crop", FormatTools.UINT8, x, y, 1, 1, 1, 1, false, -1, false, -1); 
    10531069     
    10541070    // open image 
     
    10581074      options.setId(path); 
    10591075      options.setCrop(true); 
    1060       options.setCropRegion(0, new Region(0, 0, cx, cy)); 
     1076      options.setCropRegion(0, new Region(ox, oy, cropSize, cropSize)); 
    10611077      imps = BF.openImagePlus(options); 
    10621078    } 
     
    10701086    // test results 
    10711087    impsCountTest(imps,1); 
    1072     xyzctTest(imps[0],cx,cy,1,1,1); 
     1088    xyzctTest(imps[0],cropSize,cropSize,1,1,1); 
     1089     
     1090    // test we got the right pixels 
     1091    ImageProcessor proc = imps[0].getProcessor(); 
     1092     
     1093    for (int ix = 0; ix < cropSize; ix++) 
     1094      for (int iy = 0; iy < cropSize; iy++) 
     1095        assertEquals(ox+ix,proc.getPixelValue(ix, iy),0); 
    10731096  } 
    10741097   
    10751098  // note - this test needs to rely on crop() to get predictable nonzero minimums 
    10761099   
    1077   private void comboCropAndAutoscaleTest(int pixType, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT, int numSeries, 
     1100  private void comboCropAndAutoscaleTest(int pixType, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT, 
    10781101      int originCropX, int originCropY, int sizeCrop) 
    10791102  { 
    1080     final String path = constructFakeFilename("cropAutoscale",pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries, false, -1, false, -1); 
     1103    final String path = constructFakeFilename("cropAutoscale",pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, 1, false, -1, false, -1); 
    10811104     
    10821105    // needed for this test 
    1083     assertTrue(originCropX >= 50); 
    1084     assertTrue(originCropY >= 10);  
     1106    assertTrue((sizeX > 50) || (sizeY > 10)); 
     1107    assertTrue(sizeX < 256); 
     1108    assertTrue(sizeY < 256); 
    10851109    assertTrue(sizeCrop > 0); 
    1086     assertTrue(originCropX + sizeCrop < sizeX); 
    1087     assertTrue(originCropY + sizeCrop < sizeY); 
    1088     assertTrue(originCropX + sizeCrop < 255); 
     1110    assertTrue(originCropX >= 0); 
     1111    assertTrue(originCropY >= 0); 
     1112    assertTrue((originCropX > 50) || (originCropY > 10)); 
     1113    assertTrue(originCropX + sizeCrop <= sizeX); 
     1114    assertTrue(originCropY + sizeCrop <= sizeY); 
    10891115     
    10901116    ImagePlus[] imps = null; 
     
    11121138    ImageStack st = imp.getStack(); 
    11131139    int numSlices = st.getSize(); 
    1114  
    1115     long expectedMax = originCropX+sizeCrop-1; 
    1116     long expectedMin = originCropX; 
    1117  
    1118     for (int i = 0; i < numSlices; i++) 
     1140     
     1141    assertEquals(sizeZ*sizeC*sizeT,numSlices); 
     1142 
     1143    long expectedMax = minPixelValue(pixType) + originCropX + sizeCrop - 1; 
     1144    long expectedMin = minPixelValue(pixType) + originCropX; 
     1145 
     1146    if (FormatTools.isSigned(pixType) && !FormatTools.isFloatingPoint(pixType)) 
    11191147    { 
    1120       ImageProcessor proc = st.getProcessor(i+1); 
    1121       assertEquals(expectedMax,proc.getMax(),0.1); 
    1122       assertEquals(expectedMin,proc.getMin(),0.1); 
    1123     } 
     1148      Calibration cal = imp.getCalibration(); 
     1149      assertEquals(Calibration.STRAIGHT_LINE,cal.getFunction()); 
     1150      double[] coeffs = cal.getCoefficients(); 
     1151      int bitsPerPix = FormatTools.getBytesPerPixel(pixType) * 8; 
     1152      assertEquals(-(Math.pow(2, (bitsPerPix-1))),coeffs[0],0); 
     1153      assertEquals(1,coeffs[1],0); 
     1154    } 
     1155    else 
     1156      for (int i = 0; i < numSlices; i++) 
     1157      { 
     1158        ImageProcessor proc = st.getProcessor(i+1); 
     1159        assertEquals(expectedMin,proc.getMin(),0.1); 
     1160        assertEquals(expectedMax,proc.getMax(),0.1); 
     1161      } 
    11241162  } 
    11251163   
     
    11311169    final int sizeX = 50, sizeY = 20, sizeZ = 5, sizeC = 3, sizeT = 7, series = 3; 
    11321170    final String path = constructFakeFilename("concatSplitZ", 
    1133       FormatTools.UINT8, 50, 20, sizeZ, sizeC, sizeT, series, false, -1, false, -1); 
     1171      FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, series, false, -1, false, -1); 
    11341172 
    11351173    // open image 
     
    11491187      } 
    11501188     
    1151     // one time point per image 
     1189    // one image per focal plane 
    11521190    impsCountTest(imps,sizeZ); 
    11531191 
     
    11861224    final int sizeX = 50, sizeY = 20, sizeZ = 5, sizeC = 3, sizeT = 7, series = 3; 
    11871225    final String path = constructFakeFilename("concatSplitC", 
    1188       FormatTools.UINT8, 50, 20, sizeZ, sizeC, sizeT, series, false, -1, false, -1); 
     1226      FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, series, false, -1, false, -1); 
    11891227 
    11901228    // open image 
     
    12041242      } 
    12051243     
    1206     // one time point per image 
     1244    // one image per channel 
    12071245    impsCountTest(imps,sizeC); 
    12081246     
     
    12391277 
    12401278    final int sizeX = 50, sizeY = 20, sizeZ = 5, sizeC = 3, sizeT = 7, series = 3; 
    1241     final String path = constructFakeFilename("concatSplitC", 
    1242       FormatTools.UINT8, 50, 20, sizeZ, sizeC, sizeT, series, false, -1, false, -1); 
     1279    final String path = constructFakeFilename("concatSplitT", 
     1280      FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, series, false, -1, false, -1); 
    12431281 
    12441282    // open image 
     
    12581296      } 
    12591297     
    1260     // one time point per image 
     1298    // one image per time point 
    12611299    impsCountTest(imps,sizeT); 
    12621300     
     
    13301368     
    13311369    impsCountTest(imps,1); 
    1332     assertEquals(105,imps[0].getStack().getSize()); 
     1370     
     1371    ImageStack st = imps[0].getStack(); 
     1372     
     1373    assertEquals(FAKE_FILES.length*FakePlaneCount,st.getSize()); 
     1374     
     1375    int slice = 1; 
     1376    for (int fnum = 0; fnum < FAKE_FILES.length; fnum++) 
     1377    { 
     1378      for (int plane = 0; plane < FakePlaneCount; plane++) 
     1379      { 
     1380        ImageProcessor proc = st.getProcessor(slice++); 
     1381        //printVals(proc); 
     1382        assertEquals(0,sIndex(proc)); 
     1383        assertEquals(plane,iIndex(proc)); 
     1384        assertEquals(plane,zIndex(proc)); 
     1385        assertEquals(0,cIndex(proc)); 
     1386        assertEquals(0,tIndex(proc)); 
     1387      } 
     1388    } 
    13331389  } 
    13341390 
     
    13881444  public void testDatasetSwapDims() 
    13891445  { 
    1390     // TODO: testing only swapping Z&T of XYZTC. Add more option testing 
     1446    // TODO: testing only swapping Z&T of XYZTC. Add more option testing. 
     1447    //   Note that testComboManyOptions() tests another swap order 
    13911448 
    13921449    datasetSwapDimsTest(FormatTools.UINT8, 82, 47, 1, 3); 
     
    15281585  public void testColorAutoscale() 
    15291586  { 
    1530      
    15311587    // From BF: 
    15321588    // Autoscale - Stretches the histogram of the image planes to fit the data range. Does not alter underlying values in 
     
    17511807  public void testMemoryCrop() 
    17521808  { 
    1753     memoryCropTest(FormatTools.UINT8, 203, 409, 185, 104); 
    1754     memoryCropTest(FormatTools.UINT8, 203, 409, 203, 409); 
    1755     memoryCropTest(FormatTools.UINT8, 100, 30, 3, 3); 
    1756     memoryCropTest(FormatTools.INT32, 100, 30, 3, 3); 
     1809    memoryCropTest(203, 255, 55, 20, 3); 
     1810    memoryCropTest(203, 184, 55, 40, 2); 
     1811    memoryCropTest(101, 76, 0, 25, 4); 
     1812    memoryCropTest(100, 122, 0, 15, 3); 
    17571813  } 
    17581814   
     
    17791835    } 
    17801836 
    1781     // one channel per image 
     1837    // one image per channel 
    17821838    impsCountTest(imps,sizeC); 
    17831839     
     
    18231879      } 
    18241880     
    1825     // one focal plane per image 
     1881    // one image per focal plane 
    18261882    impsCountTest(imps,sizeZ); 
    18271883 
     
    18671923      } 
    18681924     
    1869     // one time point per image 
     1925    // one image per time point 
    18701926    impsCountTest(imps,sizeT); 
    18711927     
     
    19001956  { 
    19011957    // try a simple test: single small byte type image  
    1902     comboCropAndAutoscaleTest(FormatTools.UINT8,100,80,1,1,1,1,70,40,25); 
     1958    comboCropAndAutoscaleTest(FormatTools.UINT8,100,80,1,1,1,70,40,25); 
    19031959     
    19041960    // try multiple dimensions 
    1905     comboCropAndAutoscaleTest(FormatTools.UINT8,84,63,4,3,2,5,51,8,13); 
     1961    comboCropAndAutoscaleTest(FormatTools.UINT8,84,63,4,3,2,51,15,13); 
    19061962     
    19071963    // try various pixTypes 
    19081964    for (int pixType : PixelTypes) 
    1909       comboCropAndAutoscaleTest(pixType,96,96,2,2,2,2,70,60,10); 
     1965      comboCropAndAutoscaleTest(pixType,96,96,2,2,2,70,60,10); 
    19101966  } 
    19111967   
Note: See TracChangeset for help on using the changeset viewer.