Changeset 6288


Ignore:
Timestamp:
05/12/10 14:06:12 (10 years ago)
Author:
bdezonia
Message:

fixed split tests. partial implementation of color tests. minor edits.

File:
1 edited

Legend:

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

    r6287 r6288  
    174174  private int numInSeries(int from, int to, int by) 
    175175  { 
     176    /* 
     177    int spread = from - to + 1; 
     178     
     179    if (spread % by == 0) 
     180      return (spread / by); 
     181    else 
     182      return (spread / by) + 1; 
     183    */ 
    176184    // could calc this but simple loop suffices for our purposes 
    177185    int count = 0; 
     
    179187        count++; 
    180188    return count; 
     189    /* 
     190    */ 
    181191  } 
    182192   
    183193  // note : for now assumes default ZCT ordering 
    184    
     194  /** Tests that an ImageSTack is ordered according to specified from/to/by points of z/c/t */ 
    185195  private boolean seriesInCorrectOrder(ImageStack st, 
    186196      int zFrom, int zTo, int zBy, 
     
    216226  } 
    217227   
     228  // this next method useful to avoid changes to instance vars of ImagePlus by query functions 
     229  /** Gets values of private instance variable ints from an ImagePlus */ 
    218230  private int getField(ImagePlus imp, String fieldName) { 
    219231    Exception exc = null; 
     
    232244  } 
    233245   
     246  /** The number of Z slices in an ImagePlus */ 
    234247  private int getSizeZ(ImagePlus imp) { return getField(imp, "nSlices"); } 
     248 
     249  /** The number of T slices in an ImagePlus */ 
    235250  private int getSizeT(ImagePlus imp) { return getField(imp, "nFrames"); } 
     251 
     252  /** The number of effective C slices in an ImagePlus */ 
    236253  private int getEffectiveSizeC(ImagePlus imp) { return getField(imp, "nChannels"); } 
    237254 
     
    245262  } 
    246263 
     264  // test helper 
    247265  private boolean floatArraysEqual(float[] a, float[] b) 
    248266  { 
     
    382400 
    383401    // make sure the dimensions were swapped correctly 
    384     // notice I'm testing from inside out in ZCT order 
    385     // but using input z for T and the input t for Z 
    386402    int p = 1; 
    387403    for (int zIndex = 0; zIndex < z; zIndex++) 
     
    452468      int x, int y, int z, int c, int t, int s) 
    453469  { 
    454     assertTrue(s >= 1); 
     470    assertTrue(s >= 1);  // necessary for this test 
     471     
     472    // open all series as one 
    455473     
    456474    String path = constructFakeFilename(order, pixType, x, y, z, c, t, s); 
     
    469487    } 
    470488 
     489    // test results 
     490     
    471491    assertNotNull(imps); 
    472492    assertEquals(1,imps.length); 
    473493 
    474494    ImageStack st = imps[0].getStack(); 
    475   
     495 
    476496    int numSlices = st.getSize(); 
    477497     
     
    479499    assertEquals(z*c*t*s,numSlices); 
    480500     
    481     // System.out.println("Numslices == " + numSlices); 
    482501    for (int i = 0; i < numSlices; i++) 
    483502    { 
     
    493512  { 
    494513      int x = 604, y = 531; 
     514       
    495515      String path = constructFakeFilename("vstack", FormatTools.UINT16, x, y, 7, 1, 1, -1); 
     516       
     517      // open stack 
    496518      ImagePlus[] imps = null; 
    497519      try { 
    498520        ImporterOptions options = new ImporterOptions(); 
    499521        options.setId(path); 
    500         options.setVirtual(desireVirtual); 
     522        options.setVirtual(desireVirtual);  // user specified value here 
    501523        imps = BF.openImagePlus(options); 
    502524      } 
     
    508530      } 
    509531   
     532      // test results 
    510533      assertNotNull(imps); 
    511534      assertEquals(1,imps.length); 
     
    584607  { 
    585608    String path = constructFakeFilename("crop", pixType, x, y, 1, 1, 1, 1); 
     609     
     610    // open image 
    586611    ImagePlus[] imps = null; 
    587612    try { 
     
    599624    } 
    600625 
     626    // test results 
    601627    assertNotNull(imps); 
    602628    assertEquals(1,imps.length); 
    603629    assertNotNull(imps[0]); 
    604     assertEquals(cx,imps[0].getWidth()); 
     630    assertEquals(cx,imps[0].getWidth());  // here is where we make sure we get back a cropped image 
    605631    assertEquals(cy,imps[0].getHeight()); 
    606632  } 
     
    803829    // grayscale.  The first channel is colorized red, the second channel is green, and the third channel is blue. This 
    804830    // option is not available when Merge channels to RGB or Custom colorize channels are set. 
    805     fail("to be implemented"); 
     831     
     832    String path = FAKE_FILES[0]; 
     833     
     834    ImagePlus[] imps = null; 
     835    ImagePlus imp = null; 
     836 
     837    // TODO - should not allow mergeChannels with rgb colorize 
     838    try { 
     839      ImporterOptions options = new ImporterOptions(); 
     840      options.setColorize(true); 
     841      options.setMergeChannels(true); 
     842      options.setId(path); 
     843      imps = BF.openImagePlus(options); 
     844    } 
     845    catch (IOException e) { 
     846      fail(e.getMessage()); 
     847    } 
     848    catch (FormatException e) { 
     849      fail(e.getMessage()); 
     850    } 
     851     
     852    // TODO - should not allow mergeChannels with custom colorize 
     853    try { 
     854      ImporterOptions options = new ImporterOptions(); 
     855      options.setColorize(true); 
     856      options.setCustomColorize(true); 
     857      options.setId(path); 
     858      imps = BF.openImagePlus(options); 
     859    } 
     860    catch (IOException e) { 
     861      fail(e.getMessage()); 
     862    } 
     863    catch (FormatException e) { 
     864      fail(e.getMessage()); 
     865    } 
     866 
     867    // TODO - legitimate testing 
     868    // open file 
     869    try { 
     870      ImporterOptions options = new ImporterOptions(); 
     871      options.setColorize(true); 
     872      options.setId(path); 
     873      imps = BF.openImagePlus(options); 
     874    } 
     875    catch (IOException e) { 
     876      fail(e.getMessage()); 
     877    } 
     878    catch (FormatException e) { 
     879      fail(e.getMessage()); 
     880    } 
     881     
     882    assertEquals(1,imps.length); 
     883    imp = imps[0]; 
     884    assertEquals(7,getSizeZ(imp)); 
     885    assertEquals(1,getEffectiveSizeC(imp));  // TODO : correct? 
     886    assertEquals(1,getSizeT(imp));  // TODO : huh? 
     887     
     888    // TODO - actual tests of data 
     889     
     890    fail("unfinished implementation"); 
    806891  } 
    807892 
     
    11591244  { 
    11601245    final int sizeZ = 5, sizeC = 3, sizeT = 7; 
    1161     final String path = constructFakeFilename("splitT", 
     1246    final String path = constructFakeFilename("splitC", 
    11621247      FormatTools.UINT8, 50, 20, sizeZ, sizeC, sizeT, -1); 
    11631248 
     1249    // open image 
    11641250    ImagePlus[] imps = null; 
    11651251    try { 
     
    11791265    assertEquals(sizeC,imps.length); 
    11801266     
     1267    // unwind ZCT loop : C pulled to front, ZT in order 
    11811268    for (int c = 0; c < sizeC; c++) { 
    11821269      ImageStack st = imps[c].getStack(); 
     
    11851272      for (int t = 0; t < sizeT; t++) { 
    11861273        for (int z = 0; z < sizeZ; z++) { 
    1187           // these next three statements called more times than needed but simplifies for loop logic 
    11881274          ImageProcessor proc = st.getProcessor(++index); 
    11891275          // test the values 
    11901276          assertEquals(z,zIndex(proc)); 
    1191           assertEquals(c,cIndex(proc));  // this one should always be 0 
     1277          assertEquals(c,cIndex(proc)); 
    11921278          assertEquals(t,tIndex(proc)); 
    11931279        } 
     
    12001286  { 
    12011287    final int sizeZ = 5, sizeC = 3, sizeT = 7; 
    1202     final String path = constructFakeFilename("splitT", 
     1288    final String path = constructFakeFilename("splitZ", 
    12031289      FormatTools.UINT8, 50, 20, sizeZ, sizeC, sizeT, -1); 
    12041290 
     1291    // open image 
    12051292    ImagePlus[] imps = null; 
    12061293    try { 
     
    12191306    // one focal plane per image 
    12201307    assertEquals(sizeZ,imps.length); 
    1221      
    1222     // TODO - order of for loops correct? 
    1223     for (int t = 0; t < sizeT; t++) 
    1224       for (int c = 0; c < sizeC; c++) 
    1225         for (int z = 0; z < sizeZ; z++) 
    1226         { 
    1227           // these next three statements called more times than needed but simplifies for loop logic 
    1228           ImageStack st = imps[z].getStack(); 
    1229           assertEquals(sizeC * sizeT,st.getSize()); 
    1230           ImageProcessor proc = st.getProcessor(z+1); 
     1308 
     1309    // unwind ZCT loop : Z pulled to front, CT in order 
     1310    for (int z = 0; z < sizeZ; z++) { 
     1311      ImageStack st = imps[z].getStack(); 
     1312      assertEquals(sizeC * sizeT,st.getSize()); 
     1313      int index = 0; 
     1314      for (int t = 0; t < sizeT; t++) { 
     1315        for (int c = 0; c < sizeC; c++) { 
     1316          ImageProcessor proc = st.getProcessor(++index); 
    12311317          // test the values 
    1232           assertEquals(0,zIndex(proc));  // this one should always be 0 
     1318          assertEquals(z,zIndex(proc)); 
    12331319          assertEquals(c,cIndex(proc)); 
    12341320          assertEquals(t,tIndex(proc)); 
    12351321        } 
     1322      } 
     1323    } 
    12361324  } 
    12371325   
     
    12431331      FormatTools.UINT8, 50, 20, sizeZ, sizeC, sizeT, -1); 
    12441332 
     1333    // open image 
    12451334    ImagePlus[] imps = null; 
    12461335    try { 
     
    12601349    assertEquals(sizeT,imps.length); 
    12611350     
    1262     // TODO - order of for loops correct? 
    1263     for (int t = 0; t < sizeT; t++) 
    1264       for (int c = 0; c < sizeC; c++) 
    1265         for (int z = 0; z < sizeZ; z++) 
    1266         { 
    1267           // these next three statements called more times than needed but simplifies for loop logic 
    1268           ImageStack st = imps[t].getStack(); 
    1269           assertEquals(sizeZ * sizeC,st.getSize()); 
    1270           ImageProcessor proc = st.getProcessor(t+1); 
     1351    // unwind ZTC loop : T pulled to front, ZC in order 
     1352    for (int t = 0; t < sizeT; t++) { 
     1353      ImageStack st = imps[t].getStack(); 
     1354      assertEquals(sizeZ * sizeC,st.getSize()); 
     1355      int index = 0; 
     1356      for (int c = 0; c < sizeC; c++) { 
     1357        for (int z = 0; z < sizeZ; z++) { 
     1358          ImageProcessor proc = st.getProcessor(++index); 
    12711359          // test the values 
    12721360          assertEquals(z,zIndex(proc)); 
    12731361          assertEquals(c,cIndex(proc)); 
    1274           assertEquals(0,tIndex(proc));  // this one should always be 0 
     1362          assertEquals(t,tIndex(proc)); 
    12751363        } 
     1364      } 
     1365    } 
    12761366  } 
    12771367 
Note: See TracChangeset for help on using the changeset viewer.