Changeset 6265


Ignore:
Timestamp:
05/10/10 18:55:19 (10 years ago)
Author:
curtis
Message:

Progress on Bio-Formats Importer refactoring and tests.

Location:
trunk/components/loci-plugins
Files:
24 edited
1 moved

Legend:

Unmodified
Added
Removed
  • trunk/components/loci-plugins/src/loci/plugins/BF.java

    r6247 r6265  
    3333import loci.formats.FormatException; 
    3434import loci.plugins.in.ImagePlusReader; 
     35import loci.plugins.in.ImportProcess; 
    3536import loci.plugins.in.ImporterOptions; 
    3637import loci.plugins.in.ImporterPrompter; 
     
    6869    options.setQuiet(true); 
    6970    options.setWindowless(true); 
    70     new ImporterPrompter(options).showDialogs(); 
    71     ImagePlusReader reader = new ImagePlusReader(options); 
     71    ImportProcess process = new ImportProcess(options); 
     72    new ImporterPrompter(process).showDialogs();//TEMP 
     73    ImagePlusReader reader = new ImagePlusReader(process); 
    7274    return reader.openImagePlus(); 
    7375  } 
  • trunk/components/loci-plugins/src/loci/plugins/colorize/Colorizer.java

    r6229 r6265  
    4343 
    4444import loci.formats.FormatTools; 
    45 import loci.plugins.in.ImporterOptions; 
     45import loci.plugins.in.ImportProcess; 
    4646import loci.plugins.prefs.OptionsDialog; 
    4747import loci.plugins.util.ImagePlusTools; 
     
    217217        } 
    218218 
    219         ImporterOptions options = null; 
     219        ImportProcess process = null; 
    220220        try { 
    221221          // TODO: remove dependency on importer package 
    222           options = new ImporterOptions(); 
     222          process = new ImportProcess(); 
    223223        } 
    224224        catch (IOException exc) { 
     
    227227 
    228228        if (mergeOption == null) { 
    229           MergeDialog mergeDialog = new MergeDialog(options, num); 
     229          MergeDialog mergeDialog = new MergeDialog(process, num); 
    230230          int status = mergeDialog.showDialog(); 
    231231          if (status == OptionsDialog.STATUS_OK) { 
    232             mergeOption = options.getMergeOption(); 
     232            mergeOption = process.getOptions().getMergeOption(); 
    233233          } 
    234234        } 
  • trunk/components/loci-plugins/src/loci/plugins/colorize/CustomColorChooser.java

    r6229 r6265  
    3131import java.awt.Color; 
    3232import java.awt.Dimension; 
    33 import java.awt.Graphics; 
    3433import java.awt.GridBagConstraints; 
    3534import java.awt.Insets; 
  • trunk/components/loci-plugins/src/loci/plugins/colorize/MergeDialog.java

    r6229 r6265  
    2727 
    2828import ij.gui.GenericDialog; 
    29  
    30 import loci.plugins.prefs.OptionsDialog; 
     29import loci.plugins.in.ImportProcess; 
     30import loci.plugins.in.ImporterDialog; 
    3131import loci.plugins.in.ImporterOptions; 
    3232 
     
    3838 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/importer/MergeDialog.java">SVN</a></dd></dl> 
    3939 */ 
    40 public class MergeDialog extends OptionsDialog { 
     40public class MergeDialog extends ImporterDialog { 
    4141 
    4242  // -- Fields -- 
    4343 
    44   /** LOCI plugins configuration. */ 
    45   protected ImporterOptions options; 
    46  
    47   protected int[] nums; 
     44  protected String[] mergeOptions; 
    4845 
    4946  // -- Constructor -- 
    5047 
    5148  /** Creates a merge options dialog for the Bio-Formats Importer. */ 
    52   public MergeDialog(ImporterOptions options, int[] nums) { 
    53     super(options); 
    54     this.options = options; 
    55     this.nums = nums; 
     49  public MergeDialog(ImportProcess process, int[] nums) { 
     50    super(process); 
     51     
     52    mergeOptions = new String[7]; 
     53    mergeOptions[6] = options.getDefaultValue(ImporterOptions.KEY_MERGE_OPTION); 
     54    for (int i=0; i<6; i++) { 
     55      mergeOptions[i] = nums[i] + " planes, " + (i + 2) + " channels per plane"; 
     56    } 
    5657  } 
    5758 
    58   // -- OptionsDialog methods -- 
     59  // -- ImporterDialog methods -- 
    5960 
    60   /** 
    61    * Gets the merge settings from macro options, or user prompt if necessary. 
    62    * 
    63    * @return status of operation 
    64    */ 
    65   public int showDialog() { 
    66     if (options.isWindowless()) return STATUS_OK; 
     61  protected boolean needPrompt() { 
     62    return !process.isWindowless(); 
     63  } 
     64 
     65  protected GenericDialog constructDialog() { 
    6766    GenericDialog gd = new GenericDialog("Merging Options..."); 
    6867 
    6968    String mergeOptionLabel = 
    7069      options.getLabel(ImporterOptions.KEY_MERGE_OPTION); 
    71     String mergeOptionDefault = 
    72       options.getDefaultValue(ImporterOptions.KEY_MERGE_OPTION); 
    73  
    74     String[] mergeOptions = new String[7]; 
    75     mergeOptions[6] = mergeOptionDefault; 
    76     for (int i=0; i<6; i++) { 
    77       mergeOptions[i] = nums[i] + " planes, " + (i + 2) + " channels per plane"; 
    78     } 
    7970 
    8071    gd.addMessage("How would you like to merge this data?"); 
     72    String mergeOptionDefault = mergeOptions[mergeOptions.length - 1]; 
    8173    gd.addChoice(mergeOptionLabel, mergeOptions, mergeOptionDefault); 
    82     gd.showDialog(); 
    83     if (gd.wasCanceled()) return STATUS_CANCELED; 
    8474 
     75    return gd; 
     76  } 
     77   
     78  protected boolean harvestResults(GenericDialog gd) { 
    8579    options.setMergeOption(mergeOptions[gd.getNextChoiceIndex()]); 
    86  
    87     return STATUS_OK; 
     80    return true; 
    8881  } 
    8982 
  • trunk/components/loci-plugins/src/loci/plugins/in/Concatenator.java

    r6229 r6265  
    4646public class Concatenator { 
    4747 
    48   protected ImporterOptions options; 
     48  protected ImportProcess process; 
    4949 
    50   public Concatenator(ImporterOptions options) { 
    51     this.options = options; 
     50  public Concatenator(ImportProcess process) { 
     51    this.process = process; 
    5252  } 
    5353 
    5454  /** Concatenates the list of images as appropriate. */ 
    5555  public List<ImagePlus> concatenate(List<ImagePlus> imps, String stackOrder) { 
     56    ImporterOptions options = process.getOptions(); 
     57 
    5658    if (!options.isConcatenate()) return imps; 
    5759 
    58     IFormatReader r = options.getReader(); 
     60    IFormatReader r = process.getReader(); 
    5961 
    6062    List<Integer> widths = new ArrayList<Integer>(); 
     
    9698    } 
    9799 
    98     boolean splitC = options.isSplitChannels(); 
    99     boolean splitZ = options.isSplitFocalPlanes(); 
    100     boolean splitT = options.isSplitTimepoints(); 
     100    //boolean splitC = options.isSplitChannels(); 
     101    //boolean splitZ = options.isSplitFocalPlanes(); 
     102    //boolean splitT = options.isSplitTimepoints(); 
    101103 
    102104    for (int j=0; j<newImps.size(); j++) { 
  • trunk/components/loci-plugins/src/loci/plugins/in/CropDialog.java

    r6247 r6265  
    4444 
    4545  /** Creates a crop options dialog for the Bio-Formats Importer. */ 
    46   public CropDialog(ImporterOptions options) { 
    47     super(options); 
     46  public CropDialog(ImportProcess process) { 
     47    super(process); 
    4848  } 
    4949   
     
    5252  @Override 
    5353  protected boolean needPrompt() { 
    54     return !options.isWindowless() && options.doCrop(); 
     54    return !process.isWindowless() && options.doCrop(); 
    5555  } 
    5656   
    5757  @Override 
    5858  protected GenericDialog constructDialog() { 
    59     // -- CTR TODO - refactor crop-related options into CropOptions class 
    60     // has a normalize(IFormatReader) method 
    61     // call both before and after the dialog here... 
    62  
    63     int seriesCount = options.getSeriesCount(); 
    64     IFormatReader r = options.getReader(); 
     59    int seriesCount = process.getSeriesCount(); 
     60    IFormatReader r = process.getReader(); 
    6561     
    6662    // construct dialog 
     
    7369      if (region == null) 
    7470 
    75       gd.addMessage(options.getSeriesLabel(s).replaceAll("_", " ")); 
     71      gd.addMessage(process.getSeriesLabel(s).replaceAll("_", " ")); 
    7672      gd.addNumericField("X_Coordinate_" + (s + 1), 0, 0); 
    7773      gd.addNumericField("Y_Coordinate_" + (s + 1), 0, 0); 
     
    8581   
    8682  @Override 
    87   protected void harvestResults(GenericDialog gd) { 
    88     int seriesCount = options.getSeriesCount(); 
    89     IFormatReader r = options.getReader(); 
     83  protected boolean harvestResults(GenericDialog gd) { 
     84    int seriesCount = process.getSeriesCount(); 
     85    IFormatReader r = process.getReader(); 
    9086 
    9187    for (int s=0; s<seriesCount; s++) { 
     
    116112      options.setCropRegion(s, region); // in case we got a copy 
    117113    } 
     114 
     115    return true; 
    118116  } 
    119117   
  • trunk/components/loci-plugins/src/loci/plugins/in/DisplayHandler.java

    r6258 r6265  
    6767  // -- Fields -- 
    6868 
     69  protected ImportProcess process; 
    6970  protected ImporterOptions options; 
    7071  protected XMLWindow xmlWindow; 
     
    7273  // -- Constructor -- 
    7374 
    74   public DisplayHandler(ImporterOptions options) { 
    75     this.options = options; 
     75  public DisplayHandler(ImportProcess process) { 
     76    this.process = process; 
     77    options = process.getOptions(); 
    7678  } 
    7779 
     
    8284    if (!options.isShowMetadata()) return null; 
    8385 
    84     String name = options.getIdName(); 
    85     ImporterMetadata meta = options.getOriginalMetadata(); 
     86    String name = process.getIdName(); 
     87    ImporterMetadata meta = process.getOriginalMetadata(); 
    8688    String metaString = meta.getMetadataString("\t"); 
    8789    SearchableWindow metaWindow = new SearchableWindow( 
     
    9698 
    9799    XMLWindow metaWindow = null; 
    98     metaWindow = new XMLWindow("OME Metadata - " + options.getIdName()); 
     100    metaWindow = new XMLWindow("OME Metadata - " + process.getIdName()); 
    99101    Exception exc = null; 
    100102    try { 
    101103      ServiceFactory factory = new ServiceFactory(); 
    102104      OMEXMLService service = factory.getInstance(OMEXMLService.class); 
    103       metaWindow.setXML(service.getOMEXML(options.getOMEMetadata())); 
     105      metaWindow.setXML(service.getOMEXML(process.getOMEMetadata())); 
    104106      WindowTools.placeWindow(metaWindow); 
    105107      metaWindow.setVisible(true); 
     
    139141   */ 
    140142  public void displayNormal(ImagePlus imp) { 
    141 //    IFormatReader r = options.getReader(); 
    142 //    boolean windowless = options.isWindowless(); 
    143  
    144 //    if (!options.isConcatenate() && options.isMergeChannels()) imp.show(); 
    145  
    146     // CTR CHECK 
    147     //if (imp.isVisible() && !options.isVirtual()) { 
    148     //  String mergeOptions = windowless ? options.getMergeOption() : null; 
    149     //  imp = Colorizer.colorize(imp, true, stackOrder, null, r.getSeries(), mergeOptions, options.isViewHyperstack()); 
    150     //  // CTR TODO finish this 
    151     //  if (WindowManager.getCurrentImage().getID() != imp.getID()) imp.close(); 
    152     //} 
    153  
    154     // NB: ImageJ 1.39+ is required for hyperstacks 
    155  
    156 //    if (!options.isConcatenate()) { 
    157 //      boolean hyper = options.isViewHyperstack() || options.isViewBrowser(); 
    158 // 
    159 //      boolean splitC = options.isSplitChannels(); 
    160 //      boolean splitZ = options.isSplitFocalPlanes(); 
    161 //      boolean splitT = options.isSplitTimepoints(); 
    162 // 
    163 //      boolean customColorize = options.isCustomColorize(); 
    164 //      boolean browser = options.isViewBrowser(); 
    165 //      boolean virtual = options.isVirtual(); 
    166 // 
    167 //      if (options.isColorize() || customColorize) { 
    168 //        byte[][][] lut = 
    169 //          Colorizer.makeDefaultLut(imp.getNChannels(), customColorize ? -1 : 0); 
    170 //        imp = Colorizer.colorize(imp, true, stackOrder, lut, r.getSeries(), null, options.isViewHyperstack()); 
    171 //      } 
    172 //      else if (colorModels != null && !browser && !virtual) { 
    173 //        byte[][][] lut = new byte[colorModels.length][][]; 
    174 //        for (int channel=0; channel<lut.length; channel++) { 
    175 //          lut[channel] = new byte[3][256]; 
    176 //          colorModels[channel].getReds(lut[channel][0]); 
    177 //          colorModels[channel].getGreens(lut[channel][1]); 
    178 //          colorModels[channel].getBlues(lut[channel][2]); 
    179 //        } 
    180 //        imp = Colorizer.colorize(imp, true, 
    181 //          stackOrder, lut, r.getSeries(), null, hyper); 
    182 //      } 
    183 // 
    184 //      // CTR FIXME 
    185 //      if (splitC || splitZ || splitT) { 
    186 //        imp = Slicer.reslice(imp, splitC, splitZ, splitT, hyper, stackOrder); 
    187 //      } 
    188 //    } 
    189  
    190143    imp.show(); 
    191144  } 
     
    197150    displayNormal(imp); 
    198151 
    199 //    IFormatReader r = options.getReader(); 
    200 //    String[] dimTypes = r.getChannelDimTypes(); 
    201 //    int[] dimLengths = r.getChannelDimLengths(); 
    202 //    new DataBrowser(imp, null, dimTypes, dimLengths, xmlWindow); 
     152    // CTR FIXME 
     153     
     154    //IFormatReader r = options.getReader(); 
     155    //String[] dimTypes = r.getChannelDimTypes(); 
     156    //int[] dimLengths = r.getChannelDimLengths(); 
     157    //new DataBrowser(imp, null, dimTypes, dimLengths, xmlWindow); 
    203158  } 
    204159 
     
    206161    WindowManager.setTempCurrentImage(imp); 
    207162 
    208     IFormatReader r = options.getReader(); 
     163    IFormatReader r = process.getReader(); 
    209164    ReflectedUniverse ru = new ReflectedUniverse(); 
    210165    try { 
     
    226181      WindowTools.reportException(exc, options.isQuiet(), 
    227182        "Sorry, there was a problem interfacing with Image5D"); 
    228       return; 
    229183    } 
    230184  } 
     
    249203      WindowTools.reportException(exc, options.isQuiet(), 
    250204        "Sorry, there was a problem interfacing with View5D"); 
    251       return; 
    252205    } 
    253206  } 
     
    262215      ru.exec("dataset = new Dataset(name, pattern)"); 
    263216      ru.setVar("imp", imp); 
    264       // TODO: finish VisBio logic 
     217      // CTR TODO: finish VisBio logic 
    265218    } 
    266219    catch (ReflectException exc) { 
    267220      WindowTools.reportException(exc, options.isQuiet(), 
    268221        "Sorry, there was a problem interfacing with VisBio"); 
    269       return; 
    270222    } 
    271223  } 
     
    273225  public void displayROIs(ImagePlus[] imps) { 
    274226    if (!options.showROIs()) return; 
    275     ROIHandler.openROIs(options.getOMEMetadata(), imps); 
     227    ROIHandler.openROIs(process.getOMEMetadata(), imps); 
    276228  } 
    277229 
  • trunk/components/loci-plugins/src/loci/plugins/in/FilePatternDialog.java

    r6247 r6265  
    4444 
    4545  /** Creates a file pattern dialog for the Bio-Formats Importer. */ 
    46   public FilePatternDialog(ImporterOptions options) { 
    47     super(options); 
     46  public FilePatternDialog(ImportProcess process) { 
     47    super(process); 
    4848  } 
    4949   
     
    5252  @Override 
    5353  protected boolean needPrompt() { 
    54     return !options.isWindowless() && options.isGroupFiles(); 
     54    return !process.isWindowless() && options.isGroupFiles(); 
    5555  } 
    5656   
     
    8888   
    8989  @Override 
    90   protected void harvestResults(GenericDialog gd) { 
     90  protected boolean harvestResults(GenericDialog gd) { 
    9191    String id = gd.getNextString(); 
    9292    options.setId(id); 
     93    return true; 
    9394  } 
    9495 
  • trunk/components/loci-plugins/src/loci/plugins/in/IdDialog.java

    r6247 r6265  
    3030import ij.io.OpenDialog; 
    3131import loci.common.Location; 
    32 import loci.plugins.BF; 
    33 import loci.plugins.prefs.OptionsDialog; 
    3432 
    3533/** 
     
    4038 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/in/IdDialog.java">SVN</a></dd></dl> 
    4139 */ 
    42 public class IdDialog extends OptionsDialog { 
    43  
     40public class IdDialog extends ImporterDialog { 
     41   
    4442  // -- Fields -- 
    4543 
    46   protected ImporterOptions options; 
     44  private OpenDialog od; 
    4745 
    4846  // -- Constructor -- 
    4947 
    5048  /** Creates an id chooser dialog for the Bio-Formats Importer. */ 
    51   public IdDialog(ImporterOptions options) { 
    52     super(options); 
    53     this.options = options; 
     49  public IdDialog(ImportProcess process) { 
     50    super(process); 
    5451  } 
    5552   
    56   // -- IdDialog methods -- 
     53  // -- ImporterDialog methods -- 
    5754 
     55  @Override 
     56  protected boolean needPrompt() { 
     57    return !process.isWindowless() && options.getId() == null; 
     58  } 
     59   
     60  @Override 
     61  protected GenericDialog constructDialog() { 
     62    GenericDialog gd = null; 
     63    if (options.isHTTP()) { 
     64      gd = new GenericDialog("Bio-Formats URL"); 
     65      gd.addStringField("URL: ", "http://", 30); 
     66    } 
     67    return gd; 
     68  } 
     69   
    5870  /** 
    59    * Gets the id (filename, URL, etc.) to open from macro options, 
    60    * or user prompt if necessary. 
     71   * Asks user whether Bio-Formats should automatically check for upgrades, 
     72   * and if so, checks for an upgrade and prompts user to install it. 
    6173   * 
    6274   * @return status of operation 
    6375   */ 
    64   public int showDialogLocal() { 
    65     if (options.isFirstTime() && IJ.isMacOSX() && !options.isQuiet()) { 
    66       String osVersion = System.getProperty("os.version"); 
    67       if (osVersion == null || 
    68         osVersion.startsWith("10.4.") || 
    69         osVersion.startsWith("10.3.") || 
    70         osVersion.startsWith("10.2.")) 
    71       { 
    72         // present user with one-time dialog box 
    73         IJ.showMessage("Bio-Formats", 
    74           "One-time warning: There is a bug in Java on Mac OS X with the " + 
    75           "native file chooser\nthat crashes ImageJ if you click on a file " + 
    76           "in CXD, IPW, OIB or ZVI format while in\ncolumn view mode. You " + 
    77           "can work around the problem in one of two ways:\n \n" + 
    78           "    1. Switch to list view (press Command+2)\n" + 
    79           "    2. Check \"Use JFileChooser to Open/Save\" under " + 
    80           "Edit>Options>Input/Output..."); 
     76  @Override 
     77  protected boolean displayDialog(GenericDialog gd) { 
     78    if (options.isLocal()) { 
     79      if (options.isFirstTime() && IJ.isMacOSX() && !options.isQuiet()) { 
     80        String osVersion = System.getProperty("os.version"); 
     81        if (osVersion == null || 
     82          osVersion.startsWith("10.4.") || 
     83          osVersion.startsWith("10.3.") || 
     84          osVersion.startsWith("10.2.")) 
     85        { 
     86          // present user with one-time dialog box 
     87          IJ.showMessage("Bio-Formats", 
     88            "One-time warning: There is a bug in Java on Mac OS X with the " + 
     89            "native file chooser\nthat crashes ImageJ if you click on a file " + 
     90            "in CXD, IPW, OIB or ZVI format while in\ncolumn view mode. You " + 
     91            "can work around the problem in one of two ways:\n \n" + 
     92            "    1. Switch to list view (press Command+2)\n" + 
     93            "    2. Check \"Use JFileChooser to Open/Save\" under " + 
     94            "Edit>Options>Input/Output..."); 
     95        } 
     96      } 
     97 
     98      String idLabel = options.getLabel(ImporterOptions.KEY_ID); 
     99      od = new OpenDialog(idLabel, options.getId()); 
     100      if (od.getFileName() == null) return false; 
     101    } 
     102    else if (options.isHTTP()) { 
     103      gd.showDialog(); 
     104      if (gd.wasCanceled()) return false; 
     105    } 
     106    return true; 
     107  } 
     108 
     109  @Override 
     110  protected boolean harvestResults(GenericDialog gd) { 
     111    String id = null; 
     112    if (options.isLocal()) { 
     113      String dir = od.getDirectory(); 
     114      String name = od.getFileName(); 
     115      if (dir != null || name == null)  
     116      id = dir + name; 
     117       
     118      // verify validity 
     119      Location idLoc = new Location(id); 
     120      if (!idLoc.exists() && !id.toLowerCase().endsWith(".fake")) { 
     121        if (!options.isQuiet()) { 
     122          IJ.error("Bio-Formats", 
     123            "The specified file (" + id + ") does not exist."); 
     124        } 
     125        return false; 
    81126      } 
    82127    } 
    83  
    84     String id = options.getId(); 
    85     if (id == null) { 
    86       // construct and display dialog (or grab from macro options) 
    87       String idLabel = options.getLabel(ImporterOptions.KEY_ID); 
    88       OpenDialog od = new OpenDialog(idLabel, id); 
    89  
    90       // harvest results 
    91       String dir = od.getDirectory(); 
    92       String name = od.getFileName(); 
    93       if (dir == null || name == null) return STATUS_CANCELED; 
    94       id = dir + name; 
    95     } 
    96  
    97     // verify validity 
    98     Location idLoc = new Location(id); 
    99     if (!idLoc.exists() && !id.toLowerCase().endsWith(".fake")) { 
    100       if (!options.isQuiet()) { 
    101         IJ.error("Bio-Formats", 
    102           "The specified file (" + id + ") does not exist."); 
     128    else if (options.isHTTP()) { 
     129            id = gd.getNextString(); 
     130      if (id == null) { 
     131        if (!options.isQuiet()) IJ.error("Bio-Formats", "No URL was specified."); 
     132        return false; 
    103133      } 
    104       return STATUS_FINISHED; 
    105134    } 
    106135    options.setId(id); 
    107  
    108     return STATUS_OK; 
    109   } 
    110  
    111   /** 
    112    * Gets the URL (id) to open from macro options, 
    113    * or user prompt if necessary. 
    114    * 
    115    * @return status of operation 
    116    */ 
    117   public int showDialogHTTP() { 
    118     String id = options.getId(); 
    119     if (id == null) { 
    120       // construct dialog 
    121       GenericDialog gd = new GenericDialog("Bio-Formats URL"); 
    122       gd.addStringField("URL: ", "http://", 30); 
    123  
    124       // display dialog (or grab from macro options) 
    125       gd.showDialog(); 
    126       if (gd.wasCanceled()) return STATUS_CANCELED; 
    127  
    128       // harvest results 
    129       id = gd.getNextString(); 
    130     } 
    131  
    132     // verify validity 
    133     if (id == null) { 
    134       if (!options.isQuiet()) IJ.error("Bio-Formats", "No URL was specified."); 
    135       return STATUS_FINISHED; 
    136     } 
    137     options.setId(id); 
    138  
    139     return STATUS_OK; 
    140   } 
    141  
    142   // -- OptionsDialog methods -- 
    143  
    144   /** 
    145    * Gets the filename (id) from macro options, or user prompt if necessary. 
    146    * 
    147    * @return status of operation 
    148    */ 
    149   public int showDialog() { 
    150     // verify whether prompt is necessary 
    151     if (options.isWindowless()) { 
    152       BF.debug("IdDialog: skip"); 
    153       return STATUS_OK; 
    154     } 
    155     BF.debug("IdDialog: prompt"); 
    156  
    157     if (options.isLocal()) return showDialogLocal(); 
    158     return showDialogHTTP(); // options.isHTTP() 
     136    return true; 
    159137  } 
    160138 
  • trunk/components/loci-plugins/src/loci/plugins/in/ImagePlusReader.java

    r6258 r6265  
    7676  // -- Fields -- 
    7777 
    78   /** Importer options that control the reader's behavior. */ 
    79   protected ImporterOptions options; 
     78  /** Import process managing Bio-Formats readers and other state. */ 
     79  protected ImportProcess process; 
    8080 
    8181  protected List<StatusListener> listeners = new Vector<StatusListener>(); 
     
    8888   */ 
    8989  public ImagePlusReader() throws IOException { 
    90     this(new ImporterOptions()); 
     90    this(new ImportProcess()); 
    9191  } 
    9292 
    9393  /** Constructs an ImagePlusReader with the given reader. */ 
    94   public ImagePlusReader(ImporterOptions options) { 
    95     this.options = options; 
     94  public ImagePlusReader(ImportProcess process) { 
     95    this.process = process; 
    9696  } 
    9797 
     
    132132    long time = startTime; 
    133133 
    134     ImageProcessorReader r = options.getReader(); 
     134    ImageProcessorReader r = process.getReader(); 
     135    ImporterOptions options = process.getOptions(); 
    135136 
    136137    if (options.isVirtual()) { 
     
    174175 
    175176      // populate other common FileInfo fields 
    176       String idDir = options.getIdLocation() == null ? 
    177         null : options.getIdLocation().getParent(); 
     177      String idDir = process.getIdLocation() == null ? 
     178        null : process.getIdLocation().getParent(); 
    178179      if (idDir != null && !idDir.endsWith(File.separator)) { 
    179180        idDir += File.separator; 
    180181      } 
    181       fi.fileName = options.getIdName(); 
     182      fi.fileName = process.getIdName(); 
    182183      fi.directory = idDir; 
    183184 
     
    216217 
    217218      try { 
    218         options.getOMEMetadata().setPixelsDimensionOrder( 
     219        process.getOMEMetadata().setPixelsDimensionOrder( 
    219220          DimensionOrder.fromString(stackOrder), s); 
    220221      } 
     
    225226        ServiceFactory factory = new ServiceFactory(); 
    226227        OMEXMLService service = factory.getInstance(OMEXMLService.class); 
    227         fi.description = service.getOMEXML(options.getOMEMetadata()); 
     228        fi.description = service.getOMEXML(process.getOMEMetadata()); 
    228229      } 
    229230      catch (DependencyException de) { } 
     
    244245            String label = constructSliceLabel( 
    245246              new ChannelMerger(r).getIndex(pos[0], pos[1], pos[2]), 
    246               new ChannelMerger(r), options.getOMEMetadata(), s, 
     247              new ChannelMerger(r), process.getOMEMetadata(), s, 
    247248              options.getZCount(s), options.getCCount(s), 
    248249              options.getTCount(s)); 
     
    253254          for (int j=0; j<r.getImageCount(); j++) { 
    254255            String label = constructSliceLabel(j, r, 
    255               options.getOMEMetadata(), s, options.getZCount(s), 
     256              process.getOMEMetadata(), s, options.getZCount(s), 
    256257              options.getCCount(s), options.getTCount(s)); 
    257258            virtualStackB.addSlice(label); 
     
    278279 
    279280          String label = constructSliceLabel(i, r, 
    280             options.getOMEMetadata(), s, options.getZCount(s), 
     281            process.getOMEMetadata(), s, options.getZCount(s), 
    281282            options.getCCount(s), options.getTCount(s)); 
    282283 
     
    369370    if (stack == null) return null; 
    370371 
    371     String seriesName = options.getOMEMetadata().getImageName(series); 
    372     String file = options.getCurrentFile(); 
    373     IMetadata meta = options.getOMEMetadata(); 
     372    ImporterOptions options = process.getOptions(); 
     373    String seriesName = process.getOMEMetadata().getImageName(series); 
     374    String file = process.getCurrentFile(); 
     375    IMetadata meta = process.getOMEMetadata(); 
    374376    int cCount = options.getCCount(series); 
    375377    int zCount = options.getZCount(series); 
    376378    int tCount = options.getTCount(series); 
    377     IFormatReader r = options.getReader(); 
     379    IFormatReader r = process.getReader(); 
    378380     
    379381    if (cCount == 0) cCount = r.getEffectiveSizeC(); 
     
    390392 
    391393    // place metadata key/value pairs in ImageJ's info field 
    392     String metadata = options.getOriginalMetadata().toString(); 
     394    String metadata = process.getOriginalMetadata().toString(); 
    393395    imp.setProperty("Info", metadata); 
    394396 
     
    415417    imp.setDimensions(imp.getStackSize() / (nSlices * nFrames), 
    416418      nSlices, nFrames); 
     419 
     420//    IFormatReader r = options.getReader(); 
     421//    boolean windowless = options.isWindowless(); 
     422 
     423    // CTR CHECK 
     424    //if (imp.isVisible() && !options.isVirtual()) { 
     425    //  String mergeOptions = windowless ? options.getMergeOption() : null; 
     426    //  imp = Colorizer.colorize(imp, true, stackOrder, null, r.getSeries(), mergeOptions, options.isViewHyperstack()); 
     427    //  // CTR TODO finish this 
     428    //  if (WindowManager.getCurrentImage().getID() != imp.getID()) imp.close(); 
     429    //} 
     430 
     431    // NB: ImageJ 1.39+ is required for hyperstacks 
     432 
     433//    if (!options.isConcatenate()) { 
     434//      boolean hyper = options.isViewHyperstack() || options.isViewBrowser(); 
     435// 
     436//      boolean splitC = options.isSplitChannels(); 
     437//      boolean splitZ = options.isSplitFocalPlanes(); 
     438//      boolean splitT = options.isSplitTimepoints(); 
     439// 
     440//      boolean customColorize = options.isCustomColorize(); 
     441//      boolean browser = options.isViewBrowser(); 
     442//      boolean virtual = options.isVirtual(); 
     443// 
     444//      if (options.isColorize() || customColorize) { 
     445//        byte[][][] lut = 
     446//          Colorizer.makeDefaultLut(imp.getNChannels(), customColorize ? -1 : 0); 
     447//        imp = Colorizer.colorize(imp, true, stackOrder, lut, r.getSeries(), null, options.isViewHyperstack()); 
     448//      } 
     449//      else if (colorModels != null && !browser && !virtual) { 
     450//        byte[][][] lut = new byte[colorModels.length][][]; 
     451//        for (int channel=0; channel<lut.length; channel++) { 
     452//          lut[channel] = new byte[3][256]; 
     453//          colorModels[channel].getReds(lut[channel][0]); 
     454//          colorModels[channel].getGreens(lut[channel][1]); 
     455//          colorModels[channel].getBlues(lut[channel][2]); 
     456//        } 
     457//        imp = Colorizer.colorize(imp, true, 
     458//          stackOrder, lut, r.getSeries(), null, hyper); 
     459//      } 
     460// 
     461//      // CTR FIXME 
     462//      if (splitC || splitZ || splitT) { 
     463//        imp = Slicer.reslice(imp, splitC, splitZ, splitT, hyper, stackOrder); 
     464//      } 
     465//    } 
    417466 
    418467    return imp; 
  • trunk/components/loci-plugins/src/loci/plugins/in/ImportProcess.java

    r6247 r6265  
    3535import loci.common.services.ServiceFactory; 
    3636import loci.formats.ChannelSeparator; 
     37import loci.formats.FilePattern; 
    3738import loci.formats.FileStitcher; 
    3839import loci.formats.FormatException; 
     
    5253 
    5354/** 
    54  * Helper class for reading image data. 
     55 * Helper class for managing Bio-Formats readers and associated metadata. 
    5556 * 
    5657 * <dl><dt><b>Source code:</b></dt> 
    57  * <dd><a href="https://skyking.microscopy.wisc.edu/trac/java/browser/trunk/components/loci-plugins/src/loci/plugins/in/ImporterReader.java">Trac</a>, 
    58  * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/in/ImporterReader.java">SVN</a></dd></dl> 
     58 * <dd><a href="https://skyking.microscopy.wisc.edu/trac/java/browser/trunk/components/loci-plugins/src/loci/plugins/in/ImporterPixels.java">Trac</a>, 
     59 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/in/ImporterPixels.java">SVN</a></dd></dl> 
    5960 */ 
    60 public class ImporterReader { 
     61public class ImportProcess { 
    6162 
    6263  // -- Fields -- 
     
    6869  protected Location idLoc; 
    6970 
    70   protected String currentFile; 
    71  
    72   protected ImageProcessorReader r; 
     71  private IFormatReader baseReader; 
     72  protected ImageProcessorReader reader; 
    7373  protected VirtualReader virtualReader; 
    7474 
    7575  protected IMetadata meta; 
    7676 
    77   private IFormatReader baseReader; 
     77  private ImporterMetadata metadata; 
     78 
     79  /** A descriptive label for each series. */ 
     80  private String[] seriesLabels; 
    7881 
    7982  // -- Constructors -- 
    8083 
    81   public ImporterReader() throws IOException { 
     84  public ImportProcess() throws IOException { 
    8285    this(new ImporterOptions()); 
    8386  } 
    8487 
    85   public ImporterReader(ImporterOptions options) { 
     88  public ImportProcess(ImporterOptions options) { 
    8689    this.options = options; 
     90  } 
     91 
     92  // -- ImportProcess API methods -- 
     93 
     94  public ImporterOptions getOptions() { return options; } 
     95 
     96  // CTR TEMP 
     97  public void go() { 
    8798    computeNameAndLocation(); 
    8899    createBaseReader(); 
    89100  } 
    90101 
    91   // -- ImporterReader API methods -- 
    92  
    93102  // CTR TEMP 
    94103  public void prepareStuff() throws FormatException, IOException { 
     104    if (!options.isQuiet()) IJ.showStatus("Analyzing " + getIdName()); 
    95105    baseReader.setMetadataFiltered(true); 
    96106    baseReader.setOriginalMetadataPopulated(true); 
    97107    baseReader.setGroupFiles(!options.isUngroupFiles()); 
    98108    baseReader.setId(options.getId()); 
    99     currentFile = baseReader.getCurrentFile(); 
    100109  } 
    101110 
    102111  // CTR TEMP 
    103   /** Initializes the ImagePlusReader derived value. */ 
    104112  public void initializeReader() throws FormatException, IOException { 
    105     if (options.isGroupFiles()) baseReader = new FileStitcher(baseReader, true); 
     113    if (options.isGroupFiles()) { 
     114      FileStitcher fileStitcher = new FileStitcher(baseReader); 
     115      baseReader = fileStitcher; 
     116 
     117      // overwrite base filename with file pattern 
     118      String id = options.getId(); 
     119      if (id == null) id = getCurrentFile(); 
     120      FilePattern fp = fileStitcher.findPattern(id); 
     121      if (fp.isValid()) id = fp.getPattern(); 
     122      else id = getCurrentFile(); 
     123      options.setId(id); 
     124      fileStitcher.setUsingPatternIds(true); 
     125    } 
     126 
    106127    baseReader.setId(options.getId()); 
    107128    if (options.isVirtual() || !options.isMergeChannels() || 
     
    111132    } 
    112133    virtualReader = new VirtualReader(baseReader); 
    113     r = new ImageProcessorReader(virtualReader); 
    114     r.setId(options.getId()); 
     134    reader = new ImageProcessorReader(virtualReader); 
     135    reader.setId(options.getId()); 
    115136  } 
    116137 
    117138  public boolean isWindowless() { 
     139    if (options.isWindowless()) return true; // globally windowless 
    118140    return baseReader != null && LociPrefs.isWindowless(baseReader); 
    119141  } 
     
    204226  } 
    205227 
     228  // CTR TODO - refactor how ImportProcess works 
     229  public String getIdName() { return idName; } 
     230  public Location getIdLocation() { return idLoc; } 
     231  public String getCurrentFile() { return baseReader.getCurrentFile(); } 
     232  public ImageProcessorReader getReader() { return reader; } 
     233  public IMetadata getOMEMetadata() { return meta; } 
     234  public ImporterMetadata getOriginalMetadata() { return metadata; } 
     235  public int getSeriesCount() { return getReader().getSeriesCount(); } 
     236 
     237  public String getSeriesLabel(int s) { 
     238    if (seriesLabels == null) computeSeriesLabels(); 
     239    return seriesLabels[s]; 
     240  } 
     241 
     242  /** Initializes the seriesLabels derived value. */ 
     243  private void computeSeriesLabels() { 
     244    int seriesCount = getSeriesCount(); 
     245    seriesLabels = new String[seriesCount]; 
     246    for (int i=0; i<seriesCount; i++) { 
     247      getReader().setSeries(i); 
     248      StringBuffer sb = new StringBuffer(); 
     249      sb.append("Series_"); 
     250      sb.append((i + 1)); 
     251      sb.append(": "); 
     252      String name = getOMEMetadata().getImageName(i); 
     253      if (name != null && name.length() > 0) { 
     254        sb.append(name); 
     255        sb.append(": "); 
     256      } 
     257      sb.append(getReader().getSizeX()); 
     258      sb.append(" x "); 
     259      sb.append(getReader().getSizeY()); 
     260      sb.append("; "); 
     261      sb.append(getReader().getImageCount()); 
     262      sb.append(" plane"); 
     263      if (getReader().getImageCount() > 1) { 
     264        sb.append("s"); 
     265        if (getReader().isOrderCertain()) { 
     266          sb.append(" ("); 
     267          boolean first = true; 
     268          if (getReader().getEffectiveSizeC() > 1) { 
     269            sb.append(getReader().getEffectiveSizeC()); 
     270            sb.append("C"); 
     271            first = false; 
     272          } 
     273          if (getReader().getSizeZ() > 1) { 
     274            if (!first) sb.append(" x "); 
     275            sb.append(getReader().getSizeZ()); 
     276            sb.append("Z"); 
     277            first = false; 
     278          } 
     279          if (getReader().getSizeT() > 1) { 
     280            if (!first) sb.append(" x "); 
     281            sb.append(getReader().getSizeT()); 
     282            sb.append("T"); 
     283            first = false; 
     284          } 
     285          sb.append(")"); 
     286        } 
     287      } 
     288      seriesLabels[i] = sb.toString(); 
     289      //seriesLabels[i] = seriesLabels[i].replaceAll(" ", "_"); 
     290    } 
     291  } 
     292 
     293  // -- CTR TEMP - methods to munge around with state -- 
     294 
     295  protected void saveDefaults() { 
     296    // save options as new defaults 
     297    if (!options.isQuiet()) options.setFirstTime(false); 
     298    options.saveOptions(); 
     299  } 
     300 
     301  /** Initializes the ImporterMetadata derived value. */ 
     302  protected void initializeMetadata() { 
     303    // only prepend a series name prefix to the metadata keys if multiple 
     304    // series are being opened 
     305    int seriesCount = getSeriesCount(); 
     306    int numEnabled = 0; 
     307    for (int s=0; s<seriesCount; s++) { 
     308      if (options.isSeriesOn(s)) numEnabled++; 
     309    } 
     310    metadata = new ImporterMetadata(getReader(), this, numEnabled > 1); 
     311  } 
     312 
    206313} 
  • trunk/components/loci-plugins/src/loci/plugins/in/Importer.java

    r6258 r6265  
    3434import loci.plugins.BF; 
    3535import loci.plugins.LociImporter; 
    36 import loci.plugins.util.ROIHandler; 
    3736import loci.plugins.util.WindowTools; 
    3837 
     
    7372      if (plugin.canceled) return; 
    7473 
     74      ImportProcess process = new ImportProcess(options); 
     75 
    7576      BF.debug("display option dialogs"); 
    76       showOptionDialogs(options); 
     77      showDialogs(process); 
    7778      if (plugin.canceled) return; 
    7879 
    7980      BF.debug("display metadata"); 
    80       DisplayHandler displayHandler = new DisplayHandler(options); 
     81      DisplayHandler displayHandler = new DisplayHandler(process); 
    8182      displayHandler.displayOriginalMetadata(); 
    8283      displayHandler.displayOMEXML(); 
    8384 
    8485      BF.debug("read pixel data"); 
    85       ImagePlusReader ipr = new ImagePlusReader(options); 
    86       ImagePlus[] imps = readPixels(ipr, options, displayHandler); 
     86      ImagePlusReader reader = new ImagePlusReader(process); 
     87      ImagePlus[] imps = readPixels(reader, options, displayHandler); 
    8788 
    8889      BF.debug("display pixels"); 
     
    9394 
    9495      BF.debug("finish"); 
    95       finish(options); 
     96      finish(process); 
    9697    } 
    9798    catch (FormatException exc) { 
     
    115116  } 
    116117 
    117   public void showOptionDialogs(ImporterOptions options) 
     118  public void showDialogs(ImportProcess process) 
    118119    throws FormatException, IOException 
    119120  { 
    120     boolean success = new ImporterPrompter(options).showDialogs(); 
     121    boolean success = new ImporterPrompter(process).showDialogs(); 
    121122    if (!success) plugin.canceled = true; 
    122123  } 
    123124 
    124   /** Displays standard metadata in a table in its own window. */ 
    125   public void displayOriginalMetadata(ImporterOptions options) { 
    126     DisplayHandler displayHandler = new DisplayHandler(options); 
    127     displayHandler.displayOriginalMetadata(); 
    128   } 
    129  
    130   public void displayOMEXML(ImporterOptions options) 
    131     throws FormatException, IOException 
    132   { 
    133     DisplayHandler displayHandler = new DisplayHandler(options); 
    134     displayHandler.displayOMEXML(); 
    135   } 
    136  
    137   public ImagePlus[] readPixels(ImagePlusReader ipr, ImporterOptions options, 
     125  public ImagePlus[] readPixels(ImagePlusReader reader, ImporterOptions options, 
    138126    DisplayHandler displayHandler) throws FormatException, IOException 
    139127  { 
    140128    if (options.isViewNone()) return null; 
    141     ipr.addStatusListener(displayHandler); 
    142     ImagePlus[] imps = ipr.openImagePlus(); 
     129    if (!options.isQuiet()) reader.addStatusListener(displayHandler); 
     130    ImagePlus[] imps = reader.openImagePlus(); 
    143131    return imps; 
    144132  } 
    145133 
    146   public void displayROIs(ImporterOptions options, ImagePlus[] imps) { 
    147     if (options.showROIs()) { 
    148       BF.debug("display ROIs"); 
    149       ROIHandler.openROIs(options.getOMEMetadata(), imps); 
    150     } 
    151     else BF.debug("skip ROIs"); 
    152   } 
    153  
    154   public void finish(ImporterOptions options) throws IOException { 
    155     if (!options.isVirtual()) options.getReader().close(); 
     134  public void finish(ImportProcess process) throws IOException { 
     135    if (!process.getOptions().isVirtual()) process.getReader().close(); 
    156136    plugin.success = true; 
    157137  } 
  • trunk/components/loci-plugins/src/loci/plugins/in/ImporterDialog.java

    r6247 r6265  
    4141  // -- Fields -- 
    4242 
     43  protected ImportProcess process; 
    4344  protected ImporterOptions options; 
    4445 
    4546  // -- Constructor -- 
    4647 
    47   public ImporterDialog(ImporterOptions options) { 
    48     super(options); 
    49     this.options = options; 
     48  public ImporterDialog(ImportProcess process) { 
     49    super(process.getOptions()); 
     50    this.process = process; 
     51    this.options = process.getOptions(); 
    5052  } 
    5153 
     
    6264  } 
    6365 
    64   protected abstract void harvestResults(GenericDialog gd); 
     66  protected abstract boolean harvestResults(GenericDialog gd); 
    6567 
    6668  // -- OptionsDialog methods -- 
     
    7779    GenericDialog gd = constructDialog(); 
    7880    if (!displayDialog(gd)) return STATUS_CANCELED; 
    79     harvestResults(gd); 
     81    if (!harvestResults(gd)) return STATUS_CANCELED; 
    8082 
    8183    return STATUS_OK; 
  • trunk/components/loci-plugins/src/loci/plugins/in/ImporterMetadata.java

    r6229 r6265  
    4646  // -- Constructor -- 
    4747 
    48   public ImporterMetadata(IFormatReader r, ImporterOptions options, 
     48  public ImporterMetadata(IFormatReader r, ImportProcess process, 
    4949    boolean usePrefix) 
    5050  { 
     
    5353 
    5454    // merge location path 
    55     put("Location", options.getCurrentFile()); 
     55    put("Location", process.getCurrentFile()); 
    5656 
     57    final ImporterOptions options = process.getOptions(); 
    5758    final int oldSeries = r.getSeries(); 
    5859    final int seriesCount = r.getSeriesCount(); 
     
    6566      String s = ""; 
    6667      if (usePrefix) { 
    67         s = options.getOMEMetadata().getImageName(i); 
     68        s = process.getOMEMetadata().getImageName(i); 
    6869        if ((s == null || s.trim().length() == 0) && seriesCount > 1) { 
    6970          StringBuffer sb = new StringBuffer(); 
  • trunk/components/loci-plugins/src/loci/plugins/in/ImporterOptions.java

    r6247 r6265  
    2626package loci.plugins.in; 
    2727 
    28 import ij.IJ; 
    29  
    3028import java.io.IOException; 
    3129import java.util.ArrayList; 
     
    3432import loci.common.Location; 
    3533import loci.common.Region; 
    36 import loci.formats.FilePattern; 
    37 import loci.formats.FormatException; 
    38 import loci.formats.meta.IMetadata; 
    3934import loci.plugins.prefs.OptionsList; 
    4035import loci.plugins.prefs.StringOption; 
    41 import loci.plugins.util.ImageProcessorReader; 
    4236import loci.plugins.util.LibraryChecker; 
    4337 
     
    119113  private List<Boolean> seriesOn = new ArrayList<Boolean>(); 
    120114 
    121   // TODO - swap options need to be programmatically settable 
     115  // swap options 
     116  private String inputOrder; 
    122117 
    123118  // range options 
     
    134129  // crop options 
    135130  private List<Region> cropRegion = new ArrayList<Region>(); 
    136  
    137   // -- Fields - derived values -- 
    138  
    139   private ImporterReader reader; 
    140   private ImporterMetadata metadata; 
    141  
    142   /** A descriptive label for each series. */ 
    143   private String[] seriesLabels; 
    144131 
    145132  // -- Constructor -- 
     
    364351  // windowless 
    365352  public String getWindowlessInfo() { return getInfo(KEY_WINDOWLESS); } 
    366   public boolean isWindowless() { 
    367     if (reader != null && reader.isWindowless()) return true; 
    368     return isSet(KEY_WINDOWLESS); 
    369   } 
     353  public boolean isWindowless() { return isSet(KEY_WINDOWLESS); } 
    370354  public void setWindowless(boolean b) { setValue(KEY_WINDOWLESS, b); } 
    371355 
     
    381365  } 
    382366 
    383   // TODO - swap options 
     367  // swap options 
     368  public String getInputOrder() { return inputOrder; } 
     369  public void setInputOrder(String dimOrder) { inputOrder = dimOrder; } 
    384370 
    385371  // range options 
     
    387373  public void setCBegin(int s, int value) { set(cBegin, s, value, 0); } 
    388374  public int getCEnd(int s) { return get(cEnd, s, -1); } 
    389   public void setCEnd(int s, int value) { set(cEnd, s, value, 0); } 
     375  public void setCEnd(int s, int value) { set(cEnd, s, value, -1); } 
    390376  public int getCStep(int s) { return get(cStep, s, 1); } 
    391   public void setCStep(int s, int value) { set(cStep, s, value, 0); } 
    392  
    393   public int getZBegin(int s) { return get(zBegin, s, 0); } 
    394   public void setZBegin(int s, int value) { set(zBegin, s, value, 0); } 
    395   public int getZEnd(int s) { return get(zEnd, s, -1); } 
    396   public void setZEnd(int s, int value) { set(zEnd, s, value, 0); } 
    397   public int getZStep(int s) { return get(zStep, s, 1); } 
    398   public void setZStep(int s, int value) { set(zStep, s, value, 0); } 
    399  
    400   public int getTBegin(int s) { return get(tBegin, s, 0); } 
    401   public void setTBegin(int s, int value) { set(tBegin, s, value, 0); } 
    402   public int getTEnd(int s) { return get(tEnd, s, -1); } 
    403   public void setTEnd(int s, int value) { set(tEnd, s, value, 0); } 
    404   public int getTStep(int s) { return get(tStep, s, 1); } 
    405   public void setTStep(int s, int value) { set(tStep, s, value, 0); } 
    406  
    407   // crop options 
    408   public Region getCropRegion(int s) { return get(cropRegion, s, null); } 
    409   public void setCropRegion(int s, Region r) { set(cropRegion, s, r, null); } 
    410  
    411   // -- ImporterOptions methods - derived values accessors -- 
    412  
    413   public String getIdName() { return reader.idName; } 
    414   public Location getIdLocation() { return reader.idLoc; } 
    415   public String getCurrentFile() { return reader.currentFile; } 
    416   public ImageProcessorReader getReader() { return reader.r; } 
    417   public IMetadata getOMEMetadata() { return reader.meta; } 
    418   public ImporterMetadata getOriginalMetadata() { return metadata; } 
    419   public int getSeriesCount() { return reader.r.getSeriesCount(); } 
    420  
    421   // series options 
     377  public void setCStep(int s, int value) { set(cStep, s, value, 1); } 
    422378  public int getCCount(int s) { 
    423379    if (!isSeriesOn(s)) return 0; 
     
    425381    return (getCEnd(s) - getCBegin(s) + getCStep(s)) / getCStep(s); 
    426382  } 
     383 
     384  public int getZBegin(int s) { return get(zBegin, s, 0); } 
     385  public void setZBegin(int s, int value) { set(zBegin, s, value, 0); } 
     386  public int getZEnd(int s) { return get(zEnd, s, -1); } 
     387  public void setZEnd(int s, int value) { set(zEnd, s, value, -1); } 
     388  public int getZStep(int s) { return get(zStep, s, 1); } 
     389  public void setZStep(int s, int value) { set(zStep, s, value, 1); } 
    427390  public int getZCount(int s) { 
    428391    if (!isSeriesOn(s)) return 0; 
    429392    return (getZEnd(s) - getZBegin(s) + getZStep(s)) / getZStep(s); 
    430393  } 
     394 
     395  public int getTBegin(int s) { return get(tBegin, s, 0); } 
     396  public void setTBegin(int s, int value) { set(tBegin, s, value, 0); } 
     397  public int getTEnd(int s) { return get(tEnd, s, -1); } 
     398  public void setTEnd(int s, int value) { set(tEnd, s, value, -1); } 
     399  public int getTStep(int s) { return get(tStep, s, 1); } 
     400  public void setTStep(int s, int value) { set(tStep, s, value, 1); } 
    431401  public int getTCount(int s) { 
    432402    if (!isSeriesOn(s)) return 0; 
     
    434404  } 
    435405 
    436   public String getSeriesLabel(int s) { 
    437     if (seriesLabels == null) computeSeriesLabels(); 
    438     return seriesLabels[s]; 
    439   } 
    440  
    441   // -- Helper methods - derived value computation -- 
    442  
    443   /** Initializes the ImporterMetadata derived value. */ 
    444   protected void initializeMetadata() { 
    445     // only prepend a series name prefix to the metadata keys if multiple 
    446     // series are being opened 
    447     int seriesCount = getSeriesCount(); 
    448     int numEnabled = 0; 
    449     for (int s=0; s<seriesCount; s++) { 
    450       if (isSeriesOn(s)) numEnabled++; 
    451     } 
    452     metadata = new ImporterMetadata(reader.r, this, numEnabled > 1); 
    453   } 
    454  
    455   /** Initializes the seriesLabels derived value. */ 
    456   private void computeSeriesLabels() { 
    457     int seriesCount = getSeriesCount(); 
    458     seriesLabels = new String[seriesCount]; 
    459     for (int i=0; i<seriesCount; i++) { 
    460       reader.r.setSeries(i); 
    461       StringBuffer sb = new StringBuffer(); 
    462       sb.append("Series_"); 
    463       sb.append((i + 1)); 
    464       sb.append(": "); 
    465       String name = getOMEMetadata().getImageName(i); 
    466       if (name != null && name.length() > 0) { 
    467         sb.append(name); 
    468         sb.append(": "); 
    469       } 
    470       sb.append(reader.r.getSizeX()); 
    471       sb.append(" x "); 
    472       sb.append(reader.r.getSizeY()); 
    473       sb.append("; "); 
    474       sb.append(reader.r.getImageCount()); 
    475       sb.append(" plane"); 
    476       if (reader.r.getImageCount() > 1) { 
    477         sb.append("s"); 
    478         if (reader.r.isOrderCertain()) { 
    479           sb.append(" ("); 
    480           boolean first = true; 
    481           if (reader.r.getEffectiveSizeC() > 1) { 
    482             sb.append(reader.r.getEffectiveSizeC()); 
    483             sb.append("C"); 
    484             first = false; 
    485           } 
    486           if (reader.r.getSizeZ() > 1) { 
    487             if (!first) sb.append(" x "); 
    488             sb.append(reader.r.getSizeZ()); 
    489             sb.append("Z"); 
    490             first = false; 
    491           } 
    492           if (reader.r.getSizeT() > 1) { 
    493             if (!first) sb.append(" x "); 
    494             sb.append(reader.r.getSizeT()); 
    495             sb.append("T"); 
    496             first = false; 
    497           } 
    498           sb.append(")"); 
    499         } 
    500       } 
    501       seriesLabels[i] = sb.toString(); 
    502       //seriesLabels[i] = seriesLabels[i].replaceAll(" ", "_"); 
    503     } 
    504   } 
     406  // crop options 
     407  public Region getCropRegion(int s) { return get(cropRegion, s, null); } 
     408  public void setCropRegion(int s, Region r) { set(cropRegion, s, r, null); } 
    505409 
    506410  // -- Helper methods - miscellaneous -- 
     
    518422  } 
    519423 
    520   // -- CTR TEMP - methods to munge around with state -- 
    521  
    522   public void createReader() { 
    523     reader = new ImporterReader(this); 
    524   } 
    525  
    526   public void saveDefaults() { 
    527     // save options as new defaults 
    528     if (!isQuiet()) setFirstTime(false); 
    529     saveOptions(); 
    530   } 
    531  
    532   public void prepareStuff() throws FormatException, IOException { 
    533     IJ.showStatus("Analyzing " + getIdName()); 
    534     reader.prepareStuff(); 
    535   } 
    536  
    537   public void initializeReader() throws FormatException, IOException { 
    538     if (isGroupFiles()) { 
    539       // overwrite base filename with file pattern 
    540       String id = getId(); 
    541       if (id == null) id = reader.currentFile; 
    542       FilePattern fp = new FilePattern(id); 
    543       if (!fp.isValid()) id = reader.currentFile; 
    544       setId(id); 
    545     } 
    546     reader.initializeReader(); 
    547   } 
    548  
    549424} 
  • trunk/components/loci-plugins/src/loci/plugins/in/ImporterPrompter.java

    r6247 r6265  
    4646  // -- Fields -- 
    4747 
    48   private ImporterOptions options; 
     48  private ImportProcess process; 
    4949 
    5050  // -- Constructor -- 
    5151 
    52   public ImporterPrompter(ImporterOptions options) { 
    53     this.options = options; 
     52  public ImporterPrompter(ImportProcess process) { 
     53    this.process = process; 
    5454  } 
    5555 
     
    7777    if (!promptId()) return false; 
    7878 
    79     options.createReader(); 
     79    process.go(); 
    8080 
    8181    if (!promptMain()) return false; 
    8282 
    83     options.saveDefaults(); 
     83    process.saveDefaults(); 
    8484 
    85     options.prepareStuff(); 
     85    process.prepareStuff(); 
    8686 
    8787    if (!promptFilePattern()) return false; 
    8888 
    89     options.initializeReader(); 
     89    process.initializeReader(); 
    9090 
    9191    if (!promptSeries()) return false; 
     
    9494    if (!promptCrop()) return false; 
    9595 
    96     options.initializeMetadata(); 
     96    process.initializeMetadata(); 
    9797 
    9898    return true; 
     
    102102 
    103103  private boolean promptUpgrade() { 
    104     UpgradeDialog dialog = new UpgradeDialog(options); 
     104    UpgradeDialog dialog = new UpgradeDialog(process); 
    105105    return dialog.showDialog() == OptionsDialog.STATUS_OK; 
    106106  } 
    107107 
    108108  private boolean promptLocation() { 
    109     LocationDialog dialog = new LocationDialog(options); 
     109    LocationDialog dialog = new LocationDialog(process); 
    110110    return dialog.showDialog() == OptionsDialog.STATUS_OK; 
    111111  } 
    112112 
    113113  private boolean promptId() { 
    114     IdDialog dialog = new IdDialog(options); 
     114    IdDialog dialog = new IdDialog(process); 
    115115    return dialog.showDialog() == OptionsDialog.STATUS_OK; 
    116116  } 
    117117 
    118118  private boolean promptMain() { 
    119     MainDialog dialog = new MainDialog(options); 
     119    MainDialog dialog = new MainDialog(process); 
    120120    return dialog.showDialog() == OptionsDialog.STATUS_OK; 
    121121  } 
     
    123123  /** Prompts for the file pattern, if necessary. May override id value. */ 
    124124  private boolean promptFilePattern() { 
    125     FilePatternDialog dialog = new FilePatternDialog(options); 
     125    FilePatternDialog dialog = new FilePatternDialog(process); 
    126126    return dialog.showDialog() == OptionsDialog.STATUS_OK; 
    127127  } 
     
    129129  /** Prompts for which series to import, if necessary. */ 
    130130  private boolean promptSeries() { 
    131     SeriesDialog dialog = new SeriesDialog(options); 
     131    SeriesDialog dialog = new SeriesDialog(process); 
    132132    return dialog.showDialog() == OptionsDialog.STATUS_OK; 
    133133  } 
     
    135135  /** Prompts for dimension swapping parameters, if necessary. */ 
    136136  private boolean promptSwap() { 
    137     SwapDialog dialog = new SwapDialog(options); 
     137    SwapDialog dialog = new SwapDialog(process); 
    138138    return dialog.showDialog() == OptionsDialog.STATUS_OK; 
    139139  } 
     
    141141  /** Prompts for the range of planes to import, if necessary. */ 
    142142  private boolean promptRange() { 
    143     RangeDialog dialog = new RangeDialog(options); 
     143    RangeDialog dialog = new RangeDialog(process); 
    144144    return dialog.showDialog() == OptionsDialog.STATUS_OK; 
    145145  } 
     
    147147  /** Prompts for cropping details, if necessary. */ 
    148148  private boolean promptCrop() { 
    149     CropDialog dialog = new CropDialog(options); 
     149    CropDialog dialog = new CropDialog(process); 
    150150    return dialog.showDialog() == OptionsDialog.STATUS_OK; 
    151151  } 
  • trunk/components/loci-plugins/src/loci/plugins/in/LocationDialog.java

    r6247 r6265  
    4040 
    4141  /** Creates a location chooser dialog for the Bio-Formats Importer. */ 
    42   public LocationDialog(ImporterOptions options) { 
    43     super(options); 
     42  public LocationDialog(ImportProcess process) { 
     43    super(process); 
    4444  } 
    4545   
     
    4949  protected boolean needPrompt() { 
    5050    // NB: Prompt only if location wasn't already specified. 
    51     return !options.isWindowless() && options.getLocation() == null; 
     51    return !process.isWindowless() && options.getLocation() == null; 
    5252  } 
    5353   
     
    6060   
    6161  @Override 
    62   protected void harvestResults(GenericDialog gd) { 
     62  protected boolean harvestResults(GenericDialog gd) { 
    6363    String location = gd.getNextChoice(); 
    6464    options.setLocation(location); 
     65    return true; 
    6566  } 
    6667 
  • trunk/components/loci-plugins/src/loci/plugins/in/MainDialog.java

    r6247 r6265  
    7171 
    7272  // -- Fields -- 
    73  
    74   /** LOCI plugins configuration. */ 
    75   protected ImporterOptions options; 
    7673 
    7774  protected Checkbox autoscaleBox; 
     
    103100 
    104101  /** Creates a general options dialog for the Bio-Formats Importer. */ 
    105   public MainDialog(ImporterOptions options) { 
    106     super(options); 
    107     this.options = options; 
     102  public MainDialog(ImportProcess process) { 
     103    super(process); 
    108104  } 
    109105   
     
    112108  @Override 
    113109  protected boolean needPrompt() { 
    114     return !options.isWindowless(); 
     110    return !process.isWindowless(); 
    115111  } 
    116112   
     
    145141   
    146142  @Override 
    147   protected void harvestResults(GenericDialog gd) { 
     143  protected boolean harvestResults(GenericDialog gd) { 
    148144    options.setAutoscale(gd.getNextBoolean()); 
    149145    options.setColorize(gd.getNextBoolean()); 
     
    168164    options.setSwapDimensions(gd.getNextBoolean()); 
    169165    options.setVirtual(gd.getNextBoolean()); 
     166    return true; 
    170167  } 
    171168   
  • trunk/components/loci-plugins/src/loci/plugins/in/RangeDialog.java

    r6247 r6265  
    4646   * @param dimSwap The reader to use for extracting details of each series. 
    4747   */ 
    48   public RangeDialog(ImporterOptions options) { 
    49     super(options); 
     48  public RangeDialog(ImportProcess process) { 
     49    super(process); 
    5050  } 
    5151   
     
    5353 
    5454  protected boolean needPrompt() { 
    55     if (options.isWindowless() || !options.isSpecifyRanges()) return false; 
     55    if (process.isWindowless() || !options.isSpecifyRanges()) return false; 
    5656     
    57     int seriesCount = options.getSeriesCount(); 
    58     IFormatReader r = options.getReader(); 
     57    int seriesCount = process.getSeriesCount(); 
     58    IFormatReader r = process.getReader(); 
    5959 
    6060    boolean needRange = false; 
     
    6969   
    7070  protected GenericDialog constructDialog() { 
    71     int seriesCount = options.getSeriesCount(); 
    72     IFormatReader r = options.getReader(); 
     71    int seriesCount = process.getSeriesCount(); 
     72    IFormatReader r = process.getReader(); 
    7373 
    7474    // -- CTR TODO - refactor range-related options into RangeOptions class 
     
    9494      if (!options.isSeriesOn(s)) continue; 
    9595      r.setSeries(s); 
    96       gd.addMessage(options.getSeriesLabel(s).replaceAll("_", " ")); 
     96      gd.addMessage(process.getSeriesLabel(s).replaceAll("_", " ")); 
    9797      String suffix = seriesCount > 1 ? "_" + (s + 1) : ""; 
    9898      //if (r.isOrderCertain()) { 
     
    124124  } 
    125125   
    126   protected void harvestResults(GenericDialog gd) { 
    127     int seriesCount = options.getSeriesCount(); 
    128     IFormatReader r = options.getReader(); 
     126  protected boolean harvestResults(GenericDialog gd) { 
     127    int seriesCount = process.getSeriesCount(); 
     128    IFormatReader r = process.getReader(); 
    129129 
    130130    for (int s=0; s<seriesCount; s++) { 
     
    195195      options.setTStep(s, tStep); 
    196196    } 
     197 
     198    return true; 
    197199  } 
    198200   
  • trunk/components/loci-plugins/src/loci/plugins/in/SeriesDialog.java

    r6258 r6265  
    7373  // -- Constructor -- 
    7474 
    75   /** 
    76    * Creates a series chooser dialog for the Bio-Formats Importer. 
    77    * 
    78    * @param r The reader to use for extracting details of each series. 
    79    * @param series Boolean array indicating which series to include 
    80    *   (populated by this method). 
    81    */ 
    82   public SeriesDialog(ImporterOptions options) { 
    83     super(options); 
     75  /** Creates a series chooser dialog for the Bio-Formats Importer. */ 
     76  public SeriesDialog(ImportProcess process) { 
     77    super(process); 
    8478  } 
    8579   
     
    9084    // CTR TODO - eliminate weird handling of series string here 
    9185    String seriesString = options.getSeries(); 
    92     if (options.isWindowless()) { 
     86    if (process.isWindowless()) { 
    9387      if (seriesString != null) { 
    9488        if (seriesString.startsWith("[")) { 
     
    9791 
    9892        // default all series to false 
    99         int seriesCount = options.getSeriesCount(); 
     93        int seriesCount = process.getSeriesCount(); 
    10094        for (int s=0; s<seriesCount; s++) options.setSeriesOn(s, false); 
    10195 
     
    112106    } 
    113107 
    114     return options.getSeriesCount() > 1 && 
     108    return process.getSeriesCount() > 1 && 
    115109      !options.openAllSeries() && !options.isViewNone(); 
    116110  } 
     
    125119 
    126120    // set up the thumbnail panels 
    127     thumbReader = new BufferedImageReader(options.getReader()); 
     121    thumbReader = new BufferedImageReader(process.getReader()); 
    128122    int seriesCount = thumbReader.getSeriesCount(); 
    129123    p = new Panel[seriesCount]; 
     
    169163      boolean[] defaultValues = new boolean[nRows]; 
    170164      for (int row=0; row<nRows; row++) { 
    171         labels[row] = options.getSeriesLabel(nextSeries); 
     165        labels[row] = process.getSeriesLabel(nextSeries); 
    172166        defaultValues[row] = options.isSeriesOn(nextSeries++); 
    173167      } 
     
    198192   
    199193  @Override 
    200   protected void harvestResults(GenericDialog gd) { 
     194  protected boolean harvestResults(GenericDialog gd) { 
    201195    String seriesString = "["; 
    202     int seriesCount = options.getSeriesCount(); 
     196    int seriesCount = process.getSeriesCount(); 
    203197    for (int i=0; i<seriesCount; i++) { 
    204198      boolean on = gd.getNextBoolean(); 
     
    208202    seriesString += "]"; 
    209203    options.setSeries(seriesString); 
     204    return true; 
    210205  } 
    211206 
     
    242237      protected void dispatchEventImpl(AWTEvent e) { } 
    243238    }; 
    244     int seriesCount = options.getSeriesCount(); 
     239    int seriesCount = process.getSeriesCount(); 
    245240    masterPanel.setLayout(new GridLayout(seriesCount, 2)); 
    246241 
  • trunk/components/loci-plugins/src/loci/plugins/in/SwapDialog.java

    r6247 r6265  
    5050 
    5151  /** Creates a dimension swapper dialog for the Bio-Formats Importer. */ 
    52   public SwapDialog(ImporterOptions options) { 
    53     super(options); 
     52  public SwapDialog(ImportProcess process) { 
     53    super(process); 
    5454    try { 
    5555      dimSwap = (DimensionSwapper) 
    56         options.getReader().unwrap(DimensionSwapper.class, null); 
     56        process.getReader().unwrap(DimensionSwapper.class, null); 
    5757    } 
    5858    catch (FormatException e) { 
     
    7070  @Override 
    7171  protected boolean needPrompt() { 
    72     return !options.isWindowless() && options.isSwapDimensions(); 
     72    return !process.isWindowless() && options.isSwapDimensions(); 
    7373  } 
    7474   
     
    9797   
    9898  @Override 
    99   protected void harvestResults(GenericDialog gd) { 
     99  protected boolean harvestResults(GenericDialog gd) { 
    100100    for (int s=0; s<dimSwap.getSeriesCount(); s++) { 
    101101      if (!options.isSeriesOn(s)) continue; 
     
    121121      dimSwap.swapDimensions(sb.toString()); 
    122122    } 
     123    return true; 
    123124  } 
    124125 
  • trunk/components/loci-plugins/src/loci/plugins/in/UpgradeDialog.java

    r6247 r6265  
    2828import ij.IJ; 
    2929import ij.gui.GenericDialog; 
    30 import loci.plugins.BF; 
    3130import loci.plugins.Updater; 
    32 import loci.plugins.prefs.OptionsDialog; 
    3331 
    3432/** 
     
    3937 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/in/UpgradeDialog.java">SVN</a></dd></dl> 
    4038 */ 
    41 public class UpgradeDialog extends OptionsDialog { 
    42  
    43   // -- Fields -- 
    44  
    45   /** LOCI plugins configuration. */ 
    46   protected ImporterOptions options; 
     39public class UpgradeDialog extends ImporterDialog { 
    4740 
    4841  // -- Constructor -- 
    4942 
    5043  /** Creates an upgrade checker dialog for the Bio-Formats Importer. */ 
    51   public UpgradeDialog(ImporterOptions options) { 
    52     super(options); 
    53     this.options = options; 
     44  public UpgradeDialog(ImportProcess process) { 
     45    super(process); 
    5446  } 
    5547 
    56   // -- OptionsDialog methods -- 
     48  // -- ImporterDialog methods -- 
    5749 
     50  @Override 
     51  protected boolean needPrompt() { 
     52    return !options.isQuiet() && !process.isWindowless(); 
     53  } 
     54   
     55  @Override 
     56  protected GenericDialog constructDialog() { return null; } 
     57   
    5858  /** 
    5959   * Asks user whether Bio-Formats should automatically check for upgrades, 
     
    6262   * @return status of operation 
    6363   */ 
    64   public int showDialog() { 
    65     // verify whether prompt is necessary 
    66     if (options.isQuiet() || options.isWindowless()) { 
    67       BF.debug("UpgradeDialog: skip"); 
    68       return STATUS_OK; 
    69     } 
    70     BF.debug("UpgradeDialog: prompt"); 
    71  
     64  @Override 
     65  protected boolean displayDialog(GenericDialog gd) { 
    7266    if (!options.isQuiet() && options.isFirstTime()) { 
    7367      // present user with one-time dialog box 
    74       GenericDialog gd = new GenericDialog("Bio-Formats Upgrade Checker"); 
     68      gd = new GenericDialog("Bio-Formats Upgrade Checker"); 
    7569      gd.addMessage("One-time notice: The LOCI plugins for ImageJ can " + 
    7670        "automatically check for upgrades\neach time they are run. If you " + 
     
    8074      addCheckbox(gd, ImporterOptions.KEY_UPGRADE_CHECK); 
    8175      gd.showDialog(); 
    82       if (gd.wasCanceled()) return STATUS_CANCELED; 
     76      if (gd.wasCanceled()) return false; 
    8377    } 
    8478 
     
    9286      } 
    9387    } 
    94  
    95     return STATUS_OK; 
     88   
     89    return true; 
    9690  } 
    9791 
     92  @Override 
     93  protected boolean harvestResults(GenericDialog gd) { return true; } 
     94 
    9895} 
  • trunk/components/loci-plugins/src/loci/plugins/util/IJStatusEchoer.java

    r6026 r6265  
    3737 * <dd><a href="https://skyking.microscopy.wisc.edu/trac/java/browser/trunk/components/loci-plugins/src/loci/plugins/util/IJStatusEchoer.java">Trac</a>, 
    3838 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/util/IJStatusEchoer.java">SVN</a></dd></dl> 
    39  * 
    40  * @author Curtis Rueden ctrueden at wisc.edu 
    4139 */ 
    4240public class IJStatusEchoer extends AppenderSkeleton { 
  • trunk/components/loci-plugins/src/loci/plugins/util/ImageProcessorReader.java

    r6246 r6265  
    3939import loci.formats.IFormatReader; 
    4040import loci.formats.ImageTools; 
    41 import loci.formats.MinMaxCalculator; 
     41import loci.formats.ReaderWrapper; 
    4242 
    4343/** 
     
    5050 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/util/ImageProcessorReader.java">SVN</a></dd></dl> 
    5151 */ 
    52 public class ImageProcessorReader extends MinMaxCalculator { 
     52public class ImageProcessorReader extends ReaderWrapper { 
    5353 
    5454  // -- Utility methods -- 
  • trunk/components/loci-plugins/test/loci/plugins/in/ImporterTest.java

    r6261 r6265  
    55package loci.plugins.in; 
    66 
    7 import static org.junit.Assert.assertEquals; 
    8 import static org.junit.Assert.assertNotNull; 
    9 import static org.junit.Assert.assertTrue; 
    10 import static org.junit.Assert.fail; 
    11  
    127import ij.ImagePlus; 
    138import ij.ImageStack; 
     
    1611import java.io.IOException; 
    1712import java.lang.reflect.Field; 
     13 
     14import junit.framework.TestCase; 
    1815 
    1916import loci.common.Location; 
     
    3734//  - add some tests for combination of options 
    3835 
    39 public class ImporterTest { 
     36public class ImporterTest extends TestCase { 
    4037 
    4138  private enum Axis {Z,C,T}; 
    4239   
    43   private boolean loaded = false; 
     40  private static final String[] FAKE_FILES; 
     41  private static final String FAKE_PATTERN; 
     42  static { 
     43    //String template = "test_C%s_TP%s&sizeX=50&sizeY=20&sizeZ=7.fake"; 
     44    String template = constructFakeFilename("test_C%s_TP%s", 
     45      FormatTools.UINT8, 50, 20, 7, 1, 1, -1); 
     46    FAKE_FILES = new String[] { 
     47      String.format(template, "1", "1"), 
     48      String.format(template, "2", "1"), 
     49      String.format(template, "3", "1"), 
     50      String.format(template, "1", "2"), 
     51      String.format(template, "2", "2"), 
     52      String.format(template, "3", "2"), 
     53      String.format(template, "1", "3"), 
     54      String.format(template, "2", "3"), 
     55      String.format(template, "3", "3"), 
     56      String.format(template, "1", "4"), 
     57      String.format(template, "2", "4"), 
     58      String.format(template, "3", "4"), 
     59      String.format(template, "1", "5"), 
     60      String.format(template, "2", "5"), 
     61      String.format(template, "3", "5"), 
     62      "outlier.txt" // optional 
     63    }; 
     64    FAKE_PATTERN = String.format(template, "<1-3>", "<1-5>"); 
     65 
     66    for (String file : FAKE_FILES) { 
     67      Location.mapId(file, "iThinkI'mImportantButI'mNot"); 
     68    } 
     69  } 
    4470   
    4571  // ** Helper methods ******************************************************************* 
    4672 
    47   private String constructFakeFilename(String title, 
     73  private static String constructFakeFilename(String title, 
    4874      int pixelType, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT, int numSeries) 
    4975  { 
     
    190216  private int getEffectiveSizeC(ImagePlus imp) { return getField(imp, "nChannels"); } 
    191217   
    192   private void loadFakeFileSequenceIntoBF() 
    193   { 
    194     synchronized(this) 
    195     { 
    196       if (loaded) return; 
    197        
    198       String[] files = { 
    199           "test_C1_TP1&sizeX=50&sizeY=20&sizeZ=7.fake", 
    200           "test_C2_TP1&sizeX=50&sizeY=20&sizeZ=7.fake", 
    201           "test_C3_TP1&sizeX=50&sizeY=20&sizeZ=7.fake", 
    202           "test_C1_TP2&sizeX=50&sizeY=20&sizeZ=7.fake", 
    203           "test_C2_TP2&sizeX=50&sizeY=20&sizeZ=7.fake", 
    204           "test_C3_TP2&sizeX=50&sizeY=20&sizeZ=7.fake", 
    205           "test_C1_TP3&sizeX=50&sizeY=20&sizeZ=7.fake", 
    206           "test_C2_TP3&sizeX=50&sizeY=20&sizeZ=7.fake", 
    207           "test_C3_TP3&sizeX=50&sizeY=20&sizeZ=7.fake", 
    208           "test_C1_TP4&sizeX=50&sizeY=20&sizeZ=7.fake", 
    209           "test_C2_TP4&sizeX=50&sizeY=20&sizeZ=7.fake", 
    210           "test_C3_TP4&sizeX=50&sizeY=20&sizeZ=7.fake", 
    211           "test_C1_TP5&sizeX=50&sizeY=20&sizeZ=7.fake", 
    212           "test_C2_TP5&sizeX=50&sizeY=20&sizeZ=7.fake", 
    213           "test_C3_TP5&sizeX=50&sizeY=20&sizeZ=7.fake", 
    214           "outlier.txt" 
    215         }; 
    216        
    217       for (String file : files) 
    218         Location.mapId(file, "iThinkI'mImportantButI'mNot"); 
    219        
    220       loaded = true; 
    221     } 
    222   } 
    223  
    224   private String getFirstFileInSequence() 
    225   { 
    226     return "test_C1_TP1&sizeX=50&sizeY=20&sizeZ=7.fake"; 
    227   } 
    228  
    229218  // ****** helper tests **************************************************************************************** 
    230219   
     
    322311  private void datasetSwapDimsTest(int pixType, int x, int y, int z, int t) 
    323312  { 
    324     int c = 3; String order = "XYZCT"; 
    325     String path = constructFakeFilename(order, pixType, x, y, z, c, t, -1); 
     313    int c = 3; String origOrder = "XYZCT", swappedOrder = "XYTCZ"; 
     314    String path = constructFakeFilename(origOrder, pixType, x, y, z, c, t, -1); 
    326315    ImagePlus[] imps = null; 
    327316    try { 
     
    329318      options.setId(path); 
    330319      options.setSwapDimensions(true); 
     320      options.setInputOrder(swappedOrder); 
    331321      imps = BF.openImagePlus(options); 
    332322    } 
     
    591581  public void testDatasetGroupFiles() 
    592582  { 
    593  
    594     loadFakeFileSequenceIntoBF(); 
    595      
    596     String path = getFirstFileInSequence(); 
     583    String path = FAKE_FILES[0]; 
    597584 
    598585    ImagePlus[] imps = null; 
     
    602589      options.setId(path); 
    603590      imps = BF.openImagePlus(options); 
    604       // TODO - assertEquals("test_C<1-3>_TP<1-5>&sizeX=50&sizeY=20&sizeZ=7.fake",options.getId()); 
     591      assertEquals(FAKE_PATTERN, options.getId()); 
    605592    } 
    606593    catch (IOException e) { 
     
    775762  public void testSplitChannels() 
    776763  { 
    777     loadFakeFileSequenceIntoBF(); 
    778      
    779     String path = getFirstFileInSequence(); 
     764    String path = FAKE_FILES[0]; 
    780765 
    781766    ImagePlus[] imps = null; 
     
    810795  public void testSplitFocalPlanes() 
    811796  { 
    812     loadFakeFileSequenceIntoBF(); 
    813      
    814     String path = getFirstFileInSequence(); 
     797    String path = FAKE_FILES[0]; 
    815798 
    816799    ImagePlus[] imps = null; 
     
    845828  public void testSplitTimepoints() 
    846829  { 
    847     loadFakeFileSequenceIntoBF(); 
    848      
    849     String path = getFirstFileInSequence(); 
     830    String path = FAKE_FILES[0]; 
    850831 
    851832    ImagePlus[] imps = null; 
     
    881862  public static void main(String[] args) 
    882863  { 
     864    //TODO - run all test methods via JUnit 
     865    //TestSuite suite = new TestSuite(ImporterTest.class); 
     866    //TestResult result = new TestResult(); 
     867    //suite.run(result); 
     868 
    883869    ImporterTest tester = new ImporterTest(); 
    884   
    885     //TODO - we could use reflection to discover all test methods, loop, and run them 
    886870   
    887871    // tests of single features 
    888872    tester.testDefaultBehavior(); 
    889873    tester.testOutputStackOrder(); 
    890     tester.testDatasetGroupFiles(); 
    891     tester.testDatasetOpenFilesIndividually(); 
    892     tester.testDatasetSwapDims(); 
     874    //tester.testDatasetGroupFiles(); 
     875    //tester.testDatasetOpenFilesIndividually(); 
     876    //tester.testDatasetSwapDims(); 
    893877    tester.testDatasetOpenAllSeries(); 
    894     tester.testDatasetConcatenate(); 
    895     tester.testColorMerge(); 
    896     tester.testColorRgbColorize(); 
    897     tester.testColorCustomColorize(); 
     878    //tester.testDatasetConcatenate(); 
     879    //tester.testColorMerge(); 
     880    //tester.testColorRgbColorize(); 
     881    //tester.testColorCustomColorize(); 
    898882    tester.testColorAutoscale(); 
    899883    tester.testMemoryVirtualStack(); 
     
    910894  } 
    911895} 
    912  
    913  
    914 /*  notes 
    915  
    916  public static void main(String[] args) throws FormatException, IOException { 
    917    String[] files = { 
    918      "test_C1_TP1&sizeZ=7.fake", 
    919      "test_C2_TP1&sizeZ=7.fake", 
    920      "test_C3_TP1&sizeZ=7.fake", 
    921      "test_C1_TP2&sizeZ=7.fake", 
    922      "test_C2_TP2&sizeZ=7.fake", 
    923      "test_C3_TP2&sizeZ=7.fake", 
    924      "test_C1_TP3&sizeZ=7.fake", 
    925      "test_C2_TP3&sizeZ=7.fake", 
    926      "test_C3_TP3&sizeZ=7.fake", 
    927      "test_C1_TP4&sizeZ=7.fake", 
    928      "test_C2_TP4&sizeZ=7.fake", 
    929      "test_C3_TP4&sizeZ=7.fake", 
    930      "test_C1_TP5&sizeZ=7.fake", 
    931      "test_C2_TP5&sizeZ=7.fake", 
    932      "test_C3_TP5&sizeZ=7.fake", 
    933      "outlier.txt" 
    934    }; 
    935    for (String file : files) Location.mapId(file, "x"); // "x" is irrelevant 
    936  
    937    String id = files[0]; 
    938    IFormatReader reader = new FileStitcher(); 
    939    IMetadata meta = MetadataTools.createOMEXMLMetadata(); 
    940    reader.setMetadataStore(meta); 
    941    reader.setId(id); 
    942    String[] usedFiles = reader.getUsedFiles(); 
    943    int sizeX = reader.getSizeX(); 
    944    int sizeY = reader.getSizeY(); 
    945    int sizeZ = reader.getSizeZ(); 
    946    int sizeC = reader.getSizeC(); 
    947    int sizeT = reader.getSizeT(); 
    948    reader.close(); 
    949    System.out.println("Path = " + id); 
    950    System.out.println("X size = " + sizeX); 
    951    System.out.println("Y size = " + sizeY); 
    952    System.out.println("Z size = " + sizeZ); 
    953    System.out.println("C size = " + sizeC); 
    954    System.out.println("T size = " + sizeT); 
    955    System.out.println("Used files ="); 
    956    for (String used : usedFiles) System.out.println("\t" + used); 
    957  } 
    958 That's how you synthesize a virtual directory on disk, essentially, for the file grouping logic to use. 
    959 The key is to register each fake filename with "Location.mapId(filename, dummy)" where "dummy" doesn't matter. 
    960 As long as it's not null. 
    961  
    962 Then below, I call "getUsedFiles" to get a list of the constituent filenames, which you can compare against 
    963 your expectations. 
    964  
    965 Oh, forget about what I said about getUsedFilesÑyou don't have access to the API at that level. 
    966  
    967  */ 
Note: See TracChangeset for help on using the changeset viewer.