Changeset 6594


Ignore:
Timestamp:
06/29/10 11:13:11 (9 years ago)
Author:
bdezonia
Message:

put most all virtual subcases in place

File:
1 edited

Legend:

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

    r6591 r6594  
    558558  } 
    559559   
    560   /** helper test that verifies the indices of a FakeFile[z,c,t] match passed in values*/ 
     560  /** tests that the indices of a FakeFile[z,c,t] match passed in values*/ 
    561561  private void indexValuesTest(ImagePlus imp, int z, int c, int t, boolean indexed, boolean falseColor, 
    562562                                  int es, int ei, int ez, int ec, int et) 
     
    761761  } 
    762762 
    763   /** for signed integral data tests that the Calibration of an ImagePlus is correct */ 
     763  /** tests that the Calibration of an ImagePlus of signed integer data is correct */ 
    764764  private void calibrationTest(ImagePlus imp, int pixType) 
    765765  { 
     
    918918  } 
    919919   
    920   // this one will be different from the previous two as we concat along T by default for FakeFiles as all dims compat. 
     920  // this one will be different from the previous two as we concat along T by default for FakeFiles as all dims compatible. 
    921921  //   Then we're splitting on T. Logic will need to be different from others. 
    922922  /** tests that a set of images is ordered via T first - used by concatSplit tests */ 
     
    937937          for (int c = 0; c < sizeC; c++) { 
    938938            ImageProcessor proc = st.getProcessor(++slice); 
    939             printVals(proc); 
     939            //printVals(proc); 
    940940            //System.out.println("index "+index); 
    941941            //System.out.println("s z c t "+s+" "+z+" "+c+" "+t); 
     
    10541054  } 
    10551055 
     1056  /** tests BF's options.setGroupFiles() */ 
     1057  private void datasetGroupFilesTester(boolean virtual) 
     1058  { 
     1059    String path = FAKE_FILES[0]; 
     1060 
     1061    ImagePlus[] imps = null; 
     1062     
     1063    try { 
     1064      ImporterOptions options = new ImporterOptions(); 
     1065      options.setVirtual(virtual); 
     1066      options.setGroupFiles(true); 
     1067      options.setId(path); 
     1068      imps = BF.openImagePlus(options); 
     1069      assertEquals(FAKE_PATTERN, options.getId()); 
     1070    } 
     1071    catch (IOException e) { 
     1072      fail(e.getMessage()); 
     1073    } 
     1074    catch (FormatException e) { 
     1075      fail(e.getMessage()); 
     1076    } 
     1077     
     1078    impsCountTest(imps,1); 
     1079   
     1080    groupedFilesTest(imps[0], FAKE_FILES.length, FakePlaneCount); 
     1081  } 
     1082   
     1083  /** tests BF's options.setUngroupFiles() */ 
     1084  private void datsetOpenFilesIndividuallyTester(boolean virtual) 
     1085  { 
     1086    // TODO - try to remove file dependency 
     1087     
     1088    String path = "2channel_stack_raw01.pic"; 
     1089     
     1090    // there is a second file called "2channel_stack_raw02.pic" present in the same directory 
     1091    // if open indiv true should only load one of them, otherwise both 
     1092     
     1093    // try ungrouped 
     1094     
     1095    ImagePlus[] imps = null; 
     1096     
     1097    try { 
     1098      ImporterOptions options = new ImporterOptions(); 
     1099      options.setUngroupFiles(true); 
     1100      options.setId(path); 
     1101      imps = BF.openImagePlus(options); 
     1102    } 
     1103    catch (IOException e) { 
     1104      fail(e.getMessage()); 
     1105    } 
     1106    catch (FormatException e) { 
     1107      fail(e.getMessage()); 
     1108    } 
     1109     
     1110    // test results 
     1111     
     1112    impsCountTest(imps,1); 
     1113     
     1114    stackTest(imps[0],16); // one loaded as one set with 16 slices 
     1115     
     1116    // try grouped 
     1117     
     1118    try { 
     1119      ImporterOptions options = new ImporterOptions(); 
     1120      options.setUngroupFiles(false); 
     1121      options.setId(path); 
     1122      imps = BF.openImagePlus(options); 
     1123    } 
     1124    catch (IOException e) { 
     1125      fail(e.getMessage()); 
     1126    } 
     1127    catch (FormatException e) { 
     1128      fail(e.getMessage()); 
     1129    } 
     1130 
     1131    // test results 
     1132     
     1133    impsCountTest(imps,1); 
     1134     
     1135    stackTest(imps[0],32); // both loaded as one set of 32 slices 
     1136  } 
     1137 
    10561138  /** tests BF's options.setSwapDimensions() */ 
    10571139  private void datasetSwapDimsTester(boolean virtual, int pixType, int x, int y, int z, int t) 
     
    11661248   
    11671249  /** tests BF's options.setAutoscale() */ 
    1168   private void autoscaleTester(boolean virtual, int pixType, boolean wantAutoscale) 
     1250  private void autoscaleTester(int pixType, boolean wantAutoscale) 
    11691251  { 
    11701252    final int sizeZ = 2, sizeC = 3, sizeT = 4, sizeX = 51, sizeY = 16; 
     
    11751257    try { 
    11761258      ImporterOptions options = new ImporterOptions(); 
    1177       options.setVirtual(virtual); 
    11781259      options.setAutoscale(wantAutoscale); 
    11791260      options.setId(path); 
     
    15031584   
    15041585  /** tests BF's options.set?Begin(), options.set?End(), and options.set?Step() */ 
    1505   private void memorySpecifyRangeTester(boolean virtual, int z, int c, int t, 
     1586  private void memorySpecifyRangeTester(int z, int c, int t, 
    15061587      int zFrom, int zTo, int zBy, 
    15071588      int cFrom, int cTo, int cBy, 
     
    15161597    try { 
    15171598      ImporterOptions options = new ImporterOptions(); 
    1518       options.setVirtual(virtual); 
    15191599      options.setId(path); 
    15201600       
     
    15661646   
    15671647  /** tests BF's options.setCrop() and options.setCropRegion() */ 
    1568   private void memoryCropTester(boolean virtual, int x, int y, int ox, int oy, int cropSize) 
     1648  private void memoryCropTester(int x, int y, int ox, int oy, int cropSize) 
    15691649  { 
    15701650    verifyCropInput(x, y, ox, oy, cropSize);  // needed for this test 
     
    15771657    try { 
    15781658      ImporterOptions options = new ImporterOptions(); 
    1579       options.setVirtual(virtual); 
    15801659      options.setId(path); 
    15811660      options.setCrop(true); 
     
    15991678    // test we got the right pixels 
    16001679    croppedPixelsTest(imp,ox,cropSize); 
     1680  } 
     1681 
     1682  /** tests BF's options.setSplitChannels() */ 
     1683  private void splitChannelsTester() 
     1684  { 
     1685    final int sizeX = 50, sizeY = 20, sizeZ = 5, sizeC = 3, sizeT = 7; 
     1686 
     1687    final String path = constructFakeFilename("splitC", 
     1688      FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, -1, false, -1, false, -1); 
     1689 
     1690    // open image 
     1691    ImagePlus[] imps = null; 
     1692     
     1693    try { 
     1694      ImporterOptions options = new ImporterOptions(); 
     1695      options.setSplitChannels(true); 
     1696      options.setId(path); 
     1697      imps = BF.openImagePlus(options); 
     1698    } 
     1699    catch (IOException e) { 
     1700      fail(e.getMessage()); 
     1701    } 
     1702    catch (FormatException e) { 
     1703      fail(e.getMessage()); 
     1704    } 
     1705 
     1706    // one image per channel 
     1707    impsCountTest(imps,sizeC); 
     1708     
     1709    imagesInCztOrderTest(imps,sizeX,sizeY,sizeZ,sizeC,sizeT); 
     1710  } 
     1711 
     1712  /** tests BF's options.setFocalPlanes() */ 
     1713  private void splitFocalPlanesTester() 
     1714  { 
     1715    final int sizeX = 50, sizeY = 20, sizeZ = 5, sizeC = 3, sizeT = 7; 
     1716     
     1717    final String path = constructFakeFilename("splitZ", 
     1718      FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, -1, false, -1, false, -1); 
     1719 
     1720    // open image 
     1721    ImagePlus[] imps = null; 
     1722     
     1723    try { 
     1724      ImporterOptions options = new ImporterOptions(); 
     1725      options.setSplitFocalPlanes(true); 
     1726      options.setId(path); 
     1727      imps = BF.openImagePlus(options); 
     1728    } 
     1729    catch (IOException e) { 
     1730      fail(e.getMessage()); 
     1731    } 
     1732    catch (FormatException e) { 
     1733      fail(e.getMessage()); 
     1734    } 
     1735     
     1736    // one image per focal plane 
     1737    impsCountTest(imps,sizeZ); 
     1738 
     1739    imagesInZctOrderTest(imps,sizeX,sizeY,sizeZ,sizeC,sizeT); 
     1740  } 
     1741   
     1742  /** tests BF's options.setSplitTimepoints() */ 
     1743  private void splitTimepointsTester() 
     1744  { 
     1745    final int sizeX = 50, sizeY = 20, sizeZ = 5, sizeC = 3, sizeT = 7; 
     1746   
     1747    final String path = constructFakeFilename("splitT", 
     1748      FormatTools.UINT8, 50, 20, sizeZ, sizeC, sizeT, -1, false, -1, false, -1); 
     1749 
     1750    // open image 
     1751    ImagePlus[] imps = null; 
     1752     
     1753    try { 
     1754      ImporterOptions options = new ImporterOptions(); 
     1755      options.setSplitTimepoints(true); 
     1756      options.setId(path); 
     1757      imps = BF.openImagePlus(options); 
     1758    } 
     1759    catch (IOException e) { 
     1760      fail(e.getMessage()); 
     1761    } 
     1762    catch (FormatException e) { 
     1763      fail(e.getMessage()); 
     1764    } 
     1765     
     1766    // one image per time point 
     1767    impsCountTest(imps,sizeT); 
     1768 
     1769    imagesInTczOrderTest(imps,sizeX,sizeY,sizeZ,sizeC,sizeT); 
    16011770  } 
    16021771 
     
    18261995  } 
    18271996 
    1828   private void datasetGroupFilesTester(boolean virtual) 
    1829   { 
    1830     String path = FAKE_FILES[0]; 
    1831  
    1832     ImagePlus[] imps = null; 
    1833      
    1834     try { 
    1835       ImporterOptions options = new ImporterOptions(); 
    1836       options.setVirtual(virtual); 
    1837       options.setGroupFiles(true); 
    1838       options.setId(path); 
    1839       imps = BF.openImagePlus(options); 
    1840       assertEquals(FAKE_PATTERN, options.getId()); 
    1841     } 
    1842     catch (IOException e) { 
    1843       fail(e.getMessage()); 
    1844     } 
    1845     catch (FormatException e) { 
    1846       fail(e.getMessage()); 
    1847     } 
    1848      
    1849     impsCountTest(imps,1); 
    1850    
    1851     groupedFilesTest(imps[0], FAKE_FILES.length, FakePlaneCount); 
    1852   } 
    1853    
    18541997  @Test 
    18551998  public void testDatasetGroupFiles() 
     
    18572000    for (boolean virtual : BooleanStates) 
    18582001      datasetGroupFilesTester(virtual); 
    1859   } 
    1860  
    1861   private void datsetOpenFilesIndividuallyTester(boolean virtual) 
    1862   { 
    1863     // TODO - try to remove file dependency 
    1864      
    1865     String path = "2channel_stack_raw01.pic"; 
    1866      
    1867     // there is a second file called "2channel_stack_raw02.pic" present in the same directory 
    1868     // if open indiv true should only load one of them, otherwise both 
    1869      
    1870     // try ungrouped 
    1871      
    1872     ImagePlus[] imps = null; 
    1873      
    1874     try { 
    1875       ImporterOptions options = new ImporterOptions(); 
    1876       options.setUngroupFiles(true); 
    1877       options.setId(path); 
    1878       imps = BF.openImagePlus(options); 
    1879     } 
    1880     catch (IOException e) { 
    1881       fail(e.getMessage()); 
    1882     } 
    1883     catch (FormatException e) { 
    1884       fail(e.getMessage()); 
    1885     } 
    1886      
    1887     // test results 
    1888      
    1889     impsCountTest(imps,1); 
    1890      
    1891     stackTest(imps[0],16); // one loaded as one set with 16 slices 
    1892      
    1893     // try grouped 
    1894      
    1895     try { 
    1896       ImporterOptions options = new ImporterOptions(); 
    1897       options.setUngroupFiles(false); 
    1898       options.setId(path); 
    1899       imps = BF.openImagePlus(options); 
    1900     } 
    1901     catch (IOException e) { 
    1902       fail(e.getMessage()); 
    1903     } 
    1904     catch (FormatException e) { 
    1905       fail(e.getMessage()); 
    1906     } 
    1907  
    1908     // test results 
    1909      
    1910     impsCountTest(imps,1); 
    1911      
    1912     stackTest(imps[0],32); // both loaded as one set of 32 slices 
    19132002  } 
    19142003 
     
    20772166  public void testColorAutoscale() 
    20782167  { 
    2079     for (boolean virtual : BooleanStates) 
     2168    // note - can't autoscale a virtualStack. No need to test it. 
     2169     
     2170    for (int pixType : PixelTypes) 
    20802171    { 
    2081       for (int pixType : PixelTypes) 
     2172      for (boolean autoscale : BooleanStates) 
    20822173      { 
    2083         for (boolean autoscale : BooleanStates) 
    2084         { 
    2085           //System.out.println("testColorAutoscale(): pixType = "+FormatTools.getPixelTypeString(pixType)+" autoscale = "+autoscale); 
    2086           autoscaleTester(virtual,pixType,autoscale); 
    2087         } 
     2174        //System.out.println("testColorAutoscale(): pixType = "+FormatTools.getPixelTypeString(pixType)+" autoscale = "+autoscale); 
     2175        autoscaleTester(pixType,autoscale); 
    20882176      } 
    20892177    } 
     
    21092197  public void testMemorySpecifyRange() 
    21102198  { 
     2199    // note - can't specify range in a virtualStack - no need to test 
     2200     
    21112201    int z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy; 
    21122202 
    2113     for (boolean virtual : BooleanStates) 
    2114     { 
    2115       // test partial z: from 
    2116       z=8; c=3; t=2; zFrom=2; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
    2117       memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2118        
    2119       // test partial z: to 
    2120       z=8; c=3; t=2; zFrom=0; zTo=4; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
    2121       memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2122    
    2123       // test partial z: by 
    2124       z=8; c=3; t=2; zFrom=0; zTo=z-1; zBy=3; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
    2125       memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2126    
    2127       // test full z 
    2128       z=8; c=3; t=2; zFrom=2; zTo=7; zBy=3; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
    2129       memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2130        
    2131       // test partial c: from 
    2132       z=6; c=14; t=4; zFrom=0; zTo=z-1; zBy=1; cFrom=3; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
    2133       memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2134        
    2135       // test partial c: to 
    2136       z=6; c=14; t=4; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=6; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
    2137       memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2138        
    2139       // test partial c: by 
    2140       z=6; c=14; t=4; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=4; tFrom=0; tTo=t-1; tBy=1; 
    2141       memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2142        
    2143       // test full c 
    2144       z=6; c=14; t=4; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=12; cBy=4; tFrom=0; tTo=t-1; tBy=1; 
    2145       memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2146        
    2147       // test partial t: from 
    2148       z=3; c=5; t=13; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=4; tTo=t-1; tBy=1; 
    2149       memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2150        
    2151       // test partial t: to 
    2152       z=3; c=5; t=13; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=8; tBy=1; 
    2153       memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2154        
    2155       // test partial t: by 
    2156       z=3; c=5; t=13; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=2; 
    2157       memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2158        
    2159       // test full t 
    2160       z=3; c=5; t=13; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=4; tTo=13; tBy=2; 
    2161       memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2162        
    2163       // test edge case combo with an invalid by 
    2164       z=2; c=2; t=2; zFrom=0; zTo=0; zBy=2; cFrom=1; cTo=1; cBy=1; tFrom=0; tTo=1; tBy=1; 
    2165       memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2166    
    2167       // test a combination of zct's 
    2168       z=5; c=4; t=6; zFrom=1; zTo=4; zBy=2; cFrom=1; cTo=3; cBy=1; tFrom=2; tTo=5; tBy=2; 
    2169       memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2170        
    2171       // test another combination of zct's 
    2172       z=7; c=7; t=7; zFrom=3; zTo=6; zBy=4; cFrom=1; cTo=6; cBy=3; tFrom=0; tTo=2; tBy=2; 
    2173       memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2174        
    2175       // test bad combination of zct's - choosing beyond ends of ranges 
    2176        
    2177       // z index before 0 begin 
    2178       try { 
    2179         z=7; c=7; t=7; zFrom=-1; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
    2180         memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2181         fail(); 
    2182       } catch (IllegalArgumentException e) { 
    2183         assertTrue(true); 
    2184       } 
    2185    
    2186       // z index after z-1 end 
    2187       try { 
    2188         z=7; c=7; t=7; zFrom=0; zTo=z; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
    2189         memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2190         fail(); 
    2191       } catch (IllegalArgumentException e) { 
    2192         assertTrue(true); 
    2193       } 
    2194        
    2195       // z by < 1 
    2196       try { 
    2197         z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=0; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
    2198         memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2199         fail(); 
    2200       } catch (IllegalArgumentException e) { 
    2201         assertTrue(true); 
    2202       } 
    2203    
    2204       // c index before 0 begin 
    2205       try { 
    2206         z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=-1; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
    2207         memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2208         fail(); 
    2209       } catch (IllegalArgumentException e) { 
    2210         assertTrue(true); 
    2211       } 
    2212    
    2213       // c index after c-1 end 
    2214       try { 
    2215         z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
    2216         memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2217         fail(); 
    2218       } catch (IllegalArgumentException e) { 
    2219         assertTrue(true); 
    2220       } 
    2221    
    2222       // c by < 1 
    2223       try { 
    2224         z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=0; tFrom=0; tTo=t-1; tBy=1; 
    2225         memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2226         fail(); 
    2227       } catch (IllegalArgumentException e) { 
    2228         assertTrue(true); 
    2229       } 
    2230    
    2231       // t index before 0 begin 
    2232       try { 
    2233         z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=-1; tTo=t-1; tBy=1; 
    2234         memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2235         fail(); 
    2236       } catch (IllegalArgumentException e) { 
    2237         assertTrue(true); 
    2238       } 
    2239    
    2240       // t index after t-1 end 
    2241       try { 
    2242         z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t; tBy=1; 
    2243         memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2244         fail(); 
    2245       } catch (IllegalArgumentException e) { 
    2246         assertTrue(true); 
    2247       } 
    2248    
    2249       // t by < 1 
    2250       try { 
    2251         z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=0; 
    2252         memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2253         fail(); 
    2254       } catch (IllegalArgumentException e) { 
    2255         assertTrue(true); 
    2256       } 
    2257        
    2258       /* TODO - could replace above code with this uber combo test 
    2259       // comprehensive but probably WAY too much computation to finish in reasonable time 
    2260       z = 6; c = 5; t = 4; 
    2261       for (int zStart = -1; zStart < z+2; zStart++) 
    2262         for (int zEnd = -1; zEnd < z+2; zEnd++) 
    2263           for (int zInc = -1; zInc < z+2; zInc++) 
    2264             for (int cStart = -1; cStart < c+2; cStart++) 
    2265               for (int cEnd = -1; cEnd < c+2; cEnd++) 
    2266                 for (int cInc = -1; cInc < c+2; cInc++) 
    2267                   for (int tStart = -1; tStart < t+2; tStart++) 
    2268                     for (int tEnd = -1; tEnd < t+2; tEnd++) 
    2269                       for (int tInc = -1; tInc < t+2; tInc++) 
    2270                         // if an invalid index of some kind 
    2271                         if ((zStart < 0) || (zStart >= z) || 
    2272                             (zEnd < 0) || (zEnd >= z) || // ignored by BF (zEnd < zStart) || 
    2273                             (zInc < 1) || 
    2274                             (cStart < 0) || (cStart >= c) || 
    2275                             (cEnd < 0) || (cEnd >= c) || // ignored by BF (cEnd < cStart) || 
    2276                             (cInc < 1) || 
    2277                             (tStart < 0) || (tStart >= t) || 
    2278                             (tEnd < 0) || (tEnd >= t) || // ignored by BF (tEnd < tStart) || 
    2279                             (tInc < 1)) 
    2280                         { 
    2281                           // expect failure 
    2282                           try { 
    2283                             memorySpecifyRangeTester(virtual,z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
    2284                             System.out.println("memorySpecifyRange() test failed: combo = zct "+z+" "+c+" "+t+ 
    2285                               " z vals "+zFrom+" "+zTo+" "+zBy+ 
    2286                               " c vals "+cFrom+" "+cTo+" "+cBy+ 
    2287                               " t vals "+tFrom+" "+tTo+" "+tBy); 
    2288                             fail("BF did not catch bad indexing code"); 
    2289                           } catch (IllegalArgumentException e) { 
    2290                             assertTrue(true); 
    2291                           } 
     2203    // test partial z: from 
     2204    z=8; c=3; t=2; zFrom=2; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
     2205    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2206     
     2207    // test partial z: to 
     2208    z=8; c=3; t=2; zFrom=0; zTo=4; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
     2209    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2210 
     2211    // test partial z: by 
     2212    z=8; c=3; t=2; zFrom=0; zTo=z-1; zBy=3; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
     2213    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2214 
     2215    // test full z 
     2216    z=8; c=3; t=2; zFrom=2; zTo=7; zBy=3; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
     2217    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2218     
     2219    // test partial c: from 
     2220    z=6; c=14; t=4; zFrom=0; zTo=z-1; zBy=1; cFrom=3; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
     2221    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2222     
     2223    // test partial c: to 
     2224    z=6; c=14; t=4; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=6; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
     2225    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2226     
     2227    // test partial c: by 
     2228    z=6; c=14; t=4; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=4; tFrom=0; tTo=t-1; tBy=1; 
     2229    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2230     
     2231    // test full c 
     2232    z=6; c=14; t=4; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=12; cBy=4; tFrom=0; tTo=t-1; tBy=1; 
     2233    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2234     
     2235    // test partial t: from 
     2236    z=3; c=5; t=13; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=4; tTo=t-1; tBy=1; 
     2237    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2238     
     2239    // test partial t: to 
     2240    z=3; c=5; t=13; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=8; tBy=1; 
     2241    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2242     
     2243    // test partial t: by 
     2244    z=3; c=5; t=13; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=2; 
     2245    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2246     
     2247    // test full t 
     2248    z=3; c=5; t=13; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=4; tTo=13; tBy=2; 
     2249    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2250     
     2251    // test edge case combo with an invalid by 
     2252    z=2; c=2; t=2; zFrom=0; zTo=0; zBy=2; cFrom=1; cTo=1; cBy=1; tFrom=0; tTo=1; tBy=1; 
     2253    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2254 
     2255    // test a combination of zct's 
     2256    z=5; c=4; t=6; zFrom=1; zTo=4; zBy=2; cFrom=1; cTo=3; cBy=1; tFrom=2; tTo=5; tBy=2; 
     2257    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2258     
     2259    // test another combination of zct's 
     2260    z=7; c=7; t=7; zFrom=3; zTo=6; zBy=4; cFrom=1; cTo=6; cBy=3; tFrom=0; tTo=2; tBy=2; 
     2261    memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2262     
     2263    // test bad combination of zct's - choosing beyond ends of ranges 
     2264     
     2265    // z index before 0 begin 
     2266    try { 
     2267      z=7; c=7; t=7; zFrom=-1; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
     2268      memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2269      fail(); 
     2270    } catch (IllegalArgumentException e) { 
     2271      assertTrue(true); 
     2272    } 
     2273 
     2274    // z index after z-1 end 
     2275    try { 
     2276      z=7; c=7; t=7; zFrom=0; zTo=z; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
     2277      memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2278      fail(); 
     2279    } catch (IllegalArgumentException e) { 
     2280      assertTrue(true); 
     2281    } 
     2282     
     2283    // z by < 1 
     2284    try { 
     2285      z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=0; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
     2286      memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2287      fail(); 
     2288    } catch (IllegalArgumentException e) { 
     2289      assertTrue(true); 
     2290    } 
     2291 
     2292    // c index before 0 begin 
     2293    try { 
     2294      z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=-1; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
     2295      memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2296      fail(); 
     2297    } catch (IllegalArgumentException e) { 
     2298      assertTrue(true); 
     2299    } 
     2300 
     2301    // c index after c-1 end 
     2302    try { 
     2303      z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c; cBy=1; tFrom=0; tTo=t-1; tBy=1; 
     2304      memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2305      fail(); 
     2306    } catch (IllegalArgumentException e) { 
     2307      assertTrue(true); 
     2308    } 
     2309 
     2310    // c by < 1 
     2311    try { 
     2312      z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=0; tFrom=0; tTo=t-1; tBy=1; 
     2313      memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2314      fail(); 
     2315    } catch (IllegalArgumentException e) { 
     2316      assertTrue(true); 
     2317    } 
     2318 
     2319    // t index before 0 begin 
     2320    try { 
     2321      z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=-1; tTo=t-1; tBy=1; 
     2322      memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2323      fail(); 
     2324    } catch (IllegalArgumentException e) { 
     2325      assertTrue(true); 
     2326    } 
     2327 
     2328    // t index after t-1 end 
     2329    try { 
     2330      z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t; tBy=1; 
     2331      memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2332      fail(); 
     2333    } catch (IllegalArgumentException e) { 
     2334      assertTrue(true); 
     2335    } 
     2336 
     2337    // t by < 1 
     2338    try { 
     2339      z=7; c=7; t=7; zFrom=0; zTo=z-1; zBy=1; cFrom=0; cTo=c-1; cBy=1; tFrom=0; tTo=t-1; tBy=0; 
     2340      memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2341      fail(); 
     2342    } catch (IllegalArgumentException e) { 
     2343      assertTrue(true); 
     2344    } 
     2345     
     2346    /* TODO - could replace above code with this uber combo test 
     2347    // comprehensive but probably WAY too much computation to finish in reasonable time 
     2348    z = 6; c = 5; t = 4; 
     2349    for (int zStart = -1; zStart < z+2; zStart++) 
     2350      for (int zEnd = -1; zEnd < z+2; zEnd++) 
     2351        for (int zInc = -1; zInc < z+2; zInc++) 
     2352          for (int cStart = -1; cStart < c+2; cStart++) 
     2353            for (int cEnd = -1; cEnd < c+2; cEnd++) 
     2354              for (int cInc = -1; cInc < c+2; cInc++) 
     2355                for (int tStart = -1; tStart < t+2; tStart++) 
     2356                  for (int tEnd = -1; tEnd < t+2; tEnd++) 
     2357                    for (int tInc = -1; tInc < t+2; tInc++) 
     2358                      // if an invalid index of some kind 
     2359                      if ((zStart < 0) || (zStart >= z) || 
     2360                          (zEnd < 0) || (zEnd >= z) || // ignored by BF (zEnd < zStart) || 
     2361                          (zInc < 1) || 
     2362                          (cStart < 0) || (cStart >= c) || 
     2363                          (cEnd < 0) || (cEnd >= c) || // ignored by BF (cEnd < cStart) || 
     2364                          (cInc < 1) || 
     2365                          (tStart < 0) || (tStart >= t) || 
     2366                          (tEnd < 0) || (tEnd >= t) || // ignored by BF (tEnd < tStart) || 
     2367                          (tInc < 1)) 
     2368                      { 
     2369                        // expect failure 
     2370                        try { 
     2371                          memorySpecifyRangeTester(z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy); 
     2372                          System.out.println("memorySpecifyRange() test failed: combo = zct "+z+" "+c+" "+t+ 
     2373                            " z vals "+zFrom+" "+zTo+" "+zBy+ 
     2374                            " c vals "+cFrom+" "+cTo+" "+cBy+ 
     2375                            " t vals "+tFrom+" "+tTo+" "+tBy); 
     2376                          fail("BF did not catch bad indexing code"); 
     2377                        } catch (IllegalArgumentException e) { 
     2378                          assertTrue(true); 
    22922379                        } 
    2293                         else 
    2294                           // expect success 
    2295                           memorySpecifyRangeTester(virtual,z,c,t,zStart,zEnd,zInc,cStart,cEnd,cInc,tStart,tEnd,tInc); 
    2296       */ 
    2297     } 
     2380                      } 
     2381                      else 
     2382                        // expect success 
     2383                        memorySpecifyRangeTester(z,c,t,zStart,zEnd,zInc,cStart,cEnd,cInc,tStart,tEnd,tInc); 
     2384    */ 
    22982385  } 
    22992386   
     
    23012388  public void testMemoryCrop() 
    23022389  { 
    2303     for (boolean virtual : BooleanStates) 
    2304     { 
    2305       memoryCropTester(virtual, 203, 255, 55, 20, 3); 
    2306       memoryCropTester(virtual, 203, 184, 55, 40, 2); 
    2307       memoryCropTester(virtual, 101, 76, 0, 25, 4); 
    2308       memoryCropTester(virtual, 100, 122, 0, 15, 3); 
    2309     } 
     2390    // note - can't crop a virtualStack. therefore no need to test it. 
     2391     
     2392    memoryCropTester(203, 255, 55, 20, 3); 
     2393    memoryCropTester(203, 184, 55, 40, 2); 
     2394    memoryCropTester(101, 76, 0, 25, 4); 
     2395    memoryCropTester(100, 122, 0, 15, 3); 
    23102396  } 
    23112397   
     
    23132399  public void testSplitChannels() 
    23142400  { 
    2315     final int sizeX = 50, sizeY = 20, sizeZ = 5, sizeC = 3, sizeT = 7; 
    2316  
    2317     final String path = constructFakeFilename("splitC", 
    2318       FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, -1, false, -1, false, -1); 
    2319  
    2320     // open image 
    2321     ImagePlus[] imps = null; 
    2322      
    2323     try { 
    2324       ImporterOptions options = new ImporterOptions(); 
    2325       options.setSplitChannels(true); 
    2326       options.setId(path); 
    2327       imps = BF.openImagePlus(options); 
    2328     } 
    2329     catch (IOException e) { 
    2330       fail(e.getMessage()); 
    2331     } 
    2332     catch (FormatException e) { 
    2333       fail(e.getMessage()); 
    2334     } 
    2335  
    2336     // one image per channel 
    2337     impsCountTest(imps,sizeC); 
    2338      
    2339     imagesInCztOrderTest(imps,sizeX,sizeY,sizeZ,sizeC,sizeT); 
    2340   } 
    2341    
     2401    // note - can't split channels on a virtual stack. no need to test it. 
     2402    splitChannelsTester(); 
     2403  } 
     2404 
    23422405  @Test 
    23432406  public void testSplitFocalPlanes() 
    23442407  { 
    2345     final int sizeX = 50, sizeY = 20, sizeZ = 5, sizeC = 3, sizeT = 7; 
    2346      
    2347     final String path = constructFakeFilename("splitZ", 
    2348       FormatTools.UINT8, sizeX, sizeY, sizeZ, sizeC, sizeT, -1, false, -1, false, -1); 
    2349  
    2350     // open image 
    2351     ImagePlus[] imps = null; 
    2352      
    2353     try { 
    2354       ImporterOptions options = new ImporterOptions(); 
    2355       options.setSplitFocalPlanes(true); 
    2356       options.setId(path); 
    2357       imps = BF.openImagePlus(options); 
    2358     } 
    2359     catch (IOException e) { 
    2360       fail(e.getMessage()); 
    2361     } 
    2362     catch (FormatException e) { 
    2363       fail(e.getMessage()); 
    2364     } 
    2365      
    2366     // one image per focal plane 
    2367     impsCountTest(imps,sizeZ); 
    2368  
    2369     imagesInZctOrderTest(imps,sizeX,sizeY,sizeZ,sizeC,sizeT); 
    2370   } 
    2371    
     2408    splitFocalPlanesTester(); 
     2409  } 
     2410 
    23722411  @Test 
    23732412  public void testSplitTimepoints() 
    23742413  { 
    2375     final int sizeX = 50, sizeY = 20, sizeZ = 5, sizeC = 3, sizeT = 7; 
    2376    
    2377     final String path = constructFakeFilename("splitT", 
    2378       FormatTools.UINT8, 50, 20, sizeZ, sizeC, sizeT, -1, false, -1, false, -1); 
    2379  
    2380     // open image 
    2381     ImagePlus[] imps = null; 
    2382      
    2383     try { 
    2384       ImporterOptions options = new ImporterOptions(); 
    2385       options.setSplitTimepoints(true); 
    2386       options.setId(path); 
    2387       imps = BF.openImagePlus(options); 
    2388     } 
    2389     catch (IOException e) { 
    2390       fail(e.getMessage()); 
    2391     } 
    2392     catch (FormatException e) { 
    2393       fail(e.getMessage()); 
    2394     } 
    2395      
    2396     // one image per time point 
    2397     impsCountTest(imps,sizeT); 
    2398  
    2399     imagesInTczOrderTest(imps,sizeX,sizeY,sizeZ,sizeC,sizeT); 
    2400   } 
    2401  
    2402   @Test 
    2403   public void testMacros() 
    2404   { 
    2405     //IJ.runMacro("Bio-Formats Importer", "open=int8&pixelType=int8&sizeZ=3&sizeC=5&sizeT=7&sizeY=50.fake merge_channels stack_order=Default"); 
    2406     fail("unimplemented"); 
     2414    splitTimepointsTester(); 
    24072415  } 
    24082416   
     
    24102418  public void testComboCropAutoscale() 
    24112419  { 
     2420    // note - crop and autoscale both don't work with virtualStacks. No need to test virtual here. 
     2421     
    24122422    // try a simple test: single small byte type image  
    24132423    comboCropAndAutoscaleTester(FormatTools.UINT8,240,240,1,1,1,70,40,25); 
     
    24242434  public void testComboConcatColorize() 
    24252435  { 
     2436    // note - concat doesn't work with virtualStacks. No need to test virtual here. 
     2437     
    24262438    fail("unimplemented"); 
    24272439  } 
     
    24302442  public void testComboConcatSplitFocalPlanes() 
    24312443  { 
     2444    // note - concat and split both don't work with virtualStacks. No need to test virtual here. 
     2445     
    24322446    comboConcatSplitFocalPlanesTester(); 
    24332447  } 
     
    24362450  public void testComboConcatSplitChannels() 
    24372451  { 
     2452    // note - concat and split both don't work with virtualStacks. No need to test virtual here. 
     2453 
    24382454    comboConcatSplitChannelsTester(); 
    24392455  } 
     
    24422458  public void testComboConcatSplitTimepoints() 
    24432459  { 
     2460    // note - concat and split both don't work with virtualStacks. No need to test virtual here. 
     2461 
    24442462    comboConcatSplitTimepointsTester(); 
    24452463  } 
     
    24482466  public void testComboColorizeSplit() 
    24492467  { 
     2468    // note - split both doesn't work with virtualStacks. No need to test virtual here. 
     2469     
    24502470    fail("unimplemented"); 
    24512471  } 
     
    24542474  public void testComboConcatColorizeSplit() 
    24552475  { 
     2476    // note - concat and split both don't work with virtualStacks. No need to test virtual here. 
     2477    
    24562478    fail("unimplemented"); 
    24572479  } 
     
    24602482  public void testComboManyOptions() 
    24612483  { 
     2484    // note - crop and setTStep both don't work with virtualStacks. No need to test virtual here. 
     2485 
    24622486    int pixType = FormatTools.UINT16, sizeX = 106, sizeY = 33, sizeZ = 3, sizeC = 5, sizeT = 7; 
    24632487    int cropOriginX = 0, cropOriginY = 0, cropSizeX = 55, cropSizeY = 16, start = 1, stepBy = 2; 
     
    25832607  } 
    25842608 
     2609  // TODO - make a virtual case when working 
    25852610  @Test 
    25862611  public void testColorizeSubcases() 
     
    26572682  } 
    26582683 
     2684  // TODO - make a virtual case when working 
    26592685  @Test 
    26602686  public void testCompositeSubcases() 
Note: See TracChangeset for help on using the changeset viewer.