Changeset 6284


Ignore:
Timestamp:
05/11/10 17:37:08 (10 years ago)
Author:
curtis
Message:

Progress on Z/C/T splitting. Works with Importer plugin, but test still fails.

Location:
trunk/components/loci-plugins/src/loci/plugins
Files:
5 edited

Legend:

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

    r6229 r6284  
    6363  /** Current image stack. */ 
    6464  private ImagePlus imp; 
    65  
    66   // -- PlugInFilter API methods -- 
    67  
    68   public int setup(String arg, ImagePlus imp) { 
    69     this.arg = arg; 
    70     this.imp = imp; 
    71     return DOES_ALL + NO_CHANGES; 
    72   } 
    73  
    74   public void run(ImageProcessor ip) { 
    75     if (!LibraryChecker.checkJava() || !LibraryChecker.checkImageJ()) return; 
    76  
    77     boolean sliceC = false; 
    78     boolean sliceZ = false; 
    79     boolean sliceT = false; 
    80     String stackOrder = null; 
    81     boolean keepOriginal = false; 
    82     boolean hyperstack = false; 
    83  
    84     if (arg == null || arg.trim().equals("")) { 
    85       // prompt for slicing options 
    86  
    87       GenericDialog gd = new GenericDialog("Slicing options..."); 
    88       gd.addCheckbox("Split channels", false); 
    89       gd.addCheckbox("Split Z slices", false); 
    90       gd.addCheckbox("Split timepoints", false); 
    91       gd.addCheckbox("Keep original stack", false); 
    92       gd.addCheckbox("Open as hyperstack", true); 
    93       gd.addChoice("Stack order", new String[] {"XYCZT", "XYCTZ", "XYZCT", 
    94         "XYZTC", "XYTCZ", "XYTZC"}, "XYCZT"); 
    95       gd.showDialog(); 
    96  
    97       if (gd.wasCanceled()) { 
    98         canceled = true; 
    99         return; 
    100       } 
    101  
    102       sliceC = gd.getNextBoolean(); 
    103       sliceZ = gd.getNextBoolean(); 
    104       sliceT = gd.getNextBoolean(); 
    105       keepOriginal = gd.getNextBoolean(); 
    106       hyperstack = gd.getNextBoolean(); 
    107       stackOrder = gd.getNextChoice(); 
    108     } 
    109     else { 
    110       sliceC = getBooleanValue("slice_c"); 
    111       sliceZ = getBooleanValue("slice_z"); 
    112       sliceT = getBooleanValue("slice_t"); 
    113       keepOriginal = getBooleanValue("keep_original"); 
    114       hyperstack = getBooleanValue("hyper_stack"); 
    115       stackOrder = Macro.getValue(arg, "stack_order", "XYCZT"); 
    116     } 
    117  
    118     if (imp.getImageStack().isVirtual()) { 
    119       IJ.error("Slicer plugin cannot be used with virtual stacks.\n" + 
    120       "Please convert the virtual stack using Image>Duplicate."); 
    121       return; 
    122     } 
    123     ImagePlus[] newImps = Slicer.reslice(imp, 
    124       sliceC, sliceZ, sliceT, hyperstack, stackOrder); 
    125     if (!keepOriginal) imp.close(); 
    126     for (ImagePlus imp : newImps) imp.show(); 
    127   } 
    128  
    129   // -- Helper methods -- 
    130  
    131   /** Gets the value of the given macro key as a boolean. */ 
    132   private boolean getBooleanValue(String key) { 
    133     return Boolean.valueOf(Macro.getValue(arg, key, "false")); 
    134   } 
    135  
    136   // -- Static utility methods -- 
    137  
    138   public static ImagePlus[] reslice(ImagePlus imp, 
     65   
     66  // -- Slicer methods -- 
     67   
     68  public ImagePlus[] reslice(ImagePlus imp, 
    13969    boolean sliceC, boolean sliceZ, boolean sliceT, 
    140     boolean hyperstack, String stackOrder) 
     70    String stackOrder) 
    14171  { 
    14272    ImageStack stack = imp.getImageStack(); 
     73    boolean hyperstack = imp.isHyperStack(); 
    14374 
    14475    if (stack.isVirtual()) { 
     
    210141  } 
    211142 
     143  // -- PlugInFilter methods -- 
     144 
     145  public int setup(String arg, ImagePlus imp) { 
     146    this.arg = arg; 
     147    this.imp = imp; 
     148    return DOES_ALL + NO_CHANGES; 
     149  } 
     150 
     151  public void run(ImageProcessor ip) { 
     152    if (!LibraryChecker.checkJava() || !LibraryChecker.checkImageJ()) return; 
     153 
     154    boolean sliceC = false; 
     155    boolean sliceZ = false; 
     156    boolean sliceT = false; 
     157    String stackOrder = null; 
     158    boolean keepOriginal = false; 
     159 
     160    if (arg == null || arg.trim().equals("")) { 
     161      // prompt for slicing options 
     162 
     163      GenericDialog gd = new GenericDialog("Slicing options..."); 
     164      gd.addCheckbox("Split channels", false); 
     165      gd.addCheckbox("Split Z slices", false); 
     166      gd.addCheckbox("Split timepoints", false); 
     167      gd.addCheckbox("Keep original stack", false); 
     168      gd.addChoice("Stack order", new String[] {"XYCZT", "XYCTZ", "XYZCT", 
     169        "XYZTC", "XYTCZ", "XYTZC"}, "XYCZT"); 
     170      gd.showDialog(); 
     171 
     172      if (gd.wasCanceled()) { 
     173        canceled = true; 
     174        return; 
     175      } 
     176 
     177      sliceC = gd.getNextBoolean(); 
     178      sliceZ = gd.getNextBoolean(); 
     179      sliceT = gd.getNextBoolean(); 
     180      keepOriginal = gd.getNextBoolean(); 
     181      stackOrder = gd.getNextChoice(); 
     182    } 
     183    else { 
     184      sliceC = getBooleanValue("slice_c"); 
     185      sliceZ = getBooleanValue("slice_z"); 
     186      sliceT = getBooleanValue("slice_t"); 
     187      keepOriginal = getBooleanValue("keep_original"); 
     188      stackOrder = Macro.getValue(arg, "stack_order", "XYCZT"); 
     189    } 
     190 
     191    if (imp.getImageStack().isVirtual()) { 
     192      IJ.error("Slicer plugin cannot be used with virtual stacks.\n" + 
     193      "Please convert the virtual stack using Image>Duplicate."); 
     194      return; 
     195    } 
     196    ImagePlus[] newImps = reslice(imp, 
     197      sliceC, sliceZ, sliceT, stackOrder); 
     198    if (!keepOriginal) imp.close(); 
     199    for (ImagePlus imp : newImps) imp.show(); 
     200  } 
     201 
     202  // -- Helper methods -- 
     203 
     204  /** Gets the value of the given macro key as a boolean. */ 
     205  private boolean getBooleanValue(String key) { 
     206    return Boolean.valueOf(Macro.getValue(arg, key, "false")); 
     207  } 
     208 
    212209} 
  • trunk/components/loci-plugins/src/loci/plugins/in/Concatenator.java

    r6265 r6284  
    3232import java.util.List; 
    3333 
    34 import loci.formats.IFormatReader; 
    35 import loci.plugins.colorize.Colorizer; 
    36  
    3734/** 
    3835 * Logic for concatenating multiple images together. 
     
    4643public class Concatenator { 
    4744 
    48   protected ImportProcess process; 
    49  
    50   public Concatenator(ImportProcess process) { 
    51     this.process = process; 
    52   } 
    53  
    5445  /** Concatenates the list of images as appropriate. */ 
    55   public List<ImagePlus> concatenate(List<ImagePlus> imps, String stackOrder) { 
    56     ImporterOptions options = process.getOptions(); 
    57  
    58     if (!options.isConcatenate()) return imps; 
    59  
    60     IFormatReader r = process.getReader(); 
     46  public List<ImagePlus> concatenate(List<ImagePlus> imps) { 
    6147 
    6248    List<Integer> widths = new ArrayList<Integer>(); 
     
    9884    } 
    9985 
    100     //boolean splitC = options.isSplitChannels(); 
    101     //boolean splitZ = options.isSplitFocalPlanes(); 
    102     //boolean splitT = options.isSplitTimepoints(); 
    103  
    104     for (int j=0; j<newImps.size(); j++) { 
    105       ImagePlus imp = newImps.get(j); 
    106       // CTR FIXME 
    107       //if (splitC || splitZ || splitT) { 
    108       //  imp = Slicer.reslice(imp, splitC, splitZ, splitT, 
    109       //    options.isViewHyperstack(), stackOrder); 
    110       //} 
    111       if (options.isMergeChannels() && options.isWindowless()) { 
    112         imp = Colorizer.colorize(imp, true, stackOrder, null, 
    113           r.getSeries(), options.getMergeOption(), options.isViewHyperstack()); 
    114       } 
    115       else if (options.isMergeChannels()) { 
    116         imp = Colorizer.colorize(imp, true, stackOrder, null, 
    117           r.getSeries(), null, options.isViewHyperstack()); 
    118       } 
    119       newImps.set(j, imp); 
    120     } 
    121  
    12286    return newImps; 
    12387  } 
  • trunk/components/loci-plugins/src/loci/plugins/in/ImagePlusReader.java

    r6278 r6284  
    5656import loci.formats.meta.IMetadata; 
    5757import loci.formats.services.OMEXMLService; 
     58import loci.plugins.Slicer; 
    5859import loci.plugins.util.BFVirtualStack; 
    5960import loci.plugins.util.ImagePlusTools; 
    6061import loci.plugins.util.ImageProcessorReader; 
    6162import loci.plugins.util.VirtualImagePlus; 
    62  
    63 import ome.xml.r201004.enums.DimensionOrder; 
    64 import ome.xml.r201004.enums.EnumerationException; 
    6563 
    6664/** 
     
    103101 
    104102  /** 
    105    * Opens one or more {@link ij.ImagePlus} objects 
     103   * Opens one or more {@link ImagePlus} objects 
    106104   * corresponding to the reader's associated options. 
    107105   */ 
     
    210208 
    211209      int q = 0; 
    212       String stackOrder = options.getStackOrder(); 
    213       if (stackOrder.equals(ImporterOptions.ORDER_DEFAULT)) { 
    214         stackOrder = reader.getDimensionOrder(); 
    215       } 
    216       process.getDimensionSwapper().setOutputOrder(stackOrder); 
    217  
    218       try { 
    219         process.getOMEMetadata().setPixelsDimensionOrder( 
    220           DimensionOrder.fromString(stackOrder), s); 
    221       } 
    222       catch (EnumerationException e) { } 
    223210 
    224211      // dump OME-XML to ImageJ's description field, if available 
     
    344331    } 
    345332 
    346     // CTR CHECK 
    347     //Concatenator concatenator = new Concatenator(options); 
    348     //imps = concatenator.concatenate(imps, stackOrder); 
     333    // TODO - colorize 
     334 
     335    // concatenate compatible images 
     336    if (options.isConcatenate()) imps = new Concatenator().concatenate(imps); 
     337     
     338    // split dimensions, as appropriate 
     339    boolean sliceC = options.isSplitChannels(); 
     340    boolean sliceZ = options.isSplitFocalPlanes(); 
     341    boolean sliceT = options.isSplitTimepoints(); 
     342    if (sliceC || sliceZ || sliceT) { 
     343      String stackOrder = process.getStackOrder(); 
     344      List<ImagePlus> slicedImps = new ArrayList<ImagePlus>(); 
     345      for (ImagePlus imp : imps) { 
     346        ImagePlus[] results = new Slicer().reslice(imp, 
     347          sliceC, sliceZ, sliceT, stackOrder); 
     348        for (ImagePlus result : results) slicedImps.add(result); 
     349      } 
     350      imps = slicedImps; 
     351    } 
    349352 
    350353    // end timing 
  • trunk/components/loci-plugins/src/loci/plugins/in/ImportProcess.java

    r6278 r6284  
    5555import loci.plugins.util.WindowTools; 
    5656 
     57import ome.xml.r201004.enums.DimensionOrder; 
     58import ome.xml.r201004.enums.EnumerationException; 
     59 
    5760import org.apache.log4j.Level; 
    5861import org.apache.log4j.Logger; 
     
    6063/** 
    6164 * Manages the import preparation process. 
     65 * After calling {@link #execute()}, the process will be ready to feed to 
     66 * an {@link ImagePlusReader} to read in the actual {@link ImagePlus} objects. 
    6267 * 
    6368 * <dl><dt><b>Source code:</b></dt> 
     
    7378  /** Associated importer options. */ 
    7479  private ImporterOptions options; 
     80   
     81  /** Current step in the import preparation process. */ 
     82  private ImportStep step; 
    7583 
    7684  // reader stack, from bottom to top 
     
    115123 
    116124  /** Valid only after {@link ImportStep#READER}. */ 
    117   public IFormatReader getBaseReader() { return baseReader; } 
     125  public IFormatReader getBaseReader() { 
     126    assertStep(ImportStep.READER); 
     127    return baseReader; 
     128  } 
    118129  /** Valid only after {@link ImportStep#READER}. */ 
    119   public String getIdName() { return idName; } 
     130  public String getIdName() { 
     131    assertStep(ImportStep.READER); 
     132    return idName; 
     133  } 
    120134  /** Valid only after {@link ImportStep#READER}. */ 
    121   public Location getIdLocation() { return idLoc; } 
     135  public Location getIdLocation() { 
     136    assertStep(ImportStep.READER); 
     137    return idLoc; 
     138  } 
    122139  /** 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  public IMetadata getOMEMetadata() { 
     141    assertStep(ImportStep.READER); 
     142    return meta; 
     143  } 
     144 
     145  /** Valid only after {@link ImportStep#STACK}. */ 
     146  public FileStitcher getFileStitcher() { 
     147    assertStep(ImportStep.STACK); 
     148    return fileStitcher; 
     149  } 
     150  /** Valid only after {@link ImportStep#STACK}. */ 
     151  public ChannelSeparator getChannelSeparator() { 
     152    assertStep(ImportStep.STACK); 
     153    return channelSeparator; 
     154  } 
     155  /** Valid only after {@link ImportStep#STACK}. */ 
     156  public DimensionSwapper getDimensionSwapper() { 
     157    assertStep(ImportStep.STACK); 
     158    return dimensionSwapper; 
     159  } 
     160  /** Valid only after {@link ImportStep#STACK}. */ 
     161  public VirtualReader getVirtualReader() { 
     162    assertStep(ImportStep.STACK); 
     163    return virtualReader; 
     164  } 
     165  /** Valid only after {@link ImportStep#STACK}. */ 
     166  public ImageProcessorReader getReader() { 
     167    assertStep(ImportStep.STACK); 
     168    return reader; 
     169  } 
     170 
     171  /** Valid only after {@link ImportStep#STACK}. */ 
     172  public String getCurrentFile() { 
     173    assertStep(ImportStep.STACK); 
     174    return reader.getCurrentFile(); 
     175  } 
     176  /** Valid only after {@link ImportStep#STACK}. */ 
     177  public int getSeriesCount() { 
     178    assertStep(ImportStep.STACK); 
     179    return getReader().getSeriesCount(); 
     180  } 
    140181  /** Valid only after {@link ImportStep#STACK}. */ 
    141182  public String getSeriesLabel(int s) { 
    142     if (seriesLabels == null || s >= seriesLabels.length) return null; 
     183    assertStep(ImportStep.STACK); 
    143184    return seriesLabels[s]; 
     185  } 
     186   
     187  // stackOrder 
     188  /** Valid only after {@link ImportStep#STACK}. */ 
     189  public String getStackOrder() { 
     190    assertStep(ImportStep.STACK); 
     191    String stackOrder = options.getStackOrder(); 
     192    if (stackOrder == null || 
     193      stackOrder.equals(ImporterOptions.ORDER_DEFAULT)) 
     194    { 
     195      stackOrder = reader.getDimensionOrder(); 
     196    } 
     197    return stackOrder; 
    144198  } 
    145199   
     
    148202  /** Valid only after {@link ImportStep#STACK}. */ 
    149203  public int getCEnd(int s) { 
     204    assertStep(ImportStep.STACK); 
    150205    int cEnd = options.getCEnd(s); 
    151206    if (cEnd >= 0) return cEnd; 
     
    156211  /** Valid only after {@link ImportStep#STACK}. */ 
    157212  public int getZEnd(int s) { 
     213    assertStep(ImportStep.STACK); 
    158214    int zEnd = options.getZEnd(s); 
    159215    if (zEnd >= 0) return zEnd; 
     
    164220  /** Valid only after {@link ImportStep#STACK}. */ 
    165221  public int getTEnd(int s) { 
     222    assertStep(ImportStep.STACK); 
    166223    int tEnd = options.getTEnd(s); 
    167224    if (tEnd >= 0) return tEnd; 
     
    173230  /** Valid only after {@link ImportStep#STACK}. */ 
    174231  public Region getCropRegion(int s) { 
     232    assertStep(ImportStep.STACK); 
    175233    Region region = options.getCropRegion(s); 
    176234    if (region != null) return region; 
     
    180238 
    181239  /** Valid only after {@link ImportStep#METADATA}. */ 
    182   public ImporterMetadata getOriginalMetadata() { return metadata; } 
     240  public ImporterMetadata getOriginalMetadata() { 
     241    assertStep(ImportStep.METADATA); 
     242    return metadata; 
     243  } 
    183244 
    184245  /** 
     
    188249   */ 
    189250  public boolean execute() throws FormatException, IOException { 
    190     notifyListeners(ImportStep.READER); 
     251    step(ImportStep.READER); 
    191252    if (cancel) return false; 
    192253    initializeReader(); 
    193254 
    194     notifyListeners(ImportStep.FILE); 
     255    step(ImportStep.FILE); 
    195256    if (cancel) return false; 
    196257    initializeFile(); 
    197258 
    198     notifyListeners(ImportStep.STACK); 
     259    step(ImportStep.STACK); 
    199260    if (cancel) return false; 
    200261    initializeStack(); 
    201262 
    202     notifyListeners(ImportStep.SERIES); 
     263    step(ImportStep.SERIES); 
    203264    if (cancel) return false; 
    204265    initializeSeries(); 
    205266 
    206     notifyListeners(ImportStep.DIM_ORDER); 
     267    step(ImportStep.DIM_ORDER); 
    207268    if (cancel) return false; 
    208269    initializeDimOrder(); 
    209270 
    210     notifyListeners(ImportStep.RANGE); 
     271    step(ImportStep.RANGE); 
    211272    if (cancel) return false; 
    212273    initializeRange(); 
    213274 
    214     notifyListeners(ImportStep.CROP); 
     275    step(ImportStep.CROP); 
    215276    if (cancel) return false; 
    216277    initializeCrop(); 
    217278 
    218     notifyListeners(ImportStep.METADATA); 
     279    step(ImportStep.METADATA); 
    219280    if (cancel) return false; 
    220281    initializeMetadata(); 
    221282 
    222     notifyListeners(ImportStep.COMPLETE); 
     283    step(ImportStep.COMPLETE); 
    223284    return true; 
    224285  } 
     
    305366  /** Performed following ImportStep.DIM_ORDER notification. */ 
    306367  private void initializeDimOrder() { 
    307     int seriesCount = getSeriesCount(); 
     368    final int seriesCount = getSeriesCount(); 
     369    final String stackOrder = getStackOrder(); 
     370 
    308371    for (int s=0; s<seriesCount; s++) { 
    309372      reader.setSeries(s); 
     373 
     374      // set input order 
    310375      String dimOrder = options.getInputOrder(s); 
    311376      if (dimOrder != null) dimensionSwapper.swapDimensions(dimOrder); 
     377       
     378      // set output order 
     379      getDimensionSwapper().setOutputOrder(stackOrder); 
     380      try { 
     381        DimensionOrder order = DimensionOrder.fromString(stackOrder); 
     382        getOMEMetadata().setPixelsDimensionOrder(order, s); 
     383      } 
     384      catch (EnumerationException e) { } 
    312385    } 
    313386  } 
     
    485558  // -- Helper methods - miscellaneous -- 
    486559 
    487   private void notifyListeners(ImportStep step) { 
     560  private void step(ImportStep step) { 
     561    this.step = step; 
    488562    notifyListeners(new StatusEvent(step.getStep(), 
    489563      ImportStep.COMPLETE.getStep(), step.getMessage())); 
    490564  } 
     565   
     566  private void assertStep(ImportStep importStep) { 
     567    if (step.getStep() < importStep.getStep()) { 
     568      throw new IllegalStateException("Too early in import process: " + 
     569        "current step is " + step + ", but minimum step is " + importStep); 
     570    } 
     571  } 
    491572 
    492573} 
  • trunk/components/loci-plugins/src/loci/plugins/in/importer-options.txt

    r6273 r6284  
    268268  channels into a specific order, rather than automatically assign  \ 
    269269  channels to the order of RGB. The bit depth is preserved. 
    270 default = true 
     270default = false 
    271271 
    272272[stackFormat] 
Note: See TracChangeset for help on using the changeset viewer.