Changeset 6069


Ignore:
Timestamp:
03/26/10 12:01:50 (10 years ago)
Author:
callan
Message:

A scaffold to support metadata configurability of readers.

Location:
trunk/components/bio-formats
Files:
5 added
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/components/bio-formats/src/loci/formats/FileStitcher.java

    r6026 r6069  
    3030import java.util.HashMap; 
    3131import java.util.Hashtable; 
     32import java.util.Set; 
    3233import java.util.Vector; 
    3334 
    3435import loci.common.Location; 
    3536import loci.common.RandomAccessInputStream; 
     37import loci.formats.in.MetadataLevel; 
     38import loci.formats.in.MetadataOptions; 
    3639import loci.formats.meta.MetadataStore; 
    3740 
     
    248251    } 
    249252    return new FilePattern(id); 
     253  } 
     254 
     255  // -- IMetadataConfigurable API methods -- 
     256 
     257  /* (non-Javadoc) 
     258   * @see loci.formats.IMetadataConfigurable#getSupportedMetadataLevels() 
     259   */ 
     260  public Set<MetadataLevel> getSupportedMetadataLevels() { 
     261    throw new RuntimeException("Not implemented."); 
     262  } 
     263 
     264  /* (non-Javadoc) 
     265   * @see loci.formats.IMetadataConfigurable#getMetadataOptions() 
     266   */ 
     267  public MetadataOptions getMetadataOptions() { 
     268    throw new RuntimeException("Not implemented."); 
     269  } 
     270 
     271  /* (non-Javadoc) 
     272   * @see loci.formats.IMetadataConfigurable#setMetadataOptions(loci.formats.in.MetadataOptions) 
     273   */ 
     274  public void setMetadataOptions(MetadataOptions options) { 
     275    throw new RuntimeException("Not implemented."); 
    250276  } 
    251277 
  • trunk/components/bio-formats/src/loci/formats/FormatReader.java

    r6026 r6069  
    2626import java.io.IOException; 
    2727import java.util.Hashtable; 
     28import java.util.Set; 
    2829import java.util.Vector; 
    2930 
     
    3334import loci.common.services.DependencyException; 
    3435import loci.common.services.ServiceFactory; 
     36import loci.formats.in.MetadataLevel; 
     37import loci.formats.in.MetadataOptions; 
    3538import loci.formats.meta.DummyMetadata; 
    3639import loci.formats.meta.IMetadata; 
     
    395398  } 
    396399 
     400  // -- IMetadataConfigurable API methods -- 
     401 
     402  /* (non-Javadoc) 
     403   * @see loci.formats.IMetadataConfigurable#getSupportedMetadataLevels() 
     404   */ 
     405  public Set<MetadataLevel> getSupportedMetadataLevels() { 
     406    throw new RuntimeException("Not implemented."); 
     407  } 
     408 
     409  /* (non-Javadoc) 
     410   * @see loci.formats.IMetadataConfigurable#getMetadataOptions() 
     411   */ 
     412  public MetadataOptions getMetadataOptions() { 
     413    throw new RuntimeException("Not implemented."); 
     414  } 
     415 
     416  /* (non-Javadoc) 
     417   * @see loci.formats.IMetadataConfigurable#setMetadataOptions(loci.formats.in.MetadataOptions) 
     418   */ 
     419  public void setMetadataOptions(MetadataOptions options) { 
     420    throw new RuntimeException("Not implemented."); 
     421  } 
     422 
    397423  // -- IFormatReader API methods -- 
    398424 
  • trunk/components/bio-formats/src/loci/formats/IFormatReader.java

    r6019 r6069  
    3737 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/bio-formats/src/loci/formats/IFormatReader.java">SVN</a></dd></dl> 
    3838 */ 
    39 public interface IFormatReader extends IFormatHandler { 
     39public interface IFormatReader extends IFormatHandler, IMetadataConfigurable { 
    4040 
    4141  // -- Constants -- 
  • trunk/components/bio-formats/src/loci/formats/ImageReader.java

    r6026 r6069  
    2828import java.util.HashSet; 
    2929import java.util.Hashtable; 
     30import java.util.Set; 
    3031import java.util.Vector; 
    3132 
    3233import loci.common.Location; 
    3334import loci.common.RandomAccessInputStream; 
     35import loci.formats.in.MetadataLevel; 
     36import loci.formats.in.MetadataOptions; 
    3437import loci.formats.meta.MetadataStore; 
    3538 
     
    179182  } 
    180183 
     184  // -- IMetadataConfigurable API methods -- 
     185 
     186  /* (non-Javadoc) 
     187   * @see loci.formats.IMetadataConfigurable#getSupportedMetadataLevels() 
     188   */ 
     189  public Set<MetadataLevel> getSupportedMetadataLevels() { 
     190    throw new RuntimeException("Not implemented."); 
     191  } 
     192 
     193  /* (non-Javadoc) 
     194   * @see loci.formats.IMetadataConfigurable#getMetadataOptions() 
     195   */ 
     196  public MetadataOptions getMetadataOptions() { 
     197    throw new RuntimeException("Not implemented."); 
     198  } 
     199 
     200  /* (non-Javadoc) 
     201   * @see loci.formats.IMetadataConfigurable#setMetadataOptions(loci.formats.in.MetadataOptions) 
     202   */ 
     203  public void setMetadataOptions(MetadataOptions options) { 
     204    throw new RuntimeException("Not implemented."); 
     205  } 
     206 
    181207  // -- IFormatReader API methods -- 
    182208 
  • trunk/components/bio-formats/src/loci/formats/ReaderWrapper.java

    r6026 r6069  
    2727import java.lang.reflect.InvocationTargetException; 
    2828import java.util.Hashtable; 
     29import java.util.Set; 
    2930 
    3031import loci.common.RandomAccessInputStream; 
     32import loci.formats.in.MetadataLevel; 
     33import loci.formats.in.MetadataOptions; 
    3134import loci.formats.meta.MetadataStore; 
    3235 
     
    135138    wrapperCopy.setMetadataCollected(metadataCollected); 
    136139    return wrapperCopy; 
     140  } 
     141 
     142  // -- IMetadataConfigurable API methods -- 
     143 
     144  /* (non-Javadoc) 
     145   * @see loci.formats.IMetadataConfigurable#getSupportedMetadataLevels() 
     146   */ 
     147  public Set<MetadataLevel> getSupportedMetadataLevels() { 
     148    return reader.getSupportedMetadataLevels(); 
     149  } 
     150 
     151  /* (non-Javadoc) 
     152   * @see loci.formats.IMetadataConfigurable#getMetadataOptions() 
     153   */ 
     154  public MetadataOptions getMetadataOptions() { 
     155    return reader.getMetadataOptions(); 
     156  } 
     157 
     158  /* (non-Javadoc) 
     159   * @see loci.formats.IMetadataConfigurable#setMetadataOptions(loci.formats.in.MetadataOptions) 
     160   */ 
     161  public void setMetadataOptions(MetadataOptions options) { 
     162    reader.setMetadataOptions(options); 
    137163  } 
    138164 
  • trunk/components/bio-formats/src/loci/formats/in/DeltavisionReader.java

    r6055 r6069  
    2525 
    2626import java.io.IOException; 
     27import java.util.HashSet; 
     28import java.util.Set; 
    2729import java.util.Vector; 
    2830 
     
    3436import loci.formats.FormatReader; 
    3537import loci.formats.FormatTools; 
     38import loci.formats.IMetadataConfigurable; 
    3639import loci.formats.MetadataTools; 
    3740import loci.formats.meta.FilterMetadata; 
     
    4851 * @author Melissa Linkert linkert at wisc.edu 
    4952 */ 
    50 public class DeltavisionReader extends FormatReader { 
     53public class DeltavisionReader extends FormatReader implements IMetadataConfigurable { 
    5154 
    5255  // -- Constants -- 
     
    8689  protected int numFloatsPerSection; 
    8790 
     91  private MetadataOptions metadataOptions; 
     92 
    8893  /** Initialize an array of Extended Header Field structures. */ 
    8994  protected DVExtHdrFields[][][] extHdrFields = null; 
     
    102107    suffixNecessary = false; 
    103108    domains = new String[] {FormatTools.LM_DOMAIN}; 
     109    metadataOptions = new DefaultMetadataOptions(); 
    104110  } 
    105111 
     
    168174  /* @see loci.formats.FormatReader#initFile(String) */ 
    169175  protected void initFile(String id) throws FormatException, IOException { 
     176    if (checkSuffix(id, "dv.log")) { 
     177      id = id.substring(0, id.lastIndexOf(".")); 
     178    } 
     179    else if (id.endsWith("_log.txt")) { 
     180      id = id.substring(0, id.lastIndexOf("_")) + ".dv"; 
     181    } 
     182 
     183    super.initFile(id); 
     184 
     185    MetadataLevel metadataLevel = metadataOptions.getMetadataLevel(); 
     186    switch (metadataLevel) { 
     187      case PIXELS_ONLY: { 
     188        initFilePixelsOnly(id); 
     189        break; 
     190      } 
     191      case ALL: { 
     192        initFileOld(id); 
     193        break; 
     194      } 
     195      default: { 
     196        LOGGER.warn("Unsupported level: " + metadataLevel); 
     197      } 
     198    } 
     199  } 
     200 
     201  protected void initFilePixelsOnly(String id) 
     202    throws FormatException, IOException { 
     203    LOGGER.info("Reading header"); 
     204 
     205    MetadataStore store = 
     206      new FilterMetadata(getMetadataStore(), isMetadataFiltered()); 
     207 
     208    in = new RandomAccessInputStream(id); 
     209 
     210    in.seek(96); 
     211    in.order(true); 
     212 
     213    boolean little = in.readShort() == LITTLE_ENDIAN; 
     214    in.order(little); 
     215    in.seek(0); 
     216 
     217    int sizeX = in.readInt(); 
     218    int sizeY = in.readInt(); 
     219    int imageCount = in.readInt(); 
     220    int filePixelType = in.readInt(); 
     221 
     222    in.seek(180); 
     223    int rawSizeT = in.readShort(); 
     224    int sizeT = rawSizeT == 0 ? 1 : rawSizeT; 
     225 
     226    int sequence = in.readShort(); 
     227 
     228    in.seek(92); 
     229    extSize = in.readInt(); 
     230 
     231    in.seek(196); 
     232    int rawSizeC = in.readShort(); 
     233    int sizeC = rawSizeC == 0 ? 1 : rawSizeC; 
     234 
     235    // --- compute some secondary values --- 
     236 
     237    String imageSequence; 
     238    switch (sequence) { 
     239      case 0: 
     240        imageSequence = "ZTW"; 
     241        break; 
     242      case 1: 
     243        imageSequence = "WZT"; 
     244        break; 
     245      case 2: 
     246        imageSequence = "ZWT"; 
     247        break; 
     248      case 65536: 
     249        imageSequence = "WZT"; 
     250        break; 
     251      default: 
     252        imageSequence = "ZTW"; 
     253    } 
     254 
     255    int sizeZ = imageCount / (sizeC * sizeT); 
     256 
     257    // --- populate core metadata --- 
     258 
     259    LOGGER.info("Populating core metadata"); 
     260 
     261    core[0].littleEndian = little; 
     262    core[0].sizeX = sizeX; 
     263    core[0].sizeY = sizeY; 
     264    core[0].imageCount = imageCount; 
     265 
     266    String pixel; 
     267    switch (filePixelType) { 
     268      case 0: 
     269        pixel = "8 bit unsigned integer"; 
     270        core[0].pixelType = FormatTools.UINT8; 
     271        break; 
     272      case 1: 
     273        pixel = "16 bit signed integer"; 
     274        core[0].pixelType = FormatTools.INT16; 
     275        break; 
     276      case 2: 
     277        pixel = "32 bit floating point"; 
     278        core[0].pixelType = FormatTools.FLOAT; 
     279        break; 
     280      case 3: 
     281        pixel = "16 bit complex"; 
     282        core[0].pixelType = FormatTools.INT16; 
     283        break; 
     284      case 4: 
     285        pixel = "64 bit complex"; 
     286        core[0].pixelType = FormatTools.FLOAT; 
     287        break; 
     288      case 6: 
     289        pixel = "16 bit unsigned integer"; 
     290        core[0].pixelType = FormatTools.UINT16; 
     291        break; 
     292      default: 
     293        pixel = "unknown"; 
     294        core[0].pixelType = FormatTools.UINT8; 
     295    } 
     296 
     297    core[0].sizeT = sizeT; 
     298 
     299    core[0].dimensionOrder = "XY" + imageSequence.replaceAll("W", "C"); 
     300 
     301    core[0].sizeC = sizeC; 
     302    core[0].sizeZ = sizeZ; 
     303 
     304    core[0].rgb = false; 
     305    core[0].interleaved = false; 
     306    core[0].metadataComplete = true; 
     307    core[0].indexed = false; 
     308    core[0].falseColor = false; 
     309     
     310    // --- populate original metadata --- 
     311 
     312    LOGGER.info("Populating original metadata"); 
     313 
     314    addGlobalMeta("ImageWidth", sizeX); 
     315    addGlobalMeta("ImageHeight", sizeY); 
     316    addGlobalMeta("NumberOfImages", imageCount); 
     317 
     318    addGlobalMeta("PixelType", pixel); 
     319 
     320    addGlobalMeta("Number of timepoints", rawSizeT); 
     321 
     322    addGlobalMeta("Image sequence", imageSequence); 
     323 
     324    addGlobalMeta("Number of wavelengths", rawSizeC); 
     325    addGlobalMeta("Number of focal planes", sizeZ); 
     326 
     327    // --- populate OME metadata --- 
     328 
     329    LOGGER.info("Populating OME metadata"); 
     330 
     331    MetadataTools.populatePixels(store, this, true); 
     332 
     333    MetadataTools.setDefaultCreationDate(store, id, 0); 
     334 
     335    // link Instrument and Image 
     336    String instrumentID = MetadataTools.createLSID("Instrument", 0); 
     337    store.setInstrumentID(instrumentID, 0); 
     338    store.setImageInstrumentRef(instrumentID, 0); 
     339  } 
     340 
     341  /* @see loci.formats.FormatReader#initFile(String) */ 
     342  protected void initFileOld(String id) throws FormatException, IOException { 
    170343    if (checkSuffix(id, "dv.log")) { 
    171344      id = id.substring(0, id.lastIndexOf(".")); 
     
    10321205  } 
    10331206 
     1207  /* (non-Javadoc) 
     1208   * @see loci.formats.in.IMetadataConfigurable#getMetadataOptions() 
     1209   */ 
     1210  public MetadataOptions getMetadataOptions() { 
     1211    return metadataOptions; 
     1212  } 
     1213 
     1214  /* (non-Javadoc) 
     1215   * @see loci.formats.in.IMetadataConfigurable#getSupportedMetadataLevels() 
     1216   */ 
     1217  public Set<MetadataLevel> getSupportedMetadataLevels() { 
     1218    Set<MetadataLevel> supportedLevels = new HashSet<MetadataLevel>(); 
     1219    supportedLevels.add(MetadataLevel.ALL); 
     1220    supportedLevels.add(MetadataLevel.PIXELS_ONLY); 
     1221    return supportedLevels; 
     1222  } 
     1223 
     1224  /* (non-Javadoc) 
     1225   * @see loci.formats.in.IMetadataConfigurable#setMetadataOptions(loci.formats.in.MetadataOptions) 
     1226   */ 
     1227  public void setMetadataOptions(MetadataOptions options) { 
     1228    this.metadataOptions = options; 
     1229  } 
     1230 
    10341231} 
Note: See TracChangeset for help on using the changeset viewer.