Changeset 2687


Ignore:
Timestamp:
04/26/07 16:19:28 (13 years ago)
Author:
curtis
Message:
  • Switch IFormatWriter over to setId model
  • Switch SDTReader API methods to setId model
  • Organize code and clean up whitespace
Location:
trunk/loci/formats
Files:
66 edited

Legend:

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

    r2674 r2687  
    3030public class CoreMetadata { 
    3131  public int[] sizeX, sizeY, sizeZ, sizeC, sizeT, pixelType, imageCount; 
    32   public int[] thumbSizeX, thumbSizeY;  
     32  public int[] thumbSizeX, thumbSizeY; 
    3333  public int[][] cLengths; 
    3434  public String[][] cTypes; 
  • trunk/loci/formats/FileStitcher.java

    r2678 r2687  
    8989  /** Core metadata. */ 
    9090  private CoreMetadata core; 
    91    
     91 
    9292  // -- Constructors -- 
    9393 
     
    215215  /* @see IFormatReader#getImageCount() */ 
    216216  public int getImageCount() { 
    217     return core.imageCount[getSeries()];  
     217    return core.imageCount[getSeries()]; 
    218218  } 
    219219 
     
    864864    throws FormatException, IOException 
    865865  { 
    866     if (!id.equals(currentId)) setId(id); 
     866    setId(id); 
    867867    return getAxisTypes(); 
    868868  } 
     
    872872    throws FormatException, IOException 
    873873  { 
    874     if (!id.equals(currentId)) setId(id); 
     874    setId(id); 
    875875    setAxisTypes(axes); 
    876876  } 
     
    880880    throws FormatException, IOException 
    881881  { 
    882     if (!id.equals(currentId)) initFile(id); 
     882    setId(id); 
    883883    return getFilePattern(); 
    884884  } 
     
    888888    throws FormatException, IOException 
    889889  { 
    890     if (!id.equals(currentId)) initFile(id); 
     890    setId(id); 
    891891    return getAxisGuesser(); 
    892892  } 
     
    896896  /** @deprecated Replaced by {@link #getImageCount()} */ 
    897897  public int getImageCount(String id) throws FormatException, IOException { 
    898     if (!id.equals(currentId)) setId(id); 
     898    setId(id); 
    899899    return getImageCount(); 
    900900  } 
     
    902902  /** @deprecated Replaced by {@link #isRGB()} */ 
    903903  public boolean isRGB(String id) throws FormatException, IOException { 
    904     if (!id.equals(currentId)) setId(id); 
     904    setId(id); 
    905905    return isRGB(); 
    906906  } 
     
    908908  /** @deprecated Replaced by {@link #getSizeX()} */ 
    909909  public int getSizeX(String id) throws FormatException, IOException { 
    910     if (!id.equals(currentId)) setId(id); 
     910    setId(id); 
    911911    return getSizeX(); 
    912912  } 
     
    914914  /** @deprecated Replaced by {@link #getSizeY()} */ 
    915915  public int getSizeY(String id) throws FormatException, IOException { 
    916     if (!id.equals(currentId)) setId(id); 
     916    setId(id); 
    917917    return getSizeY(); 
    918918  } 
     
    920920  /** @deprecated Replaced by {@link #getSizeZ()} */ 
    921921  public int getSizeZ(String id) throws FormatException, IOException { 
    922     if (!id.equals(currentId)) setId(id); 
     922    setId(id); 
    923923    return getSizeZ(); 
    924924  } 
     
    926926  /** @deprecated Replaced by {@link #getSizeC()} */ 
    927927  public int getSizeC(String id) throws FormatException, IOException { 
    928     if (!id.equals(currentId)) setId(id); 
     928    setId(id); 
    929929    return getSizeC(); 
    930930  } 
     
    932932  /** @deprecated Replaced by {@link #getSizeT()} */ 
    933933  public int getSizeT(String id) throws FormatException, IOException { 
    934     if (!id.equals(currentId)) setId(id); 
     934    setId(id); 
    935935    return getSizeT(); 
    936936  } 
     
    938938  /** @deprecated Replaced by {@link #getPixelType()} */ 
    939939  public int getPixelType(String id) throws FormatException, IOException { 
    940     if (!id.equals(currentId)) setId(id); 
     940    setId(id); 
    941941    return getPixelType(); 
    942942  } 
     
    944944  /** @deprecated Replaced by {@link #getEffectiveSizeC()} */ 
    945945  public int getEffectiveSizeC(String id) throws FormatException, IOException { 
    946     if (!id.equals(currentId)) setId(id); 
     946    setId(id); 
    947947    return getImageCount() / (getSizeZ() * getSizeT()); 
    948948  } 
     
    950950  /** @deprecated Replaced by {@link #getRGBChannelCount()} */ 
    951951  public int getRGBChannelCount(String id) throws FormatException, IOException { 
    952     if (!id.equals(currentId)) setId(id); 
     952    setId(id); 
    953953    return getSizeC() / getEffectiveSizeC(); 
    954954  } 
     
    958958    throws FormatException, IOException 
    959959  { 
    960     if (!id.equals(currentId)) setId(id); 
     960    setId(id); 
    961961    int sno = getSeries(); 
    962962    int len = lenC[sno].length; 
     
    970970    throws FormatException, IOException 
    971971  { 
    972     if (!id.equals(currentId)) setId(id); 
     972    setId(id); 
    973973    int sno = getSeries(); 
    974974    int len = lenC[sno].length; 
     
    980980  /** @deprecated Replaced by {@link #getThumbSizeX()} */ 
    981981  public int getThumbSizeX(String id) throws FormatException, IOException { 
    982     if (!id.equals(currentId)) setId(id); 
     982    setId(id); 
    983983    return reader.getThumbSizeX(); 
    984984  } 
     
    986986  /** @deprecated Replaced by {@link #getThumbSizeY()} */ 
    987987  public int getThumbSizeY(String id) throws FormatException, IOException { 
    988     if (!id.equals(currentId)) setId(id); 
     988    setId(id); 
    989989    return reader.getThumbSizeY(); 
    990990  } 
     
    992992  /** @deprecated Replaced by {@link #isLittleEndian()} */ 
    993993  public boolean isLittleEndian(String id) throws FormatException, IOException { 
    994     if (!id.equals(currentId)) setId(id); 
     994    setId(id); 
    995995    return reader.isLittleEndian(); 
    996996  } 
     
    10001000    throws FormatException, IOException 
    10011001  { 
    1002     if (!id.equals(currentId)) setId(id); 
     1002    setId(id); 
    10031003    return core.currentOrder[getSeries()]; 
    10041004  } 
     
    10061006  /** @deprecated Replaced by {@link #isOrderCertain()} */ 
    10071007  public boolean isOrderCertain(String id) throws FormatException, IOException { 
    1008     if (!id.equals(currentId)) setId(id); 
     1008    setId(id); 
    10091009    return ag[getSeries()].isCertain(); 
    10101010  } 
     
    10121012  /** @deprecated Replaced by {@link #isInterleaved()} */ 
    10131013  public boolean isInterleaved(String id) throws FormatException, IOException { 
    1014     if (!id.equals(currentId)) setId(id); 
     1014    setId(id); 
    10151015    return reader.isInterleaved(); 
    10161016  } 
     
    10201020    throws FormatException, IOException 
    10211021  { 
    1022     if (!id.equals(currentId)) setId(id); 
     1022    setId(id); 
    10231023    return reader.isInterleaved(subC); 
    10241024  } 
     
    10281028    throws FormatException, IOException 
    10291029  { 
    1030     if (!id.equals(currentId)) setId(id); 
     1030    setId(id); 
    10311031    return openImage(no); 
    10321032  } 
     
    10361036    throws FormatException, IOException 
    10371037  { 
    1038     if (!id.equals(currentId)) setId(id); 
     1038    setId(id); 
    10391039    return openBytes(no); 
    10401040  } 
     
    10441044    throws FormatException, IOException 
    10451045  { 
    1046     if (!id.equals(currentId)) setId(id); 
     1046    setId(id); 
    10471047    return openBytes(no, buf); 
    10481048  } 
     
    10521052    throws FormatException, IOException 
    10531053  { 
    1054     if (!id.equals(currentId)) setId(id); 
     1054    setId(id); 
    10551055    return openThumbImage(no); 
    10561056  } 
     
    10601060    throws FormatException, IOException 
    10611061  { 
    1062     if (!id.equals(currentId)) setId(id); 
     1062    setId(id); 
    10631063    return openThumbBytes(no); 
    10641064  } 
     
    10661066  /** @deprecated Replaced by {@link #getSeriesCount()} */ 
    10671067  public int getSeriesCount(String id) throws FormatException, IOException { 
    1068     if (!id.equals(currentId)) setId(id); 
     1068    setId(id); 
    10691069    return reader.getSeriesCount(); 
    10701070  } 
     
    10721072  /** @deprecated Replaced by {@link #setSeries(int)} */ 
    10731073  public void setSeries(String id, int no) throws FormatException, IOException { 
    1074     if (!id.equals(currentId)) setId(id); 
     1074    setId(id); 
    10751075    reader.setSeries(no); 
    10761076  } 
     
    10781078  /** @deprecated Replaced by {@link #getSeries()} */ 
    10791079  public int getSeries(String id) throws FormatException, IOException { 
    1080     if (!id.equals(currentId)) setId(id); 
     1080    setId(id); 
    10811081    return reader.getSeries(); 
    10821082  } 
     
    10841084  /** @deprecated Replaced by {@link #getUsedFiles()} */ 
    10851085  public String[] getUsedFiles(String id) throws FormatException, IOException { 
    1086     if (!id.equals(currentId)) setId(id); 
     1086    setId(id); 
    10871087    return getUsedFiles(); 
    10881088  } 
     
    10921092    throws FormatException, IOException 
    10931093  { 
    1094     if (!id.equals(currentId)) setId(id); 
     1094    setId(id); 
    10951095    return FormatTools.getIndex(this, z, c, t); 
    10961096  } 
     
    11001100    throws FormatException, IOException 
    11011101  { 
    1102     if (!id.equals(currentId)) setId(id); 
     1102    setId(id); 
    11031103    return FormatTools.getZCTCoords(this, index); 
    11041104  } 
     
    11081108    throws FormatException, IOException 
    11091109  { 
    1110     if (!id.equals(currentId)) setId(id); 
     1110    setId(id); 
    11111111    return reader.getMetadataValue(field); 
    11121112  } 
     
    11141114  /** @deprecated Replaced by {@link #getMetadata()} */ 
    11151115  public Hashtable getMetadata(String id) throws FormatException, IOException { 
    1116     if (!id.equals(currentId)) setId(id); 
     1116    setId(id); 
    11171117    return reader.getMetadata(); 
    11181118  } 
     
    11221122    throws FormatException, IOException 
    11231123  { 
    1124     if (!id.equals(currentId)) setId(id); 
     1124    setId(id); 
    11251125    return reader.getCoreMetadata(); 
    11261126  } 
     
    11301130    throws FormatException, IOException 
    11311131  { 
    1132     if (!id.equals(currentId)) setId(id); 
     1132    setId(id); 
    11331133    return reader.getMetadataStore(); 
    11341134  } 
     
    11381138    throws FormatException, IOException 
    11391139  { 
    1140     if (!id.equals(currentId)) setId(id); 
     1140    setId(id); 
    11411141    return reader.getMetadataStoreRoot(); 
    11421142  } 
  • trunk/loci/formats/FormatHandler.java

    r2655 r2687  
    2525package loci.formats; 
    2626 
     27import java.io.IOException; 
    2728import java.util.Vector; 
    2829 
     
    132133  public String[] getSuffixes() { return suffixes; } 
    133134 
     135  /* @see IFormatHandler#setId(String) */ 
     136  public void setId(String id) throws FormatException, IOException { 
     137    setId(id, false); 
     138  } 
     139 
    134140  // -- StatusReporter API methods -- 
    135141 
  • trunk/loci/formats/FormatReader.java

    r2674 r2687  
    180180  // -- IFormatReader API methods -- 
    181181 
    182   /* @see IFormatReader#isThisType(byte[]) */ 
    183   public abstract boolean isThisType(byte[] block); 
    184  
    185182  /* @see IFormatReader#getImageCount() */ 
    186183  public int getImageCount() { 
    187184    return core.imageCount[series]; 
    188   } 
    189  
    190   /* @see IFormatReader#setId(String) */ 
    191   public void setId(String id) throws FormatException, IOException { 
    192     setId(id, false);  
    193   } 
    194  
    195   /* @see IFormatReader#setId(String, boolean) */ 
    196   public void setId(String id, boolean force)  
    197     throws FormatException, IOException 
    198   { 
    199     if (!id.equals(currentId) || force) initFile(id); 
    200185  } 
    201186 
     
    264249  /* @see IFormatReader#getThumbSizeX() */ 
    265250  public int getThumbSizeX() { 
    266     if (core.thumbSizeX[series] == 0) {  
     251    if (core.thumbSizeX[series] == 0) { 
    267252      int sx = getSizeX(); 
    268253      int sy = getSizeY(); 
    269254      core.thumbSizeX[series] = 
    270255        sx > sy ? THUMBNAIL_DIMENSION : sx * THUMBNAIL_DIMENSION / sy; 
    271     }  
    272     return core.thumbSizeX[series];  
     256    } 
     257    return core.thumbSizeX[series]; 
    273258  } 
    274259 
    275260  /* @see IFormatReader#getThumbSizeY() */ 
    276261  public int getThumbSizeY() { 
    277     if (core.thumbSizeY[series] == 0) {  
     262    if (core.thumbSizeY[series] == 0) { 
    278263      int sx = getSizeX(); 
    279264      int sy = getSizeY(); 
    280265      core.thumbSizeY[series] = 
    281266        sy > sx ? THUMBNAIL_DIMENSION : sy * THUMBNAIL_DIMENSION / sx; 
    282     }  
    283     return core.thumbSizeY[series];  
     267    } 
     268    return core.thumbSizeY[series]; 
    284269  } 
    285270 
     
    308293    return core.interleaved[series]; 
    309294  } 
    310  
    311   /* @see IFormatReader#openImage(int) */ 
    312   public abstract BufferedImage openImage(int no) 
    313     throws FormatException, IOException; 
    314  
    315   /* @see IFormatReader#openBytes(int) */ 
    316   public abstract byte[] openBytes(int no) 
    317     throws FormatException, IOException; 
    318295 
    319296  /* @see IFormatReader#openBytes(int, byte[]) */ 
     
    352329  } 
    353330 
    354   /* @see IFormatReader#close() */ 
    355   public void close() throws IOException { 
    356     if (in != null) in.close(); 
    357     in = null; 
    358     currentId = null; 
    359   } 
    360  
    361331  /* @see IFormatReader#getSeriesCount() */ 
    362332  public int getSeriesCount() { 
     
    482452  } 
    483453 
     454  // -- IFormatHandler API methods -- 
     455 
     456  /* @see IFormatHandler#setId(String, boolean) */ 
     457  public void setId(String id, boolean force) 
     458    throws FormatException, IOException 
     459  { 
     460    if (!id.equals(currentId) || force) initFile(id); 
     461  } 
     462 
     463  /* @see IFormatHandler#close() */ 
     464  public void close() throws IOException { 
     465    if (in != null) in.close(); 
     466    in = null; 
     467    currentId = null; 
     468  } 
     469 
    484470  // -- Deprecated IFormatReader API methods -- 
    485471 
    486472  /** @deprecated Replaced by {@link #getImageCount()} */ 
    487473  public int getImageCount(String id) throws FormatException, IOException { 
    488     if (!id.equals(currentId)) setId(id); 
     474    setId(id); 
    489475    return getImageCount(); 
    490476  } 
     
    497483  /** @deprecated Replaced by {@link #getSizeX()} */ 
    498484  public int getSizeX(String id) throws FormatException, IOException { 
    499     if (!id.equals(currentId)) setId(id); 
     485    setId(id); 
    500486    return core.sizeX[series]; 
    501487  } 
     
    503489  /** @deprecated Replaced by {@link #getSizeY()} */ 
    504490  public int getSizeY(String id) throws FormatException, IOException { 
    505     if (!id.equals(currentId)) setId(id); 
     491    setId(id); 
    506492    return core.sizeY[series]; 
    507493  } 
     
    509495  /** @deprecated Replaced by {@link #getSizeZ()} */ 
    510496  public int getSizeZ(String id) throws FormatException, IOException { 
    511     if (!id.equals(currentId)) setId(id); 
     497    setId(id); 
    512498    return core.sizeZ[series]; 
    513499  } 
     
    515501  /** @deprecated Replaced by {@link #getSizeC()} */ 
    516502  public int getSizeC(String id) throws FormatException, IOException { 
    517     if (!id.equals(currentId)) setId(id); 
     503    setId(id); 
    518504    return core.sizeC[series]; 
    519505  } 
     
    521507  /** @deprecated Replaced by {@link #getSizeT()} */ 
    522508  public int getSizeT(String id) throws FormatException, IOException { 
    523     if (!id.equals(currentId)) setId(id); 
     509    setId(id); 
    524510    return core.sizeT[series]; 
    525511  } 
     
    527513  /** @deprecated Replaced by {@link #getPixelType()} */ 
    528514  public int getPixelType(String id) throws FormatException, IOException { 
    529     if (!id.equals(currentId)) setId(id); 
     515    setId(id); 
    530516    return core.pixelType[series]; 
    531517  } 
     
    546532    throws FormatException, IOException 
    547533  { 
    548     if (!id.equals(currentId)) setId(id); 
     534    setId(id); 
    549535    if (core.cLengths[series] == null) { 
    550536      core.cLengths[series] = new int[] {core.sizeC[series]}; 
     
    557543    throws FormatException, IOException 
    558544  { 
    559     if (!id.equals(currentId)) setId(id); 
     545    setId(id); 
    560546    if (core.cTypes[series] == null) { 
    561547      core.cTypes[series] = new String[] {FormatTools.CHANNEL}; 
     
    580566  /** @deprecated Replaced by {@link #isLittleEndian()} */ 
    581567  public boolean isLittleEndian(String id) throws FormatException, IOException { 
    582     if (!id.equals(currentId)) setId(id); 
     568    setId(id); 
    583569    return isLittleEndian(); 
    584570  } 
     
    587573  public String getDimensionOrder(String id) throws FormatException, IOException 
    588574  { 
    589     if (!id.equals(currentId)) setId(id); 
     575    setId(id); 
    590576    return core.currentOrder[series]; 
    591577  } 
     
    593579  /** @deprecated Replaced by {@link #isOrderCertain()} */ 
    594580  public boolean isOrderCertain(String id) throws FormatException, IOException { 
    595     if (!id.equals(currentId)) setId(id); 
     581    setId(id); 
    596582    return core.orderCertain[series]; 
    597583  } 
     
    608594    throws FormatException, IOException 
    609595  { 
    610     if (!id.equals(currentId)) setId(id); 
     596    setId(id); 
    611597    return isInterleaved(subC); 
    612598  } 
     
    616602    throws FormatException, IOException 
    617603  { 
    618     if (!id.equals(currentId)) setId(id); 
     604    setId(id); 
    619605    return openImage(no); 
    620606  } 
     
    624610    throws FormatException, IOException 
    625611  { 
    626     if (!id.equals(currentId)) setId(id); 
     612    setId(id); 
    627613    return openBytes(no); 
    628614  } 
     
    659645  /** @deprecated Replaced by {@link #getSeriesCount()} */ 
    660646  public int getSeriesCount(String id) throws FormatException, IOException { 
    661     if (!id.equals(currentId)) setId(id); 
     647    setId(id); 
    662648    return 1; 
    663649  } 
     
    673659  /** @deprecated Replaced by {@link #getSeries()} */ 
    674660  public int getSeries(String id) throws FormatException, IOException { 
    675     if (!id.equals(currentId)) setId(id); 
     661    setId(id); 
    676662    return series; 
    677663  } 
     
    679665  /** @deprecated Replaced by {@link #getUsedFiles()} */ 
    680666  public String[] getUsedFiles(String id) throws FormatException, IOException { 
    681     if (!id.equals(currentId)) setId(id); 
     667    setId(id); 
    682668    return new String[] {id}; 
    683669  } 
     
    687673    throws FormatException, IOException 
    688674  { 
    689     if (!id.equals(currentId)) setId(id); 
     675    setId(id); 
    690676    return FormatTools.getIndex(this, z, c, t); 
    691677  } 
     
    695681    throws FormatException, IOException 
    696682  { 
    697     if (!id.equals(currentId)) setId(id); 
     683    setId(id); 
    698684    return FormatTools.getZCTCoords(this, index); 
    699685  } 
     
    703689    throws FormatException, IOException 
    704690  { 
    705     if (!id.equals(currentId)) setId(id); 
     691    setId(id); 
    706692    return getMeta(field); 
    707693  } 
     
    709695  /** @deprecated Replaced by {@link #getMetadata()} */ 
    710696  public Hashtable getMetadata(String id) throws FormatException, IOException { 
    711     if (!id.equals(currentId)) setId(id); 
     697    setId(id); 
    712698    return metadata; 
    713699  } 
     
    717703    throws FormatException, IOException 
    718704  { 
    719     if (!id.equals(currentId)) setId(id); 
     705    setId(id); 
    720706    return core; 
    721707  } 
     
    725711    throws FormatException, IOException 
    726712  { 
    727     if (!id.equals(currentId)) setId(id); 
     713    setId(id); 
    728714    return metadataStore; 
    729715  } 
     
    733719    throws FormatException, IOException 
    734720  { 
    735     if (!id.equals(currentId)) setId(id); 
     721    setId(id); 
    736722    return getMetadataStore().getRoot(); 
    737723  } 
  • trunk/loci/formats/FormatTools.java

    r2672 r2687  
    600600    String in = args[0]; 
    601601    String out = args[1]; 
    602     System.out.print(in + " -> " + out + " "); 
    603602 
    604603    ImageReader reader = new ImageReader(); 
    605604    reader.setId(in); 
     605    writer.setId(out); 
     606 
     607    // check file formats 
     608    System.out.print("Input format: "); 
     609    System.out.println("[" + reader.getFormat() + "]"); 
     610    System.out.print("Output format: "); 
     611    System.out.println("[" + writer.getFormat() + "]"); 
     612 
     613    // convert file 
     614    System.out.print(in + " -> " + out + " "); 
    606615 
    607616    long start = System.currentTimeMillis(); 
    608     int num = reader.getImageCount(); 
     617    int num = writer.canDoStacks() ? reader.getImageCount() : 1; 
    609618    long mid = System.currentTimeMillis(); 
    610619    long read = 0, write = 0; 
     
    613622      Image image = reader.openImage(i); 
    614623      long m = System.currentTimeMillis(); 
    615       writer.saveImage(out, image, i == num - 1); 
     624      writer.saveImage(image, i == num - 1); 
    616625      long e = System.currentTimeMillis(); 
    617626      System.out.print("."); 
  • trunk/loci/formats/FormatWriter.java

    r2655 r2687  
    4848  protected String compression; 
    4949 
     50  /** Whether the current file has been prepped for writing. */ 
     51  protected boolean initialized; 
     52 
    5053  // -- Constructors -- 
    5154 
     
    6063  // -- IFormatWriter API methods -- 
    6164 
    62   /* @see IFormatWriter#saveImage(String, Image, boolean) */ 
    63   public abstract void saveImage(String id, Image image, boolean last) 
    64     throws FormatException, IOException; 
     65  /* @see IFormatWriter#saveBytes(byte[], boolean) */ 
     66  public void saveBytes(byte[] bytes, boolean last) 
     67    throws FormatException, IOException 
     68  { 
     69    throw new FormatException("Not implemented yet."); 
     70  } 
    6571 
    66   /** Reports whether the writer can save multiple images to a single file. */ 
    67   public abstract boolean canDoStacks(String id); 
     72  /* @see IFormatWriter#canDoStacks() */ 
     73  public boolean canDoStacks() { return false; } 
    6874 
    69   /** Sets the color model. */ 
     75  /* @see IFormatWriter#setColorModel(ColorModel) */ 
    7076  public void setColorModel(ColorModel model) { cm = model; } 
    7177 
    72   /** Gets the color model. */ 
     78  /* @see IFormatWriter#getColorModel() */ 
    7379  public ColorModel getColorModel() { return cm; } 
    7480 
    75   /** Sets the frames per second to use when writing. */ 
     81  /* @see IFormatWriter#setFramesPerSecond(int) */ 
    7682  public void setFramesPerSecond(int rate) { fps = rate; } 
    7783 
    78   /** Gets the frames per second to use when writing. */ 
     84  /* @see IFormatWriter#getFramesPerSecond() */ 
    7985  public int getFramesPerSecond() { return fps; } 
    8086 
    81   /** Get the available compression types. */ 
     87  /* @see IFormatWriter#getCompressionTypes() */ 
    8288  public String[] getCompressionTypes() { return compressionTypes; } 
    8389 
    84   /** Set the current compression type. */ 
     90  /* @see IFormatWriter#setCompression(compress) */ 
    8591  public void setCompression(String compress) throws FormatException { 
    8692    // check that this is a valid type 
     
    94100  } 
    95101 
    96   /* @see IFormatWriter#getPixelTypes(String) */ 
    97   public int[] getPixelTypes(String id) throws FormatException, IOException { 
     102  /* @see IFormatWriter#getPixelTypes() */ 
     103  public int[] getPixelTypes() { 
    98104    return new int[] {FormatTools.UINT8, FormatTools.UINT16, 
    99105      FormatTools.UINT32, FormatTools.FLOAT}; 
    100106  } 
    101107 
    102   /* @see IFormatWriter#isSupportedType(String, int) */ 
    103   public boolean isSupportedType(String id, int type) 
    104     throws FormatException, IOException 
    105   { 
    106     int[] types = getPixelTypes(id); 
     108  /* @see IFormatWriter#isSupportedType(int) */ 
     109  public boolean isSupportedType(int type) { 
     110    int[] types = getPixelTypes(); 
    107111    for (int i=0; i<types.length; i++) { 
    108112      if (type == types[i]) return true; 
     
    118122  } 
    119123 
     124  // -- IFormatHandler API methods -- 
     125 
     126  /* @see IFormatHandler#setId(String, boolean) */ 
     127  public void setId(String id, boolean force) 
     128    throws FormatException, IOException 
     129  { 
     130    if (id.equals(currentId) && !force) return; 
     131    close(); 
     132    currentId = id; 
     133    initialized = false; 
     134  } 
     135 
    120136  // -- Deprecated IFormatWriter API methods -- 
    121137 
    122   /** @deprecated Replaced by {@link #saveImage(String, Image, boolean)} */ 
     138  /** @deprecated Replaced by {@link #saveImage(Image, boolean)} */ 
     139  public void saveImage(String id, Image image, boolean last) 
     140    throws FormatException, IOException 
     141  { 
     142    setId(id); 
     143    saveImage(image, last); 
     144  } 
     145 
     146  /** @deprecated Replaced by {@link #canDoStacks()} */ 
     147  public boolean canDoStacks(String id) throws FormatException { 
     148    try { 
     149      setId(id); 
     150    } 
     151    catch (IOException exc) { 
     152      // NB: should never happen 
     153      throw new FormatException(exc); 
     154    } 
     155    return canDoStacks(id); 
     156  } 
     157 
     158  /** @deprecated Replaced by {@link #getPixelTypes()} */ 
     159  public int[] getPixelTypes(String id) throws FormatException, IOException { 
     160    setId(id); 
     161    return getPixelTypes(id); 
     162  } 
     163 
     164  /** @deprecated Replaced by {@link #isSupportedType(int type)} */ 
     165  public boolean isSupportedType(String id, int type) 
     166    throws FormatException, IOException 
     167  { 
     168    setId(id); 
     169    return isSupportedType(type); 
     170  } 
     171 
     172  /** @deprecated Replaced by {@link #saveImage(Image, boolean)} */ 
    123173  public void save(String id, Image image, boolean last) 
    124174    throws FormatException, IOException 
    125175  { 
    126     saveImage(id, image, last); 
     176    setId(id); 
     177    saveImage(image, last); 
    127178  } 
    128179 
  • trunk/loci/formats/IFormatHandler.java

    r2538 r2687  
    2525package loci.formats; 
    2626 
     27import java.io.IOException; 
     28 
    2729/** Interface for all biological file format readers and writers. */ 
    2830public interface IFormatHandler extends StatusReporter { 
     
    4446  String[] getSuffixes(); 
    4547 
     48  /** Sets the current file name. */ 
     49  void setId(String id) throws FormatException, IOException; 
     50 
     51  /** 
     52   * Sets the current file name. 
     53   * @param force If set, the handler will be re-initialized no matter what. 
     54   */ 
     55  void setId(String id, boolean force) throws FormatException, IOException; 
     56 
     57  /** Closes currently open file(s) and frees allocated memory. */ 
     58  void close() throws IOException; 
     59 
    4660} 
  • trunk/loci/formats/IFormatReader.java

    r2674 r2687  
    3434  /** Checks if the given block is a valid header for this file format. */ 
    3535  boolean isThisType(byte[] block); 
    36  
    37   /** Sets the current file name. */ 
    38   void setId(String id) throws FormatException, IOException; 
    39  
    40   /**  
    41    * Sets the current file name.   
    42    * If 'force' is set, the reader will be re-initialized no matter what. 
    43    */ 
    44   void setId(String id, boolean force) throws FormatException, IOException; 
    4536 
    4637  /** Determines the number of images in the current file. */ 
     
    143134  boolean isInterleaved(int subC); 
    144135 
    145   /** Obtains the specified image from the current file. */ 
    146   BufferedImage openImage(int no) 
    147     throws FormatException, IOException; 
    148  
    149136  /** 
    150137   * Obtains the specified image from the current file as a byte array. 
     
    165152    throws FormatException, IOException; 
    166153 
     154  /** Obtains the specified image from the current file. */ 
     155  BufferedImage openImage(int no) 
     156    throws FormatException, IOException; 
     157 
     158  /** 
     159   * Obtains a thumbnail for the specified image from the current file, 
     160   * as a byte array. 
     161   */ 
     162  byte[] openThumbBytes(int no) throws FormatException, IOException; 
     163 
    167164  /** Obtains a thumbnail for the specified image from the current file. */ 
    168165  BufferedImage openThumbImage(int no) 
     
    170167 
    171168  /** 
    172    * Obtains a thumbnail for the specified image from the current file, 
    173    * as a byte array. 
    174    */ 
    175   byte[] openThumbBytes(int no) throws FormatException, IOException; 
    176  
    177   /** 
    178169   * Closes the currently open file. If the flag is set, this is all that 
    179    * happens; if unset, it is equivalent to calling close(). 
     170   * happens; if unset, it is equivalent to calling 
     171   * {@link IFormatHandler#close()}. 
    180172   */ 
    181173  void close(boolean fileOnly) throws IOException; 
    182  
    183   /** 
    184    * Closes the currently open file and frees memory 
    185    * allocated by this reader. 
    186    */ 
    187   void close() throws IOException; 
    188174 
    189175  /** Gets the number of series in this file. */ 
  • trunk/loci/formats/IFormatWriter.java

    r2682 r2687  
    3333 
    3434  /** 
    35    * Saves the given image to the specified (possibly already open) file. 
     35   * Saves the given image to the current file. 
    3636   * If this image is the last one in the file, the last flag must be set. 
    3737   */ 
    38   void saveImage(String id, Image image, boolean last) 
     38  void saveImage(Image image, boolean last) throws FormatException, IOException; 
     39 
     40  /** 
     41   * Saves the given byte array to the current file. 
     42   * If this is the last array to be written, the last flag must be set. 
     43   */ 
     44  void saveBytes(byte[] bytes, boolean last) 
    3945    throws FormatException, IOException; 
    4046 
    41   /** 
    42    * Saves the given byte array to the specified (possibly already open) file. 
    43    * If this is the last array to be written, the last flag must be set. 
    44    */ 
    45   void saveBytes(String id, byte[] bytes, boolean last) 
    46     throws FormatException, IOException; 
    47  
    48   /** Closes open files. */ 
    49   void close() throws FormatException, IOException; 
    50  
    5147  /** Reports whether the writer can save multiple images to a single file. */ 
    52   boolean canDoStacks(String id) throws FormatException; 
     48  boolean canDoStacks(); 
    5349 
    5450  /** Sets the color model. */ 
     
    6864 
    6965  /** Gets the supported pixel types. */ 
    70   int[] getPixelTypes(String id) throws FormatException, IOException; 
     66  int[] getPixelTypes(); 
    7167 
    7268  /** Checks if the given pixel type is supported. */ 
    73   boolean isSupportedType(String id, int type) 
    74     throws FormatException, IOException; 
     69  boolean isSupportedType(int type); 
    7570 
    7671  /** Sets the current compression type. */ 
     
    8277  // -- Deprecated API methods -- 
    8378 
    84   /** @deprecated Replaced by {@link #saveImage(String, Image, boolean)} */ 
     79  /** @deprecated Replaced by {@link #saveImage(Image, boolean)} */ 
     80  void saveImage(String id, Image image, boolean last) 
     81    throws FormatException, IOException; 
     82 
     83  /** @deprecated Replaced by {@link #canDoStacks()} */ 
     84  boolean canDoStacks(String id) throws FormatException; 
     85 
     86  /** @deprecated Replaced by {@link #getPixelTypes()} */ 
     87  int[] getPixelTypes(String id) throws FormatException, IOException; 
     88 
     89  /** @deprecated Replaced by {@link #isSupportedType(int type)} */ 
     90  boolean isSupportedType(String id, int type) 
     91    throws FormatException, IOException; 
     92 
     93  /** @deprecated Replaced by {@link #saveImage(Image, boolean)} */ 
    8594  void save(String id, Image image, boolean last) 
    8695    throws FormatException, IOException; 
  • trunk/loci/formats/ImageReader.java

    r2674 r2687  
    163163  } 
    164164 
    165   /* @see IFormatReader#setId(String) */ 
    166   public void setId(String id) throws FormatException, IOException { 
    167     getReader(id).setId(id); 
    168   } 
    169  
    170   /* @see IFormatReader#setId(String, boolean) */ 
    171   public void setId(String id, boolean force) 
    172     throws FormatException, IOException 
    173   { 
    174     getReader(id).setId(id, force); 
    175   } 
    176  
    177165  /* @see IFormatReader#getImageCount() */ 
    178166  public int getImageCount() { 
     
    357345  public void close(boolean fileOnly) throws IOException { 
    358346    for (int i=0; i<readers.length; i++) readers[i].close(fileOnly); 
    359   } 
    360  
    361   /* @see IFormatReader#close() */ 
    362   public void close() throws IOException { 
    363     for (int i=0; i<readers.length; i++) readers[i].close(); 
    364347  } 
    365348 
     
    432415 
    433416  /* @see IFormatHandler#getFormat() */ 
    434   public String getFormat() { return "image"; } 
     417  public String getFormat() { return getReader().getFormat(); } 
    435418 
    436419  /* @see IFormatHandler#getSuffixes() */ 
     
    449432  } 
    450433 
     434  /* @see IFormatHandler#setId(String) */ 
     435  public void setId(String id) throws FormatException, IOException { 
     436    getReader(id).setId(id); 
     437  } 
     438 
     439  /* @see IFormatHandler#setId(String, boolean) */ 
     440  public void setId(String id, boolean force) 
     441    throws FormatException, IOException 
     442  { 
     443    getReader(id).setId(id, force); 
     444  } 
     445 
     446  /* @see IFormatHandler#close() */ 
     447  public void close() throws IOException { 
     448    for (int i=0; i<readers.length; i++) readers[i].close(); 
     449  } 
     450 
    451451  // -- StatusReporter API methods -- 
    452452 
  • trunk/loci/formats/ImageWriter.java

    r2682 r2687  
    7575 
    7676  /** Name of current file. */ 
    77   private String currentId; 
     77  protected String currentId; 
    7878 
    7979  /** Current form index. */ 
     
    138138  } 
    139139 
     140  /** Gets the writer used to save the current file. */ 
     141  public IFormatWriter getWriter() { 
     142    return writers[current]; 
     143  } 
     144 
    140145  /** Gets the file format writer instance matching the given class. */ 
    141146  public IFormatWriter getWriter(Class c) { 
     
    155160  // -- IFormatWriter API methods -- 
    156161 
    157   /* @see IFormatWriter#saveBytes(String, byte[], boolean) */ 
    158   public void saveBytes(String id, byte[] bytes, boolean last) 
    159     throws FormatException, IOException 
    160   { 
    161     getWriter(id).saveBytes(id, bytes, last);  
    162   } 
    163  
    164   /* @see IFormatWriter#saveImage(String, Image, boolean) */ 
    165   public void saveImage(String id, Image image, boolean last) 
    166     throws FormatException, IOException 
    167   { 
    168     getWriter(id).saveImage(id, image, last); 
    169   } 
    170  
    171   /* @see IFormatWriter#close() */ 
    172   public void close() throws FormatException, IOException { 
    173     getWriter(currentId).close(); 
    174   } 
    175  
    176   /* @see IFormatWriter#canDoStacks(String) */ 
    177   public boolean canDoStacks(String id) throws FormatException { 
    178     return getWriter(id).canDoStacks(id); 
     162  /* @see IFormatWriter#saveBytes(byte[], boolean) */ 
     163  public void saveBytes(byte[] bytes, boolean last) 
     164    throws FormatException, IOException 
     165  { 
     166    getWriter().saveBytes(bytes, last); 
     167  } 
     168 
     169  /* @see IFormatWriter#saveImage(Image, boolean) */ 
     170  public void saveImage(Image image, boolean last) 
     171    throws FormatException, IOException 
     172  { 
     173    getWriter().saveImage(image, last); 
     174  } 
     175 
     176  /* @see IFormatWriter#canDoStacks() */ 
     177  public boolean canDoStacks() { 
     178    return getWriter().canDoStacks(); 
    179179  } 
    180180 
     
    218218  } 
    219219 
    220   /* @see IFormatWriter#getPixelTypes(String) */ 
    221   public int[] getPixelTypes(String id) throws FormatException, IOException { 
    222     return getWriter(id).getPixelTypes(id); 
    223   } 
    224  
    225   /* @see IFormatWriter#isSupportedType(String, int) */ 
    226   public boolean isSupportedType(String id, int type) 
    227     throws FormatException, IOException 
    228   { 
    229     return getWriter(id).isSupportedType(id, type); 
     220  /* @see IFormatWriter#getPixelTypes() */ 
     221  public int[] getPixelTypes() { 
     222    return getWriter().getPixelTypes(); 
     223  } 
     224 
     225  /* @see IFormatWriter#isSupportedType(int) */ 
     226  public boolean isSupportedType(int type) { 
     227    return getWriter().isSupportedType(type); 
    230228  } 
    231229 
     
    250248    throws FormatException, IOException 
    251249  { 
    252     if (args.length > 1) { 
    253       // check file format 
    254       System.out.print("Checking file format "); 
    255       System.out.println("[" + getFormat(args[1]) + "]"); 
    256     } 
    257250    return FormatTools.testConvert(this, args); 
    258251  } 
     
    277270 
    278271  /* @see IFormatHandler#getFormat() */ 
    279   public String getFormat() { return "image"; } 
     272  public String getFormat() { return getWriter().getFormat(); } 
    280273 
    281274  /* @see IFormatHandler#getSuffixes() */ 
     
    294287  } 
    295288 
     289  /* @see IFormatHandler#setId(String) */ 
     290  public void setId(String id) throws FormatException, IOException { 
     291    getWriter(id).setId(id); 
     292  } 
     293 
     294  /* @see IFormatHandler#setId(String, boolean) */ 
     295  public void setId(String id, boolean force) 
     296    throws FormatException, IOException 
     297  { 
     298    getWriter(id).setId(id, force); 
     299  } 
     300 
     301  /* @see IFormatHandler#close() */ 
     302  public void close() throws IOException { 
     303    for (int i=0; i<writers.length; i++) writers[i].close(); 
     304  } 
     305 
    296306  // -- StatusReporter API methods -- 
    297307 
     
    320330  // -- Deprecated IFormatWriter API methods -- 
    321331 
    322   /** @deprecated Replaced by {@link #saveImage(String, Image, boolean)} */ 
     332  /** @deprecated Replaced by {@link #saveImage(Image, boolean)} */ 
     333  public void saveImage(String id, Image image, boolean last) 
     334    throws FormatException, IOException 
     335  { 
     336    setId(id); 
     337    saveImage(image, last); 
     338  } 
     339 
     340  /** @deprecated Replaced by {@link #canDoStacks()} */ 
     341  public boolean canDoStacks(String id) throws FormatException { 
     342    try { 
     343      setId(id); 
     344    } 
     345    catch (IOException exc) { 
     346      // NB: should never happen 
     347      throw new FormatException(exc); 
     348    } 
     349    return canDoStacks(id); 
     350  } 
     351 
     352  /** @deprecated Replaced by {@link #getPixelTypes()} */ 
     353  public int[] getPixelTypes(String id) throws FormatException, IOException { 
     354    setId(id); 
     355    return getPixelTypes(id); 
     356  } 
     357 
     358  /** @deprecated Replaced by {@link #isSupportedType(int type)} */ 
     359  public boolean isSupportedType(String id, int type) 
     360    throws FormatException, IOException 
     361  { 
     362    setId(id); 
     363    return isSupportedType(type); 
     364  } 
     365 
     366  /** @deprecated Replaced by {@link #saveImage(Image, boolean)} */ 
    323367  public void save(String id, Image image, boolean last) 
    324368    throws FormatException, IOException 
    325369  { 
    326     getWriter(id).save(id, image, last); 
     370    setId(id); 
     371    saveImage(image, last); 
    327372  } 
    328373 
  • trunk/loci/formats/gui/ImageViewer.java

    r2601 r2687  
    234234    wait(true); 
    235235    try { 
    236       //myWriter.save(id, images); 
    237       boolean stack = myWriter.canDoStacks(id); 
     236      myWriter.setId(id); 
     237      boolean stack = myWriter.canDoStacks(); 
    238238      ProgressMonitor progress = new ProgressMonitor(this, 
    239239        "Saving " + id, null, 0, stack ? images.length : 1); 
     
    243243          progress.setProgress(i); 
    244244          boolean canceled = progress.isCanceled(); 
    245           myWriter.saveImage(id, images[i], i == images.length - 1 || canceled); 
     245          myWriter.saveImage(images[i], i == images.length - 1 || canceled); 
    246246          if (canceled) break; 
    247247        } 
     
    250250      else { 
    251251        // save current image only 
    252         myWriter.saveImage(id, getImage(), true); 
     252        myWriter.saveImage(getImage(), true); 
    253253        progress.setProgress(1); 
    254254      } 
  • trunk/loci/formats/in/AVIReader.java

    r2641 r2687  
    6868  public AVIReader() { super("Audio Video Interleave", "avi"); } 
    6969 
    70   // -- FormatReader API methods -- 
     70  // -- AVIReader API methods -- 
     71 
     72  /** Reads a 4-byte String. */ 
     73  public String readStringBytes() throws IOException { 
     74    byte[] list = new byte[4]; 
     75    in.read(list); 
     76    return new String(list); 
     77  } 
     78 
     79  /** 
     80   * Throws a FormatException to apologize for the fact that 
     81   * AVI support is suboptimal. 
     82   */ 
     83  private void whine(String msg) throws FormatException { 
     84    throw new FormatException(msg); 
     85  } 
     86 
     87  // -- IFormatReader API methods -- 
    7188 
    7289  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    120137  } 
    121138 
    122   /** Initializes the given AVI file. */ 
     139  // -- Internal FormatReader API methods -- 
     140 
     141  /* @see loci.formats.FormatReader#initFile(String) */ 
    123142  protected void initFile(String id) throws FormatException, IOException { 
    124143    if (debug) debug("AVIReader.initFile(" + id + ")"); 
     
    439458  } 
    440459 
    441   // -- AVIReader API methods -- 
    442  
    443   /** Reads a 4-byte String. */ 
    444   public String readStringBytes() throws IOException { 
    445     byte[] list = new byte[4]; 
    446     in.read(list); 
    447     return new String(list); 
    448   } 
    449  
    450   /** 
    451    * Throws a FormatException to apologize for the fact that 
    452    * AVI support is suboptimal. 
    453    */ 
    454   private void whine(String msg) throws FormatException { 
    455     throw new FormatException(msg); 
    456   } 
    457  
    458460} 
  • trunk/loci/formats/in/AliconaReader.java

    r2673 r2687  
    4646  public AliconaReader() { super("Alicona AL3D", "al3d"); } 
    4747 
    48   // -- FormatReader API methods -- 
     48  // -- IFormatReader API methods -- 
    4949 
    5050  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    9292  } 
    9393 
    94   /** Initializes the given Alicona file. */ 
     94  // -- Internal FormatReader API methods -- 
     95 
     96  /* @see loci.formats.FormatReader#initFile(String) */ 
    9597  protected void initFile(String id) throws FormatException, IOException { 
    9698    if (debug) debug("AliconaReader.initFile(" + id + ")"); 
  • trunk/loci/formats/in/BMPReader.java

    r2636 r2687  
    6666  public BMPReader() { super("Windows Bitmap", "bmp"); } 
    6767 
    68   // -- FormatReader API methods -- 
     68  // -- IFormatReader API methods -- 
    6969 
    7070  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    7575    if (block[0] != 'B' || block[1] != 'M') return false; 
    7676    return true; 
     77  } 
     78 
     79  /* @see loci.formats.IFormatReader#openBytes(int) */ 
     80  public byte[] openBytes(int no) throws FormatException, IOException { 
     81    byte[] buf = new byte[core.sizeX[0] * core.sizeY[0] * core.sizeC[0]]; 
     82    return openBytes(no, buf); 
    7783  } 
    7884 
     
    131137  } 
    132138 
    133   /* @see loci.formats.IFormatReader#openBytes(int) */ 
    134   public byte[] openBytes(int no) throws FormatException, IOException { 
    135     byte[] buf = new byte[core.sizeX[0] * core.sizeY[0] * core.sizeC[0]]; 
    136     return openBytes(no, buf); 
    137   } 
    138  
    139139  /* @see loci.formats.IFormatReader#openImage(int) */ 
    140140  public BufferedImage openImage(int no) throws FormatException, IOException { 
     
    143143  } 
    144144 
    145   /** Initializes the given BMP file. */ 
     145  // -- Internel FormatReader API methods -- 
     146 
     147  /* @see loci.formats.FormatReader#initFile(String) */ 
    146148  protected void initFile(String id) throws FormatException, IOException { 
    147149    if (debug) debug("BMPReader.initFile(" + id + ")"); 
  • trunk/loci/formats/in/BaseTiffReader.java

    r2672 r2687  
    6767      core.imageCount[0] 
    6868    }; 
     69  } 
     70 
     71  // -- IFormatReader API methods -- 
     72 
     73  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     74  public boolean isThisType(byte[] block) { 
     75    return TiffTools.isValidHeader(block); 
     76  } 
     77 
     78  /* @see loci.formats.IFormatReader#getMetadataValue(String) */ 
     79  public Object getMetadataValue(String field) { 
     80    return getMeta(field); 
     81  } 
     82 
     83  /* @see loci.formats.FormatReader#openBytes(int) */ 
     84  public byte[] openBytes(int no) throws FormatException, IOException { 
     85    if (no < 0 || no >= getImageCount()) { 
     86      throw new FormatException("Invalid image number: " + no); 
     87    } 
     88 
     89    int bytesPerPixel = FormatTools.getBytesPerPixel(getPixelType()); 
     90    byte[] buf = new byte[getSizeX() * getSizeY() * bytesPerPixel * 
     91      getRGBChannelCount()]; 
     92    return openBytes(no, buf); 
     93  } 
     94 
     95  /* @see loci.formats.FormatReader#openBytes(int, byte[]) */ 
     96  public byte[] openBytes(int no, byte[] buf) 
     97    throws FormatException, IOException 
     98  { 
     99    if (no < 0 || no >= getImageCount()) { 
     100      throw new FormatException("Invalid image number: " + no); 
     101    } 
     102 
     103    TiffTools.getSamples(ifds[no], in, buf); 
     104    return swapIfRequired(buf); 
     105  } 
     106 
     107  /* @see loci.formats.IFormatReader#openImage(int) */ 
     108  public BufferedImage openImage(int no) throws FormatException, IOException { 
     109    if (no < 0 || no >= getImageCount()) { 
     110      throw new FormatException("Invalid image number: " + no); 
     111    } 
     112 
     113    return TiffTools.getImage(ifds[no], in); 
    69114  } 
    70115 
     
    683728  } 
    684729 
    685   // -- FormatReader API methods -- 
    686  
    687   /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
    688   public boolean isThisType(byte[] block) { 
    689     return TiffTools.isValidHeader(block); 
    690   } 
    691  
    692   /* @see loci.formats.IFormatReader#getMetadataValue(String) */ 
    693   public Object getMetadataValue(String field) { 
    694     return getMeta(field); 
    695   } 
    696  
    697   /* @see loci.formats.FormatReader#openBytes(int, byte[]) */ 
    698   public byte[] openBytes(int no, byte[] buf) 
    699     throws FormatException, IOException 
    700   { 
    701     if (no < 0 || no >= getImageCount()) { 
    702       throw new FormatException("Invalid image number: " + no); 
    703     } 
    704  
    705     TiffTools.getSamples(ifds[no], in, buf); 
    706     return swapIfRequired(buf); 
    707   } 
    708  
    709   /* @see loci.formats.FormatReader#openBytes(int) */ 
    710   public byte[] openBytes(int no) throws FormatException, IOException { 
    711     if (no < 0 || no >= getImageCount()) { 
    712       throw new FormatException("Invalid image number: " + no); 
    713     } 
    714  
    715     int bytesPerPixel = FormatTools.getBytesPerPixel(getPixelType()); 
    716     byte[] buf = new byte[getSizeX() * getSizeY() * bytesPerPixel * 
    717       getRGBChannelCount()]; 
    718     return openBytes(no, buf); 
    719   } 
    720  
    721   /* @see loci.formats.IFormatReader#openImage(int) */ 
    722   public BufferedImage openImage(int no) throws FormatException, IOException { 
    723     if (no < 0 || no >= getImageCount()) { 
    724       throw new FormatException("Invalid image number: " + no); 
    725     } 
    726  
    727     return TiffTools.getImage(ifds[no], in); 
    728   } 
    729  
    730   /** Initializes the given TIFF file. */ 
     730  // -- Internal FormatReader API methods -- 
     731 
     732  /* @see loci.formats.FormatReader#initFile(String) */ 
    731733  protected void initFile(String id) throws FormatException, IOException { 
    732734    if (debug) debug("BaseTiffReader.initFile(" + id + ")"); 
     
    762764      getExWave(i), 
    763765      getPhotometricInterpretation(i), 
    764       getMode(i), // aquisition mode 
     766      getMode(i), // acquisition mode 
    765767      null); 
    766768  } 
  • trunk/loci/formats/in/BioRadReader.java

    r2673 r2687  
    7373  public BioRadReader() { super("Bio-Rad PIC", "pic"); } 
    7474 
    75   // -- FormatReader API methods -- 
     75  // -- IFormatReader API methods -- 
    7676 
    7777  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    111111  } 
    112112 
    113   /** Initializes the given Bio-Rad file. */ 
     113  // -- Internal FormatReader API methods -- 
     114 
     115  /* @see loci.formats.FormatReader#initFile(String) */ 
    114116  protected void initFile(String id) throws FormatException, IOException { 
    115117    if (debug) debug("BioRadReader.initFile(" + id + ")"); 
     
    729731  } 
    730732 
    731   public String noteString(int n, int l, int s, int t, int x, int y, String p) { 
     733  // -- Helper methods -- 
     734 
     735  private String noteString(int n, int l, 
     736    int s, int t, int x, int y, String p) 
     737  { 
    732738    StringBuffer sb = new StringBuffer(100); 
    733739    sb.append("level="); 
  • trunk/loci/formats/in/DeltavisionReader.java

    r2673 r2687  
    8080  } 
    8181 
    82   // -- FormatReader API methods -- 
     82  // -- IFormatReader API methods -- 
    8383 
    8484  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    119119  } 
    120120 
    121   /** Initializes the given Deltavision file. */ 
     121  // -- Internal FormatReader API methods -- 
     122 
     123  /* @see loci.formats.FormatReader#initFile(String) */ 
    122124  protected void initFile(String id) throws FormatException, IOException { 
    123125    if (debug) debug("DeltavisionReader.initFile(" + id + ")"); 
     
    406408    store.setDefaultDisplaySettings(null); 
    407409  } 
     410 
     411  // -- Helper methods -- 
    408412 
    409413  /** 
     
    466470  } 
    467471 
     472  // -- Helper classes -- 
     473 
    468474  /** 
    469475   * This private class structure holds the details for the extended header 
  • trunk/loci/formats/in/DicomReader.java

    r2616 r2687  
    9696  } 
    9797 
    98   // -- FormatReader API methods -- 
     98  // -- IFormatReader API methods -- 
    9999 
    100100  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    134134  } 
    135135 
    136   /** Initializes the given DICOM file. */ 
     136  // -- Internal FormatReader API methods -- 
     137 
     138  /* @see loci.formats.FormatReader#initFile(String) */ 
    137139  protected void initFile(String id) throws FormatException, IOException { 
    138140    if (debug) debug("DicomReader.initFile(" + id + ")"); 
  • trunk/loci/formats/in/EPSReader.java

    r2636 r2687  
    5656  } 
    5757 
    58   // -- FormatReader API methods -- 
     58  // -- IFormatReader API methods -- 
    5959 
    6060  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    119119  } 
    120120 
    121   /** Initializes the given EPS file. */ 
     121  // -- Internal FormatReader API methods -- 
     122 
     123  /* @see loci.formats.FormatReader#initFile(String) */ 
    122124  protected void initFile(String id) throws FormatException, IOException { 
    123125    if (debug) debug("EPSReader.initFile(" + id + ")"); 
  • trunk/loci/formats/in/FluoviewReader.java

    r2672 r2687  
    6767  } 
    6868 
    69   // -- FormatReader API methods -- 
     69  // -- IFormatReader API methods -- 
    7070 
    7171  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
  • trunk/loci/formats/in/GIFReader.java

    r2616 r2687  
    130130  } 
    131131 
    132   // -- FormatReader API methods -- 
     132  // -- IFormatReader API methods -- 
    133133 
    134134  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    171171  } 
    172172 
    173   /** Initializes the given GIF file. */ 
     173  // -- Internal FormatReader API methods -- 
     174 
     175  /* @see loci.formats.FormatReader#initFile(String) */ 
    174176  protected void initFile(String id) throws FormatException, IOException { 
    175177    if (debug) debug("GIFReader.initFile(" + id + ")"); 
  • trunk/loci/formats/in/GatanReader.java

    r2673 r2687  
    5959  public GatanReader() { super("Gatan Digital Micrograph", "dm3"); } 
    6060 
    61   // -- FormatReader API methods -- 
     61  // -- IFormatReader API methods -- 
    6262 
    6363  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    103103  } 
    104104 
    105   /** Initializes the given Gatan file. */ 
     105  // -- Internal FormatReader API methods -- 
     106 
     107  /* @see loci.formats.FormatReader#initFile(String) */ 
    106108  protected void initFile(String id) throws FormatException, IOException { 
    107109    if (debug) debug("GatanReader.initFile(" + id + ")"); 
     
    238240    store.setObjective(null, null, null, null, 
    239241      mag == null ? null : new Float(mag), null, null); 
    240  
    241   } 
    242  
    243   // -- Helper method -- 
     242  } 
     243 
     244  // -- Helper methods -- 
    244245 
    245246  /** 
     
    249250   * http://www-hrem.msm.cam.ac.uk/~cbb/info/dmformat/ 
    250251   */ 
    251   public void parseTags(int numTags, String parent) throws IOException { 
     252  private void parseTags(int numTags, String parent) throws IOException { 
    252253    byte[] temp = new byte[4]; 
    253254    for (int i=0; i<numTags; i++) { 
  • trunk/loci/formats/in/GelReader.java

    r2601 r2687  
    5454  } 
    5555 
    56   // -- FormatReader API methods -- 
     56  // -- IFormatReader API methods -- 
    5757 
    5858  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
  • trunk/loci/formats/in/ICSReader.java

    r2673 r2687  
    8888  } 
    8989 
    90   // -- FormatReader API methods -- 
     90  // -- IFormatReader API methods -- 
    9191 
    9292  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    175175  } 
    176176 
    177   /* @see loci.formats.IFormatReader#close() */ 
     177  // -- IFormatHandler API methods -- 
     178 
     179  /* @see loci.formats.IFormatHandler#close() */ 
    178180  public void close() throws IOException { 
    179181    super.close(); 
     
    184186  } 
    185187 
    186   /** Initializes the given ICS file. */ 
     188  // -- Internal FormatReader API methods -- 
     189 
     190  /* @see loci.formats.FormatReader#initFile(String) */ 
    187191  protected void initFile(String id) throws FormatException, IOException { 
    188192    if (debug) debug("ICSReader.initFile(" + id + ")"); 
  • trunk/loci/formats/in/IPLabReader.java

    r2616 r2687  
    5050  public IPLabReader() { super("IPLab", "ipl"); } 
    5151 
    52   // -- FormatReader API methods -- 
     52  // -- IFormatReader API methods -- 
    5353 
    5454  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    9696  } 
    9797 
    98   /** Initializes the given IPLab file. */ 
     98  // -- Internal FormatReader API methods -- 
     99 
     100  /* @see loci.formats.FormatReader#initFile(String) */ 
    99101  protected void initFile(String id) throws FormatException, IOException { 
    100102    if (debug) debug("IPLabReader.initFile(" + id + ")"); 
  • trunk/loci/formats/in/IPWReader.java

    r2673 r2687  
    7676  public IPWReader() { super("Image-Pro Workspace", "ipw"); } 
    7777 
    78   // -- FormatReader API methods -- 
     78  // -- IFormatReader API methods -- 
    7979 
    8080  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    151151  } 
    152152 
    153   /* @see loci.formats.IFormatReader#close() */ 
     153  // -- IFormatHandler API methods -- 
     154 
     155  /* @see loci.formats.IFormatHandler#close() */ 
    154156  public void close() throws IOException { 
    155157    super.close(); 
     
    164166      "entry", "documentName", "entryName"}; 
    165167    for (int i=0; i<vars.length; i++) r.setVar(vars[i], null); 
    166   } 
    167  
    168   /** Initializes the given IPW file. */ 
    169   protected void initFile(String id) throws FormatException, IOException { 
    170     if (debug) debug("IPWReader.initFile(" + id + ")"); 
    171     if (noPOI) throw new FormatException(NO_POI_MSG); 
    172  
    173     currentId = id; 
    174     metadata = new Hashtable(); 
    175     core = new CoreMetadata(1); 
    176     Arrays.fill(core.orderCertain, true); 
    177     getMetadataStore().createRoot(); 
    178  
    179     in = new RandomAccessStream(id); 
    180  
    181     pixels = new Hashtable(); 
    182     names = new Hashtable(); 
    183  
    184     try { 
    185       r.setVar("fis", in); 
    186       r.exec("fs = new POIFSFileSystem(fis)"); 
    187       r.exec("dir = fs.getRoot()"); 
    188       parseDir(0, r.getVar("dir")); 
    189       status("Populating metadata"); 
    190       initMetadata(); 
    191     } 
    192     catch (Throwable t) { 
    193       noPOI = true; 
    194       if (debug) t.printStackTrace(); 
    195     } 
    196168  } 
    197169 
     
    365337    for (int i=0; i<core.sizeC[0]; i++) { 
    366338      store.setLogicalChannel(i, null, null, null, null, null, null, null); 
     339    } 
     340  } 
     341 
     342  // -- Internal FormatReader API methods -- 
     343 
     344  /* @see loci.formats.FormatReader#initFile(String) */ 
     345  protected void initFile(String id) throws FormatException, IOException { 
     346    if (debug) debug("IPWReader.initFile(" + id + ")"); 
     347    if (noPOI) throw new FormatException(NO_POI_MSG); 
     348 
     349    currentId = id; 
     350    metadata = new Hashtable(); 
     351    core = new CoreMetadata(1); 
     352    Arrays.fill(core.orderCertain, true); 
     353    getMetadataStore().createRoot(); 
     354 
     355    in = new RandomAccessStream(id); 
     356 
     357    pixels = new Hashtable(); 
     358    names = new Hashtable(); 
     359 
     360    try { 
     361      r.setVar("fis", in); 
     362      r.exec("fs = new POIFSFileSystem(fis)"); 
     363      r.exec("dir = fs.getRoot()"); 
     364      parseDir(0, r.getVar("dir")); 
     365      status("Populating metadata"); 
     366      initMetadata(); 
     367    } 
     368    catch (Throwable t) { 
     369      noPOI = true; 
     370      if (debug) t.printStackTrace(); 
    367371    } 
    368372  } 
  • trunk/loci/formats/in/ImageIOReader.java

    r2672 r2687  
    5050  } 
    5151 
    52   // -- FormatReader API methods -- 
     52  // -- IFormatReader API methods -- 
    5353 
    5454  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    5656 
    5757  /* @see loci.formats.IFormatReader#openBytes(int) */ 
    58   public byte[] openBytes(int no) 
    59     throws FormatException, IOException 
    60   { 
     58  public byte[] openBytes(int no) throws FormatException, IOException { 
    6159    byte[] b = ImageTools.getBytes(openImage(no), false, no); 
    6260    int bytesPerChannel = core.sizeX[0] * core.sizeY[0]; 
     
    9088  public void close(boolean fileOnly) throws IOException { } 
    9189 
    92   /* @see loci.formats.IFormatReader#close() */ 
     90  // -- IFormatHandler API methods -- 
     91 
     92  /* @see loci.formats.IFormatHandler#close() */ 
    9393  public void close() throws IOException { } 
    9494 
    9595  // -- Internal FormatReader API methods -- 
    9696 
    97   /** Initializes the given file. */ 
     97  /* @see loci.formats.FormatReader#initFile(String) */ 
    9898  protected void initFile(String id) throws FormatException, IOException { 
    9999    if (debug) debug("ImageIOReader.initFile(" + id + ")"); 
  • trunk/loci/formats/in/ImageJReader.java

    r2672 r2687  
    7373  } 
    7474 
    75   // -- FormatReader API methods -- 
     75  // -- IFormatReader API methods -- 
    7676 
    7777  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    128128  public void close(boolean fileOnly) throws IOException { } 
    129129 
    130   /* @see loci.formats.IFormatReader#close() */ 
     130  // -- IFormatHandler API methods -- 
     131 
     132  /* @see loci.formats.IFormatHandler#close() */ 
    131133  public void close() throws IOException { } 
    132134 
    133135  // -- Internal FormatReader API methods -- 
    134136 
    135   /** Initializes the given file. */ 
     137  /* @see loci.formats.FormatReader#initFile(String) */ 
    136138  protected void initFile(String id) throws FormatException, IOException { 
    137139    if (debug) debug("ImageJReader.initFile(" + id + ")"); 
  • trunk/loci/formats/in/ImarisReader.java

    r2616 r2687  
    5656  public ImarisReader() { super("Bitplane Imaris", "ims"); } 
    5757 
    58   // -- FormatReader API methods -- 
    59  
    60   /** Initializes the given Imaris file. */ 
     58  // -- IFormatReader API methods -- 
     59 
     60  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     61  public boolean isThisType(byte[] block) { 
     62    return DataTools.bytesToInt(block, 0, 4, IS_LITTLE) == IMARIS_MAGIC_NUMBER; 
     63  } 
     64 
     65  /* @see loci.formats.IFormatReader#openBytes(int) */ 
     66  public byte[] openBytes(int no) throws FormatException, IOException { 
     67    byte[] buf = new byte[core.sizeX[0] * core.sizeY[0]]; 
     68    return openBytes(no, buf); 
     69  } 
     70 
     71  /* @see loci.formats.IFormatReader#openBytes(int, byte[]) */ 
     72  public byte[] openBytes(int no, byte[] buf) 
     73    throws FormatException, IOException 
     74  { 
     75    if (no < 0 || no >= getImageCount()) { 
     76      throw new FormatException("Invalid image number: " + no); 
     77    } 
     78    if (buf.length < core.sizeX[0] * core.sizeY[0]) { 
     79      throw new FormatException("Buffer too small."); 
     80    } 
     81 
     82    in.seek(offsets[no]); 
     83    int row = core.sizeY[0] - 1; 
     84    for (int i=0; i<core.sizeY[0]; i++) { 
     85      in.read(buf, row*core.sizeX[0], core.sizeX[0]); 
     86      row--; 
     87    } 
     88    return buf; 
     89  } 
     90 
     91  /* @see loci.formats.IFormatReader#openImage(int) */ 
     92  public BufferedImage openImage(int no) throws FormatException, IOException { 
     93    return ImageTools.makeImage(openBytes(no), core.sizeX[0], 
     94      core.sizeY[0], 1, false); 
     95  } 
     96 
     97  // -- IFormatHandler API methods -- 
     98 
     99  /* @see loci.formats.IFormatHandler#isThisType(String, boolean) */ 
     100  public boolean isThisType(String name, boolean open) { 
     101    if (!super.isThisType(name, open)) return false; // check extension 
     102    if (!open) return true; // not allowed to check the file contents 
     103    try { 
     104      RandomAccessStream ras = new RandomAccessStream(name); 
     105      byte[] b = new byte[4]; 
     106      ras.readFully(b); 
     107      ras.close(); 
     108      return isThisType(b); 
     109    } 
     110    catch (IOException e) { return false; } 
     111  } 
     112 
     113  // -- Internal FormatReader API methods -- 
     114 
     115  /* @see loci.formats.FormatReader#initFile(String) */ 
    61116  protected void initFile(String id) throws FormatException, IOException { 
    62117    if (debug) debug("ImarisReader.initFile(" + id + ")"); 
     
    169224  } 
    170225 
    171   // -- IFormatReader API methods -- 
    172  
    173   /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
    174   public boolean isThisType(byte[] block) { 
    175     return DataTools.bytesToInt(block, 0, 4, IS_LITTLE) == IMARIS_MAGIC_NUMBER; 
    176   } 
    177  
    178   /* @see loci.formats.IFormatReader#openBytes(int) */ 
    179   public byte[] openBytes(int no) throws FormatException, IOException { 
    180     byte[] buf = new byte[core.sizeX[0] * core.sizeY[0]]; 
    181     return openBytes(no, buf); 
    182   } 
    183  
    184   /* @see loci.formats.IFormatReader#openBytes(int, byte[]) */ 
    185   public byte[] openBytes(int no, byte[] buf) 
    186     throws FormatException, IOException 
    187   { 
    188     if (no < 0 || no >= getImageCount()) { 
    189       throw new FormatException("Invalid image number: " + no); 
    190     } 
    191     if (buf.length < core.sizeX[0] * core.sizeY[0]) { 
    192       throw new FormatException("Buffer too small."); 
    193     } 
    194  
    195     in.seek(offsets[no]); 
    196     int row = core.sizeY[0] - 1; 
    197     for (int i=0; i<core.sizeY[0]; i++) { 
    198       in.read(buf, row*core.sizeX[0], core.sizeX[0]); 
    199       row--; 
    200     } 
    201     return buf; 
    202   } 
    203  
    204   /* @see loci.formats.IFormatReader#openImage(int) */ 
    205   public BufferedImage openImage(int no) throws FormatException, IOException { 
    206     return ImageTools.makeImage(openBytes(no), core.sizeX[0], 
    207       core.sizeY[0], 1, false); 
    208   } 
    209  
    210   // -- IFormatHandler API methods -- 
    211  
    212   /* @see loci.formats.IFormatHandler#isThisType(String, boolean) */ 
    213   public boolean isThisType(String name, boolean open) { 
    214     if (!super.isThisType(name, open)) return false; // check extension 
    215     if (!open) return true; // not allowed to check the file contents 
    216     try { 
    217       RandomAccessStream ras = new RandomAccessStream(name); 
    218       byte[] b = new byte[4]; 
    219       ras.readFully(b); 
    220       ras.close(); 
    221       return isThisType(b); 
    222     } 
    223     catch (IOException e) { return false; } 
    224   } 
    225  
    226226} 
  • trunk/loci/formats/in/ImarisTiffReader.java

    r2601 r2687  
    4444  } 
    4545 
    46   // -- FormatReader API methods -- 
     46  // -- IFormatReader API methods -- 
    4747 
    4848  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    205205      new Integer(core.sizeT[0]), new Integer(core.pixelType[0]), null, 
    206206      core.currentOrder[0], null, null); 
    207  
    208207  } 
    209208 
  • trunk/loci/formats/in/LIFReader.java

    r2673 r2687  
    6565  public LIFReader() { super("Leica Image File Format", "lif"); } 
    6666 
    67   // -- FormatReader API methods -- 
     67  // -- IFormatReader API methods -- 
    6868 
    6969  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
    7070  public boolean isThisType(byte[] block) { 
    7171    return block[0] == 0x70; 
    72   } 
    73  
    74   /* @see loci.formats.IFormatReader#getSeriesCount() */ 
    75   public int getSeriesCount() { 
    76     return core.sizeX.length; 
    7772  } 
    7873 
     
    117112  } 
    118113 
    119   /** Initializes the given LIF file. */ 
     114  /* @see loci.formats.IFormatReader#getSeriesCount() */ 
     115  public int getSeriesCount() { 
     116    return core.sizeX.length; 
     117  } 
     118 
     119  // -- Internal FormatReader API methods -- 
     120 
     121  /* @see loci.formats.FormatReader#initFile(String) */ 
    120122  protected void initFile(String id) throws FormatException, IOException { 
    121123    if (debug) debug("LIFReader.initFile(" + id + ")"); 
  • trunk/loci/formats/in/LegacyPictReader.java

    r2672 r2687  
    4545  public LegacyPictReader() { super("PICT", "pict"); } 
    4646 
    47   // -- FormatReader API methods -- 
     47  // -- IFormatReader API methods -- 
    4848 
    4949  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    7979  } 
    8080 
    81   /** Initializes the given PICT file. */ 
     81  /* @see loci.formats.IFormatReader#close(boolean) */ 
     82  public void close(boolean fileOnly) throws IOException { } 
     83 
     84  // -- Internal FormatReader API methods -- 
     85 
     86  /* @see loci.formats.FormatReader#initFile(String) */ 
    8287  protected void initFile(String id) throws FormatException, IOException { 
    8388    if (debug) debug("LegacyPictReader.initFile(" + id + ")"); 
     
    108113  } 
    109114 
    110   /* @see loci.formats.IFormatReader#close(boolean) */ 
    111   public void close(boolean fileOnly) throws IOException { } 
    112  
    113115} 
  • trunk/loci/formats/in/LegacyQTReader.java

    r2676 r2687  
    6666  } 
    6767 
    68   // -- FormatReader API methods -- 
     68  // -- IFormatReader API methods -- 
    6969 
    7070  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    119119  } 
    120120 
    121   /* @see loci.formats.IFormatReader#close() */ 
     121  // -- IFormatHandler API methods -- 
     122 
     123  /* @see loci.formats.IFormatHandler#close() */ 
    122124  public void close() throws IOException { 
    123125    close(false); 
    124126  } 
    125127 
    126   /** Initializes the given QuickTime file. */ 
    127   protected void initFile(String id) 
    128     throws FormatException, IOException 
    129   { 
     128  // -- Internal FormatReader API methods -- 
     129 
     130  /* @see loci.formats.FormatReader#initFile(String) */ 
     131  protected void initFile(String id) throws FormatException, IOException { 
    130132    if (debug) debug("LegacyQTReader.initFile(" + id + ")"); 
    131133 
  • trunk/loci/formats/in/LegacyZVIReader.java

    r2672 r2687  
    8282  public LegacyZVIReader() { super("Legacy ZVI", "zvi"); } 
    8383 
    84   // -- FormatReader API methods -- 
     84  // -- IFormatReader API methods -- 
    8585 
    8686  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    9494  } 
    9595 
     96  /* @see loci.formats.IFormatReader#getImageCount() */ 
     97  public int getImageCount() { 
     98    return blockList.size(); 
     99  } 
     100 
    96101  /* @see loci.formats.IFormatReader#openBytes(int) */ 
    97102  public byte[] openBytes(int no) throws FormatException, IOException { 
     
    113118  } 
    114119 
    115   /* @see loci.formats.IFormatReader#getImageCount() */ 
    116   public int getImageCount() { 
    117     return blockList.size(); 
    118   } 
    119  
    120120  /* @see loci.formats.IFormatReader#openImage(int) */ 
    121121  public BufferedImage openImage(int no) throws FormatException, IOException { 
     
    130130  } 
    131131 
    132   /** Initializes the given ZVI file. */ 
     132  // -- Internal FormatReader API methods -- 
     133 
     134  /* @see loci.formats.FormatReader#initFile(String) */ 
    133135  protected void initFile(String id) throws FormatException, IOException { 
    134136    if (debug) debug("LegacyZVIReader.initFile(" + id + ")"); 
  • trunk/loci/formats/in/LeicaReader.java

    r2683 r2687  
    7676  } 
    7777 
    78   // -- FormatReader API methods -- 
     78  // -- IFormatReader API methods -- 
    7979 
    8080  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    183183  } 
    184184 
    185   /* @see loci.formats.IFormatReader#close() */ 
     185  // -- IFormatHandler API methods -- 
     186 
     187  /* @see loci.formats.IFormatHandler#isThisType(String, boolean) */ 
     188  public boolean isThisType(String name, boolean open) { 
     189    String lname = name.toLowerCase(); 
     190    if (lname.endsWith(".lei")) return true; 
     191    else if (!lname.endsWith(".tif") && !lname.endsWith(".tiff")) return false; 
     192    if (!open) return true; // now allowed to be any more thorough 
     193 
     194    // just checking the filename isn't enough to differentiate between 
     195    // Leica and regular TIFF; open the file and check more thoroughly 
     196    Location file = new Location(name); 
     197    if (!file.exists()) return false; 
     198    long len = file.length(); 
     199    if (len < 4) return false; 
     200 
     201    try { 
     202      RandomAccessStream ras = new RandomAccessStream(name); 
     203      Hashtable ifd = TiffTools.getFirstIFD(ras); 
     204      ras.close(); 
     205      if (ifd == null) return false; 
     206 
     207      String descr = (String) ifd.get(new Integer(TiffTools.IMAGE_DESCRIPTION)); 
     208      int ndx = descr == null ? -1 : descr.indexOf("Series Name"); 
     209 
     210      if (ndx == -1) return false; 
     211 
     212      String dir = new Location(name).getAbsoluteFile().getParent(); 
     213      String[] listing = new Location(dir).list(); 
     214      for (int i=0; i<listing.length; i++) { 
     215        if (listing[i].toLowerCase().endsWith(".lei")) return true; 
     216      } 
     217      return false; 
     218    } 
     219    catch (IOException exc) { 
     220      if (debug) exc.printStackTrace(); 
     221    } 
     222    catch (ClassCastException exc) { 
     223      if (debug) exc.printStackTrace(); 
     224    } 
     225    return false; 
     226  } 
     227 
     228  /* @see loci.formats.IFormatHandler#close() */ 
    186229  public void close() throws IOException { 
    187230    super.close(); 
     
    199242  } 
    200243 
    201   /** Initializes the given Leica file. */ 
     244  // -- Internal FormatReader API methods -- 
     245 
     246  /* @see loci.formats.FormatReader#initFile(String) */ 
    202247  protected void initFile(String id) throws FormatException, IOException { 
    203248    if (debug) debug("LeicaReader.initFile(" + id + ")"); 
     
    449494              files[i] = new Vector(); 
    450495              for (int k=0; k<usedFiles.length; k++) { 
    451                 files[i].add(new Location(usedFiles[k]).getAbsolutePath());  
     496                files[i].add(new Location(usedFiles[k]).getAbsolutePath()); 
    452497              } 
    453498              break; 
     
    543588  } 
    544589 
    545   // -- IFormatHandler API methods -- 
    546  
    547   /* @see loci.formats.IFormatHandler#isThisType(String, boolean) */ 
    548   public boolean isThisType(String name, boolean open) { 
    549     String lname = name.toLowerCase(); 
    550     if (lname.endsWith(".lei")) return true; 
    551     else if (!lname.endsWith(".tif") && !lname.endsWith(".tiff")) return false; 
    552     if (!open) return true; // now allowed to be any more thorough 
    553  
    554     // just checking the filename isn't enough to differentiate between 
    555     // Leica and regular TIFF; open the file and check more thoroughly 
    556     Location file = new Location(name); 
    557     if (!file.exists()) return false; 
    558     long len = file.length(); 
    559     if (len < 4) return false; 
    560  
    561     try { 
    562       RandomAccessStream ras = new RandomAccessStream(name); 
    563       Hashtable ifd = TiffTools.getFirstIFD(ras); 
    564       ras.close(); 
    565       if (ifd == null) return false; 
    566  
    567       String descr = (String) ifd.get(new Integer(TiffTools.IMAGE_DESCRIPTION)); 
    568       int ndx = descr == null ? -1 : descr.indexOf("Series Name"); 
    569  
    570       if (ndx == -1) return false; 
    571  
    572       String dir = new Location(name).getAbsoluteFile().getParent(); 
    573       String[] listing = new Location(dir).list(); 
    574       for (int i=0; i<listing.length; i++) { 
    575         if (listing[i].toLowerCase().endsWith(".lei")) return true; 
    576       } 
    577       return false; 
    578     } 
    579     catch (IOException exc) { 
    580       if (debug) exc.printStackTrace(); 
    581     } 
    582     catch (ClassCastException exc) { 
    583       if (debug) exc.printStackTrace(); 
    584     } 
    585     return false; 
    586   } 
    587  
    588590  // -- Helper methods -- 
    589591 
    590   /* @see BaseTiffReader#initMetadata() */ 
    591592  protected void initMetadata() throws FormatException, IOException { 
    592593    if (headerIFDs == null) headerIFDs = ifds; 
     
    952953    // sizeC is null here if the file we opened was a TIFF. 
    953954    // However, the sizeC field will be adjusted anyway by 
    954     // a later call to BaseTiffReader.initMetadata. 
     955    // a later call to initMetadata. 
    955956    if (core.sizeC != null) { 
    956957      int oldSeries = getSeries(); 
  • trunk/loci/formats/in/MNGReader.java

    r2636 r2687  
    5050  public MNGReader() { super("Multiple Network Graphics (MNG)", "mng"); } 
    5151 
    52   // -- FormatReader API methods -- 
     52  // -- IFormatReader API methods -- 
    5353 
    5454  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    8888  } 
    8989 
    90   /** Initializes the given MNG file. */ 
     90  // -- Internal FormatReader API methods -- 
     91 
     92  /* @see loci.formats.FormatReader#initFile(String) */ 
    9193  protected void initFile(String id) throws FormatException, IOException { 
    9294    if (debug) debug("MNGReader.initFile(" + id + ")"); 
  • trunk/loci/formats/in/MRCReader.java

    r2616 r2687  
    8888  } 
    8989 
    90   /** Initializes the given MRC file. */ 
     90  // -- Internal FormatReader API methods -- 
     91 
     92  /* @see loci.formats.FormatReader#initFile(String) */ 
    9193  public void initFile(String id) throws FormatException, IOException { 
    9294    if (debug) debug("MRCReader.initFile(" + id + ")"); 
  • trunk/loci/formats/in/MetamorphReader.java

    r2636 r2687  
    6666 
    6767  private int mmPlanes; //number of metamorph planes 
     68 
    6869  // -- Constructor -- 
    6970 
     
    7172  public MetamorphReader() { super("Metamorph STK", "stk"); } 
    7273 
    73   // -- FormatReader API methods -- 
     74  // -- IFormatReader API methods -- 
    7475 
    7576  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    300301  } 
    301302 
    302   // -- Utility methods -- 
     303  // -- Helper methods -- 
    303304 
    304305  /** 
     
    727728  } 
    728729 
     730  // -- Utility methods -- 
     731 
    729732  /** Converts a Julian date value into a human-readable string. */ 
    730733  public static String decodeDate(int julian) { 
  • trunk/loci/formats/in/MicromanagerReader.java

    r2673 r2687  
    8686  } 
    8787 
    88   /* @see loci.formats.IFormatReader#close() */ 
     88  /* @see loci.formats.IFormatReader#close(boolean) */ 
     89  public void close(boolean fileOnly) throws IOException { 
     90    if (fileOnly) tiffReader.close(fileOnly); 
     91    else close(); 
     92  } 
     93 
     94  // -- IFormatHandler API methods -- 
     95 
     96  /* @see loci.formats.IFormatHandler#isThisType(String, boolean) */ 
     97  public boolean isThisType(String name, boolean open) { 
     98    Location parent = new Location(name).getAbsoluteFile().getParentFile(); 
     99    String[] list = parent.list(); 
     100    for (int i=0; i<list.length; i++) { 
     101      if (list[i].endsWith("metadata.txt")) return super.isThisType(name, open); 
     102    } 
     103    return false; 
     104  } 
     105 
     106  /* @see loci.formats.IFormatHandler#close() */ 
    89107  public void close() throws IOException { 
    90108    super.close(); 
     
    94112  } 
    95113 
    96   /* @see loci.formats.IFormatReader#close(boolean) */ 
    97   public void close(boolean fileOnly) throws IOException { 
    98     if (fileOnly) tiffReader.close(fileOnly); 
    99     else close(); 
    100   } 
    101  
    102   /* @see loci.formats.IFormatReader#initFile(String) */ 
     114  // -- Internal FormatReader API methods -- 
     115 
     116  /* @see loci.formats.FormatReader#initFile(String) */ 
    103117  public void initFile(String id) throws FormatException, IOException { 
    104118    super.initFile(id); 
     
    212226  } 
    213227 
    214   // -- IFormatHandler API methods -- 
    215  
    216   /* @see loci.formats.IFormatHandler#isThisType(String, boolean) */ 
    217   public boolean isThisType(String name, boolean open) { 
    218     Location parent = new Location(name).getAbsoluteFile().getParentFile(); 
    219     String[] list = parent.list(); 
    220     for (int i=0; i<list.length; i++) { 
    221       if (list[i].endsWith("metadata.txt")) return super.isThisType(name, open); 
    222     } 
    223     return false; 
    224   } 
    225  
    226228} 
  • trunk/loci/formats/in/ND2Reader.java

    r2673 r2687  
    126126  public ND2Reader() { super("Nikon ND2", new String[] {"nd2", "jp2"}); } 
    127127 
    128   // -- FormatReader API methods -- 
     128  // -- IFormatReader API methods -- 
    129129 
    130130  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    217217  } 
    218218 
    219   /** Initializes the given ND2 file. */ 
     219  // -- Internal FormatReader API methods -- 
     220 
     221  /* @see loci.formats.FormatReader#initFile(String) */ 
    220222  protected void initFile(String id) throws FormatException, IOException { 
    221223    if (debug) debug("ND2Reader.initFile(" + id + ")"); 
  • trunk/loci/formats/in/NRRDReader.java

    r2673 r2687  
    5252  public NRRDReader() { super("NRRD", new String[] {"nrrd", "nhdr"}); } 
    5353 
    54   // -- FormatReader API methods -- 
     54  // -- IFormatReader API methods -- 
    5555 
    5656  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    112112      FormatTools.getBytesPerPixel(core.pixelType[0]), core.littleEndian[0]); 
    113113  } 
     114 
     115  // -- Internal FormatReader API methods -- 
    114116 
    115117  /* @see loci.formats.FormatReader#initFile(String) */ 
  • trunk/loci/formats/in/NikonReader.java

    r2616 r2687  
    118118  } 
    119119 
    120   // -- FormatReader API methods -- 
     120  // -- IFormatReader API methods -- 
    121121 
    122122  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    169169 
    170170  // -- Internal BaseTiffReader API methods -- 
    171  
    172   /* @see BaseTiffReader#initFile(String) */ 
    173   protected void initFile(String id) throws FormatException, IOException { 
    174     if (debug) debug("NikonReader.initFile(" + id + ")"); 
    175     super.initFile(id); 
    176  
    177     in = new RandomAccessStream(id); 
    178     if (in.readShort() == 0x4949) in.order(true); 
    179  
    180     ifds = TiffTools.getIFDs(in); 
    181     if (ifds == null) throw new FormatException("No IFDs found"); 
    182  
    183     // look for the SubIFD tag (330); 
    184  
    185     int offset = 0; 
    186     try { 
    187       offset = TiffTools.getIFDIntValue(ifds[0], 330, false, 0); 
    188     } 
    189     catch (Exception e) { 
    190       // CTR TODO - eliminate catch-all exception handling 
    191       if (debug) e.printStackTrace(); 
    192       long[] array = TiffTools.getIFDLongArray(ifds[0], 330, false); 
    193       offset = (int) array[array.length - 1]; 
    194     } 
    195  
    196     Hashtable realImage = TiffTools.getIFD(in, 1, offset); 
    197     realImage.put(new Integer(TiffTools.VALID_BITS), new int[] {12, 12, 12}); 
    198  
    199     original = ifds[0]; 
    200     ifds[0] = realImage; 
    201     core.imageCount[0] = 1; 
    202  
    203     Object pattern = getMeta("CFA pattern"); 
    204     if (pattern != null) { 
    205       realImage.put(new Integer(TiffTools.COLOR_MAP), getMeta("CFA pattern")); 
    206     } 
    207   } 
    208171 
    209172  /* @see BaseTiffReader#initStandardMetadata() */ 
     
    275238    catch (IOException e) { 
    276239      if (debug) e.printStackTrace(); 
     240    } 
     241  } 
     242 
     243  // -- Internal FormatReader API methods -- 
     244 
     245  /* @see loci.formats.FormatReader#initFile(String) */ 
     246  protected void initFile(String id) throws FormatException, IOException { 
     247    if (debug) debug("NikonReader.initFile(" + id + ")"); 
     248    super.initFile(id); 
     249 
     250    in = new RandomAccessStream(id); 
     251    if (in.readShort() == 0x4949) in.order(true); 
     252 
     253    ifds = TiffTools.getIFDs(in); 
     254    if (ifds == null) throw new FormatException("No IFDs found"); 
     255 
     256    // look for the SubIFD tag (330); 
     257 
     258    int offset = 0; 
     259    try { 
     260      offset = TiffTools.getIFDIntValue(ifds[0], 330, false, 0); 
     261    } 
     262    catch (Exception e) { 
     263      // CTR TODO - eliminate catch-all exception handling 
     264      if (debug) e.printStackTrace(); 
     265      long[] array = TiffTools.getIFDLongArray(ifds[0], 330, false); 
     266      offset = (int) array[array.length - 1]; 
     267    } 
     268 
     269    Hashtable realImage = TiffTools.getIFD(in, 1, offset); 
     270    realImage.put(new Integer(TiffTools.VALID_BITS), new int[] {12, 12, 12}); 
     271 
     272    original = ifds[0]; 
     273    ifds[0] = realImage; 
     274    core.imageCount[0] = 1; 
     275 
     276    Object pattern = getMeta("CFA pattern"); 
     277    if (pattern != null) { 
     278      realImage.put(new Integer(TiffTools.COLOR_MAP), getMeta("CFA pattern")); 
    277279    } 
    278280  } 
  • trunk/loci/formats/in/OIBReader.java

    r2673 r2687  
    128128  public OIBReader() { super("Fluoview FV1000 OIB", "oib"); } 
    129129 
    130   // -- FormatReader API methods -- 
     130  // -- IFormatReader API methods -- 
    131131 
    132132  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    134134    return (block[0] == 0xd0 && block[1] == 0xcf && 
    135135      block[2] == 0x11 && block[3] == 0xe0); 
     136  } 
     137 
     138  /* @see loci.formats.IFormatReader#openImage(int) */ 
     139  public BufferedImage openImage(int no) throws FormatException, IOException { 
     140    if (no < 0 || no >= getImageCount()) { 
     141      throw new FormatException("Invalid image number: " + no); 
     142    } 
     143 
     144    byte[] b = openBytes(no); 
     145    int bytes = b.length / (core.sizeX[series] * core.sizeY[series] * 
     146      getRGBChannelCount()); 
     147 
     148    return ImageTools.makeImage(b, core.sizeX[series], core.sizeY[series], 
     149      getRGBChannelCount(), false, bytes, core.littleEndian[series], 
     150      validBits[series]); 
    136151  } 
    137152 
     
    180195  } 
    181196 
    182   /* @see loci.formats.IFormatReader#openImage(int) */ 
    183   public BufferedImage openImage(int no) throws FormatException, IOException { 
    184     if (no < 0 || no >= getImageCount()) { 
    185       throw new FormatException("Invalid image number: " + no); 
    186     } 
    187  
    188     byte[] b = openBytes(no); 
    189     int bytes = b.length / (core.sizeX[series] * core.sizeY[series] * 
    190       getRGBChannelCount()); 
    191  
    192     return ImageTools.makeImage(b, core.sizeX[series], core.sizeY[series], 
    193       getRGBChannelCount(), false, bytes, core.littleEndian[series], 
    194       validBits[series]); 
    195   } 
    196  
    197   /* @see loci.formats.IFormatReader#close() */ 
     197  // -- IFormatHandler API methods -- 
     198 
     199  /* @see loci.formats.IFormatHandler#close() */ 
    198200  public void close() throws IOException { 
    199201    super.close(); 
     
    204206  } 
    205207 
    206   /** Initializes the given OIB file. */ 
     208  // -- Internal FormatReader API methods -- 
     209 
     210  /* @see loci.formats.FormatReader#initFile(String) */ 
    207211  protected void initFile(String id) throws FormatException, IOException { 
    208212    if (debug) debug("OIBReader.initFile(" + id + ")"); 
     
    522526          null, null, null, new Integer(j)); 
    523527      } 
    524  
    525528    } 
    526529  } 
  • trunk/loci/formats/in/OIFReader.java

    r2674 r2687  
    6666  } 
    6767 
    68   // -- FormatReader API methods -- 
     68  // -- IFormatReader API methods -- 
    6969 
    7070  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    145145  } 
    146146 
    147   /* @see loci.formats.IFormatReader#close() */ 
     147  // -- IFormatHandler API methods -- 
     148 
     149  /* @see loci.formats.IFormatHandler#close() */ 
    148150  public void close() throws IOException { 
    149151    super.close(); 
     
    157159  } 
    158160 
    159   /** Initializes the given OIF file. */ 
     161  // -- Internal FormatReader API methods -- 
     162 
     163  /* @see loci.formats.FormatReader#initFile(String) */ 
    160164  protected void initFile(String id) throws FormatException, IOException { 
    161165    if (debug) debug("OIFReader.initFile(" + id + ")"); 
     
    459463      } 
    460464    } 
    461  
    462465  } 
    463466 
  • trunk/loci/formats/in/OMEXMLReader.java

    r2636 r2687  
    7474  public OMEXMLReader() { super("OME-XML", "ome"); } 
    7575 
    76   // -- FormatReader API methods -- 
     76  // -- IFormatReader API methods -- 
    7777 
    7878  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    153153  } 
    154154 
    155   /** Initializes the given OME-XML file. */ 
     155  // -- Internal FormatReader API methods -- 
     156 
     157  /* @see loci.formats.FormatReader#initFile(String) */ 
    156158  protected void initFile(String id) throws FormatException, IOException { 
    157159    if (debug) debug("OMEXMLReader.initFile(" + id + ")"); 
  • trunk/loci/formats/in/OpenlabRawReader.java

    r2616 r2687  
    5454  public OpenlabRawReader() { super("Openlab RAW", "raw"); } 
    5555 
    56   // -- FormatReader API methods -- 
     56  // -- IFormatReader API methods -- 
    5757 
    5858  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    9797  } 
    9898 
    99   /** Initializes the given RAW file. */ 
     99  // -- Internal FormatReader API methods -- 
     100 
     101  /* @see loci.formats.FormatReader#initFile(String) */ 
    100102  protected void initFile(String id) throws FormatException, IOException { 
    101103    if (debug) debug("OpenlabRawReader.initFile(" + id + ")"); 
  • trunk/loci/formats/in/OpenlabReader.java

    r2684 r2687  
    7575  public OpenlabReader() { super("Openlab LIFF", "liff"); } 
    7676 
    77   // -- FormatReader API methods -- 
     77  // -- IFormatReader API methods -- 
    7878 
    7979  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    310310  } 
    311311 
    312   /* @see loci.formats.IFormatReader#close() */ 
     312  // -- IFormatHandler API methods -- 
     313 
     314  /* @see loci.formats.IFormatHandler#isThisType(String, boolean) */ 
     315  public boolean isThisType(String name, boolean open) { 
     316    if (super.isThisType(name, open)) return true; // check extension 
     317 
     318    if (open) { 
     319      byte[] b = new byte[8]; 
     320      try { 
     321        in = new RandomAccessStream(name); 
     322        in.read(b); 
     323      } 
     324      catch (IOException e) { 
     325        if (debug) e.printStackTrace(); 
     326        return false; 
     327      } 
     328      return isThisType(b); 
     329    } 
     330    else { 
     331      return name.indexOf(".") < 0; // file appears to have no extension 
     332    } 
     333  } 
     334 
     335  /* @see loci.formats.IFormatHandler#close() */ 
    313336  public void close() throws IOException { 
    314337    super.close(); 
     
    317340  } 
    318341 
    319   /** Initialize the given Openlab LIFF file. */ 
     342  // -- Internal FormatReader API methods -- 
     343 
     344  /* @see loci.formats.FormatReader#initFile(String) */ 
    320345  protected void initFile(String id) throws FormatException, IOException { 
    321346    if (debug) debug("OpenlabReader.initFile(" + id + ")"); 
     
    572597      core.imageCount[0] = oldImages; 
    573598      if (layerInfoList[0].size() == 0) layerInfoList[0] = layerInfoList[1]; 
    574      
     599 
    575600      int x = core.sizeX[0]; 
    576601      core.sizeX = new int[1]; 
     
    682707  } 
    683708 
    684   // -- IFormatHandler API methods -- 
    685  
    686   /* @see loci.formats.IFormatHandler#isThisType(String, boolean) */ 
    687   public boolean isThisType(String name, boolean open) { 
    688     if (super.isThisType(name, open)) return true; // check extension 
    689  
    690     if (open) { 
    691       byte[] b = new byte[8]; 
    692       try { 
    693         in = new RandomAccessStream(name); 
    694         in.read(b); 
    695       } 
    696       catch (IOException e) { 
    697         if (debug) e.printStackTrace(); 
    698         return false; 
    699       } 
    700       return isThisType(b); 
    701     } 
    702     else { 
    703       return name.indexOf(".") < 0; // file appears to have no extension 
    704     } 
    705   } 
    706  
    707709  // -- Helper methods -- 
    708710 
     
    724726    return nextTag; 
    725727  } 
     728 
     729  // -- Helper classes -- 
    726730 
    727731  /** Helper class for storing layer info. */ 
  • trunk/loci/formats/in/PerkinElmerReader.java

    r2673 r2687  
    6363  } 
    6464 
    65   // -- FormatReader API methods -- 
     65  // -- IFormatReader API methods -- 
    6666 
    6767  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    117117  } 
    118118 
    119   /* @see loci.formats.IFormatReader#close() */ 
     119  // -- IFormatHandler API methods -- 
     120 
     121  /* @see loci.formats.IFormatHandler#close() */ 
    120122  public void close() throws IOException { 
    121123    currentId = null; 
     
    128130  } 
    129131 
    130   /** Initializes the given PerkinElmer file. */ 
     132  // -- Internal FormatReader API methods -- 
     133 
     134  /* @see loci.formats.FormatReader#initFile(String) */ 
    131135  protected void initFile(String id) throws FormatException, IOException { 
    132136    if (currentId != null && (id.equals(currentId) || isUsedFile(id))) return; 
  • trunk/loci/formats/in/PictReader.java

    r2616 r2687  
    111111  public PictReader() { super("PICT", new String[] {"pict", "pct"}); } 
    112112 
    113   // -- FormatReader API methods -- 
    114  
    115   /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
    116   public boolean isThisType(byte[] block) { 
    117     if (block.length < 528) return false; 
    118     return true; 
    119   } 
    120  
    121   /* @see loci.formats.IFormatReader#openBytes(int) */ 
    122   public byte[] openBytes(int no) throws FormatException, IOException { 
    123     return ImageTools.getBytes(openImage(no), false, no % 3); 
    124   } 
    125  
    126   /* @see loci.formats.IFormatReader#openImage(int) */ 
    127   public BufferedImage openImage(int no) throws FormatException, IOException { 
    128     if (no < 0 || no >= getImageCount()) { 
    129       throw new FormatException("Invalid image number: " + no); 
    130     } 
    131  
    132     return open(bytes); 
    133   } 
    134  
    135   /** Initializes the given PICT file. */ 
    136   protected void initFile(String id) throws FormatException, IOException { 
    137     if (debug) debug("PictReader.initFile(" + id + ")"); 
    138     super.initFile(id); 
    139     in = new RandomAccessStream(id); 
    140  
    141     status("Populating metadata"); 
    142  
    143     core.littleEndian[0] = false; 
    144  
    145     // skip the header and read in the remaining bytes 
    146     int len = (int) (in.length() - 512); 
    147     bytes = new byte[len]; 
    148     in.seek(512); 
    149     in.read(bytes); 
    150  
    151     byte[] b = new byte[20]; 
    152     in.seek(512); 
    153     in.read(b); 
    154     Dimension d = getDimensions(b); 
    155  
    156     core.sizeX[0] = d.width; 
    157     while (core.sizeX[0] % 8 != 0) core.sizeX[0]++; 
    158     core.sizeY[0] = d.height; 
    159     core.sizeZ[0] = 1; 
    160     core.sizeC[0] = 3; 
    161     core.sizeT[0] = 1; 
    162     core.currentOrder[0] = "XYCZT"; 
    163     core.rgb[0] = true; 
    164     core.interleaved[0] = true; 
    165     core.imageCount[0] = 1; 
    166  
    167     // The metadata store we're working with. 
    168     MetadataStore store = getMetadataStore(); 
    169  
    170     core.pixelType[0] = FormatTools.UINT8; 
    171     store.setPixels( 
    172       new Integer(core.sizeX[0]), new Integer(core.sizeY[0]), 
    173       new Integer(core.sizeZ[0]), new Integer(core.sizeC[0]), 
    174       new Integer(core.sizeT[0]), new Integer(core.pixelType[0]), 
    175       new Boolean(!core.littleEndian[0]), core.currentOrder[0], null, null); 
    176     for (int i=0; i<core.sizeC[0]; i++) { 
    177       store.setLogicalChannel(i, null, null, null, null, null, null, null); 
    178     } 
    179   } 
    180  
    181113  // -- PictReader API methods -- 
    182114 
     
    330262      } 
    331263      return ImageTools.makeImage(data, core.sizeX[0], core.sizeY[0], 3, true); 
     264    } 
     265  } 
     266 
     267  // -- IFormatReader API methods -- 
     268 
     269  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     270  public boolean isThisType(byte[] block) { 
     271    if (block.length < 528) return false; 
     272    return true; 
     273  } 
     274 
     275  /* @see loci.formats.IFormatReader#openBytes(int) */ 
     276  public byte[] openBytes(int no) throws FormatException, IOException { 
     277    return ImageTools.getBytes(openImage(no), false, no % 3); 
     278  } 
     279 
     280  /* @see loci.formats.IFormatReader#openImage(int) */ 
     281  public BufferedImage openImage(int no) throws FormatException, IOException { 
     282    if (no < 0 || no >= getImageCount()) { 
     283      throw new FormatException("Invalid image number: " + no); 
     284    } 
     285 
     286    return open(bytes); 
     287  } 
     288 
     289  // -- Internal FormatReader API methods -- 
     290 
     291  /* @see loci.formats.FormatReader#initFile(String) */ 
     292  protected void initFile(String id) throws FormatException, IOException { 
     293    if (debug) debug("PictReader.initFile(" + id + ")"); 
     294    super.initFile(id); 
     295    in = new RandomAccessStream(id); 
     296 
     297    status("Populating metadata"); 
     298 
     299    core.littleEndian[0] = false; 
     300 
     301    // skip the header and read in the remaining bytes 
     302    int len = (int) (in.length() - 512); 
     303    bytes = new byte[len]; 
     304    in.seek(512); 
     305    in.read(bytes); 
     306 
     307    byte[] b = new byte[20]; 
     308    in.seek(512); 
     309    in.read(b); 
     310    Dimension d = getDimensions(b); 
     311 
     312    core.sizeX[0] = d.width; 
     313    while (core.sizeX[0] % 8 != 0) core.sizeX[0]++; 
     314    core.sizeY[0] = d.height; 
     315    core.sizeZ[0] = 1; 
     316    core.sizeC[0] = 3; 
     317    core.sizeT[0] = 1; 
     318    core.currentOrder[0] = "XYCZT"; 
     319    core.rgb[0] = true; 
     320    core.interleaved[0] = true; 
     321    core.imageCount[0] = 1; 
     322 
     323    // The metadata store we're working with. 
     324    MetadataStore store = getMetadataStore(); 
     325 
     326    core.pixelType[0] = FormatTools.UINT8; 
     327    store.setPixels( 
     328      new Integer(core.sizeX[0]), new Integer(core.sizeY[0]), 
     329      new Integer(core.sizeZ[0]), new Integer(core.sizeC[0]), 
     330      new Integer(core.sizeT[0]), new Integer(core.pixelType[0]), 
     331      new Boolean(!core.littleEndian[0]), core.currentOrder[0], null, null); 
     332    for (int i=0; i<core.sizeC[0]; i++) { 
     333      store.setLogicalChannel(i, null, null, null, null, null, null, null); 
    332334    } 
    333335  } 
  • trunk/loci/formats/in/PrairieReader.java

    r2673 r2687  
    6464  public PrairieReader() { 
    6565    super("Prairie (TIFF)", new String[] {"tif", "tiff", "cfg", "xml"}); 
     66  } 
     67 
     68  // -- IFormatReader API methods -- 
     69 
     70  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     71  public boolean isThisType(byte[] block) { 
     72    // adapted from MetamorphReader.isThisType(byte[]) 
     73    if (block.length < 3) return false; 
     74    if (block.length < 8) { 
     75      return true; // we have no way of verifying further 
     76    } 
     77 
     78    boolean little = (block[0] == 0x49 && block[1] == 0x49); 
     79 
     80    int ifdlocation = DataTools.bytesToInt(block, 4, little); 
     81 
     82    if (ifdlocation < 0) return false; 
     83    else if (ifdlocation + 1 > block.length) return true; 
     84    else { 
     85      int ifdnumber = DataTools.bytesToInt(block, ifdlocation, 2, little); 
     86      for (int i=0; i<ifdnumber; i++) { 
     87        if (ifdlocation + 3 + (i*12) > block.length) { 
     88          return false; 
     89        } 
     90        else { 
     91          int ifdtag = DataTools.bytesToInt(block, 
     92            ifdlocation + 2 + (i*12), 2, little); 
     93          if (ifdtag == PRAIRIE_TAG_1 || ifdtag == PRAIRIE_TAG_2 || 
     94            ifdtag == PRAIRIE_TAG_3) 
     95          { 
     96            return true; 
     97          } 
     98        } 
     99      } 
     100      return false; 
     101    } 
     102  } 
     103 
     104  /* @see loci.formats.IFormatReader#getUsedFiles() */ 
     105  public String[] getUsedFiles() { 
     106    String[] s = new String[files.length + 2]; 
     107    System.arraycopy(files, 0, s, 0, files.length); 
     108    s[files.length] = xmlFile; 
     109    s[files.length + 1] = cfgFile; 
     110    return s; 
     111  } 
     112 
     113  /* @see loci.formats.IFormatReader#openBytes(int) */ 
     114  public byte[] openBytes(int no) throws FormatException, IOException { 
     115    if (no < 0 || no >= getImageCount()) { 
     116      throw new FormatException("Invalid image number: " + no); 
     117    } 
     118    tiff.setId(files[no]); 
     119    return tiff.openBytes(0); 
     120  } 
     121 
     122  /* @see loci.formats.IFormatReader#openBytes(int, byte[]) */ 
     123  public byte[] openBytes(int no, byte[] buf) 
     124    throws FormatException, IOException 
     125  { 
     126    if (no < 0 || no >= getImageCount()) { 
     127      throw new FormatException("Invalid image number: " + no); 
     128    } 
     129    tiff.setId(files[no]); 
     130    tiff.openBytes(0, buf); 
     131    return buf; 
     132  } 
     133 
     134  /* @see loci.formats.IFormatReader#openImage(int) */ 
     135  public BufferedImage openImage(int no) throws FormatException, IOException { 
     136    if (no < 0 || no >= getImageCount()) { 
     137      throw new FormatException("Invalid image number: " + no); 
     138    } 
     139    tiff.setId(files[no]); 
     140    return tiff.openImage(0); 
     141  } 
     142 
     143  /* @see loci.formats.IFormatReader#close(boolean) */ 
     144  public void close(boolean fileOnly) throws IOException { 
     145    if (fileOnly && tiff != null) tiff.close(fileOnly); 
     146    else if (!fileOnly) close(); 
    66147  } 
    67148 
     
    89170  } 
    90171 
    91   // -- FormatReader API methods -- 
    92  
    93   /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
    94   public boolean isThisType(byte[] block) { 
    95     // adapted from MetamorphReader.isThisType(byte[]) 
    96     if (block.length < 3) return false; 
    97     if (block.length < 8) { 
    98       return true; // we have no way of verifying further 
    99     } 
    100  
    101     boolean little = (block[0] == 0x49 && block[1] == 0x49); 
    102  
    103     int ifdlocation = DataTools.bytesToInt(block, 4, little); 
    104  
    105     if (ifdlocation < 0) return false; 
    106     else if (ifdlocation + 1 > block.length) return true; 
    107     else { 
    108       int ifdnumber = DataTools.bytesToInt(block, ifdlocation, 2, little); 
    109       for (int i=0; i<ifdnumber; i++) { 
    110         if (ifdlocation + 3 + (i*12) > block.length) { 
    111           return false; 
    112         } 
    113         else { 
    114           int ifdtag = DataTools.bytesToInt(block, 
    115             ifdlocation + 2 + (i*12), 2, little); 
    116           if (ifdtag == PRAIRIE_TAG_1 || ifdtag == PRAIRIE_TAG_2 || 
    117             ifdtag == PRAIRIE_TAG_3) 
    118           { 
    119             return true; 
    120           } 
    121         } 
    122       } 
    123       return false; 
    124     } 
    125   } 
    126  
    127   /* @see loci.formats.IFormatReader#getUsedFiles() */ 
    128   public String[] getUsedFiles() { 
    129     String[] s = new String[files.length + 2]; 
    130     System.arraycopy(files, 0, s, 0, files.length); 
    131     s[files.length] = xmlFile; 
    132     s[files.length + 1] = cfgFile; 
    133     return s; 
    134   } 
    135  
    136   /* @see loci.formats.IFormatReader#openBytes(int) */ 
    137   public byte[] openBytes(int no) throws FormatException, IOException { 
    138     if (no < 0 || no >= getImageCount()) { 
    139       throw new FormatException("Invalid image number: " + no); 
    140     } 
    141     tiff.setId(files[no]); 
    142     return tiff.openBytes(0); 
    143   } 
    144  
    145   /* @see loci.formats.IFormatReader#openBytes(int, byte[]) */ 
    146   public byte[] openBytes(int no, byte[] buf) 
    147     throws FormatException, IOException 
    148   { 
    149     if (no < 0 || no >= getImageCount()) { 
    150       throw new FormatException("Invalid image number: " + no); 
    151     } 
    152     tiff.setId(files[no]); 
    153     tiff.openBytes(0, buf); 
    154     return buf; 
    155   } 
    156  
    157   /* @see loci.formats.IFormatReader#openImage(int) */ 
    158   public BufferedImage openImage(int no) throws FormatException, IOException { 
    159     if (no < 0 || no >= getImageCount()) { 
    160       throw new FormatException("Invalid image number: " + no); 
    161     } 
    162     tiff.setId(files[no]); 
    163     return tiff.openImage(0); 
    164   } 
    165  
    166   /* @see loci.formats.IFormatReader#close(boolean) */ 
    167   public void close(boolean fileOnly) throws IOException { 
    168     if (fileOnly && tiff != null) tiff.close(fileOnly); 
    169     else if (!fileOnly) close(); 
    170   } 
    171  
    172   /* @see loci.formats.IFormatReader#close() */ 
     172  /* @see loci.formats.IFormatHandler#close() */ 
    173173  public void close() throws IOException { 
    174174    files = null; 
     
    179179    readCFG = false; 
    180180  } 
     181 
     182  // -- Internal FormatReader API methods -- 
    181183 
    182184  /* @see loci.formats.IFormatReader#initFile(String) */ 
  • trunk/loci/formats/in/QTReader.java

    r2675 r2687  
    132132  public void setLegacy(boolean legacy) { useLegacy = legacy; } 
    133133 
    134   // -- FormatReader API methods -- 
     134  // -- IFormatReader API methods -- 
    135135 
    136136  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    334334  } 
    335335 
    336   /* @See loci.formats.IFormatReader#openImage(int) */ 
     336  /* @see loci.formats.IFormatReader#openImage(int) */ 
    337337  public BufferedImage openImage(int no) throws FormatException, IOException { 
    338338    if (no < 0 || no >= getImageCount()) { 
     
    399399  } 
    400400 
    401   /* @see loci.formats.IFormatReader#close() */ 
     401  // -- IFormatHandler API methods -- 
     402 
     403  /* @see loci.formats.IFormatHandler#close() */ 
    402404  public void close() throws IOException { 
    403405    super.close(); 
     
    405407  } 
    406408 
    407   /** Initializes the given QuickTime file. */ 
     409  // -- Internal FormatReader API methods -- 
     410 
     411  /* @see loci.formats.FormatReader#initFile(String) */ 
    408412  protected void initFile(String id) throws FormatException, IOException { 
    409413    if (debug) debug("QTReader.initFile(" + id + ")"); 
     
    578582 
    579583  /** Parse all of the atoms in the file. */ 
    580   public void parse(int depth, long offset, long length) 
     584  private void parse(int depth, long offset, long length) 
    581585    throws FormatException, IOException 
    582586  { 
     
    659663 
    660664            b = new byte[(int) (atomSize - 12)]; 
    661             in.read(b);  
    662            
     665            in.read(b); 
     666 
    663667            Inflater inf = new Inflater(); 
    664668            inf.setInput(b, 0, b.length); 
    665669            byte[] output = new byte[uncompressedSize]; 
    666             try {  
     670            try { 
    667671              inf.inflate(output); 
    668672            } 
     
    672676            } 
    673677            inf.end(); 
    674           
     678 
    675679            RandomAccessStream oldIn = in; 
    676680            in = new RandomAccessStream(output); 
    677681            parse(0, 0, output.length); 
    678             in.close();  
     682            in.close(); 
    679683            in = oldIn; 
    680684          } 
     
    790794 
    791795  /** Checks if the given String is a container atom type. */ 
    792   public boolean isContainer(String type) { 
     796  private boolean isContainer(String type) { 
    793797    for (int i=0; i<CONTAINER_TYPES.length; i++) { 
    794798      if (type.equals(CONTAINER_TYPES[i])) return true; 
     
    798802 
    799803  /** Debugging method; prints information on an atom. */ 
    800   public void print(int depth, long size, String type, byte[] data) { 
     804  private void print(int depth, long size, String type, byte[] data) { 
    801805    StringBuffer sb = new StringBuffer(); 
    802806    for (int i=0; i<depth; i++) sb.append(" "); 
     
    806810 
    807811  /** Uncompresses an image plane according to the the codec identifier. */ 
    808   public byte[] uncompress(byte[] pixs, String code) 
     812  private byte[] uncompress(byte[] pixs, String code) 
    809813    throws FormatException, IOException 
    810814  { 
     
    987991 
    988992  /** Uncompresses a MJPEG-B compressed image plane. */ 
    989   public BufferedImage mjpbUncompress(byte[] input) throws FormatException { 
     993  private BufferedImage mjpbUncompress(byte[] input) throws FormatException { 
    990994    byte[] raw = null; 
    991995    byte[] raw2 = null; 
     
    13781382 
    13791383  /** Uncompresses a JPEG compressed image plane. */ 
    1380   public BufferedImage bufferedJPEG(byte[] input) throws FormatException { 
     1384  private BufferedImage bufferedJPEG(byte[] input) throws FormatException { 
    13811385    // some planes have a 16 byte header that needs to be removed 
    13821386    if (input[0] != (byte) 0xff || input[1] != (byte) 0xd8) { 
     
    13951399 
    13961400  /** Uncompresses a QT RLE compressed image plane. */ 
    1397   public byte[] rleUncompress(byte[] input) throws FormatException, IOException 
     1401  private byte[] rleUncompress(byte[] input) throws FormatException, IOException 
    13981402  { 
    13991403    if (input.length < 8) return prevPixels; 
     
    15401544  } 
    15411545 
    1542   // -- Main method -- 
    1543  
    1544   public static void main(String[] args) throws FormatException, IOException { 
    1545     new QTReader().testRead(args); 
    1546   } 
    1547  
    15481546} 
  • trunk/loci/formats/in/SDTReader.java

    r2672 r2687  
    7474 
    7575  /** Gets the number of bins in the lifetime histogram. */ 
    76   public int getTimeBinCount(String id) throws FormatException, IOException { 
    77     if (!id.equals(currentId)) initFile(id); 
     76  public int getTimeBinCount() { 
    7877    return timeBins; 
    7978  } 
    8079 
    8180  /** Gets the number of spectral channels. */ 
    82   public int getChannelCount(String id) throws FormatException, IOException { 
    83     if (!id.equals(currentId)) initFile(id); 
     81  public int getChannelCount() { 
    8482    return channels; 
    8583  } 
    8684 
    8785  /** Gets object containing SDT header information. */ 
    88   public SDTInfo getInfo(String id) throws FormatException, IOException { 
    89     if (!id.equals(currentId)) initFile(id); 
     86  public SDTInfo getInfo() { 
    9087    return info; 
    9188  } 
     
    174171  } 
    175172 
    176   // -- FormatReader API methods -- 
     173  // -- Internal FormatReader API methods -- 
    177174 
    178175  /** Initializes the given SDT file. */ 
     
    216213  } 
    217214 
     215  // -- Deprecated API methods -- 
     216 
     217  /** @deprecated Replaced by {@link #getTimeBinCount()} */ 
     218  public int getTimeBinCount(String id) throws FormatException, IOException { 
     219    setId(id); 
     220    return getTimeBinCount(); 
     221  } 
     222 
     223  /** @deprecated Replaced by {@link #getChannelCount()} */ 
     224  public int getChannelCount(String id) throws FormatException, IOException { 
     225    setId(id); 
     226    return getChannelCount(); 
     227  } 
     228 
     229  /** @deprecated Replaced by {@link #getInfo()} */ 
     230  public SDTInfo getInfo(String id) throws FormatException, IOException { 
     231    setId(id); 
     232    return getInfo(); 
     233  } 
     234 
    218235} 
  • trunk/loci/formats/in/SlidebookReader.java

    r2641 r2687  
    5252  public SlidebookReader() { super("Intelligent Imaging Slidebook", "sld"); } 
    5353 
    54   // -- FormatReader API methods -- 
     54  // -- IFormatReader API methods -- 
    5555 
    5656  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    8888  } 
    8989 
    90   /** Initializes the given Slidebook file. */ 
     90  // -- Internal FormatReader API methods -- 
     91 
     92  /* @see loci.formats.FormatReader#initFile(String) */ 
    9193  protected void initFile(String id) throws FormatException, IOException { 
    9294    if (debug) debug("SlidebookReader.initFile(" + id + ")"); 
  • trunk/loci/formats/in/TiffReader.java

    r2672 r2687  
    6161    if (core.sizeZ == null) core.sizeZ = new int[1]; 
    6262    core.sizeZ[0] = zSize; 
     63  } 
     64 
     65  // -- IFormatReader API methods -- 
     66 
     67  /* @see loci.formats.IFormatReader#getSeriesCount() */ 
     68  public int getSeriesCount() { 
     69    return core.currentOrder.length; 
    6370  } 
    6471 
     
    513520  } 
    514521 
    515   // -- IFormatReader API methods -- 
    516  
    517   /* @see loci.formats.IFormatReader#getSeriesCount() */ 
    518   public int getSeriesCount() { 
    519     return core.currentOrder.length; 
    520   } 
    521  
    522522} 
  • trunk/loci/formats/in/ZeissLSMReader.java

    r2674 r2687  
    4949  public ZeissLSMReader() { super("Zeiss Laser-Scanning Microscopy", "lsm"); } 
    5050 
    51   // -- FormatReader API methods -- 
     51  // -- IFormatReader API methods -- 
    5252 
    5353  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    7777  } 
    7878 
     79  /* @see loci.formats.IFormatReader#openBytes(int) */ 
     80  public byte[] openBytes(int no) throws FormatException, IOException { 
     81    if (no < 0 || no >= getImageCount()) { 
     82      throw new FormatException("Invalid image number: " + no); 
     83    } 
     84 
     85    byte[] b = new byte[core.sizeX[0] * core.sizeY[0] * core.sizeC[0] * 
     86      FormatTools.getBytesPerPixel(core.pixelType[0])]; 
     87    return openBytes(no, b); 
     88  } 
     89 
     90  /* @see loci.formats.IFormatReader#openBytes(int, byte[]) */ 
     91  public byte[] openBytes(int no, byte[] buf) 
     92    throws FormatException, IOException 
     93  { 
     94    if (no < 0 || no >= getImageCount()) { 
     95      throw new FormatException("Invalid image number: " + no); 
     96    } 
     97 
     98    int bpp = FormatTools.getBytesPerPixel(core.pixelType[0]); 
     99 
     100    if (buf.length < core.sizeX[0] * core.sizeY[0] * core.sizeC[0] * bpp) { 
     101      throw new FormatException("Buffer too small."); 
     102    } 
     103 
     104    ifds = TiffTools.getIFDs(in); 
     105    TiffTools.getSamples(ifds[2*no], in, buf); 
     106    return swapIfRequired(buf); 
     107  } 
     108 
     109  /* @see loci.formats.IFormatReader#openImage(int) */ 
     110  public BufferedImage openImage(int no) throws FormatException, IOException { 
     111    if (no < 0 || no >= getImageCount()) { 
     112      throw new FormatException("Invalid image number: " + no); 
     113    } 
     114 
     115    ifds = TiffTools.getIFDs(in); 
     116    return TiffTools.getImage(ifds[2*no], in); 
     117  } 
     118 
    79119  /* @see loci.formats.IFormatReader#openThumbImage(int) */ 
    80120  public BufferedImage openThumbImage(int no) 
     
    89129  } 
    90130 
    91   /* @see loci.formats.IFormatReader#openImage(int) */ 
    92   public BufferedImage openImage(int no) throws FormatException, IOException { 
    93     if (no < 0 || no >= getImageCount()) { 
    94       throw new FormatException("Invalid image number: " + no); 
    95     } 
    96  
    97     ifds = TiffTools.getIFDs(in); 
    98     return TiffTools.getImage(ifds[2*no], in); 
    99   } 
    100  
    101   /* @see loci.formats.IFormatReader#openBytes(int) */ 
    102   public byte[] openBytes(int no) throws FormatException, IOException { 
    103     if (no < 0 || no >= getImageCount()) { 
    104       throw new FormatException("Invalid image number: " + no); 
    105     } 
    106  
    107     byte[] b = new byte[core.sizeX[0] * core.sizeY[0] * core.sizeC[0] * 
    108       FormatTools.getBytesPerPixel(core.pixelType[0])]; 
    109     return openBytes(no, b); 
    110   } 
    111  
    112   /* @see loci.formats.IFormatReader#openBytes(int, byte[]) */ 
    113   public byte[] openBytes(int no, byte[] buf) 
    114     throws FormatException, IOException 
    115   { 
    116     if (no < 0 || no >= getImageCount()) { 
    117       throw new FormatException("Invalid image number: " + no); 
    118     } 
    119  
    120     int bpp = FormatTools.getBytesPerPixel(core.pixelType[0]); 
    121  
    122     if (buf.length < core.sizeX[0] * core.sizeY[0] * core.sizeC[0] * bpp) { 
    123       throw new FormatException("Buffer too small."); 
    124     } 
    125  
    126     ifds = TiffTools.getIFDs(in); 
    127     TiffTools.getSamples(ifds[2*no], in, buf); 
    128     return swapIfRequired(buf); 
    129   } 
    130  
    131   /** Initializes the given Zeiss LSM file. */ 
    132   protected void initFile(String id) throws FormatException, IOException { 
    133     if (debug) debug("ZeissLSMReader.initFile(" + id + ")"); 
    134     super.initFile(id); 
    135  
    136     // go through the IFD hashtable array and 
    137     // remove anything with NEW_SUBFILE_TYPE = 1 
    138     // NEW_SUBFILE_TYPE = 1 indicates that the IFD 
    139     // contains a thumbnail image 
    140  
    141     status("Removing thumbnails"); 
    142  
    143     int numThumbs = 0; 
    144     long prevOffset = 0; 
    145     byte[] b = new byte[48]; 
    146     byte[] c = new byte[48]; 
    147     for (int i=0; i<ifds.length; i++) { 
    148       long subFileType = TiffTools.getIFDLongValue(ifds[i], 
    149         TiffTools.NEW_SUBFILE_TYPE, true, 0); 
    150       long[] offsets = TiffTools.getStripOffsets(ifds[i]); 
    151  
    152       if (subFileType == 1) { 
    153         ifds[i] = null; 
    154         numThumbs++; 
    155       } 
    156       else if (i > 0) { 
    157         // make sure that we don't grab the thumbnail by accident 
    158         // there's probably a better way to do this 
    159  
    160         in.seek(prevOffset); 
    161         in.read(b); 
    162         in.seek(offsets[0]); 
    163         in.read(c); 
    164  
    165         boolean equal = true; 
    166         for (int j=0; j<48; j++) { 
    167           if (b[j] != c[j]) { 
    168             equal = false; 
    169             j = 48; 
    170           } 
    171         } 
    172  
    173         if (equal) { 
    174           offsets[0] += (offsets[0] - prevOffset); 
    175           TiffTools.putIFDValue(ifds[i], TiffTools.STRIP_OFFSETS, offsets); 
    176         } 
    177       } 
    178       prevOffset = offsets[0]; 
    179     } 
    180  
    181     // now copy ifds to a temp array so that we can get rid of 
    182     // any null entries 
    183  
    184     int ifdPointer = 0; 
    185     Hashtable[] tempIFDs = new Hashtable[ifds.length - numThumbs]; 
    186     for (int i=0; i<tempIFDs.length; i++) { 
    187       if (ifds[ifdPointer] != null) { 
    188         tempIFDs[i] = ifds[ifdPointer]; 
    189         ifdPointer++; 
    190       } 
    191       else { 
    192         while ((ifds[ifdPointer] == null) && ifdPointer < ifds.length) { 
    193           ifdPointer++; 
    194         } 
    195         tempIFDs[i] = ifds[ifdPointer]; 
    196         ifdPointer++; 
    197       } 
    198     } 
    199  
    200     // reset numImages and ifds 
    201     core.imageCount[0] = tempIFDs.length; 
    202     ifds = tempIFDs; 
    203     initMetadata(); 
    204     ifds = TiffTools.getIFDs(in); 
    205   
    206     if (ifds.length > 1) { 
    207       core.thumbSizeX[0] = TiffTools.getIFDIntValue(ifds[1],  
    208         TiffTools.IMAGE_WIDTH, false, 1); 
    209       core.thumbSizeY[0] = TiffTools.getIFDIntValue(ifds[1],  
    210         TiffTools.IMAGE_LENGTH, false, 1); 
    211     }  
    212   } 
     131  // -- Internal BaseTiffReader API methods -- 
    213132 
    214133  /* @see BaseTiffReader#initMetadata() */ 
     
    579498        i = dirList.length; 
    580499      } 
     500    } 
     501  } 
     502 
     503  // -- Internal FormatReader API methods -- 
     504 
     505  /* @see loci.formats.FormatReader#initFile(String) */ 
     506  protected void initFile(String id) throws FormatException, IOException { 
     507    if (debug) debug("ZeissLSMReader.initFile(" + id + ")"); 
     508    super.initFile(id); 
     509 
     510    // go through the IFD hashtable array and 
     511    // remove anything with NEW_SUBFILE_TYPE = 1 
     512    // NEW_SUBFILE_TYPE = 1 indicates that the IFD 
     513    // contains a thumbnail image 
     514 
     515    status("Removing thumbnails"); 
     516 
     517    int numThumbs = 0; 
     518    long prevOffset = 0; 
     519    byte[] b = new byte[48]; 
     520    byte[] c = new byte[48]; 
     521    for (int i=0; i<ifds.length; i++) { 
     522      long subFileType = TiffTools.getIFDLongValue(ifds[i], 
     523        TiffTools.NEW_SUBFILE_TYPE, true, 0); 
     524      long[] offsets = TiffTools.getStripOffsets(ifds[i]); 
     525 
     526      if (subFileType == 1) { 
     527        ifds[i] = null; 
     528        numThumbs++; 
     529      } 
     530      else if (i > 0) { 
     531        // make sure that we don't grab the thumbnail by accident 
     532        // there's probably a better way to do this 
     533 
     534        in.seek(prevOffset); 
     535        in.read(b); 
     536        in.seek(offsets[0]); 
     537        in.read(c); 
     538 
     539        boolean equal = true; 
     540        for (int j=0; j<48; j++) { 
     541          if (b[j] != c[j]) { 
     542            equal = false; 
     543            j = 48; 
     544          } 
     545        } 
     546 
     547        if (equal) { 
     548          offsets[0] += (offsets[0] - prevOffset); 
     549          TiffTools.putIFDValue(ifds[i], TiffTools.STRIP_OFFSETS, offsets); 
     550        } 
     551      } 
     552      prevOffset = offsets[0]; 
     553    } 
     554 
     555    // now copy ifds to a temp array so that we can get rid of 
     556    // any null entries 
     557 
     558    int ifdPointer = 0; 
     559    Hashtable[] tempIFDs = new Hashtable[ifds.length - numThumbs]; 
     560    for (int i=0; i<tempIFDs.length; i++) { 
     561      if (ifds[ifdPointer] != null) { 
     562        tempIFDs[i] = ifds[ifdPointer]; 
     563        ifdPointer++; 
     564      } 
     565      else { 
     566        while ((ifds[ifdPointer] == null) && ifdPointer < ifds.length) { 
     567          ifdPointer++; 
     568        } 
     569        tempIFDs[i] = ifds[ifdPointer]; 
     570        ifdPointer++; 
     571      } 
     572    } 
     573 
     574    // reset numImages and ifds 
     575    core.imageCount[0] = tempIFDs.length; 
     576    ifds = tempIFDs; 
     577    initMetadata(); 
     578    ifds = TiffTools.getIFDs(in); 
     579 
     580    if (ifds.length > 1) { 
     581      core.thumbSizeX[0] = TiffTools.getIFDIntValue(ifds[1], 
     582        TiffTools.IMAGE_WIDTH, false, 1); 
     583      core.thumbSizeY[0] = TiffTools.getIFDIntValue(ifds[1], 
     584        TiffTools.IMAGE_LENGTH, false, 1); 
    581585    } 
    582586  } 
     
    736740  } 
    737741 
    738   // -- Main method -- 
    739  
    740   public static void main(String[] args) throws FormatException, IOException { 
    741     new ZeissLSMReader().testRead(args); 
    742   } 
    743  
    744742} 
  • trunk/loci/formats/in/ZeissZVIReader.java

    r2684 r2687  
    197197  } 
    198198 
    199   /* @see loci.formats.IFormatReader#close() */ 
     199  // -- IFormatHandler API methods -- 
     200 
     201  /* @see loci.formats.IFormatHandler#close() */ 
    200202  public void close() throws IOException { 
    201203    super.close(); 
     
    213215  } 
    214216 
    215   /** Initializes the given ZVI file. */ 
     217  // -- Internal FormatReader API methods -- 
     218 
     219  /* @see loci.formats.FormatReader#initFile(String) */ 
    216220  protected void initFile(String id) throws FormatException, IOException { 
    217221    if (debug) debug("ZeissZVIReader.initFile(" + id + ")"); 
     
    20112015  } 
    20122016 
    2013   // -- Main method -- 
    2014  
    2015   public static void main(String[] args) throws FormatException, IOException { 
    2016     new ZeissZVIReader().testRead(args); 
    2017   } 
    2018  
    20192017} 
  • trunk/loci/formats/ome/OMEWriter.java

    r2682 r2687  
    8585  } 
    8686 
    87   // -- Internal FormatHandler API methods -- 
    88  
     87  // -- Internal OMEWriter API methods -- 
     88 
     89  /** Fires a status update event. */ 
    8990  protected void status(String message) { 
    9091    status(new StatusEvent(message)); 
    9192  } 
    9293 
     94  /** Fires a status update event. */ 
    9395  protected void status(int progress, int maximum, String message) { 
    9496    status(new StatusEvent(progress, maximum, message)); 
    9597  } 
    9698 
     99  /** Fires a status update event. */ 
    97100  protected void status(StatusEvent e) { 
    98101    StatusListener[] l = getStatusListeners(); 
     
    102105  // -- IFormatWriter API methods -- 
    103106 
     107  /* @see loci.formats.IFormatWriter#saveImage(String, Image, boolean) */ 
     108  public void saveImage(java.awt.Image image, boolean last) 
     109    throws FormatException, IOException 
     110  { 
     111    byte[][] b = ImageTools.getPixelBytes(ImageTools.makeBuffered(image), 
     112      !metadata.getBigEndian(null).booleanValue()); 
     113    for (int i=0; i<b.length; i++) { 
     114      saveBytes(b[i], last && (i == b.length - 1)); 
     115    } 
     116  } 
     117 
    104118  /* @see loci.formats.IFormatWriter#saveBytes(String, byte[], boolean) */ 
    105   public void saveBytes(String id, byte[] bytes, boolean last) 
     119  public void saveBytes(byte[] bytes, boolean last) 
    106120    throws FormatException, IOException 
    107121  { 
     
    109123      // parse the ID string to get the server, user name and password 
    110124 
    111       server = id.substring(0, id.lastIndexOf("?")); 
    112       int ndx = id.indexOf("&"); 
    113       if (id.indexOf("user") != -1) { 
    114         user = id.substring(id.lastIndexOf("?") + 6, ndx); 
    115         pass = id.substring(ndx + 10); 
     125      server = currentId.substring(0, currentId.lastIndexOf("?")); 
     126      int ndx = currentId.indexOf("&"); 
     127      if (currentId.indexOf("user") != -1) { 
     128        user = currentId.substring(currentId.lastIndexOf("?") + 6, ndx); 
     129        pass = currentId.substring(ndx + 10); 
    116130      } 
    117131      else { 
    118132        throw new FormatException("Invalid ID - must be of the form " + 
    119           "<server>?user=<username>&password=<password>");  
     133          "<server>?user=<username>&password=<password>"); 
    120134      } 
    121135      login(); 
    122136 
    123       // initialize necessary services  
    124       
     137      // initialize necessary services 
     138 
    125139      df = (DataFactory) rs.getService(DataFactory.class); 
    126140      im = (ImportManager) rs.getService(ImportManager.class); 
    127141      pf = (PixelsFactory) rs.getService(PixelsFactory.class); 
    128      
     142 
    129143      FieldsSpecification fields = new FieldsSpecification(); 
    130144      fields.addWantedField("id"); 
     
    140154        throw new FormatException("Could not find repository.", e); 
    141155      } 
    142      
    143       im.startImport(exp);  
    144      
     156 
     157      im.startImport(exp); 
     158 
    145159      if (metadata == null) { 
    146         throw new FormatException("Metadata store not specified.");  
    147       }  
    148     } 
    149    
     160        throw new FormatException("Metadata store not specified."); 
     161      } 
     162    } 
     163 
    150164    int z = metadata.getSizeZ(null).intValue(); 
    151165    int c = metadata.getSizeC(null).intValue(); 
     
    153167    String order = metadata.getDimensionOrder(null); 
    154168 
    155     ImageServer is = ImageServer.getHTTPImageServer(omeis, sessionKey);  
    156     /* debug */ System.out.println("omeis : " + omeis);  
     169    ImageServer is = ImageServer.getHTTPImageServer(omeis, sessionKey); 
    157170    if (pixelsId == -1) { 
    158       try {  
    159         pixelsId = is.newPixels(metadata.getSizeX(null).intValue(),  
    160           metadata.getSizeY(null).intValue(), z, c, t,  
     171      try { 
     172        pixelsId = is.newPixels(metadata.getSizeX(null).intValue(), 
     173          metadata.getSizeY(null).intValue(), z, c, t, 
    161174          FormatTools.getBytesPerPixel(FormatTools.pixelTypeFromString( 
    162           metadata.getPixelType(null))), false,  
     175          metadata.getPixelType(null))), false, 
    163176          metadata.getPixelType(null).equals("float")); 
    164177      } 
     
    168181    } 
    169182 
    170     try {  
     183    try { 
    171184      int planeLength = metadata.getSizeX(null).intValue() * 
    172185        metadata.getSizeY(null).intValue() * FormatTools.getBytesPerPixel( 
     
    174187      byte[][] b = ImageTools.splitChannels(bytes, bytes.length / planeLength, 
    175188        false, true); 
    176       
     189 
    177190      for (int ch=0; ch<b.length; ch++) { 
    178         int[] coords = FormatTools.getZCTCoords(order, z, c, t, z*c*t,  
     191        int[] coords = FormatTools.getZCTCoords(order, z, c, t, z*c*t, 
    179192          planesWritten); 
    180           
    181         is.setPlane(pixelsId, coords[0], coords[1], coords[2], b[ch],  
     193 
     194        is.setPlane(pixelsId, coords[0], coords[1], coords[2], b[ch], 
    182195          metadata.getBigEndian(null).booleanValue()); 
    183         planesWritten++;  
    184       }  
    185     }  
     196        planesWritten++; 
     197      } 
     198    } 
    186199    catch (ImageServerException e) { 
    187200      throw new FormatException("Failed to upload plane.", e); 
     
    189202 
    190203    if (last) { 
    191       try {  
     204      try { 
    192205        pixelsId = is.finishPixels(pixelsId); 
    193206      } 
     
    225238 
    226239      try { 
    227         pf.setThumbnail(pixels,  
     240        pf.setThumbnail(pixels, 
    228241          CompositingSettings.createDefaultPGISettings(z, c, t)); 
    229242      } 
     
    231244        throw new FormatException("Failed to create thumbnail.", e); 
    232245      } 
    233        
     246 
    234247      df.update(pixels); 
    235248 
     
    241254      df.markForUpdate(logical); 
    242255 
    243       PixelChannelComponent physical =  
     256      PixelChannelComponent physical = 
    244257        (PixelChannelComponent) df.createNew("PixelChannelComponent"); 
    245258      physical.setImage(img); 
     
    249262      physical.setModuleExecution(ii); 
    250263      df.markForUpdate(physical); 
    251        
     264 
    252265      ii.setStatus("FINISHED"); 
    253266      df.markForUpdate(ii); 
    254        
     267 
    255268      img.setDefaultPixels(pixels); 
    256       df.update(img);  
    257  
    258       close();  
    259     }  
    260   } 
    261  
    262   /* @see loci.formats.IFormatWriter#saveImage(String, Image, boolean) */ 
    263   public void saveImage(String id, java.awt.Image image, boolean last) 
    264     throws FormatException, IOException 
    265   { 
    266     byte[][] b = ImageTools.getPixelBytes(ImageTools.makeBuffered(image),  
    267       !metadata.getBigEndian(null).booleanValue()); 
    268     for (int i=0; i<b.length; i++) { 
    269       saveBytes(id, b[i], last && (i == b.length - 1)); 
    270     } 
    271   } 
    272    
    273   /* @see loci.formats.IFormatWriter#close() */ 
    274   public void close() throws FormatException, IOException { 
    275     rc.logout();  
     269      df.update(img); 
     270 
     271      close(); 
     272    } 
     273  } 
     274 
     275  /* @see loci.formats.IFormatWriter#canDoStacks(String) */ 
     276  public boolean canDoStacks() { return true; } 
     277 
     278  // -- IFormatHandler API methods -- 
     279 
     280  /* @see loci.formats.IFormatHandler#close() */ 
     281  public void close() throws IOException { 
     282    rc.logout(); 
    276283    pixelsId = -1; 
    277284    validLogin = false; 
    278285    planesWritten = 0; 
    279     metadata = null;  
    280   } 
    281  
    282   /* @see loci.formats.IFormatWriter#canDoStacks(String) */ 
    283   public boolean canDoStacks(String id) { return true; } 
     286    metadata = null; 
     287  } 
    284288 
    285289  // -- StatusReporter API methods -- 
     
    309313 
    310314  // -- Helper methods -- 
    311   
     315 
    312316  private void login() throws FormatException { 
    313317    while (server.lastIndexOf("/") > 7) { 
    314       server = server.substring(0, server.lastIndexOf("/"));  
    315     }  
    316     omeis = server + "/cgi-bin/omeis";  
     318      server = server.substring(0, server.lastIndexOf("/")); 
     319    } 
     320    omeis = server + "/cgi-bin/omeis"; 
    317321    server += "/shoola"; 
    318322    if (!server.startsWith("http://")) { 
    319323      server = "http://" + server; 
    320       omeis = "http://" + omeis;  
    321     } 
    322   
     324      omeis = "http://" + omeis; 
     325    } 
     326 
    323327    status("Logging in to " + server); 
    324328 
     
    333337    catch (Exception e) { 
    334338      validLogin = false; 
    335       throw new FormatException("Login failed", e);  
     339      throw new FormatException("Login failed", e); 
    336340    } 
    337341  } 
  • trunk/loci/formats/out/AVIWriter.java

    r2682 r2687  
    9191  // -- IFormatWriter API methods -- 
    9292 
    93   /* @see loci.formats.IFormatWriter#saveBytes(String, byte[], boolean) */ 
    94   public void saveBytes(String id, byte[] bytes, boolean last) 
    95     throws FormatException, IOException 
    96   { 
    97     throw new FormatException("Not implemented yet."); 
    98   } 
    99  
    100   /* @see loci.formats.IFormatWriter#saveImage(String, Image, boolean) */ 
    101   public void saveImage(String id, Image image, boolean last) 
     93  /* @see loci.formats.IFormatWriter#saveImage(Image, boolean) */ 
     94  public void saveImage(Image image, boolean last) 
    10295    throws FormatException, IOException 
    10396  { 
     
    110103    byte[][] byteData = ImageTools.getBytes(img); 
    111104 
    112     if (!id.equals(currentId)) { 
     105    if (!initialized) { 
     106      initialized = true; 
    113107      planesWritten = 0; 
    114       currentId = id; 
    115108      bytesPerPixel = byteData.length; 
    116109 
    117       file = new File(id); 
     110      file = new File(currentId); 
    118111      raFile = new RandomAccessFile(file, "rw"); 
    119112      raFile.seek(raFile.length()); 
     
    524517  } 
    525518 
    526   /* @see loci.formats.IFormatWriter#close() */ 
    527   public void close() throws FormatException, IOException { 
     519  /* @see loci.formats.IFormatWriter#canDoStacks() */ 
     520  public boolean canDoStacks() { return true; } 
     521 
     522  /* @see loci.formats.IFormatWriter#getPixelTypes() */ 
     523  public int[] getPixelTypes() { 
     524    return new int[] {FormatTools.UINT8}; 
     525  } 
     526 
     527  // -- IFormatHandler API methods -- 
     528 
     529  /* @see loci.formats.IFormatHandler#close() */ 
     530  public void close() throws IOException { 
    528531    if (raFile != null) raFile.close(); 
    529532    raFile = null; 
    530533    currentId = null; 
     534    initialized = false; 
    531535  } 
    532536 
    533   /* @see loci.formats.IFormatWriter#canDoStacks(String) */  
    534   public boolean canDoStacks(String id) { return true; } 
    535  
    536   /* @see loci.formats.IFormatWriter#getPixelTypes(String) */ 
    537   public int[] getPixelTypes(String id) throws FormatException, IOException { 
    538     return new int[] {FormatTools.UINT8}; 
    539   } 
    540  
    541   // -- Main method -- 
    542  
    543   public static void main(String[] args) throws IOException, FormatException { 
    544     new AVIWriter().testConvert(args); 
    545   } 
    546  
    547537} 
  • trunk/loci/formats/out/EPSWriter.java

    r2682 r2687  
    4848  // -- IFormatWriter API methods -- 
    4949 
    50   /* @see loci.formats.IFormatWriter#saveBytes(String, byte[], boolean) */ 
    51   public void saveBytes(String id, byte[] bytes, boolean last) 
    52     throws FormatException, IOException 
    53   { 
    54     throw new FormatException("Not implemented yet."); 
    55   } 
    56  
    57   /* @see loci.formats.IFormatWriter#saveImage(String, Image, boolean) */  
    58   public void saveImage(String id, Image image, boolean last) 
     50  /* @see loci.formats.IFormatWriter#saveImage(Image, boolean) */ 
     51  public void saveImage(Image image, boolean last) 
    5952    throws FormatException, IOException 
    6053  { 
     
    6356    } 
    6457 
    65     out = new RandomAccessFile(id, "rw"); 
     58    out = new RandomAccessFile(currentId, "rw"); 
    6659 
    6760    BufferedImage img = (cm == null) ? 
     
    7871 
    7972    DataTools.writeString(out, "%!PS-Adobe-2.0 EPSF-1.2\n"); 
    80     DataTools.writeString(out, "%%Title: " + id + "\n"); 
     73    DataTools.writeString(out, "%%Title: " + currentId + "\n"); 
    8174    DataTools.writeString(out, "%%Creator: LOCI Bio-Formats\n"); 
    8275    DataTools.writeString(out, "%%Pages: 1\n"); 
     
    148141  } 
    149142 
    150   /* @see loci.formats.IFormatWriter#close() */ 
    151   public void close() throws FormatException, IOException { 
     143  /* @see loci.formats.IFormatWriter#getPixelTypes() */ 
     144  public int[] getPixelTypes() { 
     145    return new int[] {FormatTools.UINT8}; 
     146  } 
     147 
     148  // -- IFormatHandler API methods -- 
     149 
     150  /* @see loci.formats.IFormatHandler#close() */ 
     151  public void close() throws IOException { 
    152152    if (out != null) out.close(); 
    153153    out = null; 
    154154    currentId = null; 
    155   } 
    156  
    157   /* @see loci.formats.IFormatWriter#canDoStacks(String) */  
    158   public boolean canDoStacks(String id) { return false; } 
    159  
    160   /* @see loci.formats.IFormatWriter#getPixelTypes(String) */ 
    161   public int[] getPixelTypes(String id) throws FormatException, IOException { 
    162     return new int[] {FormatTools.UINT8}; 
    163   } 
    164  
    165   // -- Main method -- 
    166  
    167   public static void main(String[] args) throws IOException, FormatException { 
    168     new EPSWriter().testConvert(args); 
     155    initialized = false; 
    169156  } 
    170157 
  • trunk/loci/formats/out/ImageIOWriter.java

    r2682 r2687  
    6868  // -- IFormatWriter API methods -- 
    6969 
    70   /* @see loci.formats.IFormatWriter#saveBytes(String, byte[], boolean) */ 
    71   public void saveBytes(String id, byte[] bytes, boolean last) 
    72     throws FormatException, IOException 
    73   { 
    74     throw new FormatException("Not implemented yet."); 
    75   } 
    76  
    77   /* @see loci.formats.IFormatWriter#saveImage(String, Image, boolean) */  
    78   public void saveImage(String id, Image image, boolean last) 
     70  /* @see loci.formats.IFormatWriter#saveImage(Image, boolean) */ 
     71  public void saveImage(Image image, boolean last) 
    7972    throws FormatException, IOException 
    8073  { 
     
    8578    } 
    8679    out = new DataOutputStream(new BufferedOutputStream( 
    87       new FileOutputStream(id), 4096)); 
     80      new FileOutputStream(currentId), 4096)); 
    8881    ImageIO.write(img, kind, out); 
    8982  } 
    9083 
    91   /* @see loci.formats.IFormatWriter#close() */ 
    92   public void close() throws FormatException, IOException { 
     84  /* @see loci.formats.IFormatWriter#getPixelTypes() */ 
     85  public int[] getPixelTypes() { 
     86    return new int[] {FormatTools.UINT8, FormatTools.UINT16}; 
     87  } 
     88 
     89  // -- IFormatHandler API methods -- 
     90 
     91  /* @see loci.formats.IFormatHandler#close() */ 
     92  public void close() throws IOException { 
    9393    if (out != null) out.close(); 
    9494    out = null; 
    9595    currentId = null; 
    96   } 
    97  
    98   /* @see loci.formats.IFormatWriter#canDoStacks(String) */  
    99   public boolean canDoStacks(String id) { return false; } 
    100  
    101   /* @see loci.formats.IFormatWriter#getPixelTypes(String) */ 
    102   public int[] getPixelTypes(String id) throws FormatException, IOException { 
    103     return new int[] {FormatTools.UINT8, FormatTools.UINT16}; 
     96    initialized = false; 
    10497  } 
    10598 
  • trunk/loci/formats/out/JPEGWriter.java

    r2574 r2687  
    4242  // -- IFormatWriter API methods -- 
    4343 
    44   /* @see loci.formats.IFormatWriter#save(String, Image, boolean) */ 
    45   public void saveImage(String id, Image image, boolean last) 
     44  /* @see loci.formats.IFormatWriter#save(Image, boolean) */ 
     45  public void saveImage(Image image, boolean last) 
    4646    throws FormatException, IOException 
    4747  { 
     
    5252      throw new FormatException("16-bit data not supported."); 
    5353    } 
    54     super.saveImage(id, image, last); 
     54    super.saveImage(image, last); 
    5555  } 
    5656 
    5757  /* @see loci.formats.IFormatWriter#getPixelTypes(String) */ 
    58   public int[] getPixelTypes(String id) throws FormatException, IOException { 
     58  public int[] getPixelTypes() { 
    5959    return new int[] {FormatTools.UINT8}; 
    6060  } 
    6161 
    62   // -- Main method -- 
    63  
    64   public static void main(String[] args) throws FormatException, IOException { 
    65     new JPEGWriter().testConvert(args); 
    66   } 
    67  
    6862} 
  • trunk/loci/formats/out/LegacyQTWriter.java

    r2682 r2687  
    106106  // -- IFormatWriter API methods -- 
    107107 
    108   /* @see loci.formats.IFormatWriter#saveBytes(String, byte[], boolean) */ 
    109   public void saveBytes(String id, byte[] bytes, boolean last) 
    110     throws FormatException, IOException 
    111   { 
    112     throw new FormatException("Not implemented yet."); 
    113   } 
    114  
    115   /* @see loci.formats.IFormatWriter#saveImage(String, Image, boolean) */ 
    116   public void saveImage(String id, Image image, boolean last) 
     108  /* @see loci.formats.IFormatWriter#saveImage(Image, boolean) */ 
     109  public void saveImage(Image image, boolean last) 
    117110    throws FormatException, IOException 
    118111  { 
     
    127120    if (!tools.canDoQT()) throw new FormatException(LegacyQTTools.NO_QT_MSG); 
    128121 
    129     if (!id.equals(currentId)) { 
    130       currentId = id; 
     122    if (!initialized) { 
     123      initialized = true; 
    131124 
    132125      try { 
     
    135128        width = img.getWidth(); 
    136129        height = img.getHeight(); 
    137         File f = new File(id); 
     130        File f = new File(currentId); 
    138131        r.setVar("f", f); 
    139132        r.setVar("width", (float) width); 
     
    280273  } 
    281274 
    282   /* @see loci.formats.IFormatWriter#close() */ 
    283   public void close() throws FormatException, IOException { 
     275  /* @see loci.formats.IFormatWriter#canDoStacks() */ 
     276  public boolean canDoStacks() { return true; } 
     277 
     278  // -- IFormatHandler API methods -- 
     279 
     280  /* @see loci.formats.IFormatHandler#close() */ 
     281  public void close() throws IOException { 
    284282    r = null; 
    285283    numWritten = 0; 
     
    287285    height = 0; 
    288286    pixels2 = null; 
     287    currentId = null; 
     288    initialized = false; 
    289289  } 
    290290 
    291   /* @see loci.formats.IFormatWriter#canDoStacks(String) */ 
    292   public boolean canDoStacks(String id) { return true; } 
    293  
    294   // -- Main method -- 
    295  
    296   public static void main(String[] args) throws IOException, FormatException { 
    297     new LegacyQTWriter().testConvert(args); 
    298   } 
    299  
    300291} 
  • trunk/loci/formats/out/PNGWriter.java

    r2178 r2687  
    2525package loci.formats.out; 
    2626 
    27 import java.io.IOException; 
    28 import loci.formats.*; 
    29  
    3027/** PNGWriter is the file format writer for PNG files. */ 
    3128public class PNGWriter extends ImageIOWriter { 
     
    3734  } 
    3835 
    39   // -- Main method -- 
    40  
    41   public static void main(String[] args) throws FormatException, IOException { 
    42     new PNGWriter().testConvert(args); 
    43   } 
    44  
    4536} 
  • trunk/loci/formats/out/QTWriter.java

    r2682 r2687  
    150150  // -- IFormatWriter API methods -- 
    151151 
    152   /* @see loci.formats.IFormatWriter#saveBytes(String, byte[], boolean) */ 
    153   public void saveBytes(String id, byte[] bytes, boolean last) 
     152  /* @see loci.formats.IFormatWriter#saveImage(Image, boolean) */ 
     153  public void saveImage(Image image, boolean last) 
    154154    throws FormatException, IOException 
    155155  { 
    156     throw new FormatException("Not implemented yet."); 
    157   } 
    158  
    159   /* @see loci.formats.IFormatWriter#saveImage(String, Image, boolean) */ 
    160   public void saveImage(String id, Image image, boolean last) 
    161     throws FormatException, IOException 
    162   { 
    163     if (image == null) { 
    164       throw new FormatException("Image is null"); 
    165     } 
    166  
    167     if (legacy == null) { 
    168       legacy = new LegacyQTWriter(); 
    169     } 
     156    if (image == null) throw new FormatException("Image is null"); 
     157    if (legacy == null) legacy = new LegacyQTWriter(); 
    170158 
    171159    if (needLegacy) { 
    172       legacy.saveImage(id, image, last); 
     160      legacy.setId(currentId); 
     161      legacy.saveImage(image, last); 
    173162      return; 
    174163    } 
     
    223212    } 
    224213 
    225     if (!id.equals(currentId)) { 
    226       close(); 
     214    if (!initialized) { 
     215      initialized = true; 
    227216      setCodec(); 
    228217      if (codec != 0) { 
    229218        needLegacy = true; 
    230219        legacy.setCodec(codec); 
    231         legacy.saveImage(id, image, last); 
     220        legacy.setId(currentId); 
     221        legacy.saveImage(image, last); 
    232222        return; 
    233223      } 
     
    236226 
    237227      offsets = new Vector(); 
    238       currentId = id; 
    239       out = new RandomAccessFile(id, "rw"); 
     228      out = new RandomAccessFile(currentId, "rw"); 
    240229      created = (int) System.currentTimeMillis(); 
    241230      numWritten = 0; 
     
    583572  } 
    584573 
    585   /* @see loci.formats.IFormatWriter#close() */ 
    586   public void close() throws FormatException, IOException { 
     574  /* @see loci.formats.IFormatWriter#canDoStacks() */ 
     575  public boolean canDoStacks() { return true; } 
     576 
     577  /* @see loci.formats.IFormatWriter#getPixelTypes(String) */ 
     578  public int[] getPixelTypes() { 
     579    return new int[] {FormatTools.UINT8, FormatTools.UINT16}; 
     580  } 
     581 
     582  // -- IFormatHandler API methods -- 
     583 
     584  /* @see loci.formats.IFormatHandler#close() */ 
     585  public void close() throws IOException { 
    587586    if (out != null) out.close(); 
    588587    out = null; 
     
    592591    created = 0; 
    593592    offsets = null; 
     593    currentId = null; 
     594    initialized = false; 
    594595  } 
    595596 
    596   /* @see loci.formats.IFormatWriter#canDoStacks(String) */ 
    597   public boolean canDoStacks(String id) { return true; } 
    598  
    599   /* @see loci.formats.IFormatWriter#getPixelTypes(String) */ 
    600   public int[] getPixelTypes(String id) throws FormatException, IOException { 
    601     return new int[] {FormatTools.UINT8, FormatTools.UINT16}; 
    602   } 
    603  
    604   // -- Helper method -- 
     597  // -- Helper methods -- 
    605598 
    606599  private void setCodec() { 
     
    616609  } 
    617610 
    618   // -- Main method -- 
    619  
    620   public static void main(String[] args) throws IOException, FormatException { 
    621     new QTWriter().testConvert(args); 
    622   } 
    623  
    624611} 
  • trunk/loci/formats/out/TiffWriter.java

    r2682 r2687  
    3030import java.util.*; 
    3131import loci.formats.*; 
    32  
    3332//import org.openmicroscopy.xml.*; 
    3433//import org.openmicroscopy.xml.st.*; 
     
    6261   * the last flag must be set. 
    6362   */ 
    64   public void saveImage(String id, Image image, Hashtable ifd, boolean last) 
     63  public void saveImage(Image image, Hashtable ifd, boolean last) 
    6564    throws IOException, FormatException 
    6665  { 
    67     if (!id.equals(currentId)) { 
    68       close(); 
    69       currentId = id; 
     66    if (!initialized) { 
     67      initialized = true; 
    7068      out = 
    7169        new BufferedOutputStream(new FileOutputStream(currentId, true), 4096); 
     
    10098 
    10199    lastOffset += TiffTools.writeImage(img, ifd, out, lastOffset, last); 
    102     if (last) { 
    103       close(); 
    104     } 
     100    if (last) close(); 
    105101  } 
    106102 
    107103  // -- IFormatWriter API methods -- 
    108104 
    109   /* @see loci.formats.IFormatWriter#saveBytes(String, byte[], boolean) */ 
    110   public void saveBytes(String id, byte[] bytes, boolean last) 
    111     throws FormatException, IOException 
    112   { 
    113     throw new FormatException("Not implemented yet."); 
    114   } 
    115  
    116105  /* @see loci.formats.IFormatWriter#save(String, Image, boolean) */ 
    117   public void saveImage(String id, Image image, boolean last) 
     106  public void saveImage(Image image, boolean last) 
    118107    throws FormatException, IOException 
    119108  { 
     
    122111    h.put(new Integer(TiffTools.COMPRESSION), compression.equals("LZW") ? 
    123112      new Integer(TiffTools.LZW) : new Integer(TiffTools.UNCOMPRESSED)); 
    124     saveImage(id, image, h, last); 
     113    saveImage(image, h, last); 
    125114  } 
    126115 
    127   /* @see loci.formats.IFormatWriter#close() */ 
    128   public void close() throws FormatException, IOException { 
     116  /* @see loci.formats.IFormatWriter#canDoStacks(String) */ 
     117  public boolean canDoStacks() { return true; } 
     118 
     119  // -- IFormatHandler API methods -- 
     120 
     121  /* @see loci.formats.IFormatHandler#close() */ 
     122  public void close() throws IOException { 
    129123    // write the metadata, if enabled 
    130124 
     
    163157    out = null; 
    164158    currentId = null; 
     159    initialized = false; 
    165160    lastOffset = 0; 
    166161  } 
    167162 
    168   /* @see loci.formats.IFormatWriter#canDoStacks(String) */ 
    169   public boolean canDoStacks(String id) { return true; } 
     163  // -- Deprecated API methods -- 
    170164 
    171   // -- Main method -- 
    172  
    173   public static void main(String[] args) throws FormatException, IOException { 
    174     new TiffWriter().testConvert(args); 
     165  /** @deprecated Replaced by {@link #saveImage(Image, Hashtable, boolean)} */ 
     166  public void saveImage(String id, Image image, Hashtable ifd, boolean last) 
     167    throws IOException, FormatException 
     168  { 
     169    setId(id); 
     170    saveImage(image, ifd, last); 
    175171  } 
    176172 
Note: See TracChangeset for help on using the changeset viewer.