Changeset 2131


Ignore:
Timestamp:
01/19/07 13:46:33 (13 years ago)
Author:
curtis
Message:

Add methods for toggling metadata filtering.
Reorganize metadata population to facilitate filtering.
But turning on filtering doesn't actually do anything yet.

Location:
trunk/loci/formats
Files:
42 edited

Legend:

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

    r2130 r2131  
    512512    if (!id.equals(currentId)) initFile(id); 
    513513    return reader.getMetadata(files[0]); 
     514  } 
     515 
     516  /* @see IFormatReader#setMetadataFiltered(boolean) */ 
     517  public void setMetadataFiltered(boolean filter) { 
     518    reader.setMetadataFiltered(filter); 
     519  } 
     520 
     521  /* @see IFormatReader#isMetadataFiltered() */ 
     522  public boolean isMetadataFiltered() { 
     523    return reader.isMetadataFiltered(); 
    514524  } 
    515525 
  • trunk/loci/formats/FormatReader.java

    r2119 r2131  
    111111  protected boolean normalizeData; 
    112112 
     113  /** Whether or not to filter out invalid metadata. */ 
     114  protected boolean filterMetadata; 
     115 
    113116  /** 
    114117   * Current metadata store. Should <b>never</b> be accessed directly as the 
     
    168171  } 
    169172 
     173  /** Adds an entry to the metadata table. */ 
     174  protected void addMeta(String key, Object value) { 
     175    metadata.put(key, value); 
     176  } 
     177 
     178  /** Gets a value from the metadata table. */ 
     179  protected Object getMeta(String key) { 
     180    return metadata.get(key); 
     181  } 
     182 
    170183  /** Issues a debugging statement. */ 
    171184  protected void debug(String s) { 
     
    434447  { 
    435448    if (!id.equals(currentId)) initFile(id); 
    436     return metadata.get(field); 
     449    return getMeta(field); 
    437450  } 
    438451 
     
    442455    return metadata; 
    443456  } 
     457 
     458  /* @see IFormatReader#setMetadataFiltered(boolean) */ 
     459  public void setMetadataFiltered(boolean filter) { 
     460    filterMetadata = filter; 
     461  } 
     462 
     463  /* @see IFormatReader#isMetadataFiltered() */ 
     464  public boolean isMetadataFiltered() { 
     465    return filterMetadata; 
     466  } 
     467 
    444468 
    445469  /* @see IFormatReader#setMetadataStore(MetadataStore) */ 
  • trunk/loci/formats/IFormatReader.java

    r2053 r2131  
    249249 
    250250  /** 
     251   * Specifies whether ugly metadata (entries with unprintable characters, 
     252   * and extremely large entries) should be discarded from the metadata table. 
     253   */ 
     254  void setMetadataFiltered(boolean filter); 
     255 
     256  /** 
     257   * Returns true if ugly metadata (entries with unprintable characters, 
     258   * and extremely large entries) are discarded from the metadata table. 
     259   */ 
     260  boolean isMetadataFiltered(); 
     261 
     262  /** 
    251263   * Sets the default metadata store for this reader. 
    252264   * 
  • trunk/loci/formats/ImageReader.java

    r2117 r2131  
    418418  } 
    419419 
     420  /* @see IFormatReader#setMetadataFiltered(boolean) */ 
     421  public void setMetadataFiltered(boolean filter) { 
     422    for (int i=0; i<readers.length; i++) readers[i].setMetadataFiltered(filter); 
     423  } 
     424 
     425  /* @see IFormatReader#isMetadataFiltered() */ 
     426  public boolean isMetadataFiltered() { 
     427    return readers[0].isNormalized(); 
     428  } 
     429 
    420430  /* @see FormatReader#setMetadataStore(MetadataStore) */ 
    421431  public void setMetadataStore(MetadataStore store) { 
  • trunk/loci/formats/ReaderWrapper.java

    r2117 r2131  
    242242  } 
    243243 
     244  public void setMetadataFiltered(boolean filter) { 
     245    reader.setMetadataFiltered(filter); 
     246  } 
     247 
     248  public boolean isMetadataFiltered() { return reader.isMetadataFiltered(); } 
     249 
    244250  public void setMetadataStore(MetadataStore store) { 
    245251    reader.setMetadataStore(store); 
  • trunk/loci/formats/in/AVIReader.java

    r2117 r2131  
    258258                dwLength = in.readInt(); 
    259259 
    260                 metadata.put("Microseconds per frame", 
     260                addMeta("Microseconds per frame", 
    261261                  new Integer(dwMicroSecPerFrame)); 
    262                 metadata.put("Max. bytes per second", 
     262                addMeta("Max. bytes per second", 
    263263                  new Integer(dwMaxBytesPerSec)); 
    264                 metadata.put("Total frames", new Integer(dwTotalFrames)); 
    265                 metadata.put("Initial frames", new Integer(dwInitialFrames)); 
    266                 metadata.put("Frame width", new Integer(dwWidth)); 
    267                 metadata.put("Frame height", new Integer(dwHeight)); 
    268                 metadata.put("Scale factor", new Integer(dwScale)); 
    269                 metadata.put("Frame rate", new Integer(dwRate)); 
    270                 metadata.put("Start time", new Integer(dwStart)); 
    271                 metadata.put("Length", new Integer(dwLength)); 
     264                addMeta("Total frames", new Integer(dwTotalFrames)); 
     265                addMeta("Initial frames", new Integer(dwInitialFrames)); 
     266                addMeta("Frame width", new Integer(dwWidth)); 
     267                addMeta("Frame height", new Integer(dwHeight)); 
     268                addMeta("Scale factor", new Integer(dwScale)); 
     269                addMeta("Frame rate", new Integer(dwRate)); 
     270                addMeta("Start time", new Integer(dwStart)); 
     271                addMeta("Length", new Integer(dwLength)); 
    272272 
    273273                try { 
     
    317317                dwStreamSampleSize = in.readInt(); 
    318318 
    319                 metadata.put("Stream quality", new Integer(dwStreamQuality)); 
    320                 metadata.put("Stream sample size", 
    321                   new Integer(dwStreamSampleSize)); 
     319                addMeta("Stream quality", new Integer(dwStreamQuality)); 
     320                addMeta("Stream sample size", new Integer(dwStreamSampleSize)); 
    322321 
    323322                try { 
     
    350349                bmpNoOfPixels = bmpWidth * bmpHeight; 
    351350 
    352                 metadata.put("Bitmap compression value", 
     351                addMeta("Bitmap compression value", 
    353352                  new Integer(bmpCompression)); 
    354                 metadata.put("Horizontal resolution", 
     353                addMeta("Horizontal resolution", 
    355354                  new Integer(bmpHorzResolution)); 
    356                 metadata.put("Vertical resolution", 
     355                addMeta("Vertical resolution", 
    357356                  new Integer(bmpVertResolution)); 
    358                 metadata.put("Number of colors used", 
     357                addMeta("Number of colors used", 
    359358                  new Integer(bmpColorsUsed)); 
    360                 metadata.put("Bits per pixel", new Integer(bmpBitsPerPixel)); 
     359                addMeta("Bits per pixel", new Integer(bmpBitsPerPixel)); 
    361360 
    362361                // scan line is padded with zeros to be a multiple of 4 bytes 
     
    532531  /** Initialize the OME-XML tree. */ 
    533532  public void initOMEMetadata() throws FormatException, IOException { 
    534     int bitsPerPixel = ((Integer) metadata.get("Bits per pixel")).intValue(); 
     533    int bitsPerPixel = ((Integer) getMeta("Bits per pixel")).intValue(); 
    535534    int bytesPerPixel = bitsPerPixel / 8; 
    536535 
     
    548547 
    549548    getMetadataStore(currentId).setPixels( 
    550       (Integer) metadata.get("Frame width"), // SizeX 
    551       (Integer) metadata.get("Frame height"), // SizeY 
     549      (Integer) getMeta("Frame width"), // SizeX 
     550      (Integer) getMeta("Frame height"), // SizeY 
    552551      new Integer(1), // SizeZ 
    553552      new Integer(bytesPerPixel), // SizeC 
  • trunk/loci/formats/in/AliconaReader.java

    r2117 r2131  
    184184      value = value.trim(); 
    185185 
    186       metadata.put(key, value); 
     186      addMeta(key, value); 
    187187 
    188188      if (key.equals("TagCount")) count += Integer.parseInt(value); 
     
    200200      (int) (in.length() - textureOffset) / (width * height * numImages); 
    201201 
    202     boolean hasC = !((String) metadata.get("TexturePtr")).trim().equals("7"); 
     202    boolean hasC = !((String) getMeta("TexturePtr")).trim().equals("7"); 
    203203 
    204204    sizeX[0] = width; 
     
    225225 
    226226    store.setDimensions( 
    227       new Float(((String) metadata.get("PlanePntX")).trim()), 
    228       new Float(((String) metadata.get("PlanePntY")).trim()), 
    229       new Float(((String) metadata.get("PlanePntZ")).trim()), null, null, null); 
     227      new Float(((String) getMeta("PlanePntX")).trim()), 
     228      new Float(((String) getMeta("PlanePntY")).trim()), 
     229      new Float(((String) getMeta("PlanePntZ")).trim()), null, null, null); 
    230230  } 
    231231 
  • trunk/loci/formats/in/AndorReader.java

    r2117 r2131  
    125125    if (header != null) { 
    126126      int pos = 3; 
    127       metadata.put("Name", DataTools.bytesToString(header, pos, 256)); 
     127      addMeta("Name", DataTools.bytesToString(header, pos, 256)); 
    128128      pos += 256; 
    129       metadata.put("Data flag", 
    130         "" + DataTools.bytesToInt(header, pos, 4, little)); 
     129      addMeta("Data flag", "" + DataTools.bytesToInt(header, pos, 4, little)); 
    131130      pos += 4;  // data flag 
    132       metadata.put("Number of colors", 
     131      addMeta("Number of colors", 
    133132        "" + DataTools.bytesToInt(header, pos, 4, little)); 
    134133      if (debug && debugLevel >= 2) { 
     
    199198          imgType = "unknown"; 
    200199      } 
    201       metadata.put("Image type", imgType); 
     200      addMeta("Image type", imgType); 
    202201 
    203202      sizeT[0] = 1; 
     
    217216        // name is supposed to be 64 bytes but in practice appears to be 16 
    218217        String name = DataTools.bytesToString(header, pos, 16); 
    219         metadata.put("Dimension " + i + " Name", name); 
     218        addMeta("Dimension " + i + " Name", name); 
    220219        pos += 16; 
    221220        int size = DataTools.bytesToInt(header, pos, little); 
    222         metadata.put("Dimension " + i + " Size", "" + size); 
     221        addMeta("Dimension " + i + " Size", "" + size); 
    223222        pos += 4; 
    224         metadata.put("Dimension " + i + " Origin", "" + 
     223        addMeta("Dimension " + i + " Origin", "" + 
    225224          Double.longBitsToDouble(DataTools.bytesToLong(header, pos, little))); 
    226225        pos += 8; 
    227         metadata.put("Dimension " + i + " Resolution", "" + 
     226        addMeta("Dimension " + i + " Resolution", "" + 
    228227          Double.longBitsToDouble(DataTools.bytesToLong(header, pos, little))); 
    229228        pos += 8; 
    230         metadata.put("Dimension " + i + " Calibration units", 
     229        addMeta("Dimension " + i + " Calibration units", 
    231230          "" + DataTools.bytesToString(header, pos, 16)); 
    232231        pos += 16; 
     
    256255      for (int i=0; i<8; i++) { 
    257256        if (i > 0) dataStamp.append(", "); 
    258         String name = (String) metadata.get("Dimension " + (i + 3) + " Name"); 
     257        String name = (String) getMeta("Dimension " + (i + 3) + " Name"); 
    259258        if (name == null || name.equals("")) break; // no more dimensions 
    260259        dataStamp.append(name); 
     
    263262          DataTools.bytesToLong(stamp, 8*i, little))); 
    264263      } 
    265       metadata.put("Data Stamp for plane #" + (j + 1), dataStamp.toString()); 
     264      addMeta("Data Stamp for plane #" + (j + 1), dataStamp.toString()); 
    266265    } 
    267266 
     
    275274    String[] values = new String[numPlanes]; 
    276275    for (int i=0; i<numPlanes; i++) { 
    277       values[i] = (String) metadata.get("Data Stamp for plane #" + (i+1)); 
     276      values[i] = (String) getMeta("Data Stamp for plane #" + (i+1)); 
    278277    } 
    279278 
     
    350349 
    351350      for (int i=1; i<10; i++) { 
    352         String name = (String) metadata.get("Dimension " + i + " Name"); 
    353         String size = (String) metadata.get("Dimension " + i + " Resolution"); 
     351        String name = (String) getMeta("Dimension " + i + " Name"); 
     352        String size = (String) getMeta("Dimension " + i + " Resolution"); 
    354353 
    355354        if (name != null && size != null) { 
  • trunk/loci/formats/in/BMPReader.java

    r2117 r2131  
    250250    byte[] two = new byte[2]; 
    251251    in.read(two); 
    252     metadata.put("Magic identifier", new String(two)); 
    253  
    254     metadata.put("File size (in bytes)", "" + in.readInt()); 
     252    addMeta("Magic identifier", new String(two)); 
     253 
     254    addMeta("File size (in bytes)", "" + in.readInt()); 
    255255    in.skipBytes(4); // reserved 
    256256 
     
    271271        width + " x " + height); 
    272272    } 
    273     metadata.put("Image width", "" + width); 
    274     metadata.put("Image height", "" + height); 
    275  
    276     metadata.put("Color planes", "" + in.readShort()); 
     273    addMeta("Image width", "" + width); 
     274    addMeta("Image height", "" + height); 
     275 
     276    addMeta("Color planes", "" + in.readShort()); 
    277277    bpp = in.readShort(); 
    278     metadata.put("Bits per pixel", "" + bpp); 
     278    addMeta("Bits per pixel", "" + bpp); 
    279279 
    280280    compression = in.readInt(); 
     
    296296    } 
    297297 
    298     metadata.put("Compression type", comp); 
     298    addMeta("Compression type", comp); 
    299299 
    300300    in.skipBytes(4); 
    301     metadata.put("X resolution", "" + in.readInt()); 
    302     metadata.put("Y resolution", "" + in.readInt()); 
     301    addMeta("X resolution", "" + in.readInt()); 
     302    addMeta("Y resolution", "" + in.readInt()); 
    303303    int nColors = in.readInt(); 
    304304    in.skipBytes(4); 
     
    318318 
    319319    global = in.getFilePointer(); 
    320     metadata.put("Indexed color", palette == null ? "false" : "true"); 
     320    addMeta("Indexed color", palette == null ? "false" : "true"); 
    321321 
    322322    int c = (palette == null & bpp == 8) ? 1 : 3; 
  • trunk/loci/formats/in/BaseTiffReader.java

    r2117 r2131  
    654654   */ 
    655655  protected String getImageDescription() { 
    656     return (String) metadata.get("Comment"); 
     656    return (String) getMeta("Comment"); 
    657657  } 
    658658 
     
    705705      initFile(id); 
    706706    } 
    707     return metadata.get(field); 
     707    return getMeta(field); 
    708708  } 
    709709 
     
    937937    if (value == null) return; 
    938938    if (value instanceof String) value = ((String) value).trim(); 
    939     metadata.put(key, value); 
     939    addMeta(key, value); 
    940940  } 
    941941 
    942942  protected void put(String key, int value) { 
    943943    if (value == -1) return; // indicates missing value 
    944     metadata.put(key, new Integer(value)); 
     944    addMeta(key, new Integer(value)); 
    945945  } 
    946946 
  • trunk/loci/formats/in/BioRadReader.java

    r2117 r2131  
    119119  { 
    120120    if (!id.equals(currentId)) initFile(id); 
    121     return new Double(((Integer) metadata.get("ramp1_min")).intValue()); 
     121    return new Double(((Integer) getMeta("ramp1_min")).intValue()); 
    122122  } 
    123123 
     
    127127  { 
    128128    if (!id.equals(currentId)) initFile(id); 
    129     return new Double(((Integer) metadata.get("ramp1_max")).intValue()); 
     129    return new Double(((Integer) getMeta("ramp1_max")).intValue()); 
    130130  } 
    131131 
     
    203203 
    204204    // populate metadata fields 
    205     metadata.put("nx", new Integer(nx)); 
    206     metadata.put("ny", new Integer(ny)); 
    207     metadata.put("npic", new Integer(npic)); 
    208     metadata.put("ramp1_min", new Integer(ramp1min)); 
    209     metadata.put("ramp1_max", new Integer(ramp1max)); 
    210     metadata.put("notes", new Boolean(notes)); 
    211     metadata.put("byte_format", new Boolean(byteFormat)); 
    212     metadata.put("image_number", new Integer(imageNumber)); 
    213     metadata.put("name", name); 
    214     metadata.put("merged", MERGE_NAMES[merged]); 
    215     metadata.put("color1", new Integer(color1)); 
    216     metadata.put("file_id", new Integer(fileId)); 
    217     metadata.put("ramp2_min", new Integer(ramp2min)); 
    218     metadata.put("ramp2_max", new Integer(ramp2max)); 
    219     metadata.put("color2", new Integer(color2)); 
    220     metadata.put("edited", new Integer(edited)); 
    221     metadata.put("lens", new Integer(lens)); 
    222     metadata.put("mag_factor", new Float(magFactor)); 
     205    addMeta("nx", new Integer(nx)); 
     206    addMeta("ny", new Integer(ny)); 
     207    addMeta("npic", new Integer(npic)); 
     208    addMeta("ramp1_min", new Integer(ramp1min)); 
     209    addMeta("ramp1_max", new Integer(ramp1max)); 
     210    addMeta("notes", new Boolean(notes)); 
     211    addMeta("byte_format", new Boolean(byteFormat)); 
     212    addMeta("image_number", new Integer(imageNumber)); 
     213    addMeta("name", name); 
     214    addMeta("merged", MERGE_NAMES[merged]); 
     215    addMeta("color1", new Integer(color1)); 
     216    addMeta("file_id", new Integer(fileId)); 
     217    addMeta("ramp2_min", new Integer(ramp2min)); 
     218    addMeta("ramp2_max", new Integer(ramp2max)); 
     219    addMeta("color2", new Integer(color2)); 
     220    addMeta("edited", new Integer(edited)); 
     221    addMeta("lens", new Integer(lens)); 
     222    addMeta("mag_factor", new Float(magFactor)); 
    223223 
    224224    // skip image data 
     
    265265      noteCount++; 
    266266 
    267       metadata.put("note" + noteCount, 
     267      addMeta("note" + noteCount, 
    268268        noteString(num, level, status, type, x, y, text)); 
    269269 
     
    290290            case 1: 
    291291              String dx = (String) params.get(0), dy = (String) params.get(1); 
    292               metadata.put(key + " distance (X) in microns", dx); 
    293               metadata.put(key + " distance (Y) in microns", dy); 
     292              addMeta(key + " distance (X) in microns", dx); 
     293              addMeta(key + " distance (Y) in microns", dy); 
    294294              pixelSize.add(dy); 
    295295              break; 
    296296            case 2: 
    297297              if (text.indexOf("AXIS_4") != -1) { 
    298                 metadata.put(key + " time (X) in seconds", params.get(0)); 
    299                 metadata.put(key + " time (Y) in seconds", params.get(1)); 
     298                addMeta(key + " time (X) in seconds", params.get(0)); 
     299                addMeta(key + " time (Y) in seconds", params.get(1)); 
    300300                zSize = 1; 
    301301                tSize = npic; 
     
    304304              break; 
    305305            case 3: 
    306               metadata.put(key + " angle (X) in degrees", params.get(0)); 
    307               metadata.put(key + " angle (Y) in degrees", params.get(1)); 
     306              addMeta(key + " angle (X) in degrees", params.get(0)); 
     307              addMeta(key + " angle (Y) in degrees", params.get(1)); 
    308308              break; 
    309309            case 4: 
    310               metadata.put(key + " intensity (X)", params.get(0)); 
    311               metadata.put(key + " intensity (Y)", params.get(1)); 
     310              addMeta(key + " intensity (X)", params.get(0)); 
     311              addMeta(key + " intensity (Y)", params.get(1)); 
    312312              break; 
    313313            case 6: 
    314               metadata.put(key + " ratio (X)", params.get(0)); 
    315               metadata.put(key + " ratio (Y)", params.get(1)); 
     314              addMeta(key + " ratio (X)", params.get(0)); 
     315              addMeta(key + " ratio (Y)", params.get(1)); 
    316316              break; 
    317317            case 7: 
    318               metadata.put(key + " log ratio (X)", params.get(0)); 
    319               metadata.put(key + " log ratio (Y)", params.get(1)); 
     318              addMeta(key + " log ratio (X)", params.get(0)); 
     319              addMeta(key + " log ratio (Y)", params.get(1)); 
    320320              break; 
    321321            case 9: 
    322               metadata.put(key + " noncalibrated intensity min", 
     322              addMeta(key + " noncalibrated intensity min", params.get(0)); 
     323              addMeta(key + " noncalibrated intensity max", params.get(1)); 
     324              addMeta(key + " calibrated intensity min", params.get(2)); 
     325              addMeta(key + " calibrated intensity max", params.get(3)); 
     326              break; 
     327            case 11: 
     328              addMeta(key + " RGB type (X)", params.get(0)); 
     329              addMeta(key + " RGB type (Y)", params.get(1)); 
     330              break; 
     331            case 14: 
     332              addMeta(key + " time course type (X)", params.get(0)); 
     333              addMeta(key + " time course type (Y)", params.get(1)); 
     334              break; 
     335            case 15: 
     336              addMeta(key + " inverse sigmoid calibrated intensity (min)", 
    323337                params.get(0)); 
    324               metadata.put(key + " noncalibrated intensity max", 
     338              addMeta(key + " inverse sigmoid calibrated intensity (max)", 
    325339                params.get(1)); 
    326               metadata.put(key + " calibrated intensity min", params.get(2)); 
    327               metadata.put(key + " calibrated intensity max", params.get(3)); 
    328               break; 
    329             case 11: 
    330               metadata.put(key + " RGB type (X)", params.get(0)); 
    331               metadata.put(key + " RGB type (Y)", params.get(1)); 
    332               break; 
    333             case 14: 
    334               metadata.put(key + " time course type (X)", params.get(0)); 
    335               metadata.put(key + " time course type (Y)", params.get(1)); 
    336               break; 
    337             case 15: 
    338               metadata.put(key + " inverse sigmoid calibrated intensity (min)", 
    339                 params.get(0)); 
    340               metadata.put(key + " inverse sigmoid calibrated intensity (max)", 
    341                 params.get(1)); 
    342               metadata.put(key + 
     340              addMeta(key + 
    343341                " inverse sigmoid calibrated intensity (beta)", params.get(2)); 
    344               metadata.put(key + " inverse sigmoid calibrated intensity (Kd)", 
     342              addMeta(key + " inverse sigmoid calibrated intensity (Kd)", 
    345343                params.get(3)); 
    346               metadata.put(key + " inverse sigmoid calibrated intensity " + 
     344              addMeta(key + " inverse sigmoid calibrated intensity " + 
    347345                "(calibrated max)", params.get(0)); 
    348346              break; 
    349347            case 16: 
    350               metadata.put(key + " log inverse sigmoid calibrated " + 
     348              addMeta(key + " log inverse sigmoid calibrated " + 
    351349                "intensity (min)", params.get(0)); 
    352               metadata.put(key + " log inverse sigmoid calibrated " + 
     350              addMeta(key + " log inverse sigmoid calibrated " + 
    353351                "intensity (max)", params.get(1)); 
    354               metadata.put(key + " log inverse sigmoid calibrated " + 
     352              addMeta(key + " log inverse sigmoid calibrated " + 
    355353                "intensity (beta)", params.get(2)); 
    356               metadata.put(key + " log inverse sigmoid calibrated " + 
     354              addMeta(key + " log inverse sigmoid calibrated " + 
    357355                "intensity (Kd)", params.get(3)); 
    358               metadata.put(key + " log inverse sigmoid calibrated " + 
     356              addMeta(key + " log inverse sigmoid calibrated " + 
    359357                "intensity (calibrated max)", params.get(0)); 
    360358              break; 
     
    409407    } 
    410408 
    411     metadata.put("luts", colorString); 
     409    addMeta("luts", colorString); 
    412410 
    413411    // Populate the metadata store 
  • trunk/loci/formats/in/DeltavisionReader.java

    r2117 r2131  
    155155  { 
    156156    if (!id.equals(currentId)) initFile(id); 
    157     Float v = (Float) metadata.get("Wavelength " + theC + " min. intensity"); 
     157    Float v = (Float) getMeta("Wavelength " + theC + " min. intensity"); 
    158158    return new Double(v.floatValue()); 
    159159  } 
     
    164164  { 
    165165    if (!id.equals(currentId)) initFile(id); 
    166     Float v = (Float) metadata.get("Wavelength " + theC + " max. intensity"); 
     166    Float v = (Float) getMeta("Wavelength " + theC + " max. intensity"); 
    167167    return new Double(v.floatValue()); 
    168168  } 
     
    246246    Integer xSize = new Integer(width); 
    247247    Integer ySize = new Integer(height); 
    248     metadata.put("ImageWidth", xSize); 
    249     metadata.put("ImageHeight", ySize); 
    250     metadata.put("NumberOfImages", new Integer(DataTools.bytesToInt(header, 
     248    addMeta("ImageWidth", xSize); 
     249    addMeta("ImageHeight", ySize); 
     250    addMeta("NumberOfImages", new Integer(DataTools.bytesToInt(header, 
    251251      8, 4, little))); 
    252252    int filePixelType = DataTools.bytesToInt(header, 12, 4, little); 
     
    290290    } 
    291291 
    292     metadata.put("PixelType", pixel); 
    293     metadata.put("Sub-image starting point (X)", new Integer( 
     292    addMeta("PixelType", pixel); 
     293    addMeta("Sub-image starting point (X)", new Integer( 
    294294      DataTools.bytesToInt(header, 16, 4, little))); 
    295     metadata.put("Sub-image starting point (Y)", new Integer( 
     295    addMeta("Sub-image starting point (Y)", new Integer( 
    296296      DataTools.bytesToInt(header, 20, 4, little))); 
    297     metadata.put("Sub-image starting point (Z)", new Integer( 
     297    addMeta("Sub-image starting point (Z)", new Integer( 
    298298      DataTools.bytesToInt(header, 24, 4, little))); 
    299     metadata.put("Pixel sampling size (X)", new Integer( 
     299    addMeta("Pixel sampling size (X)", new Integer( 
    300300      DataTools.bytesToInt(header, 28, 4, little))); 
    301     metadata.put("Pixel sampling size (Y)", new Integer( 
     301    addMeta("Pixel sampling size (Y)", new Integer( 
    302302      DataTools.bytesToInt(header, 32, 4, little))); 
    303     metadata.put("Pixel sampling size (Z)", new Integer( 
     303    addMeta("Pixel sampling size (Z)", new Integer( 
    304304      DataTools.bytesToInt(header, 36, 4, little))); 
    305     metadata.put("X element length (in um)", new Float(Float.intBitsToFloat( 
     305    addMeta("X element length (in um)", new Float(Float.intBitsToFloat( 
    306306      DataTools.bytesToInt(header, 40, 4, little)))); 
    307     metadata.put("Y element length (in um)", new Float(Float.intBitsToFloat( 
     307    addMeta("Y element length (in um)", new Float(Float.intBitsToFloat( 
    308308      DataTools.bytesToInt(header, 44, 4, little)))); 
    309     metadata.put("Z element length (in um)", new Float(Float.intBitsToFloat( 
     309    addMeta("Z element length (in um)", new Float(Float.intBitsToFloat( 
    310310      DataTools.bytesToInt(header, 48, 4, little)))); 
    311     metadata.put("X axis angle", new Float(Float.intBitsToFloat( 
     311    addMeta("X axis angle", new Float(Float.intBitsToFloat( 
    312312      DataTools.bytesToInt(header, 52, 4, little)))); 
    313     metadata.put("Y axis angle", new Float(Float.intBitsToFloat( 
     313    addMeta("Y axis angle", new Float(Float.intBitsToFloat( 
    314314      DataTools.bytesToInt(header, 56, 4, little)))); 
    315     metadata.put("Z axis angle", new Float(Float.intBitsToFloat( 
     315    addMeta("Z axis angle", new Float(Float.intBitsToFloat( 
    316316      DataTools.bytesToInt(header, 60, 4, little)))); 
    317     metadata.put("Column axis sequence", new Integer( 
     317    addMeta("Column axis sequence", new Integer( 
    318318      DataTools.bytesToInt(header, 64, 4, little))); 
    319     metadata.put("Row axis sequence", new Integer( 
     319    addMeta("Row axis sequence", new Integer( 
    320320      DataTools.bytesToInt(header, 68, 4, little))); 
    321     metadata.put("Section axis sequence", new Integer( 
     321    addMeta("Section axis sequence", new Integer( 
    322322      DataTools.bytesToInt(header, 72, 4, little))); 
    323323    Float wave1Min = new Float(Float.intBitsToFloat( 
    324324        DataTools.bytesToInt(header, 76, 4, little))); 
    325     metadata.put("Wavelength 1 min. intensity", wave1Min); 
     325    addMeta("Wavelength 1 min. intensity", wave1Min); 
    326326    Float wave1Max = new Float(Float.intBitsToFloat( 
    327327        DataTools.bytesToInt(header, 80, 4, little))); 
    328     metadata.put("Wavelength 1 max. intensity", wave1Max); 
    329     metadata.put("Wavelength 1 mean intensity", new Float(Float.intBitsToFloat( 
     328    addMeta("Wavelength 1 max. intensity", wave1Max); 
     329    addMeta("Wavelength 1 mean intensity", new Float(Float.intBitsToFloat( 
    330330      DataTools.bytesToInt(header, 84, 4, little)))); 
    331     metadata.put("Space group number", new Integer( 
     331    addMeta("Space group number", new Integer( 
    332332      DataTools.bytesToInt(header, 88, 4, little))); 
    333     metadata.put("Number of Sub-resolution sets", new Integer( 
     333    addMeta("Number of Sub-resolution sets", new Integer( 
    334334      DataTools.bytesToInt(header, 132, 2, little))); 
    335     metadata.put("Z axis reduction quotient", new Integer( 
     335    addMeta("Z axis reduction quotient", new Integer( 
    336336      DataTools.bytesToInt(header, 134, 2, little))); 
    337     Float wave2Min = new Float(Float.intBitsToFloat( 
    338         DataTools.bytesToInt(header, 136, 4, little))); 
    339     metadata.put("Wavelength 2 min. intensity", wave2Min); 
    340     Float wave2Max = new Float(Float.intBitsToFloat( 
    341         DataTools.bytesToInt(header, 140, 4, little))); 
    342     metadata.put("Wavelength 2 max. intensity", wave2Max); 
    343  
    344     Float wave3Min = new Float(Float.intBitsToFloat( 
    345         DataTools.bytesToInt(header, 144, 4, little))); 
    346     metadata.put("Wavelength 3 min. intensity", wave3Min); 
    347  
    348     Float wave3Max = new Float(Float.intBitsToFloat( 
    349         DataTools.bytesToInt(header, 148, 4, little))); 
    350     metadata.put("Wavelength 3 max. intensity", wave3Max); 
    351  
    352     Float wave4Min = new Float(Float.intBitsToFloat( 
    353         DataTools.bytesToInt(header, 152, 4, little))); 
    354     metadata.put("Wavelength 4 min. intensity", wave4Min); 
    355  
    356     Float wave4Max = new Float(Float.intBitsToFloat( 
    357         DataTools.bytesToInt(header, 156, 4, little))); 
    358     metadata.put("Wavelength 4 max. intensity", wave4Max); 
     337    Float wave2Min = new Float( 
     338      Float.intBitsToFloat(DataTools.bytesToInt(header, 136, 4, little))); 
     339    addMeta("Wavelength 2 min. intensity", wave2Min); 
     340    Float wave2Max = new Float( 
     341      Float.intBitsToFloat(DataTools.bytesToInt(header, 140, 4, little))); 
     342    addMeta("Wavelength 2 max. intensity", wave2Max); 
     343 
     344    Float wave3Min = new Float( 
     345      Float.intBitsToFloat(DataTools.bytesToInt(header, 144, 4, little))); 
     346    addMeta("Wavelength 3 min. intensity", wave3Min); 
     347 
     348    Float wave3Max = new Float( 
     349      Float.intBitsToFloat(DataTools.bytesToInt(header, 148, 4, little))); 
     350    addMeta("Wavelength 3 max. intensity", wave3Max); 
     351 
     352    Float wave4Min = new Float( 
     353      Float.intBitsToFloat(DataTools.bytesToInt(header, 152, 4, little))); 
     354    addMeta("Wavelength 4 min. intensity", wave4Min); 
     355 
     356    Float wave4Max = new Float( 
     357      Float.intBitsToFloat(DataTools.bytesToInt(header, 156, 4, little))); 
     358    addMeta("Wavelength 4 max. intensity", wave4Max); 
    359359 
    360360    int type = DataTools.bytesToShort(header, 160, 2, little); 
     
    380380    } 
    381381 
    382     metadata.put("Image Type", imageType); 
    383     metadata.put("Lens ID Number", new Integer(DataTools.bytesToShort( 
     382    addMeta("Image Type", imageType); 
     383    addMeta("Lens ID Number", new Integer(DataTools.bytesToShort( 
    384384      header, 162, 2, little))); 
    385     Float wave5Min = new Float(Float.intBitsToFloat( 
    386         DataTools.bytesToInt(header, 172, 4, little))); 
    387     metadata.put("Wavelength 5 min. intensity", wave5Min); 
    388  
    389     Float wave5Max = new Float(Float.intBitsToFloat( 
    390         DataTools.bytesToInt(header, 176, 4, little))); 
    391     metadata.put("Wavelength 5 max. intensity", wave5Max); 
     385    Float wave5Min = new Float( 
     386      Float.intBitsToFloat(DataTools.bytesToInt(header, 172, 4, little))); 
     387    addMeta("Wavelength 5 min. intensity", wave5Min); 
     388 
     389    Float wave5Max = new Float( 
     390      Float.intBitsToFloat(DataTools.bytesToInt(header, 176, 4, little))); 
     391    addMeta("Wavelength 5 max. intensity", wave5Max); 
    392392 
    393393    numT = DataTools.bytesToShort(header, 180, 2, little); 
    394     metadata.put("Number of timepoints", new Integer(numT)); 
     394    addMeta("Number of timepoints", new Integer(numT)); 
    395395 
    396396    int sequence = DataTools.bytesToInt(header, 182, 4, little); 
     
    413413        imageSequence = "unknown"; dimOrder = "XYZTC"; 
    414414    } 
    415     metadata.put("Image sequence", imageSequence); 
    416  
    417     metadata.put("X axis tilt angle", new Float(Float.intBitsToFloat( 
     415    addMeta("Image sequence", imageSequence); 
     416 
     417    addMeta("X axis tilt angle", new Float(Float.intBitsToFloat( 
    418418      DataTools.bytesToInt(header, 184, 4, little)))); 
    419     metadata.put("Y axis tilt angle", new Float(Float.intBitsToFloat( 
     419    addMeta("Y axis tilt angle", new Float(Float.intBitsToFloat( 
    420420      DataTools.bytesToInt(header, 188, 4, little)))); 
    421     metadata.put("Z axis tilt angle", new Float(Float.intBitsToFloat( 
     421    addMeta("Z axis tilt angle", new Float(Float.intBitsToFloat( 
    422422      DataTools.bytesToInt(header, 192, 4, little)))); 
    423423 
    424424    numW = DataTools.bytesToShort(header, 196, 2, little); 
    425     metadata.put("Number of wavelengths", new Integer(numW)); 
     425    addMeta("Number of wavelengths", new Integer(numW)); 
    426426    numZ = numImages / (numW * numT); 
    427     metadata.put("Number of focal planes", new Integer(numZ)); 
    428  
    429     metadata.put("Wavelength 1 (in nm)", new Integer(DataTools.bytesToShort( 
     427    addMeta("Number of focal planes", new Integer(numZ)); 
     428 
     429    addMeta("Wavelength 1 (in nm)", new Integer(DataTools.bytesToShort( 
    430430      header, 198, 2, little))); 
    431     metadata.put("Wavelength 2 (in nm)", new Integer(DataTools.bytesToShort( 
     431    addMeta("Wavelength 2 (in nm)", new Integer(DataTools.bytesToShort( 
    432432      header, 200, 2, little))); 
    433     metadata.put("Wavelength 3 (in nm)", new Integer(DataTools.bytesToShort( 
     433    addMeta("Wavelength 3 (in nm)", new Integer(DataTools.bytesToShort( 
    434434      header, 202, 2, little))); 
    435     metadata.put("Wavelength 4 (in nm)", new Integer(DataTools.bytesToShort( 
     435    addMeta("Wavelength 4 (in nm)", new Integer(DataTools.bytesToShort( 
    436436      header, 204, 2, little))); 
    437     metadata.put("Wavelength 5 (in nm)", new Integer(DataTools.bytesToShort( 
     437    addMeta("Wavelength 5 (in nm)", new Integer(DataTools.bytesToShort( 
    438438      header, 206, 2, little))); 
    439     metadata.put("X origin (in um)", new Float(Float.intBitsToFloat( 
     439    addMeta("X origin (in um)", new Float(Float.intBitsToFloat( 
    440440      DataTools.bytesToInt(header, 208, 4, little)))); 
    441     metadata.put("Y origin (in um)", new Float(Float.intBitsToFloat( 
     441    addMeta("Y origin (in um)", new Float(Float.intBitsToFloat( 
    442442      DataTools.bytesToInt(header, 212, 4, little)))); 
    443     metadata.put("Z origin (in um)", new Float(Float.intBitsToFloat( 
     443    addMeta("Z origin (in um)", new Float(Float.intBitsToFloat( 
    444444      DataTools.bytesToInt(header, 216, 4, little)))); 
    445445 
     
    453453      // Make sure that "null" characters are stripped out 
    454454      title = new String(header, 224 + 80*(i-1), 80).replaceAll("\0", ""); 
    455       metadata.put("Title " + i, title); 
     455      addMeta("Title " + i, title); 
    456456    } 
    457457 
     
    475475 
    476476    store.setDimensions( 
    477       (Float) metadata.get("X element length (in um)"), 
    478       (Float) metadata.get("Y element length (in um)"), 
    479       (Float) metadata.get("Z element length (in um)"), 
     477      (Float) getMeta("X element length (in um)"), 
     478      (Float) getMeta("Y element length (in um)"), 
     479      (Float) getMeta("Z element length (in um)"), 
    480480      null, null, null); 
    481481 
    482     String description = (String) metadata.get("Title 1"); 
    483     description = description.length() == 0? null : description; 
     482    String description = (String) getMeta("Title 1"); 
     483    description = description.length() == 0 ? null : description; 
    484484    store.setImage(id, null, description, null); 
    485485 
     
    502502      store.setLogicalChannel(w, null, 
    503503        new Float(extHdrFields[0][w][0].getNdFilter()), 
    504         (Integer) metadata.get("Wavelength " + (w+1) + " (in nm)"), 
     504        (Integer) getMeta("Wavelength " + (w+1) + " (in nm)"), 
    505505        new Integer((int) extHdrFields[0][w][0].getExFilter()), 
    506506        "Monochrome", "Wide-field", null); 
  • trunk/loci/formats/in/DicomReader.java

    r2117 r2131  
    161161      } 
    162162 
    163       String windowCenter = (String) metadata.get("Window Center"); 
    164       String windowWidth = (String) metadata.get("Window Width"); 
     163      String windowCenter = (String) getMeta("Window Center"); 
     164      String windowWidth = (String) getMeta("Window Width"); 
    165165      if (windowCenter != null && windowCenter.indexOf("\\") != -1) { 
    166166        windowCenter = windowCenter.substring(windowCenter.indexOf("\\") + 1); 
     
    187187      } 
    188188 
    189       String rescale = (String) metadata.get("Rescale Intercept"); 
     189      String rescale = (String) getMeta("Rescale Intercept"); 
    190190      double scale = 0; 
    191191      if (rescale != null) { 
     
    262262      byte[] header = new byte[128]; 
    263263      in.read(header); 
    264       metadata.put("Header information", new String(header)); 
     264      addMeta("Header information", new String(header)); 
    265265      in.readInt(); 
    266266      location = 128; 
     
    406406    // populate OME-XML node 
    407407    store.setPixels( 
    408       new Integer((String) metadata.get("Columns")), // SizeX 
    409       new Integer((String) metadata.get("Rows")), // SizeY 
     408      new Integer((String) getMeta("Columns")), // SizeX 
     409      new Integer((String) getMeta("Rows")), // SizeY 
    410410      new Integer(numImages), // SizeZ 
    411411      new Integer(1), // SizeC 
     
    418418    store.setImage( 
    419419      null, // name 
    420       ((String) metadata.get("Content Date")) + "T" + 
    421       ((String) metadata.get("Content Time")),  // CreationDate 
    422       (String) metadata.get("Image Type"), 
     420      ((String) getMeta("Content Date")) + "T" + 
     421      ((String) getMeta("Content Time")),  // CreationDate 
     422      (String) getMeta("Image Type"), 
    423423      null); // Use index 0 
    424424 
    425425    store.setInstrument( 
    426       (String) metadata.get("Manufacturer"), 
    427       (String) metadata.get("Manufacturer's Model Name"), 
     426      (String) getMeta("Manufacturer"), 
     427      (String) getMeta("Manufacturer's Model Name"), 
    428428      null, null, null); 
    429429  } 
     
    437437      String key = (String) TYPES.get(new Integer(tag)); 
    438438      if (key == null) key = "" + tag; 
    439       if (tag != PIXEL_DATA) metadata.put(key, info); 
     439      if (tag != PIXEL_DATA) addMeta(key, info); 
    440440    } 
    441441  } 
  • trunk/loci/formats/in/EPSReader.java

    r2117 r2131  
    214214          height = Integer.parseInt(t.nextToken()) - originY; 
    215215 
    216           metadata.put("X-coordinate of origin", new Integer(originX)); 
    217           metadata.put("Y-coordinate of origin", new Integer(originY)); 
     216          addMeta("X-coordinate of origin", new Integer(originX)); 
     217          addMeta("Y-coordinate of origin", new Integer(originY)); 
    218218        } 
    219219        else if (line.startsWith("%%BeginBinary")) { 
     
    227227            String key = line.substring(0, ndx); 
    228228            String value = line.substring(ndx + 1); 
    229             metadata.put(key, value); 
     229            addMeta(key, value); 
    230230          } 
    231231        } 
  • trunk/loci/formats/in/FluoviewReader.java

    r2117 r2131  
    7575  { 
    7676    if (!id.equals(currentId)) initFile(id); 
    77     String s = (String) metadata.get("Map Ch" + theC + ": Range"); 
     77    String s = (String) getMeta("Map Ch" + theC + ": Range"); 
    7878    s = s.substring(0, s.indexOf("to") - 1).trim(); 
    7979    return new Double(Integer.parseInt(s)); 
     
    8585  { 
    8686    if (!id.equals(currentId)) initFile(id); 
    87     String s = (String) metadata.get("Map Ch" + theC + ": Range"); 
     87    String s = (String) getMeta("Map Ch" + theC + ": Range"); 
    8888    s = s.substring(s.indexOf("to") + 2).trim(); 
    8989    return new Double(Integer.parseInt(s)); 
     
    244244        new Float(stageZ), null); 
    245245 
    246       String descr = (String) metadata.get("Comment"); 
     246      String descr = (String) getMeta("Comment"); 
    247247      metadata.remove("Comment"); 
    248248 
     
    275275        key = descr.substring(0, eqIndex); 
    276276        value = descr.substring(eqIndex+1, descr.indexOf("\n", eqIndex)); 
    277         metadata.put(key.trim(), value.trim()); 
     277        addMeta(key.trim(), value.trim()); 
    278278        descr = descr.substring(descr.indexOf("\n", eqIndex)); 
    279279        eqIndex = descr.indexOf("="); 
     
    282282      // finally, set descr to be the value of "FLUOVIEW Version" 
    283283 
    284       descr = (String) metadata.get("FLUOVIEW Version"); 
     284      descr = (String) getMeta("FLUOVIEW Version"); 
    285285      if (descr == null) { 
    286         descr = (String) metadata.get("File Version"); 
     286        descr = (String) getMeta("File Version"); 
    287287      } 
    288288      store.setImage(imageName, null, descr, null); 
     
    378378      // set the number of valid bits per pixel 
    379379 
    380       String bits = (String) 
    381         metadata.get("Map Ch" + (sizeC[0] - 1) + ": Range"); 
     380      String bits = (String) getMeta("Map Ch" + (sizeC[0] - 1) + ": Range"); 
    382381      int[] validBits = null; 
    383382      int vb = -1; 
  • trunk/loci/formats/in/GatanReader.java

    r2117 r2131  
    107107    // yes, we really do want to get the value for "EstimatedMax" 
    108108    // for some reason, all of our files have max and min reversed 
    109     return new Double(((Integer) metadata.get("EstimatedMax")).intValue()); 
     109    return new Double(((Integer) getMeta("EstimatedMax")).intValue()); 
    110110  } 
    111111 
     
    115115  { 
    116116    if (!id.equals(currentId)) initFile(id); 
    117     return new Double(((Integer) metadata.get("EstimatedMin")).intValue()); 
     117    return new Double(((Integer) getMeta("EstimatedMin")).intValue()); 
    118118  } 
    119119 
     
    183183    parseTags(DataTools.bytesToInt(temp, !littleEndian), "initFile"); 
    184184 
    185     int datatype = Integer.parseInt((String) metadata.get("DataType")); 
     185    int datatype = Integer.parseInt((String) getMeta("DataType")); 
    186186 
    187187    pixelType[0] = FormatReader.INT8; 
     
    345345            pixelSizes.add(data); 
    346346          } 
    347           metadata.put(labelString, data); 
     347          addMeta(labelString, data); 
    348348        } 
    349349        else if (n == 2) { 
     
    356356          byte[] data = new byte[length]; 
    357357          in.read(data); 
    358           metadata.put(labelString, new String(label)); 
     358          addMeta(labelString, new String(label)); 
    359359        } 
    360360        else if (n == 3) { 
  • trunk/loci/formats/in/GelReader.java

    r2010 r2131  
    6969    try { 
    7070      long fmt = TiffTools.getIFDLongValue(ifds[1], MD_FILETAG, true, 128); 
    71       metadata.put("Data format", fmt == 2 ? "square root" : "linear"); 
     71      addMeta("Data format", fmt == 2 ? "square root" : "linear"); 
    7272    } 
    7373    catch (FormatException f) { 
     
    7777    TiffRational scale = 
    7878      (TiffRational) TiffTools.getIFDValue(ifds[1], MD_SCALE_PIXEL); 
    79     metadata.put("Scale factor", 
    80       (scale == null) ? new TiffRational(1, 1) : scale); 
     79    addMeta("Scale factor", scale == null ? new TiffRational(1, 1) : scale); 
    8180 
    8281    // ignore MD_COLOR_TABLE 
    8382 
    8483    String lab = (String) TiffTools.getIFDValue(ifds[1], MD_LAB_NAME); 
    85     metadata.put("Lab name", lab == null ? "unknown" : lab); 
     84    addMeta("Lab name", lab == null ? "unknown" : lab); 
    8685 
    8786    String info = (String) TiffTools.getIFDValue(ifds[1], MD_SAMPLE_INFO); 
    88     metadata.put("Sample info", info == null ? "unknown" : info); 
     87    addMeta("Sample info", info == null ? "unknown" : info); 
    8988 
    9089    String prepDate = (String) TiffTools.getIFDValue(ifds[1], MD_PREP_DATE); 
    91     metadata.put("Date prepared", prepDate == null ? "unknown" : prepDate); 
     90    addMeta("Date prepared", prepDate == null ? "unknown" : prepDate); 
    9291 
    9392    String prepTime = (String) TiffTools.getIFDValue(ifds[1], MD_PREP_TIME); 
    94     metadata.put("Time prepared", prepTime == null ? "unknown" : prepTime); 
     93    addMeta("Time prepared", prepTime == null ? "unknown" : prepTime); 
    9594 
    9695    String units = (String) TiffTools.getIFDValue(ifds[1], MD_FILE_UNITS); 
    97     metadata.put("File units", units == null ? "unknown" : units); 
     96    addMeta("File units", units == null ? "unknown" : units); 
    9897 
    9998    sizeT[series] = numImages; 
  • trunk/loci/formats/in/ICSReader.java

    r2117 r2131  
    261261          if (t.countTokens() < 3) { 
    262262            try { 
    263               metadata.put(token, t.nextToken()); 
     263              addMeta(token, t.nextToken()); 
    264264            } 
    265265            catch (NoSuchElementException e) { } 
     
    270270              meta = meta + " " + t.nextToken(); 
    271271            } 
    272             metadata.put(token, meta); 
     272            addMeta(token, meta); 
    273273          } 
    274274        } 
     
    280280    } 
    281281 
    282     String images = (String) metadata.get("sizes"); 
    283     String ord = (String) metadata.get("order"); 
     282    String images = (String) getMeta("sizes"); 
     283    String ord = (String) getMeta("order"); 
    284284    ord = ord.trim(); 
    285285    // bpp, width, height, z, channels 
     
    324324    if (numImages == 0) numImages++; 
    325325 
    326     String endian = (String) metadata.get("byte_order"); 
     326    String endian = (String) getMeta("byte_order"); 
    327327    littleEndian = true; 
    328328 
     
    339339    } 
    340340 
    341     String test = (String) metadata.get("compression"); 
     341    String test = (String) getMeta("compression"); 
    342342    boolean gzip = (test == null) ? false : test.equals("gzip"); 
    343343 
     
    378378    MetadataStore store = getMetadataStore(id); 
    379379 
    380     store.setImage((String) metadata.get("filename"), null, null, null); 
     380    store.setImage((String) getMeta("filename"), null, null, null); 
    381381 
    382382    // populate Pixels element 
    383383 
    384     String o = (String) metadata.get("order"); 
     384    String o = (String) getMeta("order"); 
    385385    o = o.trim(); 
    386386    o = o.substring(o.indexOf("x")).trim(); 
     
    397397 
    398398    int bitsPerPixel = 
    399       Integer.parseInt((String) metadata.get("significant_bits")); 
    400     String fmt = (String) metadata.get("format"); 
    401     String sign = (String) metadata.get("sign"); 
     399      Integer.parseInt((String) getMeta("significant_bits")); 
     400    String fmt = (String) getMeta("format"); 
     401    String sign = (String) getMeta("sign"); 
    402402 
    403403    if (bitsPerPixel < 32) littleEndian = !littleEndian; 
  • trunk/loci/formats/in/IPLabReader.java

    r2117 r2131  
    115115  { 
    116116    if (!id.equals(currentId)) initFile(id); 
    117     return (Double) metadata.get("NormalizationMin" + theC); 
     117    return (Double) getMeta("NormalizationMin" + theC); 
    118118  } 
    119119 
     
    123123  { 
    124124    if (!id.equals(currentId)) initFile(id); 
    125     return (Double) metadata.get("NormalizationMax" + theC); 
     125    return (Double) getMeta("NormalizationMax" + theC); 
    126126  } 
    127127 
     
    184184    numImages = zDepth * tDepth; 
    185185 
    186     metadata.put("Width", new Long(width)); 
    187     metadata.put("Height", new Long(height)); 
    188     metadata.put("Channels", new Long(c)); 
    189     metadata.put("ZDepth", new Long(zDepth)); 
    190     metadata.put("TDepth", new Long(tDepth)); 
     186    addMeta("Width", new Long(width)); 
     187    addMeta("Height", new Long(height)); 
     188    addMeta("Channels", new Long(c)); 
     189    addMeta("ZDepth", new Long(zDepth)); 
     190    addMeta("TDepth", new Long(tDepth)); 
    191191 
    192192    String ptype; 
     
    237237    } 
    238238 
    239     metadata.put("PixelType", ptype); 
     239    addMeta("PixelType", ptype); 
    240240    in.skipBytes(dataSize); 
    241241 
     
    308308              break; 
    309309          } 
    310           metadata.put("LUT type", clutType); 
     310          addMeta("LUT type", clutType); 
    311311        } 
    312312        else { 
     
    354354              sourceType = "user"; 
    355355          } 
    356           metadata.put("NormalizationSource" + i, sourceType); 
     356          addMeta("NormalizationSource" + i, sourceType); 
    357357 
    358358          double min = in.readDouble(); 
     
    362362          double white = in.readDouble(); 
    363363 
    364           metadata.put("NormalizationMin" + i, new Double(min)); 
    365           metadata.put("NormalizationMax" + i, new Double(max)); 
    366           metadata.put("NormalizationGamma" + i, new Double(gamma)); 
    367           metadata.put("NormalizationBlack" + i, new Double(black)); 
    368           metadata.put("NormalizationWhite" + i, new Double(white)); 
     364          addMeta("NormalizationMin" + i, new Double(min)); 
     365          addMeta("NormalizationMax" + i, new Double(max)); 
     366          addMeta("NormalizationGamma" + i, new Double(gamma)); 
     367          addMeta("NormalizationBlack" + i, new Double(black)); 
     368          addMeta("NormalizationWhite" + i, new Double(white)); 
    369369        } 
    370370      } 
     
    378378          in.read(fourBytes); 
    379379          String name = new String(fourBytes); 
    380           metadata.put("Header" + num, name); 
     380          addMeta("Header" + num, name); 
    381381        } 
    382382      } 
     
    412412          int xUnitName = in.readInt(); 
    413413 
    414           metadata.put("ResolutionStyle" + i, new Long(xResStyle)); 
    415           metadata.put("UnitsPerPixel" + i, new Long(unitsPerPixel)); 
     414          addMeta("ResolutionStyle" + i, new Long(xResStyle)); 
     415          addMeta("UnitsPerPixel" + i, new Long(unitsPerPixel)); 
    416416 
    417417          if (i == 0) { 
     
    420420          } 
    421421 
    422           metadata.put("UnitName" + i, new Long(xUnitName)); 
     422          addMeta("UnitName" + i, new Long(xUnitName)); 
    423423        } 
    424424      } 
     
    441441        in.read(temp); 
    442442        String notes = new String(temp); 
    443         metadata.put("Descriptor", descriptor); 
    444         metadata.put("Notes", notes); 
     443        addMeta("Descriptor", descriptor); 
     444        addMeta("Notes", notes); 
    445445 
    446446        store.setImage(id, null, notes, null); 
     
    459459    sizeX[0] = width; 
    460460    sizeY[0] = height; 
    461     sizeZ[0] = (int) ((Long) metadata.get("ZDepth")).longValue(); 
     461    sizeZ[0] = (int) ((Long) getMeta("ZDepth")).longValue(); 
    462462    sizeC[0] = c; 
    463     sizeT[0] = (int) ((Long) metadata.get("TDepth")).longValue(); 
     463    sizeT[0] = (int) ((Long) getMeta("TDepth")).longValue(); 
    464464    currentOrder[0] = order; 
    465465 
  • trunk/loci/formats/in/IPWReader.java

    r2117 r2131  
    267267    // parse the image description 
    268268    String description = new String(tags, 22, tags.length-22); 
    269     metadata.put("Image Description", description); 
     269    addMeta("Image Description", description); 
    270270 
    271271    // default values 
    272     metadata.put("slices", "1"); 
    273     metadata.put("channels", "1"); 
    274     metadata.put("frames", new Integer(getImageCount(id))); 
     272    addMeta("slices", "1"); 
     273    addMeta("channels", "1"); 
     274    addMeta("frames", new Integer(getImageCount(id))); 
    275275 
    276276    // parse the description to get channels/slices/times where applicable 
     
    289289          data = token.trim(); 
    290290        } 
    291         metadata.put(label, data); 
    292       } 
    293     } 
    294  
    295     metadata.put("Version", new String(header).trim()); 
    296  
    297     Integer tSize = Integer.valueOf((String) metadata.get("slices")); 
    298     Integer cSize = Integer.valueOf((String) metadata.get("channels")); 
    299     Integer zSize = Integer.valueOf(metadata.get("frames").toString()); 
     291        addMeta(label, data); 
     292      } 
     293    } 
     294 
     295    addMeta("Version", new String(header).trim()); 
     296 
     297    Integer tSize = Integer.valueOf((String) getMeta("slices")); 
     298    Integer cSize = Integer.valueOf((String) getMeta("channels")); 
     299    Integer zSize = Integer.valueOf(getMeta("frames").toString()); 
    300300 
    301301    sizeX = new int[1]; 
     
    311311    sizeX[0] = TiffTools.getIFDIntValue(h, TiffTools.IMAGE_WIDTH); 
    312312    sizeY[0] = TiffTools.getIFDIntValue(h, TiffTools.IMAGE_LENGTH); 
    313     sizeZ[0] = Integer.valueOf(metadata.get("frames").toString()).intValue(); 
    314     sizeC[0] = Integer.parseInt((String) metadata.get("channels")); 
    315     sizeT[0] = Integer.parseInt((String) metadata.get("slices")); 
     313    sizeZ[0] = Integer.valueOf(getMeta("frames").toString()).intValue(); 
     314    sizeC[0] = Integer.parseInt((String) getMeta("channels")); 
     315    sizeT[0] = Integer.parseInt((String) getMeta("slices")); 
    316316    currentOrder[0] = "XY"; 
    317317 
     
    386386    store.setPixels(null, null, zSize, cSize, tSize, new Integer(pixelType[0]), 
    387387      new Boolean(!isLittleEndian(id)), getDimensionOrder(id), null); 
    388     store.setImage(null, null, (String) metadata.get("Version"), null); 
     388    store.setImage(null, null, (String) getMeta("Version"), null); 
    389389  } 
    390390 
     
    432432          // should always be exactly 4 bytes 
    433433          // only exists if the file has more than one image 
    434           metadata.put("Frame Rate", 
    435             new Long(DataTools.bytesToInt(data, true))); 
     434          addMeta("Frame Rate", new Long(DataTools.bytesToInt(data, true))); 
    436435        } 
    437436        else if (entryName.equals("FrameInfo")) { 
    438437          // should always be 16 bytes (if present) 
    439438          for(int i=0; i<data.length/2; i++) { 
    440             metadata.put("FrameInfo "+i, 
     439            addMeta("FrameInfo "+i, 
    441440              new Short(DataTools.bytesToShort(data, i*2, true))); 
    442441          } 
  • trunk/loci/formats/in/ImarisReader.java

    r2117 r2131  
    8282 
    8383    int version = in.readInt(); 
    84     metadata.put("Version", new Integer(version)); 
     84    addMeta("Version", new Integer(version)); 
    8585    in.readInt(); 
    8686 
     
    8888    in.read(name); 
    8989    String iName = new String(name); 
    90     metadata.put("Image name", iName); 
     90    addMeta("Image name", iName); 
    9191 
    9292    dims[0] = in.readShort(); 
     
    102102    in.read(date); 
    103103    String origDate = new String(date); 
    104     metadata.put("Original date", origDate); 
     104    addMeta("Original date", origDate); 
    105105 
    106106    float dx = in.readFloat(); 
     
    112112    in.read(com); 
    113113    String comment = new String(com); 
    114     metadata.put("Image comment", comment); 
     114    addMeta("Image comment", comment); 
    115115    int isSurvey = in.readInt(); 
    116     metadata.put("Survey performed", isSurvey == 0 ? "true" : "false"); 
     116    addMeta("Survey performed", isSurvey == 0 ? "true" : "false"); 
    117117 
    118118    numImages = dims[2] * dims[3]; 
     
    149149 
    150150    store.setImage( 
    151       (String) metadata.get("Image name"), 
    152       (String) metadata.get("Original date"), 
    153       (String) metadata.get("Image comment"), 
     151      (String) getMeta("Image name"), 
     152      (String) getMeta("Original date"), 
     153      (String) getMeta("Image comment"), 
    154154      null); 
    155155 
  • trunk/loci/formats/in/ImarisTiffReader.java

    r2117 r2131  
    201201    } 
    202202 
    203     String comment = (String) metadata.get("Comment"); 
     203    String comment = (String) getMeta("Comment"); 
    204204 
    205205    // likely an INI-style comment, although we can't be sure 
     
    214214        String key = line.substring(0, equals); 
    215215        String value = line.substring(equals + 1); 
    216         metadata.put(key.trim(), value.trim()); 
     216        addMeta(key.trim(), value.trim()); 
    217217      } 
    218218      metadata.remove("Comment"); 
  • trunk/loci/formats/in/LIFReader.java

    r2120 r2131  
    275275    String key = token.substring(0, token.indexOf("\"")); 
    276276    String value = token.substring(token.indexOf("\"") + 1, token.length()-1); 
    277     metadata.put(key, value); 
     277    addMeta(key, value); 
    278278 
    279279    // what we have right now is a vector of XML elements, which need to 
     
    314314        } 
    315315        value = token.substring(token.indexOf(" ") + 1).trim(); 
    316         metadata.put(prefix + " - " + key, value); 
     316        addMeta(prefix + " - " + key, value); 
    317317      } 
    318318      token = tmpToken; 
  • trunk/loci/formats/in/LegacyZVIReader.java

    r2117 r2131  
    358358      } 
    359359 
    360       metadata.put("Width", new Integer(width)); 
    361       metadata.put("Height", new Integer(height)); 
    362       metadata.put("PixelType", type); 
    363       metadata.put("BPP", new Integer(bytesPerPixel)); 
     360      addMeta("Width", new Integer(width)); 
     361      addMeta("Height", new Integer(height)); 
     362      addMeta("PixelType", type); 
     363      addMeta("BPP", new Integer(bytesPerPixel)); 
    364364 
    365365      ZVIBlock zviBlock = new ZVIBlock(theZ, theC, theT, width, height, 
  • trunk/loci/formats/in/LeicaReader.java

    r2126 r2131  
    236236      if (ifds == null) throw new FormatException("No IFDs found"); 
    237237 
    238       String descr = (String) metadata.get("Comment"); 
     238      String descr = (String) getMeta("Comment"); 
    239239      metadata.remove("Comment"); 
    240240 
     
    277277        if (newLineNdx == -1) newLineNdx = descr.length(); 
    278278        value = descr.substring(eqIndex+1, newLineNdx); 
    279         metadata.put(key.trim(), value.trim()); 
     279        addMeta(key.trim(), value.trim()); 
    280280        newLineNdx = descr.indexOf("\n", eqIndex); 
    281281        if (newLineNdx == -1) newLineNdx = descr.length(); 
     
    603603        // the series data 
    604604        // ID_SERIES 
    605         metadata.put("Version", 
     605        addMeta("Version", 
    606606          new Integer(DataTools.bytesToInt(temp, 0, 4, littleEndian))); 
    607         metadata.put("Number of Series", 
     607        addMeta("Number of Series", 
    608608          new Integer(DataTools.bytesToInt(temp, 4, 4, littleEndian))); 
    609         metadata.put("Length of filename", 
     609        addMeta("Length of filename", 
    610610          new Integer(DataTools.bytesToInt(temp, 8, 4, littleEndian))); 
    611         metadata.put("Length of file extension", 
     611        addMeta("Length of file extension", 
    612612          new Integer(DataTools.bytesToInt(temp, 12, 4, littleEndian))); 
    613         Integer fileExtLen = (Integer) metadata.get("Length of file extension"); 
    614         metadata.put("Image file extension", 
     613        Integer fileExtLen = (Integer) getMeta("Length of file extension"); 
     614        addMeta("Image file extension", 
    615615          DataTools.stripString(new String(temp, 16, fileExtLen.intValue()))); 
    616616      } 
     
    625625        heights[i] = DataTools.bytesToInt(temp, 8, 4, littleEndian); 
    626626 
    627         metadata.put("Number of images", new Integer(zs[i])); 
    628         metadata.put("Image width", new Integer(widths[i])); 
    629         metadata.put("Image height", new Integer(heights[i])); 
    630         metadata.put("Bits per Sample", new Integer( 
    631           DataTools.bytesToInt(temp, 12, 4, littleEndian))); 
    632         metadata.put("Samples per pixel", new Integer( 
    633           DataTools.bytesToInt(temp, 16, 4, littleEndian))); 
     627        addMeta("Number of images", new Integer(zs[i])); 
     628        addMeta("Image width", new Integer(widths[i])); 
     629        addMeta("Image height", new Integer(heights[i])); 
     630        addMeta("Bits per Sample", 
     631          new Integer(DataTools.bytesToInt(temp, 12, 4, littleEndian))); 
     632        addMeta("Samples per pixel", 
     633          new Integer(DataTools.bytesToInt(temp, 16, 4, littleEndian))); 
    634634      } 
    635635 
     
    639639        // ID_DIMDESCR 
    640640        int pt = 0; 
    641         metadata.put("Voxel Version", new Integer( 
     641        addMeta("Voxel Version", new Integer( 
    642642          DataTools.bytesToInt(temp, 0, 4, littleEndian))); 
    643643        int voxelType = DataTools.bytesToInt(temp, 4, 4, littleEndian); 
     
    655655        } 
    656656 
    657         metadata.put("VoxelType", type); 
    658  
    659         metadata.put("Bytes per pixel", new Integer( 
    660           DataTools.bytesToInt(temp, 8, 4, littleEndian))); 
    661         metadata.put("Real world resolution", new Integer( 
    662           DataTools.bytesToInt(temp, 12, 4, littleEndian))); 
     657        addMeta("VoxelType", type); 
     658 
     659        addMeta("Bytes per pixel", 
     660          new Integer(DataTools.bytesToInt(temp, 8, 4, littleEndian))); 
     661        addMeta("Real world resolution", 
     662          new Integer(DataTools.bytesToInt(temp, 12, 4, littleEndian))); 
    663663        int length = DataTools.bytesToInt(temp, 16, 4, littleEndian); 
    664         metadata.put("Maximum voxel intensity", 
     664        addMeta("Maximum voxel intensity", 
    665665          DataTools.stripString(new String(temp, 20, length))); 
    666666        pt = 20 + length; 
    667667        pt += 4; 
    668         metadata.put("Minimum voxel intensity", 
     668        addMeta("Minimum voxel intensity", 
    669669          DataTools.stripString(new String(temp, pt, length))); 
    670670        pt += length; 
     
    761761 
    762762          //if (dimType.equals("channel")) numChannels++; 
    763           metadata.put("Dim" + j + " type", dimType); 
    764           pt += 4; 
    765           metadata.put("Dim" + j + " size", new Integer( 
     763          addMeta("Dim" + j + " type", dimType); 
     764          pt += 4; 
     765          addMeta("Dim" + j + " size", new Integer( 
    766766            DataTools.bytesToInt(temp, pt, 4, littleEndian))); 
    767767          pt += 4; 
    768           metadata.put("Dim" + j + " distance between sub-dimensions", 
     768          addMeta("Dim" + j + " distance between sub-dimensions", 
    769769            new Integer(DataTools.bytesToInt(temp, pt, 4, littleEndian))); 
    770770          pt += 4; 
     
    772772          int len = DataTools.bytesToInt(temp, pt, 4, littleEndian); 
    773773          pt += 4; 
    774           metadata.put("Dim" + j + " physical length", 
     774          addMeta("Dim" + j + " physical length", 
    775775            DataTools.stripString(new String(temp, pt, len))); 
    776776          pt += len; 
     
    778778          len = DataTools.bytesToInt(temp, pt, 4, littleEndian); 
    779779          pt += 4; 
    780           metadata.put("Dim" + j + " physical origin", 
     780          addMeta("Dim" + j + " physical origin", 
    781781            DataTools.stripString(new String(temp, pt, len))); 
    782782          pt += len; 
     
    784784          len = DataTools.bytesToInt(temp, pt, 4, littleEndian); 
    785785          pt += 4; 
    786           metadata.put("Dim" + j + " name", 
     786          addMeta("Dim" + j + " name", 
    787787            DataTools.stripString(new String(temp, pt, len))); 
    788788          pt += len; 
     
    790790          len = DataTools.bytesToInt(temp, pt, 4, littleEndian); 
    791791          pt += 4; 
    792           metadata.put("Dim" + j + " description", 
     792          addMeta("Dim" + j + " description", 
    793793            DataTools.stripString(new String(temp, pt, len))); 
    794794        } 
     
    808808        // ID_TIMEINFO 
    809809        try { 
    810           metadata.put("Number of time-stamped dimensions", 
     810          addMeta("Number of time-stamped dimensions", 
    811811            new Integer(DataTools.bytesToInt(temp, 0, 4, littleEndian))); 
    812812          int nDims = DataTools.bytesToInt(temp, 4, 4, littleEndian); 
    813           metadata.put("Time-stamped dimension", new Integer(nDims)); 
     813          addMeta("Time-stamped dimension", new Integer(nDims)); 
    814814 
    815815          int pt = 8; 
    816816 
    817817          for (int j=0; j < nDims; j++) { 
    818             metadata.put("Dimension " + j + " ID", 
     818            addMeta("Dimension " + j + " ID", 
    819819              new Integer(DataTools.bytesToInt(temp, pt, 4, littleEndian))); 
    820820            pt += 4; 
    821             metadata.put("Dimension " + j + " size", 
     821            addMeta("Dimension " + j + " size", 
    822822              new Integer(DataTools.bytesToInt(temp, pt, 4, littleEndian))); 
    823823            pt += 4; 
    824             metadata.put("Dimension " + j + " distance between dimensions", 
     824            addMeta("Dimension " + j + " distance between dimensions", 
    825825              new Integer(DataTools.bytesToInt(temp, pt, 4, littleEndian))); 
    826826            pt += 4; 
     
    829829          int numStamps = DataTools.bytesToInt(temp, pt, 4, littleEndian); 
    830830          pt += 4; 
    831           metadata.put("Number of time-stamps", new Integer(numStamps)); 
     831          addMeta("Number of time-stamps", new Integer(numStamps)); 
    832832          for (int j=0; j<numStamps; j++) { 
    833             metadata.put("Timestamp " + j, 
     833            addMeta("Timestamp " + j, 
    834834              DataTools.stripString(new String(temp, pt, 64))); 
    835835            pt += 64; 
     
    838838          int numTMs = DataTools.bytesToInt(temp, pt, 4, littleEndian); 
    839839          pt += 4; 
    840           metadata.put("Number of time-markers", new Integer(numTMs)); 
     840          addMeta("Number of time-markers", new Integer(numTMs)); 
    841841          for (int j=0; j<numTMs; j++) { 
    842842            int numDims = DataTools.bytesToInt(temp, pt, 4, littleEndian); 
     
    844844 
    845845            for (int k=0; k<numDims; k++) { 
    846               metadata.put("Time-marker " + j + 
     846              addMeta("Time-marker " + j + 
    847847                " Dimension " + k + " coordinate", 
    848848                new Integer(DataTools.bytesToInt(temp, pt, 4, littleEndian))); 
    849849              pt += 4; 
    850850            } 
    851             metadata.put("Time-marker " + j, 
     851            addMeta("Time-marker " + j, 
    852852              DataTools.stripString(new String(temp, pt, 64))); 
    853853            pt += 64; 
     
    876876        pt += 4; 
    877877 
    878         metadata.put("Image Description", 
     878        addMeta("Image Description", 
    879879          DataTools.stripString(new String(temp, pt, 2*len))); 
    880880        pt += 2*len; 
     
    882882        pt += 4; 
    883883 
    884         metadata.put("Main file extension", 
     884        addMeta("Main file extension", 
    885885          DataTools.stripString(new String(temp, pt, 2*len))); 
    886886        pt += 2*len; 
     
    888888        len = DataTools.bytesToInt(temp, pt, 4, littleEndian); 
    889889        pt += 4; 
    890         metadata.put("Single image format identifier", 
     890        addMeta("Single image format identifier", 
    891891          DataTools.stripString(new String(temp, pt, 2*len))); 
    892892        pt += 2*len; 
     
    894894        len = DataTools.bytesToInt(temp, pt, 4, littleEndian); 
    895895        pt += 4; 
    896         metadata.put("Single image extension", 
     896        addMeta("Single image extension", 
    897897          DataTools.stripString(new String(temp, pt, 2*len))); 
    898898      } 
     
    905905        int nChannels = DataTools.bytesToInt(temp, pt, 4, littleEndian); 
    906906        pt += 4; 
    907         metadata.put("Number of LUT channels", new Integer(nChannels)); 
    908         metadata.put("ID of colored dimension", 
     907        addMeta("Number of LUT channels", new Integer(nChannels)); 
     908        addMeta("ID of colored dimension", 
    909909          new Integer(DataTools.bytesToInt(temp, pt, 4, littleEndian))); 
    910910        pt += 4; 
     
    913913 
    914914        for (int j=0; j<nChannels; j++) { 
    915           metadata.put("LUT Channel " + j + " version", 
     915          addMeta("LUT Channel " + j + " version", 
    916916            new Integer(DataTools.bytesToInt(temp, pt, 4, littleEndian))); 
    917917          pt += 4; 
     
    920920          pt += 1; 
    921921          boolean inverted = invert == 1; 
    922           metadata.put("LUT Channel " + j + " inverted?", 
     922          addMeta("LUT Channel " + j + " inverted?", 
    923923            new Boolean(inverted).toString()); 
    924924 
    925925          int length = DataTools.bytesToInt(temp, pt, 4, littleEndian); 
    926926          pt += 4; 
    927           metadata.put("LUT Channel " + j + " description", 
     927          addMeta("LUT Channel " + j + " description", 
    928928            DataTools.stripString(new String(temp, pt, length))); 
    929929 
     
    931931          length = DataTools.bytesToInt(temp, pt, 4, littleEndian); 
    932932          pt += 4; 
    933           metadata.put("LUT Channel " + j + " filename", 
     933          addMeta("LUT Channel " + j + " filename", 
    934934            DataTools.stripString(new String(temp, pt, length))); 
    935935          pt += length; 
     
    942942            numChannels[i] = 3; 
    943943          } 
    944           metadata.put("LUT Channel " + j + " name", name); 
     944          addMeta("LUT Channel " + j + " name", name); 
    945945          pt += length; 
    946946 
     
    978978    } 
    979979 
    980     Integer v = (Integer) metadata.get("Real world resolution"); 
     980    Integer v = (Integer) getMeta("Real world resolution"); 
    981981 
    982982    if (v != null) { 
     
    10091009      currentOrder[i] = "XYZTC"; 
    10101010 
    1011       int tPixelType = ((Integer) metadata.get("Bytes per pixel")).intValue(); 
     1011      int tPixelType = ((Integer) getMeta("Bytes per pixel")).intValue(); 
    10121012      switch (tPixelType) { 
    10131013        case 1: 
     
    10421042        new Integer(i)); 
    10431043 
    1044       String timestamp = (String) metadata.get("Timestamp " + (i+1)); 
    1045       String description = (String) metadata.get("Image Description"); 
     1044      String timestamp = (String) getMeta("Timestamp " + (i+1)); 
     1045      String description = (String) getMeta("Image Description"); 
    10461046 
    10471047      try { 
  • trunk/loci/formats/in/MRCReader.java

    r2117 r2131  
    206206    float zlen = Float.intBitsToFloat(DataTools.bytesToInt(b, little)); 
    207207 
    208     metadata.put("Pixel size (X)", "" + (xlen / mx)); 
    209     metadata.put("Pixel size (Y)", "" + (ylen / my)); 
    210     metadata.put("Pixel size (Z)", "" + (zlen / mz)); 
     208    addMeta("Pixel size (X)", "" + (xlen / mx)); 
     209    addMeta("Pixel size (Y)", "" + (ylen / my)); 
     210    addMeta("Pixel size (Z)", "" + (zlen / mz)); 
    211211 
    212212    in.read(b); 
     
    217217    float gamma = Float.intBitsToFloat(DataTools.bytesToInt(b, little)); 
    218218 
    219     metadata.put("Alpha angle", "" + alpha); 
    220     metadata.put("Beta angle", "" + beta); 
    221     metadata.put("Gamma angle", "" + gamma); 
     219    addMeta("Alpha angle", "" + alpha); 
     220    addMeta("Beta angle", "" + beta); 
     221    addMeta("Gamma angle", "" + gamma); 
    222222 
    223223    in.skipBytes(12); 
     
    232232    float mean = Float.intBitsToFloat(DataTools.bytesToInt(b, little)); 
    233233 
    234     metadata.put("Minimum pixel value", "" + min); 
    235     metadata.put("Maximum pixel value", "" + max); 
    236     metadata.put("Mean pixel value", "" + mean); 
     234    addMeta("Minimum pixel value", "" + min); 
     235    addMeta("Maximum pixel value", "" + max); 
     236    addMeta("Mean pixel value", "" + mean); 
    237237 
    238238    in.skipBytes(4); 
     
    287287    } 
    288288 
    289     metadata.put("Series type", type); 
    290     metadata.put("Lens", "" + lens); 
    291     metadata.put("ND1", "" + nd1); 
    292     metadata.put("ND2", "" + nd2); 
    293     metadata.put("VD1", "" + vd1); 
    294     metadata.put("VD2", "" + vd2); 
     289    addMeta("Series type", type); 
     290    addMeta("Lens", "" + lens); 
     291    addMeta("ND1", "" + nd1); 
     292    addMeta("ND2", "" + nd2); 
     293    addMeta("VD1", "" + vd1); 
     294    addMeta("VD2", "" + vd2); 
    295295 
    296296    b = new byte[4]; 
     
    299299      in.read(b); 
    300300      angles[i] = Float.intBitsToFloat(DataTools.bytesToInt(b, little)); 
    301       metadata.put("Angle " + (i+1), "" + angles[i]); 
     301      addMeta("Angle " + (i+1), "" + angles[i]); 
    302302    } 
    303303 
     
    306306    in.read(b); 
    307307    int nUsefulLabels = DataTools.bytesToInt(b, little); 
    308     metadata.put("Number of useful labels", "" + nUsefulLabels); 
     308    addMeta("Number of useful labels", "" + nUsefulLabels); 
    309309 
    310310    b = new byte[80]; 
    311311    for (int i=0; i<10; i++) { 
    312312      in.read(b); 
    313       metadata.put("Label " + (i+1), new String(b)); 
     313      addMeta("Label " + (i+1), new String(b)); 
    314314    } 
    315315 
  • trunk/loci/formats/in/MetamorphReader.java

    r2033 r2131  
    142142            } 
    143143 
    144             metadata.put("Extra data", sb.toString().trim()); 
     144            addMeta("Extra data", sb.toString().trim()); 
    145145          } 
    146146        } 
     
    247247 
    248248    // parse (mangle) TIFF comment 
    249     String descr = (String) metadata.get("Comment"); 
     249    String descr = (String) getMeta("Comment"); 
    250250    if (descr != null) { 
    251251      StringTokenizer st = new StringTokenizer(descr, "\n"); 
     
    318318    throws FormatException, IOException 
    319319  { 
    320     Double globalMin = (Double) metadata.get("grayMin"); 
    321     Double globalMax = (Double) metadata.get("grayMax"); 
     320    Double globalMin = (Double) getMeta("grayMin"); 
     321    Double globalMax = (Double) getMeta("grayMax"); 
    322322    if (globalMin != null || globalMax != null) { 
    323323      getMetadataStore(currentId).setChannelGlobalMinMax(i, 
  • trunk/loci/formats/in/ND2Reader.java

    r2117 r2131  
    327327                  String effectiveKey = prefix + " " + pre + " " + key; 
    328328                  if (!metadata.containsKey(effectiveKey)) { 
    329                     metadata.put(effectiveKey, value); 
     329                    addMeta(effectiveKey, value); 
    330330                  } 
    331331                  else { 
    332                     String v = (String) metadata.get(effectiveKey); 
     332                    String v = (String) getMeta(effectiveKey); 
    333333                    try { 
    334334                      if (Integer.parseInt(v) < Integer.parseInt(value)) { 
    335                         metadata.put(effectiveKey, value); 
     335                        addMeta(effectiveKey, value); 
    336336                      } 
    337337                    } 
     
    375375 
    376376    String sigBits = 
    377       (String) metadata.get("AdvancedImageAttributes SignificantBits value"); 
     377      (String) getMeta("AdvancedImageAttributes SignificantBits value"); 
    378378    int bits = 0; 
    379379    if (sigBits != null && sigBits.length() > 0) { 
     
    382382 
    383383    // determine the pixel size 
    384     String pixX = (String) metadata.get( 
    385       "CalibrationSeq _SEQUENCE_INDEX=\"0\" dCalibration value"); 
    386     String pixZ = (String) metadata.get( 
    387       "CalibrationSeq _SEQUENCE_INDEX=\"0\" dAspect value"); 
     384    String pixX = (String) 
     385      getMeta("CalibrationSeq _SEQUENCE_INDEX=\"0\" dCalibration value"); 
     386    String pixZ = (String) 
     387      getMeta("CalibrationSeq _SEQUENCE_INDEX=\"0\" dAspect value"); 
    388388 
    389389    float pixSizeX = 0f; 
     
    398398 
    399399    String c = (String)  
    400       metadata.get("MetadataSeq _SEQUENCE_INDEX=\"0\" uiCompCount value"); 
     400      getMeta("MetadataSeq _SEQUENCE_INDEX=\"0\" uiCompCount value"); 
    401401    if (c != null) sizeC[0] = Integer.parseInt(c); 
    402402    else sizeC[0] = openImage(id, 0).getRaster().getNumBands(); 
     
    408408    for (int i=0; i<numImages; i++) { 
    409409      String pre = "MetadataSeq _SEQUENCE_INDEX=\"" + i + "\" "; 
    410       String tstamp = (String) metadata.get(pre + "dTimeMSec value"); 
    411       String zstamp = (String) metadata.get(pre + "dZPos value"); 
     410      String tstamp = (String) getMeta(pre + "dTimeMSec value"); 
     411      String zstamp = (String) getMeta(pre + "dZPos value"); 
    412412      if (tstamp != null) timestamps[i] = (long) Float.parseFloat(tstamp); 
    413413      if (zstamp != null) zstamps[i] = (long) Float.parseFloat(zstamp); 
  • trunk/loci/formats/in/NikonReader.java

    r2117 r2131  
    225225 
    226226    try { 
    227       realImage.put(new Integer(TiffTools.COLOR_MAP), 
    228         metadata.get("CFA pattern")); 
     227      realImage.put(new Integer(TiffTools.COLOR_MAP), getMeta("CFA pattern")); 
    229228    } 
    230229    catch (Exception e) { 
     
    245244    String v = ""; 
    246245    for (int i=0; i<version.length; i++) v += version[i]; 
    247     metadata.put("Version", v); 
     246    addMeta("Version", v); 
    248247 
    249248    littleEndian = true; 
     
    272271              int[] colorMap = new int[cfa.length]; 
    273272              for (int i=0; i<cfa.length; i++) colorMap[i] = (int) cfa[i]; 
    274               metadata.put(getTagName(tag), colorMap); 
     273              addMeta(getTagName(tag), colorMap); 
    275274            } 
    276             else metadata.put(getTagName(tag), exifIFD.get(key)); 
     275            else addMeta(getTagName(tag), exifIFD.get(key)); 
    277276          } 
    278277        } 
     
    284283 
    285284    try { 
    286       byte[] offsets = (byte[]) metadata.get("Offset to maker note"); 
     285      byte[] offsets = (byte[]) getMeta("Offset to maker note"); 
    287286      makerNoteOffset = offsets[0]; 
    288287      Hashtable makerNote = TiffTools.getIFD(in, 0, makerNoteOffset); 
     
    293292          key = (Integer) e.nextElement(); 
    294293          int tag = key.intValue(); 
    295           metadata.put(getTagName(tag), makerNote.get(key)); 
     294          addMeta(getTagName(tag), makerNote.get(key)); 
    296295        } 
    297296      } 
  • trunk/loci/formats/in/OIBReader.java

    r2117 r2131  
    163163  { 
    164164    if (!id.equals(currentId)) initFile(id); 
    165     String s = (String) metadata.get("[Image Parameters] - DataMin"); 
     165    String s = (String) getMeta("[Image Parameters] - DataMin"); 
    166166    try { return new Double(s); } 
    167167    catch (NumberFormatException exc) { return null; } 
     
    173173  { 
    174174    if (!id.equals(currentId)) initFile(id); 
    175     String s = (String) metadata.get("[Image Parameters] - DataMax"); 
     175    String s = (String) getMeta("[Image Parameters] - DataMax"); 
    176176    try { return new Double(s); } 
    177177    catch (NumberFormatException exc) { return null; } 
     
    328328      for (int i=0; i<labels.length; i++) { 
    329329        labels[i] = (String) 
    330           metadata.get("[Axis " + i + " Parameters Common] - AxisCode"); 
     330          getMeta("[Axis " + i + " Parameters Common] - AxisCode"); 
    331331        dims[i] = 
    332           (String) metadata.get("[Axis " + i + " Parameters Common] - MaxSize"); 
     332          (String) getMeta("[Axis " + i + " Parameters Common] - MaxSize"); 
    333333        if (labels[i] == null) labels[i] = ""; 
    334334        if (dims[i] == null) dims[i] = "0"; 
     
    425425          String key = k.nextElement().toString(); 
    426426          if (key.indexOf("ValidBitCounts") != -1) { 
    427             vb = Integer.parseInt((String) metadata.get(key)); 
     427            vb = Integer.parseInt((String) getMeta(key)); 
    428428          } 
    429429        } 
     
    454454  private void initMetadata() throws FormatException, IOException { 
    455455    MetadataStore store = getMetadataStore(currentId); 
    456     store.setImage((String) metadata.get("DataName"), null, null, null); 
     456    store.setImage((String) getMeta("DataName"), null, null, null); 
    457457 
    458458    for (int i=0; i<width.size(); i++) { 
     
    484484        new Integer(i)); 
    485485 
    486       Float pixX = new Float(metadata.get( 
     486      Float pixX = new Float(getMeta( 
    487487        "[Reference Image Parameter] - WidthConvertValue").toString()); 
    488       Float pixY = new Float(metadata.get( 
     488      Float pixY = new Float(getMeta( 
    489489        "[Reference Image Parameter] - HeightConvertValue").toString()); 
    490490      store.setDimensions(pixX, pixY, null, null, null, new Integer(i)); 
     
    609609                prefix.indexOf("Green") == -1 && prefix.indexOf("Blue") == -1) 
    610610              { 
    611                 metadata.put(prefix + key, value); 
     611                addMeta(prefix + key, value); 
    612612              } 
    613613            } 
  • trunk/loci/formats/in/OIFReader.java

    r2117 r2131  
    9393      initFile(id); 
    9494    } 
    95     return metadata.get(field); 
     95    return getMeta(field); 
    9696  } 
    9797 
     
    120120  { 
    121121    if (!id.equals(currentId)) initFile(id); 
    122     return new Double((String) metadata.get("[Image Parameters] - DataMin")); 
     122    return new Double((String) getMeta("[Image Parameters] - DataMin")); 
    123123  } 
    124124 
     
    128128  { 
    129129    if (!id.equals(currentId)) initFile(id); 
    130     return new Double((String) metadata.get("[Image Parameters] - DataMax")); 
     130    return new Double((String) getMeta("[Image Parameters] - DataMax")); 
    131131  } 
    132132 
     
    277277          filenames.put(new Integer(pos), value); 
    278278        } 
    279         metadata.put(prefix + key, value); 
     279        addMeta(prefix + key, value); 
    280280      } 
    281281      else if (line.length() > 0) { 
     
    323323            tiffs.add(i, tiffPath + File.separator + value); 
    324324          } 
    325           metadata.put("Image " + i + " : " + key, value); 
     325          addMeta("Image " + i + " : " + key, value); 
    326326        } 
    327327      } 
     
    331331    for (int i=0; i<9; i++) { 
    332332      String pre = "[Axis " + i + " Parameters Common] - "; 
    333       String code = (String) metadata.get(pre + "AxisCode"); 
    334       String size = (String) metadata.get(pre + "MaxSize"); 
     333      String code = (String) getMeta(pre + "AxisCode"); 
     334      String size = (String) getMeta(pre + "MaxSize"); 
    335335      if (code.equals("\"X\"")) sizeX[0] = Integer.parseInt(size); 
    336336      else if (code.equals("\"Y\"")) sizeY[0] = Integer.parseInt(size); 
     
    349349    } 
    350350 
    351     String metadataOrder = 
    352       (String) metadata.get("[Axis Parameter Common] - AxisOrder"); 
     351    String metadataOrder = (String) 
     352      getMeta("[Axis Parameter Common] - AxisOrder"); 
    353353    metadataOrder = metadataOrder.substring(1, metadataOrder.length() - 1); 
    354354    if (metadataOrder == null) metadataOrder = "XYZTC"; 
     
    366366    MetadataStore store = getMetadataStore(oifFile); 
    367367 
    368     int imageDepth = Integer.parseInt( 
    369       (String) metadata.get("[Reference Image Parameter] - ImageDepth")); 
     368    int imageDepth = Integer.parseInt((String) 
     369      getMeta("[Reference Image Parameter] - ImageDepth")); 
    370370    switch (imageDepth) { 
    371371      case 1: 
     
    386386    if (validBits.length == 2) validBits = new int[3]; 
    387387    for (int i=0; i<validBits.length; i++) { 
    388       s = (String) metadata.get("[Reference Image Parameter] - ValidBitCounts"); 
     388      s = (String) getMeta("[Reference Image Parameter] - ValidBitCounts"); 
    389389      if (s != null) { 
    390390        validBits[i] = Integer.parseInt(s); 
     
    412412 
    413413    Float pixX = new Float((String) 
    414       metadata.get("[Reference Image Parameter] - WidthConvertValue")); 
     414      getMeta("[Reference Image Parameter] - WidthConvertValue")); 
    415415    Float pixY = new Float((String) 
    416       metadata.get("[Reference Image Parameter] - HeightConvertValue")); 
     416      getMeta("[Reference Image Parameter] - HeightConvertValue")); 
    417417 
    418418    store.setDimensions(pixX, pixY, null, null, null, null); 
  • trunk/loci/formats/in/OpenlabRawReader.java

    r2117 r2131  
    153153 
    154154    int version = in.readInt(); 
    155     metadata.put("Version", new Integer(version)); 
     155    addMeta("Version", new Integer(version)); 
    156156 
    157157    numImages = in.readInt(); 
     
    168168    if (channels <= 1) channels = 1; 
    169169    else channels = 3; 
    170     metadata.put("Width", new Integer(width)); 
    171     metadata.put("Height", new Integer(height)); 
    172     metadata.put("Bytes per pixel", new Integer(bytesPerPixel)); 
     170    addMeta("Width", new Integer(width)); 
     171    addMeta("Height", new Integer(height)); 
     172    addMeta("Bytes per pixel", new Integer(bytesPerPixel)); 
    173173 
    174174    for (int i=1; i<numImages; i++) { 
     
    176176    } 
    177177 
    178     bytesPerPixel = ((Integer) metadata.get("Bytes per pixel")).intValue(); 
     178    bytesPerPixel = ((Integer) getMeta("Bytes per pixel")).intValue(); 
    179179 
    180180    sizeX[0] = width; 
     
    203203 
    204204    store.setPixels( 
    205       (Integer) metadata.get("Width"), 
    206       (Integer) metadata.get("Height"), 
     205      (Integer) getMeta("Width"), 
     206      (Integer) getMeta("Height"), 
    207207      new Integer(numImages), 
    208208      new Integer(channels), 
  • trunk/loci/formats/in/OpenlabReader.java

    r2117 r2131  
    528528                } 
    529529 
    530                 metadata.put(varName, varStringValue); 
     530                addMeta(varName, varStringValue); 
    531531                numVars--; 
    532532              } 
     
    628628 
    629629    // finish populating metadata hashtable 
    630     metadata.put("Version", new Integer(version)); 
    631     metadata.put("Number of Series", new Integer(numSeries)); 
     630    addMeta("Version", new Integer(version)); 
     631    addMeta("Number of Series", new Integer(numSeries)); 
    632632    for (int i=0; i<numSeries; i++) { 
    633       metadata.put("Width (Series " + i + ")", new Integer(width[i])); 
    634       metadata.put("Height (Series " + i + ")", new Integer(height[i])); 
    635       metadata.put("Bit depth (Series " + i + ")", 
     633      addMeta("Width (Series " + i + ")", new Integer(width[i])); 
     634      addMeta("Height (Series " + i + ")", new Integer(height[i])); 
     635      addMeta("Bit depth (Series " + i + ")", 
    636636        new Integer(bpp[i] * 8)); 
    637       metadata.put("Number of channels (Series " + i + ")", 
     637      addMeta("Number of channels (Series " + i + ")", 
    638638        new Integer(channelCount[i])); 
    639       metadata.put("Number of images (Series " + i + ")", 
     639      addMeta("Number of images (Series " + i + ")", 
    640640        new Integer(numImages[i])); 
    641641    } 
  • trunk/loci/formats/in/PerkinElmerReader.java

    r2117 r2131  
    382382          catch (NumberFormatException e) { tNum++; } 
    383383        } 
    384         metadata.put(hashKeys[tNum], token); 
     384        addMeta(hashKeys[tNum], token); 
    385385        tNum++; 
    386386      } 
     
    406406        } 
    407407        else if (pt < hashKeys.length) { 
    408           metadata.put(hashKeys[pt], t.nextToken()); 
     408          addMeta(hashKeys[pt], t.nextToken()); 
    409409          pt++; 
    410410        } 
    411411        else { 
    412           metadata.put(t.nextToken() + t.nextToken(), 
    413             t.nextToken()); 
     412          addMeta(t.nextToken() + t.nextToken(), t.nextToken()); 
    414413        } 
    415414        tNum++; 
     
    425424      int tNum = 0; 
    426425      while (t.hasMoreTokens()) { 
    427         metadata.put("Z slice #" + tNum + " position", t.nextToken()); 
     426        addMeta("Z slice #" + tNum + " position", t.nextToken()); 
    428427        tNum++; 
    429428      } 
     
    462461      for (int j=0; j<tokens.length-1; j+=2) { 
    463462        if (tokens[j].indexOf("Wavelength") != -1) { 
    464           metadata.put("Camera Data " + tokens[j].charAt(13), tokens[j]); 
     463          addMeta("Camera Data " + tokens[j].charAt(13), tokens[j]); 
    465464          j--; 
    466465        } 
    467466        else if (!tokens[j].trim().equals("")) { 
    468           metadata.put(tokens[j], tokens[j+1]); 
     467          addMeta(tokens[j], tokens[j+1]); 
    469468        } 
    470469      } 
     
    474473    } 
    475474 
    476     String details = (String) metadata.get("Experiment details:"); 
     475    String details = (String) getMeta("Experiment details:"); 
    477476    // parse details to get number of wavelengths and timepoints 
    478477 
     
    495494    channels = Integer.parseInt(wavelengths); 
    496495 
    497     sizeX[0] = Integer.parseInt((String) metadata.get("Image Width")); 
    498     sizeY[0] = Integer.parseInt((String) metadata.get("Image Length")); 
    499     sizeZ[0] = Integer.parseInt((String) metadata.get("Number of slices")); 
     496    sizeX[0] = Integer.parseInt((String) getMeta("Image Width")); 
     497    sizeY[0] = Integer.parseInt((String) getMeta("Image Length")); 
     498    sizeZ[0] = Integer.parseInt((String) getMeta("Number of slices")); 
    500499    sizeC[0] = channels; 
    501500    sizeT[0] = getImageCount(currentId) / (sizeZ[0] * sizeC[0]); 
     
    531530    if (sizeT[0] <= 0) sizeT[0] = 1; 
    532531 
    533     Object o = metadata.get("Z slice space"); 
     532    Object o = getMeta("Z slice space"); 
    534533    if (o != null) { 
    535534      float spacing = Float.parseFloat(o.toString()); 
     
    545544 
    546545    // populate Dimensions element 
    547     String pixelSizeX = (String) metadata.get("Pixel Size X"); 
    548     String pixelSizeY = (String) metadata.get("Pixel Size Y"); 
     546    String pixelSizeX = (String) getMeta("Pixel Size X"); 
     547    String pixelSizeY = (String) getMeta("Pixel Size Y"); 
    549548    store.setDimensions(new Float(pixelSizeX), 
    550549        new Float(pixelSizeY), null, null, null, null); 
    551550 
    552551    // populate Image element 
    553     String time = (String) metadata.get("Finish Time:"); 
     552    String time = (String) getMeta("Finish Time:"); 
    554553    time = time.substring(1).trim(); 
    555554    store.setImage(null, time, null, null); 
    556555 
    557556    // populate Pixels element 
    558     String x = (String) metadata.get("Image Width"); 
    559     String y = (String) metadata.get("Image Length"); 
    560     String z = (String) metadata.get("Number of slices"); 
     557    String x = (String) getMeta("Image Width"); 
     558    String y = (String) getMeta("Image Length"); 
     559    String z = (String) getMeta("Number of slices"); 
    561560    store.setPixels( 
    562561      new Integer(x), // SizeX 
     
    571570 
    572571    // populate StageLabel element 
    573     String originX = (String) metadata.get("Origin X"); 
    574     String originY = (String) metadata.get("Origin Y"); 
    575     String originZ = (String) metadata.get("Origin Z"); 
     572    String originX = (String) getMeta("Origin X"); 
     573    String originY = (String) getMeta("Origin Y"); 
     574    String originZ = (String) getMeta("Origin Z"); 
    576575    try { 
    577576      store.setStageLabel(null, new Float(originX), new Float(originY), 
  • trunk/loci/formats/in/PrairieReader.java

    r2117 r2131  
    255255              String value = el.substring(eq + 2, el.indexOf("\"", eq + 2)); 
    256256              if (prefix.equals("File")) { 
    257                 metadata.put(pastPrefix + " " + prefix + " " + fileIndex + 
     257                addMeta(pastPrefix + " " + prefix + " " + fileIndex + 
    258258                  " " + key, value); 
    259259                if (key.equals("filename")) fileIndex++; 
    260260              } 
    261               else metadata.put(pastPrefix + " " + prefix + " " + key, value); 
     261              else addMeta(pastPrefix + " " + prefix + " " + key, value); 
    262262              el = el.substring(el.indexOf("\"", eq + 2) + 1).trim(); 
    263263              if (prefix.equals("File") && key.equals("filename")) { 
     
    274274            String value = 
    275275              el.substring(valueIndex, el.indexOf("\"", valueIndex)); 
    276             metadata.put(key, value); 
     276            addMeta(key, value); 
    277277          } 
    278278          if (!closed) { 
     
    292292 
    293293        boolean isZ = 
    294           ((String) metadata.get("PVScan Sequence type")).equals("ZSeries"); 
     294          ((String) getMeta("PVScan Sequence type")).equals("ZSeries"); 
    295295        if (zt == 0) zt = 1; 
    296296 
    297         sizeX[0] = Integer.parseInt((String) metadata.get("pixelsPerLine")); 
    298         sizeY[0] = Integer.parseInt((String) metadata.get("linesPerFrame")); 
     297        sizeX[0] = Integer.parseInt((String) getMeta("pixelsPerLine")); 
     298        sizeY[0] = Integer.parseInt((String) getMeta("linesPerFrame")); 
    299299        sizeZ[0] = isZ ? zt : 1; 
    300300        sizeT[0] = isZ ? 1 : zt; 
     
    304304 
    305305        float pixSizeX = 
    306           Float.parseFloat((String) metadata.get("micronsPerPixel_XAxis")); 
     306          Float.parseFloat((String) getMeta("micronsPerPixel_XAxis")); 
    307307        float pixSizeY = 
    308           Float.parseFloat((String) metadata.get("micronsPerPixel_YAxis")); 
     308          Float.parseFloat((String) getMeta("micronsPerPixel_YAxis")); 
    309309 
    310310        MetadataStore store = getMetadataStore(id); 
  • trunk/loci/formats/in/QTReader.java

    r2117 r2131  
    814814              int fieldsPerPlane = in.read(); 
    815815              interlaced = fieldsPerPlane == 2; 
    816               metadata.put("Codec", codec); 
    817               metadata.put("Bits per pixel", new Integer(bitsPerPixel)); 
     816              addMeta("Codec", codec); 
     817              addMeta("Bits per pixel", new Integer(bitsPerPixel)); 
    818818              in.readDouble(); 
    819819              in.read(); 
     
    821821            else { 
    822822              altCodec = new String(b); 
    823               metadata.put("Second codec", altCodec); 
     823              addMeta("Second codec", altCodec); 
    824824            } 
    825825          } 
     
    860860          in.readInt(); 
    861861          int fps = in.readInt(); 
    862           metadata.put("Frames per second", new Integer(fps)); 
     862          addMeta("Frames per second", new Integer(fps)); 
    863863        } 
    864864        if (oldpos + atomSize < in.length()) { 
  • trunk/loci/formats/in/SDTInfo.java

    r1651 r2131  
    419419   * populating the given metadata table. 
    420420   */ 
    421   public SDTInfo(RandomAccessStream in, Hashtable metadata) throws IOException { 
     421  public SDTInfo(RandomAccessStream in, Hashtable meta) throws IOException { 
    422422    // read bhfileHeader 
    423423    revision = in.readShort(); 
     
    438438 
    439439    // save bhfileHeader to metadata table 
    440     if (metadata != null) { 
     440    if (meta != null) { 
    441441      final String bhfileHeader = "bhfileHeader."; 
    442       metadata.put(bhfileHeader + "revision", new Short(revision)); 
    443       metadata.put(bhfileHeader + "infoOffs", new Integer(infoOffs)); 
    444       metadata.put(bhfileHeader + "infoLength", new Short(infoLength)); 
    445       metadata.put(bhfileHeader + "setupOffs", new Integer(setupOffs)); 
    446       metadata.put(bhfileHeader + "dataBlockOffs", new Integer(dataBlockOffs)); 
    447       metadata.put(bhfileHeader + "noOfDataBlocks", new Short(noOfDataBlocks)); 
    448       metadata.put(bhfileHeader + "dataBlockLength", 
     442      meta.put(bhfileHeader + "revision", new Short(revision)); 
     443      meta.put(bhfileHeader + "infoOffs", new Integer(infoOffs)); 
     444      meta.put(bhfileHeader + "infoLength", new Short(infoLength)); 
     445      meta.put(bhfileHeader + "setupOffs", new Integer(setupOffs)); 
     446      meta.put(bhfileHeader + "dataBlockOffs", new Integer(dataBlockOffs)); 
     447      meta.put(bhfileHeader + "noOfDataBlocks", new Short(noOfDataBlocks)); 
     448      meta.put(bhfileHeader + "dataBlockLength", 
    449449        new Integer(dataBlockLength)); 
    450       metadata.put(bhfileHeader + "measDescBlockOffs", 
     450      meta.put(bhfileHeader + "measDescBlockOffs", 
    451451        new Integer(measDescBlockOffs)); 
    452       metadata.put(bhfileHeader + "noOfMeasDescBlocks", 
     452      meta.put(bhfileHeader + "noOfMeasDescBlocks", 
    453453        new Short(noOfMeasDescBlocks)); 
    454       metadata.put(bhfileHeader + "measDescBlockLength", 
     454      meta.put(bhfileHeader + "measDescBlockLength", 
    455455        new Integer(measDescBlockLength)); 
    456       metadata.put(bhfileHeader + "headerValid", new Integer(headerValid)); 
    457       metadata.put(bhfileHeader + "reserved1", new Long(reserved1)); 
    458       metadata.put(bhfileHeader + "reserved2", new Integer(reserved2)); 
    459       metadata.put(bhfileHeader + "chksum", new Integer(chksum)); 
     456      meta.put(bhfileHeader + "headerValid", new Integer(headerValid)); 
     457      meta.put(bhfileHeader + "reserved1", new Long(reserved1)); 
     458      meta.put(bhfileHeader + "reserved2", new Integer(reserved2)); 
     459      meta.put(bhfileHeader + "chksum", new Integer(chksum)); 
    460460    } 
    461461 
     
    467467 
    468468    // save file info to metadata table 
    469     if (metadata != null) metadata.put("File Info", info); 
     469    if (meta != null) meta.put("File Info", info); 
    470470    // TODO: parse individual parameters from info string and store them 
    471471 
     
    477477 
    478478    // save setup to metadata table 
    479     if (metadata != null) metadata.put("Setup", setup); 
     479    if (meta != null) meta.put("Setup", setup); 
    480480    // TODO: parse individual parameters from setup string and store them 
    481481 
     
    589589 
    590590        // save MeasureInfo to metadata table 
    591         if (metadata != null) { 
     591        if (meta != null) { 
    592592          final String measureInfo = "MeasureInfo."; 
    593           metadata.put(measureInfo + "time", time); 
    594           metadata.put(measureInfo + "date", date); 
    595           metadata.put(measureInfo + "modSerNo", modSerNo); 
    596           metadata.put(measureInfo + "measMode", new Short(measMode)); 
    597           metadata.put(measureInfo + "cfdLL", new Float(cfdLL)); 
    598           metadata.put(measureInfo + "cfdLH", new Float(cfdLH)); 
    599           metadata.put(measureInfo + "cfdZC", new Float(cfdZC)); 
    600           metadata.put(measureInfo + "cfdHF", new Float(cfdHF)); 
    601           metadata.put(measureInfo + "synZC", new Float(synZC)); 
    602           metadata.put(measureInfo + "synFD", new Short(synFD)); 
    603           metadata.put(measureInfo + "synHF", new Float(synHF)); 
    604           metadata.put(measureInfo + "tacR", new Float(tacR)); 
    605           metadata.put(measureInfo + "tacG", new Short(tacG)); 
    606           metadata.put(measureInfo + "tacOF", new Float(tacOF)); 
    607           metadata.put(measureInfo + "tacLL", new Float(tacLL)); 
    608           metadata.put(measureInfo + "tacLH", new Float(tacLH)); 
    609           metadata.put(measureInfo + "adcRE", new Short(adcRE)); 
    610           metadata.put(measureInfo + "ealDE", new Short(ealDE)); 
    611           metadata.put(measureInfo + "ncx", new Short(ncx)); 
    612           metadata.put(measureInfo + "ncy", new Short(ncy)); 
    613           metadata.put(measureInfo + "page", new Integer(page)); 
    614           metadata.put(measureInfo + "colT", new Float(colT)); 
    615           metadata.put(measureInfo + "repT", new Float(repT)); 
    616           metadata.put(measureInfo + "stopt", new Short(stopt)); 
    617           metadata.put(measureInfo + "overfl", new Integer(overfl)); 
    618           metadata.put(measureInfo + "useMotor", new Short(useMotor)); 
    619           metadata.put(measureInfo + "steps", new Integer(steps)); 
    620           metadata.put(measureInfo + "offset", new Float(offset)); 
    621           metadata.put(measureInfo + "dither", new Short(dither)); 
    622           metadata.put(measureInfo + "incr", new Short(incr)); 
    623           metadata.put(measureInfo + "memBank", new Short(memBank)); 
    624           metadata.put(measureInfo + "modType", modType); 
    625           metadata.put(measureInfo + "synTH", new Float(synTH)); 
    626           metadata.put(measureInfo + "deadTimeComp", new Short(deadTimeComp)); 
    627           metadata.put(measureInfo + "polarityL", new Short(polarityL)); 
    628           metadata.put(measureInfo + "polarityF", new Short(polarityF)); 
    629           metadata.put(measureInfo + "polarityP", new Short(polarityP)); 
    630           metadata.put(measureInfo + "linediv", new Short(linediv)); 
    631           metadata.put(measureInfo + "accumulate", new Short(accumulate)); 
    632           metadata.put(measureInfo + "flbckY", new Integer(flbckY)); 
    633           metadata.put(measureInfo + "flbckX", new Integer(flbckX)); 
    634           metadata.put(measureInfo + "bordU", new Integer(bordU)); 
    635           metadata.put(measureInfo + "bordL", new Integer(bordL)); 
    636           metadata.put(measureInfo + "pixTime", new Float(pixTime)); 
    637           metadata.put(measureInfo + "pixClk", new Short(pixClk)); 
    638           metadata.put(measureInfo + "trigger", new Short(trigger)); 
    639           metadata.put(measureInfo + "scanX", new Integer(scanX)); 
    640           metadata.put(measureInfo + "scanY", new Integer(scanY)); 
    641           metadata.put(measureInfo + "scanRX", new Integer(scanRX)); 
    642           metadata.put(measureInfo + "scanRY", new Integer(scanRY)); 
    643           metadata.put(measureInfo + "fifoTyp", new Short(fifoTyp)); 
    644           metadata.put(measureInfo + "epxDiv", new Integer(epxDiv)); 
    645           metadata.put(measureInfo + "modTypeCode", new Integer(modTypeCode)); 
    646           metadata.put(measureInfo + "modFpgaVer", new Integer(modFpgaVer)); 
    647           metadata.put(measureInfo + "overflowCorrFactor", 
     593          meta.put(measureInfo + "time", time); 
     594          meta.put(measureInfo + "date", date); 
     595          meta.put(measureInfo + "modSerNo", modSerNo); 
     596          meta.put(measureInfo + "measMode", new Short(measMode)); 
     597          meta.put(measureInfo + "cfdLL", new Float(cfdLL)); 
     598          meta.put(measureInfo + "cfdLH", new Float(cfdLH)); 
     599          meta.put(measureInfo + "cfdZC", new Float(cfdZC)); 
     600          meta.put(measureInfo + "cfdHF", new Float(cfdHF)); 
     601          meta.put(measureInfo + "synZC", new Float(synZC)); 
     602          meta.put(measureInfo + "synFD", new Short(synFD)); 
     603          meta.put(measureInfo + "synHF", new Float(synHF)); 
     604          meta.put(measureInfo + "tacR", new Float(tacR)); 
     605          meta.put(measureInfo + "tacG", new Short(tacG)); 
     606          meta.put(measureInfo + "tacOF", new Float(tacOF)); 
     607          meta.put(measureInfo + "tacLL", new Float(tacLL)); 
     608          meta.put(measureInfo + "tacLH", new Float(tacLH)); 
     609          meta.put(measureInfo + "adcRE", new Short(adcRE)); 
     610          meta.put(measureInfo + "ealDE", new Short(ealDE)); 
     611          meta.put(measureInfo + "ncx", new Short(ncx)); 
     612          meta.put(measureInfo + "ncy", new Short(ncy)); 
     613          meta.put(measureInfo + "page", new Integer(page)); 
     614          meta.put(measureInfo + "colT", new Float(colT)); 
     615          meta.put(measureInfo + "repT", new Float(repT)); 
     616          meta.put(measureInfo + "stopt", new Short(stopt)); 
     617          meta.put(measureInfo + "overfl", new Integer(overfl)); 
     618          meta.put(measureInfo + "useMotor", new Short(useMotor)); 
     619          meta.put(measureInfo + "steps", new Integer(steps)); 
     620          meta.put(measureInfo + "offset", new Float(offset)); 
     621          meta.put(measureInfo + "dither", new Short(dither)); 
     622          meta.put(measureInfo + "incr", new Short(incr)); 
     623          meta.put(measureInfo + "memBank", new Short(memBank)); 
     624          meta.put(measureInfo + "modType", modType); 
     625          meta.put(measureInfo + "synTH", new Float(synTH)); 
     626          meta.put(measureInfo + "deadTimeComp", new Short(deadTimeComp)); 
     627          meta.put(measureInfo + "polarityL", new Short(polarityL)); 
     628          meta.put(measureInfo + "polarityF", new Short(polarityF)); 
     629          meta.put(measureInfo + "polarityP", new Short(polarityP)); 
     630          meta.put(measureInfo + "linediv", new Short(linediv)); 
     631          meta.put(measureInfo + "accumulate", new Short(accumulate)); 
     632          meta.put(measureInfo + "flbckY", new Integer(flbckY)); 
     633          meta.put(measureInfo + "flbckX", new Integer(flbckX)); 
     634          meta.put(measureInfo + "bordU", new Integer(bordU)); 
     635          meta.put(measureInfo + "bordL", new Integer(bordL)); 
     636          meta.put(measureInfo + "pixTime", new Float(pixTime)); 
     637          meta.put(measureInfo + "pixClk", new Short(pixClk)); 
     638          meta.put(measureInfo + "trigger", new Short(trigger)); 
     639          meta.put(measureInfo + "scanX", new Integer(scanX)); 
     640          meta.put(measureInfo + "scanY", new Integer(scanY)); 
     641          meta.put(measureInfo + "scanRX", new Integer(scanRX)); 
     642          meta.put(measureInfo + "scanRY", new Integer(scanRY)); 
     643          meta.put(measureInfo + "fifoTyp", new Short(fifoTyp)); 
     644          meta.put(measureInfo + "epxDiv", new Integer(epxDiv)); 
     645          meta.put(measureInfo + "modTypeCode", new Integer(modTypeCode)); 
     646          meta.put(measureInfo + "modFpgaVer", new Integer(modFpgaVer)); 
     647          meta.put(measureInfo + "overflowCorrFactor", 
    648648            new Float(overflowCorrFactor)); 
    649           metadata.put(measureInfo + "adcZoom", new Integer(adcZoom)); 
    650           metadata.put(measureInfo + "cycles", new Integer(cycles)); 
     649          meta.put(measureInfo + "adcZoom", new Integer(adcZoom)); 
     650          meta.put(measureInfo + "cycles", new Integer(cycles)); 
    651651        } 
    652652 
     
    678678 
    679679        // save MeasStopInfo to metadata table 
    680         if (metadata != null) { 
     680        if (meta != null) { 
    681681          final String measStopInfo = "MeasStopInfo."; 
    682           metadata.put(measStopInfo + "status", new Integer(status)); 
    683           metadata.put(measStopInfo + "flags", new Integer(flags)); 
    684           metadata.put(measStopInfo + "stopTime", new Float(stopTime)); 
    685           metadata.put(measStopInfo + "curStep", new Integer(curStep)); 
    686           metadata.put(measStopInfo + "curCycle", new Integer(curCycle)); 
    687           metadata.put(measStopInfo + "curPage", new Integer(curPage)); 
    688           metadata.put(measStopInfo + "minSyncRate", new Float(minSyncRate)); 
    689           metadata.put(measStopInfo + "minCfdRate", new Float(minCfdRate)); 
    690           metadata.put(measStopInfo + "minTacRate", new Float(minTacRate)); 
    691           metadata.put(measStopInfo + "minAdcRate", new Float(minAdcRate)); 
    692           metadata.put(measStopInfo + "maxSyncRate", new Float(maxSyncRate)); 
    693           metadata.put(measStopInfo + "maxCfdRate", new Float(maxCfdRate)); 
    694           metadata.put(measStopInfo + "maxTacRate", new Float(maxTacRate)); 
    695           metadata.put(measStopInfo + "maxAdcRate", new Float(maxAdcRate)); 
    696           metadata.put(measStopInfo + "reserved1", new Integer(mReserved1)); 
    697           metadata.put(measStopInfo + "reserved2", new Float(mReserved2)); 
     682          meta.put(measStopInfo + "status", new Integer(status)); 
     683          meta.put(measStopInfo + "flags", new Integer(flags)); 
     684          meta.put(measStopInfo + "stopTime", new Float(stopTime)); 
     685          meta.put(measStopInfo + "curStep", new Integer(curStep)); 
     686          meta.put(measStopInfo + "curCycle", new Integer(curCycle)); 
     687          meta.put(measStopInfo + "curPage", new Integer(curPage)); 
     688          meta.put(measStopInfo + "minSyncRate", new Float(minSyncRate)); 
     689          meta.put(measStopInfo + "minCfdRate", new Float(minCfdRate)); 
     690          meta.put(measStopInfo + "minTacRate", new Float(minTacRate)); 
     691          meta.put(measStopInfo + "minAdcRate", new Float(minAdcRate)); 
     692          meta.put(measStopInfo + "maxSyncRate", new Float(maxSyncRate)); 
     693          meta.put(measStopInfo + "maxCfdRate", new Float(maxCfdRate)); 
     694          meta.put(measStopInfo + "maxTacRate", new Float(maxTacRate)); 
     695          meta.put(measStopInfo + "maxAdcRate", new Float(maxAdcRate)); 
     696          meta.put(measStopInfo + "reserved1", new Integer(mReserved1)); 
     697          meta.put(measStopInfo + "reserved2", new Float(mReserved2)); 
    698698        } 
    699699      } 
     
    716716 
    717717        // save MeasFCSInfo to metadata table 
    718         if (metadata != null) { 
     718        if (meta != null) { 
    719719          final String measFCSInfo = "MeasFCSInfo."; 
    720           metadata.put(measFCSInfo + "chan", new Integer(chan)); 
    721           metadata.put(measFCSInfo + "fcsDecayCalc", new Integer(fcsDecayCalc)); 
    722           metadata.put(measFCSInfo + "mtResol", new Long(mtResol)); 
    723           metadata.put(measFCSInfo + "cortime", new Float(cortime)); 
    724           metadata.put(measFCSInfo + "calcPhotons", new Long(calcPhotons)); 
    725           metadata.put(measFCSInfo + "fcsPoints", new Integer(fcsPoints)); 
    726           metadata.put(measFCSInfo + "endTime", new Float(endTime)); 
    727           metadata.put(measFCSInfo + "overruns", new Integer(overruns)); 
    728           metadata.put(measFCSInfo + "fcsType", new Integer(fcsType)); 
    729           metadata.put(measFCSInfo + "crossChan", new Integer(crossChan)); 
    730           metadata.put(measFCSInfo + "mod", new Integer(mod)); 
    731           metadata.put(measFCSInfo + "crossMod", new Integer(crossMod)); 
    732           metadata.put(measFCSInfo + "crossMtResol", new Float(crossMtResol)); 
     720          meta.put(measFCSInfo + "chan", new Integer(chan)); 
     721          meta.put(measFCSInfo + "fcsDecayCalc", new Integer(fcsDecayCalc)); 
     722          meta.put(measFCSInfo + "mtResol", new Long(mtResol)); 
     723          meta.put(measFCSInfo + "cortime", new Float(cortime)); 
     724          meta.put(measFCSInfo + "calcPhotons", new Long(calcPhotons)); 
     725          meta.put(measFCSInfo + "fcsPoints", new Integer(fcsPoints)); 
     726          meta.put(measFCSInfo + "endTime", new Float(endTime)); 
     727          meta.put(measFCSInfo + "overruns", new Integer(overruns)); 
     728          meta.put(measFCSInfo + "fcsType", new Integer(fcsType)); 
     729          meta.put(measFCSInfo + "crossChan", new Integer(crossChan)); 
     730          meta.put(measFCSInfo + "mod", new Integer(mod)); 
     731          meta.put(measFCSInfo + "crossMod", new Integer(crossMod)); 
     732          meta.put(measFCSInfo + "crossMtResol", new Float(crossMtResol)); 
    733733        } 
    734734      } 
     
    746746 
    747747        // save extra MeasureInfo to metadata table 
    748         if (metadata != null) { 
     748        if (meta != null) { 
    749749          final String measureInfo = "MeasureInfo."; 
    750           metadata.put(measureInfo + "imageX", new Integer(imageX)); 
    751           metadata.put(measureInfo + "imageY", new Integer(imageY)); 
    752           metadata.put(measureInfo + "imageRX", new Integer(imageRX)); 
    753           metadata.put(measureInfo + "imageRY", new Integer(imageRY)); 
    754           metadata.put(measureInfo + "xyGain", new Short(xyGain)); 
    755           metadata.put(measureInfo + "masterClock", new Short(masterClock)); 
    756           metadata.put(measureInfo + "adcDE", new Short(adcDE)); 
    757           metadata.put(measureInfo + "detType", new Short(detType)); 
    758           metadata.put(measureInfo + "xAxis", new Short(xAxis)); 
     750          meta.put(measureInfo + "imageX", new Integer(imageX)); 
     751          meta.put(measureInfo + "imageY", new Integer(imageY)); 
     752          meta.put(measureInfo + "imageRX", new Integer(imageRX)); 
     753          meta.put(measureInfo + "imageRY", new Integer(imageRY)); 
     754          meta.put(measureInfo + "xyGain", new Short(xyGain)); 
     755          meta.put(measureInfo + "masterClock", new Short(masterClock)); 
     756          meta.put(measureInfo + "adcDE", new Short(adcDE)); 
     757          meta.put(measureInfo + "detType", new Short(detType)); 
     758          meta.put(measureInfo + "xAxis", new Short(xAxis)); 
    759759        } 
    760760      } 
     
    771771 
    772772        // save MeasHISTInfo to metadata table 
    773         if (metadata != null) { 
     773        if (meta != null) { 
    774774          final String measHISTInfo = "MeasHISTInfo."; 
    775           metadata.put(measHISTInfo + "fidaTime", new Float(fidaTime)); 
    776           metadata.put(measHISTInfo + "fildaTime", new Float(fildaTime)); 
    777           metadata.put(measHISTInfo + "fidaPoints", new Integer(fidaPoints)); 
    778           metadata.put(measHISTInfo + "fildaPoints", new Integer(fildaPoints)); 
    779           metadata.put(measHISTInfo + "mcsTime", new Float(mcsTime)); 
    780           metadata.put(measHISTInfo + "mcsPoints", new Integer(mcsPoints)); 
     775          meta.put(measHISTInfo + "fidaTime", new Float(fidaTime)); 
     776          meta.put(measHISTInfo + "fildaTime", new Float(fildaTime)); 
     777          meta.put(measHISTInfo + "fidaPoints", new Integer(fidaPoints)); 
     778          meta.put(measHISTInfo + "fildaPoints", new Integer(fildaPoints)); 
     779          meta.put(measHISTInfo + "mcsTime", new Float(mcsTime)); 
     780          meta.put(measHISTInfo + "mcsPoints", new Integer(mcsPoints)); 
    781781        } 
    782782      } 
     
    795795 
    796796    // save BHFileBlockHeader to metadata table 
    797     if (metadata != null) { 
     797    if (meta != null) { 
    798798      final String bhFileBlockHeader = "BHFileBlockHeader."; 
    799       metadata.put(bhFileBlockHeader + "blockNo", new Short(blockNo)); 
    800       metadata.put(bhFileBlockHeader + "dataOffs", new Integer(dataOffs)); 
    801       metadata.put(bhFileBlockHeader + "nextBlockOffs", 
     799      meta.put(bhFileBlockHeader + "blockNo", new Short(blockNo)); 
     800      meta.put(bhFileBlockHeader + "dataOffs", new Integer(dataOffs)); 
     801      meta.put(bhFileBlockHeader + "nextBlockOffs", 
    802802        new Integer(nextBlockOffs)); 
    803       metadata.put(bhFileBlockHeader + "blockType", new Integer(blockType)); 
    804       metadata.put(bhFileBlockHeader + "measDescBlockNo", 
     803      meta.put(bhFileBlockHeader + "blockType", new Integer(blockType)); 
     804      meta.put(bhFileBlockHeader + "measDescBlockNo", 
    805805        new Short(measDescBlockNo)); 
    806       metadata.put(bhFileBlockHeader + "lblockNo", new Long(lblockNo)); 
    807       metadata.put(bhFileBlockHeader + "blockLength", new Long(blockLength)); 
     806      meta.put(bhFileBlockHeader + "lblockNo", new Long(lblockNo)); 
     807      meta.put(bhFileBlockHeader + "blockLength", new Long(blockLength)); 
    808808    } 
    809809  } 
  • trunk/loci/formats/in/SDTReader.java

    r2117 r2131  
    209209    timeBins = info.timeBins; 
    210210    channels = info.channels; 
    211     metadata.put("time bins", new Integer(timeBins)); 
    212     metadata.put("channels", new Integer(channels)); 
     211    addMeta("time bins", new Integer(timeBins)); 
     212    addMeta("channels", new Integer(channels)); 
    213213 
    214214    sizeX[0] = info.width; 
  • trunk/loci/formats/in/SEQReader.java

    r2033 r2131  
    7070        String seqId = ""; 
    7171        for (int i=0; i<tag1.length; i++) seqId = seqId + tag1[i]; 
    72         metadata.put("Image-Pro SEQ ID", seqId); 
     72        addMeta("Image-Pro SEQ ID", seqId); 
    7373      } 
    7474 
     
    7878        // should be one of these for every image plane 
    7979        zSize++; 
    80         metadata.put("Frame Rate", new Integer(tag2)); 
     80        addMeta("Frame Rate", new Integer(tag2)); 
    8181      } 
    8282 
    83       metadata.put("Number of images", new Integer(zSize)); 
     83      addMeta("Number of images", new Integer(zSize)); 
    8484    } 
    8585 
     
    9191 
    9292    // default values 
    93     metadata.put("frames", "" + zSize); 
    94     metadata.put("channels", metadata.get("NumberOfChannels").toString()); 
    95     metadata.put("slices", "" + tSize); 
     93    addMeta("frames", "" + zSize); 
     94    addMeta("channels", getMeta("NumberOfChannels").toString()); 
     95    addMeta("slices", "" + tSize); 
    9696 
    9797    // parse the description to get channels, slices and times where applicable 
    98     String descr = (String) metadata.get("Comment"); 
     98    String descr = (String) getMeta("Comment"); 
    9999    metadata.remove("Comment"); 
    100100    if (descr != null) { 
     
    104104        String label = token.substring(0, token.indexOf("=")); 
    105105        String data = token.substring(token.indexOf("=") + 1); 
    106         metadata.put(label, data); 
     106        addMeta(label, data); 
    107107      } 
    108108    } 
    109109 
    110     sizeC[0] = Integer.parseInt((String) metadata.get("channels")); 
    111     sizeZ[0] = Integer.parseInt((String) metadata.get("frames")); 
    112     sizeT[0] = Integer.parseInt((String) metadata.get("slices")); 
     110    sizeC[0] = Integer.parseInt((String) getMeta("channels")); 
     111    sizeZ[0] = Integer.parseInt((String) getMeta("frames")); 
     112    sizeT[0] = Integer.parseInt((String) getMeta("slices")); 
    113113 
    114114    try { 
  • trunk/loci/formats/in/TiffReader.java

    r2010 r2131  
    6969  protected void initStandardMetadata() throws FormatException { 
    7070    super.initStandardMetadata(); 
    71     String comment = (String) metadata.get("Comment"); 
     71    String comment = (String) getMeta("Comment"); 
    7272 
    7373    // check for OME-XML in TIFF comment (OME-TIFF format) 
     
    445445        String key = line.substring(0, equals); 
    446446        String value = line.substring(equals + 1); 
    447         metadata.put(key, value); 
     447        addMeta(key, value); 
    448448      } 
    449449      metadata.remove("Comment"); 
     
    457457    // OME-XML (and not some other XML variant) 
    458458 
    459     String comment = (String) metadata.get("Comment"); 
     459    String comment = (String) getMeta("Comment"); 
    460460    if (comment != null && comment.indexOf("ome.xsd") >= 0) { 
    461461      metadata.remove("Comment"); 
  • trunk/loci/formats/in/ZeissLSMReader.java

    r2117 r2131  
    679679 
    680680    try { 
    681       Float pixX = new Float(metadata.get("VoxelSizeX").toString()); 
    682       Float pixY = new Float(metadata.get("VoxelSizeY").toString()); 
    683       Float pixZ = new Float(metadata.get("VoxelSizeZ").toString()); 
     681      Float pixX = new Float(getMeta("VoxelSizeX").toString()); 
     682      Float pixY = new Float(getMeta("VoxelSizeY").toString()); 
     683      Float pixZ = new Float(getMeta("VoxelSizeZ").toString()); 
    684684 
    685685      MetadataStore store = getMetadataStore(currentId); 
  • trunk/loci/formats/in/ZeissZVIReader.java

    r2119 r2131  
    383383      nImages = sizeZ[0] * sizeT[0] * getEffectiveSizeC(id); 
    384384 
    385       String s = (String) metadata.get("Acquisition Bit Depth"); 
     385      String s = (String) getMeta("Acquisition Bit Depth"); 
    386386      if (s != null && s.trim().length() > 0) { 
    387387        validBits = new int[nChannels]; 
     
    393393      else validBits = null; 
    394394 
    395       Object check = metadata.get("Image Channel Index"); 
     395      Object check = getMeta("Image Channel Index"); 
    396396      if (check != null && !check.toString().trim().equals("")) { 
    397397        int[] dims = {sizeZ[0], sizeC[0], sizeT[0]}; 
     
    420420        } 
    421421      } 
    422       else if (metadata.get("MultiChannel Color") != null) { 
     422      else if (getMeta("MultiChannel Color") != null) { 
    423423        currentOrder[0] = (zSize > tSize) ? "XYCZT" : "XYCTZ"; 
    424424      } 
     
    446446  private void initMetadata() throws FormatException, IOException { 
    447447    MetadataStore store = getMetadataStore(currentId); 
    448     store.setImage((String) metadata.get("File Name"), null, null, null); 
     448    store.setImage((String) getMeta("File Name"), null, null, null); 
    449449 
    450450    if (bpp == 1 || bpp == 3) pixelType[0] = FormatReader.UINT8; 
     
    463463 
    464464    store.setDimensions( 
    465       new Float((String) metadata.get("Scale Factor for X")), 
    466       new Float((String) metadata.get("Scale Factor for Y")), 
    467       new Float((String) metadata.get("Scale Factor for Z")), 
     465      new Float((String) getMeta("Scale Factor for X")), 
     466      new Float((String) getMeta("Scale Factor for Y")), 
     467      new Float((String) getMeta("Scale Factor for Z")), 
    468468      null, null, null); 
    469469  } 
     
    881881    switch (tagID) { 
    882882      case 222: 
    883         metadata.put("Compression", data); 
     883        addMeta("Compression", data); 
    884884        break; 
    885885      case 258: 
    886         metadata.put("BlackValue", data); 
     886        addMeta("BlackValue", data); 
    887887        break; 
    888888      case 259: 
    889         metadata.put("WhiteValue", data); 
     889        addMeta("WhiteValue", data); 
    890890        break; 
    891891      case 260: 
    892         metadata.put("ImageDataMappingAutoRange", data); 
     892        addMeta("ImageDataMappingAutoRange", data); 
    893893        break; 
    894894      case 261: 
    895         metadata.put("Thumbnail", data); 
     895        addMeta("Thumbnail", data); 
    896896        break; 
    897897      case 262: 
    898         metadata.put("GammaValue", data); 
     898        addMeta("GammaValue", data); 
    899899        break; 
    900900      case 264: 
    901         metadata.put("ImageOverExposure", data); 
     901        addMeta("ImageOverExposure", data); 
    902902        break; 
    903903      case 265: 
    904         metadata.put("ImageRelativeTime1", data); 
     904        addMeta("ImageRelativeTime1", data); 
    905905        break; 
    906906      case 266: 
    907         metadata.put("ImageRelativeTime2", data); 
     907        addMeta("ImageRelativeTime2", data); 
    908908        break; 
    909909      case 267: 
    910         metadata.put("ImageRelativeTime3", data); 
     910        addMeta("ImageRelativeTime3", data); 
    911911        break; 
    912912      case 268: 
    913         metadata.put("ImageRelativeTime4", data); 
     913        addMeta("ImageRelativeTime4", data); 
    914914        break; 
    915915      case 333: 
    916         metadata.put("RelFocusPosition1", data); 
     916        addMeta("RelFocusPosition1", data); 
    917917        break; 
    918918      case 334: 
    919         metadata.put("RelFocusPosition2", data); 
     919        addMeta("RelFocusPosition2", data); 
    920920        break; 
    921921      case 513: 
    922         metadata.put("tagID_513", data); 
     922        addMeta("tagID_513", data); 
    923923        break; 
    924924      case 515: 
    925         metadata.put("ImageWidth", data); 
     925        addMeta("ImageWidth", data); 
    926926        break; 
    927927      case 516: 
    928         metadata.put("ImageHeight", data); 
     928        addMeta("ImageHeight", data); 
    929929        break; 
    930930      case 517: 
    931         metadata.put("tagID_517", data); 
     931        addMeta("tagID_517", data); 
    932932        break; 
    933933      case 518: 
    934         metadata.put("PixelType", data); 
     934        addMeta("PixelType", data); 
    935935        break; 
    936936      case 519: 
    937         metadata.put("NumberOfRawImages", data); 
     937        addMeta("NumberOfRawImages", data); 
    938938        break; 
    939939      case 520: 
    940         metadata.put("ImageSize", data); 
     940        addMeta("ImageSize", data); 
    941941        break; 
    942942      case 523: 
    943         metadata.put("Acquisition pause annotation", data); 
     943        addMeta("Acquisition pause annotation", data); 
    944944        break; 
    945945      case 530: 
    946         metadata.put("Document Subtype", data); 
     946        addMeta("Document Subtype", data); 
    947947        break; 
    948948      case 531: 
    949         metadata.put("Acquisition Bit Depth", data); 
     949        addMeta("Acquisition Bit Depth", data); 
    950950        break; 
    951951      case 532: 
    952         metadata.put("Image Memory Usage (RAM)", data); 
     952        addMeta("Image Memory Usage (RAM)", data); 
    953953        break; 
    954954      case 534: 
    955         metadata.put("Z-Stack single representative", data); 
     955        addMeta("Z-Stack single representative", data); 
    956956        break; 
    957957      case 769: 
    958         metadata.put("Scale Factor for X", data); 
     958        addMeta("Scale Factor for X", data); 
    959959        break; 
    960960      case 770: 
    961         metadata.put("Scale Unit for X", data); 
     961        addMeta("Scale Unit for X", data); 
    962962        break; 
    963963      case 771: 
    964         metadata.put("Scale Width", data); 
     964        addMeta("Scale Width", data); 
    965965        break; 
    966966      case 772: 
    967         metadata.put("Scale Factor for Y", data); 
     967        addMeta("Scale Factor for Y", data); 
    968968        break; 
    969969      case 773: 
    970         metadata.put("Scale Unit for Y", data); 
     970        addMeta("Scale Unit for Y", data); 
    971971        break; 
    972972      case 774: 
    973         metadata.put("Scale Height", data); 
     973        addMeta("Scale Height", data); 
    974974        break; 
    975975      case 775: 
    976         metadata.put("Scale Factor for Z", data); 
     976        addMeta("Scale Factor for Z", data); 
    977977        break; 
    978978      case 776: 
    979         metadata.put("Scale Unit for Z", data); 
     979        addMeta("Scale Unit for Z", data); 
    980980        break; 
    981981      case 777: 
    982         metadata.put("Scale Depth", data); 
     982        addMeta("Scale Depth", data); 
    983983        break; 
    984984      case 778: 
    985         metadata.put("Scaling Parent", data); 
     985        addMeta("Scaling Parent", data); 
    986986        break; 
    987987      case 1001: 
    988         metadata.put("Date", data); 
     988        addMeta("Date", data); 
    989989        break; 
    990990      case 1002: 
    991         metadata.put("code", data); 
     991        addMeta("code", data); 
    992992        break; 
    993993      case 1003: 
    994         metadata.put("Source", data); 
     994        addMeta("Source", data); 
    995995        break; 
    996996      case 1004: 
    997         metadata.put("Message", data); 
     997        addMeta("Message", data); 
    998998        break; 
    999999      case 1025: 
    1000         metadata.put("Acquisition Date", data); 
     1000        addMeta("Acquisition Date", data); 
    10011001        break; 
    10021002      case 1026: 
    1003         metadata.put("8-bit acquisition", data); 
     1003        addMeta("8-bit acquisition", data); 
    10041004        break; 
    10051005      case 1027: 
    1006         metadata.put("Camera Bit Depth", data); 
     1006        addMeta("Camera Bit Depth", data); 
    10071007        break; 
    10081008      case 1029: 
    1009         metadata.put("MonoReferenceLow", data); 
     1009        addMeta("MonoReferenceLow", data); 
    10101010        break; 
    10111011      case 1030: 
    1012         metadata.put("MonoReferenceHigh", data); 
     1012        addMeta("MonoReferenceHigh", data); 
    10131013        break; 
    10141014      case 1031: 
    1015         metadata.put("RedReferenceLow", data); 
     1015        addMeta("RedReferenceLow", data); 
    10161016        break; 
    10171017      case 1032: 
    1018         metadata.put("RedReferenceHigh", data); 
     1018        addMeta("RedReferenceHigh", data); 
    10191019        break; 
    10201020      case 1033: 
    1021         metadata.put("GreenReferenceLow", data); 
     1021        addMeta("GreenReferenceLow", data); 
    10221022        break; 
    10231023      case 1034: 
    1024         metadata.put("GreenReferenceHigh", data); 
     1024        addMeta("GreenReferenceHigh", data); 
    10251025        break; 
    10261026      case 1035: 
    1027         metadata.put("BlueReferenceLow", data); 
     1027        addMeta("BlueReferenceLow", data); 
    10281028        break; 
    10291029      case 1036: 
    1030         metadata.put("BlueReferenceHigh", data); 
     1030        addMeta("BlueReferenceHigh", data); 
    10311031        break; 
    10321032      case 1041: 
    1033         metadata.put("FrameGrabber Name", data); 
     1033        addMeta("FrameGrabber Name", data); 
    10341034        break; 
    10351035      case 1042: 
    1036         metadata.put("Camera", data); 
     1036        addMeta("Camera", data); 
    10371037        break; 
    10381038      case 1044: 
    1039         metadata.put("CameraTriggerSignalType", data); 
     1039        addMeta("CameraTriggerSignalType", data); 
    10401040        break; 
    10411041      case 1045: 
    1042         metadata.put("CameraTriggerEnable", data); 
     1042        addMeta("CameraTriggerEnable", data); 
    10431043        break; 
    10441044      case 1046: 
    1045         metadata.put("GrabberTimeout", data); 
     1045        addMeta("GrabberTimeout", data); 
    10461046        break; 
    10471047      case 1281: 
    1048         metadata.put("MultiChannelEnabled", data); 
     1048        addMeta("MultiChannelEnabled", data); 
    10491049        break; 
    10501050      case 1282: 
    1051         metadata.put("MultiChannel Color", data); 
     1051        addMeta("MultiChannel Color", data); 
    10521052        break; 
    10531053      case 1283: 
    1054         metadata.put("MultiChannel Weight", data); 
     1054        addMeta("MultiChannel Weight", data); 
    10551055        break; 
    10561056      case 1284: 
    1057         metadata.put("Channel Name", data); 
     1057        addMeta("Channel Name", data); 
    10581058        break; 
    10591059      case 1536: 
    1060         metadata.put("DocumentInformationGroup", data); 
     1060        addMeta("DocumentInformationGroup", data); 
    10611061        break; 
    10621062      case 1537: 
    1063         metadata.put("Title", data); 
     1063        addMeta("Title", data); 
    10641064        break; 
    10651065      case 1538: 
    1066         metadata.put("Author", data); 
     1066        addMeta("Author", data); 
    10671067        break; 
    10681068      case 1539: 
    1069         metadata.put("Keywords", data); 
     1069        addMeta("Keywords", data); 
    10701070        break; 
    10711071      case 1540: 
    1072         metadata.put("Comments", data); 
     1072        addMeta("Comments", data); 
    10731073        break; 
    10741074      case 1541: 
    1075         metadata.put("SampleID", data); 
     1075        addMeta("SampleID", data); 
    10761076        break; 
    10771077      case 1542: 
    1078         metadata.put("Subject", data); 
     1078        addMeta("Subject", data); 
    10791079        break; 
    10801080      case 1543: 
    1081         metadata.put("RevisionNumber", data); 
     1081        addMeta("RevisionNumber", data); 
    10821082        break; 
    10831083      case 1544: 
    1084         metadata.put("Save Folder", data); 
     1084        addMeta("Save Folder", data); 
    10851085        break; 
    10861086      case 1545: 
    1087         metadata.put("FileLink", data); 
     1087        addMeta("FileLink", data); 
    10881088        break; 
    10891089      case 1546: 
    1090         metadata.put("Document Type", data); 
     1090        addMeta("Document Type", data); 
    10911091        break; 
    10921092      case 1547: 
    1093         metadata.put("Storage Media", data); 
     1093        addMeta("Storage Media", data); 
    10941094        break; 
    10951095      case 1548: 
    1096         metadata.put("File ID", data); 
     1096        addMeta("File ID", data); 
    10971097        break; 
    10981098      case 1549: 
    1099         metadata.put("Reference", data); 
     1099        addMeta("Reference", data); 
    11001100        break; 
    11011101      case 1550: 
    1102         metadata.put("File Date", data); 
     1102        addMeta("File Date", data); 
    11031103        break; 
    11041104      case 1551: 
    1105         metadata.put("File Size", data); 
     1105        addMeta("File Size", data); 
    11061106        break; 
    11071107      case 1553: 
    1108         metadata.put("Filename", data); 
     1108        addMeta("Filename", data); 
    11091109        break; 
    11101110      case 1792: 
    1111         metadata.put("ProjectGroup", data); 
     1111        addMeta("ProjectGroup", data); 
    11121112        break; 
    11131113      case 1793: 
    1114         metadata.put("Acquisition Date", data); 
     1114        addMeta("Acquisition Date", data); 
    11151115        break; 
    11161116      case 1794: 
    1117         metadata.put("Last modified by", data); 
     1117        addMeta("Last modified by", data); 
    11181118        break; 
    11191119      case 1795: 
    1120         metadata.put("User company", data); 
     1120        addMeta("User company", data); 
    11211121        break; 
    11221122      case 1796: 
    1123         metadata.put("User company logo", data); 
     1123        addMeta("User company logo", data); 
    11241124        break; 
    11251125      case 1797: 
    1126         metadata.put("Image", data); 
     1126        addMeta("Image", data); 
    11271127        break; 
    11281128      case 1800: 
    1129         metadata.put("User ID", data); 
     1129        addMeta("User ID", data); 
    11301130        break; 
    11311131      case 1801: 
    1132         metadata.put("User Name", data); 
     1132        addMeta("User Name", data); 
    11331133        break; 
    11341134      case 1802: 
    1135         metadata.put("User City", data); 
     1135        addMeta("User City", data); 
    11361136        break; 
    11371137      case 1803: 
    1138         metadata.put("User Address", data); 
     1138        addMeta("User Address", data); 
    11391139        break; 
    11401140      case 1804: 
    1141         metadata.put("User Country", data); 
     1141        addMeta("User Country", data); 
    11421142        break; 
    11431143      case 1805: 
    1144         metadata.put("User Phone", data); 
     1144        addMeta("User Phone", data); 
    11451145        break; 
    11461146      case 1806: 
    1147         metadata.put("User Fax", data); 
     1147        addMeta("User Fax", data); 
    11481148        break; 
    11491149      case 2049: 
    1150         metadata.put("Objective Name", data); 
     1150        addMeta("Objective Name", data); 
    11511151        break; 
    11521152      case 2050: 
    1153         metadata.put("Optovar", data); 
     1153        addMeta("Optovar", data); 
    11541154        break; 
    11551155      case 2051: 
    1156         metadata.put("Reflector", data); 
     1156        addMeta("Reflector", data); 
    11571157        break; 
    11581158      case 2052: 
    1159         metadata.put("Condenser Contrast", data); 
     1159        addMeta("Condenser Contrast", data); 
    11601160        break; 
    11611161      case 2053: 
    1162         metadata.put("Transmitted Light Filter 1", data); 
     1162        addMeta("Transmitted Light Filter 1", data); 
    11631163        break; 
    11641164      case 2054: 
    1165         metadata.put("Transmitted Light Filter 2", data); 
     1165        addMeta("Transmitted Light Filter 2", data); 
    11661166        break; 
    11671167      case 2055: 
    1168         metadata.put("Reflected Light Shutter", data); 
     1168        addMeta("Reflected Light Shutter", data); 
    11691169        break; 
    11701170      case 2056: 
    1171         metadata.put("Condenser Front Lens", data); 
     1171        addMeta("Condenser Front Lens", data); 
    11721172        break; 
    11731173      case 2057: 
    1174         metadata.put("Excitation Filter Name", data); 
     1174        addMeta("Excitation Filter Name", data); 
    11751175        break; 
    11761176      case 2060: 
    1177         metadata.put("Transmitted Light Fieldstop Aperture", data); 
     1177        addMeta("Transmitted Light Fieldstop Aperture", data); 
    11781178        break; 
    11791179      case 2061: 
    1180         metadata.put("Reflected Light Aperture", data); 
     1180        addMeta("Reflected Light Aperture", data); 
    11811181        break; 
    11821182      case 2062: 
    1183         metadata.put("Condenser N.A.", data); 
     1183        addMeta("Condenser N.A.", data); 
    11841184        break; 
    11851185      case 2063: 
    1186         metadata.put("Light Path", data); 
     1186        addMeta("Light Path", data); 
    11871187        break; 
    11881188      case 2064: 
    1189         metadata.put("HalogenLampOn", data); 
     1189        addMeta("HalogenLampOn", data); 
    11901190        break; 
    11911191      case 2065: 
    1192         metadata.put("Halogen Lamp Mode", data); 
     1192        addMeta("Halogen Lamp Mode", data); 
    11931193        break; 
    11941194      case 2066: 
    1195         metadata.put("Halogen Lamp Voltage", data); 
     1195        addMeta("Halogen Lamp Voltage", data); 
    11961196        break; 
    11971197      case 2068: 
    1198         metadata.put("Fluorescence Lamp Level", data); 
     1198        addMeta("Fluorescence Lamp Level", data); 
    11991199        break; 
    12001200      case 2069: 
    1201         metadata.put("Fluorescence Lamp Intensity", data); 
     1201        addMeta("Fluorescence Lamp Intensity", data); 
    12021202        break; 
    12031203      case 2070: 
    1204         metadata.put("LightManagerEnabled", data); 
     1204        addMeta("LightManagerEnabled", data); 
    12051205        break; 
    12061206      case 2071: 
    1207         metadata.put("tag_ID_2071", data); 
     1207        addMeta("tag_ID_2071", data); 
    12081208        break; 
    12091209      case 2072: 
    1210         metadata.put("Focus Position", data); 
     1210        addMeta("Focus Position", data); 
    12111211        break; 
    12121212      case 2073: 
    1213         metadata.put("Stage Position X", data); 
     1213        addMeta("Stage Position X", data); 
    12141214        break; 
    12151215      case 2074: 
    1216         metadata.put("Stage Position Y", data); 
     1216        addMeta("Stage Position Y", data); 
    12171217        break; 
    12181218      case 2075: 
    1219         metadata.put("Microscope Name", data); 
     1219        addMeta("Microscope Name", data); 
    12201220        break; 
    12211221      case 2076: 
    1222         metadata.put("Objective Magnification", data); 
     1222        addMeta("Objective Magnification", data); 
    12231223        break; 
    12241224      case 2077: 
    1225         metadata.put("Objective N.A.", data); 
     1225        addMeta("Objective N.A.", data); 
    12261226        break; 
    12271227      case 2078: 
    1228         metadata.put("MicroscopeIllumination", data); 
     1228        addMeta("MicroscopeIllumination", data); 
    12291229        break; 
    12301230      case 2079: 
    1231         metadata.put("External Shutter 1", data); 
     1231        addMeta("External Shutter 1", data); 
    12321232        break; 
    12331233      case 2080: 
    1234         metadata.put("External Shutter 2", data); 
     1234        addMeta("External Shutter 2", data); 
    12351235        break; 
    12361236      case 2081: 
    1237         metadata.put("External Shutter 3", data); 
     1237        addMeta("External Shutter 3", data); 
    12381238        break; 
    12391239      case 2082: 
    1240         metadata.put("External Filter Wheel 1 Name", data); 
     1240        addMeta("External Filter Wheel 1 Name", data); 
    12411241        break; 
    12421242      case 2083: 
    1243         metadata.put("External Filter Wheel 2 Name", data); 
     1243        addMeta("External Filter Wheel 2 Name", data); 
    12441244        break; 
    12451245      case 2084: 
    1246         metadata.put("Parfocal Correction", data); 
     1246        addMeta("Parfocal Correction", data); 
    12471247        break; 
    12481248      case 2086: 
    1249         metadata.put("External Shutter 4", data); 
     1249        addMeta("External Shutter 4", data); 
    12501250        break; 
    12511251      case 2087: 
    1252         metadata.put("External Shutter 5", data); 
     1252        addMeta("External Shutter 5", data); 
    12531253        break; 
    12541254      case 2088: 
    1255         metadata.put("External Shutter 6", data); 
     1255        addMeta("External Shutter 6", data); 
    12561256        break; 
    12571257      case 2089: 
    1258         metadata.put("External Filter Wheel 3 Name", data); 
     1258        addMeta("External Filter Wheel 3 Name", data); 
    12591259        break; 
    12601260      case 2090: 
    1261         metadata.put("External Filter Wheel 4 Name", data); 
     1261        addMeta("External Filter Wheel 4 Name", data); 
    12621262        break; 
    12631263      case 2103: 
    1264         metadata.put("Objective Turret Position", data); 
     1264        addMeta("Objective Turret Position", data); 
    12651265        break; 
    12661266      case 2104: 
    1267         metadata.put("Objective Contrast Method", data); 
     1267        addMeta("Objective Contrast Method", data); 
    12681268        break; 
    12691269      case 2105: 
    1270         metadata.put("Objective Immersion Type", data); 
     1270        addMeta("Objective Immersion Type", data); 
    12711271        break; 
    12721272      case 2107: 
    1273         metadata.put("Reflector Position", data); 
     1273        addMeta("Reflector Position", data); 
    12741274        break; 
    12751275      case 2109: 
    1276         metadata.put("Transmitted Light Filter 1 Position", data); 
     1276        addMeta("Transmitted Light Filter 1 Position", data); 
    12771277        break; 
    12781278      case 2110: 
    1279         metadata.put("Transmitted Light Filter 2 Position", data); 
     1279        addMeta("Transmitted Light Filter 2 Position", data); 
    12801280        break; 
    12811281      case 2112: 
    1282         metadata.put("Excitation Filter Position", data); 
     1282        addMeta("Excitation Filter Position", data); 
    12831283        break; 
    12841284      case 2113: 
    1285         metadata.put("Lamp Mirror Position", data); 
     1285        addMeta("Lamp Mirror Position", data); 
    12861286        break; 
    12871287      case 2114: 
    1288         metadata.put("External Filter Wheel 1 Position", data); 
     1288        addMeta("External Filter Wheel 1 Position", data); 
    12891289        break; 
    12901290      case 2115: 
    1291         metadata.put("External Filter Wheel 2 Position", data); 
     1291        addMeta("External Filter Wheel 2 Position", data); 
    12921292        break; 
    12931293      case 2116: 
    1294         metadata.put("External Filter Wheel 3 Position", data); 
     1294        addMeta("External Filter Wheel 3 Position", data); 
    12951295        break; 
    12961296      case 2117: 
    1297         metadata.put("External Filter Wheel 4 Position", data); 
     1297        addMeta("External Filter Wheel 4 Position", data); 
    12981298        break; 
    12991299      case 2118: 
    1300         metadata.put("Lightmanager Mode", data); 
     1300        addMeta("Lightmanager Mode", data); 
    13011301        break; 
    13021302      case 2119: 
    1303         metadata.put("Halogen Lamp Calibration", data); 
     1303        addMeta("Halogen Lamp Calibration", data); 
    13041304        break; 
    13051305      case 2120: 
    1306         metadata.put("CondenserNAGoSpeed", data); 
     1306        addMeta("CondenserNAGoSpeed", data); 
    13071307        break; 
    13081308      case 2121: 
    1309         metadata.put("TransmittedLightFieldstopGoSpeed", data); 
     1309        addMeta("TransmittedLightFieldstopGoSpeed", data); 
    13101310        break; 
    13111311      case 2122: 
    1312         metadata.put("OptovarGoSpeed", data); 
     1312        addMeta("OptovarGoSpeed", data); 
    13131313        break; 
    13141314      case 2123: 
    1315         metadata.put("Focus calibrated", data); 
     1315        addMeta("Focus calibrated", data); 
    13161316        break; 
    13171317      case 2124: 
    1318         metadata.put("FocusBasicPosition", data); 
     1318        addMeta("FocusBasicPosition", data); 
    13191319        break; 
    13201320      case 2125: 
    1321         metadata.put("FocusPower", data); 
     1321        addMeta("FocusPower", data); 
    13221322        break; 
    13231323      case 2126: 
    1324         metadata.put("FocusBacklash", data); 
     1324        addMeta("FocusBacklash", data); 
    13251325        break; 
    13261326      case 2127: 
    1327         metadata.put("FocusMeasurementOrigin", data); 
     1327        addMeta("FocusMeasurementOrigin", data); 
    13281328        break; 
    13291329      case 2128: 
    1330         metadata.put("FocusMeasurementDistance", data); 
     1330        addMeta("FocusMeasurementDistance", data); 
    13311331        break; 
    13321332      case 2129: 
    1333         metadata.put("FocusSpeed", data); 
     1333        addMeta("FocusSpeed", data); 
    13341334        break; 
    13351335      case 2130: 
    1336         metadata.put("FocusGoSpeed", data); 
     1336        addMeta("FocusGoSpeed", data); 
    13371337        break; 
    13381338      case 2131: 
    1339         metadata.put("FocusDistance", data); 
     1339        addMeta("FocusDistance", data); 
    13401340        break; 
    13411341      case 2132: 
    1342         metadata.put("FocusInitPosition", data); 
     1342        addMeta("FocusInitPosition", data); 
    13431343        break; 
    13441344      case 2133: 
    1345         metadata.put("Stage calibrated", data); 
     1345        addMeta("Stage calibrated", data); 
    13461346        break; 
    13471347      case 2134: 
    1348         metadata.put("StagePower", data); 
     1348        addMeta("StagePower", data); 
    13491349        break; 
    13501350      case 2135: 
    1351         metadata.put("StageXBacklash", data); 
     1351        addMeta("StageXBacklash", data); 
    13521352        break; 
    13531353      case 2136: 
    1354         metadata.put("StageYBacklash", data); 
     1354        addMeta("StageYBacklash", data); 
    13551355        break; 
    13561356      case 2137: 
    1357         metadata.put("StageSpeedX", data); 
     1357        addMeta("StageSpeedX", data); 
    13581358        break; 
    13591359      case 2138: 
    1360         metadata.put("StageSpeedY", data); 
     1360        addMeta("StageSpeedY", data); 
    13611361        break; 
    13621362      case 2139: 
    1363         metadata.put("StageSpeed", data); 
     1363        addMeta("StageSpeed", data); 
    13641364        break; 
    13651365      case 2140: 
    1366         metadata.put("StageGoSpeedX", data); 
     1366        addMeta("StageGoSpeedX", data); 
    13671367        break; 
    13681368      case 2141: 
    1369         metadata.put("StageGoSpeedY", data); 
     1369        addMeta("StageGoSpeedY", data); 
    13701370        break; 
    13711371      case 2142: 
    1372         metadata.put("StageStepDistanceX", data); 
     1372        addMeta("StageStepDistanceX", data); 
    13731373        break; 
    13741374      case 2143: 
    1375         metadata.put("StageStepDistanceY", data); 
     1375        addMeta("StageStepDistanceY", data); 
    13761376        break; 
    13771377      case 2144: 
    1378         metadata.put("StageInitialisationPositionX", data); 
     1378        addMeta("StageInitialisationPositionX", data); 
    13791379        break; 
    13801380      case 2145: 
    1381         metadata.put("StageInitialisationPositionY", data); 
     1381        addMeta("StageInitialisationPositionY", data); 
    13821382        break; 
    13831383      case 2146: 
    1384         metadata.put("MicroscopeMagnification", data); 
     1384        addMeta("MicroscopeMagnification", data); 
    13851385        break; 
    13861386      case 2147: 
    1387         metadata.put("ReflectorMagnification", data); 
     1387        addMeta("ReflectorMagnification", data); 
    13881388        break; 
    13891389      case 2148: 
    1390         metadata.put("LampMirrorPosition", data); 
     1390        addMeta("LampMirrorPosition", data); 
    13911391        break; 
    13921392      case 2149: 
    1393         metadata.put("FocusDepth", data); 
     1393        addMeta("FocusDepth", data); 
    13941394        break; 
    13951395      case 2150: 
    1396         metadata.put("MicroscopeType", data); 
     1396        addMeta("MicroscopeType", data); 
    13971397        break; 
    13981398      case 2151: 
    1399         metadata.put("Objective Working Distance", data); 
     1399        addMeta("Objective Working Distance", data); 
    14001400        break; 
    14011401      case 2152: 
    1402         metadata.put("ReflectedLightApertureGoSpeed", data); 
     1402        addMeta("ReflectedLightApertureGoSpeed", data); 
    14031403        break; 
    14041404      case 2153: 
    1405         metadata.put("External Shutter", data); 
     1405        addMeta("External Shutter", data); 
    14061406        break; 
    14071407      case 2154: 
    1408         metadata.put("ObjectiveImmersionStop", data); 
     1408        addMeta("ObjectiveImmersionStop", data); 
    14091409        break; 
    14101410      case 2155: 
    1411         metadata.put("Focus Start Speed", data); 
     1411        addMeta("Focus Start Speed", data); 
    14121412        break; 
    14131413      case 2156: 
    1414         metadata.put("Focus Acceleration", data); 
     1414        addMeta("Focus Acceleration", data); 
    14151415        break; 
    14161416      case 2157: 
    1417         metadata.put("ReflectedLightFieldstop", data); 
     1417        addMeta("ReflectedLightFieldstop", data); 
    14181418        break; 
    14191419      case 2158: 
    1420         metadata.put("ReflectedLightFieldstopGoSpeed", data); 
     1420        addMeta("ReflectedLightFieldstopGoSpeed", data); 
    14211421        break; 
    14221422      case 2159: 
    1423         metadata.put("ReflectedLightFilter 1", data); 
     1423        addMeta("ReflectedLightFilter 1", data); 
    14241424        break; 
    14251425      case 2160: 
    1426         metadata.put("ReflectedLightFilter 2", data); 
     1426        addMeta("ReflectedLightFilter 2", data); 
    14271427        break; 
    14281428      case 2161: 
    1429         metadata.put("ReflectedLightFilter1Position", data); 
     1429        addMeta("ReflectedLightFilter1Position", data); 
    14301430        break; 
    14311431      case 2162: 
    1432         metadata.put("ReflectedLightFilter2Position", data); 
     1432        addMeta("ReflectedLightFilter2Position", data); 
    14331433        break; 
    14341434      case 2163: 
    1435         metadata.put("TransmittedLightAttenuator", data); 
     1435        addMeta("TransmittedLightAttenuator", data); 
    14361436        break; 
    14371437      case 2164: 
    1438         metadata.put("ReflectedLightAttenuator", data); 
     1438        addMeta("ReflectedLightAttenuator", data); 
    14391439        break; 
    14401440      case 2165: 
    1441         metadata.put("Transmitted Light Shutter", data); 
     1441        addMeta("Transmitted Light Shutter", data); 
    14421442        break; 
    14431443      case 2166: 
    1444         metadata.put("TransmittedLightAttenuatorGoSpeed", data); 
     1444        addMeta("TransmittedLightAttenuatorGoSpeed", data); 
    14451445        break; 
    14461446      case 2167: 
    1447         metadata.put("ReflectedLightAttenuatorGoSpeed", data); 
     1447        addMeta("ReflectedLightAttenuatorGoSpeed", data); 
    14481448        break; 
    14491449      case 2176: 
    1450         metadata.put("TransmittedLightVirtualFilterPosition", data); 
     1450        addMeta("TransmittedLightVirtualFilterPosition", data); 
    14511451        break; 
    14521452      case 2177: 
    1453         metadata.put("TransmittedLightVirtualFilter", data); 
     1453        addMeta("TransmittedLightVirtualFilter", data); 
    14541454        break; 
    14551455      case 2178: 
    1456         metadata.put("ReflectedLightVirtualFilterPosition", data); 
     1456        addMeta("ReflectedLightVirtualFilterPosition", data); 
    14571457        break; 
    14581458      case 2179: 
    1459         metadata.put("ReflectedLightVirtualFilter", data); 
     1459        addMeta("ReflectedLightVirtualFilter", data); 
    14601460        break; 
    14611461      case 2180: 
    1462         metadata.put("ReflectedLightHalogenLampMode", data); 
     1462        addMeta("ReflectedLightHalogenLampMode", data); 
    14631463        break; 
    14641464      case 2181: 
    1465         metadata.put("ReflectedLightHalogenLampVoltage", data); 
     1465        addMeta("ReflectedLightHalogenLampVoltage", data); 
    14661466        break; 
    14671467      case 2182: 
    1468         metadata.put("ReflectedLightHalogenLampColorTemperature", data); 
     1468        addMeta("ReflectedLightHalogenLampColorTemperature", data); 
    14691469        break; 
    14701470      case 2183: 
    1471         metadata.put("ContrastManagerMode", data); 
     1471        addMeta("ContrastManagerMode", data); 
    14721472        break; 
    14731473      case 2184: 
    1474         metadata.put("Dazzle Protection Active", data); 
     1474        addMeta("Dazzle Protection Active", data); 
    14751475        break; 
    14761476      case 2195: 
    1477         metadata.put("Zoom", data); 
     1477        addMeta("Zoom", data); 
    14781478        break; 
    14791479      case 2196: 
    1480         metadata.put("ZoomGoSpeed", data); 
     1480        addMeta("ZoomGoSpeed", data); 
    14811481        break; 
    14821482      case 2197: 
    1483         metadata.put("LightZoom", data); 
     1483        addMeta("LightZoom", data); 
    14841484        break; 
    14851485      case 2198: 
    1486         metadata.put("LightZoomGoSpeed", data); 
     1486        addMeta("LightZoomGoSpeed", data); 
    14871487        break; 
    14881488      case 2199: 
    1489         metadata.put("LightZoomCoupled", data); 
     1489        addMeta("LightZoomCoupled", data); 
    14901490        break; 
    14911491      case 2200: 
    1492         metadata.put("TransmittedLightHalogenLampMode", data); 
     1492        addMeta("TransmittedLightHalogenLampMode", data); 
    14931493        break; 
    14941494      case 2201: 
    1495         metadata.put("TransmittedLightHalogenLampVoltage", data); 
     1495        addMeta("TransmittedLightHalogenLampVoltage", data); 
    14961496        break; 
    14971497      case 2202: 
    1498         metadata.put("TransmittedLightHalogenLampColorTemperature", data); 
     1498        addMeta("TransmittedLightHalogenLampColorTemperature", data); 
    14991499        break; 
    15001500      case 2203: 
    1501         metadata.put("Reflected Coldlight Mode", data); 
     1501        addMeta("Reflected Coldlight Mode", data); 
    15021502        break; 
    15031503      case 2204: 
    1504         metadata.put("Reflected Coldlight Intensity", data); 
     1504        addMeta("Reflected Coldlight Intensity", data); 
    15051505        break; 
    15061506      case 2205: 
    1507         metadata.put("Reflected Coldlight Color Temperature", data); 
     1507        addMeta("Reflected Coldlight Color Temperature", data); 
    15081508        break; 
    15091509      case 2206: 
    1510         metadata.put("Transmitted Coldlight Mode", data); 
     1510        addMeta("Transmitted Coldlight Mode", data); 
    15111511        break; 
    15121512      case 2207: 
    1513         metadata.put("Transmitted Coldlight Intensity", data); 
     1513        addMeta("Transmitted Coldlight Intensity", data); 
    15141514        break; 
    15151515      case 2208: 
    1516         metadata.put("Transmitted Coldlight Color Temperature", data); 
     1516        addMeta("Transmitted Coldlight Color Temperature", data); 
    15171517        break; 
    15181518      case 2209: 
    1519         metadata.put("Infinityspace Portchanger Position", data); 
     1519        addMeta("Infinityspace Portchanger Position", data); 
    15201520        break; 
    15211521      case 2210: 
    1522         metadata.put("Beamsplitter Infinity Space", data); 
     1522        addMeta("Beamsplitter Infinity Space", data); 
    15231523        break; 
    15241524      case 2211: 
    1525         metadata.put("TwoTv VisCamChanger Position", data); 
     1525        addMeta("TwoTv VisCamChanger Position", data); 
    15261526        break; 
    15271527      case 2212: 
    1528         metadata.put("Beamsplitter Ocular", data); 
     1528        addMeta("Beamsplitter Ocular", data); 
    15291529        break; 
    15301530      case 2213: 
    1531         metadata.put("TwoTv CamerasChanger Position", data); 
     1531        addMeta("TwoTv CamerasChanger Position", data); 
    15321532        break; 
    15331533      case 2214: 
    1534         metadata.put("Beamsplitter Cameras", data); 
     1534        addMeta("Beamsplitter Cameras", data); 
    15351535        break; 
    15361536      case 2215: 
    1537         metadata.put("Ocular Shutter", data); 
     1537        addMeta("Ocular Shutter", data); 
    15381538        break; 
    15391539      case 2216: 
    1540         metadata.put("TwoTv CamerasChangerCube", data); 
     1540        addMeta("TwoTv CamerasChangerCube", data); 
    15411541        break; 
    15421542      case 2218: 
    1543         metadata.put("Ocular Magnification", data); 
     1543        addMeta("Ocular Magnification", data); 
    15441544        break; 
    15451545      case 2219: 
    1546         metadata.put("Camera Adapter Magnification", data); 
     1546        addMeta("Camera Adapter Magnification", data); 
    15471547        break; 
    15481548      case 2220: 
    1549         metadata.put("Microscope Port", data); 
     1549        addMeta("Microscope Port", data); 
    15501550        break; 
    15511551      case 2221: 
    1552         metadata.put("Ocular Total Magnification", data); 
     1552        addMeta("Ocular Total Magnification", data); 
    15531553        break; 
    15541554      case 2222: 
    1555         metadata.put("Field of View", data); 
     1555        addMeta("Field of View", data); 
    15561556        break; 
    15571557      case 2223: 
    1558         metadata.put("Ocular", data); 
     1558        addMeta("Ocular", data); 
    15591559        break; 
    15601560      case 2224: 
    1561         metadata.put("CameraAdapter", data); 
     1561        addMeta("CameraAdapter", data); 
    15621562        break; 
    15631563      case 2225: 
    1564         metadata.put("StageJoystickEnabled", data); 
     1564        addMeta("StageJoystickEnabled", data); 
    15651565        break; 
    15661566      case 2226: 
    1567         metadata.put("ContrastManager Contrast Method", data); 
     1567        addMeta("ContrastManager Contrast Method", data); 
    15681568        break; 
    15691569      case 2229: 
    1570         metadata.put("CamerasChanger Beamsplitter Type", data); 
     1570        addMeta("CamerasChanger Beamsplitter Type", data); 
    15711571        break; 
    15721572      case 2235: 
    1573         metadata.put("Rearport Slider Position", data); 
     1573        addMeta("Rearport Slider Position", data); 
    15741574        break; 
    15751575      case 2236: 
    1576         metadata.put("Rearport Source", data); 
     1576        addMeta("Rearport Source", data); 
    15771577        break; 
    15781578      case 2237: 
    1579         metadata.put("Beamsplitter Type Infinity Space", data); 
     1579        addMeta("Beamsplitter Type Infinity Space", data); 
    15801580        break; 
    15811581      case 2238: 
    1582         metadata.put("Fluorescence Attenuator", data); 
     1582        addMeta("Fluorescence Attenuator", data); 
    15831583        break; 
    15841584      case 2239: 
    1585         metadata.put("Fluorescence Attenuator Position", data); 
     1585        addMeta("Fluorescence Attenuator Position", data); 
    15861586        break; 
    15871587      case 2261: 
    1588         metadata.put("Objective ID", data); 
     1588        addMeta("Objective ID", data); 
    15891589        break; 
    15901590      case 2262: 
    1591         metadata.put("Reflector ID", data); 
     1591        addMeta("Reflector ID", data); 
    15921592        break; 
    15931593      case 2307: 
    1594         metadata.put("Camera Framestart Left", data); 
     1594        addMeta("Camera Framestart Left", data); 
    15951595        break; 
    15961596      case 2308: 
    1597         metadata.put("Camera Framestart Top", data); 
     1597        addMeta("Camera Framestart Top", data); 
    15981598        break; 
    15991599      case 2309: 
    1600         metadata.put("Camera Frame Width", data); 
     1600        addMeta("Camera Frame Width", data); 
    16011601        break; 
    16021602      case 2310: 
    1603         metadata.put("Camera Frame Height", data); 
     1603        addMeta("Camera Frame Height", data); 
    16041604        break; 
    16051605      case 2311: 
    1606         metadata.put("Camera Binning", data); 
     1606        addMeta("Camera Binning", data); 
    16071607        break; 
    16081608      case 2312: 
    1609         metadata.put("CameraFrameFull", data); 
     1609        addMeta("CameraFrameFull", data); 
    16101610        break; 
    16111611      case 2313: 
    1612         metadata.put("CameraFramePixelDistance", data); 
     1612        addMeta("CameraFramePixelDistance", data); 
    16131613        break; 
    16141614      case 2318: 
    1615         metadata.put("DataFormatUseScaling", data); 
     1615        addMeta("DataFormatUseScaling", data); 
    16161616        break; 
    16171617      case 2319: 
    1618         metadata.put("CameraFrameImageOrientation", data); 
     1618        addMeta("CameraFrameImageOrientation", data); 
    16191619        break; 
    16201620      case 2320: 
    1621         metadata.put("VideoMonochromeSignalType", data); 
     1621        addMeta("VideoMonochromeSignalType", data); 
    16221622        break; 
    16231623      case 2321: 
    1624         metadata.put("VideoColorSignalType", data); 
     1624        addMeta("VideoColorSignalType", data); 
    16251625        break; 
    16261626      case 2322: 
    1627         metadata.put("MeteorChannelInput", data); 
     1627        addMeta("MeteorChannelInput", data); 
    16281628        break; 
    16291629      case 2323: 
    1630         metadata.put("MeteorChannelSync", data); 
     1630        addMeta("MeteorChannelSync", data); 
    16311631        break; 
    16321632      case 2324: 
    1633         metadata.put("WhiteBalanceEnabled", data); 
     1633        addMeta("WhiteBalanceEnabled", data); 
    16341634        break; 
    16351635      case 2325: 
    1636         metadata.put("CameraWhiteBalanceRed", data); 
     1636        addMeta("CameraWhiteBalanceRed", data); 
    16371637        break; 
    16381638      case 2326: 
    1639         metadata.put("CameraWhiteBalanceGreen", data); 
     1639        addMeta("CameraWhiteBalanceGreen", data); 
    16401640        break; 
    16411641      case 2327: 
    1642         metadata.put("CameraWhiteBalanceBlue", data); 
     1642        addMeta("CameraWhiteBalanceBlue", data); 
    16431643        break; 
    16441644      case 2331: 
    1645         metadata.put("CameraFrameScalingFactor", data); 
     1645        addMeta("CameraFrameScalingFactor", data); 
    16461646        break; 
    16471647      case 2562: 
    1648         metadata.put("Meteor Camera Type", data); 
     1648        addMeta("Meteor Camera Type", data); 
    16491649        break; 
    16501650      case 2564: 
    1651         metadata.put("Exposure Time [ms]", data); 
     1651        addMeta("Exposure Time [ms]", data); 
    16521652        break; 
    16531653      case 2568: 
    1654         metadata.put("CameraExposureTimeAutoCalculate", data); 
     1654        addMeta("CameraExposureTimeAutoCalculate", data); 
    16551655        break; 
    16561656      case 2569: 
    1657         metadata.put("Meteor Gain Value", data); 
     1657        addMeta("Meteor Gain Value", data); 
    16581658        break; 
    16591659      case 2571: 
    1660         metadata.put("Meteor Gain Automatic", data); 
     1660        addMeta("Meteor Gain Automatic", data); 
    16611661        break; 
    16621662      case 2572: 
    1663         metadata.put("MeteorAdjustHue", data); 
     1663        addMeta("MeteorAdjustHue", data); 
    16641664        break; 
    16651665      case 2573: 
    1666         metadata.put("MeteorAdjustSaturation", data); 
     1666        addMeta("MeteorAdjustSaturation", data); 
    16671667        break; 
    16681668      case 2574: 
    1669         metadata.put("MeteorAdjustRedLow", data); 
     1669        addMeta("MeteorAdjustRedLow", data); 
    16701670        break; 
    16711671      case 2575: 
    1672         metadata.put("MeteorAdjustGreenLow", data); 
     1672        addMeta("MeteorAdjustGreenLow", data); 
    16731673        break; 
    16741674      case 2576: 
    1675         metadata.put("Meteor Blue Low", data); 
     1675        addMeta("Meteor Blue Low", data); 
    16761676        break; 
    16771677      case 2577: 
    1678         metadata.put("MeteorAdjustRedHigh", data); 
     1678        addMeta("MeteorAdjustRedHigh", data); 
    16791679        break; 
    16801680      case 2578: 
    1681         metadata.put("MeteorAdjustGreenHigh", data); 
     1681        addMeta("MeteorAdjustGreenHigh", data); 
    16821682        break; 
    16831683      case 2579: 
    1684         metadata.put("MeteorBlue High", data); 
     1684        addMeta("MeteorBlue High", data); 
    16851685        break; 
    16861686      case 2582: 
    1687         metadata.put("CameraExposureTimeCalculationControl", data); 
     1687        addMeta("CameraExposureTimeCalculationControl", data); 
    16881688        break; 
    16891689      case 2585: 
    1690         metadata.put("AxioCamFadingCorrectionEnable", data); 
     1690        addMeta("AxioCamFadingCorrectionEnable", data); 
    16911691        break; 
    16921692      case 2587: 
    1693         metadata.put("CameraLiveImage", data); 
     1693        addMeta("CameraLiveImage", data); 
    16941694        break; 
    16951695      case 2588: 
    1696         metadata.put("CameraLiveEnabled", data); 
     1696        addMeta("CameraLiveEnabled", data); 
    16971697        break; 
    16981698      case 2589: 
    1699         metadata.put("LiveImageSyncObjectName", data); 
     1699        addMeta("LiveImageSyncObjectName", data); 
    17001700        break; 
    17011701      case 2590: 
    1702         metadata.put("CameraLiveSpeed", data); 
     1702        addMeta("CameraLiveSpeed", data); 
    17031703        break; 
    17041704      case 2591: 
    1705         metadata.put("CameraImage", data); 
     1705        addMeta("CameraImage", data); 
    17061706        break; 
    17071707      case 2592: 
    1708         metadata.put("CameraImageWidth", data); 
     1708        addMeta("CameraImageWidth", data); 
    17091709        break; 
    17101710      case 2593: 
    1711         metadata.put("CameraImageHeight", data); 
     1711        addMeta("CameraImageHeight", data); 
    17121712        break; 
    17131713      case 2594: 
    1714         metadata.put("CameraImagePixelType", data); 
     1714        addMeta("CameraImagePixelType", data); 
    17151715        break; 
    17161716      case 2595: 
    1717         metadata.put("CameraImageShMemoryName", data); 
     1717        addMeta("CameraImageShMemoryName", data); 
    17181718        break; 
    17191719      case 2596: 
    1720         metadata.put("CameraLiveImageWidth", data); 
     1720        addMeta("CameraLiveImageWidth", data); 
    17211721        break; 
    17221722      case 2597: 
    1723         metadata.put("CameraLiveImageHeight", data); 
     1723        addMeta("CameraLiveImageHeight", data); 
    17241724        break; 
    17251725      case 2598: 
    1726         metadata.put("CameraLiveImagePixelType", data); 
     1726        addMeta("CameraLiveImagePixelType", data); 
    17271727        break; 
    17281728      case 2599: 
    1729         metadata.put("CameraLiveImageShMemoryName", data); 
     1729        addMeta("CameraLiveImageShMemoryName", data); 
    17301730        break; 
    17311731      case 2600: 
    1732         metadata.put("CameraLiveMaximumSpeed", data); 
     1732        addMeta("CameraLiveMaximumSpeed", data); 
    17331733        break; 
    17341734      case 2601: 
    1735         metadata.put("CameraLiveBinning", data); 
     1735        addMeta("CameraLiveBinning", data); 
    17361736        break; 
    17371737      case 2602: 
    1738         metadata.put("CameraLiveGainValue", data); 
     1738        addMeta("CameraLiveGainValue", data); 
    17391739        break; 
    17401740      case 2603: 
    1741         metadata.put("CameraLiveExposureTimeValue", data); 
     1741        addMeta("CameraLiveExposureTimeValue", data); 
    17421742        break; 
    17431743      case 2604: 
    1744         metadata.put("CameraLiveScalingFactor", data); 
     1744        addMeta("CameraLiveScalingFactor", data); 
    17451745        break; 
    17461746      case 2819: 
    1747         metadata.put("Image Index Z", data); 
     1747        addMeta("Image Index Z", data); 
    17481748        break; 
    17491749      case 2820: 
    1750         metadata.put("Image Channel Index", data); 
     1750        addMeta("Image Channel Index", data); 
    17511751        break; 
    17521752      case 2821: 
    1753         metadata.put("Image Index T", data); 
     1753        addMeta("Image Index T", data); 
    17541754        break; 
    17551755      case 2822: 
    1756         metadata.put("ImageTile Index", data); 
     1756        addMeta("ImageTile Index", data); 
    17571757        break; 
    17581758      case 2823: 
    1759         metadata.put("Image acquisition Index", data); 
     1759        addMeta("Image acquisition Index", data); 
    17601760        break; 
    17611761      case 2827: 
    1762         metadata.put("Image IndexS", data); 
     1762        addMeta("Image IndexS", data); 
    17631763        break; 
    17641764      case 2841: 
    1765         metadata.put("Original Stage Position X", data); 
     1765        addMeta("Original Stage Position X", data); 
    17661766        break; 
    17671767      case 2842: 
    1768         metadata.put("Original Stage Position Y", data); 
     1768        addMeta("Original Stage Position Y", data); 
    17691769        break; 
    17701770      case 3088: 
    1771         metadata.put("LayerDrawFlags", data); 
     1771        addMeta("LayerDrawFlags", data); 
    17721772        break; 
    17731773      case 3334: 
    1774         metadata.put("RemainingTime", data); 
     1774        addMeta("RemainingTime", data); 
    17751775        break; 
    17761776      case 3585: 
    1777         metadata.put("User Field 1", data); 
     1777        addMeta("User Field 1", data); 
    17781778        break; 
    17791779      case 3586: 
    1780         metadata.put("User Field 2", data); 
     1780        addMeta("User Field 2", data); 
    17811781        break; 
    17821782      case 3587: 
    1783         metadata.put("User Field 3", data); 
     1783        addMeta("User Field 3", data); 
    17841784        break; 
    17851785      case 3588: 
    1786         metadata.put("User Field 4", data); 
     1786        addMeta("User Field 4", data); 
    17871787        break; 
    17881788      case 3589: 
    1789         metadata.put("User Field 5", data); 
     1789        addMeta("User Field 5", data); 
    17901790        break; 
    17911791      case 3590: 
    1792         metadata.put("User Field 6", data); 
     1792        addMeta("User Field 6", data); 
    17931793        break; 
    17941794      case 3591: 
    1795         metadata.put("User Field 7", data); 
     1795        addMeta("User Field 7", data); 
    17961796        break; 
    17971797      case 3592: 
    1798         metadata.put("User Field 8", data); 
     1798        addMeta("User Field 8", data); 
    17991799        break; 
    18001800      case 3593: 
    1801         metadata.put("User Field 9", data); 
     1801        addMeta("User Field 9", data); 
    18021802        break; 
    18031803      case 3594: 
    1804         metadata.put("User Field 10", data); 
     1804        addMeta("User Field 10", data); 
    18051805        break; 
    18061806      case 3840: 
    1807         metadata.put("ID", data); 
     1807        addMeta("ID", data); 
    18081808        break; 
    18091809      case 3841: 
    1810         metadata.put("Name", data); 
     1810        addMeta("Name", data); 
    18111811        break; 
    18121812      case 3842: 
    1813         metadata.put("Value", data); 
     1813        addMeta("Value", data); 
    18141814        break; 
    18151815      case 5501: 
    1816         metadata.put("PvCamClockingMode", data); 
     1816        addMeta("PvCamClockingMode", data); 
    18171817        break; 
    18181818      case 8193: 
    1819         metadata.put("Autofocus Status Report", data); 
     1819        addMeta("Autofocus Status Report", data); 
    18201820        break; 
    18211821      case 8194: 
    1822         metadata.put("Autofocus Position", data); 
     1822        addMeta("Autofocus Position", data); 
    18231823        break; 
    18241824      case 8195: 
    1825         metadata.put("Autofocus Position Offset", data); 
     1825        addMeta("Autofocus Position Offset", data); 
    18261826        break; 
    18271827      case 8196: 
    1828         metadata.put("Autofocus Empty Field Threshold", data); 
     1828        addMeta("Autofocus Empty Field Threshold", data); 
    18291829        break; 
    18301830      case 8197: 
    1831         metadata.put("Autofocus Calibration Name", data); 
     1831        addMeta("Autofocus Calibration Name", data); 
    18321832        break; 
    18331833      case 8198: 
    1834         metadata.put("Autofocus Current Calibration Item", data); 
     1834        addMeta("Autofocus Current Calibration Item", data); 
    18351835        break; 
    18361836      case 20478: 
    1837         metadata.put("tag_ID_20478", data); 
     1837        addMeta("tag_ID_20478", data); 
    18381838        break; 
    18391839      case 65537: 
    1840         metadata.put("CameraFrameFullWidth", data); 
     1840        addMeta("CameraFrameFullWidth", data); 
    18411841        break; 
    18421842      case 65538: 
    1843         metadata.put("CameraFrameFullHeight", data); 
     1843        addMeta("CameraFrameFullHeight", data); 
    18441844        break; 
    18451845      case 65541: 
    1846         metadata.put("AxioCam Shutter Signal", data); 
     1846        addMeta("AxioCam Shutter Signal", data); 
    18471847        break; 
    18481848      case 65542: 
    1849         metadata.put("AxioCam Delay Time", data); 
     1849        addMeta("AxioCam Delay Time", data); 
    18501850        break; 
    18511851      case 65543: 
    1852         metadata.put("AxioCam Shutter Control", data); 
     1852        addMeta("AxioCam Shutter Control", data); 
    18531853        break; 
    18541854      case 65544: 
    1855         metadata.put("AxioCam BlackRefIsCalculated", data); 
     1855        addMeta("AxioCam BlackRefIsCalculated", data); 
    18561856        break; 
    18571857      case 65545: 
    1858         metadata.put("AxioCam Black Reference", data); 
     1858        addMeta("AxioCam Black Reference", data); 
    18591859        break; 
    18601860      case 65547: 
    1861         metadata.put("Camera Shading Correction", data); 
     1861        addMeta("Camera Shading Correction", data); 
    18621862        break; 
    18631863      case 65550: 
    1864         metadata.put("AxioCam Enhance Color", data); 
     1864        addMeta("AxioCam Enhance Color", data); 
    18651865        break; 
    18661866      case 65551: 
    1867         metadata.put("AxioCam NIR Mode", data); 
     1867        addMeta("AxioCam NIR Mode", data); 
    18681868        break; 
    18691869      case 65552: 
    1870         metadata.put("CameraShutterCloseDelay", data); 
     1870        addMeta("CameraShutterCloseDelay", data); 
    18711871        break; 
    18721872      case 65553: 
    1873         metadata.put("CameraWhiteBalanceAutoCalculate", data); 
     1873        addMeta("CameraWhiteBalanceAutoCalculate", data); 
    18741874        break; 
    18751875      case 65556: 
    1876         metadata.put("AxioCam NIR Mode Available", data); 
     1876        addMeta("AxioCam NIR Mode Available", data); 
    18771877        break; 
    18781878      case 65557: 
    1879         metadata.put("AxioCam Fading Correction Available", data); 
     1879        addMeta("AxioCam Fading Correction Available", data); 
    18801880        break; 
    18811881      case 65559: 
    1882         metadata.put("AxioCam Enhance Color Available", data); 
     1882        addMeta("AxioCam Enhance Color Available", data); 
    18831883        break; 
    18841884      case 65565: 
    1885         metadata.put("MeteorVideoNorm", data); 
     1885        addMeta("MeteorVideoNorm", data); 
    18861886        break; 
    18871887      case 65566: 
    1888         metadata.put("MeteorAdjustWhiteReference", data); 
     1888        addMeta("MeteorAdjustWhiteReference", data); 
    18891889        break; 
    18901890      case 65567: 
    1891         metadata.put("MeteorBlackReference", data); 
     1891        addMeta("MeteorBlackReference", data); 
    18921892        break; 
    18931893      case 65568: 
    1894         metadata.put("MeteorChannelInputCountMono", data); 
     1894        addMeta("MeteorChannelInputCountMono", data); 
    18951895        break; 
    18961896      case 65570: 
    1897         metadata.put("MeteorChannelInputCountRGB", data); 
     1897        addMeta("MeteorChannelInputCountRGB", data); 
    18981898        break; 
    18991899      case 65571: 
    1900         metadata.put("MeteorEnableVCR", data); 
     1900        addMeta("MeteorEnableVCR", data); 
    19011901        break; 
    19021902      case 65572: 
    1903         metadata.put("Meteor Brightness", data); 
     1903        addMeta("Meteor Brightness", data); 
    19041904        break; 
    19051905      case 65573: 
    1906         metadata.put("Meteor Contrast", data); 
     1906        addMeta("Meteor Contrast", data); 
    19071907        break; 
    19081908      case 65575: 
    1909         metadata.put("AxioCam Selector", data); 
     1909        addMeta("AxioCam Selector", data); 
    19101910        break; 
    19111911      case 65576: 
    1912         metadata.put("AxioCam Type", data); 
     1912        addMeta("AxioCam Type", data); 
    19131913        break; 
    19141914      case 65577: 
    1915         metadata.put("AxioCam Info", data); 
     1915        addMeta("AxioCam Info", data); 
    19161916        break; 
    19171917      case 65580: 
    1918         metadata.put("AxioCam Resolution", data); 
     1918        addMeta("AxioCam Resolution", data); 
    19191919        break; 
    19201920      case 65581: 
    1921         metadata.put("AxioCam Color Model", data); 
     1921        addMeta("AxioCam Color Model", data); 
    19221922        break; 
    19231923      case 65582: 
    1924         metadata.put("AxioCam MicroScanning", data); 
     1924        addMeta("AxioCam MicroScanning", data); 
    19251925        break; 
    19261926      case 65585: 
    1927         metadata.put("Amplification Index", data); 
     1927        addMeta("Amplification Index", data); 
    19281928        break; 
    19291929      case 65586: 
    1930         metadata.put("Device Command", data); 
     1930        addMeta("Device Command", data); 
    19311931        break; 
    19321932      case 65587: 
    1933         metadata.put("BeamLocation", data); 
     1933        addMeta("BeamLocation", data); 
    19341934        break; 
    19351935      case 65588: 
    1936         metadata.put("ComponentType", data); 
     1936        addMeta("ComponentType", data); 
    19371937        break; 
    19381938      case 65589: 
    1939         metadata.put("ControllerType", data); 
     1939        addMeta("ControllerType", data); 
    19401940        break; 
    19411941      case 65590: 
    1942         metadata.put("CameraWhiteBalanceCalculationRedPaint", data); 
     1942        addMeta("CameraWhiteBalanceCalculationRedPaint", data); 
    19431943        break; 
    19441944      case 65591: 
    1945         metadata.put("CameraWhiteBalanceCalculationBluePaint", data); 
     1945        addMeta("CameraWhiteBalanceCalculationBluePaint", data); 
    19461946        break; 
    19471947      case 65592: 
    1948         metadata.put("CameraWhiteBalanceSetRed", data); 
     1948        addMeta("CameraWhiteBalanceSetRed", data); 
    19491949        break; 
    19501950      case 65593: 
    1951         metadata.put("CameraWhiteBalanceSetGreen", data); 
     1951        addMeta("CameraWhiteBalanceSetGreen", data); 
    19521952        break; 
    19531953      case 65594: 
    1954         metadata.put("CameraWhiteBalanceSetBlue", data); 
     1954        addMeta("CameraWhiteBalanceSetBlue", data); 
    19551955        break; 
    19561956      case 65595: 
    1957         metadata.put("CameraWhiteBalanceSetTargetRed", data); 
     1957        addMeta("CameraWhiteBalanceSetTargetRed", data); 
    19581958        break; 
    19591959      case 65596: 
    1960         metadata.put("CameraWhiteBalanceSetTargetGreen", data); 
     1960        addMeta("CameraWhiteBalanceSetTargetGreen", data); 
    19611961        break; 
    19621962      case 65597: 
    1963         metadata.put("CameraWhiteBalanceSetTargetBlue", data); 
     1963        addMeta("CameraWhiteBalanceSetTargetBlue", data); 
    19641964        break; 
    19651965      case 65598: 
    1966         metadata.put("ApotomeCamCalibrationMode", data); 
     1966        addMeta("ApotomeCamCalibrationMode", data); 
    19671967        break; 
    19681968      case 65599: 
    1969         metadata.put("ApoTome Grid Position", data); 
     1969        addMeta("ApoTome Grid Position", data); 
    19701970        break; 
    19711971      case 65600: 
    1972         metadata.put("ApotomeCamScannerPosition", data); 
     1972        addMeta("ApotomeCamScannerPosition", data); 
    19731973        break; 
    19741974      case 65601: 
    1975         metadata.put("ApoTome Full Phase Shift", data); 
     1975        addMeta("ApoTome Full Phase Shift", data); 
    19761976        break; 
    19771977      case 65602: 
    1978         metadata.put("ApoTome Grid Name", data); 
     1978        addMeta("ApoTome Grid Name", data); 
    19791979        break; 
    19801980      case 65603: 
    1981         metadata.put("ApoTome Staining", data); 
     1981        addMeta("ApoTome Staining", data); 
    19821982        break; 
    19831983      case 65604: 
    1984         metadata.put("ApoTome Processing Mode", data); 
     1984        addMeta("ApoTome Processing Mode", data); 
    19851985        break; 
    19861986      case 65605: 
    1987         metadata.put("ApotmeCamLiveCombineMode", data); 
     1987        addMeta("ApotmeCamLiveCombineMode", data); 
    19881988        break; 
    19891989      case 65606: 
    1990         metadata.put("ApoTome Filter Name", data); 
     1990        addMeta("ApoTome Filter Name", data); 
    19911991        break; 
    19921992      case 65607: 
    1993         metadata.put("Apotome Filter Strength", data); 
     1993        addMeta("Apotome Filter Strength", data); 
    19941994        break; 
    19951995      case 65608: 
    1996         metadata.put("ApotomeCamFilterHarmonics", data); 
     1996        addMeta("ApotomeCamFilterHarmonics", data); 
    19971997        break; 
    19981998      case 65609: 
    1999         metadata.put("ApoTome Grating Period", data); 
     1999        addMeta("ApoTome Grating Period", data); 
    20002000        break; 
    20012001      case 65610: 
    2002         metadata.put("ApoTome Auto Shutter Used", data); 
     2002        addMeta("ApoTome Auto Shutter Used", data); 
    20032003        break; 
    20042004      case 65611: 
    2005         metadata.put("Apotome Cam Status", data); 
     2005        addMeta("Apotome Cam Status", data); 
    20062006        break; 
    20072007      case 65612: 
    2008         metadata.put("ApotomeCamNormalize", data); 
     2008        addMeta("ApotomeCamNormalize", data); 
    20092009        break; 
    20102010      case 65613: 
    2011         metadata.put("ApotomeCamSettingsManager", data); 
     2011        addMeta("ApotomeCamSettingsManager", data); 
    20122012        break; 
    20132013      case 65614: 
    2014         metadata.put("DeepviewCamSupervisorMode", data); 
     2014        addMeta("DeepviewCamSupervisorMode", data); 
    20152015        break; 
    20162016      case 65615: 
    2017         metadata.put("DeepView Processing", data); 
     2017        addMeta("DeepView Processing", data); 
    20182018        break; 
    20192019      case 65616: 
    2020         metadata.put("DeepviewCamFilterName", data); 
     2020        addMeta("DeepviewCamFilterName", data); 
    20212021        break; 
    20222022      case 65617: 
    2023         metadata.put("DeepviewCamStatus", data); 
     2023        addMeta("DeepviewCamStatus", data); 
    20242024        break; 
    20252025      case 65618: 
    2026         metadata.put("DeepviewCamSettingsManager", data); 
     2026        addMeta("DeepviewCamSettingsManager", data); 
    20272027        break; 
    20282028      case 65619: 
    2029         metadata.put("DeviceScalingName", data); 
     2029        addMeta("DeviceScalingName", data); 
    20302030        break; 
    20312031      case 65620: 
    2032         metadata.put("CameraShadingIsCalculated", data); 
     2032        addMeta("CameraShadingIsCalculated", data); 
    20332033        break; 
    20342034      case 65621: 
    2035         metadata.put("CameraShadingCalculationName", data); 
     2035        addMeta("CameraShadingCalculationName", data); 
    20362036        break; 
    20372037      case 65622: 
    2038         metadata.put("CameraShadingAutoCalculate", data); 
     2038        addMeta("CameraShadingAutoCalculate", data); 
    20392039        break; 
    20402040      case 65623: 
    2041         metadata.put("CameraTriggerAvailable", data); 
     2041        addMeta("CameraTriggerAvailable", data); 
    20422042        break; 
    20432043      case 65626: 
    2044         metadata.put("CameraShutterAvailable", data); 
     2044        addMeta("CameraShutterAvailable", data); 
    20452045        break; 
    20462046      case 65627: 
    2047         metadata.put("AxioCam ShutterMicroScanningEnable", data); 
     2047        addMeta("AxioCam ShutterMicroScanningEnable", data); 
    20482048        break; 
    20492049      case 65628: 
    2050         metadata.put("ApotomeCamLiveFocus", data); 
     2050        addMeta("ApotomeCamLiveFocus", data); 
    20512051        break; 
    20522052      case 65629: 
    2053         metadata.put("DeviceInitStatus", data); 
     2053        addMeta("DeviceInitStatus", data); 
    20542054        break; 
    20552055      case 65630: 
    2056         metadata.put("DeviceErrorStatus", data); 
     2056        addMeta("DeviceErrorStatus", data); 
    20572057        break; 
    20582058      case 65631: 
    2059         metadata.put("ApotomeCamSliderInGridPosition", data); 
     2059        addMeta("ApotomeCamSliderInGridPosition", data); 
    20602060        break; 
    20612061      case 65632: 
    2062         metadata.put("Orca NIR Mode Used", data); 
     2062        addMeta("Orca NIR Mode Used", data); 
    20632063        break; 
    20642064      case 65633: 
    2065         metadata.put("Orca Analog Gain", data); 
     2065        addMeta("Orca Analog Gain", data); 
    20662066        break; 
    20672067      case 65634: 
    2068         metadata.put("Orca Analog Offset", data); 
     2068        addMeta("Orca Analog Offset", data); 
    20692069        break; 
    20702070      case 65635: 
    2071         metadata.put("Orca Binning", data); 
     2071        addMeta("Orca Binning", data); 
    20722072        break; 
    20732073      case 65636: 
    2074         metadata.put("Orca Bit Depth", data); 
     2074        addMeta("Orca Bit Depth", data); 
    20752075        break; 
    20762076      case 65637: 
    2077         metadata.put("ApoTome Averaging Count", data); 
     2077        addMeta("ApoTome Averaging Count", data); 
    20782078        break; 
    20792079      case 65638: 
    2080         metadata.put("DeepView DoF", data); 
     2080        addMeta("DeepView DoF", data); 
    20812081        break; 
    20822082      case 65639: 
    2083         metadata.put("DeepView EDoF", data); 
     2083        addMeta("DeepView EDoF", data); 
    20842084        break; 
    20852085      case 65643: 
    2086         metadata.put("DeepView Slider Name", data); 
     2086        addMeta("DeepView Slider Name", data); 
    20872087        break; 
    20882088      case 65655: 
    2089         metadata.put("DeepView Slider Name", data); 
     2089        addMeta("DeepView Slider Name", data); 
    20902090        break; 
    20912091      case 5439491: 
    2092         metadata.put("Acquisition Sofware", data); 
     2092        addMeta("Acquisition Sofware", data); 
    20932093        break; 
    20942094      case 16777488: 
    2095         metadata.put("Excitation Wavelength", data); 
     2095        addMeta("Excitation Wavelength", data); 
    20962096        break; 
    20972097      case 16777489: 
    2098         metadata.put("Emission Wavelength", data); 
     2098        addMeta("Emission Wavelength", data); 
    20992099        break; 
    21002100      case 101515267: 
    2101         metadata.put("File Name", data); 
     2101        addMeta("File Name", data); 
    21022102        break; 
    21032103      case 101253123: 
    21042104      case 101777411: 
    2105         metadata.put("Image Name", data); 
     2105        addMeta("Image Name", data); 
    21062106        break; 
    21072107      default: 
    2108         metadata.put("" + tagID, data); 
     2108        addMeta("" + tagID, data); 
    21092109    } 
    21102110  } 
Note: See TracChangeset for help on using the changeset viewer.