Changeset 1831


Ignore:
Timestamp:
11/20/06 16:05:19 (13 years ago)
Author:
curtis
Message:

Initial version of Bio-Formats OME importer with support for file grouping.

Location:
trunk/loci/formats
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/loci/formats/FileStitcher.java

    r1812 r1831  
    177177  } 
    178178 
    179   // -- IFormatReader API methods -- 
    180  
    181   /* @see IFormatReader#isThisType(byte[]) */ 
    182   public boolean isThisType(byte[] block) { 
    183     return reader.isThisType(block); 
    184   } 
    185  
    186   /** Determines the number of images in the given file series. */ 
    187   public int getImageCount(String id) throws FormatException, IOException { 
    188     if (!id.equals(currentId)) initFile(id); 
    189     return totalImages; 
    190   } 
    191  
    192   /** Checks if the images in the file are RGB. */ 
    193   public boolean isRGB(String id) throws FormatException, IOException { 
    194     if (!id.equals(currentId)) initFile(id); 
    195     return reader.isRGB(files[0]); 
    196   } 
    197  
    198   /* @see IFormatReader#getSizeX(String) */ 
    199   public int getSizeX(String id) throws FormatException, IOException { 
    200     if (!id.equals(currentId)) initFile(id); 
    201     return width; 
    202   } 
    203  
    204   /* @see IFormatReader#getSizeY(String) */ 
    205   public int getSizeY(String id) throws FormatException, IOException { 
    206     if (!id.equals(currentId)) initFile(id); 
    207     return height; 
    208   } 
    209  
    210   /* @see IFormatReader#getSizeZ(String) */ 
    211   public int getSizeZ(String id) throws FormatException, IOException { 
    212     if (!id.equals(currentId)) initFile(id); 
    213     return totalSizeZ; 
    214   } 
    215  
    216   /* @see IFormatReader#getSizeC(String) */ 
    217   public int getSizeC(String id) throws FormatException, IOException { 
    218     if (!id.equals(currentId)) initFile(id); 
    219     return totalSizeC; 
    220   } 
    221  
    222   /* @see IFormatReader#getSizeT(String) */ 
    223   public int getSizeT(String id) throws FormatException, IOException { 
    224     if (!id.equals(currentId)) initFile(id); 
    225     return totalSizeT; 
    226   } 
    227  
    228   /* @see IFormatReader#getPixelType(String) */ 
    229   public int getPixelType(String id) throws FormatException, IOException { 
    230     if (!id.equals(currentId)) initFile(id); 
    231     return reader.getPixelType(files[0]); 
    232   } 
    233  
    234   /* @see IFormatReader#getChannelGlobalMinimum(String, int) */ 
    235   public Double getChannelGlobalMinimum(String id, int theC) 
    236     throws FormatException, IOException 
    237   { 
    238     int[] include = getIncludeList(id, theC); 
    239     Double min = new Double(Double.POSITIVE_INFINITY); 
    240     for (int i=0; i<readers.length; i++) { 
    241       if (include[i] >= 0) { 
    242         Double d = readers[i].getChannelGlobalMinimum(files[i], include[i]); 
    243         if (d.compareTo(min) < 0) min = d; 
    244       } 
    245     } 
    246     return min; 
    247   } 
    248  
    249   /* @see IFormatReader#getChannelGlobalMaximum(String, int) */ 
    250   public Double getChannelGlobalMaximum(String id, int theC) 
    251     throws FormatException, IOException 
    252   { 
    253     int[] include = getIncludeList(id, theC); 
    254     Double max = new Double(Double.NEGATIVE_INFINITY); 
    255     for (int i=0; i<readers.length; i++) { 
    256       if (include[i] >= 0) { 
    257         Double d = readers[i].getChannelGlobalMaximum(files[i], include[i]); 
    258         if (d.compareTo(max) > 0) max = d; 
    259       } 
    260     } 
    261     return max; 
    262   } 
    263  
    264   /* @see IFormatReader#getThumbSizeX(String) */ 
    265   public int getThumbSizeX(String id) throws FormatException, IOException { 
    266     if (!id.equals(currentId)) initFile(id); 
    267     return reader.getThumbSizeX(files[0]); 
    268   } 
    269  
    270   /* @see IFormatReader#getThumbSizeY(String) */ 
    271   public int getThumbSizeY(String id) throws FormatException, IOException { 
    272     if (!id.equals(currentId)) initFile(id); 
    273     return reader.getThumbSizeY(files[0]); 
    274   } 
    275  
    276   /* @see IFormatReader#isLittleEndian(String) */ 
    277   public boolean isLittleEndian(String id) throws FormatException, IOException { 
    278     if (!id.equals(currentId)) initFile(id); 
    279     return reader.isLittleEndian(files[0]); 
    280   } 
    281  
    282   /** 
    283    * Gets a five-character string representing the 
    284    * dimension order across the file series. 
    285    */ 
    286   public String getDimensionOrder(String id) 
    287     throws FormatException, IOException 
    288   { 
    289     if (!id.equals(currentId)) initFile(id); 
    290     return order; 
    291   } 
    292  
    293   /* @see IFormatReader#isOrderCertain(String) */ 
    294   public boolean isOrderCertain(String id) throws FormatException, IOException { 
    295     if (!id.equals(currentId)) initFile(id); 
    296     return ag.isCertain(); 
    297   } 
    298  
    299   /* @see IFormatReader#setChannelStatCalculationStatus(boolean) */ 
    300   public void setChannelStatCalculationStatus(boolean on) { 
    301     enableChannelStatCalculation = on; 
    302   } 
    303  
    304   /* @see IFormatReader#getChannelStatCalculationStatus */ 
    305   public boolean getChannelStatCalculationStatus() { 
    306     return enableChannelStatCalculation; 
    307   } 
    308  
    309   /* @see IFormatReader#isInterleaved(String) */ 
    310   public boolean isInterleaved(String id) throws FormatException, IOException { 
    311     if (!id.equals(currentId)) initFile(id); 
    312     return reader.isInterleaved(files[0]); 
    313   } 
    314  
    315   /** Obtains the specified image from the given file series. */ 
    316   public BufferedImage openImage(String id, int no) 
    317     throws FormatException, IOException 
    318   { 
    319     int[] q = computeIndices(id, no); 
    320     int fno = q[0], ino = q[1]; 
    321     if (ino < readers[fno].getImageCount(files[fno])) { 
    322       return readers[fno].openImage(files[fno], ino); 
    323     } 
    324     // return a blank image to cover for the fact that 
    325     // this file does not contain enough image planes 
    326     if (blankImage == null) { 
    327       blankImage = ImageTools.blankImage(width, height, 
    328         sizeC, getPixelType(currentId)); 
    329     } 
    330     return blankImage; 
    331   } 
    332  
    333   /** Obtains the specified image from the given file series as a byte array. */ 
    334   public byte[] openBytes(String id, int no) 
    335     throws FormatException, IOException 
    336   { 
    337     int[] q = computeIndices(id, no); 
    338     int fno = q[0], ino = q[1]; 
    339     if (ino < readers[fno].getImageCount(files[fno])) { 
    340       return readers[fno].openBytes(files[fno], ino); 
    341     } 
    342     // return a blank image to cover for the fact that 
    343     // this file does not contain enough image planes 
    344     if (blankBytes == null) { 
    345       int bytes = FormatReader.getBytesPerPixel(getPixelType(currentId)); 
    346       blankBytes = new byte[width * height * bytes * sizeC]; 
    347     } 
    348     return blankBytes; 
    349   } 
    350  
    351   /* @see IFormatReader#openBytes(String, int, byte[]) */ 
    352   public byte[] openBytes(String id, int no, byte[] buf) 
    353     throws FormatException, IOException 
    354   { 
    355     int[] q = computeIndices(id, no); 
    356     int fno = q[0], ino = q[1]; 
    357     return readers[fno].openBytes(files[fno], ino, buf); 
    358   } 
    359  
    360   /* @see IFormatReader#openThumbImage(String, int) */ 
    361   public BufferedImage openThumbImage(String id, int no) 
    362     throws FormatException, IOException 
    363   { 
    364     int[] q = computeIndices(id, no); 
    365     int fno = q[0], ino = q[1]; 
    366     return readers[fno].openThumbImage(files[fno], ino); 
    367   } 
    368  
    369   /* @see IFormatReader#openThumbImage(String, int) */ 
    370   public byte[] openThumbBytes(String id, int no) 
    371     throws FormatException, IOException 
    372   { 
    373     int[] q = computeIndices(id, no); 
    374     int fno = q[0], ino = q[1]; 
    375     return readers[fno].openThumbBytes(files[fno], ino); 
    376   } 
    377  
    378   /* @see IFormatReader#close() */ 
    379   public void close() throws FormatException, IOException { 
    380     if (readers != null) { 
    381       for (int i=0; i<readers.length; i++) readers[i].close(); 
    382     } 
    383     readers = null; 
    384     blankImage = null; 
    385     blankBytes = null; 
    386     currentId = null; 
    387   } 
    388  
    389   /* @see IFormatReader#getSeriesCount(String) */ 
    390   public int getSeriesCount(String id) throws FormatException, IOException { 
    391     if (!id.equals(currentId)) initFile(id); 
    392     return reader.getSeriesCount(files[0]); 
    393   } 
    394  
    395   /* @see IFormatReader#setSeries(String, int) */ 
    396   public void setSeries(String id, int no) throws FormatException, IOException { 
    397     if (!id.equals(currentId)) initFile(id); 
    398     reader.setSeries(files[0], no); 
    399   } 
    400  
    401   /* @see IFormatReader#getSeries(String) */ 
    402   public int getSeries(String id) throws FormatException, IOException { 
    403     if (!id.equals(currentId)) initFile(id); 
    404     return reader.getSeries(files[0]); 
    405   } 
    406  
    407   /* @see IFormatReader#setColorTableIgnored(boolean) */ 
    408   public void setColorTableIgnored(boolean ignore) { 
    409     ignoreColorTable = ignore; 
    410   } 
    411  
    412   /* @see IFormatReader#isColorTableIgnored() */ 
    413   public boolean isColorTableIgnored() { return ignoreColorTable; } 
    414  
    415   /* @see IFormatReader#setNormalized(boolean) */ 
    416   public void setNormalized(boolean normalize) { 
    417     normalizeData = normalize; 
    418   } 
    419  
    420   /* @see IFormatReader#isNormalized() */ 
    421   public boolean isNormalized() { return normalizeData; } 
    422  
    423   /* @see IFormatReader#swapDimensions(String, String) */ 
    424   public void swapDimensions(String id, String order) 
    425     throws FormatException, IOException 
    426   { 
    427     if (!id.equals(currentId)) initFile(id); 
    428     this.order = order; 
    429     String f0 = files[0]; 
    430     reader.swapDimensions(f0, order); 
    431     sizeZ = reader.getSizeZ(f0); 
    432     sizeC = reader.getSizeC(f0); 
    433     sizeT = reader.getSizeT(f0); 
    434     computeAxisLengths(); 
    435   } 
    436  
    437   /* @see IFormatReader#getIndex(String, int, int, int) */ 
    438   public int getIndex(String id, int z, int c, int t) 
    439     throws FormatException, IOException 
    440   { 
    441     return FormatReader.getIndex(this, id, z, c, t); 
    442   } 
    443  
    444   /* @see IFormatReader#getZCTCoords(String, int) */ 
    445   public int[] getZCTCoords(String id, int index) 
    446     throws FormatException, IOException 
    447   { 
    448     return FormatReader.getZCTCoords(this, id, index); 
    449   } 
    450  
    451  
    452   /* @see IFormatReader#getMetadataValue(String, String) */ 
    453   public Object getMetadataValue(String id, String field) 
    454     throws FormatException, IOException 
    455   { 
    456     if (!id.equals(currentId)) initFile(id); 
    457     return reader.getMetadataValue(files[0], field); 
    458   } 
    459  
    460   /* @see IFormatReader#getMetadata(String) */ 
    461   public Hashtable getMetadata(String id) throws FormatException, IOException { 
    462     if (!id.equals(currentId)) initFile(id); 
    463     return reader.getMetadata(files[0]); 
    464   } 
    465  
    466   /* @see IFormatReader#setMetadataStore(MetadataStore) */ 
    467   public void setMetadataStore(MetadataStore store) { 
    468     reader.setMetadataStore(store); 
    469   } 
    470  
    471   /* @see IFormatReader#getMetadataStore(String) */ 
    472   public MetadataStore getMetadataStore(String id) 
    473     throws FormatException, IOException 
    474   { 
    475     if (!id.equals(currentId)) initFile(id); 
    476     return reader.getMetadataStore(files[0]); 
    477   } 
    478  
    479   /* @see IFormatReader#getMetadataStoreRoot(String) */ 
    480   public Object getMetadataStoreRoot(String id) 
    481     throws FormatException, IOException 
    482   { 
    483     if (!id.equals(currentId)) initFile(id); 
    484     return reader.getMetadataStoreRoot(files[0]); 
    485   } 
    486  
    487   /* @see IFormatReader#testRead(String[]) */ 
    488   public boolean testRead(String[] args) throws FormatException, IOException { 
    489     return FormatReader.testRead(this, args); 
    490   } 
    491  
    492   // -- IFormatHandler API methods -- 
    493  
    494   /* @see IFormatHandler#isThisType(String) */ 
    495   public boolean isThisType(String name) { 
    496     return reader.isThisType(name); 
    497   } 
    498  
    499   /* @see IFormatHandler#isThisType(String, boolean) */ 
    500   public boolean isThisType(String name, boolean open) { 
    501     return reader.isThisType(name, open); 
    502   } 
    503  
    504   /* @see IFormatHandler#getFormat() */ 
    505   public String getFormat() { 
    506     return reader.getFormat(); 
    507   } 
    508  
    509   /* @see IFormatHandler#getSuffixes() */ 
    510   public String[] getSuffixes() { 
    511     return reader.getSuffixes(); 
    512   } 
    513  
    514   /* @see IFormatHandler#getFileFilters() */ 
    515   public FileFilter[] getFileFilters() { 
    516     return reader.getFileFilters(); 
    517   } 
    518  
    519   /* @see IFormatHandler#getFileChooser() */ 
    520   public JFileChooser getFileChooser() { 
    521     return reader.getFileChooser(); 
    522   } 
    523  
    524   /* @see IFormatHandler#mapId(String, String) */ 
    525   public void mapId(String id, String filename) { 
    526     // NB: all readers share the same ID map 
    527     reader.mapId(id, filename); 
    528   } 
    529  
    530   /* @see IFormatHandler#getMappedId(String) */ 
    531   public String getMappedId(String id) { 
    532     return reader.getMappedId(id); 
    533   } 
    534  
    535   /* @see IFormatHandler#getIdMap() */ 
    536   public Hashtable getIdMap() { 
    537     return reader.getIdMap(); 
    538   } 
    539  
    540   /* @see IFormatHandler#setIdMap(Hashtable) */ 
    541   public void setIdMap(Hashtable map) { 
    542     for (int i=0; i<readers.length; i++) readers[i].setIdMap(map); 
    543   } 
    544  
    545  
    546   // -- Helper methods -- 
    547  
    548   /** Initializes the given file. */ 
    549   protected void initFile(String id) throws FormatException, IOException { 
    550     currentId = id; 
     179  /** 
     180   * Finds the file pattern for the given ID, based on the state of the file 
     181   * stitcher. Takes both ID map entries and the patternIds flag into account. 
     182   */ 
     183  public FilePattern findPattern(String id) { 
    551184    if (!patternIds) { 
    552185      // find the containing pattern 
     
    566199      } 
    567200    } 
    568     fp = new FilePattern(id); 
     201    return new FilePattern(id); 
     202  } 
     203 
     204  // -- IFormatReader API methods -- 
     205 
     206  /* @see IFormatReader#isThisType(byte[]) */ 
     207  public boolean isThisType(byte[] block) { 
     208    return reader.isThisType(block); 
     209  } 
     210 
     211  /* @see IFormatReader#getImageCount(String) */ 
     212  public int getImageCount(String id) throws FormatException, IOException { 
     213    if (!id.equals(currentId)) initFile(id); 
     214    return totalImages; 
     215  } 
     216 
     217  /* @see IFormatReader#isRGB(String) */ 
     218  public boolean isRGB(String id) throws FormatException, IOException { 
     219    if (!id.equals(currentId)) initFile(id); 
     220    return reader.isRGB(files[0]); 
     221  } 
     222 
     223  /* @see IFormatReader#getSizeX(String) */ 
     224  public int getSizeX(String id) throws FormatException, IOException { 
     225    if (!id.equals(currentId)) initFile(id); 
     226    return width; 
     227  } 
     228 
     229  /* @see IFormatReader#getSizeY(String) */ 
     230  public int getSizeY(String id) throws FormatException, IOException { 
     231    if (!id.equals(currentId)) initFile(id); 
     232    return height; 
     233  } 
     234 
     235  /* @see IFormatReader#getSizeZ(String) */ 
     236  public int getSizeZ(String id) throws FormatException, IOException { 
     237    if (!id.equals(currentId)) initFile(id); 
     238    return totalSizeZ; 
     239  } 
     240 
     241  /* @see IFormatReader#getSizeC(String) */ 
     242  public int getSizeC(String id) throws FormatException, IOException { 
     243    if (!id.equals(currentId)) initFile(id); 
     244    return totalSizeC; 
     245  } 
     246 
     247  /* @see IFormatReader#getSizeT(String) */ 
     248  public int getSizeT(String id) throws FormatException, IOException { 
     249    if (!id.equals(currentId)) initFile(id); 
     250    return totalSizeT; 
     251  } 
     252 
     253  /* @see IFormatReader#getPixelType(String) */ 
     254  public int getPixelType(String id) throws FormatException, IOException { 
     255    if (!id.equals(currentId)) initFile(id); 
     256    return reader.getPixelType(files[0]); 
     257  } 
     258 
     259  /* @see IFormatReader#getChannelGlobalMinimum(String, int) */ 
     260  public Double getChannelGlobalMinimum(String id, int theC) 
     261    throws FormatException, IOException 
     262  { 
     263    int[] include = getIncludeList(id, theC); 
     264    Double min = new Double(Double.POSITIVE_INFINITY); 
     265    for (int i=0; i<readers.length; i++) { 
     266      if (include[i] >= 0) { 
     267        Double d = readers[i].getChannelGlobalMinimum(files[i], include[i]); 
     268        if (d.compareTo(min) < 0) min = d; 
     269      } 
     270    } 
     271    return min; 
     272  } 
     273 
     274  /* @see IFormatReader#getChannelGlobalMaximum(String, int) */ 
     275  public Double getChannelGlobalMaximum(String id, int theC) 
     276    throws FormatException, IOException 
     277  { 
     278    int[] include = getIncludeList(id, theC); 
     279    Double max = new Double(Double.NEGATIVE_INFINITY); 
     280    for (int i=0; i<readers.length; i++) { 
     281      if (include[i] >= 0) { 
     282        Double d = readers[i].getChannelGlobalMaximum(files[i], include[i]); 
     283        if (d.compareTo(max) > 0) max = d; 
     284      } 
     285    } 
     286    return max; 
     287  } 
     288 
     289  /* @see IFormatReader#getThumbSizeX(String) */ 
     290  public int getThumbSizeX(String id) throws FormatException, IOException { 
     291    if (!id.equals(currentId)) initFile(id); 
     292    return reader.getThumbSizeX(files[0]); 
     293  } 
     294 
     295  /* @see IFormatReader#getThumbSizeY(String) */ 
     296  public int getThumbSizeY(String id) throws FormatException, IOException { 
     297    if (!id.equals(currentId)) initFile(id); 
     298    return reader.getThumbSizeY(files[0]); 
     299  } 
     300 
     301  /* @see IFormatReader#isLittleEndian(String) */ 
     302  public boolean isLittleEndian(String id) throws FormatException, IOException { 
     303    if (!id.equals(currentId)) initFile(id); 
     304    return reader.isLittleEndian(files[0]); 
     305  } 
     306 
     307  /** 
     308   * Gets a five-character string representing the 
     309   * dimension order across the file series. 
     310   */ 
     311  public String getDimensionOrder(String id) 
     312    throws FormatException, IOException 
     313  { 
     314    if (!id.equals(currentId)) initFile(id); 
     315    return order; 
     316  } 
     317 
     318  /* @see IFormatReader#isOrderCertain(String) */ 
     319  public boolean isOrderCertain(String id) throws FormatException, IOException { 
     320    if (!id.equals(currentId)) initFile(id); 
     321    return ag.isCertain(); 
     322  } 
     323 
     324  /* @see IFormatReader#setChannelStatCalculationStatus(boolean) */ 
     325  public void setChannelStatCalculationStatus(boolean on) { 
     326    enableChannelStatCalculation = on; 
     327  } 
     328 
     329  /* @see IFormatReader#getChannelStatCalculationStatus */ 
     330  public boolean getChannelStatCalculationStatus() { 
     331    return enableChannelStatCalculation; 
     332  } 
     333 
     334  /* @see IFormatReader#isInterleaved(String) */ 
     335  public boolean isInterleaved(String id) throws FormatException, IOException { 
     336    if (!id.equals(currentId)) initFile(id); 
     337    return reader.isInterleaved(files[0]); 
     338  } 
     339 
     340  /** Obtains the specified image from the given file series. */ 
     341  public BufferedImage openImage(String id, int no) 
     342    throws FormatException, IOException 
     343  { 
     344    int[] q = computeIndices(id, no); 
     345    int fno = q[0], ino = q[1]; 
     346    if (ino < readers[fno].getImageCount(files[fno])) { 
     347      return readers[fno].openImage(files[fno], ino); 
     348    } 
     349    // return a blank image to cover for the fact that 
     350    // this file does not contain enough image planes 
     351    if (blankImage == null) { 
     352      blankImage = ImageTools.blankImage(width, height, 
     353        sizeC, getPixelType(currentId)); 
     354    } 
     355    return blankImage; 
     356  } 
     357 
     358  /** Obtains the specified image from the given file series as a byte array. */ 
     359  public byte[] openBytes(String id, int no) 
     360    throws FormatException, IOException 
     361  { 
     362    int[] q = computeIndices(id, no); 
     363    int fno = q[0], ino = q[1]; 
     364    if (ino < readers[fno].getImageCount(files[fno])) { 
     365      return readers[fno].openBytes(files[fno], ino); 
     366    } 
     367    // return a blank image to cover for the fact that 
     368    // this file does not contain enough image planes 
     369    if (blankBytes == null) { 
     370      int bytes = FormatReader.getBytesPerPixel(getPixelType(currentId)); 
     371      blankBytes = new byte[width * height * bytes * sizeC]; 
     372    } 
     373    return blankBytes; 
     374  } 
     375 
     376  /* @see IFormatReader#openBytes(String, int, byte[]) */ 
     377  public byte[] openBytes(String id, int no, byte[] buf) 
     378    throws FormatException, IOException 
     379  { 
     380    int[] q = computeIndices(id, no); 
     381    int fno = q[0], ino = q[1]; 
     382    return readers[fno].openBytes(files[fno], ino, buf); 
     383  } 
     384 
     385  /* @see IFormatReader#openThumbImage(String, int) */ 
     386  public BufferedImage openThumbImage(String id, int no) 
     387    throws FormatException, IOException 
     388  { 
     389    int[] q = computeIndices(id, no); 
     390    int fno = q[0], ino = q[1]; 
     391    return readers[fno].openThumbImage(files[fno], ino); 
     392  } 
     393 
     394  /* @see IFormatReader#openThumbImage(String, int) */ 
     395  public byte[] openThumbBytes(String id, int no) 
     396    throws FormatException, IOException 
     397  { 
     398    int[] q = computeIndices(id, no); 
     399    int fno = q[0], ino = q[1]; 
     400    return readers[fno].openThumbBytes(files[fno], ino); 
     401  } 
     402 
     403  /* @see IFormatReader#close() */ 
     404  public void close() throws FormatException, IOException { 
     405    if (readers != null) { 
     406      for (int i=0; i<readers.length; i++) readers[i].close(); 
     407    } 
     408    readers = null; 
     409    blankImage = null; 
     410    blankBytes = null; 
     411    currentId = null; 
     412  } 
     413 
     414  /* @see IFormatReader#getSeriesCount(String) */ 
     415  public int getSeriesCount(String id) throws FormatException, IOException { 
     416    if (!id.equals(currentId)) initFile(id); 
     417    return reader.getSeriesCount(files[0]); 
     418  } 
     419 
     420  /* @see IFormatReader#setSeries(String, int) */ 
     421  public void setSeries(String id, int no) throws FormatException, IOException { 
     422    if (!id.equals(currentId)) initFile(id); 
     423    reader.setSeries(files[0], no); 
     424  } 
     425 
     426  /* @see IFormatReader#getSeries(String) */ 
     427  public int getSeries(String id) throws FormatException, IOException { 
     428    if (!id.equals(currentId)) initFile(id); 
     429    return reader.getSeries(files[0]); 
     430  } 
     431 
     432  /* @see IFormatReader#setColorTableIgnored(boolean) */ 
     433  public void setColorTableIgnored(boolean ignore) { 
     434    ignoreColorTable = ignore; 
     435  } 
     436 
     437  /* @see IFormatReader#isColorTableIgnored() */ 
     438  public boolean isColorTableIgnored() { return ignoreColorTable; } 
     439 
     440  /* @see IFormatReader#setNormalized(boolean) */ 
     441  public void setNormalized(boolean normalize) { 
     442    normalizeData = normalize; 
     443  } 
     444 
     445  /* @see IFormatReader#isNormalized() */ 
     446  public boolean isNormalized() { return normalizeData; } 
     447 
     448  /* @see IFormatReader#swapDimensions(String, String) */ 
     449  public void swapDimensions(String id, String order) 
     450    throws FormatException, IOException 
     451  { 
     452    if (!id.equals(currentId)) initFile(id); 
     453    this.order = order; 
     454    String f0 = files[0]; 
     455    reader.swapDimensions(f0, order); 
     456    sizeZ = reader.getSizeZ(f0); 
     457    sizeC = reader.getSizeC(f0); 
     458    sizeT = reader.getSizeT(f0); 
     459    computeAxisLengths(); 
     460  } 
     461 
     462  /* @see IFormatReader#getIndex(String, int, int, int) */ 
     463  public int getIndex(String id, int z, int c, int t) 
     464    throws FormatException, IOException 
     465  { 
     466    return FormatReader.getIndex(this, id, z, c, t); 
     467  } 
     468 
     469  /* @see IFormatReader#getZCTCoords(String, int) */ 
     470  public int[] getZCTCoords(String id, int index) 
     471    throws FormatException, IOException 
     472  { 
     473    return FormatReader.getZCTCoords(this, id, index); 
     474  } 
     475 
     476 
     477  /* @see IFormatReader#getMetadataValue(String, String) */ 
     478  public Object getMetadataValue(String id, String field) 
     479    throws FormatException, IOException 
     480  { 
     481    if (!id.equals(currentId)) initFile(id); 
     482    return reader.getMetadataValue(files[0], field); 
     483  } 
     484 
     485  /* @see IFormatReader#getMetadata(String) */ 
     486  public Hashtable getMetadata(String id) throws FormatException, IOException { 
     487    if (!id.equals(currentId)) initFile(id); 
     488    return reader.getMetadata(files[0]); 
     489  } 
     490 
     491  /* @see IFormatReader#setMetadataStore(MetadataStore) */ 
     492  public void setMetadataStore(MetadataStore store) { 
     493    reader.setMetadataStore(store); 
     494  } 
     495 
     496  /* @see IFormatReader#getMetadataStore(String) */ 
     497  public MetadataStore getMetadataStore(String id) 
     498    throws FormatException, IOException 
     499  { 
     500    if (!id.equals(currentId)) initFile(id); 
     501    return reader.getMetadataStore(files[0]); 
     502  } 
     503 
     504  /* @see IFormatReader#getMetadataStoreRoot(String) */ 
     505  public Object getMetadataStoreRoot(String id) 
     506    throws FormatException, IOException 
     507  { 
     508    if (!id.equals(currentId)) initFile(id); 
     509    return reader.getMetadataStoreRoot(files[0]); 
     510  } 
     511 
     512  /* @see IFormatReader#testRead(String[]) */ 
     513  public boolean testRead(String[] args) throws FormatException, IOException { 
     514    return FormatReader.testRead(this, args); 
     515  } 
     516 
     517  // -- IFormatHandler API methods -- 
     518 
     519  /* @see IFormatHandler#isThisType(String) */ 
     520  public boolean isThisType(String name) { 
     521    return reader.isThisType(name); 
     522  } 
     523 
     524  /* @see IFormatHandler#isThisType(String, boolean) */ 
     525  public boolean isThisType(String name, boolean open) { 
     526    return reader.isThisType(name, open); 
     527  } 
     528 
     529  /* @see IFormatHandler#getFormat() */ 
     530  public String getFormat() { 
     531    return reader.getFormat(); 
     532  } 
     533 
     534  /* @see IFormatHandler#getSuffixes() */ 
     535  public String[] getSuffixes() { 
     536    return reader.getSuffixes(); 
     537  } 
     538 
     539  /* @see IFormatHandler#getFileFilters() */ 
     540  public FileFilter[] getFileFilters() { 
     541    return reader.getFileFilters(); 
     542  } 
     543 
     544  /* @see IFormatHandler#getFileChooser() */ 
     545  public JFileChooser getFileChooser() { 
     546    return reader.getFileChooser(); 
     547  } 
     548 
     549  /* @see IFormatHandler#mapId(String, String) */ 
     550  public void mapId(String id, String filename) { 
     551    // NB: all readers share the same ID map 
     552    reader.mapId(id, filename); 
     553  } 
     554 
     555  /* @see IFormatHandler#getMappedId(String) */ 
     556  public String getMappedId(String id) { 
     557    return reader.getMappedId(id); 
     558  } 
     559 
     560  /* @see IFormatHandler#getIdMap() */ 
     561  public Hashtable getIdMap() { 
     562    return reader.getIdMap(); 
     563  } 
     564 
     565  /* @see IFormatHandler#setIdMap(Hashtable) */ 
     566  public void setIdMap(Hashtable map) { 
     567    for (int i=0; i<readers.length; i++) readers[i].setIdMap(map); 
     568  } 
     569 
     570 
     571  // -- Helper methods -- 
     572 
     573  /** Initializes the given file. */ 
     574  protected void initFile(String id) throws FormatException, IOException { 
     575    currentId = id; 
     576    fp = findPattern(id); 
    569577 
    570578    // verify that file pattern is valid and matches existing files 
  • trunk/loci/formats/OmeisImporter.java

    r1828 r1831  
    5555   * specified by -http-response CLI flag. 
    5656   */ 
    57   private static boolean httpResponse = false; 
     57  private static boolean http = false; 
    5858 
    5959  // -- Fields -- 
    6060 
    6161  /** Reader for handling file formats. */ 
    62   private IFormatReader reader; 
     62  private FileStitcher reader; 
    6363 
    6464  /** Metadata store, for gathering OME-XML metadata. */ 
     
    6868 
    6969  public OmeisImporter() { 
    70     reader = new ChannelSeparator(); 
     70    reader = new FileStitcher(new ChannelSeparator()); 
    7171    store = new OMEXMLMetadataStore(); 
    7272    reader.setMetadataStore(store); 
     
    7777  /** 
    7878   * Tests whether Bio-Formats is potentially capable of importing the given 
    79    * file IDs. Outputs the IDs it can potentially import, one per line. 
     79   * file IDs. Outputs the IDs it can potentially import, one group per line, 
     80   * with elements of the each group separated by spaces. 
    8081   */ 
    8182  public void testIds(int[] fileIds) throws OmeisException { 
     
    8889      reader.mapId(ids[i], path); 
    8990    } 
    90     // check types 
     91 
     92    // check types and groups 
     93    if (http) printHttpResponseHeader(); 
     94    boolean[] done = new boolean[fileIds.length]; 
     95    StringBuffer sb = new StringBuffer(); 
    9196    for (int i=0; i<fileIds.length; i++) { 
    92       if (ids[i] != null && reader.isThisType(ids[i])) { 
    93         if (httpResponse) printHttpResponseHeader(); 
    94         System.out.println(fileIds[i]); 
    95       } 
    96     } 
    97   } 
    98  
    99   /** 
    100    * Attempts to import the given file IDs using Bio-Formats. Pixels are saved 
    101    * to the pixels files designated by OMEIS, and an OME-XML metadata block 
    102    * describing all successfully imported data is dumped to standard output. 
     97      if (done[i]) continue; // already part of another group 
     98      if (ids[i] == null) continue; // invalid id 
     99      if (!reader.isThisType(ids[i])) continue; // unknown format 
     100      FilePattern fp = reader.findPattern(ids[i]); 
     101      if (!fp.isValid()) continue; // invalid file pattern 
     102      String[] files = fp.getFiles(); 
     103      if (files == null) continue; // invalid files list 
     104      sb.setLength(0); 
     105      for (int j=0; j<files.length; j++) { 
     106        for (int ii=i; ii<fileIds.length; ii++) { 
     107          if (files[j].equals(ids[ii])) { 
     108            if (done[ii]) { 
     109              log("Warning: FileID " + fileIds[ii] + " ('" + 
     110                ids[ii] + "') already belongs to a group"); 
     111            } 
     112            done[ii] = true; 
     113            if (j > 0) sb.append(" "); 
     114            sb.append(fileIds[ii]); 
     115            break; 
     116          } 
     117        } 
     118      } 
     119      System.out.println(sb.toString()); 
     120    } 
     121  } 
     122 
     123  /** 
     124   * Attempts to import the given file IDs using Bio-Formats, as a single 
     125   * group. Pixels are saved to the pixels file designated by OMEIS, and an 
     126   * OME-XML metadata block describing the successfully imported data is 
     127   * dumped to standard output. 
    103128   */ 
    104129  public void importIds(int[] fileIds) throws OmeisException { 
     
    114139    } 
    115140 
    116     ByteArrayOutputStream xml = new ByteArrayOutputStream(); 
    117  
    118     // read files 
    119     for (int i=0; i<fileIds.length; i++) { 
    120       String id = ids[i]; 
    121       String path = reader.getMappedId(ids[i]); 
    122       if (DEBUG) log("Reading file '" + id + "' --> " + path); 
    123       try { 
    124         int seriesCount = reader.getSeriesCount(id); 
    125  
    126         // get DOM and Pixels elements for the file's OME-XML metadata 
    127         OMENode ome = (OMENode) store.getRoot(); 
    128         Document omeDoc = ome.getOMEDocument(false); 
    129         Vector pix = DOMUtil.findElementList("Pixels", omeDoc); 
    130         if (pix.size() != seriesCount) { 
    131           System.err.println("Error: Pixels element count (" + 
    132             pix.size() + ") does not match series count (" + 
    133             seriesCount + ") for '" + path + "'"); 
    134           continue; 
    135         } 
    136         if (DEBUG) log(seriesCount + " series detected."); 
    137  
    138         for (int s=0; s<seriesCount; s++) { 
    139           reader.setSeries(id, s); 
    140  
    141           // gather pixels information for this series 
    142           int sizeX = reader.getSizeX(id); 
    143           int sizeY = reader.getSizeY(id); 
    144           int sizeZ = reader.getSizeZ(id); 
    145           int sizeC = reader.getSizeC(id); 
    146           int sizeT = reader.getSizeT(id); 
    147           int pixelType = reader.getPixelType(id); 
    148           int bytesPerPixel; 
    149           boolean isSigned, isFloat; 
    150           switch (pixelType) { 
    151             case FormatReader.INT8: 
    152               bytesPerPixel = 1; 
    153               isSigned = true; 
    154               isFloat = false; 
    155               break; 
    156             case FormatReader.UINT8: 
    157               bytesPerPixel = 1; 
    158               isSigned = false; 
    159               isFloat = false; 
    160               break; 
    161             case FormatReader.INT16: 
    162               bytesPerPixel = 2; 
    163               isSigned = true; 
    164               isFloat = false; 
    165               break; 
    166             case FormatReader.UINT16: 
    167               bytesPerPixel = 2; 
    168               isSigned = false; 
    169               isFloat = false; 
    170               break; 
    171             case FormatReader.INT32: 
    172               bytesPerPixel = 4; 
    173               isSigned = true; 
    174               isFloat = false; 
    175               break; 
    176             case FormatReader.UINT32: 
    177               bytesPerPixel = 4; 
    178               isSigned = false; 
    179               isFloat = false; 
    180               break; 
    181             case FormatReader.FLOAT: 
    182               bytesPerPixel = 4; 
    183               isSigned = true; 
    184               isFloat = true; 
    185               break; 
    186             case FormatReader.DOUBLE: 
    187               bytesPerPixel = 8; 
    188               isSigned = true; 
    189               isFloat = true; 
    190               break; 
    191             default: 
    192               System.err.println("Error: unknown pixel type for '" + 
    193                 path + "' series #" + s + ": " + pixelType); 
    194               continue; 
     141    // read file group 
     142    String id = ids[0]; 
     143    String path = reader.getMappedId(ids[0]); 
     144    if (DEBUG) log("Reading file '" + id + "' --> " + path); 
     145    try { 
     146      // verify that all given file IDs were grouped by the file stitcher 
     147      FilePattern fp = reader.getFilePattern(id); 
     148      if (!fp.isValid()) { 
     149        log("Error: invalid file pattern for " + path); 
     150        if (http) printHttpErrorHeader(); 
     151        return; 
     152      } 
     153      String[] files = fp.getFiles(); 
     154      if (files == null) { 
     155        log("Error: invalid file list for " + path); 
     156        if (http) printHttpErrorHeader(); 
     157        return; 
     158      } 
     159      if (files.length != ids.length) { 
     160        log("Error: file list length mismatch for " + path); 
     161        if (http) printHttpErrorHeader(); 
     162        return; 
     163      } 
     164      boolean[] done = new boolean[ids.length]; 
     165      int numLeft = ids.length; 
     166      for (int i=0; i<files.length; i++) { 
     167        for (int j=0; j<ids.length; j++) { 
     168          if (done[j]) continue; 
     169          if (files[i].equals(ids[j])) { 
     170            done[j] = true; 
     171            numLeft--; 
     172            break; 
    195173          } 
    196           boolean little = reader.isLittleEndian(id); 
    197           boolean swap = doLittle != little; 
    198  
    199           // ask OMEIS to allocate new pixels file 
    200           int pixelsId = newPixels(sizeX, sizeY, sizeZ, sizeC, sizeT, 
    201             bytesPerPixel, isSigned, isFloat); 
    202           String pixelsPath = getLocalPixelsPath(pixelsId); 
    203           if (DEBUG) { 
    204             log("Series #" + s + ": id=" + pixelsId + ", path=" + pixelsPath); 
    205           } 
    206  
    207           // write pixels to file 
    208           FileOutputStream out = new FileOutputStream(pixelsPath); 
    209           int imageCount = reader.getImageCount(id); 
    210           if (DEBUG) { 
    211             log("Processing " + imageCount + " planes (sizeZ=" + sizeZ + 
    212               ", sizeC=" + sizeC + ", sizeT=" + sizeT + "): "); 
    213           } 
    214           for (int j=0; j<imageCount; j++) { 
    215             if (DEBUG) log("  Reading plane #" + j); 
    216             byte[] plane = reader.openBytes(id, j); 
    217             if (swap && bytesPerPixel > 1 && !isFloat) { // swap endianness 
    218               for (int b=0; b<plane.length; b+=bytesPerPixel) { 
    219                 for (int k=0; k<bytesPerPixel/2; k++) { 
    220                   int i1 = b + k; 
    221                   int i2 = b + bytesPerPixel - k - 1; 
    222                   byte b1 = plane[i1]; 
    223                   byte b2 = plane[i2]; 
    224                   plane[i1] = b2; 
    225                   plane[i2] = b1; 
    226                 } 
     174        } 
     175      } 
     176      if (numLeft > 0) { 
     177        log("Error: file list does not correspond to ID list for " + path); 
     178        if (http) printHttpErrorHeader(); 
     179        return; 
     180      } 
     181 
     182      int seriesCount = reader.getSeriesCount(id); 
     183 
     184      // get DOM and Pixels elements for the file's OME-XML metadata 
     185      OMENode ome = (OMENode) store.getRoot(); 
     186      Document omeDoc = ome.getOMEDocument(false); 
     187      Vector pix = DOMUtil.findElementList("Pixels", omeDoc); 
     188      if (pix.size() != seriesCount) { 
     189        log("Error: Pixels element count (" + 
     190          pix.size() + ") does not match series count (" + 
     191          seriesCount + ") for '" + id + "'"); 
     192        if (http) printHttpErrorHeader(); 
     193        return; 
     194      } 
     195      if (DEBUG) log(seriesCount + " series detected."); 
     196 
     197      for (int s=0; s<seriesCount; s++) { 
     198        reader.setSeries(id, s); 
     199 
     200        // gather pixels information for this series 
     201        int sizeX = reader.getSizeX(id); 
     202        int sizeY = reader.getSizeY(id); 
     203        int sizeZ = reader.getSizeZ(id); 
     204        int sizeC = reader.getSizeC(id); 
     205        int sizeT = reader.getSizeT(id); 
     206        int pixelType = reader.getPixelType(id); 
     207        int bytesPerPixel; 
     208        boolean isSigned, isFloat; 
     209        switch (pixelType) { 
     210          case FormatReader.INT8: 
     211            bytesPerPixel = 1; 
     212            isSigned = true; 
     213            isFloat = false; 
     214            break; 
     215          case FormatReader.UINT8: 
     216            bytesPerPixel = 1; 
     217            isSigned = false; 
     218            isFloat = false; 
     219            break; 
     220          case FormatReader.INT16: 
     221            bytesPerPixel = 2; 
     222            isSigned = true; 
     223            isFloat = false; 
     224            break; 
     225          case FormatReader.UINT16: 
     226            bytesPerPixel = 2; 
     227            isSigned = false; 
     228            isFloat = false; 
     229            break; 
     230          case FormatReader.INT32: 
     231            bytesPerPixel = 4; 
     232            isSigned = true; 
     233            isFloat = false; 
     234            break; 
     235          case FormatReader.UINT32: 
     236            bytesPerPixel = 4; 
     237            isSigned = false; 
     238            isFloat = false; 
     239            break; 
     240          case FormatReader.FLOAT: 
     241            bytesPerPixel = 4; 
     242            isSigned = true; 
     243            isFloat = true; 
     244            break; 
     245          case FormatReader.DOUBLE: 
     246            bytesPerPixel = 8; 
     247            isSigned = true; 
     248            isFloat = true; 
     249            break; 
     250          default: 
     251            log("Error: unknown pixel type for '" + 
     252              id + "' series #" + s + ": " + pixelType); 
     253            if (http) printHttpErrorHeader(); 
     254            return; 
     255        } 
     256        boolean little = reader.isLittleEndian(id); 
     257        boolean swap = doLittle != little; 
     258 
     259        // ask OMEIS to allocate new pixels file 
     260        int pixelsId = newPixels(sizeX, sizeY, sizeZ, sizeC, sizeT, 
     261          bytesPerPixel, isSigned, isFloat); 
     262        String pixelsPath = getLocalPixelsPath(pixelsId); 
     263        if (DEBUG) { 
     264          log("Series #" + s + ": id=" + pixelsId + ", path=" + pixelsPath); 
     265        } 
     266 
     267        // write pixels to file 
     268        FileOutputStream out = new FileOutputStream(pixelsPath); 
     269        int imageCount = reader.getImageCount(id); 
     270        if (DEBUG) { 
     271          log("Processing " + imageCount + " planes (sizeZ=" + sizeZ + 
     272            ", sizeC=" + sizeC + ", sizeT=" + sizeT + "): "); 
     273        } 
     274        for (int j=0; j<imageCount; j++) { 
     275          if (DEBUG) log("  Reading plane #" + j); 
     276          byte[] plane = reader.openBytes(id, j); 
     277          if (swap && bytesPerPixel > 1 && !isFloat) { // swap endianness 
     278            for (int b=0; b<plane.length; b+=bytesPerPixel) { 
     279              for (int k=0; k<bytesPerPixel/2; k++) { 
     280                int i1 = b + k; 
     281                int i2 = b + bytesPerPixel - k - 1; 
     282                byte b1 = plane[i1]; 
     283                byte b2 = plane[i2]; 
     284                plane[i1] = b2; 
     285                plane[i2] = b1; 
    227286              } 
    228287            } 
    229             out.write(plane); 
    230288          } 
    231           out.close(); 
    232           reader.close(); 
    233           if (DEBUG) log("[done]"); 
    234  
    235           // tell OMEIS we're done 
    236           pixelsId = finishPixels(pixelsId); 
    237           if (DEBUG) log("finishPixels called (new id=" + pixelsId + ")"); 
    238  
    239           // get SHA1 hash for finished pixels 
    240           String sha1 = getPixelsSHA1(pixelsId); 
    241           if (DEBUG) log("SHA1=" + sha1); 
    242  
    243           // inject important extra attributes into proper Pixels element 
    244           Element pixels = (Element) pix.elementAt(s); 
    245           pixels.setAttribute("FileSHA1", sha1); 
    246           pixels.setAttribute("ImageServerID", "" + pixelsId); 
    247           if (DEBUG) log("Pixel attributes injected."); 
    248         } 
    249  
    250         // accumulate XML into buffer 
    251         DOMUtil.writeXML(xml, omeDoc); 
    252         // TODO need to strip off <OME></OME> root, and readd it at 
    253         // the end, so that all XML blocks are part of the same root. 
    254       } 
    255       catch (Exception exc) { 
    256         System.err.println( 
    257           "Error: an exception occurred reading " + path + ":"); 
    258         exc.printStackTrace(); 
    259       } 
    260     } 
    261  
    262     // output OME-XML to standard output 
    263     try { 
     289          out.write(plane); 
     290        } 
     291        out.close(); 
     292        reader.close(); 
     293        if (DEBUG) log("[done]"); 
     294 
     295        // tell OMEIS we're done 
     296        pixelsId = finishPixels(pixelsId); 
     297        if (DEBUG) log("finishPixels called (new id=" + pixelsId + ")"); 
     298 
     299        // get SHA1 hash for finished pixels 
     300        String sha1 = getPixelsSHA1(pixelsId); 
     301        if (DEBUG) log("SHA1=" + sha1); 
     302 
     303        // inject important extra attributes into proper Pixels element 
     304        Element pixels = (Element) pix.elementAt(s); 
     305        pixels.setAttribute("FileSHA1", sha1); 
     306        pixels.setAttribute("ImageServerID", "" + pixelsId); 
     307        if (DEBUG) log("Pixel attributes injected."); 
     308      } 
     309 
     310      // accumulate XML into buffer 
     311      ByteArrayOutputStream xml = new ByteArrayOutputStream(); 
     312      DOMUtil.writeXML(xml, omeDoc); 
     313 
     314      // output OME-XML to standard output 
    264315      xml.close(); 
    265       if (httpResponse) printHttpResponseHeader(); 
    266316      String xmlString = new String(xml.toByteArray()); 
     317      if (DEBUG) log(xmlString); 
     318      if (http) printHttpResponseHeader(); 
    267319      System.out.println(xmlString); 
    268       if (DEBUG) log(xmlString); 
    269     } 
    270     catch (IOException exc) { 
    271       System.err.println("Error: an exception occurred compiling OME-XML"); 
     320    } 
     321    catch (Exception exc) { 
     322      log("Error: an exception occurred importing " + path + ":"); 
    272323      exc.printStackTrace(); 
     324      if (http) printHttpErrorHeader(); 
    273325    } 
    274326  } 
     
    283335    catch (IOException exc) { throw new OmeisException(exc); } 
    284336    if (s.length > 1) { 
    285       System.err.println("Warning: ignoring " + (s.length - 1) + 
     337      log("Warning: ignoring " + (s.length - 1) + 
    286338        " extraneous lines in OMEIS GetLocalPath call"); 
    287339    } 
     
    306358      int equals = s[i].indexOf("="); 
    307359      if (equals < 0) { 
    308         System.err.println( 
    309           "Warning: ignoring extraneous line in OMEIS FileInfo call: " + s[i]); 
     360        log("Warning: ignoring extraneous line in OMEIS FileInfo call: " + 
     361          s[i]); 
    310362      } 
    311363      else { 
     
    334386    catch (IOException exc) { throw new OmeisException(exc); } 
    335387    if (s.length > 1) { 
    336       System.err.println("Warning: ignoring " + (s.length - 1) + 
     388      log("Warning: ignoring " + (s.length - 1) + 
    337389        " extraneous lines in OMEIS NewPixels call output"); 
    338390    } 
     
    356408    catch (IOException exc) { throw new OmeisException(exc); } 
    357409    if (s.length > 1) { 
    358       System.err.println("Warning: ignoring " + (s.length - 1) + 
     410      log("Warning: ignoring " + (s.length - 1) + 
    359411        " extraneous lines in OMEIS GetLocalPath call output"); 
    360412    } 
     
    374426    catch (IOException exc) { throw new OmeisException(exc); } 
    375427    if (s.length > 1) { 
    376       System.err.println("Warning: ignoring " + (s.length - 1) + 
     428      log("Warning: ignoring " + (s.length - 1) + 
    377429        " extraneous lines in OMEIS GetLocalPath call"); 
    378430    } 
     
    395447    catch (IOException exc) { throw new OmeisException(exc); } 
    396448    if (s.length > 1) { 
    397       System.err.println("Warning: ignoring " + (s.length - 1) + 
     449      log("Warning: ignoring " + (s.length - 1) + 
    398450        " extraneous lines in OMEIS FinishPixels call output"); 
    399451    } 
     
    417469    catch (IOException exc) { throw new OmeisException(exc); } 
    418470    if (s.length > 1) { 
    419       System.err.println("Warning: ignoring " + (s.length - 1) + 
     471      log("Warning: ignoring " + (s.length - 1) + 
    420472        " extraneous lines in OMEIS PixelsSHA1 call"); 
    421473    } 
     
    488540    for (int i=0; i<args.length; i++) { 
    489541      if ("-test".equalsIgnoreCase(args[i])) test = true; 
    490       else if ("-http-response".equalsIgnoreCase(args[i])) httpResponse = true; 
     542      else if ("-http-response".equalsIgnoreCase(args[i])) http = true; 
    491543      else { 
    492544        try { 
     
    509561    } 
    510562    catch (Exception exc) { 
    511       if (httpResponse) { 
     563      if (http) { 
    512564        importer.printHttpErrorHeader(); 
    513565        System.out.println("An exception occurred while processing FileIDs:"); 
Note: See TracChangeset for help on using the changeset viewer.