Changeset 5867 for branches/cleanup


Ignore:
Timestamp:
02/01/10 08:40:09 (10 years ago)
Author:
melissa
Message:

Ported r5857 to cleanup, with appropriate logging changes.

Location:
branches/cleanup/components/loci-plugins/src/loci/plugins
Files:
3 added
8 edited

Legend:

Unmodified
Added
Removed
  • branches/cleanup/components/loci-plugins/src/loci/plugins/exporter/Exporter.java

    r5605 r5867  
    3333import ij.io.FileInfo; 
    3434import ij.io.OpenDialog; 
     35import ij.measure.Calibration; 
    3536import ij.plugin.frame.Recorder; 
    3637import ij.process.ByteProcessor; 
     
    267268      } 
    268269 
     270      Calibration cal = imp.getCalibration(); 
     271 
     272      store.setDimensionsPhysicalSizeX(new Double(cal.pixelWidth), 0, 0); 
     273      store.setDimensionsPhysicalSizeY(new Double(cal.pixelHeight), 0, 0); 
     274      store.setDimensionsPhysicalSizeZ(new Double(cal.pixelDepth), 0, 0); 
     275      store.setDimensionsTimeIncrement(new Double(cal.frameInterval), 0, 0); 
     276 
    269277      if (imp.getImageStackSize() != 
    270278        imp.getNChannels() * imp.getNSlices() * imp.getNFrames()) 
  • branches/cleanup/components/loci-plugins/src/loci/plugins/importer/Importer.java

    r5852 r5867  
    4646import java.util.Enumeration; 
    4747import java.util.Hashtable; 
    48 import java.util.StringTokenizer; 
    4948import java.util.Vector; 
    5049 
     
    5352import loci.common.ReflectedUniverse; 
    5453import loci.formats.ChannelMerger; 
    55 import loci.formats.ChannelSeparator; 
    56 import loci.formats.DimensionSwapper; 
    5754import loci.formats.FilePattern; 
    58 import loci.formats.FileStitcher; 
    5955import loci.formats.FormatException; 
    6056import loci.formats.FormatTools; 
    6157import loci.formats.IFormatReader; 
    62 import loci.formats.ImageReader; 
    6358import loci.formats.MetadataTools; 
    6459import loci.formats.gui.XMLWindow; 
    65 import loci.formats.meta.IMetadata; 
    6660import loci.formats.meta.MetadataRetrieve; 
    6761import loci.plugins.Colorizer; 
    6862import loci.plugins.LociImporter; 
    6963import loci.plugins.prefs.OptionsDialog; 
     64import loci.plugins.util.BF; 
    7065import loci.plugins.util.BFVirtualStack; 
    7166import loci.plugins.util.DataBrowser; 
    7267import loci.plugins.util.ImagePlusReader; 
    7368import loci.plugins.util.ImagePlusTools; 
    74 import loci.plugins.util.LociPrefs; 
    7569import loci.plugins.util.ROIHandler; 
    7670import loci.plugins.util.SearchableWindow; 
    7771import loci.plugins.util.VirtualImagePlus; 
     72import loci.plugins.util.VirtualReader; 
    7873import loci.plugins.util.WindowTools; 
    7974 
     
    111106  // -- Importer API methods -- 
    112107 
    113   /** Executes the plugin. */ 
    114   public void run(String arg) { 
    115  
    116     // -- Step 0: parse core options -- 
    117  
    118     debug("parse core options"); 
    119  
     108  /** Parses core importer options. */ 
     109  public ImporterOptions parseOptions(String arg, boolean quiet) { 
     110    BF.debug("parse core options"); 
    120111    ImporterOptions options = null; 
    121112    try { 
     
    123114    } 
    124115    catch (IOException exc) { 
    125       WindowTools.reportException(exc); 
     116      WindowTools.reportException(exc, quiet); 
    126117    } 
    127118    options.loadOptions(); 
    128119    options.parseArg(arg); 
    129  
    130     // -- Step 1: check if new version is available -- 
    131  
    132     debug("check if new version is available"); 
     120    return options; 
     121  } 
     122 
     123  /** Checks if a new version of the LOCI plugins is available. */ 
     124  public void checkNewVersion(ImporterOptions options) { 
     125    BF.debug("check if new version is available"); 
    133126 
    134127    UpgradeDialog upgradeDialog = new UpgradeDialog(options); 
    135128    int status = upgradeDialog.showDialog(); 
    136129    if (!statusOk(status)) return; 
    137  
    138     // -- Step 2: construct reader and check id -- 
    139  
    140     debug("construct reader and check id"); 
    141  
    142     LocationDialog locationDialog = new LocationDialog(options); 
    143     status = locationDialog.showDialog(); 
    144     if (!statusOk(status)) return; 
    145  
    146     IdDialog idDialog = new IdDialog(options); 
    147     status = idDialog.showDialog(); 
    148     if (!statusOk(status)) return; 
    149  
    150     String id = options.getId(); 
    151     boolean quiet = options.isQuiet(); 
    152  
    153     Location idLoc = null; 
    154     String idName = id; 
    155     if (options.isLocal()) { 
    156       idLoc = new Location(id); 
    157       idName = idLoc.getName(); 
    158     } 
    159     else if (options.isOME() || options.isOMERO()) { 
    160       // NB: strip out username and password when opening from OME/OMERO 
    161       StringTokenizer st = new StringTokenizer(id, "?&"); 
    162       StringBuffer idBuf = new StringBuffer(); 
    163       int tokenCount = 0; 
    164       while (st.hasMoreTokens()) { 
    165         String token = st.nextToken(); 
    166         if (token.startsWith("username=") || token.startsWith("password=")) { 
    167           continue; 
    168         } 
    169         if (tokenCount == 1) idBuf.append("?"); 
    170         else if (tokenCount > 1) idBuf.append("&"); 
    171         idBuf.append(token); 
    172         tokenCount++; 
    173       } 
    174       idName = idBuf.toString(); 
    175     } 
    176  
    177     IFormatReader base = null; 
    178     if (options.isLocal() || options.isHTTP()) { 
    179       IJ.showStatus("Identifying " + idName); 
    180       ImageReader reader = ImagePlusReader.makeImageReader(); 
    181       try { base = reader.getReader(id); } 
    182       catch (FormatException exc) { 
    183         WindowTools.reportException(exc, quiet, 
    184           "Sorry, there was an error reading the file."); 
     130  } 
     131 
     132  /** Executes the plugin. */ 
     133  public void run(String arg) { 
     134 
     135    // -- Step 0: parse core options -- 
     136 
     137    ImporterOptions options = parseOptions(arg, false); 
     138 
     139    // -- Step 1: check if new version is available -- 
     140 
     141    checkNewVersion(options); 
     142    if (plugin.canceled) return; 
     143 
     144    // -- Step 2: harvest additional options -- 
     145 
     146    BF.debug("get parameter values"); 
     147 
     148    try { 
     149      boolean success = options.showDialogs(); 
     150      if (!success) { 
     151        plugin.canceled = true; 
    185152        return; 
    186153      } 
    187       catch (IOException exc) { 
    188         WindowTools.reportException(exc, quiet, 
    189           "Sorry, there was a I/O problem reading the file."); 
    190         return; 
    191       } 
    192     } 
    193     else if (options.isOMERO()) { 
    194       // NB: avoid dependencies on optional loci.ome.io package 
    195       try { 
    196         ReflectedUniverse ru = new ReflectedUniverse(); 
    197         ru.exec("import loci.ome.io.OMEROReader"); 
    198         base = (IFormatReader) ru.exec("new OMEROReader()"); 
    199       } 
    200       catch (ReflectException exc) { 
    201         WindowTools.reportException(exc, options.isQuiet(), 
    202           "Sorry, there was a problem constructing the OMERO I/O engine"); 
    203         return; 
    204       } 
    205     } 
    206     else if (options.isOME()) { 
    207       // NB: avoid dependencies on optional loci.ome.io package 
    208       try { 
    209         ReflectedUniverse ru = new ReflectedUniverse(); 
    210         ru.exec("import loci.ome.io.OMEReader"); 
    211         base = (IFormatReader) ru.exec("new OMEReader()"); 
    212       } 
    213       catch (ReflectException exc) { 
    214         WindowTools.reportException(exc, options.isQuiet(), 
    215           "Sorry, there was a problem constructing the OME I/O engine"); 
    216         return; 
    217       } 
    218     } 
    219     else { 
    220       WindowTools.reportException(null, options.isQuiet(), 
    221         "Sorry, there has been an internal error: unknown data source"); 
    222     } 
    223     IMetadata omexmlMeta = MetadataTools.createOMEXMLMetadata(); 
    224     base.setMetadataStore(omexmlMeta); 
    225  
    226     IJ.showStatus(""); 
    227  
    228     // -- Step 3: get parameter values -- 
    229  
    230     debug("get parameter values"); 
    231  
    232     boolean windowless = options.isWindowless() || LociPrefs.isWindowless(base); 
    233     if (!windowless) { 
    234       ImporterDialog importerDialog = new ImporterDialog(options); 
    235       status = importerDialog.showDialog(); 
    236     } 
    237     if (!statusOk(status)) return; 
    238  
    239     boolean mergeChannels = options.isMergeChannels(); 
    240     boolean colorize = options.isColorize(); 
    241     boolean showMetadata = options.isShowMetadata(); 
    242     boolean showOMEXML = options.isShowOMEXML(); 
    243     boolean groupFiles = options.isGroupFiles(); 
    244     boolean ungroupFiles = options.isUngroupFiles(); 
    245     boolean concatenate = options.isConcatenate(); 
    246     boolean specifyRanges = options.isSpecifyRanges(); 
    247     boolean cropOnImport = options.doCrop(); 
    248     boolean swapDimensions = options.isSwapDimensions(); 
    249     quiet = options.isQuiet(); 
    250  
    251     // save options as new defaults 
    252     if (!quiet) options.setFirstTime(false); 
    253     options.saveOptions(); 
    254  
    255     // -- Step 4: analyze and read from data source -- 
    256  
    257     debug("analyze and read from data source"); 
    258  
    259     IJ.showStatus("Analyzing " + idName); 
    260  
    261     try { 
    262       base.setMetadataFiltered(true); 
    263       base.setOriginalMetadataPopulated(true); 
    264       base.setGroupFiles(!ungroupFiles); 
    265       base.setId(id); 
    266  
    267       int pixelType = base.getPixelType(); 
    268       String currentFile = base.getCurrentFile(); 
    269  
    270       // -- Step 4a: prompt for the file pattern, if necessary -- 
    271  
    272       if (groupFiles) { 
    273         debug("prompt for the file pattern"); 
    274         FilePatternDialog filePatternDialog = new FilePatternDialog(options); 
    275         status = filePatternDialog.showDialog(); 
    276         if (!statusOk(status)) return; 
    277         id = options.getId(); 
    278         if (id == null) id = currentFile; 
    279         FilePattern fp = new FilePattern(id); 
    280         if (!fp.isValid()) { 
    281           id = currentFile; 
    282         } 
    283       } 
    284       else debug("no need to prompt for file pattern"); 
    285  
    286       if (groupFiles) base = new FileStitcher(base, true); 
    287       if (options.isVirtual() || !options.isMergeChannels() || 
    288         FormatTools.getBytesPerPixel(base.getPixelType()) != 1) 
    289       { 
    290         base = new ChannelSeparator(base); 
    291       } 
    292       // NB: VirtualReader extends DimensionSwapper 
    293       VirtualReader virtualReader = new VirtualReader(base); 
    294       ImagePlusReader r = new ImagePlusReader(virtualReader); 
    295       r.setId(id); 
    296  
    297       // -- Step 4b: prompt for which series to import, if necessary -- 
    298  
    299       // populate series-related variables 
    300       int seriesCount = r.getSeriesCount(); 
    301       int[] num = new int[seriesCount]; 
    302       int[] sizeC = new int[seriesCount]; 
    303       int[] sizeZ = new int[seriesCount]; 
    304       int[] sizeT = new int[seriesCount]; 
    305       boolean[] certain = new boolean[seriesCount]; 
    306       int[] cBegin = new int[seriesCount]; 
    307       int[] cEnd = new int[seriesCount]; 
    308       int[] cStep = new int[seriesCount]; 
    309       int[] zBegin = new int[seriesCount]; 
    310       int[] zEnd = new int[seriesCount]; 
    311       int[] zStep = new int[seriesCount]; 
    312       int[] tBegin = new int[seriesCount]; 
    313       int[] tEnd = new int[seriesCount]; 
    314       int[] tStep = new int[seriesCount]; 
    315       boolean[] series = new boolean[seriesCount]; 
    316       for (int i=0; i<seriesCount; i++) { 
    317         r.setSeries(i); 
    318         num[i] = r.getImageCount(); 
    319         sizeC[i] = r.getEffectiveSizeC(); 
    320         sizeZ[i] = r.getSizeZ(); 
    321         sizeT[i] = r.getSizeT(); 
    322         certain[i] = r.isOrderCertain(); 
    323         cBegin[i] = zBegin[i] = tBegin[i] = 0; 
    324         //cEnd[i] = certain[i] ? sizeC[i] - 1 : num[i] - 1; 
    325         cEnd[i] = sizeC[i] - 1; 
    326         zEnd[i] = sizeZ[i] - 1; 
    327         tEnd[i] = sizeT[i] - 1; 
    328         cStep[i] = zStep[i] = tStep[i] = 1; 
    329       } 
    330       series[0] = true; 
    331  
    332       // build descriptive label for each series 
    333       String[] seriesLabels = new String[seriesCount]; 
    334       for (int i=0; i<seriesCount; i++) { 
    335         r.setSeries(i); 
    336         StringBuffer sb = new StringBuffer(); 
    337         sb.append("Series_"); 
    338         sb.append((i + 1)); 
    339         sb.append(": "); 
    340         String name = omexmlMeta.getImageName(i); 
    341         if (name != null && name.length() > 0) { 
    342           sb.append(name); 
    343           sb.append(": "); 
    344         } 
    345         sb.append(r.getSizeX()); 
    346         sb.append(" x "); 
    347         sb.append(r.getSizeY()); 
    348         sb.append("; "); 
    349         sb.append(num[i]); 
    350         sb.append(" plane"); 
    351         if (num[i] > 1) { 
    352           sb.append("s"); 
    353           if (certain[i]) { 
    354             sb.append(" ("); 
    355             boolean first = true; 
    356             if (sizeC[i] > 1) { 
    357               sb.append(sizeC[i]); 
    358               sb.append("C"); 
    359               first = false; 
    360             } 
    361             if (sizeZ[i] > 1) { 
    362               if (!first) sb.append(" x "); 
    363               sb.append(sizeZ[i]); 
    364               sb.append("Z"); 
    365               first = false; 
    366             } 
    367             if (sizeT[i] > 1) { 
    368               if (!first) sb.append(" x "); 
    369               sb.append(sizeT[i]); 
    370               sb.append("T"); 
    371               first = false; 
    372             } 
    373             sb.append(")"); 
    374           } 
    375         } 
    376         seriesLabels[i] = sb.toString(); 
    377         //seriesLabels[i] = seriesLabels[i].replaceAll(" ", "_"); 
    378       } 
    379  
    380       if (seriesCount > 1 && !options.openAllSeries() && !options.isViewNone()) 
    381       { 
    382         debug("prompt for which series to import"); 
    383         SeriesDialog seriesDialog = new SeriesDialog(options, 
    384           r, seriesLabels, series); 
    385         status = seriesDialog.showDialog(); 
    386         if (!statusOk(status)) return; 
    387       } 
    388       else debug("no need to prompt for series"); 
    389  
    390       if (options.openAllSeries() || options.isViewNone()) { 
    391         Arrays.fill(series, true); 
    392       } 
    393  
    394       // -- Step 4c: prompt for dimension swapping parameters, if necessary -- 
    395  
    396       if (swapDimensions) { 
    397         debug("prompt for dimension swapping parameters"); 
    398  
    399         SwapDialog swapDialog = new SwapDialog(options, virtualReader, series); 
    400         status = swapDialog.showDialog(); 
    401         if (!statusOk(status)) return; 
    402  
    403         for (int i=0; i<seriesCount; i++) { 
    404           r.setSeries(i); 
    405           num[i] = r.getImageCount(); 
    406           sizeC[i] = r.getEffectiveSizeC(); 
    407           sizeZ[i] = r.getSizeZ(); 
    408           sizeT[i] = r.getSizeT(); 
    409           certain[i] = r.isOrderCertain(); 
    410           cBegin[i] = zBegin[i] = tBegin[i] = 0; 
    411           cEnd[i] = sizeC[i] - 1; 
    412           zEnd[i] = sizeZ[i] - 1; 
    413           tEnd[i] = sizeT[i] - 1; 
    414           cStep[i] = zStep[i] = tStep[i] = 1; 
    415         } 
    416       } 
    417       else debug("no need to prompt for dimension swapping"); 
    418  
    419       // -- Step 4d: prompt for the range of planes to import, if necessary -- 
    420  
    421       if (specifyRanges) { 
    422         boolean needRange = false; 
    423         for (int i=0; i<seriesCount; i++) { 
    424           if (series[i] && num[i] > 1) needRange = true; 
    425         } 
    426         if (needRange) { 
    427           debug("prompt for planar ranges"); 
    428           IJ.showStatus(""); 
    429           RangeDialog rangeDialog = new RangeDialog(options, 
    430             r, series, seriesLabels, cBegin, cEnd, cStep, 
    431             zBegin, zEnd, zStep, tBegin, tEnd, tStep); 
    432           status = rangeDialog.showDialog(); 
    433           if (!statusOk(status)) return; 
    434         } 
    435         else debug("no need to prompt for planar ranges"); 
    436       } 
    437       else debug("open all planes"); 
    438       int[] cCount = new int[seriesCount]; 
    439       int[] zCount = new int[seriesCount]; 
    440       int[] tCount = new int[seriesCount]; 
    441       for (int i=0; i<seriesCount; i++) { 
    442         if (!series[i]) continue; 
    443         cCount[i] = (cEnd[i] - cBegin[i] + cStep[i]) / cStep[i]; 
    444         zCount[i] = (zEnd[i] - zBegin[i] + zStep[i]) / zStep[i]; 
    445         tCount[i] = (tEnd[i] - tBegin[i] + tStep[i]) / tStep[i]; 
    446       } 
    447  
    448       Rectangle[] cropOptions = new Rectangle[seriesCount]; 
    449       for (int i=0; i<cropOptions.length; i++) { 
    450         if (series[i] && cropOnImport) cropOptions[i] = new Rectangle(); 
    451       } 
    452       if (cropOnImport) { 
    453         CropDialog cropDialog = new CropDialog(options, 
    454           r, seriesLabels, series, cropOptions); 
    455         status = cropDialog.showDialog(); 
    456         if (!statusOk(status)) return; 
    457       } 
    458  
    459       // -- Step 4e: display metadata, if appropriate -- 
    460  
    461       if (showMetadata) { 
    462         debug("display metadata"); 
     154      ImagePlusReader r = options.getReader(); 
     155 
     156      // -- Step 3: prompt for more information as needed -- 
     157 
     158      BF.debug("analyze and read from data source"); 
     159 
     160      IJ.showStatus("Analyzing " + options.getIdName()); 
     161 
     162      // -- Step 4: display metadata, if appropriate -- 
     163 
     164      if (options.isShowMetadata()) { 
     165        BF.debug("display metadata"); 
    463166        IJ.showStatus("Populating metadata"); 
    464167 
    465168        // display standard metadata in a table in its own window 
    466169        Hashtable meta = r.getMetadata(); 
    467         //if (seriesCount == 1) meta = r.getMetadata(); 
    468         meta.put(options.getLocation(), currentFile); 
    469         int digits = digits(seriesCount); 
    470         for (int i=0; i<seriesCount; i++) { 
    471           if (!series[i]) continue; 
     170        //if (r.getSeriesCount() == 1) meta = r.getMetadata(); 
     171        meta.put(options.getLocation(), options.getCurrentFile()); 
     172        int digits = digits(r.getSeriesCount()); 
     173        for (int i=0; i<r.getSeriesCount(); i++) { 
     174          if (!options.isSeriesOn(i)) continue; 
    472175          r.setSeries(i); 
    473176          //meta.putAll(r.getCoreMetadata().seriesMetadata[i]); 
    474177 
    475           String s = omexmlMeta.getImageName(i); 
    476           if ((s == null || s.trim().length() == 0) && seriesCount > 1) { 
     178          String s = options.getMetadata().getImageName(i); 
     179          if ((s == null || s.trim().length() == 0) && r.getSeriesCount() > 1) { 
    477180            StringBuffer sb = new StringBuffer(); 
    478181            sb.append("Series "); 
     
    502205        String metaString = getMetadataString(meta, "\t"); 
    503206 
    504         SearchableWindow w = new SearchableWindow("Original Metadata - " + id, 
    505           "Key\tValue", metaString, 400, 400); 
     207        SearchableWindow w = new SearchableWindow("Original Metadata - " + 
     208          options.getIdName(), "Key\tValue", metaString, 400, 400); 
    506209        w.setVisible(true); 
    507210      } 
    508       else debug("skip metadata"); 
    509  
    510       if (showOMEXML) { 
    511         debug("show OME-XML"); 
     211      else BF.debug("skip metadata"); 
     212 
     213      if (options.isShowOMEXML()) { 
     214        BF.debug("show OME-XML"); 
    512215        if (options.isViewBrowser()) { 
    513216          // NB: Data Browser has its own internal OME-XML metadata window, 
     
    516219        } 
    517220        else { 
    518           XMLWindow metaWindow = new XMLWindow("OME Metadata - " + id); 
     221          XMLWindow metaWindow = 
     222            new XMLWindow("OME Metadata - " + options.getIdName()); 
    519223          try { 
    520             metaWindow.setXML(MetadataTools.getOMEXML(omexmlMeta)); 
     224            metaWindow.setXML(MetadataTools.getOMEXML(options.getMetadata())); 
    521225            WindowTools.placeWindow(metaWindow); 
    522226            metaWindow.setVisible(true); 
     
    532236        } 
    533237      } 
    534       else debug("skip OME-XML"); 
    535  
    536       // -- Step 4f: read pixel data -- 
     238      else BF.debug("skip OME-XML"); 
     239 
     240      // -- Step 5: read pixel data -- 
    537241 
    538242      if (options.isViewNone()) return; // nothing to display 
    539243 
    540       debug("read pixel data"); 
    541  
    542       IJ.showStatus("Reading " + currentFile); 
     244      BF.debug("read pixel data"); 
     245 
     246      IJ.showStatus("Reading " + options.getCurrentFile()); 
    543247 
    544248      if (options.isVirtual()) { 
    545249        int totalSeries = 0; 
    546         for (int i=0; i<seriesCount; i++) { 
    547           if (series[i]) totalSeries++; 
    548         } 
    549         virtualReader.setRefCount(totalSeries); 
    550       } 
    551  
    552       for (int i=0; i<seriesCount; i++) { 
    553         if (!series[i]) continue; 
     250        for (int i=0; i<r.getSeriesCount(); i++) { 
     251          if (options.isSeriesOn(i)) totalSeries++; 
     252        } 
     253        ((VirtualReader) r.getReader()).setRefCount(totalSeries); 
     254      } 
     255 
     256      for (int i=0; i<r.getSeriesCount(); i++) { 
     257        if (!options.isSeriesOn(i)) continue; 
    554258        r.setSeries(i); 
    555259 
    556         boolean[] load = new boolean[num[i]]; 
    557         for (int c=cBegin[i]; c<=cEnd[i]; c+=cStep[i]) { 
    558           for (int z=zBegin[i]; z<=zEnd[i]; z+=zStep[i]) { 
    559             for (int t=tBegin[i]; t<=tEnd[i]; t+=tStep[i]) { 
     260        boolean[] load = new boolean[r.getImageCount()]; 
     261        int cBegin = options.getCBegin(i); 
     262        int cEnd = options.getCEnd(i); 
     263        int cStep = options.getCStep(i); 
     264        int zBegin = options.getZBegin(i); 
     265        int zEnd = options.getZEnd(i); 
     266        int zStep = options.getZStep(i); 
     267        int tBegin = options.getTBegin(i); 
     268        int tEnd = options.getTEnd(i); 
     269        int tStep = options.getTStep(i); 
     270        for (int c=cBegin; c<=cEnd; c+=cStep) { 
     271          for (int z=zBegin; z<=zEnd; z+=zStep) { 
     272            for (int t=tBegin; t<=tEnd; t+=tStep) { 
    560273              //int index = r.isOrderCertain() ? r.getIndex(z, c, t) : c; 
    561274              int index = r.getIndex(z, c, t); 
     
    565278        } 
    566279        int total = 0; 
    567         for (int j=0; j<num[i]; j++) if (load[j]) total++; 
     280        for (int j=0; j<r.getImageCount(); j++) if (load[j]) total++; 
    568281 
    569282        FileInfo fi = new FileInfo(); 
    570283 
    571284        // populate other common FileInfo fields 
    572         String idDir = idLoc == null ? null : idLoc.getParent(); 
     285        String idDir = options.getIdLocation() == null ? 
     286          null : options.getIdLocation().getParent(); 
    573287        if (idDir != null && !idDir.endsWith(File.separator)) { 
    574288          idDir += File.separator; 
    575289        } 
    576         fi.fileName = idName; 
     290        fi.fileName = options.getIdName(); 
    577291        fi.directory = idDir; 
    578292 
     
    588302        ImageStack stackO = null; // for all other images (24-bit RGB) 
    589303 
    590         int w = cropOnImport ? cropOptions[i].width : r.getSizeX(); 
    591         int h = cropOnImport ? cropOptions[i].height : r.getSizeY(); 
     304        Rectangle cropRegion = options.getCropRegion(i); 
     305        int w = options.doCrop() ? cropRegion.width : r.getSizeX(); 
     306        int h = options.doCrop() ? cropRegion.height : r.getSizeY(); 
    592307        int c = r.getRGBChannelCount(); 
    593308        int type = r.getPixelType(); 
     
    598313          stackOrder = r.getDimensionOrder(); 
    599314        } 
    600         virtualReader.setOutputOrder(stackOrder); 
    601  
    602         omexmlMeta.setPixelsDimensionOrder(stackOrder, i, 0); 
     315        ((VirtualReader) r.getReader()).setOutputOrder(stackOrder); 
     316 
     317        options.getMetadata().setPixelsDimensionOrder(stackOrder, i, 0); 
    603318 
    604319        // dump OME-XML to ImageJ's description field, if available 
    605         fi.description = MetadataTools.getOMEXML(omexmlMeta); 
     320        fi.description = MetadataTools.getOMEXML(options.getMetadata()); 
    606321 
    607322        if (options.isVirtual()) { 
     
    615330          r.setSeries(i); 
    616331          // NB: ImageJ 1.39+ is required for VirtualStack 
    617           BFVirtualStack virtualStackB = new BFVirtualStack(id, 
    618             r, colorize, doMerge, options.isRecord()); 
     332          BFVirtualStack virtualStackB = new BFVirtualStack(options.getId(), 
     333            r, options.isColorize(), doMerge, options.isRecord()); 
    619334          stackB = virtualStackB; 
    620335          if (doMerge) { 
    621             cCount[i] = 1; 
    622             for (int j=0; j<num[i]; j++) { 
     336            for (int j=0; j<r.getImageCount(); j++) { 
    623337              int[] pos = r.getZCTCoords(j); 
    624338              if (pos[1] > 0) continue; 
    625339              String label = constructSliceLabel( 
    626340                new ChannelMerger(r).getIndex(pos[0], pos[1], pos[2]), 
    627                 new ChannelMerger(r), omexmlMeta, i, zCount, cCount, tCount); 
     341                new ChannelMerger(r), options.getMetadata(), i, 
     342                options.getZCount(i), options.getCCount(i), 
     343                options.getTCount(i)); 
    628344              virtualStackB.addSlice(label); 
    629345            } 
    630346          } 
    631347          else { 
    632             for (int j=0; j<num[i]; j++) { 
     348            for (int j=0; j<r.getImageCount(); j++) { 
    633349              String label = constructSliceLabel(j, r, 
    634                 omexmlMeta, i, zCount, cCount, tCount); 
     350                options.getMetadata(), i, options.getZCount(i), 
     351                options.getCCount(i), options.getTCount(i)); 
    635352              virtualStackB.addSlice(label); 
    636353            } 
     
    640357          if (r.isIndexed()) colorModels = new IndexColorModel[r.getSizeC()]; 
    641358 
    642           for (int j=0; j<num[i]; j++) { 
     359          for (int j=0; j<r.getImageCount(); j++) { 
    643360            if (!load[j]) continue; 
    644361 
     
    647364            if (clock - time >= 100) { 
    648365              IJ.showStatus("Reading " + 
    649                 (seriesCount > 1 ? ("series " + (i + 1) + ", ") : "") + 
     366                (r.getSeriesCount() > 1 ? ("series " + (i + 1) + ", ") : "") + 
    650367                "plane " + (j + 1) + "/" + total); 
    651368              time = clock; 
     
    656373 
    657374            String label = constructSliceLabel(ndx, r, 
    658               omexmlMeta, i, zCount, cCount, tCount); 
     375              options.getMetadata(), i, options.getZCount(i), 
     376              options.getCCount(i), options.getTCount(i)); 
    659377 
    660378            // get image processor for jth plane 
    661             ImageProcessor[] p = r.openProcessors(ndx, cropOptions[i]); 
     379            ImageProcessor[] p = r.openProcessors(ndx, cropRegion); 
    662380            ImageProcessor ip = p[0]; 
    663381            if (p.length > 1) { 
     
    708426        IJ.showProgress(1); 
    709427 
    710         String seriesName = omexmlMeta.getImageName(i); 
    711  
    712         showStack(stackB, currentFile, seriesName, omexmlMeta, 
    713           cCount[i], zCount[i], tCount[i], sizeZ[i], sizeC[i], sizeT[i], 
    714           fi, r, options, metadata, windowless); 
    715         showStack(stackS, currentFile, seriesName, omexmlMeta, 
    716           cCount[i], zCount[i], tCount[i], sizeZ[i], sizeC[i], sizeT[i], 
    717           fi, r, options, metadata, windowless); 
    718         showStack(stackF, currentFile, seriesName, omexmlMeta, 
    719           cCount[i], zCount[i], tCount[i], sizeZ[i], sizeC[i], sizeT[i], 
    720           fi, r, options, metadata, windowless); 
    721         showStack(stackO, currentFile, seriesName, omexmlMeta, 
    722           cCount[i], zCount[i], tCount[i], sizeZ[i], sizeC[i], sizeT[i], 
    723           fi, r, options, metadata, windowless); 
     428        String seriesName = options.getMetadata().getImageName(i); 
     429 
     430        showStack(stackB, options.getCurrentFile(), seriesName, 
     431          options.getMetadata(), options.getCCount(i), 
     432          options.getZCount(i), options.getTCount(i), 
     433          r.getSizeZ(), r.getEffectiveSizeC(), r.getSizeT(), 
     434          fi, r, options, metadata, options.isWindowless()); 
     435        showStack(stackS, options.getCurrentFile(), seriesName, 
     436          options.getMetadata(), options.getCCount(i), 
     437          options.getZCount(i), options.getTCount(i), 
     438          r.getSizeZ(), r.getEffectiveSizeC(), r.getSizeT(), 
     439          fi, r, options, metadata, options.isWindowless()); 
     440        showStack(stackF, options.getCurrentFile(), seriesName, 
     441          options.getMetadata(), options.getCCount(i), 
     442          options.getZCount(i), options.getTCount(i), 
     443          r.getSizeZ(), r.getEffectiveSizeC(), r.getSizeT(), 
     444          fi, r, options, metadata, options.isWindowless()); 
     445        showStack(stackO, options.getCurrentFile(), seriesName, 
     446          options.getMetadata(), options.getCCount(i), 
     447          options.getZCount(i), options.getTCount(i), 
     448          r.getSizeZ(), r.getEffectiveSizeC(), r.getSizeT(), 
     449          fi, r, options, metadata, options.isWindowless()); 
    724450 
    725451        long endTime = System.currentTimeMillis(); 
    726452        double elapsed = (endTime - startTime) / 1000.0; 
    727         if (num[i] == 1) { 
     453        if (r.getImageCount() == 1) { 
    728454          IJ.showStatus("Bio-Formats: " + elapsed + " seconds"); 
    729455        } 
    730456        else { 
    731           long average = (endTime - startTime) / num[i]; 
     457          long average = (endTime - startTime) / r.getImageCount(); 
    732458          IJ.showStatus("Bio-Formats: " + elapsed + " seconds (" + 
    733459            average + " ms per plane)"); 
     
    735461      } 
    736462 
    737       if (concatenate) { 
     463      if (options.isConcatenate()) { 
    738464        Vector widths = new Vector(); 
    739465        Vector heights = new Vector(); 
     
    788514            imp.close(); 
    789515          } 
    790           if (mergeChannels && windowless) { 
     516          if (options.isMergeChannels() && options.isWindowless()) { 
    791517            IJ.runPlugIn("loci.plugins.Colorizer", "stack_order=" + stackOrder + 
    792518              " merge=true merge_option=[" + options.getMergeOption() + "] " + 
     
    795521            imp.close(); 
    796522          } 
    797           else if (mergeChannels) { 
     523          else if (options.isMergeChannels()) { 
    798524            IJ.runPlugIn("loci.plugins.Colorizer", "stack_order=" + stackOrder + 
    799525              " merge=true series=" + r.getSeries() + " hyper_stack=" + 
     
    804530      } 
    805531 
    806       // display ROIs, if necessary 
     532      // -- Step 6: display ROIs, if necessary -- 
    807533 
    808534      if (options.showROIs()) { 
    809         debug("display ROIs"); 
    810  
    811         ROIHandler.openROIs(omexmlMeta, 
     535        BF.debug("display ROIs"); 
     536 
     537        ROIHandler.openROIs(options.getMetadata(), 
    812538          (ImagePlus[]) imps.toArray(new ImagePlus[0])); 
    813539      } 
    814       else debug("skip ROIs"); 
    815  
    816       // -- Step 5: finish up -- 
    817  
    818       debug("finish up"); 
     540      else BF.debug("skip ROIs"); 
     541 
     542      // -- Step 7: finish up -- 
     543 
     544      BF.debug("finish up"); 
    819545 
    820546      try { 
     
    829555    } 
    830556    catch (FormatException exc) { 
    831       WindowTools.reportException(exc, quiet, 
     557      WindowTools.reportException(exc, options.isQuiet(), 
    832558        "Sorry, there was a problem reading the data."); 
    833559    } 
    834560    catch (IOException exc) { 
    835       WindowTools.reportException(exc, quiet, 
     561      WindowTools.reportException(exc, options.isQuiet(), 
    836562        "Sorry, there was an I/O problem reading the data."); 
    837563    } 
     
    874600    boolean hyper = options.isViewHyperstack() || options.isViewBrowser(); 
    875601    imp.setOpenAsHyperStack(hyper); 
    876     boolean mergeChannels = options.isMergeChannels(); 
    877     boolean concatenate = options.isConcatenate(); 
    878602    int nSlices = imp.getNSlices(); 
    879603    int nFrames = imp.getNFrames(); 
     
    896620    int t = r.getSizeT(); 
    897621 
    898     if (!concatenate && mergeChannels) imp.show(); 
     622    if (!options.isConcatenate() && options.isMergeChannels()) imp.show(); 
    899623 
    900624    if (imp.isVisible() && !options.isVirtual()) { 
     
    957681      // NB: ImageJ 1.39+ is required for hyperstacks 
    958682 
    959       if (!concatenate) { 
     683      if (!options.isConcatenate()) { 
    960684        if (options.isViewBrowser()) { 
    961685          DataBrowser dataBrowser = new DataBrowser(imp, null, 
     
    965689        else if (!imp.isVisible()) imp.show(); 
    966690 
    967         boolean colorize = options.isColorize(); 
    968691        boolean customColorize = options.isCustomColorize(); 
    969692        boolean browser = options.isViewBrowser(); 
    970693        boolean virtual = options.isVirtual(); 
    971694 
    972         if (colorize || customColorize) { 
     695        if (options.isColorize() || customColorize) { 
    973696          IJ.runPlugIn("loci.plugins.Colorizer", "stack_order=" + stackOrder + 
    974697            " merge=false colorize=true ndx=" + (customColorize ? "-1" : "0") + 
     
    1049772  private String constructSliceLabel(int ndx, IFormatReader r, 
    1050773    MetadataRetrieve retrieve, int series, 
    1051     int[] zCount, int[] cCount, int[] tCount) 
     774    int zCount, int cCount, int tCount) 
    1052775  { 
    1053776    r.setSeries(series); 
     
    1057780    StringBuffer sb = new StringBuffer(); 
    1058781    boolean first = true; 
    1059     if (cCount[series] > 1) { 
     782    if (cCount > 1) { 
    1060783      if (first) first = false; 
    1061784      else sb.append("; "); 
     
    1071794      } 
    1072795    } 
    1073     if (zCount[series] > 1) { 
     796    if (zCount > 1) { 
    1074797      if (first) first = false; 
    1075798      else sb.append("; "); 
     
    1079802      sb.append(r.getSizeZ()); 
    1080803    } 
    1081     if (tCount[series] > 1) { 
     804    if (tCount > 1) { 
    1082805      if (first) first = false; 
    1083806      else sb.append("; "); 
     
    1121844  } 
    1122845 
    1123   /** Prints a debugging message to the ImageJ log if debug mode is set. */ 
    1124   private void debug(String msg) { 
    1125     if (IJ.debugMode) IJ.log("Bio-Formats Importer: " + msg); 
    1126   } 
    1127  
    1128846  // -- Main method -- 
    1129847 
     
    1139857  } 
    1140858 
    1141   // -- Helper classes -- 
    1142  
    1143   private class VirtualReader extends DimensionSwapper { 
    1144     private int refCount; 
    1145  
    1146     // -- Constructor -- 
    1147  
    1148     public VirtualReader(IFormatReader r) { 
    1149       super(r); 
    1150       refCount = 0; 
    1151     } 
    1152  
    1153     // -- VirtualReader API methods -- 
    1154  
    1155     public void setRefCount(int refCount) { 
    1156       this.refCount = refCount; 
    1157     } 
    1158  
    1159     // -- IFormatReader API methods -- 
    1160  
    1161     public void close() throws IOException { 
    1162       if (refCount > 0) refCount--; 
    1163       if (refCount == 0) super.close(); 
    1164     } 
    1165  
    1166   } 
    1167  
    1168859} 
  • branches/cleanup/components/loci-plugins/src/loci/plugins/importer/ImporterOptions.java

    r5729 r5867  
    2626package loci.plugins.importer; 
    2727 
     28import ij.IJ; 
     29 
     30import java.awt.Rectangle; 
    2831import java.io.IOException; 
     32import java.util.Arrays; 
     33import java.util.StringTokenizer; 
    2934 
    3035import loci.common.Location; 
     36import loci.common.ReflectException; 
     37import loci.common.ReflectedUniverse; 
     38import loci.formats.ChannelSeparator; 
     39import loci.formats.FilePattern; 
     40import loci.formats.FileStitcher; 
     41import loci.formats.FormatException; 
     42import loci.formats.FormatTools; 
     43import loci.formats.IFormatReader; 
     44import loci.formats.ImageReader; 
     45import loci.formats.MetadataTools; 
     46import loci.formats.meta.IMetadata; 
     47import loci.plugins.prefs.OptionsDialog; 
    3148import loci.plugins.prefs.OptionsList; 
    3249import loci.plugins.prefs.StringOption; 
     50import loci.plugins.util.BF; 
     51import loci.plugins.util.IJStatusEchoer; 
     52import loci.plugins.util.ImagePlusReader; 
    3353import loci.plugins.util.LibraryChecker; 
     54import loci.plugins.util.LociPrefs; 
     55import loci.plugins.util.VirtualReader; 
     56import loci.plugins.util.WindowTools; 
     57 
     58import org.apache.log4j.Level; 
     59import org.apache.log4j.Logger; 
    3460 
    3561/** 
     
    108134  public static final String ORDER_XYTZC   = "XYTZC"; 
    109135 
     136  // -- Fields - derived values -- 
     137 
     138  protected ImagePlusReader r; 
     139  protected String idName; 
     140  protected Location idLoc; 
     141  protected IMetadata meta; 
     142  protected String currentFile; 
     143 
     144  // series options 
     145  protected boolean[] series; 
     146 
     147  // range options 
     148  protected int[] cBegin, cEnd, cStep, cCount; 
     149  protected int[] zBegin, zEnd, zStep, zCount; 
     150  protected int[] tBegin, tEnd, tStep, tCount; 
     151 
     152  // crop options 
     153  protected Rectangle[] cropRegion; 
     154 
     155  // -- Fields - internal -- 
     156 
     157  private IFormatReader baseReader; 
     158  private VirtualReader virtualReader; 
     159  private String[] seriesLabels; 
     160 
    110161  // -- Constructor -- 
    111162 
     
    125176  } 
    126177 
    127   // -- ImporterOptions methods -- 
     178  // -- ImporterOptions methods - option harvesting -- 
    128179 
    129180  /** Parses the plugin argument for parameter values. */ 
     
    155206    } 
    156207  } 
     208 
     209  /** 
     210   * Displays dialog boxes prompting for additional configuration details. 
     211   * 
     212   * Which dialogs are shown depends on a variety of factors, including the 
     213   * current configuration (i.e., which options are enabled), whether quiet or 
     214   * windowless mode is set, and whether the method is being called from within 
     215   * a macro. 
     216   * 
     217   * After calling this method, derived field values will also be populated. 
     218   * 
     219   * @return true if harvesting went OK, or false if something went wrong 
     220   *   (e.g., the user canceled a dialog box) 
     221   * 
     222   * @see ij.gui.GenericDialog 
     223   */ 
     224  public boolean showDialogs() throws FormatException, IOException { 
     225    baseReader = null; 
     226    idName = null; 
     227    idLoc = null; 
     228 
     229    if (!promptLocation()) return false; 
     230    if (!promptId()) return false; 
     231 
     232    computeNameAndLocation(); 
     233    createBaseReader(); 
     234 
     235    if (!promptOptions()) return false; 
     236 
     237    // save options as new defaults 
     238    if (!isQuiet()) setFirstTime(false); 
     239    saveOptions(); 
     240 
     241    IJ.showStatus("Analyzing " + getIdName()); 
     242 
     243    baseReader.setMetadataFiltered(true); 
     244    baseReader.setOriginalMetadataPopulated(true); 
     245    baseReader.setGroupFiles(!isUngroupFiles()); 
     246    baseReader.setId(getId()); 
     247 
     248    currentFile = baseReader.getCurrentFile(); 
     249 
     250    if (!promptFilePattern()) return false; 
     251 
     252    initializeReader(); 
     253 
     254    if (!promptSeries()) return false; 
     255    if (!promptSwap()) return false; 
     256    if (!promptRange()) return false; 
     257    if (!promptCrop()) return false; 
     258 
     259    computeRangeCounts(); 
     260 
     261    return true; 
     262  } 
     263 
     264  // -- ImporterOptions methods - base options accessors and mutators -- 
    157265 
    158266  // autoscale 
     
    327435  // windowless 
    328436  public String getWindowlessInfo() { return getInfo(KEY_WINDOWLESS); } 
    329   public boolean isWindowless() { return isSet(KEY_WINDOWLESS); } 
     437  public boolean isWindowless() { 
     438    if (baseReader != null && LociPrefs.isWindowless(baseReader)) return true; 
     439    return isSet(KEY_WINDOWLESS); 
     440  } 
    330441  public void setWindowless(boolean b) { setValue(KEY_WINDOWLESS, b); } 
    331442 
     443  // -- ImporterOptions methods - derived values accessors -- 
     444 
     445  public String getIdName() { return idName; } 
     446  public Location getIdLocation() { return idLoc; } 
     447  public ImagePlusReader getReader() { return r; } 
     448  public IMetadata getMetadata() { return meta; } 
     449  public String getCurrentFile() { return currentFile; } 
     450 
     451  // series options 
     452  public int getCBegin(int s) { return cBegin[s]; } 
     453  public int getCEnd(int s) { return cEnd[s]; } 
     454  public int getCStep(int s) { return cStep[s]; } 
     455  public int getCCount(int s) { return cCount[s]; } 
     456  public int getZBegin(int s) { return zBegin[s]; } 
     457  public int getZEnd(int s) { return zEnd[s]; } 
     458  public int getZStep(int s) { return zStep[s]; } 
     459  public int getZCount(int s) { return zCount[s]; } 
     460  public int getTBegin(int s) { return tBegin[s]; } 
     461  public int getTEnd(int s) { return tEnd[s]; } 
     462  public int getTStep(int s) { return tStep[s]; } 
     463  public int getTCount(int s) { return tCount[s]; } 
     464  public boolean isSeriesOn(int s) { return series[s]; } 
     465 
     466  // crop options 
     467  public Rectangle getCropRegion(int s) { return cropRegion[s]; } 
     468 
     469  // -- Helper methods -- 
     470 
     471  /** Initializes the idName and idLoc derived values. */ 
     472  private void computeNameAndLocation() { 
     473    String id = getId(); 
     474 
     475    idLoc = null; 
     476    idName = id; 
     477    if (isLocal()) { 
     478      idLoc = new Location(id); 
     479      idName = idLoc.getName(); 
     480    } 
     481    else if (isOME() || isOMERO()) { 
     482      // NB: strip out username and password when opening from OME/OMERO 
     483      StringTokenizer st = new StringTokenizer(id, "?&"); 
     484      StringBuffer idBuf = new StringBuffer(); 
     485      int tokenCount = 0; 
     486      while (st.hasMoreTokens()) { 
     487        String token = st.nextToken(); 
     488        if (token.startsWith("username=") || token.startsWith("password=")) { 
     489          continue; 
     490        } 
     491        if (tokenCount == 1) idBuf.append("?"); 
     492        else if (tokenCount > 1) idBuf.append("&"); 
     493        idBuf.append(token); 
     494        tokenCount++; 
     495      } 
     496      idName = idBuf.toString(); 
     497    } 
     498  } 
     499 
     500  /** 
     501   * Initializes an {@link loci.formats.IFormatReader} 
     502   * according to the current configuration. 
     503   */ 
     504  private void createBaseReader() { 
     505    if (isLocal() || isHTTP()) { 
     506      if (!isQuiet()) IJ.showStatus("Identifying " + idName); 
     507      ImageReader reader = ImagePlusReader.makeImageReader(); 
     508      try { baseReader = reader.getReader(getId()); } 
     509      catch (FormatException exc) { 
     510        WindowTools.reportException(exc, isQuiet(), 
     511          "Sorry, there was an error reading the file."); 
     512        return; 
     513      } 
     514      catch (IOException exc) { 
     515        WindowTools.reportException(exc, isQuiet(), 
     516          "Sorry, there was a I/O problem reading the file."); 
     517        return; 
     518      } 
     519    } 
     520    else if (isOMERO()) { 
     521      // NB: avoid dependencies on optional loci.ome.io package 
     522      try { 
     523        ReflectedUniverse ru = new ReflectedUniverse(); 
     524        ru.exec("import loci.ome.io.OMEROReader"); 
     525        baseReader = (IFormatReader) ru.exec("new OMEROReader()"); 
     526      } 
     527      catch (ReflectException exc) { 
     528        WindowTools.reportException(exc, isQuiet(), 
     529          "Sorry, there was a problem constructing the OMERO I/O engine"); 
     530        return; 
     531      } 
     532    } 
     533    else if (isOME()) { 
     534      // NB: avoid dependencies on optional loci.ome.io package 
     535      try { 
     536        ReflectedUniverse ru = new ReflectedUniverse(); 
     537        ru.exec("import loci.ome.io.OMEReader"); 
     538        baseReader = (IFormatReader) ru.exec("new OMEReader()"); 
     539      } 
     540      catch (ReflectException exc) { 
     541        WindowTools.reportException(exc, isQuiet(), 
     542          "Sorry, there was a problem constructing the OME I/O engine"); 
     543        return; 
     544      } 
     545    } 
     546    else { 
     547      WindowTools.reportException(null, isQuiet(), 
     548        "Sorry, there has been an internal error: unknown data source"); 
     549    } 
     550    meta = MetadataTools.createOMEXMLMetadata(); 
     551    baseReader.setMetadataStore(meta); 
     552 
     553    if (!isQuiet()) IJ.showStatus(""); 
     554 
     555    Logger root = Logger.getRootLogger(); 
     556    root.setLevel(Level.INFO); 
     557    root.addAppender(new IJStatusEchoer()); 
     558  } 
     559 
     560  private boolean promptLocation() { 
     561    LocationDialog dialog = new LocationDialog(this); 
     562    return dialog.showDialog() == OptionsDialog.STATUS_OK; 
     563  } 
     564 
     565  private boolean promptId() { 
     566    IdDialog dialog = new IdDialog(this); 
     567    return dialog.showDialog() == OptionsDialog.STATUS_OK; 
     568  } 
     569 
     570  private boolean promptOptions() { 
     571    if (isWindowless()) return true; 
     572 
     573    ImporterDialog dialog = new ImporterDialog(this); 
     574    return dialog.showDialog() == OptionsDialog.STATUS_OK; 
     575  } 
     576 
     577  /** Prompts for the file pattern, if necessary. May override id value. */ 
     578  private boolean promptFilePattern() throws FormatException, IOException { 
     579    if (!isGroupFiles()) { 
     580      BF.debug("no need to prompt for file pattern"); 
     581      return true; 
     582    } 
     583    BF.debug("prompt for the file pattern"); 
     584 
     585    FilePatternDialog dialog = new FilePatternDialog(this); 
     586    if (dialog.showDialog() != OptionsDialog.STATUS_OK) return false; 
     587 
     588    String id = getId(); 
     589    if (id == null) id = currentFile; 
     590    FilePattern fp = new FilePattern(id); 
     591    if (!fp.isValid()) id = currentFile; 
     592    setId(id); // CTR CHECK -- probably the wrong way to do this 
     593    return true; 
     594  } 
     595 
     596  /** Initializes the ImagePlusReader derived value. */ 
     597  private void initializeReader() throws FormatException, IOException { 
     598    if (isGroupFiles()) baseReader = new FileStitcher(baseReader, true); 
     599    if (isVirtual() || !isMergeChannels() || 
     600      FormatTools.getBytesPerPixel(baseReader.getPixelType()) != 1) 
     601    { 
     602      baseReader = new ChannelSeparator(baseReader); 
     603    } 
     604    virtualReader = new VirtualReader(baseReader); 
     605    r = new ImagePlusReader(virtualReader); 
     606    r.setId(getId()); 
     607  } 
     608 
     609  /** Prompts for which series to import, if necessary. */ 
     610  private boolean promptSeries() throws FormatException, IOException { 
     611    // initialize series-related derived values 
     612    series = new boolean[r.getSeriesCount()]; 
     613    series[0] = true; 
     614 
     615    // build descriptive label for each series 
     616    int seriesCount = r.getSeriesCount(); 
     617    seriesLabels = new String[seriesCount]; 
     618    for (int i=0; i<seriesCount; i++) { 
     619      r.setSeries(i); 
     620      StringBuffer sb = new StringBuffer(); 
     621      sb.append("Series_"); 
     622      sb.append((i + 1)); 
     623      sb.append(": "); 
     624      String name = getMetadata().getImageName(i); 
     625      if (name != null && name.length() > 0) { 
     626        sb.append(name); 
     627        sb.append(": "); 
     628      } 
     629      sb.append(r.getSizeX()); 
     630      sb.append(" x "); 
     631      sb.append(r.getSizeY()); 
     632      sb.append("; "); 
     633      sb.append(r.getImageCount()); 
     634      sb.append(" plane"); 
     635      if (r.getImageCount() > 1) { 
     636        sb.append("s"); 
     637        if (r.isOrderCertain()) { 
     638          sb.append(" ("); 
     639          boolean first = true; 
     640          if (r.getEffectiveSizeC() > 1) { 
     641            sb.append(r.getEffectiveSizeC()); 
     642            sb.append("C"); 
     643            first = false; 
     644          } 
     645          if (r.getSizeZ() > 1) { 
     646            if (!first) sb.append(" x "); 
     647            sb.append(r.getSizeZ()); 
     648            sb.append("Z"); 
     649            first = false; 
     650          } 
     651          if (r.getSizeT() > 1) { 
     652            if (!first) sb.append(" x "); 
     653            sb.append(r.getSizeT()); 
     654            sb.append("T"); 
     655            first = false; 
     656          } 
     657          sb.append(")"); 
     658        } 
     659      } 
     660      seriesLabels[i] = sb.toString(); 
     661      //seriesLabels[i] = seriesLabels[i].replaceAll(" ", "_"); 
     662    } 
     663 
     664    if (seriesCount > 1 && !openAllSeries() && !isViewNone()) { 
     665      BF.debug("prompt for which series to import"); 
     666      SeriesDialog dialog = new SeriesDialog(this, r, seriesLabels, series); 
     667      if (dialog.showDialog() != OptionsDialog.STATUS_OK) return false; 
     668    } 
     669    else BF.debug("no need to prompt for series"); 
     670 
     671    if (openAllSeries() || isViewNone()) { 
     672      Arrays.fill(series, true); 
     673    } 
     674    return true; 
     675  } 
     676 
     677  /** Prompts for dimension swapping parameters, if necessary. */ 
     678  private boolean promptSwap() { 
     679    if (!isSwapDimensions()) { 
     680      BF.debug("no need to prompt for dimension swapping"); 
     681      return true; 
     682    } 
     683    BF.debug("prompt for dimension swapping parameters"); 
     684 
     685    SwapDialog dialog = new SwapDialog(this, virtualReader, series); 
     686    return dialog.showDialog() == OptionsDialog.STATUS_OK; 
     687  } 
     688 
     689  /** Prompts for the range of planes to import, if necessary. */ 
     690  private boolean promptRange() { 
     691    // initialize range-related derived values 
     692    int seriesCount = r.getSeriesCount(); 
     693    cBegin = new int[seriesCount]; 
     694    cEnd = new int[seriesCount]; 
     695    cStep = new int[seriesCount]; 
     696    zBegin = new int[seriesCount]; 
     697    zEnd = new int[seriesCount]; 
     698    zStep = new int[seriesCount]; 
     699    tBegin = new int[seriesCount]; 
     700    tEnd = new int[seriesCount]; 
     701    tStep = new int[seriesCount]; 
     702 
     703    for (int i=0; i<seriesCount; i++) { 
     704      r.setSeries(i); 
     705      cBegin[i] = zBegin[i] = tBegin[i] = 0; 
     706      cEnd[i] = r.getEffectiveSizeC() - 1; 
     707      zEnd[i] = r.getSizeZ() - 1; 
     708      tEnd[i] = r.getSizeT() - 1; 
     709      cStep[i] = zStep[i] = tStep[i] = 1; 
     710    } 
     711 
     712 
     713    if (!isSpecifyRanges()) { 
     714      BF.debug("open all planes"); 
     715      return true; 
     716    } 
     717    boolean needRange = false; 
     718    for (int i=0; i<seriesCount; i++) { 
     719      if (series[i] && r.getImageCount() > 1) needRange = true; 
     720    } 
     721    if (!needRange) { 
     722      BF.debug("no need to prompt for planar ranges"); 
     723      return true; 
     724    } 
     725    BF.debug("prompt for planar ranges"); 
     726    IJ.showStatus(""); 
     727 
     728    RangeDialog dialog = new RangeDialog(this, 
     729      r, series, seriesLabels, cBegin, cEnd, cStep, 
     730      zBegin, zEnd, zStep, tBegin, tEnd, tStep); 
     731    return dialog.showDialog() == OptionsDialog.STATUS_OK; 
     732  } 
     733 
     734  /** Prompts for cropping details, if necessary. */ 
     735  private boolean promptCrop() { 
     736    // initialize crop-related derived values 
     737    cropRegion = new Rectangle[r.getSeriesCount()]; 
     738    for (int i=0; i<cropRegion.length; i++) { 
     739      if (series[i] && doCrop()) cropRegion[i] = new Rectangle(); 
     740    } 
     741 
     742    if (!doCrop()) { 
     743      BF.debug("no need to prompt for cropping region"); 
     744      return true; 
     745    } 
     746    BF.debug("prompt for cropping region"); 
     747 
     748    CropDialog dialog = new CropDialog(this, 
     749      r, seriesLabels, series, cropRegion); 
     750    return dialog.showDialog() == OptionsDialog.STATUS_OK; 
     751  } 
     752 
     753  /** Initializes the cCount, zCount and tCount derived values. */ 
     754  private void computeRangeCounts() { 
     755    int seriesCount = r.getSeriesCount(); 
     756    cCount = new int[seriesCount]; 
     757    zCount = new int[seriesCount]; 
     758    tCount = new int[seriesCount]; 
     759    for (int i=0; i<seriesCount; i++) { 
     760      if (!series[i]) cCount[i] = zCount[i] = tCount[i] = 0; 
     761      else { 
     762        if (isMergeChannels()) cCount[i] = 1; 
     763        else cCount[i] = (cEnd[i] - cBegin[i] + cStep[i]) / cStep[i]; 
     764        zCount[i] = (zEnd[i] - zBegin[i] + zStep[i]) / zStep[i]; 
     765        tCount[i] = (tEnd[i] - tBegin[i] + tStep[i]) / tStep[i]; 
     766      } 
     767    } 
     768  } 
     769 
    332770} 
  • branches/cleanup/components/loci-plugins/src/loci/plugins/macro/LociFunctions.java

    r5624 r5867  
    3737import loci.formats.FormatTools; 
    3838import loci.formats.IFormatReader; 
     39import loci.formats.ImageReader; 
    3940import loci.formats.MetadataTools; 
    4041import loci.formats.meta.MetadataRetrieve; 
     
    259260  // -- LociFunctions API methods - additional methods -- 
    260261 
     262  public void getFormat(String id, String[] format) 
     263    throws FormatException, IOException 
     264  { 
     265    ImageReader reader = new ImageReader(); 
     266    format[0] = reader.getFormat(id); 
     267  } 
     268 
    261269  public void setId(String id) throws FormatException, IOException { 
    262270    r.setId(id); 
     
    318326      IJ.write("-= Usable any time =-"); 
    319327      IJ.write(""); 
     328      IJ.write("Ext.getFormat(id, format)"); 
     329      IJ.write("-- Retrieves the file format of the given id (filename)."); 
    320330      IJ.write("Ext.setId(id)"); 
    321331      IJ.write("-- Initializes the given id (filename)."); 
  • branches/cleanup/components/loci-plugins/src/loci/plugins/prefs/BooleanOption.java

    r5139 r5867  
    9191    String s = Macro.getValue(arg, key, null); 
    9292    if (s != null) value = s.equalsIgnoreCase("true"); 
     93    else if (label != null) { 
     94      s = Macro.getValue(arg, label, null); 
     95      if (s != null) value = s.equalsIgnoreCase("true"); 
     96    } 
    9397  } 
    9498 
  • branches/cleanup/components/loci-plugins/src/loci/plugins/prefs/StringOption.java

    r5139 r5867  
    140140  public void parseOption(String arg) { 
    141141    value = Macro.getValue(arg, key, value); 
     142    if (value == null && label != null) { 
     143      value = Macro.getValue(arg, label, value); 
     144    } 
    142145  } 
    143146 
  • branches/cleanup/components/loci-plugins/src/loci/plugins/util/LociPrefs.java

    r5111 r5867  
    3636 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/util/LociPrefs.java">SVN</a></dd></dl> 
    3737 */ 
    38 public class LociPrefs { 
     38public final class LociPrefs { 
    3939 
    4040  // -- Constants -- 
  • branches/cleanup/components/loci-plugins/src/loci/plugins/util/WindowTools.java

    r5256 r5867  
    171171 
    172172  /** Reports the given exception with stack trace in an ImageJ error dialog. */ 
     173  public static void reportException(Throwable t, boolean quiet) { 
     174    reportException(t, quiet, null); 
     175  } 
     176 
     177  /** Reports the given exception with stack trace in an ImageJ error dialog. */ 
    173178  public static void reportException(Throwable t, boolean quiet, String msg) { 
    174179    IJ.showStatus(""); 
Note: See TracChangeset for help on using the changeset viewer.