Changeset 2046


Ignore:
Timestamp:
01/08/07 13:49:29 (13 years ago)
Author:
melissa
Message:
  • Added options to importer to allow downloading from OME or other servers.
  • Cleaned up OME plugin to play nicely with importer.
Location:
trunk/loci/plugins
Files:
10 deleted
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/loci/plugins/Importer.java

    r2025 r2046  
    5959  private static final String VIEW_VIEW_5D = "View5D"; 
    6060 
     61  private static final String LOCAL_FILE = "Local machine"; 
     62  private static final String OME_FILE = "OME server"; 
     63  private static final String HTTP_FILE = "Internet"; 
     64 
    6165  // -- Fields -- 
    6266 
     
    100104    } 
    101105 
    102     // if necessary, prompt the user for the filename 
    103     OpenDialog od = new OpenDialog("Open", id); 
    104     String directory = od.getDirectory(); 
    105     String fileName = od.getFileName(); 
    106     if (fileName == null) { 
    107       plugin.canceled = true; 
    108       return; 
    109     } 
    110     id = directory + fileName; 
    111  
    112     // if no valid filename, give up 
    113     if (id == null || !new File(id).exists()) { 
    114       if (!quiet) { 
    115         IJ.error("LOCI Bio-Formats", "The specified file " + 
    116           (id == null ? "" : ("(" + id + ") ")) + "does not exist."); 
    117       } 
    118       return; 
     106    String fileName = id; 
     107 
     108    if (id == null || id.length() == 0) {  
     109      // open a dialog asking the user where their dataset is 
     110      GenericDialog g = new GenericDialog("Specify location"); 
     111      g.addChoice("File location: ",  
     112        new String[] {LOCAL_FILE, OME_FILE, HTTP_FILE}, LOCAL_FILE);  
     113      g.showDialog(); 
     114     
     115      String location = g.getNextChoice(); 
     116 
     117      if (location.equals(LOCAL_FILE)) { 
     118        // if necessary, prompt the user for the filename 
     119        OpenDialog od = new OpenDialog("Open", id); 
     120        String directory = od.getDirectory(); 
     121        fileName = od.getFileName(); 
     122        if (fileName == null) { 
     123          plugin.canceled = true; 
     124          return; 
     125        } 
     126        id = directory + fileName; 
     127 
     128        // if no valid filename, give up 
     129        if (id == null || !new File(id).exists()) { 
     130          if (!quiet) { 
     131            IJ.error("LOCI Bio-Formats", "The specified file " + 
     132              (id == null ? "" : ("(" + id + ") ")) + "does not exist."); 
     133          } 
     134          return; 
     135        } 
     136      } 
     137      else if (location.equals(OME_FILE)) { 
     138        IJ.runPlugIn("loci.plugins.ome.OMEPlugin", ""); 
     139        return; 
     140      } 
     141      else { 
     142        // prompt for URL 
     143        GenericDialog urlBox = new GenericDialog("Open"); 
     144        urlBox.addStringField("URL: ", "", 30); 
     145        urlBox.showDialog(); 
     146        id = urlBox.getNextString(); 
     147        fileName = id; 
     148      }  
    119149    } 
    120150 
  • trunk/loci/plugins/ome/OMEPlugin.java

    r2010 r2046  
    2424package loci.plugins.ome; 
    2525 
    26 import ij.IJ; 
    2726import ij.plugin.PlugIn; 
    2827import loci.plugins.Util; 
     
    3635 */ 
    3736public class OMEPlugin implements PlugIn { 
    38   private static OMESidePanel omeSidePanel; 
    3937 
    4038  /** shows and retrieves info from the SidePanel */ 
     
    4240    if (!Util.checkVersion()) return; 
    4341    if (!Util.checkLibraries(true, true, true, true)) return; 
    44     if (omeSidePanel == null) omeSidePanel = new OMESidePanel(IJ.getInstance()); 
    45     WindowMonitor monitor = new WindowMonitor(); 
    46     monitor.start(); 
    47     OMESidePanel.showIt(); 
     42    new OMETools().run(); 
    4843  } 
    4944 
  • trunk/loci/plugins/ome/OMETablePanel.java

    r2010 r2046  
    2424package loci.plugins.ome; 
    2525 
     26import ij.IJ; 
     27import java.awt.*; 
     28import java.awt.event.*; 
     29import java.awt.image.BufferedImage; 
     30import java.util.ArrayList; 
    2631import javax.swing.*; 
     32import javax.swing.border.*; 
    2733import javax.swing.event.*; 
    28 import javax.swing.border.*; 
    29 import java.awt.*; 
    30 import java.awt.image.BufferedImage; 
    31 import java.awt.event.*; 
    32 import java.util.ArrayList; 
     34import javax.swing.table.DefaultTableModel; 
    3335 
    3436/** 
     
    158160 
    159161    //create table 
    160     MyTableModel tableModel = new MyTableModel(tableData, columns); 
     162    //MyTableModel tableModel = new MyTableModel(tableData, columns); 
     163    DefaultTableModel tableModel = new DefaultTableModel(tableData, columns) { 
     164      public Class getColumnClass(int c) { 
     165        return getValueAt(0, c).getClass(); 
     166      } 
     167      public boolean isCellEditable(int row, int col) { 
     168        return col == 0; 
     169      } 
     170    }; 
    161171    sorter = new TableSorter(tableModel); 
    162172 
     
    229239    mainpane.setMinimumSize(new Dimension(800,300)); 
    230240    dialog.pack(); 
    231     OMESidePanel.centerWindow(frame, dialog); 
    232241  } 
    233242 
     
    313322    } 
    314323    if (results.length == 0) { 
    315       OMEDownPanel.error((Frame)dialog.getOwner(), 
    316       "No images were selected to download.  Try again.", 
    317         "OME Download"); 
     324      IJ.error("OME Download",  
     325        "No images were selected to download.  Try again."); 
    318326      return getInput(); 
    319327    } 
  • trunk/loci/plugins/ome/OMETools.java

    r2010 r2046  
    2525 
    2626import ij.*; 
     27import ij.gui.GenericDialog; 
    2728import ij.process.*; 
    28 import ij.gui.GenericDialog; 
    29  
    30 import java.awt.Panel; 
    31 import java.util.Hashtable; 
    32  
    33 //import loci.plugins.browser.LociDataBrowser; 
    34  
     29import java.util.*; 
     30import loci.formats.*; 
    3531import org.openmicroscopy.ds.*; 
    3632import org.openmicroscopy.ds.dto.*; 
    37 import org.openmicroscopy.ds.managers.*; 
    3833import org.openmicroscopy.ds.st.*; 
    3934import org.openmicroscopy.is.*; 
    4035 
    4136/** 
    42  * Handles uploading and downloading images. 
     37 * Handles downloading images. 
    4338 * 
    4439 * @author Philip Huettl pmhuettl at wisc.edu 
     
    7570  private boolean upload; 
    7671 
    77   /** Current OMELoginPanel. */ 
    78   private OMELoginPanel lp; 
    79  
    8072  /** Data for the current image. */ 
    8173  private DataFactory df; 
    8274  private PixelsFactory pf; 
    83   private DatasetManager dm; 
    84   private ConfigurationManager cm; 
    85   private AnalysisEngineManager aem; 
    86   private ImportManager im; 
    8775  private RemoteCaller rc; 
    8876  private DataServices rs; 
    89  
    90 //  private LociDataBrowser viewer; 
    9177 
    9278  // -- Runnable API methods -- 
     
    9682   * the OME login fields and whether the stack is in the time or space domain 
    9783   */ 
    98   private void getInput(boolean b, OMELoginPanel d) { 
    99     String[] in = d.getInput(b); 
    100     if (in == null) { 
    101       cancelPlugin = true; 
    102       return; 
    103     } 
    104     server = in[0]; 
    105     username = in[1]; 
    106     password = in[2]; 
    107  
    108     if(upload) { 
    109       // choose the 4th dimension 
    110       GenericDialog gc = new GenericDialog("OME image export"); 
    111       Panel p = new Panel(); 
    112       String[] domains = {"Time", "Space"}; 
    113       gc.addChoice("Stack Domain:", domains, "Time"); 
    114       gc.showDialog(); 
    115       cancelPlugin = gc.wasCanceled(); 
    116       if(cancelPlugin) return; 
    117       domainIndex = gc.getNextChoiceIndex(); 
    118     } 
     84  private void getInput() { 
     85    GenericDialog gd = new GenericDialog("OME Login"); 
     86    gd.addStringField("Server:   ", "", 30); 
     87    gd.addStringField("Username: ", "", 30); 
     88    gd.addStringField("Password: ", "", 30); 
     89    gd.showDialog(); 
     90 
     91    server = gd.getNextString(); 
     92    username = gd.getNextString(); 
     93    password = gd.getNextString(); 
    11994  } 
    12095 
     
    133108   * This code has been adapted from Doug Creager's TestImport example. 
    134109   */ 
    135   public void login(boolean isUp) { 
     110  public void login() { 
    136111    boolean error = false; 
    137112    boolean loggedIn = false; 
    138113    try { 
    139       upload = isUp; 
    140114      IJ.showProgress(0); 
    141       lp = new OMELoginPanel(IJ.getInstance()); 
    142       getInput(false, lp); 
     115      getInput(); 
    143116      if(cancelPlugin) { 
    144117        pluginCancelled(); 
     
    161134    } 
    162135    catch(Exception e) { 
    163       OMEDownPanel.error(IJ.getInstance(), 
    164         "The login information is not valid.", "Input Error"); 
    165       login(isUp); 
     136      IJ.error("Input Error", "The login information is not valid."); 
     137      login(); 
    166138      if(cancelPlugin) { 
    167139        pluginCancelled(); 
     
    180152      } 
    181153      df = (DataFactory) rs.getService(DataFactory.class); 
    182       im = (ImportManager) rs.getService(ImportManager.class); 
    183154      pf = (PixelsFactory) rs.getService(PixelsFactory.class); 
    184       dm = (DatasetManager) rs.getService(DatasetManager.class); 
    185       cm = (ConfigurationManager) rs.getService(ConfigurationManager.class); 
    186       aem = (AnalysisEngineManager) rs.getService(AnalysisEngineManager.class); 
    187155    } 
    188156    catch(NullPointerException e) { 
     
    190158      getHelpers(); 
    191159    } 
    192   } 
    193  
    194   /** Set the stack domain (4th dimension) */ 
    195   public int[] setDomain(int[] dims) { 
    196     if (dims[0] == 0) dims[0]++; 
    197     if (dims[1] == 0) dims[1]++; 
    198     if (domainIndex == 0) { 
    199       return new int[] {dims[0], dims[1]}; 
    200     } 
    201     return new int[] {dims[1], dims[0]}; 
    202  
    203     //if(dims[0] == 0) return new int[] {dims[1], 1}; 
    204     //else return new int[] {1, dims[1]}; 
    205160  } 
    206161 
     
    211166    rc.logout(); 
    212167    IJ.showStatus("OME: Completed"); 
    213     OMELoginPanel.infoShow(IJ.getInstance(), "OME Transaction Completed", 
    214       "OME"); 
    215   } 
    216  
    217   public void finalCatch(Exception exc) { 
    218     IJ.setColumnHeadings("Errors"); 
    219     IJ.write("An exception has occurred:  \n" + exc.toString()); 
    220     IJ.showStatus("Error uploading (see error console for details)"); 
    221     exc.printStackTrace(); 
    222   } 
    223  
    224   // -- Upload methods -- 
    225  
    226   /** Does the work for uploading data to OME. */ 
    227   public void run(ImagePlus ip, Object[] metadata) { 
    228     try { 
    229       login(true); 
    230       imageP = ip; 
    231       getHelpers(); 
    232  
    233       Experimenter user = OMERetrieve.getUser(df); 
    234  
    235       // start the import process 
    236       IJ.showStatus("OmeUpload: Starting import..."); 
    237       im.startImport(user); 
    238       IJ.showProgress(0.15); 
    239  
    240       //getting the image to add the pixels to from OME 
    241       Image omeImage = null; 
    242       int omeID = ((Integer)metadata[0]).intValue(); 
    243       if (omeID != 0) { 
    244         omeImage = OMERetrieve.getImagefromID(df, omeID); 
    245       } 
    246  
    247       // locate a repository object to contain the pixels 
    248       IJ.showStatus("OmeUpload: Finding repository..."); 
    249       Repository rep = pf.findRepository(0); 
    250       IJ.showProgress(0.18); 
    251  
    252       // create a new Image object for the multidimensional image 
    253       IJ.showStatus("OmeUpload: Creating image entry..."); 
    254       Image image; 
    255       if (omeImage != null) { 
    256         image = omeImage; 
    257       } 
    258       else { 
    259         image = (Image) df.createNew(Image.class); 
    260         image.setName(imageP.getTitle()); 
    261         image.setOwner(user); 
    262         image.setInserted("now"); 
    263         image.setCreated("now"); 
    264         image.setDescription("This image was uploaded from ImageJ"); 
    265       } 
    266       df.markForUpdate(image); 
    267  
    268       // extract image dimensions 
    269       int sizeX = imageP.getWidth(); 
    270       int sizeY = imageP.getHeight(); 
    271       int type = imageP.getType(); 
    272       int bytesPerPix = 1; 
    273       int sizeC = 1; 
    274       boolean isFloat = false; 
    275       switch (type) { 
    276         case ImagePlus.COLOR_256: 
    277           //in order to correctly upload you need to convert to an RGB image 
    278           imageP = new ImagePlus(ip.getTitle(), new ColorProcessor( 
    279             ((ByteProcessor) imageP.getProcessor()).createImage())); 
    280           break; 
    281         case ImagePlus.COLOR_RGB: 
    282           sizeC = 3; 
    283           break; 
    284         case ImagePlus.GRAY16: 
    285           bytesPerPix = 2; 
    286           break; 
    287         case ImagePlus.GRAY32: 
    288           bytesPerPix = 4; 
    289           isFloat = true; 
    290           break; 
    291       } 
    292  
    293       // set domain of stack 
    294       int[] results = new int[] {domainIndex, imageP.getStackSize()}; 
    295       results = setDomain(results); 
    296       int sizeT = results[1]; 
    297       int sizeZ = results[0]; 
    298  
    299       IJ.showProgress(.25); 
    300  
    301       // get a MEX for the image's metadata 
    302       IJ.showStatus("OmeUpload: Creating pixels file..."); 
    303       ModuleExecution ii = im.getImageImportMEX(image); 
    304       ii.setExperimenter(user); 
    305  
    306       // create a new pixels file on the image server to contain image pixels 
    307       Pixels pix = pf.newPixels(rep, image, ii, 
    308         sizeX, sizeY, sizeZ, sizeC, sizeT, bytesPerPix, isFloat, isFloat); 
    309  
    310       // extract image pixels from each plane 
    311       byte [] r = new byte[sizeX*sizeY]; 
    312       byte [] g = new byte[sizeX*sizeY]; 
    313       byte [] b = new byte[sizeX*sizeY]; 
    314       for (int t=0; t<sizeT; t++) { 
    315         for (int z=0; z<sizeZ; z++) { 
    316           for (int c=0; c<sizeC; c++) { 
    317             byte[] pixels = new byte[sizeX * sizeY * bytesPerPix]; 
    318             IJ.showStatus("OmeUpload: Loading data (t=" + t + ", z=" + z + 
    319               ", c=" + c + ")..."); 
    320             double progress = (double) 
    321               (t*sizeC*sizeZ+z*sizeC+c)/(sizeT*sizeZ*sizeC); 
    322             IJ.showProgress(.25+.25*progress); 
    323             switch (type) { 
    324               case ImagePlus.COLOR_RGB: 
    325                 ((ColorProcessor)imageP.getStack().getProcessor( 
    326                   Math.max(z,t)+1)).getRGB(r, g, b); 
    327                 switch (c) { 
    328                   case 2: 
    329                     pixels = r; 
    330                     break; 
    331                   case 1: 
    332                     pixels = g; 
    333                     break; 
    334                   case 0: 
    335                     pixels = b; 
    336                     break; 
    337                 } 
    338                 break; 
    339  
    340               case ImagePlus.GRAY16: 
    341                 short[] pixsh = 
    342                   (short[]) imageP.getStack().getPixels(Math.max(z,t)+1); 
    343                 for (int i=0; i<pixsh.length; i++) { 
    344                   pixels[2*i] = (byte) ((pixsh[i] & 0xff00) >> 8); 
    345                   pixels[2*i+1] = (byte) (pixsh[i] & 0x00ff); 
    346                 } 
    347                 break; 
    348  
    349               case ImagePlus.GRAY32: 
    350                 float[] pixsf = 
    351                   (float[]) imageP.getStack().getPixels(Math.max(z,t)+1); 
    352                 for (int i=0; i<pixsf.length; i++) { 
    353                   pixels[4*i] = (byte) 
    354                     ((Float.floatToRawIntBits(pixsf[i]) & 0xff000000)>>24); 
    355                   pixels[4*i+1] = (byte) 
    356                     ((Float.floatToRawIntBits(pixsf[i]) & 0x00ff0000)>>16); 
    357                   pixels[4*i+2] = (byte) 
    358                     ((Float.floatToRawIntBits(pixsf[i]) & 0x0000ff00)>>8); 
    359                   pixels[4*i+3] = (byte) 
    360                     (Float.floatToRawIntBits(pixsf[i]) & 0x000000ff); 
    361                 } 
    362                 break; 
    363  
    364               default: 
    365                 byte[] pixsb = (byte[]) 
    366                   imageP.getStack().getPixels(Math.max(z,t)+1); 
    367                 System.arraycopy(pixsb, 0, pixels, 0, pixsb.length); 
    368             } 
    369             // upload the byte buffer 
    370             pf.setPlane(pix, z, c, t, pixels, true); 
    371  
    372             // This next piece of metadata is necessary for all 
    373             // images; otherwise, the standard OME viewers will not be 
    374             // able to display the image.  The PixelChannelComponent 
    375             // attribute represents one channel index in the pixels 
    376             // file; there should be at least one of these for each 
    377             // channel in the image.  The LogicalChannel attribute 
    378             // describes a logical channel, which might comprise more 
    379             // than one channel index in the pixels file.  (Usually it 
    380             // doesn't.)  The mutators listed below are the minimum 
    381             // necessary to fully represents the image's channels; 
    382             // there are others which might be populated if the 
    383             // metadata exists in the original file.  As with the 
    384             // Pixels attribute, the channel attributes should use the 
    385             // image import MEX received earlier from the 
    386             // ImportManager. 
    387             LogicalChannel logical = (LogicalChannel) 
    388             df.createNew("LogicalChannel"); 
    389             logical.setImage(image); 
    390             logical.setModuleExecution(ii); 
    391             if (sizeC == 3) { 
    392               switch(c) { 
    393                 case 0: logical.setFluor("Blue"); break; 
    394                 case 1: logical.setFluor("Green"); break; 
    395                 case 2: logical.setFluor("Red"); break; 
    396               } 
    397               logical.setPhotometricInterpretation("RGB"); 
    398             } 
    399             else { 
    400               logical.setFluor("Gray"); 
    401               logical.setPhotometricInterpretation("monochrome"); 
    402             } 
    403             df.markForUpdate(logical); 
    404  
    405             PixelChannelComponent physical = (PixelChannelComponent) 
    406               df.createNew("PixelChannelComponent"); 
    407             physical.setImage(image); 
    408             physical.setPixels(pix); 
    409             physical.setIndex(new Integer(c)); 
    410             physical.setLogicalChannel(logical); 
    411             physical.setModuleExecution(ii); 
    412             df.markForUpdate(physical); 
    413           } 
    414         } 
    415       } 
    416       IJ.showProgress(.5); 
    417  
    418       // close the pixels file on the image server 
    419       IJ.showStatus("OmeUpload: Closing pixels file.."); 
    420       pf.finishPixels(pix); 
    421       IJ.showProgress(.55); 
    422  
    423       // create a default thumbnail for the image 
    424       IJ.showStatus("OmeUpload: Creating PGI thumbnail..."); 
    425       CompositingSettings cs = 
    426         CompositingSettings.createDefaultPGISettings(sizeZ, sizeC, sizeT); 
    427       if (sizeC == 3) { 
    428         cs.activateRedChannel(2,0,255,1); 
    429         cs.activateGreenChannel(1,0,255,1); 
    430         cs.activateBlueChannel(0,0,255,1); 
    431       } 
    432       else cs.activateGrayChannel(0,0,255,1); 
    433       pf.setThumbnail(pix, cs); 
    434       IJ.showProgress(.6); 
    435  
    436       // mark image import MEX as having completed executing 
    437       ii.setStatus("FINISHED"); 
    438       df.markForUpdate(ii); 
    439       IJ.showProgress(.85); 
    440  
    441       // commit all changes 
    442       IJ.showStatus("OmeUpload: Committing changes..."); 
    443       df.updateMarked(); 
    444       IJ.showProgress(.87); 
    445  
    446       // set default pixels entry 
    447       image.setDefaultPixels(pix); 
    448       df.update(image); 
    449       IJ.showProgress(.9); 
    450  
    451       // extract image display options and create display options 
    452       DisplayOptions disOp = (DisplayOptions) df.createNew("DisplayOptions"); 
    453       disOp.setPixels(pix); 
    454       disOp.setImage(image); 
    455       disOp.setModuleExecution(ii); 
    456       disOp.setTStart(new Integer(0)); 
    457       disOp.setTStop(new Integer(0)); 
    458       disOp.setZStart(new Integer(0)); 
    459       disOp.setZStop(new Integer(0)); 
    460  
    461       ImageProcessor proc = imageP.getProcessor(); 
    462       // The white and black level are set as constants because imageJ gives 
    463       // the pixels truncated if you changed these values, this prevents the 
    464       // min and max being set twice. 
    465       Double whiteLevel = new Double(255);//proc.getMax()); 
    466       Double blackLevel = new Double(0);//proc.getMin()); 
    467  
    468       if(sizeC == 3) { 
    469         disOp.setColorMap("RGB"); 
    470         disOp.setDisplayRGB(new Boolean(true)); 
    471       } 
    472       else { 
    473         disOp.setColorMap("monochrome"); 
    474         disOp.setDisplayRGB(new Boolean(false)); 
    475       } 
    476  
    477       DisplayChannel ch; 
    478       for(int i=0; i<sizeC; i++) { 
    479         ch = (DisplayChannel) df.createNew("DisplayChannel"); 
    480         if(sizeC == 1) ch.setModuleExecution(ii);  // remove?? 
    481         ch.setImage(image); 
    482         ch.setGamma(new Float(1)); 
    483         ch.setWhiteLevel(whiteLevel); 
    484         ch.setBlackLevel(blackLevel); 
    485         ch.setChannelNumber(new Integer(i)); 
    486  
    487         switch(i) { 
    488           case 0: 
    489             disOp.setGreyChannel(ch); 
    490             disOp.setRedChannel(ch); 
    491             disOp.setGreenChannel(ch); 
    492             disOp.setBlueChannel(ch); 
    493             disOp.setRedChannelOn(new Boolean(false)); 
    494             disOp.setGreenChannelOn(new Boolean(false)); 
    495             disOp.setBlueChannelOn(new Boolean(false)); 
    496             break; 
    497           case 1: 
    498             disOp.setGreenChannel(ch); 
    499             break; 
    500           case 2: 
    501             disOp.setRedChannel(ch); 
    502             disOp.setGreyChannel(ch); 
    503             disOp.setRedChannelOn(new Boolean(true)); 
    504             disOp.setGreenChannelOn(new Boolean(true)); 
    505             disOp.setBlueChannelOn(new Boolean(true)); 
    506             break; 
    507         } 
    508         df.update(ch); 
    509       } 
    510       df.update(disOp); 
    511  
    512       // execute the import analysis chain 
    513       IJ.showStatus("OmeUpload: Executing import chain..."); 
    514       AnalysisChain chain = cm.getImportChain(); 
    515       IJ.showProgress(.95); 
    516  
    517       logout(); 
    518     } 
    519     catch(NullPointerException e) { 
    520       // do nothing; this means that the user cancelled the login procedure 
    521     } 
    522     catch(IllegalArgumentException e) { 
    523       // do nothing; this means that the user cancelled the login procedure 
    524     } 
    525     catch (Exception exc) { 
    526       finalCatch(exc); 
    527     } 
    528  
    529     upThread = null; 
    530     IJ.showProgress(1); 
     168    IJ.showMessage("OME", "OME Transaction Completed"); 
    531169  } 
    532170 
    533171  // -- Download methods -- 
    534172 
    535   /** Method that puts an image from OME back into ImageJ */ 
    536   private void download(Image image, PixelsFactory pf, OMESidePanel omesp, 
    537       DataFactory df) { 
    538  
    539     if (cancelPlugin) { 
    540       pluginCancelled(); 
    541       return; 
    542     } 
    543  
    544     //get pixel data 
    545  
    546     Pixels pix = image.getDefaultPixels(); 
    547     int sizeX, sizeY, sizeZ, sizeC, sizeT; 
    548     sizeX = pix.getSizeX().intValue(); 
    549     sizeY = pix.getSizeY().intValue(); 
    550     sizeZ = pix.getSizeZ().intValue(); 
    551     sizeC = pix.getSizeC().intValue(); 
    552     sizeT = pix.getSizeT().intValue(); 
    553     String typeS = pix.getPixelType(); 
    554     Hashtable table = new Hashtable(4); 
    555     table.put("Uint16", new Integer(ImagePlus.GRAY16)); 
    556     table.put("uint16", new Integer(ImagePlus.GRAY16)); 
    557     table.put("Uint8", new Integer(ImagePlus.GRAY8)); 
    558     table.put("uint8", new Integer(ImagePlus.GRAY8)); 
    559     table.put("float", new Integer(ImagePlus.GRAY32)); 
    560     table.put("color256", new Integer(ImagePlus.COLOR_256)); 
    561     table.put("colorRGB", new Integer(ImagePlus.COLOR_RGB)); 
    562     table.put("Uint32", new Integer(17)); 
    563     table.put("uint32", new Integer(17)); 
    564     table.put("int16", new Integer(ImagePlus.GRAY16)); 
    565     table.put("int8", new Integer(ImagePlus.GRAY8)); 
    566     int type = ((Integer)table.get(typeS)).intValue(); 
    567     int redChanNum = 2; 
    568     int greenChanNum = 1; 
    569     int blueChanNum = 0; 
    570     if (sizeC == 3) { 
    571       type = ImagePlus.COLOR_RGB; 
    572       IJ.showStatus("Finding color channel numbers."); 
    573       //code that figures out the display options and 
    574       //what color is what channel number 
    575       String [] attrs = {"BlueChannel", "ColorMap","DisplayROIList", 
    576         "GreenChannel", "GreyChannel", "Pixels", "RedChannel", "TStart", 
    577         "TStop", "Zoom", "ZStart", "ZStop", "BlueChannelOn", "DisplayRGB", 
    578         "GreenChannelOn", "RedChannelOn"}; 
    579       Criteria criteria = OMERetrieve.makeAttributeFields(attrs); 
    580       criteria.addWantedField("image_id"); 
    581       criteria.addFilter("image_id", (new Integer(image.getID())).toString()); 
    582       //retrieve element to add with all columns loaded 
    583       DisplayOptions element = (DisplayOptions) 
    584         df.retrieve("DisplayOptions", criteria); 
    585       DisplayChannel redChannel = null; 
    586       DisplayChannel greenChannel = null; 
    587       DisplayChannel blueChannel = null; 
    588  
    589       if (element != null) { 
    590         redChannel = element.getRedChannel(); 
    591         greenChannel = element.getGreenChannel(); 
    592         blueChannel = element.getBlueChannel(); 
    593  
    594         String [] attrsC = {"ChannelNumber"}; 
    595         DisplayChannel[] channels = {redChannel, greenChannel, blueChannel}; 
    596         int[] channelNum = {redChanNum, greenChanNum, blueChanNum}; 
    597         for(int i=0; i<sizeC; i++) { 
    598           criteria = OMERetrieve.makeAttributeFields(attrsC); 
    599           criteria.addWantedField("id"); 
    600           criteria.addFilter("id", new Integer(channels[i].getID()).toString()); 
    601           channels[i] = (DisplayChannel) 
    602             df.retrieve("DisplayChannel", criteria); 
    603           channelNum[i] = channels[i].getChannelNumber().intValue(); 
    604         } 
    605         redChanNum = channelNum[0]; 
    606         greenChanNum = channelNum[1]; 
    607         blueChanNum = channelNum[2]; 
    608       } 
    609     } 
    610  
    611     // create Stack to add planes to in ImageJ 
    612     ImageStack is = new ImageStack(sizeX, sizeY); 
    613     try { 
    614       for (int c=0; c<sizeC; c++) { 
    615         for (int t=0; t<sizeT; t++) { 
    616           for (int z=0; z<sizeZ; z++) { 
    617             byte[] pixelb = new byte[sizeX * sizeY]; 
    618             int[] pixeli = new int[sizeX * sizeY]; 
    619             short[] pixels = new short[sizeX * sizeY]; 
    620             double[] pixeld = new double[sizeX * sizeY]; 
    621             IJ.showStatus("OmeDownload: Loading data (c=" + 
    622               c + ", t=" + t + ", z=" + z + ")..."); 
    623             ImageProcessor ip = null; 
    624             if (type == 17 || type == ImagePlus.GRAY32) { 
    625               byte[] pixs = pf.getPlane(pix, z, c, t, true); 
    626               for (int i=0; i<pixeli.length; i++) { 
    627                 pixeli[i] = ((pixs[4*i] & 0xff)<<24) + 
    628                   ((pixs[4*i+1] & 0xff)<<16) + 
    629                   ((pixs[4*i+2] & 0xff)<<8) + 
    630                   (pixs[4*i+3] & 0xff); 
    631                 pixeld[i] = (new Integer(pixeli[i])).doubleValue(); 
    632               } 
    633               ip = new FloatProcessor(sizeX, sizeY, pixeld); 
    634             } 
    635             else if (type == ImagePlus.COLOR_256) { 
    636               pixelb = pf.getPlane(pix, z, c, t, true); 
    637               for (int i=0; i<pixelb.length; i++) { 
    638                 pixelb[i] = (byte)(128-pixelb[i]); 
    639               } 
    640               ip = new ByteProcessor(sizeX, sizeY); 
    641               ip.setPixels(pixelb); 
    642             } 
    643             else if (type == ImagePlus.COLOR_RGB) { 
    644               byte[] r = pf.getPlane(pix, z, redChanNum, t, true); 
    645               byte[] g = pf.getPlane(pix, z, greenChanNum, t, true); 
    646               byte[] b = pf.getPlane(pix, z, blueChanNum, t, true); 
    647               for (int i=0; i<pixeli.length; i++) { 
    648                 pixeli[i] = ((r[i] & 0xff)<<16)+ 
    649                   ((g[i] & 0xff)<<8)+ (b[i] & 0xff); 
    650               } 
    651               ip = new ColorProcessor(sizeX, sizeY, pixeli); 
    652             } 
    653             else if (type == ImagePlus.GRAY16) { 
    654               byte[] pixs = pf.getPlane(pix, z, c, t, true); 
    655               for (int i=0; i<pixels.length; i++) { 
    656                 pixels[i] = (short)(((pixs[2*i] & 0xff)<<8)+ 
    657                   (pixs[2*i+1] & 0xff)); 
    658               } 
    659               ip = new ShortProcessor(sizeX, sizeY); 
    660               ip.setPixels(pixels); 
    661             } 
    662             else if (type == ImagePlus.GRAY8) { 
    663               pixelb = pf.getPlane(pix, z, c, t, true); 
    664               ip = new ByteProcessor(sizeX, sizeY); 
    665               ip.setPixels(pixelb); 
    666             } 
    667             if (ip != null) { 
    668               // adding plane to the ImageStack 
    669               is.addSlice("C=" + c + " Z=" + z + " T=" + t, ip); 
    670             } 
    671           } 
    672         } 
    673       } 
    674     } 
    675     catch(ImageServerException e) { 
    676       OMEDownPanel.error(IJ.getInstance(), 
    677         "There was an error downloading the image.\n" + e.toString(), 
    678         "Download Error"); 
    679       cancelPlugin = true; 
    680       pluginCancelled(); 
    681       e.printStackTrace(); 
    682       return; 
    683     } 
    684  
    685     //Create the ImagePlus in ImageJ and display it 
    686     imageP = new ImagePlus(image.getName(), is); 
    687  
    688     //retrieve metadata 
    689     Object[] metas = new Object[2]; 
    690     metas[0] = new Integer(image.getID()); 
    691     if (OMESidePanel.yesNo(IJ.getInstance(), 
    692       "Would you like to download\nmetadata associated with the\n" + 
    693       "image " + image.getName() + " along with\n" + 
    694       "the pixels?  (It takes a bit longer.)")) { 
    695       IJ.showStatus("Retrieving metadata..."); 
    696       metas[1] = OMEMetaDataHandler.exportMeta(image, imageP, df); 
    697     } 
    698     IJ.showStatus("Displaying Image"); 
    699 //    viewer = new LociDataBrowser(); 
    700  
    701 //    viewer.setDimensions(sizeZ, sizeC, sizeT, 0, 2, 1); 
    702 //    viewer.show(imageP); 
    703     imageP.show(); 
    704     OMESidePanel.hashInImage(-image.getID(), metas); 
     173  /** 
     174   * HACK: this replaces calls to DataFactory.retrieveList(String, Criteria), 
     175   * since that method is broken for unknown reasons. 
     176   */ 
     177  public static List retrieveList(String st, Criteria crit, DataFactory df) { 
     178    List l = new Vector(); 
     179    int need = df.count(st, crit); 
     180    int have = 0; 
     181    while (have < need) { 
     182      crit.setOffset(have); 
     183      l.add(df.retrieve(st, crit)); 
     184      have++; 
     185    } 
     186    return l; 
    705187  } 
    706188 
     
    709191    //table array 
    710192    Object[][] props = new Object[ima.length][4]; 
     193     
    711194    //details array 
    712195    Object[][] details = new Object[ima.length][10]; 
     196     
    713197    //build a hashtable of experimenters to display names 
    714     String[][] expers = OMERetrieve.retrieveExperimenters(df); 
     198     
     199    Criteria criteria = new Criteria(); 
     200    criteria.addWantedField("FirstName"); 
     201    criteria.addWantedField("LastName"); 
     202    criteria.addOrderBy("LastName"); 
     203    List l = df.retrieveList("Experimenter", criteria); 
     204    String[][] expers = new String[3][l.size()]; 
     205    for (int i=0; i<l.size(); i++) { 
     206      expers[0][i] = ((Experimenter) l.get(i)).getFirstName(); 
     207      expers[1][i] = ((Experimenter) l.get(i)).getLastName(); 
     208      expers[2][i] = "" + ((Experimenter) l.get(i)).getID(); 
     209    } 
     210     
    715211    Hashtable hm = new Hashtable(expers.length); 
    716212    for (int i=0; i<expers[0].length; i++) { 
    717213      hm.put(new Integer(expers[2][i]), expers[1][i] + ", " + expers[0][i]); 
    718214    } 
     215     
    719216    //assemble the table array 
    720217    Pixels p; 
     
    735232      } 
    736233      catch (Throwable t) { 
    737         OMEDownPanel.error(IJ.getInstance(), "An exception occured.\n" + 
    738           t.toString(), "Error"); 
     234        IJ.error("Error", "An exception occured.\n" + t.toString()); 
    739235        IJ.showStatus("Error Downloading thumbnails."); 
    740236        t.printStackTrace(); 
     
    774270 
    775271  /** Does the work for downloading data from OME. */ 
    776   public void run(OMESidePanel osp) { 
     272  public void run() { 
    777273    try { 
    778       login(false); 
     274      login(); 
    779275      getHelpers(); 
    780276 
    781277      //get database info to use in search 
    782278      IJ.showStatus("Getting database info.."); 
    783       String[][] owners = OMERetrieve.retrieveExperimenters(df); 
    784       Project[] projects = OMERetrieve.retrieveAllProjects(df); 
     279       
     280      Criteria criteria = new Criteria(); 
     281      criteria.addWantedField("FirstName"); 
     282      criteria.addWantedField("LastName"); 
     283      criteria.addOrderBy("LastName"); 
     284 
     285      List l = df.retrieveList("Experimenter", criteria); 
     286      String[][] owners = new String[2][l.size() + 1]; 
     287      owners[0][0] = "All"; 
     288      owners[1][0] = "0"; 
     289      for (int i=1; i<=l.size(); i++) { 
     290        Experimenter e = (Experimenter) l.get(i - 1); 
     291        owners[0][i] = e.getFirstName() + " " + e.getLastName(); 
     292        owners[1][i] = "" + e.getID(); 
     293      } 
     294 
     295      criteria = new Criteria(); 
     296      criteria.addWantedField("id"); 
     297      criteria.addWantedField("name"); 
     298      criteria.addWantedField("datasets"); 
     299      criteria.addWantedField("datasets", "id"); 
     300      criteria.addWantedField("datasets", "name"); 
     301      criteria.addWantedField("datasets", "images"); 
     302      
     303      FieldsSpecification fs = new FieldsSpecification(); 
     304      fs.addWantedField("id"); 
     305      fs.addWantedField("experimenter"); 
     306      fs.addWantedField("experimenter", "id"); 
     307 
     308      Experimenter user = df.getUserState(fs).getExperimenter(); 
     309 
     310      criteria.addFilter("owner_id", new Integer(user.getID())); 
     311      criteria.addOrderBy("name"); 
     312      l = df.retrieveList(Project.class, criteria); 
     313      Project[] projects = (Project[]) l.toArray(new Project[0]); 
     314      String[] projectNames = new String[projects.length + 1]; 
     315      projectNames[0] = "All"; 
     316      for (int i=1; i<projectNames.length; i++) { 
     317        projectNames[i] = projects[i - 1].getName(); 
     318      } 
     319 
    785320      //create search panel 
    786321      IJ.showStatus("Creating search panel..."); 
    787       OMEDownPanel dp = null; 
    788       try { 
    789         dp = new OMEDownPanel(IJ.getInstance(), projects, owners); 
    790       } 
    791       catch (NullPointerException n) { return; } 
     322      GenericDialog gd = new GenericDialog("OME Download Search"); 
     323      gd.addChoice("Project:    ", projectNames, "All"); 
     324      gd.addChoice("Owner:      ", owners[0], "All"); 
     325      gd.addStringField("Image ID:   ", "", 30); 
     326      gd.addStringField("Image Name: ", "", 30); 
     327      gd.showDialog(); 
     328       
    792329      Image[] images = new Image[0]; 
    793330 
     
    795332      IJ.showStatus("Searching for images..."); 
    796333      while (images.length == 0) { 
    797         Object[] objects = dp.search(); 
    798         if (objects == null) { 
    799           cancelPlugin = true; 
    800           pluginCancelled(); 
    801           return; 
    802         } 
    803334        //get search results 
    804         images = OMERetrieve.retrieveImages(df, objects); 
     335        
     336        String project = gd.getNextChoice(); 
     337        String owner = gd.getNextChoice(); 
     338        String img = gd.getNextString(); 
     339        if (img == null || img.length() == 0) img = "0"; 
     340        int imageId = new Integer(img).intValue(); 
     341        String imageName = gd.getNextString(); 
     342 
     343        Criteria c = new Criteria(); 
     344        c.addWantedField("id"); 
     345        c.addWantedField("name"); 
     346        c.addWantedField("description"); 
     347        c.addWantedField("inserted"); 
     348        c.addWantedField("created"); 
     349        c.addWantedField("owner"); 
     350        c.addWantedField("default_pixels"); 
     351        c.addWantedField("default_pixels", "id"); 
     352        c.addWantedField("default_pixels", "SizeX"); 
     353        c.addWantedField("default_pixels", "SizeY"); 
     354        c.addWantedField("default_pixels", "SizeZ"); 
     355        c.addWantedField("default_pixels", "SizeC"); 
     356        c.addWantedField("default_pixels", "SizeT"); 
     357        c.addWantedField("default_pixels", "PixelType"); 
     358        c.addWantedField("default_pixels", "Repository"); 
     359        c.addWantedField("default_pixels", "ImageServerID"); 
     360        c.addWantedField("default_pixels.Repository", "ImageServerURL"); 
     361        c.addWantedField("owner", "FirstName"); 
     362        c.addWantedField("owner", "LastName"); 
     363        c.addWantedField("owner", "id"); 
     364 
     365        if (!owner.equals("All")) { 
     366          // TODO : add filters 
     367        } 
     368 
     369        if (!project.equals("All")) { 
     370          // TODO : add filters 
     371        } 
     372 
     373        l = df.retrieveList(Image.class, c); 
     374        images = (Image[]) l.toArray(new Image[0]); 
     375 
    805376        if(images == null) images = new Image[0]; 
    806377        if (images.length == 0) { 
    807           OMELoginPanel.infoShow(IJ.getInstance(), 
    808             "No images matched the specified criteria.", "OME Download"); 
     378          IJ.showMessage("OME Download",  
     379            "No images matched the specified criteria."); 
    809380        } 
    810381        else { 
     
    820391      //download into ImageJ 
    821392      for (int i=0; i<images.length; i++) { 
    822         download(images[i], pf, osp, df); 
     393        ImageReader reader = new ImageReader(); 
     394        String file = server + "?user=" + username + "&password=" + password + 
     395          "&id=" + images[i].getID(); 
     396        IJ.runPlugIn("loci.plugins.LociImporter", file); 
     397 
    823398        if (cancelPlugin) { 
    824399          pluginCancelled(); 
     
    836411    } 
    837412    catch (Exception exc) { 
    838       finalCatch(exc); 
     413      IJ.setColumnHeadings("Errors"); 
     414      IJ.write("An exception has occurred:  \n" + exc.toString()); 
     415      IJ.showStatus("Error uploading (see error console for details)"); 
     416      exc.printStackTrace(); 
    839417    } 
    840418 
Note: See TracChangeset for help on using the changeset viewer.