Changeset 6271


Ignore:
Timestamp:
05/11/10 13:45:38 (10 years ago)
Author:
curtis
Message:

Cleaner import preparation process (ImportProcess & ImportStep).

Location:
trunk/components/loci-plugins
Files:
1 added
10 edited

Legend:

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

    r6265 r6271  
    6767    throws FormatException, IOException 
    6868  { 
    69     options.setQuiet(true); 
    70     options.setWindowless(true); 
     69    options.setQuiet(true);//TEMP 
     70    options.setWindowless(true);//TEMP 
    7171    ImportProcess process = new ImportProcess(options); 
    72     new ImporterPrompter(process).showDialogs();//TEMP 
     72    new ImporterPrompter(process);//TEMP 
     73    if (!process.process()) return null; 
    7374    ImagePlusReader reader = new ImagePlusReader(process); 
    7475    return reader.openImagePlus(); 
  • trunk/components/loci-plugins/src/loci/plugins/colorize/CustomColorChooser.java

    r6265 r6271  
    3737import java.awt.event.TextEvent; 
    3838import java.awt.event.TextListener; 
    39 import java.util.Vector; 
     39import java.util.List; 
    4040 
    4141import loci.plugins.util.WindowTools; 
     
    5454 */ 
    5555public class CustomColorChooser implements TextListener { 
    56   Vector<TextField> colors; 
     56  List<TextField> colors; 
    5757  Panel panel; 
    5858  Color initialColor; 
  • trunk/components/loci-plugins/src/loci/plugins/in/ImagePlusReader.java

    r6265 r6271  
    6060import loci.plugins.util.ImageProcessorReader; 
    6161import loci.plugins.util.VirtualImagePlus; 
    62 import loci.plugins.util.VirtualReader; 
    6362 
    6463import ome.xml.r201004.enums.DimensionOrder; 
     
    7675  // -- Fields -- 
    7776 
    78   /** Import process managing Bio-Formats readers and other state. */ 
     77  /** 
     78   * Import preparation process managing Bio-Formats readers and other state. 
     79   */ 
    7980  protected ImportProcess process; 
    8081 
     
    9192  } 
    9293 
    93   /** Constructs an ImagePlusReader with the given reader. */ 
     94  /** 
     95   * Constructs an ImagePlusReader with the 
     96   * given complete import preparation process. 
     97   */ 
    9498  public ImagePlusReader(ImportProcess process) { 
    9599    this.process = process; 
     
    132136    long time = startTime; 
    133137 
    134     ImageProcessorReader r = process.getReader(); 
     138    ImageProcessorReader reader = process.getReader(); 
    135139    ImporterOptions options = process.getOptions(); 
    136140 
    137141    if (options.isVirtual()) { 
    138142      int totalSeries = 0; 
    139       for (int s=0; s<r.getSeriesCount(); s++) { 
     143      for (int s=0; s<reader.getSeriesCount(); s++) { 
    140144        if (options.isSeriesOn(s)) totalSeries++; 
    141145      } 
    142       ((VirtualReader) r.getReader()).setRefCount(totalSeries); 
    143     } 
    144  
    145     for (int s=0; s<r.getSeriesCount(); s++) { 
     146      process.getVirtualReader().setRefCount(totalSeries); 
     147    } 
     148 
     149    for (int s=0; s<reader.getSeriesCount(); s++) { 
    146150      if (!options.isSeriesOn(s)) continue; 
    147       r.setSeries(s); 
    148  
    149       boolean[] load = new boolean[r.getImageCount()]; 
     151      reader.setSeries(s); 
     152 
     153      boolean[] load = new boolean[reader.getImageCount()]; 
    150154      int cBegin = options.getCBegin(s); 
    151155      int cEnd = options.getCEnd(s); 
    152       if (cEnd < 0) cEnd = r.getEffectiveSizeC() - 1; 
     156      if (cEnd < 0) cEnd = reader.getEffectiveSizeC() - 1; 
    153157      int cStep = options.getCStep(s); 
    154158      int zBegin = options.getZBegin(s); 
    155159      int zEnd = options.getZEnd(s); 
    156       if (zEnd < 0) zEnd = r.getSizeZ() - 1; 
     160      if (zEnd < 0) zEnd = reader.getSizeZ() - 1; 
    157161      int zStep = options.getZStep(s); 
    158162      int tBegin = options.getTBegin(s); 
    159163      int tEnd = options.getTEnd(s); 
    160       if (tEnd < 0) tEnd = r.getSizeT() - 1; 
     164      if (tEnd < 0) tEnd = reader.getSizeT() - 1; 
    161165      int tStep = options.getTStep(s); 
    162166      for (int c=cBegin; c<=cEnd; c+=cStep) { 
     
    164168          for (int t=tBegin; t<=tEnd; t+=tStep) { 
    165169            //int index = r.isOrderCertain() ? r.getIndex(z, c, t) : c; 
    166             int index = r.getIndex(z, c, t); 
     170            int index = reader.getIndex(z, c, t); 
    167171            load[index] = true; 
    168172          } 
     
    170174      } 
    171175      int total = 0; 
    172       for (int j=0; j<r.getImageCount(); j++) if (load[j]) total++; 
     176      for (int j=0; j<reader.getImageCount(); j++) if (load[j]) total++; 
    173177 
    174178      FileInfo fi = new FileInfo(); 
     
    190194      Region region = options.getCropRegion(s); 
    191195      if (region == null) region = new Region(); 
    192       int sizeX = r.getSizeX(), sizeY = r.getSizeY(); 
     196      int sizeX = reader.getSizeX(), sizeY = reader.getSizeY(); 
    193197      if (options.doCrop()) { 
    194198        // bounds checking for cropped region 
     
    212216      String stackOrder = options.getStackOrder(); 
    213217      if (stackOrder.equals(ImporterOptions.ORDER_DEFAULT)) { 
    214         stackOrder = r.getDimensionOrder(); 
    215       } 
    216       ((VirtualReader) r.getReader()).setOutputOrder(stackOrder); 
     218        stackOrder = reader.getDimensionOrder(); 
     219      } 
     220      process.getDimensionSwapper().setOutputOrder(stackOrder); 
    217221 
    218222      try { 
     
    234238        boolean doMerge = options.isMergeChannels(); 
    235239 
    236         r.setSeries(s); 
     240        reader.setSeries(s); 
    237241        // NB: ImageJ 1.39+ is required for VirtualStack 
    238242        BFVirtualStack virtualStackB = new BFVirtualStack(options.getId(), 
    239           r, options.isColorize(), doMerge, options.isRecord()); 
     243          reader, options.isColorize(), doMerge, options.isRecord()); 
    240244        stackB = virtualStackB; 
    241245        if (doMerge) { 
    242           for (int j=0; j<r.getImageCount(); j++) { 
    243             int[] pos = r.getZCTCoords(j); 
     246          for (int j=0; j<reader.getImageCount(); j++) { 
     247            int[] pos = reader.getZCTCoords(j); 
    244248            if (pos[1] > 0) continue; 
    245249            String label = constructSliceLabel( 
    246               new ChannelMerger(r).getIndex(pos[0], pos[1], pos[2]), 
    247               new ChannelMerger(r), process.getOMEMetadata(), s, 
     250              new ChannelMerger(reader).getIndex(pos[0], pos[1], pos[2]), 
     251              new ChannelMerger(reader), process.getOMEMetadata(), s, 
    248252              options.getZCount(s), options.getCCount(s), 
    249253              options.getTCount(s)); 
     
    252256        } 
    253257        else { 
    254           for (int j=0; j<r.getImageCount(); j++) { 
    255             String label = constructSliceLabel(j, r, 
     258          for (int j=0; j<reader.getImageCount(); j++) { 
     259            String label = constructSliceLabel(j, reader, 
    256260              process.getOMEMetadata(), s, options.getZCount(s), 
    257261              options.getCCount(s), options.getTCount(s)); 
     
    264268        //if (r.isIndexed()) colorModels = new IndexColorModel[r.getSizeC()]; 
    265269 
    266         for (int i=0; i<r.getImageCount(); i++) { 
     270        for (int i=0; i<reader.getImageCount(); i++) { 
    267271          if (!load[i]) continue; 
    268272 
     
    270274          long clock = System.currentTimeMillis(); 
    271275          if (clock - time >= 100) { 
    272             String sLabel = r.getSeriesCount() > 1 ? 
     276            String sLabel = reader.getSeriesCount() > 1 ? 
    273277              ("series " + (s + 1) + ", ") : ""; 
    274278            String pLabel = "plane " + (i + 1) + "/" + total; 
     
    278282          notifyListeners(new StatusEvent(q++, total, null)); 
    279283 
    280           String label = constructSliceLabel(i, r, 
     284          String label = constructSliceLabel(i, reader, 
    281285            process.getOMEMetadata(), s, options.getZCount(s), 
    282286            options.getCCount(s), options.getTCount(s)); 
     
    284288          // get image processor for ith plane 
    285289          ImageProcessor[] p; 
    286           p = r.openProcessors(i, region.x, region.y, 
     290          p = reader.openProcessors(i, region.x, region.y, 
    287291            region.width, region.height); 
    288292          ImageProcessor ip = p[0]; 
     
    351355    long endTime = System.currentTimeMillis(); 
    352356    double elapsed = (endTime - startTime) / 1000.0; 
    353     if (r.getImageCount() == 1) { 
     357    if (reader.getImageCount() == 1) { 
    354358      notifyListeners(new StatusEvent("Bio-Formats: " + elapsed + " seconds")); 
    355359    } 
    356360    else { 
    357       long average = (endTime - startTime) / r.getImageCount(); 
     361      long average = (endTime - startTime) / reader.getImageCount(); 
    358362      notifyListeners(new StatusEvent("Bio-Formats: " + 
    359363        elapsed + " seconds (" + average + " ms per plane)")); 
     
    377381    int zCount = options.getZCount(series); 
    378382    int tCount = options.getTCount(series); 
    379     IFormatReader r = process.getReader(); 
     383    IFormatReader reader = process.getReader(); 
    380384     
    381     if (cCount == 0) cCount = r.getEffectiveSizeC(); 
    382     if (zCount == 0) zCount = r.getSizeZ(); 
    383     if (tCount == 0) tCount = r.getSizeT(); 
    384  
    385     String title = getTitle(r, file, seriesName, options.isGroupFiles()); 
     385    if (cCount == 0) cCount = reader.getEffectiveSizeC(); 
     386    if (zCount == 0) zCount = reader.getSizeZ(); 
     387    if (tCount == 0) tCount = reader.getSizeT(); 
     388 
     389    String title = getTitle(reader, file, seriesName, options.isGroupFiles()); 
    386390    ImagePlus imp = null; 
    387391    if (options.isVirtual()) { 
    388392      imp = new VirtualImagePlus(title, stack); 
    389       ((VirtualImagePlus) imp).setReader(r); 
     393      ((VirtualImagePlus) imp).setReader(reader); 
    390394    } 
    391395    else imp = new ImagePlus(title, stack); 
     
    396400 
    397401    // retrieve the spatial calibration information, if available 
    398     ImagePlusTools.applyCalibration(meta, imp, r.getSeries()); 
     402    ImagePlusTools.applyCalibration(meta, imp, reader.getSeries()); 
    399403    imp.setFileInfo(fi); 
    400404    imp.setDimensions(cCount, zCount, tCount); 
     
    406410 
    407411    if (options.isAutoscale() && !options.isVirtual()) { 
    408       ImagePlusTools.adjustColorRange(imp, r); 
     412      ImagePlusTools.adjustColorRange(imp, reader); 
    409413    } 
    410414    else if (!(imp.getProcessor() instanceof ColorProcessor)) { 
  • trunk/components/loci-plugins/src/loci/plugins/in/ImportProcess.java

    r6265 r6271  
    11// 
    2 // ImporterReader.java 
     2// ImportProcess.java 
    33// 
    44 
     
    2929 
    3030import java.io.IOException; 
     31import java.util.ArrayList; 
     32import java.util.List; 
    3133 
    3234import loci.common.Location; 
     35import loci.common.StatusEvent; 
     36import loci.common.StatusListener; 
     37import loci.common.StatusReporter; 
    3338import loci.common.services.DependencyException; 
    3439import loci.common.services.ServiceException; 
    3540import loci.common.services.ServiceFactory; 
    3641import loci.formats.ChannelSeparator; 
     42import loci.formats.DimensionSwapper; 
    3743import loci.formats.FilePattern; 
    3844import loci.formats.FileStitcher; 
     
    5359 
    5460/** 
    55  * Helper class for managing Bio-Formats readers and associated metadata. 
     61 * Manages the import preparation process. 
    5662 * 
    5763 * <dl><dt><b>Source code:</b></dt> 
    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> 
     64 * <dd><a href="https://skyking.microscopy.wisc.edu/trac/java/browser/trunk/components/loci-plugins/src/loci/plugins/in/ImportProcess.java">Trac</a>, 
     65 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/in/ImportProcess.java">SVN</a></dd></dl> 
    6066 */ 
    61 public class ImportProcess { 
     67public class ImportProcess implements StatusReporter { 
    6268 
    6369  // -- Fields -- 
    6470 
     71  private List<StatusListener> listeners = new ArrayList<StatusListener>(); 
     72 
    6573  /** Associated importer options. */ 
    66   protected ImporterOptions options; 
     74  private ImporterOptions options; 
     75 
     76  // reader stack, from bottom to top 
     77  private IFormatReader baseReader; 
     78  private FileStitcher fileStitcher; 
     79  private ChannelSeparator channelSeparator; 
     80  private DimensionSwapper dimensionSwapper; 
     81  private VirtualReader virtualReader; 
     82  private ImageProcessorReader reader; 
     83   
     84  /** Whether the process has been canceled. */ 
     85  private boolean cancel; 
    6786 
    6887  protected String idName; 
    6988  protected Location idLoc; 
    7089 
    71   private IFormatReader baseReader; 
    72   protected ImageProcessorReader reader; 
    73   protected VirtualReader virtualReader; 
    74  
    7590  protected IMetadata meta; 
    7691 
     
    90105  } 
    91106 
    92   // -- ImportProcess API methods -- 
     107  // -- ImportProcess methods -- 
    93108 
    94109  public ImporterOptions getOptions() { return options; } 
    95  
    96   // CTR TEMP 
    97   public void go() { 
     110   
     111  public boolean isWindowless() { 
     112    if (options.isWindowless()) return true; // globally windowless 
     113    return baseReader != null && LociPrefs.isWindowless(baseReader); 
     114  } 
     115 
     116  /** Valid only after {@link ImportStep#READER}. */ 
     117  public IFormatReader getBaseReader() { return baseReader; } 
     118  /** Valid only after {@link ImportStep#READER}. */ 
     119  public String getIdName() { return idName; } 
     120  /** Valid only after {@link ImportStep#READER}. */ 
     121  public Location getIdLocation() { return idLoc; } 
     122  /** Valid only after {@link ImportStep#READER}. */ 
     123  public IMetadata getOMEMetadata() { return meta; } 
     124 
     125  /** Valid only after {@link ImportStep#STACK}. */ 
     126  public FileStitcher getFileStitcher() { return fileStitcher; } 
     127  /** Valid only after {@link ImportStep#STACK}. */ 
     128  public ChannelSeparator getChannelSeparator() { return channelSeparator; } 
     129  /** Valid only after {@link ImportStep#STACK}. */ 
     130  public DimensionSwapper getDimensionSwapper() { return dimensionSwapper; } 
     131  /** Valid only after {@link ImportStep#STACK}. */ 
     132  public VirtualReader getVirtualReader() { return virtualReader; } 
     133  /** Valid only after {@link ImportStep#STACK}. */ 
     134  public ImageProcessorReader getReader() { return reader; } 
     135 
     136  /** Valid only after {@link ImportStep#STACK}. */ 
     137  public String getCurrentFile() { return reader.getCurrentFile(); } 
     138  /** Valid only after {@link ImportStep#STACK}. */ 
     139  public int getSeriesCount() { return getReader().getSeriesCount(); } 
     140  /** Valid only after {@link ImportStep#STACK}. */ 
     141  public String getSeriesLabel(int s) { 
     142    if (seriesLabels == null || s >= seriesLabels.length) return null; 
     143    return seriesLabels[s]; 
     144  } 
     145 
     146  /** Valid only after {@link ImportStep#METADATA}. */ 
     147  public ImporterMetadata getOriginalMetadata() { return metadata; } 
     148 
     149  /** 
     150   * Performs the import process, notifying status listeners at each step. 
     151   *  
     152   * @return true if the process completed successfully. 
     153   */ 
     154  public boolean process() throws FormatException, IOException { 
     155    notifyListeners(ImportStep.READER); 
     156    if (cancel) return false; 
     157    initializeReader(); 
     158 
     159    notifyListeners(ImportStep.FILE); 
     160    if (cancel) return false; 
     161    initializeFile(); 
     162 
     163    notifyListeners(ImportStep.STACK); 
     164    if (cancel) return false; 
     165    initializeStack(); 
     166 
     167    notifyListeners(ImportStep.SERIES); 
     168    if (cancel) return false; 
     169    initializeSeries(); 
     170 
     171    notifyListeners(ImportStep.DIM_ORDER); 
     172    if (cancel) return false; 
     173    initializeDimOrder(); 
     174 
     175    notifyListeners(ImportStep.RANGE); 
     176    if (cancel) return false; 
     177    initializeRange(); 
     178 
     179    notifyListeners(ImportStep.CROP); 
     180    if (cancel) return false; 
     181    initializeCrop(); 
     182 
     183    notifyListeners(ImportStep.METADATA); 
     184    if (cancel) return false; 
     185    initializeMetadata(); 
     186 
     187    notifyListeners(ImportStep.COMPLETE); 
     188    return true; 
     189  } 
     190   
     191  /** Cancels the import process. */ 
     192  public void cancel() { this.cancel = true; } 
     193   
     194  /** Gets whether the import process was canceled. */ 
     195  public boolean wasCanceled() { return cancel; } 
     196 
     197  // -- StatusReporter methods -- 
     198 
     199  public void addStatusListener(StatusListener l) { 
     200    synchronized (listeners) { 
     201      listeners.add(l); 
     202    } 
     203  } 
     204 
     205  public void removeStatusListener(StatusListener l) { 
     206    synchronized (listeners) { 
     207      listeners.remove(l); 
     208    } 
     209  } 
     210 
     211  public void notifyListeners(StatusEvent e) { 
     212    synchronized (listeners) { 
     213      for (StatusListener l : listeners) l.statusUpdated(e); 
     214    } 
     215  } 
     216 
     217  // -- Helper methods - process steps -- 
     218 
     219  /** Performed following ImportStep.READER notification. */ 
     220  private void initializeReader() { 
    98221    computeNameAndLocation(); 
    99222    createBaseReader(); 
    100223  } 
    101224 
    102   // CTR TEMP 
    103   public void prepareStuff() throws FormatException, IOException { 
     225  /** Performed following ImportStep.FILE notification. */ 
     226  private void initializeFile() throws FormatException, IOException { 
     227    saveDefaults(); 
     228 
    104229    if (!options.isQuiet()) IJ.showStatus("Analyzing " + getIdName()); 
    105230    baseReader.setMetadataFiltered(true); 
     
    109234  } 
    110235 
    111   // CTR TEMP 
    112   public void initializeReader() throws FormatException, IOException { 
     236  /** Performed following ImportStep.STACK notification. */ 
     237  private void initializeStack() throws FormatException, IOException { 
     238    IFormatReader r = baseReader; 
     239 
    113240    if (options.isGroupFiles()) { 
    114       FileStitcher fileStitcher = new FileStitcher(baseReader); 
    115       baseReader = fileStitcher; 
     241      r = fileStitcher = new FileStitcher(baseReader); 
    116242 
    117243      // overwrite base filename with file pattern 
     
    124250      fileStitcher.setUsingPatternIds(true); 
    125251    } 
    126  
    127     baseReader.setId(options.getId()); 
     252    r.setId(options.getId()); 
     253 
    128254    if (options.isVirtual() || !options.isMergeChannels() || 
    129       FormatTools.getBytesPerPixel(baseReader.getPixelType()) != 1) 
     255      FormatTools.getBytesPerPixel(r.getPixelType()) != 1) 
    130256    { 
    131       baseReader = new ChannelSeparator(baseReader); 
    132     } 
    133     virtualReader = new VirtualReader(baseReader); 
    134     reader = new ImageProcessorReader(virtualReader); 
     257      r = channelSeparator = new ChannelSeparator(r); 
     258    } 
     259    r = dimensionSwapper = new DimensionSwapper(r); 
     260    r = virtualReader = new VirtualReader(r); 
     261    reader = new ImageProcessorReader(r); 
    135262    reader.setId(options.getId()); 
    136   } 
    137  
    138   public boolean isWindowless() { 
    139     if (options.isWindowless()) return true; // globally windowless 
    140     return baseReader != null && LociPrefs.isWindowless(baseReader); 
    141   } 
    142  
    143   // -- Helper methods -- 
     263     
     264    computeSeriesLabels(); 
     265  } 
     266 
     267  /** Performed following ImportStep.SERIES notification. */ 
     268  private void initializeSeries() { } 
     269 
     270  /** Performed following ImportStep.DIM_ORDER notification. */ 
     271  private void initializeDimOrder() { 
     272    String dimOrder = options.getInputOrder(); 
     273    if (dimOrder != null) dimensionSwapper.swapDimensions(dimOrder); 
     274  } 
     275 
     276  /** Performed following ImportStep.RANGE notification. */ 
     277  private void initializeRange() { } 
     278 
     279  /** Performed following ImportStep.CROP notification. */ 
     280  private void initializeCrop() { } 
     281 
     282  /** Performed following ImportStep.METADATA notification. */ 
     283  private void initializeMetadata() { 
     284    // only prepend a series name prefix to the metadata keys if multiple 
     285    // series are being opened 
     286    int seriesCount = getSeriesCount(); 
     287    int numEnabled = 0; 
     288    for (int s=0; s<seriesCount; s++) { 
     289      if (options.isSeriesOn(s)) numEnabled++; 
     290    } 
     291    metadata = new ImporterMetadata(getReader(), this, numEnabled > 1); 
     292  } 
     293 
     294  // -- Helper methods - ImportStep.READER -- 
    144295 
    145296  /** Initializes the idName and idLoc derived values. */ 
     
    210361        "Sorry, there has been an internal error: unknown data source"); 
    211362    } 
     363    Exception exc = null; 
    212364    try { 
    213365      ServiceFactory factory = new ServiceFactory(); 
     
    215367      meta = service.createOMEXMLMetadata(); 
    216368    } 
    217     catch (DependencyException de) { } 
    218     catch (ServiceException se) { } 
     369    catch (DependencyException de) { exc = de; } 
     370    catch (ServiceException se) { exc = se; } 
     371    if (exc != null) { 
     372        WindowTools.reportException(exc, options.isQuiet(), 
     373          "Sorry, there was a problem constructing the OME-XML metadata store"); 
     374    } 
    219375    baseReader.setMetadataStore(meta); 
    220376 
     
    225381    root.addAppender(new IJStatusEchoer()); 
    226382  } 
    227  
    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  
     383   
     384  // -- Helper methods - ImportStep.FILE -- 
     385 
     386  /** Performed following ImportStep.FILE notification. */ 
     387  private void saveDefaults() { 
     388    // save options as new defaults 
     389    if (!options.isQuiet()) options.setFirstTime(false); 
     390    options.saveOptions(); 
     391  } 
     392   
     393  // -- Helper methods -- ImportStep.STACK -- 
     394   
    242395  /** Initializes the seriesLabels derived value. */ 
    243396  private void computeSeriesLabels() { 
     
    290443    } 
    291444  } 
    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); 
     445   
     446  // -- Helper methods - miscellaneous -- 
     447 
     448  private void notifyListeners(ImportStep step) { 
     449    notifyListeners(new StatusEvent(step.getStep(), 
     450      ImportStep.COMPLETE.getStep(), step.getMessage())); 
    311451  } 
    312452 
  • trunk/components/loci-plugins/src/loci/plugins/in/Importer.java

    r6265 r6271  
    119119    throws FormatException, IOException 
    120120  { 
    121     boolean success = new ImporterPrompter(process).showDialogs(); 
    122     if (!success) plugin.canceled = true; 
     121    // attach dialog prompter to process 
     122    new ImporterPrompter(process); 
     123    // execute the preparation process 
     124    process.process(); 
     125    if (process.wasCanceled()) plugin.canceled = true; 
    123126  } 
    124127 
  • trunk/components/loci-plugins/src/loci/plugins/in/ImporterPrompter.java

    r6265 r6271  
    2626package loci.plugins.in; 
    2727 
    28 import java.io.IOException; 
     28import ij.IJ; 
    2929 
    30 import loci.formats.FormatException; 
     30import loci.common.StatusEvent; 
     31import loci.common.StatusListener; 
    3132import loci.plugins.prefs.OptionsDialog; 
    3233 
     
    3435 * Helper class for presenting the user with dialog boxes 
    3536 * for configuring importer options. 
    36  * 
     37 *  
    3738 * If running as a macro, gets parameter values from macro options; 
    3839 * if not, get parameter values from user input from dialog boxes. 
     40 * 
     41 * Which dialogs are shown depends on a variety of factors, including the 
     42 * current configuration (i.e., which options are enabled), whether quiet or 
     43 * windowless mode is set, and whether the method is being called from within 
     44 * a macro. 
    3945 * 
    4046 * <dl><dt><b>Source code:</b></dt> 
     
    4248 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/in/ImporterPrompter.java">SVN</a></dd></dl> 
    4349 */ 
    44 public class ImporterPrompter { 
     50public class ImporterPrompter implements StatusListener { 
    4551 
    4652  // -- Fields -- 
     
    5258  public ImporterPrompter(ImportProcess process) { 
    5359    this.process = process; 
     60    process.addStatusListener(this); 
    5461  } 
    5562 
    56   // -- ImporterPrompter methods -- 
     63  // -- StatusListener methods -- 
    5764 
    58   /** 
    59    * Displays dialog boxes prompting for additional configuration details. 
    60    * 
    61    * Which dialogs are shown depends on a variety of factors, including the 
    62    * current configuration (i.e., which options are enabled), whether quiet or 
    63    * windowless mode is set, and whether the method is being called from within 
    64    * a macro. 
    65    * 
    66    * After calling this method, derived field values will also be populated. 
    67    * 
    68    * @return true if harvesting went OK, or false if something went wrong 
    69    *   (e.g., the user canceled a dialog box) 
    70    * 
    71    * @see ij.gui.GenericDialog 
    72    */ 
    73   public boolean showDialogs() throws FormatException, IOException { 
    74     if (!promptUpgrade()) return false; 
     65  public void statusUpdated(StatusEvent e) { 
     66    final String message = e.getStatusMessage(); 
     67    final int value = e.getProgressValue(); 
     68    //final int max = e.getProgressMaximum(); 
     69    final ImportStep step = ImportStep.getStep(value); 
    7570 
    76     if (!promptLocation()) return false; 
    77     if (!promptId()) return false; 
     71    if (!process.getOptions().isQuiet()) IJ.showStatus(message); 
    7872 
    79     process.go(); 
    80  
    81     if (!promptMain()) return false; 
    82  
    83     process.saveDefaults(); 
    84  
    85     process.prepareStuff(); 
    86  
    87     if (!promptFilePattern()) return false; 
    88  
    89     process.initializeReader(); 
    90  
    91     if (!promptSeries()) return false; 
    92     if (!promptSwap()) return false; 
    93     if (!promptRange()) return false; 
    94     if (!promptCrop()) return false; 
    95  
    96     process.initializeMetadata(); 
    97  
    98     return true; 
     73    switch (step) { 
     74      case READER: 
     75        if (!promptUpgrade()) { process.cancel(); break; } 
     76        if (!promptLocation()) { process.cancel(); break; } 
     77        if (!promptId()) { process.cancel(); break; } 
     78        break; 
     79      case FILE: 
     80        if (!promptMain()) process.cancel(); 
     81        break; 
     82      case STACK: 
     83        if (!promptFilePattern()) process.cancel(); 
     84        break; 
     85      case SERIES: 
     86        if (!promptSeries()) process.cancel(); 
     87        break; 
     88      case DIM_ORDER: 
     89        if (!promptSwap()) process.cancel(); 
     90        break; 
     91      case RANGE: 
     92        if (!promptRange()) process.cancel(); 
     93        break; 
     94      case CROP: 
     95        if (!promptCrop()) process.cancel(); 
     96        break; 
     97      case METADATA: 
     98        break; 
     99      case COMPLETE: 
     100        break; 
     101      default: 
     102    } 
    99103  } 
    100104 
     
    150154    return dialog.showDialog() == OptionsDialog.STATUS_OK; 
    151155  } 
    152  
     156   
    153157} 
  • trunk/components/loci-plugins/src/loci/plugins/in/SwapDialog.java

    r6265 r6271  
    2626package loci.plugins.in; 
    2727 
    28 import java.io.IOException; 
    29  
    3028import ij.IJ; 
    3129import ij.gui.GenericDialog; 
    32 import loci.formats.DimensionSwapper; 
    33 import loci.formats.FormatException; 
     30 
     31import loci.plugins.util.ImageProcessorReader; 
    3432import loci.plugins.util.WindowTools; 
    3533 
     
    4341public class SwapDialog extends ImporterDialog { 
    4442 
    45   // -- Fields -- 
    46  
    47   protected DimensionSwapper dimSwap; 
    48  
    4943  // -- Constructor -- 
    5044 
     
    5246  public SwapDialog(ImportProcess process) { 
    5347    super(process); 
    54     try { 
    55       dimSwap = (DimensionSwapper) 
    56         process.getReader().unwrap(DimensionSwapper.class, null); 
    57     } 
    58     catch (FormatException e) { 
    59       // TODO Auto-generated catch block 
    60       e.printStackTrace(); 
    61     } 
    62     catch (IOException e) { 
    63       // TODO Auto-generated catch block 
    64       e.printStackTrace(); 
    65     } 
    6648  } 
    6749 
     
    7557  @Override 
    7658  protected GenericDialog constructDialog() { 
     59    ImageProcessorReader reader = process.getReader(); 
     60    int seriesCount = process.getSeriesCount(); 
     61 
    7762    GenericDialog gd = new GenericDialog("Dimension swapping options"); 
    7863 
    7964    String[] labels = {"Z", "C", "T"}; 
    8065    int[] sizes = new int[] { 
    81       dimSwap.getSizeZ(), dimSwap.getSizeC(), dimSwap.getSizeT() 
     66      reader.getSizeZ(), reader.getSizeC(), reader.getSizeT() 
    8267    }; 
    83     for (int s=0; s<dimSwap.getSeriesCount(); s++) { 
     68    for (int s=0; s<seriesCount; s++) { 
    8469      if (!options.isSeriesOn(s)) continue; 
    85       dimSwap.setSeries(s); 
     70      reader.setSeries(s); 
    8671 
    8772      gd.addMessage("Series " + (s + 1) + ":\n"); 
     
    9277    } 
    9378    WindowTools.addScrollBars(gd); 
    94      
     79 
    9580    return gd; 
    9681  } 
     
    9883  @Override 
    9984  protected boolean harvestResults(GenericDialog gd) { 
    100     for (int s=0; s<dimSwap.getSeriesCount(); s++) { 
     85    ImageProcessorReader reader = process.getReader(); 
     86    int seriesCount = process.getSeriesCount(); 
     87 
     88    for (int s=0; s<seriesCount; s++) { 
    10189      if (!options.isSeriesOn(s)) continue; 
    102       dimSwap.setSeries(s); 
     90      reader.setSeries(s); 
    10391      String z = gd.getNextChoice(); 
    10492      String c = gd.getNextChoice(); 
     
    11098      } 
    11199 
    112       String originalOrder = dimSwap.getDimensionOrder(); 
     100      String originalOrder = reader.getDimensionOrder(); 
    113101      StringBuffer sb = new StringBuffer(); 
    114102      sb.append("XY"); 
     
    119107      } 
    120108 
    121       dimSwap.swapDimensions(sb.toString()); 
     109      // CTR FIXME - need separate input order for each series... 
     110      options.setInputOrder(sb.toString()); 
    122111    } 
    123112    return true; 
  • trunk/components/loci-plugins/src/loci/plugins/util/VirtualReader.java

    r5881 r6271  
    2828import java.io.IOException; 
    2929 
    30 import loci.formats.DimensionSwapper; 
    3130import loci.formats.IFormatReader; 
     31import loci.formats.ReaderWrapper; 
    3232 
    3333/** 
     
    4040 * @author Melissa Linkert linkert at wisc.edu 
    4141 */ 
    42 public class VirtualReader extends DimensionSwapper { 
     42public class VirtualReader extends ReaderWrapper { 
    4343 
    4444  // -- Fields -- 
  • trunk/components/loci-plugins/src/loci/plugins/util/WindowTools.java

    r6229 r6271  
    4747import java.io.ByteArrayOutputStream; 
    4848import java.io.PrintStream; 
     49import java.util.List; 
    4950import java.util.StringTokenizer; 
    50 import java.util.Vector; 
    5151 
    5252/** 
     
    195195 
    196196  @SuppressWarnings("unchecked") 
    197   public static Vector<TextField> getNumericFields(GenericDialog gd) { 
     197  public static List<TextField> getNumericFields(GenericDialog gd) { 
    198198    return gd.getNumericFields(); 
    199199  } 
    200200 
    201201  @SuppressWarnings("unchecked") 
    202   public static Vector<Checkbox> getCheckboxes(GenericDialog gd) { 
     202  public static List<Checkbox> getCheckboxes(GenericDialog gd) { 
    203203    return gd.getCheckboxes(); 
    204204  } 
  • trunk/components/loci-plugins/test/loci/plugins/in/ImporterTest.java

    r6270 r6271  
    55package loci.plugins.in; 
    66 
     7import static org.junit.Assert.assertEquals;  
     8import static org.junit.Assert.assertNotNull;  
     9import static org.junit.Assert.assertTrue;  
     10import static org.junit.Assert.fail;  
     11 
    712import ij.ImagePlus; 
    813import ij.ImageStack; 
     
    1116import java.io.IOException; 
    1217import java.lang.reflect.Field; 
    13  
    14 import junit.framework.TestCase; 
    1518 
    1619import loci.common.Location; 
     
    3437//  - add some tests for combination of options 
    3538 
    36 public class ImporterTest extends TestCase { 
     39public class ImporterTest { 
    3740 
    3841  private enum Axis {Z,C,T}; 
     
    656659    assertEquals(32,imps[0].getStack().getSize()); 
    657660  } 
    658    
     661 
    659662  @Test 
    660663  public void testDatasetSwapDims() 
    661664  { 
    662665    // TODO: testing only swapping Z&T of XYZTC. Add more option testing 
    663      
     666 
    664667    datasetSwapDimsTest(FormatTools.UINT8, 82, 47, 1, 3); 
    665668    datasetSwapDimsTest(FormatTools.UINT16, 82, 47, 3, 1); 
     
    669672    datasetSwapDimsTest(FormatTools.INT32, 44, 109, 4, 3); 
    670673  } 
    671    
     674 
    672675  @Test 
    673676  public void testDatasetOpenAllSeries() 
     
    677680    datasetOpenAllSeriesTest(73,107,5,3,4,4);  // multiple series with Z,C,T larger than 1 
    678681  } 
    679    
     682 
    680683  @Test 
    681684  public void testDatasetConcatenate() 
     
    686689    datasetConcatenateTest(FormatTools.UINT8, "XYZCT", 82, 47, 4, 5, 2, 9); 
    687690  } 
    688    
     691 
    689692  @Test 
    690693  public void testColorMerge() 
     
    693696    fail("to be implemented"); 
    694697  } 
    695    
     698 
    696699  @Test 
    697700  public void testColorRgbColorize() 
     
    700703    fail("to be implemented"); 
    701704  } 
    702    
     705 
    703706  @Test 
    704707  public void testColorCustomColorize() 
     
    707710    fail("to be implemented"); 
    708711  } 
    709    
     712 
    710713  @Test 
    711714  public void testColorAutoscale() 
     
    714717    fail("to be implemented"); 
    715718  } 
    716    
     719 
    717720  @Test 
    718721  public void testMemoryVirtualStack() 
     
    721724    memoryVirtualStackTest(true); 
    722725  } 
    723    
     726 
    724727  @Test 
    725728  public void testMemoryRecordModifications() 
     
    735738    fail("to be implemented"); 
    736739  } 
    737    
     740 
    738741  @Test 
    739742  public void testMemorySpecifyRange() 
    740743  { 
    741744    int z,c,t,zFrom,zTo,zBy,cFrom,cTo,cBy,tFrom,tTo,tBy; 
    742      
     745 
    743746    // test partial z: from 
    744747    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; 
     
    922925  } 
    923926 
    924   // ** Main method ***************************************************************** 
    925  
    926   public static void main(String[] args) 
    927   { 
    928     //TODO - run all test methods via JUnit 
    929     //TestSuite suite = new TestSuite(ImporterTest.class); 
    930     //TestResult result = new TestResult(); 
    931     //suite.run(result); 
    932  
    933     ImporterTest tester = new ImporterTest(); 
    934    
    935     // tests of single features 
    936     tester.testDefaultBehavior(); 
    937     tester.testOutputStackOrder(); 
    938     //tester.testDatasetGroupFiles(); 
    939     //tester.testDatasetOpenFilesIndividually(); 
    940     //tester.testDatasetSwapDims(); 
    941     tester.testDatasetOpenAllSeries(); 
    942     //tester.testDatasetConcatenate(); 
    943     //tester.testColorMerge(); 
    944     //tester.testColorRgbColorize(); 
    945     //tester.testColorCustomColorize(); 
    946     tester.testColorAutoscale(); 
    947     tester.testMemoryVirtualStack(); 
    948     tester.testMemoryRecordModifications(); 
    949     tester.testMemorySpecifyRange(); 
    950     tester.testMemoryCrop(); 
    951     tester.testSplitChannels(); 
    952     tester.testSplitFocalPlanes(); 
    953     tester.testSplitTimepoints(); 
    954      
    955     // TODO - add tests involving combinations of features 
    956      
    957     System.exit(0); 
    958   } 
    959927} 
Note: See TracChangeset for help on using the changeset viewer.