Changeset 6393


Ignore:
Timestamp:
05/26/10 15:58:36 (10 years ago)
Author:
bdezonia
Message:

Some work on color tests

File:
1 edited

Legend:

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

    r6387 r6393  
    3434// TODO 
    3535//    waiting on BF implementations for 
    36 //      range step by 0 
    37 //      BF/imageJ returning wrong max num pixels for UINT32 - off by one 
     36//      range step by 0 or less 
     37//      BF/imageJ returning wrong values of max num pixels (UINT32 off by one, float weird too, etc.) 
    3838//      memoryRecord failure needs BF code fix 
    3939//      comboCropAutoscale() - autoscale of a cropped image returning min of whole image 
     40//      autoscale failing for Float and Double - need to decide on correct behavior in BF 
     41//      autoscale of signed images an issue (INT16 gets clamped 0..65535 by ImageJ also) 
    4042//  - flesh out existing tests 
    4143//      write tests for the color options : some mention was made that indexcolor is an issue in testing 
    4244//        default 
     45//        composite 
     46//        colorized 
     47//        grayscale 
    4348//        custom 
    44 //        rgb colorize - need to do actual tests. see BF gui to get idea of how it works 
    45 //        custom colorize - waiting for creation of API for setting r,g,b info 
    46 //        autoscale - working 
     49//        autoscale - test written 
    4750//      open individual files: try to come up with a way to test without a disk file as source 
    4851//      swapped dims test needs to test cases other than from default swapping Z & T 
     
    378381    assertEquals((byte)minB,blues[0]); 
    379382    assertEquals((byte)maxB,blues[255]); 
     383  } 
     384   
     385  private void genericLutTest(CompositeImage ci, int numChannels) 
     386  { 
     387    lutTest(ci,0,0,0,0,255,0,0); 
     388    if (numChannels > 1) 
     389      lutTest(ci,1,0,0,0,0,255,0); 
     390    if (numChannels > 2) 
     391      lutTest(ci,2,0,0,0,0,0,255); 
     392    if (numChannels > 3) 
     393      lutTest(ci,3,0,0,0,255,255,255); 
     394    if (numChannels > 4) 
     395      lutTest(ci,4,0,0,0,0,255,255); 
     396    if (numChannels > 5) 
     397      lutTest(ci,5,0,0,0,255,0,255); 
     398    if (numChannels > 6) 
     399      lutTest(ci,6,0,0,0,255,255,0); 
    380400  } 
    381401   
     
    650670  } 
    651671   
    652   // note - this test needs to rely on crop() to get predictable nonzero minimums 
    653    
    654   private void cropAndAutoscaleTest(int pixType, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT, int numSeries, 
    655       int originCropX, int originCropY, int sizeCrop) 
    656   { 
    657     final String path = constructFakeFilename("cropAutoscale",pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries, false, -1, false); 
    658      
    659     // needed for this test 
    660     assertTrue(originCropX >= 50); 
    661     assertTrue(originCropY >= 10);  
    662     assertTrue(sizeCrop > 0); 
    663     assertTrue(originCropX + sizeCrop < sizeX); 
    664     assertTrue(originCropY + sizeCrop < sizeY); 
    665     assertTrue(originCropX + sizeCrop < 255); 
     672  private void colorCompositeTest(int pixType, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT, int numSeries) 
     673  { 
     674    // reportedly works in BF for 2<=sizeC<=7 and also numSeries*sizeC*3 <= 25 
     675     
     676    assertTrue(sizeC >= 2); 
     677    assertTrue(sizeC <= 7); 
     678    assertTrue(numSeries*sizeC*3 <= 25);  // slider limit in IJ 
     679     
     680    String path = constructFakeFilename("colorComposite", pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries, false, -1, false); 
    666681     
    667682    ImagePlus[] imps = null; 
    668683    ImagePlus imp = null; 
    669      
    670     try { 
    671       ImporterOptions options = new ImporterOptions(); 
    672       options.setAutoscale(true); 
    673       options.setCrop(true); 
    674       options.setCropRegion(0,new Region(originCropX,originCropY,sizeCrop,sizeCrop)); 
    675       options.setId(path); 
    676       imps = BF.openImagePlus(options); 
    677     } 
    678     catch (IOException e) { 
    679       fail(e.getMessage()); 
    680     } 
    681     catch (FormatException e) { 
    682       fail(e.getMessage()); 
    683     } 
    684      
    685     impsTest(imps,1); 
     684    CompositeImage ci = null; 
     685     
     686    try { 
     687      ImporterOptions options = new ImporterOptions(); 
     688      options.setColorMode(ImporterOptions.COLOR_MODE_COMPOSITE); 
     689      options.setId(path); 
     690      imps = BF.openImagePlus(options); 
     691    } 
     692    catch (IOException e) { 
     693      fail(e.getMessage()); 
     694    } 
     695    catch (FormatException e) { 
     696      fail(e.getMessage()); 
     697    } 
     698 
     699    impsTest(imps,1); 
     700     
    686701    imp = imps[0]; 
    687     xyzctTest(imps[0],sizeCrop,sizeCrop,sizeZ,sizeC,sizeT); 
    688  
    689     ImageStack st = imp.getStack(); 
    690     int numSlices = st.getSize(); 
    691  
    692     long expectedMax = originCropX+sizeCrop-1; 
    693     long expectedMin = originCropX; 
    694  
    695     for (int i = 0; i < numSlices; i++) 
    696     { 
    697       ImageProcessor proc = st.getProcessor(i+1); 
    698       assertEquals(expectedMax,proc.getMax(),0.1); 
    699       assertEquals(expectedMin,proc.getMin(),0.1); 
    700     } 
     702     
     703    xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,sizeT); 
     704     
     705    assertTrue(imp.isComposite()); 
     706     
     707    ci = (CompositeImage)imp; 
     708     
     709    assertFalse(ci.hasCustomLuts()); 
     710 
     711    assertEquals(CompositeImage.COMPOSITE, ci.getMode()); 
     712     
     713    genericLutTest(ci,sizeC); 
     714     
     715    // TODO - do I need to test more than LUTs? 
     716  } 
     717   
     718  private void colorCustomTest(int pixType, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT, int numSeries) 
     719  { 
     720    // reportedly works in BF for 2<=sizeC<=7 and also numSeries*sizeC*3 <= 25 
     721     
     722    assertTrue(sizeC >= 2); 
     723    assertTrue(sizeC <= 7); 
     724    assertTrue(numSeries*sizeC*3 <= 25);  // slider limit in IJ 
     725     
     726    String path = constructFakeFilename("colorCustom", pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries, false, -1, false); 
     727    ImagePlus[] imps = null; 
     728    ImagePlus imp = null; 
     729    CompositeImage ci = null; 
     730     
     731    try { 
     732      ImporterOptions options = new ImporterOptions(); 
     733      options.setColorMode(ImporterOptions.COLOR_MODE_CUSTOM); 
     734      for (int s = 0; s < numSeries; s++) 
     735      { 
     736        options.setCustomColor(s, 0, Color.BLUE); 
     737        if (sizeC > 1) 
     738          options.setCustomColor(s, 1, Color.RED); 
     739        if (sizeC > 2) 
     740          options.setCustomColor(s, 2, Color.GREEN); 
     741        if (sizeC > 3) 
     742          options.setCustomColor(s, 3, Color.MAGENTA); 
     743        if (sizeC > 4) 
     744          options.setCustomColor(s, 4, Color.CYAN); 
     745        if (sizeC > 5) 
     746          options.setCustomColor(s, 5, Color.YELLOW); 
     747        if (sizeC > 6) 
     748          options.setCustomColor(s, 6, Color.GRAY); 
     749      } 
     750      options.setId(path); 
     751      imps = BF.openImagePlus(options); 
     752    } 
     753    catch (IOException e) { 
     754      fail(e.getMessage()); 
     755    } 
     756    catch (FormatException e) { 
     757      fail(e.getMessage()); 
     758    } 
     759 
     760    impsTest(imps,1); 
     761     
     762    imp = imps[0]; 
     763     
     764    xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,sizeT); 
     765     
     766    assertTrue(imp.isComposite()); 
     767     
     768    ci = (CompositeImage)imp; 
     769     
     770    assertFalse(ci.hasCustomLuts()); 
     771 
     772    assertEquals(CompositeImage.COLOR, ci.getMode()); 
     773 
     774    lutTest(ci,0,0,0,0,0,0,255);        // blue 
     775    if (sizeC >= 2) 
     776      lutTest(ci,1,0,0,0,255,0,0);      // red 
     777    if (sizeC >= 3) 
     778      lutTest(ci,2,0,0,0,0,255,0);      // green 
     779    if (sizeC >= 4) 
     780      lutTest(ci,3,0,0,0,255,0,255);    // magenta 
     781    if (sizeC >= 5) 
     782      lutTest(ci,4,0,0,0,0,255,255);    // cyan 
     783    if (sizeC >= 7) 
     784      lutTest(ci,5,0,0,0,255,255,0);    // yellow 
     785    if (sizeC >= 7) 
     786      lutTest(ci,6,0,0,0,128,128,128);  // gray 
     787     
     788    // TODO - do I need to test more than LUTs? 
    701789  } 
    702790   
     
    860948  } 
    861949   
    862  
     950  // note - this test needs to rely on crop() to get predictable nonzero minimums 
     951   
     952  private void comboCropAndAutoscaleTest(int pixType, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT, int numSeries, 
     953      int originCropX, int originCropY, int sizeCrop) 
     954  { 
     955    final String path = constructFakeFilename("cropAutoscale",pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries, false, -1, false); 
     956     
     957    // needed for this test 
     958    assertTrue(originCropX >= 50); 
     959    assertTrue(originCropY >= 10);  
     960    assertTrue(sizeCrop > 0); 
     961    assertTrue(originCropX + sizeCrop < sizeX); 
     962    assertTrue(originCropY + sizeCrop < sizeY); 
     963    assertTrue(originCropX + sizeCrop < 255); 
     964     
     965    ImagePlus[] imps = null; 
     966    ImagePlus imp = null; 
     967     
     968    try { 
     969      ImporterOptions options = new ImporterOptions(); 
     970      options.setAutoscale(true); 
     971      options.setCrop(true); 
     972      options.setCropRegion(0,new Region(originCropX,originCropY,sizeCrop,sizeCrop)); 
     973      options.setId(path); 
     974      imps = BF.openImagePlus(options); 
     975    } 
     976    catch (IOException e) { 
     977      fail(e.getMessage()); 
     978    } 
     979    catch (FormatException e) { 
     980      fail(e.getMessage()); 
     981    } 
     982     
     983    impsTest(imps,1); 
     984    imp = imps[0]; 
     985    xyzctTest(imps[0],sizeCrop,sizeCrop,sizeZ,sizeC,sizeT); 
     986 
     987    ImageStack st = imp.getStack(); 
     988    int numSlices = st.getSize(); 
     989 
     990    long expectedMax = originCropX+sizeCrop-1; 
     991    long expectedMin = originCropX; 
     992 
     993    for (int i = 0; i < numSlices; i++) 
     994    { 
     995      ImageProcessor proc = st.getProcessor(i+1); 
     996      assertEquals(expectedMax,proc.getMax(),0.1); 
     997      assertEquals(expectedMin,proc.getMin(),0.1); 
     998    } 
     999  } 
     1000   
    8631001// ** ImporterTest methods ************************************************************** 
    8641002 
     
    10281166  public void testColorComposite() 
    10291167  { 
     1168    // BF only supporting C from 2 to 7 and due to IJ's slider limitation (C*numSeries*3) <= 25 
     1169     
     1170    int[] pixTypes = new int[] {FormatTools.INT8, FormatTools.INT16, FormatTools.INT32}; 
     1171    int[] xs = new int[] {56,107}; 
     1172    int[] ys = new int[] {41,86}; 
     1173    int[] zs = new int[] {1,2}; 
     1174    int[] cs = new int[] {2,3,4,5,6,7};  // all that BF/IJ supports right now 
     1175    int[] ts = new int[] {1,2}; 
     1176    int[] series = new int[] {1,2,3,4}; 
     1177     
     1178    for (int pixFormat : pixTypes) 
     1179      for (int x : xs) 
     1180        for (int y : ys) 
     1181          for (int z : zs) 
     1182            for (int c : cs) 
     1183              for (int t : ts) 
     1184                for (int s : series) 
     1185                  if ((c*s*3) <= 25)  // IJ slider limitation 
     1186                    colorCompositeTest(pixFormat,x,y,z,c,t,s); 
     1187  } 
     1188   
     1189  @Test 
     1190  public void testColorColorized() 
     1191  { 
    10301192    int sizeX = 100, sizeY = 120, sizeZ = 2, sizeC = 7, sizeT = 4, numSeries = 3; 
    10311193     
    1032     String path = constructFakeFilename("colorComposite", FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries, false, -1, false); 
     1194    String path = constructFakeFilename("colorColorized", FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries, false, -1, false); 
    10331195     
    10341196    ImagePlus[] imps = null; 
     
    10381200    try { 
    10391201      ImporterOptions options = new ImporterOptions(); 
    1040       options.setColorMode(ImporterOptions.COLOR_MODE_COMPOSITE); 
     1202      options.setColorMode(ImporterOptions.COLOR_MODE_COLORIZED); 
    10411203      options.setId(path); 
    10421204      imps = BF.openImagePlus(options); 
     
    10611223    assertFalse(ci.hasCustomLuts()); 
    10621224 
    1063     assertEquals(CompositeImage.COMPOSITE, ci.getMode()); 
    1064      
    1065     lutTest(ci,0,0,0,0,255,0,0); 
    1066     if (sizeC > 1) 
    1067       lutTest(ci,1,0,0,0,0,255,0); 
    1068     if (sizeC > 2) 
    1069       lutTest(ci,2,0,0,0,0,0,255); 
    1070     if (sizeC > 3) 
    1071       lutTest(ci,3,0,0,0,255,255,255); 
    1072     if (sizeC > 4) 
    1073       lutTest(ci,4,0,0,0,0,255,255); 
    1074     if (sizeC > 5) 
    1075       lutTest(ci,5,0,0,0,255,0,255); 
    1076     if (sizeC > 6) 
    1077       lutTest(ci,6,0,0,0,255,255,0); 
    1078      
    1079     fail("partial impl"); 
    1080   } 
    1081    
    1082   @Test 
    1083   public void testColorColorized() 
     1225    assertEquals(CompositeImage.COLOR, ci.getMode()); 
     1226     
     1227    genericLutTest(ci,sizeC); 
     1228 
     1229    fail("unfinished"); 
     1230  } 
     1231   
     1232  @Test 
     1233  public void testColorGrayscale() 
    10841234  { 
    10851235    int sizeX = 100, sizeY = 120, sizeZ = 2, sizeC = 7, sizeT = 4, numSeries = 3; 
    10861236     
    1087     String path = constructFakeFilename("colorColorized", FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries, false, -1, false); 
     1237    String path = constructFakeFilename("colorGrayscale", FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries, false, -1, false); 
    10881238     
    10891239    ImagePlus[] imps = null; 
     
    10931243    try { 
    10941244      ImporterOptions options = new ImporterOptions(); 
    1095       options.setColorMode(ImporterOptions.COLOR_MODE_COLORIZED); 
     1245      options.setColorMode(ImporterOptions.COLOR_MODE_GRAYSCALE); 
    10961246      options.setId(path); 
    10971247      imps = BF.openImagePlus(options); 
     
    11161266    assertFalse(ci.hasCustomLuts()); 
    11171267 
    1118     assertEquals(CompositeImage.COLOR, ci.getMode()); 
    1119      
    1120     lutTest(ci,0,0,0,0,255,0,0); 
    1121     if (sizeC > 1) 
    1122       lutTest(ci,1,0,0,0,0,255,0); 
    1123     if (sizeC > 2) 
    1124       lutTest(ci,2,0,0,0,0,0,255); 
    1125     if (sizeC > 3) 
    1126       lutTest(ci,3,0,0,0,255,255,255); 
    1127     if (sizeC > 4) 
    1128       lutTest(ci,4,0,0,0,0,255,255); 
    1129     if (sizeC > 5) 
    1130       lutTest(ci,5,0,0,0,255,0,255); 
    1131     if (sizeC > 6) 
    1132       lutTest(ci,6,0,0,0,255,255,0); 
     1268    assertEquals(CompositeImage.GRAYSCALE, ci.getMode()); 
     1269 
     1270    genericLutTest(ci,sizeC); 
    11331271 
    11341272    fail("unfinished"); 
     
    11361274   
    11371275  @Test 
    1138   public void testColorGrayscale() 
    1139   { 
    1140     int sizeX = 100, sizeY = 120, sizeZ = 2, sizeC = 7, sizeT = 4, numSeries = 3; 
    1141      
    1142     String path = constructFakeFilename("colorGrayscale", FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries, false, -1, false); 
    1143      
    1144     ImagePlus[] imps = null; 
    1145     ImagePlus imp = null; 
    1146     CompositeImage ci = null; 
    1147      
    1148     try { 
    1149       ImporterOptions options = new ImporterOptions(); 
    1150       options.setColorMode(ImporterOptions.COLOR_MODE_GRAYSCALE); 
    1151       options.setId(path); 
    1152       imps = BF.openImagePlus(options); 
    1153     } 
    1154     catch (IOException e) { 
    1155       fail(e.getMessage()); 
    1156     } 
    1157     catch (FormatException e) { 
    1158       fail(e.getMessage()); 
    1159     } 
    1160  
    1161     impsTest(imps,1); 
    1162      
    1163     imp = imps[0]; 
    1164      
    1165     xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,sizeT); 
    1166      
    1167     assertTrue(imp.isComposite()); 
    1168      
    1169     ci = (CompositeImage)imp; 
    1170      
    1171     assertFalse(ci.hasCustomLuts()); 
    1172  
    1173     assertEquals(CompositeImage.GRAYSCALE, ci.getMode()); 
    1174  
    1175     lutTest(ci,0,0,0,0,255,0,0); 
    1176     if (sizeC > 1) 
    1177       lutTest(ci,1,0,0,0,0,255,0); 
    1178     if (sizeC > 2) 
    1179       lutTest(ci,2,0,0,0,0,0,255); 
    1180     if (sizeC > 3) 
    1181       lutTest(ci,3,0,0,0,255,255,255); 
    1182     if (sizeC > 4) 
    1183       lutTest(ci,4,0,0,0,0,255,255); 
    1184     if (sizeC > 5) 
    1185       lutTest(ci,5,0,0,0,255,0,255); 
    1186     if (sizeC > 6) 
    1187       lutTest(ci,6,0,0,0,255,255,0); 
    1188  
    1189     fail("unfinished"); 
    1190   } 
    1191    
    1192   @Test 
    11931276  public void testColorCustom() 
    11941277  { 
    1195     int sizeX = 100, sizeY = 120, sizeZ = 2, sizeC = 7, sizeT = 4, numSeries = 3; 
    1196      
    1197     String path = constructFakeFilename("colorCustom", FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries, false, -1, false); 
    1198      
    1199     ImagePlus[] imps = null; 
    1200     ImagePlus imp = null; 
    1201     CompositeImage ci = null; 
    1202      
    1203     try { 
    1204       ImporterOptions options = new ImporterOptions(); 
    1205       options.setColorMode(ImporterOptions.COLOR_MODE_CUSTOM); 
    1206       for (int s = 0; s < numSeries; s++) 
    1207       { 
    1208         options.setCustomColor(s, 0, Color.BLUE); 
    1209         if (sizeC > 1) 
    1210           options.setCustomColor(s, 1, Color.RED); 
    1211         if (sizeC > 2) 
    1212           options.setCustomColor(s, 2, Color.GREEN); 
    1213         if (sizeC > 3) 
    1214           options.setCustomColor(s, 3, Color.MAGENTA); 
    1215         if (sizeC > 4) 
    1216           options.setCustomColor(s, 4, Color.CYAN); 
    1217         if (sizeC > 5) 
    1218           options.setCustomColor(s, 5, Color.YELLOW); 
    1219         if (sizeC > 6) 
    1220           options.setCustomColor(s, 6, Color.GRAY); 
    1221       } 
    1222       options.setId(path); 
    1223       imps = BF.openImagePlus(options); 
    1224     } 
    1225     catch (IOException e) { 
    1226       fail(e.getMessage()); 
    1227     } 
    1228     catch (FormatException e) { 
    1229       fail(e.getMessage()); 
    1230     } 
    1231  
    1232     impsTest(imps,1); 
    1233      
    1234     imp = imps[0]; 
    1235      
    1236     xyzctTest(imp,sizeX,sizeY,sizeZ,sizeC,sizeT); 
    1237      
    1238     assertTrue(imp.isComposite()); 
    1239      
    1240     ci = (CompositeImage)imp; 
    1241      
    1242     assertFalse(ci.hasCustomLuts()); 
    1243  
    1244     assertEquals(CompositeImage.COLOR, ci.getMode()); 
    1245  
    1246     lutTest(ci,0,0,0,0,0,0,255);        // blue 
    1247     if (sizeC >= 2) 
    1248       lutTest(ci,1,0,0,0,255,0,0);      // red 
    1249     if (sizeC >= 3) 
    1250       lutTest(ci,2,0,0,0,0,255,0);      // green 
    1251     if (sizeC >= 4) 
    1252       lutTest(ci,3,0,0,0,255,0,255);    // magenta 
    1253     if (sizeC >= 5) 
    1254       lutTest(ci,4,0,0,0,0,255,255);    // cyan 
    1255     if (sizeC >= 7) 
    1256       lutTest(ci,5,0,0,0,255,255,0);    // yellow 
    1257     if (sizeC >= 7) 
    1258       lutTest(ci,6,0,0,0,128,128,128);  // gray 
    1259  
    1260     fail("unfinished"); 
     1278    // BF only supporting C from 2 to 7 and due to IJ's slider limitation (C*numSeries*3) <= 25 
     1279     
     1280    int[] pixTypes = new int[]{FormatTools.UINT8, FormatTools.UINT16, FormatTools.FLOAT}; 
     1281    int[] xs = new int[] {41,123}; 
     1282    int[] ys = new int[] {10,105}; 
     1283    int[] zs = new int[] {1,2}; 
     1284    int[] cs = new int[] {2,3,4,5,6,7};  // all that BF/IJ supports right now 
     1285    int[] ts = new int[] {1,2}; 
     1286    int[] series = new int[] {1,2,3,4}; 
     1287     
     1288    for (int pixFormat : pixTypes) 
     1289      for (int x : xs) 
     1290        for (int y : ys) 
     1291          for (int z : zs) 
     1292            for (int c : cs) 
     1293              for (int t : ts) 
     1294                for (int s : series) 
     1295                  if ((c*s*3) <= 25)  // IJ slider limitation 
     1296                    colorCustomTest(pixFormat,x,y,z,c,t,s); 
    12611297  } 
    12621298   
     
    16161652     
    16171653    /* TODO - enable when step by 0 code fixed and remove extra tests above 
    1618     // uber combo test 
     1654    // uber combo test : comprehensive but probably WAY too much computation to finish in reasonable time 
    16191655    z = 6; c = 5; t = 4; 
    16201656    for (int zStart = -1; zStart < z+2; zStart++) 
     
    18021838  { 
    18031839    // try a simple test: single small byte type image  
    1804     cropAndAutoscaleTest(FormatTools.UINT8,100,80,1,1,1,1,70,40,25); 
     1840    comboCropAndAutoscaleTest(FormatTools.UINT8,100,80,1,1,1,1,70,40,25); 
    18051841     
    18061842    // try multiple dimensions 
    1807     cropAndAutoscaleTest(FormatTools.UINT8,84,63,4,3,2,5,51,8,13); 
     1843    comboCropAndAutoscaleTest(FormatTools.UINT8,84,63,4,3,2,5,51,8,13); 
    18081844     
    18091845    // try various pixTypes 
    18101846    for (int pixType : PixelTypes) 
    1811       cropAndAutoscaleTest(pixType,96,96,2,2,2,2,70,60,10); 
     1847      comboCropAndAutoscaleTest(pixType,96,96,2,2,2,2,70,60,10); 
    18121848  } 
    18131849   
Note: See TracChangeset for help on using the changeset viewer.