Changeset 6410


Ignore:
Timestamp:
05/27/10 15:39:12 (10 years ago)
Author:
bdezonia
Message:

some refactoring, some composite test code

File:
1 edited

Legend:

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

    r6403 r6410  
    5959  private enum Axis {Z,C,T}; 
    6060   
    61   private enum ChannelOrder {XYZTC, XYZCT, XYCZT, XYCTZ, XYTZC, XYTCZ}; 
     61  private enum ChannelOrder {ZTC, ZCT, CZT, CTZ, TZC, TCZ}; 
    6262   
    6363  private static final boolean[] BooleanStates = new boolean[] {false, true}; 
     
    6969      }; 
    7070   
     71  private static Color[] DefaultColorOrder = 
     72    new Color[] {Color.RED, Color.GREEN, Color.BLUE, Color.WHITE, Color.CYAN, Color.MAGENTA, Color.YELLOW}; 
     73   
     74  private static Color[] CustomColorOrder = 
     75    new Color[] {Color.BLUE, Color.RED, Color.GREEN, Color.MAGENTA, Color.YELLOW, Color.CYAN, Color.WHITE}; 
     76 
    7177  private static final String[] FAKE_FILES; 
    7278  private static final String FAKE_PATTERN; 
     
    159165  } 
    160166 
     167  /** returns the character at the given index within a string that is a permutation of ZCT */ 
    161168  private char axisChar(String order, int d) 
    162169  { 
     
    164171      throw new IllegalArgumentException("axisChar() - index out of bounds [0..2]: "+d); 
    165172     
    166     return order.charAt(2+d); 
    167   } 
    168    
     173    return order.charAt(d); 
     174  } 
     175   
     176  /** returns Axis given an order string and an index */ 
    169177  private Axis axis(String order, int d) 
    170178  { 
     
    178186  } 
    179187 
     188  /** returns z, c, or t value given an Axis selector */ 
    180189  private int value(Axis axis, int z, int c, int t) 
    181190  { 
     
    187196  } 
    188197   
     198  /** returns z, c, or t index value given an ImageProcessor and an Axis selector */ 
    189199  private int index(Axis axis, ImageProcessor proc) 
    190200  { 
     
    196206  } 
    197207 
     208  /** get full order (XYTCZ) from ChannelOrder (TCZ) as string */ 
     209  private String bfChanOrd(ChannelOrder order) 
     210  { 
     211    return "XY" + order.toString(); 
     212  } 
     213   
     214  /** returns the number of of elements in a series given from, to, and by values */ 
    198215  private int numInSeries(int from, int to, int by) 
    199216  { 
     
    345362  // ****** helper tests **************************************************************************************** 
    346363   
    347   private void impsTest(ImagePlus[] imps, int numExpected) 
     364  /** tests that the correct number of ImagePluses exist */ 
     365  private void impsCountTest(ImagePlus[] imps, int numExpected) 
    348366  { 
    349367    assertNotNull(imps); 
     
    351369  } 
    352370   
     371  /** tests that the dimensions of an ImagePlus match passed in x,y,z,c,t values */ 
    353372  private void xyzctTest(ImagePlus imp, int x, int y, int z, int c, int t) 
    354373  { 
     
    361380  } 
    362381   
    363   // channel is 0-based 
     382  /** tests that the first and last entries of a lut match expected values */ 
    364383  private void lutTest(CompositeImage ci, int channel, int minR, int minG, int minB, int maxR, int maxG, int maxB) 
    365384  { 
     385    // channel is 0-based 
    366386    LUT lut = ci.getChannelLut(channel+1);  // IJ is 1-based 
    367387     
     
    381401    assertEquals((byte)maxB,blues[255]); 
    382402  } 
    383    
    384   private void multipleLutTests(CompositeImage ci, int numChannels, Color[] colors) 
     403 
     404  /** tests that each channel lut in a CompositeImage matches the passed in expected colors */ 
     405  private void colorTests(CompositeImage ci, int numChannels, Color[] expectedColors) 
    385406  { 
    386407    for (int i = 0; i < numChannels; i++) 
    387408    { 
    388       Color color = colors[i]; 
     409      Color color = expectedColors[i]; 
    389410      lutTest(ci,i,0,0,0,color.getRed(),color.getGreen(),color.getBlue()); 
    390411    } 
    391412  } 
    392413   
    393   private void genericLutTest(CompositeImage ci, int numChannels) 
    394   { 
    395     Color[] defaultColorOrder = 
    396       new Color[] {Color.RED, Color.GREEN, Color.BLUE, Color.WHITE, Color.CYAN, Color.MAGENTA, Color.YELLOW}; 
    397      
    398     multipleLutTests(ci,numChannels,defaultColorOrder); 
    399   } 
    400    
     414  /** tests BioFormats when directly calling BF.openImagePlus(path) (no options set) */ 
    401415  private void defaultBehaviorTest(int pixType, int x, int y, int z, int c, int t) 
    402416  { 
     
    414428    } 
    415429     
    416     impsTest(imps,1); 
     430    impsCountTest(imps,1); 
    417431 
    418432    ImagePlus imp = imps[0]; 
     
    421435  } 
    422436   
    423   private void outputStackOrderTest(int pixType, String order, int x, int y, int z, int c, int t) 
    424   { 
    425     String path = constructFakeFilename(order, pixType, x, y, z, c, t, -1, false, -1, false); 
    426      
    427     ImagePlus[] imps = null; 
    428     try { 
    429       ImporterOptions options = new ImporterOptions(); 
    430       options.setId(path); 
    431       options.setStackOrder(order); 
    432       imps = BF.openImagePlus(options); 
    433     } 
    434     catch (IOException e) { 
    435       fail(e.getMessage()); 
    436     } 
    437     catch (FormatException e) { 
    438       fail(e.getMessage()); 
    439     } 
    440  
    441     impsTest(imps,1); 
     437  private void outputStackOrderTest(int pixType, ChannelOrder order, int x, int y, int z, int c, int t) 
     438  { 
     439    String bfChOrder = bfChanOrd(order); 
     440    String chOrder = order.toString(); 
     441     
     442    String path = constructFakeFilename("stack", pixType, x, y, z, c, t, -1, false, -1, false); 
     443     
     444    ImagePlus[] imps = null; 
     445    try { 
     446      ImporterOptions options = new ImporterOptions(); 
     447      options.setId(path); 
     448      options.setStackOrder(bfChOrder); 
     449      imps = BF.openImagePlus(options); 
     450    } 
     451    catch (IOException e) { 
     452      fail(e.getMessage()); 
     453    } 
     454    catch (FormatException e) { 
     455      fail(e.getMessage()); 
     456    } 
     457 
     458    impsCountTest(imps,1); 
    442459     
    443460    ImagePlus imp = imps[0]; 
     
    452469    int procNum = 1; 
    453470    //System.out.println(order); 
    454     Axis fastest = axis(order,0); 
    455     Axis middle = axis(order,1); 
    456     Axis slowest = axis(order,2); 
     471    Axis fastest = axis(chOrder,0); 
     472    Axis middle = axis(chOrder,1); 
     473    Axis slowest = axis(chOrder,2); 
    457474    int maxI = value(slowest,z,c,t); 
    458475    int maxJ = value(middle,z,c,t); 
     
    476493  private void datasetSwapDimsTest(int pixType, int x, int y, int z, int t) 
    477494  { 
    478     int c = 3; String origOrder = "XYZCT", swappedOrder = "XYTCZ"; 
     495    int c = 3; ChannelOrder origOrder = ChannelOrder.ZCT, swappedOrder = ChannelOrder.TCZ; 
    479496    String path = constructFakeFilename("swapDims", pixType, x, y, z, c, t, -1, false, -1, false); 
    480497    ImagePlus[] imps = null; 
     
    483500      options.setId(path); 
    484501      options.setSwapDimensions(true); 
    485       options.setInputOrder(0, swappedOrder); 
    486       imps = BF.openImagePlus(options); 
    487     } 
    488     catch (IOException e) { 
    489       fail(e.getMessage()); 
    490     } 
    491     catch (FormatException e) { 
    492       fail(e.getMessage()); 
    493     } 
    494  
    495     impsTest(imps,1); 
     502      options.setInputOrder(0, bfChanOrd(swappedOrder)); 
     503      imps = BF.openImagePlus(options); 
     504    } 
     505    catch (IOException e) { 
     506      fail(e.getMessage()); 
     507    } 
     508    catch (FormatException e) { 
     509      fail(e.getMessage()); 
     510    } 
     511 
     512    impsCountTest(imps,1); 
    496513 
    497514    ImagePlus imp = imps[0]; 
     
    518535  private void datasetOpenAllSeriesTest(int x, int y, int z, int c, int t, int s) 
    519536  { 
    520     String path = constructFakeFilename("XYZCT", FormatTools.UINT32, x, y, z, c, t, s, false, -1, false); 
     537    String path = constructFakeFilename("openAllSeries", FormatTools.UINT32, x, y, z, c, t, s, false, -1, false); 
    521538     
    522539    // try it when false 
     
    538555    // test results 
    539556     
    540     impsTest(imps,1); 
     557    impsCountTest(imps,1); 
    541558    xyzctTest(imps[0],x,y,z,c,t); 
    542559    assertEquals(z*c*t, imps[0].getStack().getSize()); 
     
    568585  } 
    569586   
    570   private void datasetConcatenateTest(int pixType, String order, 
    571       int x, int y, int z, int c, int t, int s) 
     587  private void datasetConcatenateTest(int pixType, int x, int y, int z, int c, int t, int s) 
    572588  { 
    573589    assertTrue(s >= 1);  // necessary for this test 
     
    575591    // open all series as one 
    576592     
    577     String path = constructFakeFilename(order, pixType, x, y, z, c, t, s, false, -1, false); 
     593    String path = constructFakeFilename("concat", pixType, x, y, z, c, t, s, false, -1, false); 
    578594    ImagePlus[] imps = null; 
    579595    try { 
     
    593609    // test results 
    594610     
    595     impsTest(imps,1); 
     611    impsCountTest(imps,1); 
    596612    ImageStack st = imps[0].getStack(); 
    597613 
     
    636652    } 
    637653     
    638     impsTest(imps,1); 
     654    impsCountTest(imps,1); 
    639655     
    640656    imp = imps[0]; 
     
    668684  } 
    669685   
    670   private void colorCompositeTest(int pixType, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT, int numSeries) 
     686  private int getPixelValue(CompositeImage ci, int channel, boolean indexed) 
     687  { 
     688    int rawValue = iIndex(ci.getProcessor(channel)); 
     689    if (indexed) 
     690      return ci.getChannelLut(channel).getRGB(rawValue); 
     691    else 
     692      return rawValue; 
     693  } 
     694   
     695  private void colorCompositeTest(boolean indexed, int pixType, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT, int numSeries) 
    671696  { 
    672697    // reportedly works in BF for 2<=sizeC<=7 and also numSeries*sizeC*3 <= 25 
     
    676701    assertTrue(numSeries*sizeC*3 <= 25);  // slider limit in IJ 
    677702     
    678     String path = constructFakeFilename("colorComposite", pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries, false, -1, false); 
     703    int rgb = -1; 
     704    if (indexed) rgb = 1;  // TEMP 
     705     
     706    String path = constructFakeFilename("colorComposite", pixType, sizeX, sizeY, sizeZ, sizeC, sizeT, numSeries, 
     707        indexed, rgb, false); 
    679708     
    680709    ImagePlus[] imps = null; 
     
    695724    } 
    696725 
    697     impsTest(imps,1); 
     726    impsCountTest(imps,1); 
    698727     
    699728    imp = imps[0]; 
     
    709738    assertEquals(CompositeImage.COMPOSITE, ci.getMode()); 
    710739     
    711     genericLutTest(ci,sizeC); 
     740    colorTests(ci,sizeC,DefaultColorOrder); 
    712741  } 
    713742   
     
    724753    ImagePlus imp = null; 
    725754    CompositeImage ci = null; 
    726     Color[] colors = new Color[] {Color.BLUE, Color.RED, Color.GREEN, Color.MAGENTA, Color.CYAN, Color.YELLOW, Color.WHITE}; 
    727755     
    728756    try { 
     
    731759      for (int s = 0; s < numSeries; s++) 
    732760        for (int c = 0; c < sizeC; c++) 
    733           options.setCustomColor(s, c, colors[c]); 
    734       options.setId(path); 
    735       imps = BF.openImagePlus(options); 
    736     } 
    737     catch (IOException e) { 
    738       fail(e.getMessage()); 
    739     } 
    740     catch (FormatException e) { 
    741       fail(e.getMessage()); 
    742     } 
    743  
    744     impsTest(imps,1); 
     761          options.setCustomColor(s, c, CustomColorOrder[c]); 
     762      options.setId(path); 
     763      imps = BF.openImagePlus(options); 
     764    } 
     765    catch (IOException e) { 
     766      fail(e.getMessage()); 
     767    } 
     768    catch (FormatException e) { 
     769      fail(e.getMessage()); 
     770    } 
     771 
     772    impsCountTest(imps,1); 
    745773     
    746774    imp = imps[0]; 
     
    756784    assertEquals(CompositeImage.COLOR, ci.getMode()); 
    757785 
    758     multipleLutTests(ci,sizeC,colors); 
     786    colorTests(ci,sizeC,CustomColorOrder); 
    759787  } 
    760788   
     
    781809   
    782810      // test results 
    783       impsTest(imps,1); 
     811      impsCountTest(imps,1); 
    784812      ImagePlus imp = imps[0]; 
    785813      xyzctTest(imp,x,y,z,c,t); 
     
    814842 
    815843    // basic tests 
    816     impsTest(imps,1); 
     844    impsCountTest(imps,1); 
    817845    imp = imps[0]; 
    818846    xyzctTest(imp,x,y,z,c,t); 
     
    884912     
    885913    // should have the data in one series 
    886     impsTest(imps,1); 
     914    impsCountTest(imps,1); 
    887915    ImagePlus imp = imps[0]; 
    888916    xyzctTest(imp,x,y,numInSeries(zFrom,zTo,zBy),numInSeries(cFrom,cTo,cBy),numInSeries(tFrom,tTo,tBy)); 
     
    914942 
    915943    // test results 
    916     impsTest(imps,1); 
     944    impsCountTest(imps,1); 
    917945    xyzctTest(imps[0],cx,cy,1,1,1); 
    918946  } 
     
    951979    } 
    952980     
    953     impsTest(imps,1); 
     981    impsCountTest(imps,1); 
    954982    imp = imps[0]; 
    955983    xyzctTest(imps[0],sizeCrop,sizeCrop,sizeZ,sizeC,sizeT); 
     
    9861014  { 
    9871015    for (ChannelOrder order : ChannelOrder.values()) 
    988       outputStackOrderTest(FormatTools.UINT8, order.toString(),  82, 47, 2, 3, 4); 
     1016      outputStackOrderTest(FormatTools.UINT8, order,  82, 47, 2, 3, 4); 
    9891017  } 
    9901018     
     
    10091037      } 
    10101038     
    1011     impsTest(imps,1); 
     1039    impsCountTest(imps,1); 
    10121040    assertEquals(105,imps[0].getStack().getSize()); 
    10131041  } 
     
    10411069    // test results 
    10421070     
    1043     impsTest(imps,1); 
     1071    impsCountTest(imps,1); 
    10441072    assertEquals(16,imps[0].getStack().getSize());  // one loaded as one set with 16 slices 
    10451073     
     
    10611089    // test results 
    10621090     
    1063     impsTest(imps,1); 
     1091    impsCountTest(imps,1); 
    10641092    assertEquals(32,imps[0].getStack().getSize());  // both loaded as one set of 32 slices 
    10651093  } 
     
    10921120  { 
    10931121    // open a dataset that has multiple series and should get back a single series 
    1094     datasetConcatenateTest(FormatTools.UINT8, "XYZCT", 82, 47, 1, 1, 1, 1); 
    1095     datasetConcatenateTest(FormatTools.UINT8, "XYZCT", 82, 47, 1, 1, 1, 17); 
    1096     datasetConcatenateTest(FormatTools.UINT8, "XYZCT", 82, 47, 4, 5, 2, 9); 
     1122    datasetConcatenateTest(FormatTools.UINT8, 82, 47, 1, 1, 1, 1); 
     1123    datasetConcatenateTest(FormatTools.UINT8, 82, 47, 1, 1, 1, 17); 
     1124    datasetConcatenateTest(FormatTools.UINT8, 82, 47, 4, 5, 2, 9); 
    10971125  } 
    10981126 
     
    11201148    } 
    11211149 
    1122     impsTest(imps,1); 
     1150    impsCountTest(imps,1); 
    11231151     
    11241152    imp = imps[0]; 
     
    11381166    // BF only supporting C from 2 to 7 and due to IJ's slider limitation (C*numSeries*3) <= 25 
    11391167 
    1140     int[] pixTypes = new int[] {FormatTools.INT8, FormatTools.INT16, FormatTools.INT32}; 
    1141     int[] xs = new int[] {56,107}; 
    1142     int[] ys = new int[] {41,86}; 
     1168    colorCompositeTest(true,FormatTools.UINT8,55,44,2,3,4,1); 
     1169 
     1170    int[] pixTypes = new int[] {FormatTools.UINT8}; 
     1171    int[] xs = new int[] {56}; 
     1172    int[] ys = new int[] {41}; 
    11431173    int[] zs = new int[] {1,2}; 
    11441174    int[] cs = new int[] {2,3,4,5,6,7};  // all that BF/IJ supports right now 
     
    11461176    int[] series = new int[] {1,2,3,4}; 
    11471177     
    1148     for (int pixFormat : pixTypes) 
    1149       for (int x : xs) 
    1150         for (int y : ys) 
    1151           for (int z : zs) 
    1152             for (int c : cs) 
    1153               for (int t : ts) 
    1154                 for (int s : series) 
     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) { 
    11551185                  if ((c*s*3) <= 25)  // IJ slider limitation 
    11561186                  { 
    1157                     //System.out.println("format "+pixFormat+" x "+x+" y "+y+" z "+z+" c "+c+" t "+t+" s "+s); 
    1158                     colorCompositeTest(pixFormat,x,y,z,c,t,s); 
     1187                    for (boolean indexed : BooleanStates) { 
     1188                      //System.out.println("indexed "+indexed+" format "+pixFormat+" x "+x+" y "+y+" z "+z+" c "+c+" t "+t+" s "+s); 
     1189                      colorCompositeTest(indexed,pixFormat,x,y,z,c,t,s); 
     1190                    } 
    11591191                  } 
     1192                } 
     1193              } 
     1194            } 
     1195          } 
     1196        } 
     1197      } 
     1198    } 
    11601199  } 
    11611200   
     
    11841223    } 
    11851224 
    1186     impsTest(imps,1); 
     1225    impsCountTest(imps,1); 
    11871226     
    11881227    imp = imps[0]; 
     
    11981237    assertEquals(CompositeImage.COLOR, ci.getMode()); 
    11991238     
    1200     genericLutTest(ci,sizeC); 
     1239    colorTests(ci,sizeC,DefaultColorOrder); 
    12011240 
    12021241    fail("unfinished"); 
     
    12271266    } 
    12281267 
    1229     impsTest(imps,1); 
     1268    impsCountTest(imps,1); 
    12301269     
    12311270    imp = imps[0]; 
     
    12411280    assertEquals(CompositeImage.GRAYSCALE, ci.getMode()); 
    12421281 
    1243     genericLutTest(ci,sizeC); 
     1282    colorTests(ci,sizeC,DefaultColorOrder); 
    12441283 
    12451284    fail("unfinished"); 
     
    12521291     
    12531292    int[] pixTypes = new int[]{FormatTools.UINT8, FormatTools.UINT16, FormatTools.FLOAT}; 
    1254     int[] xs = new int[] {41,123}; 
    1255     int[] ys = new int[] {10,105}; 
     1293    int[] xs = new int[] {45}; 
     1294    int[] ys = new int[] {14}; 
    12561295    int[] zs = new int[] {1,2}; 
    12571296    int[] cs = new int[] {2,3,4,5,6,7};  // all that BF/IJ supports right now 
     
    12721311                  } 
    12731312  } 
    1274    
    1275   /* 
    1276   @Test 
    1277   public void testColorMerge() 
    1278   { 
    1279      
    1280     String path = FAKE_FILES[0]; 
    1281      
    1282     ImagePlus[] imps = null; 
    1283     ImagePlus imp = null; 
    1284      
    1285     // test when color merge false 
    1286  
    1287     // open file 
    1288     try { 
    1289       ImporterOptions options = new ImporterOptions(); 
    1290       options.setMergeChannels(false); 
    1291       options.setId(path); 
    1292       imps = BF.openImagePlus(options); 
    1293     } 
    1294     catch (IOException e) { 
    1295       fail(e.getMessage()); 
    1296     } 
    1297     catch (FormatException e) { 
    1298       fail(e.getMessage()); 
    1299     } 
    1300      
    1301     // test results 
    1302     impsTest(imps,1); 
    1303     imp = imps[0]; 
    1304     assertEquals(3,getEffectiveSizeC(imp));  // unmerged 
    1305     assertEquals(7,getSizeZ(imp)); 
    1306     assertEquals(5,getSizeT(imp)); 
    1307      
    1308     // test when color merge true 
    1309      
    1310     // open file 
    1311     try { 
    1312       ImporterOptions options = new ImporterOptions(); 
    1313       options.setMergeChannels(true); 
    1314       options.setId(path); 
    1315       imps = BF.openImagePlus(options); 
    1316     } 
    1317     catch (IOException e) { 
    1318       fail(e.getMessage()); 
    1319     } 
    1320     catch (FormatException e) { 
    1321       fail(e.getMessage()); 
    1322     } 
    1323      
    1324     // test results 
    1325     impsTest(imps,1); 
    1326     imp = imps[0]; 
    1327     assertTrue(imp.getHeight() > 10);  // required for this test to work 
    1328     assertEquals(1, getEffectiveSizeC(imp));  // merged 
    1329     assertEquals(7, getSizeZ(imp)); 
    1330     assertEquals(5, getSizeT(imp)); 
    1331     for (int i = 0; i < 10; i++) 
    1332       assertEquals(mergedPixel(i),imp.getProcessor().get(i,10)); 
    1333      
    1334     // TODO - also test mergeOptions when chans > 3. it will be an int == chans per plane. extra blank images are 
    1335     //   added as needed to make multiple images each with same number of channels 
    1336     //   i.e. 6 channels can -> 123/456 or 12/34/56 or 1/2/3/4/5/6 (last one not merged ???) 
    1337     //        5 channels can -> 123/45b or 12/34/5b or 1/2/3/4/5 (last one not merged ???) 
    1338      
    1339     fail("unfinished implementation"); 
    1340   } 
    1341    
    1342   @Test 
    1343   public void testColorRgbColorize() 
    1344   { 
    1345     // From BF: RGB colorize channels - Each channel is assigned an appropriate pseudocolor table rather than the normal 
    1346     // grayscale.  The first channel is colorized red, the second channel is green, and the third channel is blue. This 
    1347     // option is not available when Merge channels to RGB or Custom colorize channels are set. 
    1348      
    1349     String path = FAKE_FILES[0]; 
    1350      
    1351     ImagePlus[] imps = null; 
    1352     ImagePlus imp = null; 
    1353  
    1354     // TODO - should not allow mergeChannels with rgb colorize 
    1355     try { 
    1356       ImporterOptions options = new ImporterOptions(); 
    1357       options.setColorize(true); 
    1358       options.setMergeChannels(true); 
    1359       options.setId(path); 
    1360       imps = BF.openImagePlus(options); 
    1361       // TODO - eventually fail() here but need BF support first I think 
    1362     } 
    1363     catch (IOException e) { 
    1364       fail(e.getMessage()); 
    1365     } 
    1366     catch (FormatException e) { 
    1367       fail(e.getMessage()); 
    1368     } 
    1369      
    1370     // TODO - should not allow mergeChannels with custom colorize 
    1371     try { 
    1372       ImporterOptions options = new ImporterOptions(); 
    1373       options.setColorize(true); 
    1374       options.setCustomColorize(true); 
    1375       options.setId(path); 
    1376       imps = BF.openImagePlus(options); 
    1377       // TODO - eventually fail() here but need BF support first I think 
    1378     } 
    1379     catch (IOException e) { 
    1380       fail(e.getMessage()); 
    1381     } 
    1382     catch (FormatException e) { 
    1383       fail(e.getMessage()); 
    1384     } 
    1385  
    1386     // TODO - legitimate testing 
    1387     // open file 
    1388     try { 
    1389       ImporterOptions options = new ImporterOptions(); 
    1390       options.setColorize(true); 
    1391       options.setId(path); 
    1392       imps = BF.openImagePlus(options); 
    1393     } 
    1394     catch (IOException e) { 
    1395       fail(e.getMessage()); 
    1396     } 
    1397     catch (FormatException e) { 
    1398       fail(e.getMessage()); 
    1399     } 
    1400      
    1401     impsTest(imps,1); 
    1402     imp = imps[0]; 
    1403     assertEquals(7,getSizeZ(imp)); 
    1404     assertEquals(1,getEffectiveSizeC(imp));  // TODO : correct? 
    1405     assertEquals(1,getSizeT(imp));  // TODO : huh? 
    1406      
    1407     // TODO - actual tests of data 
    1408      
    1409     fail("unfinished implementation"); 
    1410   } 
    1411  
    1412   @Test 
    1413   public void testColorCustomColorize() 
    1414   { 
    1415     // From BF: Custom colorize channels - Each channel is assigned a pseudocolor table rather than the normal grayscale. 
    1416     //   The color for each channel is chosen by the user. This option is not available when Merge channels to RGB or RGB 
    1417     //   colorize channels are set. 
    1418      
    1419     // TODO 
    1420     fail("to be implemented"); 
    1421   } 
    1422   */ 
    14231313   
    14241314  @Test 
     
    17011591 
    17021592    // one channel per image 
    1703     impsTest(imps,sizeC); 
     1593    impsCountTest(imps,sizeC); 
    17041594     
    17051595    // unwind ZCT loop : C pulled outside, ZT in order 
     
    17451635     
    17461636    // one focal plane per image 
    1747     impsTest(imps,sizeZ); 
     1637    impsCountTest(imps,sizeZ); 
    17481638 
    17491639    // unwind ZCT loop : Z pulled outside, CT in order 
     
    17891679     
    17901680    // one time point per image 
    1791     impsTest(imps,sizeT); 
     1681    impsCountTest(imps,sizeT); 
    17921682     
    17931683    // unwind ZTC loop : T pulled outside, ZC in order 
Note: See TracChangeset for help on using the changeset viewer.