Changeset 4053


Ignore:
Timestamp:
05/16/08 16:30:37 (12 years ago)
Author:
curtis
Message:

Miscellaneous cleanup.

Location:
branches/OMERO Writer
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/OMERO Writer/.classpath

    r4026 r4053  
    1717        <classpathentry kind="lib" path="jar/blitz-3.0-Beta2.3.jar"/> 
    1818        <classpathentry kind="lib" path="jar/bio-formats-internal.jar"/> 
    19         <classpathentry kind="lib" path="jar/ij.jar"/> 
    2019        <classpathentry kind="lib" path="jar/ome-java-2007-Aug-07-r3052.jar"/> 
    2120        <classpathentry kind="output" path="bin"/> 
  • branches/OMERO Writer/src/loci/formats/ome/OMEROWriter.java

    r4026 r4053  
    44 
    55/* 
    6 LOCI Bio-Formats package for reading and converting biological file formats. 
    7 Copyright (C) 2005-@year@ Melissa Linkert, Curtis Rueden, Chris Allan, 
    8 Eric Kjellman and Brian Loranger. 
     6OME Bio-Formats package for reading and converting biological file formats. 
     7Copyright (C) 2005-@year@ UW-Madison LOCI and Glencoe Software, Inc. 
    98 
    109This program is free software; you can redistribute it and/or modify 
    11 it under the terms of the GNU Library General Public License as published by 
    12 the Free Software Foundation; either version 2 of the License, or 
     10it under the terms of the GNU General Public License as published by 
     11the Free Software Foundation; either version 3 of the License, or 
    1312(at your option) any later version. 
    1413 
     
    1615but WITHOUT ANY WARRANTY; without even the implied warranty of 
    1716MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    18 GNU Library General Public License for more details. 
    19  
    20 You should have received a copy of the GNU Library General Public License 
     17GNU General Public License for more details. 
     18 
     19You should have received a copy of the GNU General Public License 
    2120along with this program; if not, write to the Free Software 
    2221Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
     
    5251import java.util.List; 
    5352 
    54 import org.openmicroscopy.ds.st.Pixels; 
    55  
    56  
     53import ome.model.core.Pixels; 
    5754 
    5855import loci.formats.*; 
     
    6057import loci.formats.ReflectedUniverse; 
    6158 
    62  
    63  
    6459import ome.formats.importer.*; 
    65  
    6660 
    6761/** 
     
    6963 * 
    7064 * <dl><dt><b>Source code:</b></dt> 
    71  * <dd><a href="https://skyking.microscopy.wisc.edu/trac/java/browser/trunk/loci/formats/ome/OMEWriter.java">Trac</a>, 
    72  * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/loci/formats/ome/OMEWriter.java">SVN</a></dd></dl> 
     65 * <dd><a href="https://skyking.microscopy.wisc.edu/trac/java/browser/trunk/loci/formats/ome/OMEROWriter.java">Trac</a>, 
     66 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/loci/formats/ome/OMEROWriter.java">SVN</a></dd></dl> 
    7367 */ 
    7468public class OMEROWriter extends FormatWriter{ 
    75          
    76           // -- Constants -- 
    77  
    78           private static final String NO_OMERO_MSG = "OMERO client libraries not " + 
    79             "found.  Please install omero-common.jar and omero-client.jar from " + 
    80             "http://www.loci.wisc.edu/ome/formats.html"; 
    81            
    82  
    83           // -- Static fields -- 
    84  
    85           private static boolean noOMERO = false; 
    86           private static ReflectedUniverse r = createReflectedUniverse(); 
    87            
    88           // -- Fields -- 
    89  
    90           private static String username; 
    91           private static String password; 
    92           private static String serverName; 
    93           private static String port; 
    94            
    95           private static String imageName; 
    96            
    97          // private Main         viewer; 
    98  
    99          
    100             /** OMERO raw pixels service */ 
    101             private static RawPixelsStore pservice; 
    102  
    103             /** OMERO query service */ 
    104             private static IQuery         iQuery; 
    105  
    106             /** OMERO update service */ 
    107             private static IUpdate        iUpdate; 
    108              
    109             private static Experimenter    exp; 
    110              
    111  
    112             private static Log  log    = (Log) LogFactory.getLog(OMEROWriter.class); 
    113  
    114             /** OMERO service factory; all other services are retrieved from here. */ 
    115             private static ServiceFactory sf; 
    116             private static OMEROMetadataStore store; 
    117              
    118             private OMEROWrapper reader; 
    119              
    120             /** Flag indicating the current session is valid. */ 
    121             private boolean validLogin = false; 
    122  
    123           /** Authentication credentials. */ 
    124           private OMECredentials credentials; 
    125  
    126           /** Image server. */ 
    127           private String omeis; 
    128  
    129  
    130           private MetadataRetrieve metadata; 
    131            
    132           // -- Constructor -- 
    133  
    134           /** Constructs a new OMERO writer. */ 
    135           public OMEROWriter() { super("OMERO", "*"); } 
    136  
    137           // -- Internal OMEWriter API methods -- 
    138  
    139           private static ReflectedUniverse createReflectedUniverse() { 
    140                     r = null; 
    141                     try { 
    142                       r = new ReflectedUniverse(); 
    143                       r.exec("import java.lang.Class"); 
    144                       r.exec("import org.openmicroscopy.ds.DataFactory"); 
    145                       r.exec("import org.openmicroscopy.ds.DataServer"); 
    146                       r.exec("import org.openmicroscopy.ds.DataServices"); 
    147                       r.exec("import org.openmicroscopy.ds.FieldsSpecification"); 
    148                       r.exec("import org.openmicroscopy.ds.RemoteCaller"); 
    149                       r.exec("import org.openmicroscopy.ds.dto.ModuleExecution"); 
    150                       r.exec("import org.openmicroscopy.ds.dto.UserState"); 
    151                       r.exec("import org.openmicroscopy.ds.managers.ImportManager"); 
    152                       r.exec("import org.openmicroscopy.ds.st.Experimenter"); 
    153                       r.exec("import org.openmicroscopy.ds.st.LogicalChannel"); 
    154                       r.exec("import org.openmicroscopy.ds.st.Pixels"); 
    155                       r.exec("import org.openmicroscopy.ds.st.Repository"); 
    156                       r.exec("import org.openmicroscopy.is.CompositingSettings"); 
    157                       r.exec("import org.openmicroscopy.is.ImageServer"); 
    158                       r.exec("import org.openmicroscopy.is.PixelsFactory"); 
    159                     } 
    160                     catch (ReflectException e) { 
    161                       if (debug) LogTools.trace(e); 
    162                       noOMERO = false; 
    163                     } 
    164                     return r; 
    165                   } 
    166  
    167  
    168         /** Fires a status update event. */ 
    169           protected void status(String message) { 
    170             status(new StatusEvent(message)); 
    171           } 
    172  
    173           /** Fires a status update event. */ 
    174           protected void status(int progress, int maximum, String message) { 
    175             status(new StatusEvent(progress, maximum, message)); 
    176           } 
    177  
    178           /** Fires a status update event. */ 
    179           protected void status(StatusEvent e) { 
    180             StatusListener[] l = getStatusListeners(); 
    181             for (int i=0; i<l.length; i++) l[i].statusUpdated(e); 
    182           } 
    183            
    184            
    185          
    186            
    187  
    188           public void saveImage(Image image, boolean last) 
    189               throws FormatException, IOException 
    190                   { 
    191                     saveImage(image, 0, last, last); 
    192                   } 
    193                  
    194                   /* @see loci.formats.IFormatWriter#saveImage(Image, int, boolean, boolean) */ 
    195                   public void saveImage(Image image, int series, boolean lastInSeries, 
    196                     boolean last) 
    197                     throws FormatException, IOException 
    198                   { 
    199                           
    200                          
    201                     byte[][] b = ImageTools.getPixelBytes(ImageTools.makeBuffered(image), 
    202                       !metadata.getBigEndian(series).booleanValue()); 
    203                     for (int i=0; i<b.length; i++) { 
    204                       saveBytes(b[i], series, lastInSeries && (i == b.length - 1), 
    205                         last && (i == b.length - 1)); 
    206                     } 
    207                   } 
    208            
    209                 public void saveBytes(byte[] bytes, int series, boolean lastInSeries, 
    210                          boolean last) 
    211                          throws FormatException, IOException 
    212                                   { 
    213                                     if (!validLogin) { 
    214                                      // parse the ID string to get the server, user name and password 
    215                                  
    216                                       serverName = currentId.substring(0, currentId.lastIndexOf("?")); 
    217                                       int ndx = currentId.indexOf("&"); 
    218                                       if (currentId.indexOf("user") != -1) { 
    219                                         username = currentId.substring(currentId.lastIndexOf("?") + 6, ndx); 
    220                                                 password = currentId.substring(ndx + 10); 
    221                                               } 
    222                                       else { 
    223                                         throw new FormatException("Invalid ID - must be of the form " + 
    224                                                   "<server>?user=<username>&password=<password>"); 
    225                                       } 
    226                                     } 
    227                                     login(); 
    228  
    229                          
    230                                   credentials.imageID = -1; 
    231                                   MetadataTools.convertMetadata(metadata, store); 
    232                                    
    233                                 Pixels p = (Pixels) store.getRoot(); 
    234                             p.getImage().setName(imageName); 
    235                             ArrayList<ome.model.core.Pixels> pixId = store.saveToDB(); 
    236                             //store.addPixelsToDataset(pixId, dataset); 
    237                                    
    238                         long timestampIn; 
    239                         long timestampOut; 
    240                         long timestampDiff; 
    241                         long timeInSeconds; 
    242                         long hours, minutes, seconds; 
    243                         Date date = null; 
    244                          
    245                       // record initial timestamp and record total running time for the import 
    246                         timestampIn = System.currentTimeMillis(); 
    247                         date = new Date(timestampIn); 
    248                         SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm"); 
    249                         String myDate = formatter.format(date); 
    250  
    251                              int i = 1; 
    252                             // int bytesPerPixel = getBytesPerPixel(reader.getPixelType()); 
    253                            //  byte[] arrayBuf = new byte[store.* sizeY * bytesPerPixel]; 
    254                                  reader.setSeries(series); 
    255                                  
    256                          List<Image> imageList = (List<Image>) store.getRoot(); 
    257                                 ArrayList<ome.model.core.Pixels> pixelsList = store.saveToDB(); 
    258                          
    259                         for (Image image : imageList) 
    260                         { 
    261                            // store.addImageToDataset(image, dataset); 
    262                         } 
    263  
    264                               
    265                                      
    266                                       
    267                                   close(); 
    268                                      
    269                 } 
    270                  
    271            
    272           //methods done so far: 
    273  
    274           public static void login() throws FormatException 
    275             { 
    276  
    277                  
    278                 if (username == null) throw new NullPointerException("username cannot be null"); 
    279                 if (password == null) throw new NullPointerException("password cannot be null"); 
    280                 if (port == null) throw new NullPointerException("port cannot be null"); 
    281                 if (serverName == null) throw new NullPointerException("server cannot be null"); 
    282                          
    283                  try { 
    284                                 tryLogin(); 
    285                         } catch (Exception e) { 
    286                                 // TODO Auto-generated catch block 
    287                                 e.printStackTrace(); 
    288                         } 
    289                                // notifyObservers(connectionStatus); 
    290                         
    291             } 
    292              
    293             /** 
    294              * @return 
    295              * @throws Exception  
    296              */ 
    297             private static boolean tryLogin() throws Exception 
    298             { 
    299 //               Attempt to log in 
    300                 if(!isValidLogin()) 
    301                 { 
    302                         return false; 
    303                 } 
    304                 try 
    305                 { 
    306                     Server server = new Server(serverName, Integer.parseInt(port)); 
    307                     Login login = new Login(username, password); 
    308                     // Instantiate our service factory 
    309                     sf = new ServiceFactory(server, login); 
    310                     store = new OMEROMetadataStore(sf); 
    311                      
    312                     
    313                 } catch (Throwable t) 
    314                 { 
    315                         System.out.println(t.toString()); 
    316                     return false; 
    317                 } 
    318                 System.out.println("login worked!"); 
    319                 return true; 
    320                  
    321             }     
    322              
    323  
    324             public OMEROMetadataStore getMetadataStore() 
    325             { 
    326                 return store; 
    327             } 
    328   
    329  
    330            
    331           /* @see loci.formats.IFormatHandler#close() */ 
    332           public void close() throws IOException { 
    333             try { 
    334               r.exec("rc.logout()"); 
    335             } 
    336             catch (ReflectException e) { } 
    337             credentials = null; 
    338            //planesWritten = 0; 
    339             metadata = null; 
    340           } 
    341            
    342    
    343            
    344           public void setMetadata(MetadataRetrieve meta) { 
    345                     metadata = meta; 
    346                   } 
    347            
    348           public boolean canDoStacks() { return true; }   
    349            
    350            
    351    
    352            
    353           // -- StatusReporter API methods -- 
    354  
    355           /* @see loci.formats.StatusReporter#addStatusListener(StatusListener) */ 
    356           public void addStatusListener(StatusListener l) { 
    357             synchronized (statusListeners) { 
    358               if (!statusListeners.contains(l)) statusListeners.add(l); 
    359             } 
    360           } 
    361  
    362           /* @see loci.formats.StatusReporter#removeStatusListener(StatusListener) */ 
    363           public void removeStatusListener(StatusListener l) { 
    364             synchronized (statusListeners) { 
    365               statusListeners.remove(l); 
    366             } 
    367           } 
    368  
    369           /* @see loci.formats.StatusReporter#getStatusListeners() */ 
    370           public StatusListener[] getStatusListeners() { 
    371             synchronized (statusListeners) { 
    372               StatusListener[] l = new StatusListener[statusListeners.size()]; 
    373               statusListeners.copyInto(l); 
    374               return l; 
    375             } 
    376           }        
    377            
    378             private static boolean isValidLogin() throws Exception 
    379             { 
    380                 System.out.println(username+ password+serverName+ port); 
    381                 try 
    382                 { 
    383                     store = new OMEROMetadataStore(username, password, serverName, port); 
    384                     store.getProjects(); 
    385                      
    386                 } catch (EJBAccessException e) 
    387                 { 
    388                     return false; 
    389                 } 
    390  
    391                 return true; 
    392             } 
    393            
    394            
    395    public static void main(String[] args) throws Exception { 
    396             org.apache.log4j.BasicConfigurator.configure(); 
    397         username="allison"; 
    398         password="omero"; 
    399         serverName="localhost";       
    400         port="1099"; 
    401          
    402         String id=null; 
    403                    
    404                     // parse command-line arguments 
    405                     boolean doUsage = false; 
    406                     if (args.length == 0) doUsage = true; 
    407                     for (int i=0; i<args.length; i++) { 
    408                       if (args[i].startsWith("-")) { 
    409                         // argument is a command line flag 
    410                         String param = args[i]; 
    411                         try { 
    412                           if (param.equalsIgnoreCase("-s")) serverName = args[++i]; 
    413                           else if (param.equalsIgnoreCase("-a")) port = args[++i]; 
    414                           else if (param.equalsIgnoreCase("-u")) username = args[++i]; 
    415                           else if (param.equalsIgnoreCase("-p")) password = args[++i]; 
    416                           else if (param.equalsIgnoreCase("-h") || param.equalsIgnoreCase("-?")) 
    417                           { 
    418                             doUsage = true; 
    419                           } 
    420                           else { 
    421                             LogTools.println("Error: unknown flag: "+ param); 
    422                             LogTools.println(); 
    423                             doUsage = true; 
    424                             break; 
    425                           } 
    426                         } 
    427                         catch (ArrayIndexOutOfBoundsException exc) { 
    428                           if (i == args.length - 1) { 
    429                             LogTools.println("Error: flag " + param + 
    430                               " must be followed by a parameter value."); 
    431                             LogTools.println(); 
    432                             doUsage = true; 
    433                             break; 
    434                           } 
    435                           else throw exc; 
    436                         } 
    437                       } 
    438                       else { 
    439                         if (id == null) id = args[i]; 
    440                         else { 
    441                           LogTools.println("Error: unknown argument: " + args[i]); 
    442                           LogTools.println(); 
    443                         } 
    444                       } 
    445                     } 
    446  
    447                     if (id == null) doUsage = true; 
    448                     if (doUsage) { 
    449                       LogTools.println("Usage: omero [-s server.address] " + 
    450                         "[-a port] [-u username] [-p password] filename"); 
    451                       LogTools.println(); 
    452                       System.exit(1); 
    453                     }              
    454                    
    455                    
    456 //               ask for information if necessary 
    457                     BufferedReader cin = new BufferedReader(new InputStreamReader(System.in)); 
    458                     if (serverName == null) { 
    459                       LogTools.print("Server name? "); 
    460                       try { serverName = cin.readLine(); } 
    461                       catch (IOException exc) { } 
    462                     } 
    463                     if (port == null) { 
    464                               LogTools.print("Port? "); 
    465                               try { port = cin.readLine(); } 
    466                               catch (IOException exc) { } 
    467                             } 
    468                     if (username == null) { 
    469                       LogTools.print("Username? "); 
    470                       try { username = cin.readLine(); } 
    471                       catch (IOException exc) { } 
    472                     } 
    473                     if (password == null) { 
    474                       LogTools.print("Password? "); 
    475                       try { password = cin.readLine(); } 
    476                       catch (IOException exc) { } 
    477                     } 
    478                     if (serverName == null || username == null || password == null || port == null ) { 
    479                       LogTools.println("Error: could not obtain server login information"); 
    480                       System.exit(2); 
    481                     } 
    482                     LogTools.println("Using server " + serverName + " as user " + username); 
    483                    
    484                  
    485                    
    486            
    487       //create image uploader 
    488                   
    489       OMEROWriter uploader = new OMEROWriter(); 
    490       uploader.addStatusListener(new StatusListener() { 
     69 
     70  // -- Constants -- 
     71 
     72  private static final String NO_OMERO_MSG = "OMERO client libraries not " + 
     73    "found. Please install omero-common.jar and omero-client.jar from " + 
     74    "http://www.loci.wisc.edu/ome/formats.html"; 
     75 
     76  // -- Static fields -- 
     77 
     78  private static boolean noOMERO = false; 
     79 
     80  // -- Fields -- 
     81 
     82  private static String username; 
     83  private static String password; 
     84  private static String serverName; 
     85  private static String port; 
     86 
     87  private static String imageName; 
     88 
     89  // private Main viewer; 
     90 
     91 
     92  /** OMERO raw pixels service */ 
     93  private static RawPixelsStore pservice; 
     94 
     95  /** OMERO query service */ 
     96  private static IQuery iQuery; 
     97 
     98  /** OMERO update service */ 
     99  private static IUpdate iUpdate; 
     100 
     101  private static Experimenter exp; 
     102 
     103  private static Log log = (Log) LogFactory.getLog(OMEROWriter.class); 
     104 
     105  /** OMERO service factory; all other services are retrieved from here. */ 
     106  private static ServiceFactory sf; 
     107  private static OMEROMetadataStore store; 
     108 
     109  private OMEROWrapper reader; 
     110 
     111  /** Flag indicating the current session is valid. */ 
     112  private boolean validLogin = false; 
     113 
     114  /** Authentication credentials. */ 
     115  private OMECredentials credentials; 
     116 
     117  /** Image server. */ 
     118  private String omeis; 
     119 
     120  private MetadataRetrieve metadata; 
     121 
     122  // -- Constructor -- 
     123 
     124  /** Constructs a new OMERO writer. */ 
     125  public OMEROWriter() { super("OMERO", "*"); } 
     126 
     127  // -- Internal OMEWriter API methods -- 
     128 
     129  /** Fires a status update event. */ 
     130  protected void status(String message) { 
     131    status(new StatusEvent(message)); 
     132  } 
     133 
     134  /** Fires a status update event. */ 
     135  protected void status(int progress, int maximum, String message) { 
     136    status(new StatusEvent(progress, maximum, message)); 
     137  } 
     138 
     139  /** Fires a status update event. */ 
     140  protected void status(StatusEvent e) { 
     141    StatusListener[] l = getStatusListeners(); 
     142    for (int i=0; i<l.length; i++) l[i].statusUpdated(e); 
     143  } 
     144 
     145  public void saveImage(Image image, boolean last) 
     146    throws FormatException, IOException 
     147  { 
     148    saveImage(image, 0, last, last); 
     149  } 
     150 
     151  /* @see loci.formats.IFormatWriter#saveImage(Image, int, boolean, boolean) */ 
     152  public void saveImage(Image image, int series, boolean lastInSeries, 
     153    boolean last) 
     154  throws FormatException, IOException 
     155  { 
     156    byte[][] b = ImageTools.getPixelBytes(ImageTools.makeBuffered(image), 
     157      !metadata.getBigEndian(series).booleanValue()); 
     158    for (int i=0; i<b.length; i++) { 
     159      saveBytes(b[i], series, lastInSeries && (i == b.length - 1), 
     160        last && (i == b.length - 1)); 
     161    } 
     162  } 
     163 
     164  public void saveBytes(byte[] bytes, int series, boolean lastInSeries, 
     165    boolean last) throws FormatException, IOException 
     166  { 
     167    if (!validLogin) { 
     168      // parse the ID string to get the server, user name and password 
     169 
     170      serverName = currentId.substring(0, currentId.lastIndexOf("?")); 
     171      int ndx = currentId.indexOf("&"); 
     172      if (currentId.indexOf("user") != -1) { 
     173        username = currentId.substring(currentId.lastIndexOf("?") + 6, ndx); 
     174        password = currentId.substring(ndx + 10); 
     175      } 
     176      else { 
     177        throw new FormatException("Invalid ID - must be of the form " + 
     178            "<server>?user=<username>&password=<password>"); 
     179      } 
     180    } 
     181    login(); 
     182 
     183    credentials.imageID = -1; 
     184    MetadataTools.convertMetadata(metadata, store); 
     185 
     186    Pixels p = (Pixels) store.getRoot(); 
     187    p.getImage().setName(imageName); 
     188    ArrayList<ome.model.core.Pixels> pixId = store.saveToDB(); 
     189    //store.addPixelsToDataset(pixId, dataset); 
     190 
     191    long timestampIn; 
     192    long timestampOut; 
     193    long timestampDiff; 
     194    long timeInSeconds; 
     195    long hours, minutes, seconds; 
     196    Date date = null; 
     197 
     198    // record initial timestamp and record total running time for the import 
     199    timestampIn = System.currentTimeMillis(); 
     200    date = new Date(timestampIn); 
     201    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm"); 
     202    String myDate = formatter.format(date); 
     203 
     204    int i = 1; 
     205    //int bytesPerPixel = getBytesPerPixel(reader.getPixelType()); 
     206    //byte[] arrayBuf = new byte[store.* sizeY * bytesPerPixel]; 
     207    reader.setSeries(series); 
     208 
     209    List<Image> imageList = (List<Image>) store.getRoot(); 
     210    ArrayList<ome.model.core.Pixels> pixelsList = store.saveToDB(); 
     211 
     212    for (Image image : imageList) { 
     213      // store.addImageToDataset(image, dataset); 
     214    } 
     215 
     216    close(); 
     217  } 
     218 
     219  //methods done so far: 
     220 
     221  public static void login() throws FormatException { 
     222    if (username == null) throw new FormatException("username cannot be null"); 
     223    if (password == null) throw new FormatException("password cannot be null"); 
     224    if (port == null) throw new FormatException("port cannot be null"); 
     225    if (serverName == null) throw new FormatException("server cannot be null"); 
     226 
     227    try { 
     228      tryLogin(); 
     229    } 
     230    catch (Exception e) { 
     231      // TODO Auto-generated catch block 
     232      e.printStackTrace(); 
     233    } 
     234    // notifyObservers(connectionStatus); 
     235  } 
     236 
     237  /** 
     238   * @return 
     239   * @throws Exception 
     240   */ 
     241  private static boolean tryLogin() throws Exception { 
     242    // attempt to log in 
     243    if (!isValidLogin()) { 
     244      return false; 
     245    } 
     246    try { 
     247      Server server = new Server(serverName, Integer.parseInt(port)); 
     248      Login login = new Login(username, password); 
     249      // Instantiate our service factory 
     250      sf = new ServiceFactory(server, login); 
     251      store = new OMEROMetadataStore(sf); 
     252    } 
     253    catch (Throwable t) { 
     254      System.out.println(t.toString()); 
     255      return false; 
     256    } 
     257    System.out.println("login worked!"); 
     258    return true; 
     259  } 
     260 
     261  public OMEROMetadataStore getMetadataStore() { 
     262    return store; 
     263  } 
     264 
     265  /* @see loci.formats.IFormatHandler#close() */ 
     266  public void close() throws IOException { 
     267    credentials = null; 
     268    //planesWritten = 0; 
     269    metadata = null; 
     270  } 
     271 
     272  public void setMetadata(MetadataRetrieve meta) { 
     273    metadata = meta; 
     274  } 
     275 
     276  public boolean canDoStacks() { return true; } 
     277 
     278  // -- StatusReporter API methods -- 
     279 
     280  /* @see loci.formats.StatusReporter#addStatusListener(StatusListener) */ 
     281  public void addStatusListener(StatusListener l) { 
     282    synchronized (statusListeners) { 
     283      if (!statusListeners.contains(l)) statusListeners.add(l); 
     284    } 
     285  } 
     286 
     287  /* @see loci.formats.StatusReporter#removeStatusListener(StatusListener) */ 
     288  public void removeStatusListener(StatusListener l) { 
     289    synchronized (statusListeners) { 
     290      statusListeners.remove(l); 
     291    } 
     292  } 
     293 
     294  /* @see loci.formats.StatusReporter#getStatusListeners() */ 
     295  public StatusListener[] getStatusListeners() { 
     296    synchronized (statusListeners) { 
     297      StatusListener[] l = new StatusListener[statusListeners.size()]; 
     298      statusListeners.copyInto(l); 
     299      return l; 
     300    } 
     301  } 
     302 
     303  private static boolean isValidLogin() throws Exception { 
     304    System.out.println(username+ password+serverName+ port); 
     305    try { 
     306      store = new OMEROMetadataStore(username, password, serverName, port); 
     307      store.getProjects(); 
     308    } 
     309    catch (EJBAccessException e) { 
     310      return false; 
     311    } 
     312    return true; 
     313  } 
     314 
     315  public static void main(String[] args) throws Exception { 
     316    org.apache.log4j.BasicConfigurator.configure(); 
     317    username="allison"; 
     318    password="omero"; 
     319    serverName="localhost"; 
     320    port="1099"; 
     321 
     322    String id=null; 
     323 
     324    // parse command-line arguments 
     325    boolean doUsage = false; 
     326    if (args.length == 0) doUsage = true; 
     327    for (int i=0; i<args.length; i++) { 
     328      if (args[i].startsWith("-")) { 
     329        // argument is a command line flag 
     330        String param = args[i]; 
     331        try { 
     332          if (param.equalsIgnoreCase("-s")) serverName = args[++i]; 
     333          else if (param.equalsIgnoreCase("-a")) port = args[++i]; 
     334          else if (param.equalsIgnoreCase("-u")) username = args[++i]; 
     335          else if (param.equalsIgnoreCase("-p")) password = args[++i]; 
     336          else if (param.equalsIgnoreCase("-h") || 
     337            param.equalsIgnoreCase("-?")) 
     338          { 
     339            doUsage = true; 
     340          } 
     341          else { 
     342            LogTools.println("Error: unknown flag: "+ param); 
     343            LogTools.println(); 
     344            doUsage = true; 
     345            break; 
     346          } 
     347        } 
     348        catch (ArrayIndexOutOfBoundsException exc) { 
     349          if (i == args.length - 1) { 
     350            LogTools.println("Error: flag " + param + 
     351                " must be followed by a parameter value."); 
     352            LogTools.println(); 
     353            doUsage = true; 
     354            break; 
     355          } 
     356          else throw exc; 
     357        } 
     358      } 
     359      else { 
     360        if (id == null) id = args[i]; 
     361        else { 
     362          LogTools.println("Error: unknown argument: " + args[i]); 
     363          LogTools.println(); 
     364        } 
     365      } 
     366    } 
     367 
     368    if (id == null) doUsage = true; 
     369    if (doUsage) { 
     370      LogTools.println("Usage: omero [-s server.address] " + 
     371          "[-a port] [-u username] [-p password] filename"); 
     372      LogTools.println(); 
     373      System.exit(1); 
     374    } 
     375 
     376    // ask for information if necessary 
     377    BufferedReader cin = new BufferedReader(new InputStreamReader(System.in)); 
     378    if (serverName == null) { 
     379      LogTools.print("Server name? "); 
     380      try { serverName = cin.readLine(); } 
     381      catch (IOException exc) { } 
     382    } 
     383    if (port == null) { 
     384      LogTools.print("Port? "); 
     385      try { port = cin.readLine(); } 
     386      catch (IOException exc) { } 
     387    } 
     388    if (username == null) { 
     389      LogTools.print("Username? "); 
     390      try { username = cin.readLine(); } 
     391      catch (IOException exc) { } 
     392    } 
     393    if (password == null) { 
     394      LogTools.print("Password? "); 
     395      try { password = cin.readLine(); } 
     396      catch (IOException exc) { } 
     397    } 
     398    if (serverName == null || username == null || 
     399      password == null || port == null) 
     400    { 
     401      LogTools.println("Error: could not obtain server login information"); 
     402      System.exit(2); 
     403    } 
     404    LogTools.println("Using server " + serverName + " as user " + username); 
     405 
     406    // create image uploader 
     407 
     408    OMEROWriter uploader = new OMEROWriter(); 
     409    uploader.addStatusListener(new StatusListener() { 
    491410      public void statusUpdated(StatusEvent e) { 
    492        LogTools.println(e.getStatusMessage()); 
    493        } 
    494       }); 
    495        
    496       uploader.setId(serverName + "?user=" + username + "&password=" + password); 
    497        
    498       try{ 
    499          login(); 
    500       }catch(Exception e) 
    501       { 
    502           System.out.println("Incorrect login info"); 
     411        LogTools.println(e.getStatusMessage()); 
    503412      } 
    504       System.out.println(":)"); 
    505        
    506       FileStitcher reader = new FileStitcher(); 
    507       //reader.setMetadataStore(MetadataTools.createOMEXMLMetadata()); 
    508       //reader.setMetadataStore(new OMEXMLMetadata()); 
    509        
    510       reader.setId(id); 
    511       uploader.setMetadata((MetadataRetrieve) reader.getMetadataStore()); 
    512       for (int i=0; i<reader.getImageCount(); i++) { 
    513           uploader.saveImage(reader.openImage(i), i == reader.getImageCount() - 1); 
    514         } 
    515         reader.close(); 
    516         uploader.close(); 
    517        
    518  
    519        
    520  } 
     413    }); 
     414 
     415    uploader.setId(serverName + "?user=" + username + "&password=" + password); 
     416 
     417    try { 
     418      login(); 
     419    } 
     420    catch (FormatException e) { 
     421      System.out.println("Incorrect login info"); 
     422    } 
     423    System.out.println(":)"); 
     424 
     425    FileStitcher reader = new FileStitcher(); 
     426    reader.setMetadataStore(MetadataTools.createOMEXMLMetadata()); 
     427 
     428    reader.setId(id); 
     429    uploader.setMetadata((MetadataRetrieve) reader.getMetadataStore()); 
     430    for (int i=0; i<reader.getImageCount(); i++) { 
     431      uploader.saveImage(reader.openImage(i), i == reader.getImageCount() - 1); 
     432    } 
     433    reader.close(); 
     434    uploader.close(); 
     435  } 
     436 
    521437} 
Note: See TracChangeset for help on using the changeset viewer.