Changeset 6248


Ignore:
Timestamp:
05/07/10 14:33:57 (10 years ago)
Author:
bdezonia
Message:

partial implementation

File:
1 edited

Legend:

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

    r6247 r6248  
    11package loci.plugins.in; 
    22 
    3 import static org.junit.Assert.assertNotNull; 
    4 import static org.junit.Assert.assertTrue; 
    5 import static org.junit.Assert.fail; 
     3import static org.junit.Assert.*; 
    64import ij.ImagePlus; 
     5import ij.ImageStack; 
     6import ij.process.ImageProcessor; 
    77 
    88import java.io.IOException; 
     
    1515import org.junit.Test; 
    1616 
     17// TODO 
     18//  - flesh out existing tests 
     19//  - add some tests for combination of options 
     20 
    1721public class ImporterTest { 
    1822 
    19   // -- ImporterTest methods -- 
    20  
    21   @Test 
    22   public void testBasic() { 
    23     final int sizeX = 477, sizeY = 393; 
    24     final int pixelType = FormatTools.UINT8; 
    25     final String path = constructFakeFilename("basic", sizeX, sizeY, pixelType); 
     23  private static final boolean debug = true; 
     24 
     25  // TODO - in place to switch off tests that interface with gui 
     26  private static final boolean runAllTests = true; 
     27   
     28  private enum Axis {Z,C,T}; 
     29   
     30  // ** Helper methods ******************************************************************* 
     31 
     32  private String constructFakeFilename(String title, 
     33      int pixelType, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT, int numSeries) 
     34  { 
     35    String fileName = ""; 
     36     
     37    fileName += title; 
     38     
     39    fileName += "&pixelType=" + FormatTools.getPixelTypeString(pixelType); 
     40     
     41    fileName += "&sizeX=" + sizeX; 
     42     
     43    fileName += "&sizeY=" + sizeY; 
     44     
     45    fileName += "&sizeZ=" + sizeZ; 
     46 
     47    fileName += "&sizeC=" + sizeC; 
     48  
     49    fileName += "&sizeT=" + sizeT; 
     50 
     51    if (numSeries > 0) 
     52      fileName += "&series=" + numSeries; 
     53     
     54    fileName += ".fake"; 
     55     
     56    return fileName; 
     57  } 
     58 
     59  private int sIndex(ImageProcessor proc) { return proc.get(0,0);  }  // series 
     60  private int iIndex(ImageProcessor proc) { return proc.get(10,0); }  // num in series 
     61  private int zIndex(ImageProcessor proc) { return proc.get(20,0); }  // z 
     62  private int cIndex(ImageProcessor proc) { return proc.get(30,0); }  // c 
     63  private int tIndex(ImageProcessor proc) { return proc.get(40,0); }  // t 
     64   
     65  private void printVals(ImageProcessor proc) 
     66  { 
     67    System.out.println( 
     68        " S=" + sIndex(proc) + 
     69        " I=" + iIndex(proc) + 
     70        " Z=" + zIndex(proc) + 
     71        " C=" + cIndex(proc) + 
     72        " T=" + tIndex(proc)); 
     73  } 
     74 
     75  private Axis axis(String order, int d) 
     76  { 
     77    if ((d < 0) || (d > 2)) 
     78      throw new IllegalArgumentException("axis() - index out of bounds [0..2]: "+d); 
     79     
     80    char dim = order.charAt(2+d); 
     81     
     82    if (dim == 'Z') return Axis.Z; 
     83    if (dim == 'C') return Axis.C; 
     84    if (dim == 'T') return Axis.T; 
     85 
     86    throw new IllegalArgumentException("axis() - invalid image order specified: "+order); 
     87  } 
     88 
     89  private int value(Axis axis, int z, int c, int t) 
     90  { 
     91    if (axis == Axis.Z) return z; 
     92    if (axis == Axis.C) return c; 
     93    if (axis == Axis.T) return t; 
     94 
     95    throw new IllegalArgumentException("value() - unknown axis: "+axis); 
     96  } 
     97   
     98  private int index(Axis axis, ImageProcessor proc) 
     99  { 
     100    if (axis == Axis.Z) return zIndex(proc); 
     101    if (axis == Axis.C) return cIndex(proc); 
     102    if (axis == Axis.T) return tIndex(proc); 
     103     
     104    throw new IllegalArgumentException("index() - unknown axis: "+axis); 
     105  } 
     106 
     107  private void defaultBehaviorTest(int pixType, int x, int y, int z, int c, int t) 
     108  { 
     109    String path = constructFakeFilename("default", pixType, x, y, z, c, t, -1); 
    26110    ImagePlus[] imps = null; 
    27111     
     
    36120    } 
    37121     
     122    assertNotNull(imps); 
     123    assertEquals(1,imps.length); 
     124    ImagePlus ip = imps[0]; 
     125    assertNotNull(ip); 
     126    assertEquals(x,ip.getWidth()); 
     127    assertEquals(y,ip.getHeight()); 
     128    assertEquals(z,ip.getNSlices()); 
     129    assertEquals(c,ip.getNChannels()); 
     130    assertEquals(t,ip.getNFrames()); 
     131  } 
     132   
     133  private void outputStackOrderTest(int pixType, String order, int x, int y, int z, int c, int t) 
     134  { 
     135    String path = constructFakeFilename(order, pixType, x, y, z, c, t, -1); 
     136     
     137    ImagePlus[] imps = null; 
     138    try { 
     139      ImporterOptions options = new ImporterOptions(); 
     140      options.setId(path); 
     141      options.setStackOrder(order); 
     142      imps = BF.openImagePlus(options); 
     143    } 
     144    catch (IOException e) { 
     145      fail(e.getMessage()); 
     146    } 
     147    catch (FormatException e) { 
     148      fail(e.getMessage()); 
     149    } 
     150 
     151    assertNotNull(imps); 
     152    assertEquals(1,imps.length); 
     153     
     154    ImagePlus ip = imps[0]; 
     155     
     156    // these tests rely on each image being large enough to get the siztc index pixels of a 
     157    // FakeFile. This requires the x value of tested images to be somewhat large. Assert 
     158    // the input image fits the bill 
     159     
     160    assertTrue(ip.getWidth() >= 41); 
     161    assertTrue(ip.getHeight() >= 1); 
     162     
     163    ImageStack st = ip.getStack(); 
     164    int numSlices = st.getSize(); 
     165 
     166    assertEquals(z*c*t,numSlices); 
     167 
     168    int count = 0; 
     169    //if (debug) 
     170    //  System.out.println(order); 
     171    Axis fastest = axis(order,0); 
     172    Axis middle = axis(order,1); 
     173    Axis slowest = axis(order,2); 
     174    int maxI = value(fastest,z,c,t); 
     175    int maxJ = value(middle,z,c,t); 
     176    int maxK = value(slowest,z,c,t); 
     177    for (int k = 0; k < maxK; k++) 
     178      for (int j = 0; j < maxJ; j++) 
     179        for (int i = 0; i < maxI; i++) 
     180        { 
     181          ImageProcessor proc = st.getProcessor(count+1); 
     182          //if (debug) 
     183          //  printVals(proc); 
     184          assertNotNull(proc); 
     185          assertEquals(x,proc.getWidth()); 
     186          assertEquals(y,proc.getHeight()); 
     187          assertEquals(0,sIndex(proc)); 
     188          //test iIndex too? : assertEquals(count,somethingOrOther(iIndex(proc))); 
     189          //System.out.println("iIndex " + iIndex(proc) + " calc " + 
     190          //    ((maxJ*maxI*k) + (maxI*j) + i) 
     191          //    ); 
     192          assertEquals(i,index(fastest,proc)); 
     193          assertEquals(j,index(middle,proc)); 
     194          assertEquals(k,index(slowest,proc)); 
     195          count++; 
     196        } 
     197  } 
     198   
     199  private void datasetSwapDimsTest(int pixType, String order, int x, int y, int z, int c, int t) 
     200  { 
     201    String path = constructFakeFilename(order, pixType, x, y, z, c, t, -1); 
     202    ImagePlus[] imps = null; 
     203    try { 
     204      ImporterOptions options = new ImporterOptions(); 
     205      options.setId(path); 
     206      options.setSwapDimensions(true); 
     207      imps = BF.openImagePlus(options); 
     208    } 
     209    catch (IOException e) { 
     210      fail(e.getMessage()); 
     211    } 
     212    catch (FormatException e) { 
     213      fail(e.getMessage()); 
     214    } 
     215 
     216    assertNotNull(imps); 
     217    assertEquals(1,imps.length); 
     218 
     219    ImageStack st = imps[0].getStack(); 
     220    int numSlices = st.getSize(); 
     221    assertEquals(z*c*t,numSlices); 
     222 
     223    System.out.println("Numslices == " + numSlices); 
     224    for (int i = 0; i < numSlices; i++) 
     225      printVals(st.getProcessor(i+1)); 
     226 
     227    // TODO - do some tests on order of dims of created images 
     228  } 
     229 
     230  private void datasetConcatenateTest(int pixType, String order, 
     231      int x, int y, int z, int c, int t, int s) 
     232  { 
     233    assertTrue(s >= 1); 
     234     
     235    String path = constructFakeFilename(order, pixType, x, y, z, c, t, s); 
     236    ImagePlus[] imps = null; 
     237    try { 
     238      ImporterOptions options = new ImporterOptions(); 
     239      options.setId(path); 
     240      options.setConcatenate(true); 
     241      imps = BF.openImagePlus(options); 
     242    } 
     243    catch (IOException e) { 
     244      fail(e.getMessage()); 
     245    } 
     246    catch (FormatException e) { 
     247      fail(e.getMessage()); 
     248    } 
     249 
     250    assertNotNull(imps); 
     251    assertEquals(1,imps.length); 
     252 
     253    ImageStack st = imps[0].getStack(); 
     254  
     255    int numSlices = st.getSize(); 
     256     
     257    // make sure the number of slices in stack is a sum of all series 
     258    assertEquals(z*c*t*s,numSlices); 
     259     
     260    // System.out.println("Numslices == " + numSlices); 
     261    for (int i = 0; i < numSlices; i++) 
     262    { 
     263      ImageProcessor proc = st.getProcessor(i+1);  
     264      // printVals(proc); 
     265      assertEquals(0,sIndex(proc));  // make sure we have one series only 
     266    } 
     267  } 
     268   
     269  private void memoryVirtualStackTest(boolean desireVirtual) 
     270  { 
     271      int x = 604, y = 531; 
     272      String path = constructFakeFilename("vstack", FormatTools.UINT16, x, y, 7, 1, 1, -1); 
     273      ImagePlus[] imps = null; 
     274      try { 
     275        ImporterOptions options = new ImporterOptions(); 
     276        options.setId(path); 
     277        options.setVirtual(desireVirtual); 
     278        imps = BF.openImagePlus(options); 
     279      } 
     280      catch (IOException e) { 
     281        fail(e.getMessage()); 
     282      } 
     283      catch (FormatException e) { 
     284        fail(e.getMessage()); 
     285      } 
     286   
     287      assertNotNull(imps); 
     288      assertTrue(imps.length == 1); 
     289      ImagePlus ip = imps[0]; 
     290      assertNotNull(ip); 
     291      assertTrue(ip.getWidth() == x); 
     292      assertTrue(ip.getHeight() == y); 
     293   
     294      assertEquals(desireVirtual,ip.getStack().isVirtual()); 
     295  } 
     296   
     297  private void memorySpecifyZRangeTest() 
     298  {  
     299    int pixType = FormatTools.UINT8, x=30, y=30, z=5, c=2, t=4, s=-1; 
     300    String path = constructFakeFilename("range", pixType, x, y, z, c, t, s); 
     301    ImagePlus[] imps = null; 
     302    try { 
     303      ImporterOptions options = new ImporterOptions(); 
     304      options.setId(path); 
     305      options.setZBegin(0, 0); 
     306      options.setZEnd(0, 4); 
     307      options.setZStep(0, 2); 
     308      imps = BF.openImagePlus(options); 
     309    } 
     310    catch (IOException e) { 
     311      fail(e.getMessage()); 
     312    } 
     313    catch (FormatException e) { 
     314      fail(e.getMessage()); 
     315    } 
     316     
     317    // should have the data: one series, all t's, all c's, z's from 1 to 3 by 2 
     318    assertNotNull(imps); 
     319    assertTrue(imps.length == 1); 
     320    ImagePlus ip = imps[0]; 
     321    assertNotNull(ip); 
     322    assertTrue(ip.getWidth() == x); 
     323    assertTrue(ip.getHeight() == y); 
     324    ImageStack st = ip.getStack(); 
     325    int numSlices = st.getSize(); 
     326    assertEquals(16,numSlices); 
     327    System.out.println("SpecifyZRangeTest: slices below"); 
     328    for (int i = 0; i < numSlices; i++) 
     329      printVals(st.getProcessor(i)); 
     330     
     331    //TODO - some assertions 
     332     
     333  } 
     334   
     335  private void memorySpecifyCRangeTest() 
     336  {  
     337    int pixType = FormatTools.UINT8, x=30, y=30, z=4, c=11, t=4, s=-1; 
     338    String path = constructFakeFilename("range", pixType, x, y, z, c, t, s); 
     339    ImagePlus[] imps = null; 
     340    try { 
     341      ImporterOptions options = new ImporterOptions(); 
     342      options.setId(path); 
     343      options.setCBegin(0, 3); 
     344      options.setCEnd(0, 9); 
     345      options.setCStep(0, 3); 
     346      imps = BF.openImagePlus(options); 
     347    } 
     348    catch (IOException e) { 
     349      fail(e.getMessage()); 
     350    } 
     351    catch (FormatException e) { 
     352      fail(e.getMessage()); 
     353    } 
     354     
     355    // should have the data: one series, all t's, all c's, z's from 1 to 3 by 2 
     356    assertNotNull(imps); 
     357    assertTrue(imps.length == 1); 
     358    ImagePlus ip = imps[0]; 
     359    assertNotNull(ip); 
     360    assertTrue(ip.getWidth() == x); 
     361    assertTrue(ip.getHeight() == y); 
     362    ImageStack st = ip.getStack(); 
     363    int numSlices = st.getSize(); 
     364    assertEquals(48,numSlices); 
     365    System.out.println("SpecifyCRangeTest: slices below"); 
     366    for (int i = 0; i < numSlices; i++) 
     367      printVals(st.getProcessor(i)); 
     368     
     369    //TODO - some assertions 
     370     
     371  } 
     372   
     373  private void memorySpecifyTRangeTest() 
     374  {  
     375    int pixType = FormatTools.UINT8, x=30, y=30, z=3, c=2, t=12, s=-1; 
     376    String path = constructFakeFilename("range", pixType, x, y, z, c, t, s); 
     377    ImagePlus[] imps = null; 
     378    try { 
     379      ImporterOptions options = new ImporterOptions(); 
     380      options.setId(path); 
     381      options.setTBegin(0, 0); 
     382      options.setTEnd(0, 3); 
     383      options.setTStep(0, 4); 
     384      imps = BF.openImagePlus(options); 
     385    } 
     386    catch (IOException e) { 
     387      fail(e.getMessage()); 
     388    } 
     389    catch (FormatException e) { 
     390      fail(e.getMessage()); 
     391    } 
     392     
     393    // should have the data: one series, all t's, all c's, z's from 1 to 3 by 2 
     394    assertNotNull(imps); 
     395    assertTrue(imps.length == 1); 
     396    ImagePlus ip = imps[0]; 
     397    assertNotNull(ip); 
     398    assertTrue(ip.getWidth() == x); 
     399    assertTrue(ip.getHeight() == y); 
     400    ImageStack st = ip.getStack(); 
     401    int numSlices = st.getSize(); 
     402    assertEquals(18,numSlices); 
     403    System.out.println("SpecifyTRangeTest: slices below"); 
     404    for (int i = 0; i < numSlices; i++) 
     405      printVals(st.getProcessor(i)); 
     406     
     407    //TODO - some assertions 
     408     
     409  } 
     410   
     411  private void memoryCropTest(int pixType, int x, int y, int cx, int cy) 
     412  { 
     413    String path = constructFakeFilename("crop", pixType, x, y, 1, 1, 1, 1); 
     414    ImagePlus[] imps = null; 
     415    try { 
     416      ImporterOptions options = new ImporterOptions(); 
     417      options.setId(path); 
     418      options.setCrop(true); 
     419      options.setCropRegion(0, new Region(0, 0, cx, cy)); 
     420      imps = BF.openImagePlus(options); 
     421    } 
     422    catch (IOException e) { 
     423      fail(e.getMessage()); 
     424    } 
     425    catch (FormatException e) { 
     426      fail(e.getMessage()); 
     427    } 
     428 
    38429    assertNotNull(imps); 
    39430    assertTrue(imps.length == 1); 
    40431    assertNotNull(imps[0]); 
    41     assertTrue(imps[0].getWidth() == sizeX); 
    42     assertTrue(imps[0].getHeight() == sizeY); 
    43  
    44     System.out.println("Basic worked!");//TEMP 
    45   } 
    46  
    47   @Test 
    48   public void testCrop() { 
    49     final int sizeX = 253, sizeY = 511; 
    50     final int cropSizeX = 112, cropSizeY = 457; 
     432    assertTrue(imps[0].getWidth() == cx); 
     433    assertTrue(imps[0].getHeight() == cy); 
     434  } 
     435 
     436// ** ImporterTest methods ************************************************************** 
     437 
     438  @Test 
     439  public void testDefaultBehavior() { 
     440 
     441    if (runAllTests) 
     442    { 
     443      defaultBehaviorTest(FormatTools.UINT16, 400, 300, 1, 1, 1); 
     444      defaultBehaviorTest(FormatTools.INT16, 107, 414, 1, 1, 1); 
     445      defaultBehaviorTest(FormatTools.UINT32, 323, 206, 3, 2, 1); 
     446      defaultBehaviorTest(FormatTools.UINT8, 57, 78, 5, 4, 3); 
     447      defaultBehaviorTest(FormatTools.INT32, 158, 99, 2, 3, 4); 
     448      defaultBehaviorTest(FormatTools.INT8, 232, 153, 3, 7, 5); 
     449    } 
     450  } 
     451 
     452  @Test 
     453  public void testOutputStackOrder() 
     454  { 
     455    if (runAllTests) 
     456    { 
     457      outputStackOrderTest(FormatTools.UINT8, "XYZCT", 82, 47, 2, 3, 4); 
     458      outputStackOrderTest(FormatTools.UINT8, "XYZTC", 82, 47, 2, 3, 4); 
     459      outputStackOrderTest(FormatTools.UINT8, "XYCZT", 82, 47, 2, 3, 4); 
     460      outputStackOrderTest(FormatTools.UINT8, "XYCTZ", 82, 47, 2, 3, 4); 
     461      outputStackOrderTest(FormatTools.UINT8, "XYTCZ", 82, 47, 2, 3, 4); 
     462      outputStackOrderTest(FormatTools.UINT8, "XYTZC", 82, 47, 2, 3, 4); 
     463    } 
     464  } 
     465     
     466  @Test 
     467  public void testDatasetGroupFiles() { 
     468    // TODO - need to enhance FakeFiles first I think 
     469    //   This option kicks in when you have similarly named files. all the files get loaded 
     470    //   as one dataset. This relies on the filename differing only by an index. Not sure 
     471    //   what an index in a fake filename would do. Tried adding -1 before .fake to see what 
     472    //   would happen and BF crashes with negArraySizeExcep   
     473  } 
     474 
     475  @Test 
     476  public void testDatasetSwapDims() { 
     477    // TODO - can't really test this with fake files. It needs a series of files from grouping 
     478    //   to reorder. 
     479    if (runAllTests) 
     480    { 
     481      datasetSwapDimsTest(FormatTools.UINT8, "XYZCT", 82, 47, 2, 3, 4); 
     482    } 
     483  } 
     484   
     485  @Test 
     486  public void testDatasetConcatenate() { 
     487     
     488    // TODO - Curtis says impl broken right now - will test later 
     489    if (runAllTests) 
     490    { 
     491      // open a dataset that has multiple series 
     492      //   and should get back a single series 
     493      datasetConcatenateTest(FormatTools.UINT8, "XYZCT", 82, 47, 1, 1, 1, 1); 
     494      datasetConcatenateTest(FormatTools.UINT8, "XYZCT", 82, 47, 1, 1, 1, 17); 
     495      datasetConcatenateTest(FormatTools.UINT8, "XYZCT", 82, 47, 4, 5, 2, 9); 
     496    } 
     497  } 
     498   
     499  @Test 
     500  public void testColorMerge() { 
     501    // TODO - Curtis says impl broken right now - will test later 
     502  } 
     503   
     504  @Test 
     505  public void testColorRgbColorize() { 
     506    // TODO - Curtis says impl broken right now - will test later 
     507  } 
     508   
     509  @Test 
     510  public void testColorCustomColorize() { 
     511    // TODO - Curtis says impl broken right now - will test later 
     512  } 
     513   
     514  @Test 
     515  public void testColorAutoscale() { 
     516    // TODO - Curtis says impl broken right now - will test later 
     517  } 
     518   
     519  @Test 
     520  public void testMemoryVirtualStack() { 
     521    if (runAllTests) 
     522    { 
     523      memoryVirtualStackTest(false); 
     524      memoryVirtualStackTest(true); 
     525    } 
     526  } 
     527   
     528  @Test 
     529  public void testMemoryRecordModifications() { 
     530    // TODO - how to test this? 
     531  } 
     532   
     533  @Test 
     534  public void testMemorySpecifyRange() { 
     535    memorySpecifyZRangeTest(); 
     536    memorySpecifyCRangeTest(); 
     537    memorySpecifyTRangeTest(); 
     538    //memorySpecifySRangeTest(); 
     539  } 
     540   
     541  @Test 
     542  public void testMemoryCrop() { 
     543     
     544    // TODO - Curtis says impl broken right now - will test later 
     545     
     546    if (runAllTests) 
     547    { 
     548      memoryCropTest(FormatTools.UINT8, 203, 409, 185, 104); 
     549      // TODO - crop window too big or too small 
     550    } 
     551  } 
     552   
     553  @Test 
     554  public void testSplitChannels() { 
     555    // TODO - Curtis says impl broken right now - will test later 
     556  } 
     557   
     558  @Test 
     559  public void testSplitFocalPlanes() { 
     560    // TODO - Curtis says impl broken right now - will test later 
     561  } 
     562   
     563  @Test 
     564  public void testSplitTimepoints() { 
     565    // TODO - Curtis says impl broken right now - will test later 
     566  } 
     567 
     568  // ** Main method ***************************************************************** 
     569 
     570  public static void main(String[] args) { 
     571    ImporterTest tester = new ImporterTest(); 
     572  
     573    //TODO - we could use reflection to discover all test methods, loop, and run them 
     574     
     575    tester.testDefaultBehavior(); 
     576    tester.testOutputStackOrder(); 
     577    tester.testDatasetGroupFiles(); 
     578    tester.testDatasetSwapDims(); 
     579    tester.testDatasetConcatenate(); 
     580    tester.testColorMerge(); 
     581    tester.testColorRgbColorize(); 
     582    tester.testColorCustomColorize(); 
     583    tester.testColorAutoscale(); 
     584    tester.testMemoryVirtualStack(); 
     585    tester.testMemoryRecordModifications(); 
     586    tester.testMemorySpecifyRange(); 
     587    tester.testMemoryCrop(); 
     588    tester.testSplitChannels(); 
     589    tester.testSplitFocalPlanes(); 
     590    tester.testSplitTimepoints(); 
     591     
     592    // TODO - add combination tests 
     593     
     594    System.exit(0); 
     595  } 
     596} 
     597 
     598  // **************************************************************************************** 
     599  // * old code vault : working copies to be deleted once refactored code proven 
     600  // **************************************************************************************** 
     601   
     602  /* 
     603  @Test 
     604  public void testOutputStackOrderXYZCT() { 
     605    final int x = 82, y = 47, z = 2, c = 3, t = 4; 
    51606    final int pixelType = FormatTools.UINT8; 
    52     final String path = constructFakeFilename("crop", sizeX, sizeY, pixelType); 
    53     ImagePlus[] imps = null; 
    54     try { 
    55             final ImporterOptions options = new ImporterOptions(); 
    56       options.setId(path); 
    57       options.setCrop(true); 
    58       options.setCropRegion(0, new Region(0, 0, cropSizeX, cropSizeY)); 
    59       imps = BF.openImagePlus(options); 
    60     } 
    61     catch (IOException e) { 
    62       fail(e.getMessage()); 
    63     } 
    64     catch (FormatException e) { 
    65       fail(e.getMessage()); 
    66     } 
    67  
    68     assertNotNull(imps); 
    69     assertTrue(imps.length == 1); 
    70     assertNotNull(imps[0]); 
    71     assertTrue(imps[0].getWidth() == cropSizeX); 
    72     assertTrue(imps[0].getHeight() == cropSizeY); 
    73  
    74     System.out.println("Crop worked!");//TEMP 
    75   } 
    76    
    77   // -- Helper methods -- 
    78  
    79   private String constructFakeFilename(String title, 
    80     int sizeX, int sizeY, int pixelType) 
    81   { 
    82     return title + 
    83       "&pixelType=" + FormatTools.getPixelTypeString(pixelType) + 
    84       "&sizeX=" + sizeX + "&sizeY=" + sizeY + ".fake"; 
    85   } 
    86  
    87   // -- Main method -- 
    88  
    89   public static void main(String[] args) { 
    90     ImporterTest test = new ImporterTest(); 
    91     test.testBasic(); 
    92     test.testCrop(); 
    93     System.exit(0); 
    94   } 
    95  
    96 } 
     607    final String path = constructFakeFilename("xyzct", pixelType, x, y, z, c, t, -1); 
     608    ImagePlus[] imps = null; 
     609    try { 
     610      final ImporterOptions options = new ImporterOptions(); 
     611      options.setId(path); 
     612      options.setStackOrder("XYZCT"); 
     613      imps = BF.openImagePlus(options); 
     614    } 
     615    catch (IOException e) { 
     616      fail(e.getMessage()); 
     617    } 
     618    catch (FormatException e) { 
     619      fail(e.getMessage()); 
     620    } 
     621 
     622    assertNotNull(imps); 
     623    assertEquals(1,imps.length); 
     624     
     625    ImageStack st = imps[0].getStack(); 
     626    int numSlices = st.getSize(); 
     627    assertEquals(z*c*t,numSlices); 
     628    int count = 0; 
     629    // order differs here from other cases 
     630    System.out.println("XYZCT"); 
     631    for (int k = 0; k < t; k++) 
     632      for (int j = 0; j < c; j++) 
     633        for (int i = 0; i < z; i++) 
     634        { 
     635          ImageProcessor proc = st.getProcessor(count+1); 
     636          printVals(proc); 
     637          assertNotNull(proc); 
     638          assertEquals(x,proc.getWidth()); 
     639          assertEquals(y,proc.getHeight()); 
     640          assertEquals(count,iIndex(proc)); 
     641          assertEquals(i,zIndex(proc)); 
     642          assertEquals(j,cIndex(proc)); 
     643          assertEquals(k,tIndex(proc)); 
     644          count++; 
     645        } 
     646  } 
     647   
     648  @Test 
     649  public void testOutputStackOrderXYZTC() { 
     650    final int x = 82, y = 47, z = 2, c = 3, t = 4; 
     651    final int pixelType = FormatTools.UINT8; 
     652    final String path = constructFakeFilename("xyztc", pixelType, x, y, z, c, t, -1); 
     653    ImagePlus[] imps = null; 
     654    try { 
     655      final ImporterOptions options = new ImporterOptions(); 
     656      options.setId(path); 
     657      options.setStackOrder("XYZTC"); 
     658      imps = BF.openImagePlus(options); 
     659    } 
     660    catch (IOException e) { 
     661      fail(e.getMessage()); 
     662    } 
     663    catch (FormatException e) { 
     664      fail(e.getMessage()); 
     665    } 
     666 
     667    assertNotNull(imps); 
     668    assertEquals(1,imps.length); 
     669     
     670    ImageStack st = imps[0].getStack(); 
     671    int numSlices = st.getSize(); 
     672    assertEquals(z*c*t,numSlices); 
     673    int count = 0; 
     674    // order differs here from other cases 
     675    System.out.println("XYZTC"); 
     676    for (int j = 0; j < c; j++) 
     677      for (int k = 0; k < t; k++) 
     678        for (int i = 0; i < z; i++) 
     679        { 
     680          ImageProcessor proc = st.getProcessor(count+1); 
     681          printVals(proc); 
     682          assertNotNull(proc); 
     683          assertEquals(x,proc.getWidth()); 
     684          assertEquals(y,proc.getHeight()); 
     685          //assertEquals(count,iIndex(proc)); 
     686          assertEquals(i,zIndex(proc)); 
     687          assertEquals(j,cIndex(proc)); 
     688          assertEquals(k,tIndex(proc)); 
     689          count++; 
     690        } 
     691  } 
     692   
     693  @Test 
     694  public void testOutputStackOrderXYCZT() { 
     695    final int x = 82, y = 47, z = 2, c = 3, t = 4; 
     696    final int pixelType = FormatTools.UINT8; 
     697    final String path = constructFakeFilename("xyczt", pixelType, x, y, z, c, t, -1); 
     698    ImagePlus[] imps = null; 
     699    try { 
     700      final ImporterOptions options = new ImporterOptions(); 
     701      options.setId(path); 
     702      options.setStackOrder("XYCZT"); 
     703      imps = BF.openImagePlus(options); 
     704    } 
     705    catch (IOException e) { 
     706      fail(e.getMessage()); 
     707    } 
     708    catch (FormatException e) { 
     709      fail(e.getMessage()); 
     710    } 
     711 
     712    assertNotNull(imps); 
     713    assertEquals(1,imps.length); 
     714     
     715    ImageStack st = imps[0].getStack(); 
     716    int numSlices = st.getSize(); 
     717    assertEquals(z*c*t,numSlices); 
     718    int count = 0; 
     719    // order differs here from other cases 
     720    System.out.println("XYCZT"); 
     721    for (int k = 0; k < t; k++) 
     722      for (int i = 0; i < z; i++) 
     723        for (int j = 0; j < c; j++) 
     724        { 
     725          ImageProcessor proc = st.getProcessor(count+1); 
     726          printVals(proc); 
     727          assertNotNull(proc); 
     728          assertEquals(x,proc.getWidth()); 
     729          assertEquals(y,proc.getHeight()); 
     730          //assertEquals(count,iIndex(proc)); 
     731          assertEquals(i,zIndex(proc)); 
     732          assertEquals(j,cIndex(proc)); 
     733          assertEquals(k,tIndex(proc)); 
     734          count++; 
     735        } 
     736  } 
     737   
     738  @Test 
     739  public void testOutputStackOrderXYCTZ() { 
     740    final int x = 82, y = 47, z = 2, c = 3, t = 4; 
     741    final int pixelType = FormatTools.UINT8; 
     742    final String path = constructFakeFilename("xyctz", pixelType, x, y, z, c, t, -1); 
     743    ImagePlus[] imps = null; 
     744    try { 
     745      final ImporterOptions options = new ImporterOptions(); 
     746      options.setId(path); 
     747      options.setStackOrder("XYCTZ"); 
     748      imps = BF.openImagePlus(options); 
     749    } 
     750    catch (IOException e) { 
     751      fail(e.getMessage()); 
     752    } 
     753    catch (FormatException e) { 
     754      fail(e.getMessage()); 
     755    } 
     756 
     757    assertNotNull(imps); 
     758    assertEquals(1,imps.length); 
     759     
     760    ImageStack st = imps[0].getStack(); 
     761    int numSlices = st.getSize(); 
     762    assertEquals(z*c*t,numSlices); 
     763    int count = 0; 
     764    // order differs here from other cases 
     765    System.out.println("XYCTZ"); 
     766    for (int i = 0; i < z; i++) 
     767      for (int k = 0; k < t; k++) 
     768        for (int j = 0; j < c; j++) 
     769        { 
     770          ImageProcessor proc = st.getProcessor(count+1); 
     771          printVals(proc); 
     772          assertNotNull(proc); 
     773          assertEquals(x,proc.getWidth()); 
     774          assertEquals(y,proc.getHeight()); 
     775          //assertEquals(count,iIndex(proc)); 
     776          assertEquals(i,zIndex(proc)); 
     777          assertEquals(j,cIndex(proc)); 
     778          assertEquals(k,tIndex(proc)); 
     779          count++; 
     780        } 
     781  } 
     782   
     783  @Test 
     784  public void testOutputStackOrderXYTZC() { 
     785    final int x = 82, y = 47, z = 2, c = 3, t = 4; 
     786    final int pixelType = FormatTools.UINT8; 
     787    final String path = constructFakeFilename("xytzc", pixelType, x, y, z, c, t, -1); 
     788    ImagePlus[] imps = null; 
     789    try { 
     790      final ImporterOptions options = new ImporterOptions(); 
     791      options.setId(path); 
     792      options.setStackOrder("XYTZC"); 
     793      imps = BF.openImagePlus(options); 
     794    } 
     795    catch (IOException e) { 
     796      fail(e.getMessage()); 
     797    } 
     798    catch (FormatException e) { 
     799      fail(e.getMessage()); 
     800    } 
     801 
     802    assertNotNull(imps); 
     803    assertEquals(1,imps.length); 
     804     
     805    ImageStack st = imps[0].getStack(); 
     806    int numSlices = st.getSize(); 
     807    assertEquals(z*c*t,numSlices); 
     808    int count = 0; 
     809    // order differs here from other cases 
     810    System.out.println("XYTZC"); 
     811    for (int j = 0; j < c; j++) 
     812      for (int i = 0; i < z; i++) 
     813        for (int k = 0; k < t; k++) 
     814        { 
     815          ImageProcessor proc = st.getProcessor(count+1); 
     816          printVals(proc); 
     817          assertNotNull(proc); 
     818          assertEquals(x,proc.getWidth()); 
     819          assertEquals(y,proc.getHeight()); 
     820          //assertEquals(count,iIndex(proc)); 
     821          assertEquals(i,zIndex(proc)); 
     822          assertEquals(j,cIndex(proc)); 
     823          assertEquals(k,tIndex(proc)); 
     824          count++; 
     825        } 
     826  } 
     827   
     828  @Test 
     829  public void testOutputStackOrderXYTCZ() { 
     830    final int x = 82, y = 47, z = 2, c = 3, t = 4; 
     831    final int pixelType = FormatTools.UINT8; 
     832    final String path = constructFakeFilename("xytcz", pixelType, x, y, z, c, t, -1); 
     833    ImagePlus[] imps = null; 
     834    try { 
     835      final ImporterOptions options = new ImporterOptions(); 
     836      options.setId(path); 
     837      options.setStackOrder("XYTCZ"); 
     838      imps = BF.openImagePlus(options); 
     839    } 
     840    catch (IOException e) { 
     841      fail(e.getMessage()); 
     842    } 
     843    catch (FormatException e) { 
     844      fail(e.getMessage()); 
     845    } 
     846 
     847    assertNotNull(imps); 
     848    assertEquals(1,imps.length); 
     849     
     850    ImageStack st = imps[0].getStack(); 
     851    int numSlices = st.getSize(); 
     852    assertEquals(z*c*t,numSlices); 
     853    int count = 0; 
     854    // order differs here from other cases 
     855    System.out.println("XYTCZ"); 
     856    for (int i = 0; i < z; i++) 
     857      for (int j = 0; j < c; j++) 
     858        for (int k = 0; k < t; k++) 
     859        { 
     860          ImageProcessor proc = st.getProcessor(count+1); 
     861          printVals(proc); 
     862          assertNotNull(proc); 
     863          assertEquals(x,proc.getWidth()); 
     864          assertEquals(y,proc.getHeight()); 
     865          //assertEquals(count,iIndex(proc)); 
     866          assertEquals(i,zIndex(proc)); 
     867          assertEquals(j,cIndex(proc)); 
     868          assertEquals(k,tIndex(proc)); 
     869          count++; 
     870        } 
     871  } 
     872*/ 
Note: See TracChangeset for help on using the changeset viewer.