Changeset 6118


Ignore:
Timestamp:
04/13/10 12:22:25 (10 years ago)
Author:
melissa
Message:
  • Updated a few more readers to respect MetadataOptions.
  • Added utility method to FormatTools that returns a pixel type given the number of bytes per pixel. Several readers now use this method instead of nearly identical switch statements.
Location:
trunk/components/bio-formats/src/loci/formats
Files:
27 edited

Legend:

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

    r6026 r6118  
    592592    } 
    593593    throw new IllegalArgumentException("Unknown pixel type: " + pixelType); 
     594  } 
     595 
     596  /** 
     597   * Returns an appropriate pixel type given the number of bytes per pixel. 
     598   * 
     599   * @param bytes number of bytes per pixel. 
     600   * @param signed whether or not the pixel type should be signed. 
     601   * @param fp whether or not these are floating point pixels. 
     602   */ 
     603  public static int pixelTypeFromBytes(int bytes, boolean signed, boolean fp) 
     604    throws FormatException 
     605  { 
     606    switch (bytes) { 
     607      case 1: 
     608        return signed ? INT8 : UINT8; 
     609      case 2: 
     610        return signed ? INT16: UINT16; 
     611      case 4: 
     612        return fp ? FLOAT : signed ? INT32: UINT32; 
     613      case 8: 
     614        return DOUBLE; 
     615      default: 
     616        throw new FormatException("Unsupported byte depth: " + bytes); 
     617    } 
    594618  } 
    595619 
  • trunk/components/bio-formats/src/loci/formats/in/ARFReader.java

    r6112 r6118  
    122122    core[0].sizeT = numImages; 
    123123 
    124     if (bitsPerPixel > 32) { 
    125       throw new FormatException("Too many bits per pixel: " + bitsPerPixel); 
    126     } 
    127     else if (bitsPerPixel > 16) core[0].pixelType = FormatTools.UINT32; 
    128     else if (bitsPerPixel > 8) core[0].pixelType = FormatTools.UINT16; 
    129     else core[0].pixelType = FormatTools.UINT8; 
     124    int bpp = bitsPerPixel / 8; 
     125    if ((bitsPerPixel % 8) != 0) bpp++; 
     126    core[0].pixelType = FormatTools.pixelTypeFromBytes(bpp, false, false); 
    130127 
    131128    core[0].bitsPerPixel = bitsPerPixel; 
  • trunk/components/bio-formats/src/loci/formats/in/AliconaReader.java

    r6112 r6118  
    185185    core[0].littleEndian = true; 
    186186 
    187     core[0].pixelType = numBytes == 2 ? FormatTools.UINT16 : FormatTools.UINT8; 
     187    core[0].pixelType = FormatTools.pixelTypeFromBytes(numBytes, false, false); 
    188188    core[0].dimensionOrder = "XYCTZ"; 
    189189    core[0].metadataComplete = true; 
  • trunk/components/bio-formats/src/loci/formats/in/BioRadGelReader.java

    r6113 r6118  
    146146    in.skipBytes(2); 
    147147 
    148     int bytesPerPixel = in.readShort(); 
     148    int bpp = in.readShort(); 
     149    core[0].pixelType = FormatTools.pixelTypeFromBytes(bpp, false, false); 
    149150 
    150     switch (bytesPerPixel) { 
    151       case 1: 
    152         core[0].pixelType = FormatTools.UINT8; 
    153         break; 
    154       case 2: 
    155         core[0].pixelType = FormatTools.UINT16; 
    156         break; 
    157       default: 
    158         throw new FormatException("Unsupported bytes per pixel: " + 
    159           bytesPerPixel); 
    160     } 
    161151    offset = in.getFilePointer(); 
    162152 
  • trunk/components/bio-formats/src/loci/formats/in/CellomicsReader.java

    r6112 r6118  
    150150    core[0].littleEndian = true; 
    151151    core[0].dimensionOrder = "XYCZT"; 
    152  
    153     switch (nBits) { 
    154       case 8: 
    155        core[0].pixelType = FormatTools.UINT8; 
    156        break; 
    157       case 16: 
    158         core[0].pixelType = FormatTools.UINT16; 
    159         break; 
    160       default: 
    161         throw new FormatException("Unsupported bits per pixel: " + nBits); 
    162     } 
     152    core[0].pixelType = FormatTools.pixelTypeFromBytes(nBits / 8, false, false); 
    163153 
    164154    LOGGER.info("Populating metadata store"); 
  • trunk/components/bio-formats/src/loci/formats/in/DicomReader.java

    r6099 r6118  
    575575    } 
    576576 
    577     switch (bitsPerPixel) { 
    578       case 8: 
    579         core[0].pixelType = signed ? FormatTools.INT8 : FormatTools.UINT8; 
    580         break; 
    581       case 16: 
    582         core[0].pixelType = signed ? FormatTools.INT16 : FormatTools.UINT16; 
    583         break; 
    584       case 32: 
    585         core[0].pixelType = signed ? FormatTools.INT32 : FormatTools.UINT32; 
    586         break; 
    587     } 
     577    core[0].pixelType = 
     578      FormatTools.pixelTypeFromBytes(bitsPerPixel / 8, signed, false); 
    588579 
    589580    int bpp = FormatTools.getBytesPerPixel(getPixelType()); 
  • trunk/components/bio-formats/src/loci/formats/in/FV1000Reader.java

    r6098 r6118  
    537537        int bits = ifds.get(0).getBitsPerSample()[0]; 
    538538        while ((bits % 8) != 0) bits++; 
    539         switch (bits) { 
    540           case 8: 
    541             core[1].pixelType = FormatTools.UINT8; 
    542             break; 
    543           case 16: 
    544             core[1].pixelType = FormatTools.UINT16; 
    545             break; 
    546           case 32: 
    547             core[1].pixelType = FormatTools.UINT32; 
    548         } 
     539        bits /= 8; 
     540        core[1].pixelType = FormatTools.pixelTypeFromBytes(bits, false, false); 
    549541        core[1].dimensionOrder = "XYCZT"; 
    550542        core[1].indexed = false; 
     
    734726    if (getDimensionOrder().indexOf("T") == -1) core[0].dimensionOrder += "T"; 
    735727 
    736     switch (imageDepth) { 
    737       case 1: 
    738         core[0].pixelType = FormatTools.UINT8; 
    739         break; 
    740       case 2: 
    741         core[0].pixelType = FormatTools.UINT16; 
    742         break; 
    743       case 4: 
    744         core[0].pixelType = FormatTools.UINT32; 
    745         break; 
    746       default: 
    747         throw new RuntimeException("Unsupported pixel depth: " + imageDepth); 
    748     } 
     728    core[0].pixelType = 
     729      FormatTools.pixelTypeFromBytes(imageDepth, false, false); 
    749730 
    750731    // set up thumbnail file mapping 
  • trunk/components/bio-formats/src/loci/formats/in/FitsReader.java

    r6116 r6118  
    119119      if (key.equals("BITPIX")) { 
    120120        int bits = Integer.parseInt(value); 
    121         switch (bits) { 
    122           case 8: 
    123             core[0].pixelType = FormatTools.UINT8; 
    124             break; 
    125           case 16: 
    126             core[0].pixelType = FormatTools.INT16; 
    127             break; 
    128           case 32: 
    129             core[0].pixelType = FormatTools.INT32; 
    130             break; 
    131           case -32: 
    132             core[0].pixelType = FormatTools.FLOAT; 
    133             break; 
    134           case -64: 
    135             core[0].pixelType = FormatTools.DOUBLE; 
    136             break; 
    137           default: throw new FormatException("Unsupported pixel type: " + bits); 
    138         } 
     121        boolean fp = bits < 0; 
     122        boolean signed = bits != 8; 
     123        bits = Math.abs(bits) / 8; 
     124        core[0].pixelType = FormatTools.pixelTypeFromBytes(bits, signed, fp); 
    139125      } 
    140126      else if (key.equals("NAXIS1")) core[0].sizeX = Integer.parseInt(value); 
  • trunk/components/bio-formats/src/loci/formats/in/GatanDM2Reader.java

    r6026 r6118  
    105105    int bpp = (int) ((footerOffset - HEADER_SIZE) / (getSizeX() * getSizeY())); 
    106106 
    107     switch (bpp) { 
    108       case 1: 
    109         core[0].pixelType = FormatTools.UINT8; 
    110         break; 
    111       case 2: 
    112         core[0].pixelType = FormatTools.UINT16; 
    113         break; 
    114       case 4: 
    115         core[0].pixelType = FormatTools.UINT32; 
    116         break; 
    117       default: 
    118         throw new FormatException("Unsupported bytes per pixel: " + bpp); 
    119     } 
    120  
     107    core[0].pixelType = FormatTools.pixelTypeFromBytes(bpp, false, false); 
    121108    core[0].sizeC = 1; 
    122109    core[0].sizeT = 1; 
     
    126113    core[0].littleEndian = false; 
    127114 
    128     in.skipBytes(FormatTools.getPlaneSize(this) + 39); 
    129115 
    130116    MetadataStore store = 
     
    136122    store.setImageInstrumentRef(instrumentID, 0); 
    137123 
    138     String date = null, time = null; 
     124    String date = null, time = null, name = null; 
     125    in.skipBytes(FormatTools.getPlaneSize(this) + 39); 
     126 
     127    MetadataLevel level = getMetadataOptions().getMetadataLevel(); 
    139128 
    140129    while (in.getFilePointer() < in.length()) { 
     130      if (level != MetadataLevel.ALL && date != null && 
     131        time != null && name != null) 
     132      { 
     133        break; 
     134      } 
     135 
    141136      int strlen = in.readShort(); 
    142137      if (strlen == 0) { 
     
    187182        } 
    188183      } 
    189       else if (type.equals("sing")) { 
    190         in.skipBytes(count); 
    191       } 
    192184      else { 
    193185        in.skipBytes(count); 
     
    211203      } 
    212204      else if (label.equals("Name")) { 
    213         store.setImageName(value.toString(), 0); 
     205        name = value.toString(); 
    214206      } 
    215207      else if (label.equals("Operator")) { 
    216         String[] name = value.toString().split(" "); 
    217         store.setExperimenterFirstName(name[0], 0); 
    218         if (name.length > 1) { 
    219           store.setExperimenterLastName(name[1], 0); 
     208        String[] experimenterName = value.toString().split(" "); 
     209        store.setExperimenterFirstName(experimenterName[0], 0); 
     210        if (experimenterName.length > 1) { 
     211          store.setExperimenterLastName(experimenterName[1], 0); 
    220212        } 
    221213        String expID = MetadataTools.createLSID("Experimenter", 0); 
     
    232224      store.setImageCreationDate(DateTools.formatDate(date, format), 0); 
    233225    } 
     226    if (name != null) { 
     227      store.setImageName(name, 0); 
     228    } 
    234229  } 
    235230 
  • trunk/components/bio-formats/src/loci/formats/in/GatanReader.java

    r6055 r6118  
    7474 
    7575  /** List of pixel sizes. */ 
    76   private Vector<String> pixelSizes; 
     76  private Vector<Double> pixelSizes; 
    7777 
    7878  private int bytesPerPixel; 
     
    116116    in.seek(pixelOffset); 
    117117    readPlane(in, x, y, w, h, buf); 
    118  
    119118    return buf; 
    120119  } 
     
    145144 
    146145    core[0].littleEndian = false; 
    147     pixelSizes = new Vector<String>(); 
    148  
    149     in.order(false); 
     146    pixelSizes = new Vector<Double>(); 
     147 
     148    in.order(isLittleEndian()); 
    150149 
    151150    // only support version 3 
     
    182181    int bytes = numPixelBytes / (getSizeX() * getSizeY()); 
    183182 
    184     switch (bytes) { 
    185       case 1: 
    186         core[0].pixelType = signed ? FormatTools.INT8 : FormatTools.UINT8; 
    187         break; 
    188       case 2: 
    189         core[0].pixelType = signed ? FormatTools.INT16 : FormatTools.UINT16; 
    190         break; 
    191       case 4: 
    192         core[0].pixelType = signed ? FormatTools.INT32 : FormatTools.UINT32; 
    193         break; 
    194       default: 
    195         throw new FormatException("Unsupported pixel type"); 
    196     } 
    197  
     183    core[0].pixelType = FormatTools.pixelTypeFromBytes(bytes, signed, false); 
    198184    core[0].sizeZ = 1; 
    199185    core[0].sizeC = 1; 
     
    213199    MetadataTools.setDefaultCreationDate(store, id, 0); 
    214200 
    215     Double pixX = new Double(1); 
    216     Double pixY = new Double(1); 
    217     Double pixZ = new Double(1); 
    218  
    219     if (pixelSizes.size() > 0) { 
    220       pixX = new Double(pixelSizes.get(0)); 
    221     } 
    222  
    223     if (pixelSizes.size() > 1) { 
    224       pixY = new Double(pixelSizes.get(1)); 
    225     } 
    226  
    227     if (pixelSizes.size() > 2) { 
    228       pixZ = new Double(pixelSizes.get(2)); 
    229     } 
    230  
    231     store.setDimensionsPhysicalSizeX(pixX, 0, 0); 
    232     store.setDimensionsPhysicalSizeY(pixY, 0, 0); 
    233     store.setDimensionsPhysicalSizeZ(pixZ, 0, 0); 
    234  
    235     for (int i=0; i<getSizeC(); i++) { 
    236       // CTR CHECK 
    237 //      store.setDisplayChannel(i, null, null, gamma, null); 
    238     } 
    239  
    240     // CTR CHECK 
    241     //store.setObjectiveCalibratedMagnification(mag, 0, 0); 
    242     //store.setDetectorVoltage(voltage, 0, 0); 
    243  
    244     if (info == null) info = ""; 
    245     StringTokenizer scopeInfo = new StringTokenizer(info, "("); 
    246     while (scopeInfo.hasMoreTokens()) { 
    247       String token = scopeInfo.nextToken().trim(); 
    248       if (token.startsWith("Microscope")) { 
    249         //token = token.substring(0, token.indexOf(" ")).trim(); 
    250         //store.setMicroscopeManufacturer( 
    251         //  token.substring(token.indexOf(" ")).trim(), 0, 0); 
    252         //store.setMicroscopeModel(token, 0, 0); 
    253       } 
    254       else if (token.startsWith("Mode")) { 
    255         token = token.substring(token.indexOf(" ")).trim(); 
    256         String mode = token.substring(0, token.indexOf(" ")).trim(); 
    257         if (mode.equals("TEM")) mode = "Other"; 
    258         store.setLogicalChannelMode(mode, 0, 0); 
     201    if (getMetadataOptions().getMetadataLevel() == MetadataLevel.ALL) { 
     202      if (pixelSizes.size() > 0) { 
     203        store.setDimensionsPhysicalSizeX(pixelSizes.get(0), 0, 0); 
     204      } 
     205      if (pixelSizes.size() > 1) { 
     206        store.setDimensionsPhysicalSizeY(pixelSizes.get(1), 0, 0); 
     207      } 
     208      if (pixelSizes.size() > 2) { 
     209        store.setDimensionsPhysicalSizeZ(pixelSizes.get(2), 0, 0); 
     210      } 
     211 
     212      if (info == null) info = ""; 
     213      String[] scopeInfo = info.split("\\("); 
     214      for (String token : scopeInfo) { 
     215        token = token.trim(); 
     216        if (token.startsWith("Mode")) { 
     217          token = token.substring(token.indexOf(" ")).trim(); 
     218          String mode = token.substring(0, token.indexOf(" ")).trim(); 
     219          if (mode.equals("TEM")) mode = "Other"; 
     220          store.setLogicalChannelMode(mode, 0, 0); 
     221        } 
    259222      } 
    260223    } 
     
    280243    for (int i=0; i<numTags; i++) { 
    281244      if (in.getFilePointer() >= in.length()) break; 
     245 
    282246      byte type = in.readByte();  // can be 21 (data) or 20 (tag group) 
    283247      int length = in.readShort(); 
     
    407371 
    408372        if (labelString.equals("Scale")) { 
    409           if (value.indexOf(",") == -1) pixelSizes.add(value); 
     373          if (value.indexOf(",") == -1) pixelSizes.add(new Double(value)); 
    410374          else { 
    411             double start = 
    412               Double.parseDouble(value.substring(0, value.indexOf(","))); 
    413             double end = 
    414               Double.parseDouble(value.substring(value.indexOf(",") + 2)); 
    415             pixelSizes.add(String.valueOf(end - start)); 
     375            int comma = value.indexOf(","); 
     376            double start = Double.parseDouble(value.substring(0, comma)); 
     377            double end = Double.parseDouble(value.substring(comma + 2)); 
     378            pixelSizes.add(end - start); 
    416379          } 
    417380        } 
  • trunk/components/bio-formats/src/loci/formats/in/GelReader.java

    r6026 r6118  
    103103    IFD ifd = ifds.get(no); 
    104104 
    105     boolean sqrt = fmt == SQUARE_ROOT; 
    106  
    107     if (sqrt) { 
    108       double scale = ((TiffRational) 
    109         ifd.getIFDValue(MD_SCALE_PIXEL)).doubleValue(); 
     105    if (fmt == SQUARE_ROOT) { 
     106      float scale = 
     107        ((TiffRational) ifd.getIFDValue(MD_SCALE_PIXEL)).floatValue(); 
    110108 
    111109      byte[] tmp = new byte[buf.length]; 
    112       super.openBytes(no, tmp, x, y, w, h); 
     110 
     111      // DO NOT call super.openBytes here. MinimalTiffReader will interpret 
     112      // the pixels as half-floats, when really they are unsigned shorts. 
     113      tiffParser.getSamples(ifds.get(no), tmp, x, y, w, h); 
    113114 
    114115      int originalBytes = ifd.getBitsPerSample()[0] / 8; 
     
    118119          originalBytes, isLittleEndian()); 
    119120        long square = value * value; 
    120         float pixel = (float) (square * scale); 
     121        float pixel = square * scale; 
    121122        DataTools.unpackBytes(Float.floatToIntBits(pixel), buf, i*4, 4, 
    122123          isLittleEndian()); 
     
    150151    fmt = firstIFD.getIFDLongValue(MD_FILETAG, LINEAR); 
    151152    if (fmt == SQUARE_ROOT) core[0].pixelType = FormatTools.FLOAT; 
    152     addGlobalMeta("Data format", fmt == SQUARE_ROOT ? "square root" : "linear"); 
    153  
    154     TiffRational scale = 
    155       (TiffRational) firstIFD.getIFDValue(MD_SCALE_PIXEL); 
     153 
     154    TiffRational scale = (TiffRational) firstIFD.getIFDValue(MD_SCALE_PIXEL); 
    156155    if (scale == null) scale = new TiffRational(1, 1); 
    157     addGlobalMeta("Scale factor", scale); 
    158  
    159     // ignore MD_COLOR_TABLE 
    160  
    161     String lab = firstIFD.getIFDStringValue(MD_LAB_NAME); 
    162     addGlobalMeta("Lab name", lab); 
    163  
    164     String info = firstIFD.getIFDStringValue(MD_SAMPLE_INFO); 
    165     addGlobalMeta("Sample info", info); 
    166  
    167     String prepDate = firstIFD.getIFDStringValue(MD_PREP_DATE); 
    168     addGlobalMeta("Date prepared", prepDate); 
    169  
    170     String prepTime = firstIFD.getIFDStringValue(MD_PREP_TIME); 
    171     addGlobalMeta("Time prepared", prepTime); 
    172  
    173     String units = firstIFD.getIFDStringValue(MD_FILE_UNITS); 
    174     addGlobalMeta("File units", units); 
    175156 
    176157    core[0].imageCount = ifds.size(); 
    177158    core[0].sizeT = getImageCount(); 
     159 
     160    // ignore MD_COLOR_TABLE 
     161 
     162    String info = firstIFD.getIFDStringValue(MD_SAMPLE_INFO); 
     163    String prepDate = firstIFD.getIFDStringValue(MD_PREP_DATE); 
     164    String prepTime = firstIFD.getIFDStringValue(MD_PREP_TIME); 
     165 
     166    if (getMetadataOptions().getMetadataLevel() == MetadataLevel.ALL) { 
     167      String units = firstIFD.getIFDStringValue(MD_FILE_UNITS); 
     168      String lab = firstIFD.getIFDStringValue(MD_LAB_NAME); 
     169 
     170      addGlobalMeta("Scale factor", scale); 
     171      addGlobalMeta("Lab name", lab); 
     172      addGlobalMeta("Sample info", info); 
     173      addGlobalMeta("Date prepared", prepDate); 
     174      addGlobalMeta("Time prepared", prepTime); 
     175      addGlobalMeta("File units", units); 
     176      addGlobalMeta("Data format", 
     177        fmt == SQUARE_ROOT ? "square root" : "linear"); 
     178    } 
    178179 
    179180    MetadataStore store = 
    180181      new FilterMetadata(getMetadataStore(), isMetadataFiltered()); 
    181182    MetadataTools.populatePixels(store, this); 
    182     store.setImageDescription(info, 0); 
    183183 
    184184    String parsedDate = DateTools.formatDate(prepDate, FORMATS); 
     
    195195    } 
    196196 
    197     Double pixelSize = new Double(scale.doubleValue()); 
    198     store.setDimensionsPhysicalSizeX(pixelSize, 0, 0); 
    199     store.setDimensionsPhysicalSizeY(pixelSize, 0, 0); 
     197    if (getMetadataOptions().getMetadataLevel() == MetadataLevel.ALL) { 
     198      store.setImageDescription(info, 0); 
     199      Double pixelSize = new Double(scale.doubleValue()); 
     200      store.setDimensionsPhysicalSizeX(pixelSize, 0, 0); 
     201      store.setDimensionsPhysicalSizeY(pixelSize, 0, 0); 
     202    } 
    200203  } 
    201204 
  • trunk/components/bio-formats/src/loci/formats/in/HISReader.java

    r6055 r6118  
    5353  // -- Fields -- 
    5454 
     55  /** Offsets to pixel data for each series. */ 
    5556  private long[] pixelOffset; 
    5657 
     
    181182      in.skipBytes(50); 
    182183      String comment = in.readString(commentBytes); 
    183       String[] data = comment.split(";"); 
    184       for (String token : data) { 
    185         int eq = token.indexOf("="); 
    186         if (eq != -1) { 
    187           String key = token.substring(0, eq); 
    188           String value = token.substring(eq + 1); 
    189  
    190           addSeriesMeta(key, value); 
    191  
    192           if (key.equals("vDate")) { 
    193             date[i] = value; 
    194           } 
    195           else if (key.equals("vTime")) { 
    196             date[i] += " " + value; 
    197             date[i] = DateTools.formatDate(date[i], "yyyy/MM/dd HH:mm:ss"); 
    198           } 
    199           else if (key.equals("vOffset")) { 
    200             offset[i] = Double.parseDouble(value); 
    201           } 
    202           else if (key.equals("vBinX")) { 
    203             binning[i] = value; 
    204           } 
    205           else if (key.equals("vBinY")) { 
    206             binning[i] += "x" + value; 
    207           } 
    208           else if (key.equals("vExpTim1")) { 
    209             exposureTime[i] = Double.parseDouble(value) * 100; 
     184      if (getMetadataOptions().getMetadataLevel() == MetadataLevel.ALL) { 
     185        String[] data = comment.split(";"); 
     186        for (String token : data) { 
     187          int eq = token.indexOf("="); 
     188          if (eq != -1) { 
     189            String key = token.substring(0, eq); 
     190            String value = token.substring(eq + 1); 
     191 
     192            addSeriesMeta(key, value); 
     193 
     194            if (key.equals("vDate")) { 
     195              date[i] = value; 
     196            } 
     197            else if (key.equals("vTime")) { 
     198              date[i] += " " + value; 
     199              date[i] = DateTools.formatDate(date[i], "yyyy/MM/dd HH:mm:ss"); 
     200            } 
     201            else if (key.equals("vOffset")) { 
     202              offset[i] = Double.parseDouble(value); 
     203            } 
     204            else if (key.equals("vBinX")) { 
     205              binning[i] = value; 
     206            } 
     207            else if (key.equals("vBinY")) { 
     208              binning[i] += "x" + value; 
     209            } 
     210            else if (key.equals("vExpTim1")) { 
     211              exposureTime[i] = Double.parseDouble(value) * 100; 
     212            } 
    210213          } 
    211214        } 
     
    234237    store.setInstrumentID(instrumentID, 0); 
    235238 
    236     for (int i=0; i<nSeries; i++) { 
    237       store.setImageInstrumentRef(instrumentID, i); 
    238       store.setImageCreationDate(date[i], i); 
    239  
    240       store.setPlaneTimingExposureTime(exposureTime[i], i, 0, 0); 
    241  
    242       String detectorID = MetadataTools.createLSID("Detector", 0, i); 
    243       store.setDetectorID(detectorID, 0, i); 
    244       store.setDetectorOffset(offset[i], 0, i); 
    245       store.setDetectorType("Unknown", 0, i); 
    246       store.setDetectorSettingsDetector(detectorID, i, 0); 
    247       store.setDetectorSettingsBinning(binning[i], i, 0); 
     239    if (getMetadataOptions().getMetadataLevel() == MetadataLevel.ALL) { 
     240      for (int i=0; i<nSeries; i++) { 
     241        store.setImageInstrumentRef(instrumentID, i); 
     242        store.setImageCreationDate(date[i], i); 
     243 
     244        store.setPlaneTimingExposureTime(exposureTime[i], i, 0, 0); 
     245 
     246        String detectorID = MetadataTools.createLSID("Detector", 0, i); 
     247        store.setDetectorID(detectorID, 0, i); 
     248        store.setDetectorOffset(offset[i], 0, i); 
     249        store.setDetectorType("Unknown", 0, i); 
     250        store.setDetectorSettingsDetector(detectorID, i, 0); 
     251        store.setDetectorSettingsBinning(binning[i], i, 0); 
     252      } 
    248253    } 
    249254  } 
  • trunk/components/bio-formats/src/loci/formats/in/ICSReader.java

    r6089 r6118  
    743743    if (bitsPerPixel < 32) core[0].littleEndian = !isLittleEndian(); 
    744744 
    745     if (rFormat.equals("real")) { 
    746       if (bitsPerPixel == 32) core[0].pixelType = FormatTools.FLOAT; 
    747       else if (bitsPerPixel == 64) core[0].pixelType = FormatTools.DOUBLE; 
    748     } 
    749     else if (rFormat.equals("integer")) { 
    750       switch (bitsPerPixel) { 
    751         case 8: 
    752           core[0].pixelType = signed ? FormatTools.INT8 : FormatTools.UINT8; 
    753           break; 
    754         case 16: 
    755           core[0].pixelType = signed ? FormatTools.INT16 : FormatTools.UINT16; 
    756           break; 
    757         case 32: 
    758           core[0].pixelType = signed ? FormatTools.INT32 : FormatTools.UINT32; 
    759           break; 
    760       } 
    761     } 
    762     else { 
    763       throw new RuntimeException("Unknown pixel format: " + rFormat); 
    764     } 
     745    boolean fp = rFormat.equals("real"); 
     746    int bytes = bitsPerPixel / 8; 
     747    core[0].pixelType = FormatTools.pixelTypeFromBytes(bytes, signed, fp); 
    765748 
    766749    LOGGER.info("Populating OME metadata"); 
  • trunk/components/bio-formats/src/loci/formats/in/IPWReader.java

    r6026 r6118  
    292292    if (bitsPerSample == 24 || bitsPerSample == 48) bitsPerSample /= 3; 
    293293 
    294     core[0].pixelType = FormatTools.UINT8; 
    295  
    296     if (bitFormat == 3) core[0].pixelType = FormatTools.FLOAT; 
    297     else if (bitFormat == 2) { 
    298       switch (bitsPerSample) { 
    299         case 8: 
    300           core[0].pixelType = FormatTools.INT8; 
    301           break; 
    302         case 16: 
    303           core[0].pixelType = FormatTools.INT16; 
    304           break; 
    305         case 32: 
    306           core[0].pixelType = FormatTools.INT32; 
    307           break; 
    308       } 
    309     } 
    310     else { 
    311       switch (bitsPerSample) { 
    312         case 8: 
    313           core[0].pixelType = FormatTools.UINT8; 
    314           break; 
    315         case 16: 
    316           core[0].pixelType = FormatTools.UINT16; 
    317           break; 
    318         case 32: 
    319           core[0].pixelType = FormatTools.UINT32; 
    320           break; 
    321       } 
    322     } 
     294    boolean fp = bitFormat == 3; 
     295    boolean signed = bitFormat == 2; 
     296 
     297    core[0].pixelType = 
     298      FormatTools.pixelTypeFromBytes(bitsPerSample / 4, signed, fp); 
    323299 
    324300    MetadataStore store = 
  • trunk/components/bio-formats/src/loci/formats/in/LIMReader.java

    r6026 r6118  
    101101 
    102102    while (bits % 8 != 0) bits++; 
    103     switch (bits) { 
    104       case 8: 
    105         core[0].pixelType = FormatTools.UINT8; 
    106         break; 
    107       case 16: 
    108         core[0].pixelType = FormatTools.UINT16; 
    109         break; 
    110       case 24: 
    111         core[0].pixelType = FormatTools.UINT8; 
    112         core[0].sizeC = 3; 
    113         break; 
    114       case 32: 
    115         core[0].pixelType = FormatTools.UINT32; 
    116         break; 
    117       case 48: 
    118         core[0].pixelType = FormatTools.UINT16; 
    119         core[0].sizeC = 3; 
    120         break; 
    121       default: 
    122         throw new FormatException("Unsupported bits per pixel : " + bits); 
     103    if ((bits % 3) == 0) { 
     104      core[0].sizeC = 3; 
     105      bits /= 3; 
    123106    } 
     107    core[0].pixelType = FormatTools.pixelTypeFromBytes(bits / 8, false, false); 
    124108 
    125109    isCompressed = in.readShort() != 0; 
  • trunk/components/bio-formats/src/loci/formats/in/LegacyND2Reader.java

    r6053 r6118  
    153153        else core[i].rgb = false; 
    154154 
    155         switch (bytes) { 
    156           case 1: 
    157             core[i].pixelType = FormatTools.UINT8; 
    158             break; 
    159           case 2: 
    160             core[i].pixelType = FormatTools.UINT16; 
    161             break; 
    162           case 4: 
    163             core[i].pixelType = FormatTools.FLOAT; 
    164             break; 
    165         } 
     155        core[i].pixelType = FormatTools.pixelTypeFromBytes(bytes, false, true); 
    166156        core[i].imageCount = core[i].sizeZ * core[i].sizeT; 
    167157        if (!core[i].rgb) core[i].imageCount *= core[i].sizeC; 
  • trunk/components/bio-formats/src/loci/formats/in/LeicaReader.java

    r6094 r6118  
    855855    addSeriesMeta("Bytes per pixel", bpp); 
    856856 
    857     switch (bpp) { 
    858       case 1: 
    859         core[seriesIndex].pixelType = FormatTools.UINT8; 
    860         break; 
    861       case 3: 
    862         core[seriesIndex].pixelType = FormatTools.UINT8; 
    863         core[seriesIndex].sizeC = 3; 
    864         core[seriesIndex].rgb = true; 
    865         break; 
    866       case 2: 
    867         core[seriesIndex].pixelType = FormatTools.UINT16; 
    868         break; 
    869       case 6: 
    870         core[seriesIndex].pixelType = FormatTools.UINT16; 
    871         core[seriesIndex].sizeC = 3; 
    872         core[seriesIndex].rgb = true; 
    873         break; 
    874       case 4: 
    875         core[seriesIndex].pixelType = FormatTools.UINT32; 
    876         break; 
    877       default: 
    878         throw new FormatException("Unsupported bytes per pixel (" + 
    879           bpp + ")"); 
    880     } 
     857    if (bpp % 3 == 0) { 
     858      core[seriesIndex].sizeC = 3; 
     859      core[seriesIndex].rgb = true; 
     860      bpp /= 3; 
     861    } 
     862    core[seriesIndex].pixelType = 
     863      FormatTools.pixelTypeFromBytes(bpp, false, false); 
    881864 
    882865    core[seriesIndex].dimensionOrder = "XY"; 
  • trunk/components/bio-formats/src/loci/formats/in/NAFReader.java

    r6026 r6118  
    130130 
    131131      core[i].imageCount = core[i].sizeZ * core[i].sizeC * core[i].sizeT; 
    132       switch (numBits) { 
    133         case 8: 
    134           core[i].pixelType = FormatTools.UINT8; 
    135           break; 
    136         case 16: 
    137           core[i].pixelType = FormatTools.UINT16; 
    138           break; 
    139         case 32: 
    140           core[i].pixelType = FormatTools.UINT32; 
    141           break; 
    142         case 64: 
    143           core[i].pixelType = FormatTools.DOUBLE; 
    144           break; 
    145       } 
     132      int nBytes = numBits / 8; 
     133      core[i].pixelType = 
     134        FormatTools.pixelTypeFromBytes(nBytes, false, nBytes == 8); 
    146135 
    147136      core[i].dimensionOrder = "XYCZT"; 
  • trunk/components/bio-formats/src/loci/formats/in/NativeND2Reader.java

    r6096 r6118  
    819819        int bytes = Integer.parseInt(value) / div; 
    820820 
    821         switch (bytes) { 
    822           case 2: 
    823             core[0].pixelType = FormatTools.UINT16; 
    824             break; 
    825           case 4: 
    826             core[0].pixelType = FormatTools.UINT32; 
    827             break; 
    828           default: 
    829             core[0].pixelType = FormatTools.UINT8; 
    830         } 
     821        try { 
     822          core[0].pixelType = 
     823            FormatTools.pixelTypeFromBytes(bytes, false, false); 
     824        } 
     825        catch (FormatException e) { } 
    831826        parseKeyAndValue(qName, value, prevRuntype); 
    832827      } 
  • trunk/components/bio-formats/src/loci/formats/in/NativeQTReader.java

    r6026 r6118  
    288288    int bytesPerPixel = (bitsPerPixel / 8) % 4; 
    289289    core[0].pixelType = 
    290       bytesPerPixel == 2 ?  FormatTools.UINT16 : FormatTools.UINT8; 
     290      FormatTools.pixelTypeFromBytes(bytesPerPixel, false, false); 
    291291 
    292292    core[0].sizeZ = 1; 
  • trunk/components/bio-formats/src/loci/formats/in/OMEXMLReader.java

    r6026 r6118  
    327327      core[i].indexed = false; 
    328328      core[i].falseColor = true; 
    329  
    330       String type = pixType.toLowerCase(); 
    331       boolean signed = type.charAt(0) != 'u'; 
    332       if (type.endsWith("16")) { 
    333         core[i].pixelType = signed ? FormatTools.INT16 : FormatTools.UINT16; 
    334       } 
    335       else if (type.endsWith("32")) { 
    336         core[i].pixelType = signed ? FormatTools.INT32 : FormatTools.UINT32; 
    337       } 
    338       else if (type.equals("float")) { 
    339         core[i].pixelType = FormatTools.FLOAT; 
    340       } 
    341       else { 
    342         core[i].pixelType = signed ? FormatTools.INT8 : FormatTools.UINT8; 
    343       } 
     329      core[i].pixelType = FormatTools.pixelTypeFromString(pixType); 
    344330      core[i].orderCertain = true; 
    345331    } 
  • trunk/components/bio-formats/src/loci/formats/in/PCIReader.java

    r6055 r6118  
    211211        int bits = (int) DataTools.bytesToDouble(b, true); 
    212212        while (bits % 8 != 0 || bits == 0) bits++; 
    213         switch (bits) { 
    214           case 8: 
    215             core[0].pixelType = FormatTools.UINT8; 
    216             break; 
    217           case 16: 
    218             core[0].pixelType = FormatTools.UINT16; 
    219             break; 
    220           case 32: 
    221             core[0].pixelType = FormatTools.UINT32; 
    222             break; 
    223           case 48: 
    224             core[0].pixelType = FormatTools.UINT16; 
    225             break; 
    226           default: 
    227             throw new FormatException("Unsupported bits per pixel : " + bits); 
     213        if (bits % 3 == 0) { 
     214          core[0].sizeC = 3; 
     215          bits /= 3; 
    228216        } 
     217        bits /= 8; 
     218        core[0].pixelType = FormatTools.pixelTypeFromBytes(bits, false, false); 
    229219      } 
    230220      else if (relativePath.indexOf("Image_Height") != -1 && getSizeY() == 0) { 
  • trunk/components/bio-formats/src/loci/formats/in/PSDReader.java

    r6026 r6118  
    156156    int bits = in.readShort(); 
    157157    addGlobalMeta("Bits per pixel", bits); 
    158     if (bits == 16) core[0].pixelType = FormatTools.UINT16; 
    159     else core[0].pixelType = FormatTools.UINT8; 
     158    core[0].pixelType = FormatTools.pixelTypeFromBytes(bits / 8, false, false); 
    160159 
    161160    int colorMode = in.readShort(); 
  • trunk/components/bio-formats/src/loci/formats/in/TillVisionReader.java

    r6055 r6118  
    441441 
    442442  private int convertPixelType(int type) throws FormatException { 
    443     switch (type) { 
    444       case 1: 
    445         return FormatTools.INT8; 
    446       case 2: 
    447         return FormatTools.UINT8; 
    448       case 3: 
    449         return FormatTools.INT16; 
    450       case 4: 
    451         return FormatTools.UINT16; 
    452       default: 
    453         throw new FormatException("Unsupported data type: " + type); 
    454     } 
     443    boolean signed = type % 2 == 1; 
     444    int bytes = (type / 2) + (signed ? 1 : 0); 
     445    return FormatTools.pixelTypeFromBytes(bytes, signed, false); 
    455446  } 
    456447 
  • trunk/components/bio-formats/src/loci/formats/in/UnisokuReader.java

    r6055 r6118  
    163163          value = value.substring(value.indexOf(" ") + 1); 
    164164          int type = Integer.parseInt(value); 
    165           switch (type) { 
    166             case 2: 
    167               core[0].pixelType = FormatTools.UINT8; 
    168               break; 
    169             case 3: 
    170               core[0].pixelType = FormatTools.INT8; 
    171               break; 
    172             case 4: 
    173               core[0].pixelType = FormatTools.UINT16; 
    174               break; 
    175             case 5: 
    176               core[0].pixelType = FormatTools.INT16; 
    177               break; 
    178             case 8: 
    179               core[0].pixelType = FormatTools.FLOAT; 
    180               break; 
    181             default: 
    182               throw new FormatException("Unsupported data type: " + type); 
    183           } 
     165          boolean signed = type % 2 == 1; 
     166          int bytes = type / 2; 
     167          core[0].pixelType = 
     168            FormatTools.pixelTypeFromBytes(bytes, signed, bytes == 4); 
    184169        } 
    185170      } 
  • trunk/components/bio-formats/src/loci/formats/in/VGSAMReader.java

    r6026 r6118  
    9393 
    9494    int bpp = in.readInt(); 
    95     switch (bpp) { 
    96       case 1: 
    97         core[0].pixelType = FormatTools.UINT8; 
    98         break; 
    99       case 2: 
    100         core[0].pixelType = FormatTools.UINT16; 
    101         break; 
    102       case 4: 
    103         core[0].pixelType = FormatTools.FLOAT; 
    104         break; 
    105       default: 
    106         throw new FormatException("Unsupported bytes per pixel: " + bpp); 
    107     } 
    108  
     95    core[0].pixelType = FormatTools.pixelTypeFromBytes(bpp, false, bpp == 4); 
    10996    core[0].littleEndian = false; 
    11097    core[0].sizeZ = 1; 
  • trunk/components/bio-formats/src/loci/formats/in/VisitechReader.java

    r5548 r6118  
    189189            int bits = Integer.parseInt(value); 
    190190            while ((bits % 8) != 0) bits++; 
    191             switch (bits) { 
    192               case 16: 
    193                 core[0].pixelType = FormatTools.UINT16; 
    194                 break; 
    195               case 32: 
    196                 core[0].pixelType = FormatTools.UINT32; 
    197                 break; 
    198               default: 
    199                 core[0].pixelType = FormatTools.UINT8; 
    200             } 
     191            bits /= 8; 
     192            core[0].pixelType = 
     193              FormatTools.pixelTypeFromBytes(bits, false, false); 
    201194          } 
    202195          else if (key.equals("Image dimensions")) { 
Note: See TracChangeset for help on using the changeset viewer.