Changeset 4297


Ignore:
Timestamp:
08/07/08 14:27:08 (12 years ago)
Author:
curtis
Message:

Some cleanup. Still need to fix compile problems.

Location:
trunk/loci/ome/io
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/loci/ome/io/OMEROReader.java

    r4295 r4297  
    2626import java.io.IOException; 
    2727import java.util.*; 
    28  
     28import loci.formats.*; 
     29import loci.formats.meta.MetadataStore; 
    2930import ome.api.IAdmin; 
     31import ome.api.IPixels; 
     32import ome.api.IQuery; 
     33import ome.api.RawPixelsStore; 
    3034import ome.model.IObject; 
    3135import ome.model.core.Pixels; 
     
    3539import ome.system.Server; 
    3640import ome.system.ServiceFactory; 
    37 import loci.formats.*; 
    38 import loci.formats.meta.MetadataStore; 
    39  
    40 //new imports 
    41 import ome.api.IPixels; 
    42 import ome.api.IQuery; 
    43 import ome.api.RawPixelsStore; 
    4441import pojos.ImageData; 
    4542import pojos.PixelsData; 
     
    6764  private static boolean noOMERO = false; 
    6865 
    69  
    7066  // -- Fields -- 
    7167 
     
    7470  private String serverName; 
    7571  private String port; 
    76    
     72 
    7773  private static ServiceFactory sf; 
    7874  private static Login login; 
     
    8076  private static long id; 
    8177  private static Parameters params; 
    82    
     78 
    8379  private int x; 
    8480  private int y; 
     
    8682  private int c; 
    8783  private int t; 
    88   
     84 
    8985  /** OMERO query service */ 
    90   private static IQuery         query; 
     86  private static IQuery query; 
     87 
    9188  /** OMERO raw pixels service */ 
    9289  private static RawPixelsStore raw; 
    93  
    9490 
    9591  // -- Constructor -- 
     
    111107  } 
    112108 
    113   /** 
     109  /* 
    114110   * @see loci.formats.IFormatReader#openBytes(int, byte[], int, int, int, int) 
    115111   */ 
    116    
    117112  public byte[] openBytes(int no, byte[] buf, int x1, int y1, int w1, int h1) 
    118   throws FormatException, IOException 
    119 { 
    120   FormatTools.assertId(currentId, true, 1); 
    121   FormatTools.checkPlaneNumber(this, no); 
    122   FormatTools.checkBufferSize(this, buf.length); 
    123  
    124   int[] zct = FormatTools.getZCTCoords(this, no); 
    125    
     113    throws FormatException, IOException 
     114  { 
     115    FormatTools.assertId(currentId, true, 1); 
     116    FormatTools.checkPlaneNumber(this, no); 
     117    FormatTools.checkBufferSize(this, buf.length); 
     118 
     119    int[] zct = FormatTools.getZCTCoords(this, no); 
     120 
    126121    z = new Integer(zct[0]); 
    127122    c = new Integer(zct[1]); 
     
    132127    System.arraycopy((byte[]) plane, 0, buf, 0, len); 
    133128 
    134   return buf; 
    135 } 
    136    
    137    
     129    return buf; 
     130  } 
    138131 
    139132  // -- IFormatHandler API methods -- 
     
    155148 
    156149    cred.isOMERO = true; 
    157      
     150 
    158151    username = cred.username; 
    159152    password = cred.password; 
    160153    port = cred.port; 
    161154    Long idObj = new Long(cred.imageID); 
    162      
     155 
    163156    login = new Login("allison","omero"); 
    164157        server = new Server("http://localhost"); 
     
    170163 
    171164        params = new Parameters().addId(idObj); 
    172          
     165 
    173166    query = sf.getQueryService(); 
    174167    raw = sf.createRawPixelsStore(); 
     
    187180    params = new Parameters(); 
    188181    params.addId(idObj); 
    189      
    190182 
    191183    Pixels results = query.findByQuery(q, params); 
    192184    PixelsData pix = new PixelsData(results); 
    193    
    194185 
    195186    String ptype = pix.getPixelType(); 
     
    216207    double pz = pix.getPixelSizeZ(); 
    217208 
    218  
    219209    ImageData image = pix.getImage(); 
    220      
    221210 
    222211    String name = image.getName(); 
  • trunk/loci/ome/io/OMEROWriter.java

    r4294 r4297  
    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 database I/O package for communicating with OME and OMERO servers. 
     7Copyright (C) 2005-@year@ Melissa Linkert, Curtis Rueden and Philip Huettl. 
    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 
     
    3332import java.util.Date; 
    3433import java.util.List; 
    35  
    3634import loci.formats.FileStitcher; 
    3735import loci.formats.FormatException; 
     
    5351import ome.system.Server; 
    5452import ome.system.ServiceFactory; 
    55  
    5653import org.apache.commons.logging.Log; 
    5754import org.apache.commons.logging.LogFactory; 
    58  
    5955 
    6056/** 
     
    6561 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/loci/formats/ome/OMEWriter.java">SVN</a></dd></dl> 
    6662 */ 
    67 public class OMEROWriter extends FormatWriter{ 
    68          
    69           // -- Constants -- 
    70  
    71           private static final String NO_OMERO_MSG = "OMERO client libraries not " + 
    72             "found.  Please install omero-common.jar and omero-client.jar from " + 
    73             "http://www.loci.wisc.edu/ome/formats.html"; 
    74            
    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             /** OMERO raw pixels service */ 
    90             private static RawPixelsStore pservice; 
    91  
    92             /** OMERO query service */ 
    93             private static IQuery         iQuery; 
    94  
    95             /** OMERO update service */ 
    96             private static IUpdate        iUpdate; 
    97              
    98             private static Experimenter    exp; 
    99              
    100  
    101             private static Log  log    = (Log) LogFactory.getLog(OMEROWriter.class); 
    102  
    103             /** OMERO service factory; all other services are retrieved from here. */ 
    104             private static ServiceFactory sf; 
    105             private static OMEROMetadataStore store; 
    106              
    107             private OMEROWrapper reader; 
    108              
    109             /** Flag indicating the current session is valid. */ 
    110             private boolean validLogin = false; 
    111  
    112           /** Authentication credentials. */ 
    113           private OMECredentials credentials; 
    114  
    115           /** Image server. */ 
    116           private String omeis; 
    117  
    118  
    119           private MetadataRetrieve metadata; 
    120            
    121           // -- Constructor -- 
    122  
    123           /** Constructs a new OMERO writer. */ 
    124           public OMEROWriter() { super("OMERO", "*"); } 
    125  
    126           // -- Internal OMEWriter API methods -- 
    127  
    128         /** Fires a status update event. */ 
    129           protected void status(String message) { 
    130             status(new StatusEvent(message)); 
    131           } 
    132  
    133           /** Fires a status update event. */ 
    134           protected void status(int progress, int maximum, String message) { 
    135             status(new StatusEvent(progress, maximum, message)); 
    136           } 
    137  
    138           /** Fires a status update event. */ 
    139           protected void status(StatusEvent e) { 
    140             StatusListener[] l = getStatusListeners(); 
    141             for (int i=0; i<l.length; i++) l[i].statusUpdated(e); 
    142           } 
    143            
    144            
    145          
    146            
    147  
    148           public void saveImage(Image image, boolean last) 
    149               throws FormatException, IOException 
    150                   { 
    151                    
    152                     saveImage(image, 0, last, last); 
    153                   } 
    154                  
    155                   /* @see loci.formats.IFormatWriter#saveImage(Image, int, boolean, boolean) */ 
    156                   public void saveImage(Image image, int series, boolean lastInSeries, 
    157                     boolean last) 
    158                     throws FormatException, IOException 
    159                   { 
    160                          
    161                           
    162                          
    163                     byte[][] b = ImageTools.getPixelBytes(ImageTools.makeBuffered(image),true); 
    164                      
    165                      
    166                        
    167                                  
    168                                 //!metadata.getBigEndian(series).booleanValue()); 
    169                     for (int i=0; i<b.length; i++) { 
    170                       saveBytes(b[i], series, lastInSeries && (i == b.length - 1), 
    171                        last && (i == b.length - 1)); 
    172                     } 
    173                   } 
    174            
    175                 public void saveBytes(byte[] bytes, int series, boolean lastInSeries, 
    176                          boolean last) 
    177                          throws FormatException, IOException 
    178                                   { 
    179                         /* 
    180                                     if (!validLogin) { 
    181                                      // parse the ID string to get the server, user name and password 
    182                                  
    183                                       serverName = currentId.substring(0, currentId.lastIndexOf("?")); 
    184                                       int ndx = currentId.indexOf("&"); 
    185                                       if (currentId.indexOf("user") != -1) { 
    186                                         username = currentId.substring(currentId.lastIndexOf("?") + 6, ndx); 
    187                                                 password = currentId.substring(ndx + 10); 
    188                                               } 
    189                                       else { 
    190                                         throw new FormatException("Invalid ID - must be of the form " + 
    191                                                   "<server>?user=<username>&password=<password>"); 
    192                                       } 
    193                                     } 
    194                                     login(); 
    195  
    196                          
    197                                   //credentials.imageID = -1; 
    198                                   MetadataTools.convertMetadata(metadata, store); 
    199                                 ArrayList<Pixels> pixList = ((ArrayList<Pixels>) store.getRoot()); 
    200                                 Pixels p = pixList.get(0); 
    201          
    202                                 //todo fix this, null pointer error 
    203                                 //p.getImage().setName(imageName); 
    204                             //ArrayList<Pixels> pixId = ((ArrayList<Pixels>) store.saveToDB()); 
    205                             //store.addPixelsToDataset(arg0, arg1) 
    206                                  
    207                         long timestampIn; 
    208                         long timestampOut; 
    209                         long timestampDiff; 
    210                         long timeInSeconds; 
    211                         long hours, minutes, seconds; 
    212                         Date date = null; 
    213                          
    214                       // record initial timestamp and record total running time for the import 
    215                         timestampIn = System.currentTimeMillis(); 
    216                         date = new Date(timestampIn); 
    217                         SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm"); 
    218                         String myDate = formatter.format(date); 
    219  
    220                              int i = 1; 
    221                             // int bytesPerPixel = getBytesPerPixel(reader.getPixelType()); 
    222                            //  byte[] arrayBuf = new byte[store.* sizeY * bytesPerPixel]; 
    223                                  reader.setSeries(series); 
    224  
    225                          List<Image> imageList = (List<Image>) store.getRoot(); 
    226                                 ArrayList<ome.model.core.Pixels> pixelsList = (ArrayList<Pixels>) store.saveToDB(); 
    227                          
    228                         for (Image image : imageList) 
    229                         { 
    230                            // store.addImageToDataset(image, dataset); 
    231                         } 
    232                       
    233                                   close(); 
    234                 */ 
    235                                      
    236                 } 
    237                  
    238            
    239           //methods done so far: 
    240  
    241           public static void login() throws FormatException 
    242             { 
    243  
    244                  
    245                 if (username == null) throw new NullPointerException("username cannot be null"); 
    246                 if (password == null) throw new NullPointerException("password cannot be null"); 
    247                 if (port == null) throw new NullPointerException("port cannot be null"); 
    248                 if (serverName == null) throw new NullPointerException("server cannot be null"); 
    249                          
    250                  try { 
    251                                 tryLogin(); 
    252                         } catch (Exception e) { 
    253                                 // TODO Auto-generated catch block 
    254                                 //e.printStackTrace(); 
    255                         } 
    256                                // notifyObservers(connectionStatus);           
    257             } 
    258              
    259             /** 
    260              * @return 
    261              * @throws Exception  
    262              */ 
    263             private static boolean tryLogin() throws Exception 
    264             { 
    265 //               Attempt to log in 
    266                 if(!isValidLogin()) 
    267                 { 
    268                         return false; 
    269                 } 
    270                 try 
    271                 { 
    272                     Server server = new Server(serverName, Integer.parseInt(port)); 
    273                     Login login = new Login(username, password); 
    274                     // Instantiate our service factory 
    275                     sf = new ServiceFactory(server, login); 
    276                     store = new OMEROMetadataStore(sf); 
    277                      
    278                     
    279                 } catch (Throwable t) 
    280                 { 
    281                         System.out.println(t.toString()); 
    282                     return false; 
    283                 } 
    284                 System.out.println("login worked!"); 
    285                 return true; 
    286                  
    287             }     
    288              
    289             //create setId method?? 
    290                 //calls trylogin() ?? 
    291  
    292             public OMEROMetadataStore getMetadataStore() 
    293             { 
    294                 return store; 
    295             } 
    296   
    297  
    298            
    299           /* @see loci.formats.IFormatHandler#close() */ 
    300           public void close() throws IOException { 
    301                  // TODO 
    302           } 
    303            
    304           public void setMetadata(MetadataRetrieve meta) { 
    305                     metadata = meta;} 
    306            
    307           public boolean canDoStacks() { return true; }   
    308            
    309           // -- StatusReporter API methods -- 
    310  
    311           /* @see loci.formats.StatusReporter#addStatusListener(StatusListener) */ 
    312           public void addStatusListener(StatusListener l) { 
    313             synchronized (statusListeners) { 
    314               if (!statusListeners.contains(l)) statusListeners.add(l); 
    315             } 
    316           } 
    317  
    318           /* @see loci.formats.StatusReporter#removeStatusListener(StatusListener) */ 
    319           public void removeStatusListener(StatusListener l) { 
    320             synchronized (statusListeners) { 
    321               statusListeners.remove(l); 
    322             } 
    323           } 
    324  
    325           /* @see loci.formats.StatusReporter#getStatusListeners() */ 
    326           public StatusListener[] getStatusListeners() { 
    327             synchronized (statusListeners) { 
    328               StatusListener[] l = new StatusListener[statusListeners.size()]; 
    329               statusListeners.copyInto(l); 
    330               return l; 
    331             } 
    332           }        
    333            
    334             private static boolean isValidLogin() throws Exception 
    335             { 
    336                 System.out.println(username+ password+serverName+ port); 
    337                 try 
    338                 { 
    339                     store = new OMEROMetadataStore(username, password, serverName, port); 
    340                     store.getProjects(); 
    341                      
    342                 //} catch (EJBAccessException e) 
    343                 } catch (Exception e) 
    344                 { 
    345                     return false; 
    346                 } 
    347  
    348                 return true; 
    349             } 
    350            
    351            
     63public class OMEROWriter extends FormatWriter { 
     64 
     65    // -- Constants -- 
     66 
     67    private static final String NO_OMERO_MSG = "OMERO client libraries not " + 
     68      "found.  Please install omero-common.jar and omero-client.jar from " + 
     69      "http://www.loci.wisc.edu/ome/formats.html"; 
     70 
     71    // -- Static fields -- 
     72 
     73    private static boolean noOMERO = false; 
     74 
     75    // -- Fields -- 
     76 
     77    private static String username; 
     78    private static String password; 
     79    private static String serverName; 
     80    private static String port; 
     81 
     82    private static String imageName; 
     83 
     84      /** OMERO raw pixels service */ 
     85      private static RawPixelsStore pservice; 
     86 
     87      /** OMERO query service */ 
     88      private static IQuery         iQuery; 
     89 
     90      /** OMERO update service */ 
     91      private static IUpdate        iUpdate; 
     92 
     93      private static Experimenter    exp; 
     94 
     95      private static Log  log    = (Log) LogFactory.getLog(OMEROWriter.class); 
     96 
     97      /** OMERO service factory; all other services are retrieved from here. */ 
     98      private static ServiceFactory sf; 
     99      private static OMEROMetadataStore store; 
     100 
     101      private OMEROWrapper reader; 
     102 
     103      /** Flag indicating the current session is valid. */ 
     104      private boolean validLogin = false; 
     105 
     106    /** Authentication credentials. */ 
     107    private OMECredentials credentials; 
     108 
     109    /** Image server. */ 
     110    private String omeis; 
     111 
     112    private MetadataRetrieve metadata; 
     113 
     114    // -- Constructor -- 
     115 
     116    /** Constructs a new OMERO writer. */ 
     117    public OMEROWriter() { super("OMERO", "*"); } 
     118 
     119    // -- Internal OMEWriter API methods -- 
     120 
     121  /** Fires a status update event. */ 
     122    protected void status(String message) { 
     123      status(new StatusEvent(message)); 
     124    } 
     125 
     126    /** Fires a status update event. */ 
     127    protected void status(int progress, int maximum, String message) { 
     128      status(new StatusEvent(progress, maximum, message)); 
     129    } 
     130 
     131    /** Fires a status update event. */ 
     132    protected void status(StatusEvent e) { 
     133      StatusListener[] l = getStatusListeners(); 
     134      for (int i=0; i<l.length; i++) l[i].statusUpdated(e); 
     135    } 
     136 
     137    public void saveImage(Image image, boolean last) 
     138        throws FormatException, IOException 
     139        { 
     140 
     141          saveImage(image, 0, last, last); 
     142        } 
     143 
     144        /* @see loci.formats.IFormatWriter#saveImage(Image, int, boolean, boolean) */ 
     145        public void saveImage(Image image, int series, boolean lastInSeries, 
     146          boolean last) 
     147          throws FormatException, IOException 
     148        { 
     149 
     150          byte[][] b = ImageTools.getPixelBytes(ImageTools.makeBuffered(image),true); 
     151 
     152              //!metadata.getBigEndian(series).booleanValue()); 
     153          for (int i=0; i<b.length; i++) { 
     154            saveBytes(b[i], series, lastInSeries && (i == b.length - 1), 
     155             last && (i == b.length - 1)); 
     156          } 
     157        } 
     158 
     159      public void saveBytes(byte[] bytes, int series, boolean lastInSeries, 
     160         boolean last) 
     161         throws FormatException, IOException 
     162            { 
     163        /* 
     164              if (!validLogin) { 
     165               // parse the ID string to get the server, user name and password 
     166 
     167                serverName = currentId.substring(0, currentId.lastIndexOf("?")); 
     168                int ndx = currentId.indexOf("&"); 
     169                if (currentId.indexOf("user") != -1) { 
     170                  username = currentId.substring(currentId.lastIndexOf("?") + 6, ndx); 
     171                    password = currentId.substring(ndx + 10); 
     172                  } 
     173                else { 
     174                  throw new FormatException("Invalid ID - must be of the form " + 
     175                      "<server>?user=<username>&password=<password>"); 
     176                } 
     177              } 
     178              login(); 
     179 
     180            //credentials.imageID = -1; 
     181            MetadataTools.convertMetadata(metadata, store); 
     182          ArrayList<Pixels> pixList = ((ArrayList<Pixels>) store.getRoot()); 
     183          Pixels p = pixList.get(0); 
     184 
     185          //todo fix this, null pointer error 
     186          //p.getImage().setName(imageName); 
     187          //ArrayList<Pixels> pixId = ((ArrayList<Pixels>) store.saveToDB()); 
     188          //store.addPixelsToDataset(arg0, arg1) 
     189 
     190              long timestampIn; 
     191              long timestampOut; 
     192              long timestampDiff; 
     193              long timeInSeconds; 
     194              long hours, minutes, seconds; 
     195              Date date = null; 
     196 
     197            // record initial timestamp and record total running time for the import 
     198              timestampIn = System.currentTimeMillis(); 
     199              date = new Date(timestampIn); 
     200              SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm"); 
     201              String myDate = formatter.format(date); 
     202 
     203             int i = 1; 
     204            // int bytesPerPixel = getBytesPerPixel(reader.getPixelType()); 
     205           //  byte[] arrayBuf = new byte[store.* sizeY * bytesPerPixel]; 
     206            reader.setSeries(series); 
     207 
     208         List<Image> imageList = (List<Image>) store.getRoot(); 
     209           ArrayList<ome.model.core.Pixels> pixelsList = (ArrayList<Pixels>) store.saveToDB(); 
     210 
     211              for (Image image : imageList) 
     212              { 
     213                 // store.addImageToDataset(image, dataset); 
     214              } 
     215 
     216            close(); 
     217      */ 
     218 
     219      } 
     220 
     221    //methods done so far: 
     222 
     223    public static void login() throws FormatException 
     224      { 
     225 
     226          if (username == null) throw new NullPointerException("username cannot be null"); 
     227          if (password == null) throw new NullPointerException("password cannot be null"); 
     228          if (port == null) throw new NullPointerException("port cannot be null"); 
     229          if (serverName == null) throw new NullPointerException("server cannot be null"); 
     230 
     231           try { 
     232        tryLogin(); 
     233      } catch (Exception e) { 
     234        // TODO Auto-generated catch block 
     235        //e.printStackTrace(); 
     236      } 
     237                         // notifyObservers(connectionStatus); 
     238      } 
     239 
     240      /** 
     241       * @return 
     242       * @throws Exception 
     243       */ 
     244      private static boolean tryLogin() throws Exception 
     245      { 
     246//         Attempt to log in 
     247        if(!isValidLogin()) 
     248        { 
     249          return false; 
     250        } 
     251          try 
     252          { 
     253              Server server = new Server(serverName, Integer.parseInt(port)); 
     254              Login login = new Login(username, password); 
     255              // Instantiate our service factory 
     256              sf = new ServiceFactory(server, login); 
     257              store = new OMEROMetadataStore(sf); 
     258 
     259          } catch (Throwable t) 
     260          { 
     261            System.out.println(t.toString()); 
     262              return false; 
     263          } 
     264          System.out.println("login worked!"); 
     265          return true; 
     266 
     267      } 
     268 
     269      //create setId method?? 
     270        //calls trylogin() ?? 
     271 
     272      public OMEROMetadataStore getMetadataStore() 
     273      { 
     274          return store; 
     275      } 
     276 
     277    /* @see loci.formats.IFormatHandler#close() */ 
     278    public void close() throws IOException { 
     279     // TODO 
     280    } 
     281 
     282    public void setMetadata(MetadataRetrieve meta) { 
     283        metadata = meta;} 
     284 
     285    public boolean canDoStacks() { return true; } 
     286 
     287    // -- StatusReporter API methods -- 
     288 
     289    /* @see loci.formats.StatusReporter#addStatusListener(StatusListener) */ 
     290    public void addStatusListener(StatusListener l) { 
     291      synchronized (statusListeners) { 
     292        if (!statusListeners.contains(l)) statusListeners.add(l); 
     293      } 
     294    } 
     295 
     296    /* @see loci.formats.StatusReporter#removeStatusListener(StatusListener) */ 
     297    public void removeStatusListener(StatusListener l) { 
     298      synchronized (statusListeners) { 
     299        statusListeners.remove(l); 
     300      } 
     301    } 
     302 
     303    /* @see loci.formats.StatusReporter#getStatusListeners() */ 
     304    public StatusListener[] getStatusListeners() { 
     305      synchronized (statusListeners) { 
     306        StatusListener[] l = new StatusListener[statusListeners.size()]; 
     307        statusListeners.copyInto(l); 
     308        return l; 
     309      } 
     310    } 
     311 
     312      private static boolean isValidLogin() throws Exception 
     313      { 
     314        System.out.println(username+ password+serverName+ port); 
     315          try 
     316          { 
     317              store = new OMEROMetadataStore(username, password, serverName, port); 
     318              store.getProjects(); 
     319 
     320          //} catch (EJBAccessException e) 
     321          } catch (Exception e) 
     322          { 
     323              return false; 
     324          } 
     325 
     326          return true; 
     327      } 
     328 
    352329   public static void main(String[] args) throws Exception { 
    353            // org.apache.log4j.BasicConfigurator.configure(); 
     330     // org.apache.log4j.BasicConfigurator.configure(); 
    354331        username="allison"; 
    355332        password="omero"; 
    356         serverName="localhost";       
     333        serverName="localhost"; 
    357334        port="1099"; 
    358          
     335 
    359336        String id=null; 
    360                    
    361                     // parse command-line arguments 
    362                     boolean doUsage = false; 
    363                     if (args.length == 0) doUsage = true; 
    364                     for (int i=0; i<args.length; i++) { 
    365                       if (args[i].startsWith("-")) { 
    366                         // argument is a command line flag 
    367                         String param = args[i]; 
    368                         try { 
    369                           if (param.equalsIgnoreCase("-s")) serverName = args[++i]; 
    370                           else if (param.equalsIgnoreCase("-a")) port = args[++i]; 
    371                           else if (param.equalsIgnoreCase("-u")) username = args[++i]; 
    372                           else if (param.equalsIgnoreCase("-p")) password = args[++i]; 
    373                           else if (param.equalsIgnoreCase("-h") || param.equalsIgnoreCase("-?")) 
    374                           { 
    375                             doUsage = true; 
    376                           } 
    377                           else { 
    378                             LogTools.println("Error: unknown flag: "+ param); 
    379                             LogTools.println(); 
    380                             doUsage = true; 
    381                             break; 
    382                           } 
    383                         } 
    384                         catch (ArrayIndexOutOfBoundsException exc) { 
    385                           if (i == args.length - 1) { 
    386                             LogTools.println("Error: flag " + param + 
    387                               " must be followed by a parameter value."); 
    388                             LogTools.println(); 
    389                             doUsage = true; 
    390                             break; 
    391                           } 
    392                           else throw exc; 
    393                         } 
    394                       } 
    395                       else { 
    396                         if (id == null) id = args[i]; 
    397                         else { 
    398                           LogTools.println("Error: unknown argument: " + args[i]); 
    399                           LogTools.println(); 
    400                         } 
    401                       } 
    402                     } 
    403  
    404                     if (id == null) doUsage = true; 
    405                     if (doUsage) { 
    406                       LogTools.println("Usage: omero [-s server.address] " + 
    407                         "[-a port] [-u username] [-p password] filename"); 
    408                       LogTools.println(); 
    409                       System.exit(1); 
    410                     }              
    411                    
    412                    
    413 //               ask for information if necessary 
    414                     BufferedReader cin = new BufferedReader(new InputStreamReader(System.in)); 
    415                     if (serverName == null) { 
    416                       LogTools.print("Server name? "); 
    417                       try { serverName = cin.readLine(); } 
    418                       catch (IOException exc) { } 
    419                     } 
    420                     if (port == null) { 
    421                               LogTools.print("Port? "); 
    422                               try { port = cin.readLine(); } 
    423                               catch (IOException exc) { } 
    424                             } 
    425                     if (username == null) { 
    426                       LogTools.print("Username? "); 
    427                       try { username = cin.readLine(); } 
    428                       catch (IOException exc) { } 
    429                     } 
    430                     if (password == null) { 
    431                       LogTools.print("Password? "); 
    432                       try { password = cin.readLine(); } 
    433                       catch (IOException exc) { } 
    434                     } 
    435                     if (serverName == null || username == null || password == null || port == null ) { 
    436                       LogTools.println("Error: could not obtain server login information"); 
    437                       System.exit(2); 
    438                     } 
    439                     LogTools.println("Using server " + serverName + " as user " + username); 
    440                    
    441                  
    442                    
    443            
     337 
     338        // parse command-line arguments 
     339        boolean doUsage = false; 
     340        if (args.length == 0) doUsage = true; 
     341        for (int i=0; i<args.length; i++) { 
     342          if (args[i].startsWith("-")) { 
     343            // argument is a command line flag 
     344            String param = args[i]; 
     345            try { 
     346              if (param.equalsIgnoreCase("-s")) serverName = args[++i]; 
     347              else if (param.equalsIgnoreCase("-a")) port = args[++i]; 
     348              else if (param.equalsIgnoreCase("-u")) username = args[++i]; 
     349              else if (param.equalsIgnoreCase("-p")) password = args[++i]; 
     350              else if (param.equalsIgnoreCase("-h") || param.equalsIgnoreCase("-?")) 
     351              { 
     352                doUsage = true; 
     353              } 
     354              else { 
     355                LogTools.println("Error: unknown flag: "+ param); 
     356                LogTools.println(); 
     357                doUsage = true; 
     358                break; 
     359              } 
     360            } 
     361            catch (ArrayIndexOutOfBoundsException exc) { 
     362              if (i == args.length - 1) { 
     363                LogTools.println("Error: flag " + param + 
     364                  " must be followed by a parameter value."); 
     365                LogTools.println(); 
     366                doUsage = true; 
     367                break; 
     368              } 
     369              else throw exc; 
     370            } 
     371          } 
     372          else { 
     373            if (id == null) id = args[i]; 
     374            else { 
     375              LogTools.println("Error: unknown argument: " + args[i]); 
     376              LogTools.println(); 
     377            } 
     378          } 
     379        } 
     380 
     381        if (id == null) doUsage = true; 
     382        if (doUsage) { 
     383          LogTools.println("Usage: omero [-s server.address] " + 
     384            "[-a port] [-u username] [-p password] filename"); 
     385          LogTools.println(); 
     386          System.exit(1); 
     387        } 
     388 
     389//     ask for information if necessary 
     390        BufferedReader cin = new BufferedReader(new InputStreamReader(System.in)); 
     391        if (serverName == null) { 
     392          LogTools.print("Server name? "); 
     393          try { serverName = cin.readLine(); } 
     394          catch (IOException exc) { } 
     395        } 
     396        if (port == null) { 
     397            LogTools.print("Port? "); 
     398            try { port = cin.readLine(); } 
     399            catch (IOException exc) { } 
     400          } 
     401        if (username == null) { 
     402          LogTools.print("Username? "); 
     403          try { username = cin.readLine(); } 
     404          catch (IOException exc) { } 
     405        } 
     406        if (password == null) { 
     407          LogTools.print("Password? "); 
     408          try { password = cin.readLine(); } 
     409          catch (IOException exc) { } 
     410        } 
     411        if (serverName == null || username == null || password == null || port == null ) { 
     412          LogTools.println("Error: could not obtain server login information"); 
     413          System.exit(2); 
     414        } 
     415        LogTools.println("Using server " + serverName + " as user " + username); 
     416 
    444417      //create image uploader 
    445                   
     418 
    446419      OMEROWriter uploader = new OMEROWriter(); 
    447420      uploader.addStatusListener(new StatusListener() { 
     
    450423       } 
    451424      }); 
    452        
     425 
    453426      uploader.setId(serverName + "?user=" + username + "&password=" + password); 
    454427 
     
    456429      //reader.setMetadataStore(MetadataTools.createOMEXMLMetadata()); 
    457430      //reader.setMetadataStore(new OMEXMLMetadata()); 
    458        
     431 
    459432      reader.setId(id); 
    460433      //reader.setMetadataStore(store); 
    461434      uploader.setMetadata((MetadataRetrieve) reader.getMetadataStore()); 
    462435      for (int i=0; i<reader.getImageCount(); i++) { 
    463            
     436 
    464437          uploader.saveImage(reader.openImage(i), i == reader.getImageCount()-1 ); 
    465            
    466            
     438 
    467439        } 
    468440        reader.close(); 
    469441        uploader.close(); 
    470        
     442 
    471443 } 
    472444} 
Note: See TracChangeset for help on using the changeset viewer.