Changeset 2922


Ignore:
Timestamp:
06/29/07 13:03:59 (12 years ago)
Author:
melissa
Message:
  • Don't automatically populate OriginalMetadata nodes in OMEXMLMetadataStore. Instead, call populateOriginalMetadata(Hashtable).
  • Tweaked/fixed many readers
  • Fixed how test framework config files are parsed
Location:
trunk/loci/formats
Files:
38 edited

Legend:

Unmodified
Added
Removed
  • trunk/loci/formats/in/AliconaReader.java

    r2842 r2922  
    7575    } 
    7676 
    77     long offset = textureOffset; 
    78  
    7977    for (int i=0; i<numBytes; i++) { 
    80       in.seek(offset + (no * (core.sizeX[0] + pad)*core.sizeY[0]*(i+1))); 
     78      in.seek(textureOffset + (no * (core.sizeX[0] + pad)*core.sizeY[0]*(i+1))); 
    8179      for (int j=0; j<core.sizeX[0] * core.sizeY[0]; j++) { 
    82         buf[j*numBytes + i] = (byte) in.read(); 
     80        buf[j*numBytes + i] = (byte) (in.read() & 0xff); 
    8381        if (j % core.sizeX[0] == core.sizeX[0] - 1) in.skipBytes(pad); 
    8482      } 
     
    105103    // check that this is a valid AL3D file 
    106104    status("Verifying Alicona format"); 
    107     byte[] check = new byte[17]; 
    108     in.read(check); 
    109     String magicString = new String(check); 
     105    String magicString = in.readString(17); 
    110106    if (!magicString.trim().equals("AliconaImaging")) { 
    111107      throw new FormatException("Invalid magic string : " + 
     
    118114    status("Reading tags"); 
    119115 
    120     byte[] keyBytes = new byte[20]; 
    121     byte[] valueBytes = new byte[30]; 
    122  
    123116    int count = 2; 
    124117 
     
    128121 
    129122    for (int i=0; i<count; i++) { 
    130       in.read(keyBytes); 
    131       in.read(valueBytes); 
    132       in.skipBytes(2); 
    133  
    134       String key = new String(keyBytes); 
    135       String value = new String(valueBytes); 
     123      String key = in.readString(20); 
     124      String value = in.readString(30); 
    136125      key = key.trim(); 
    137126      value = value.trim(); 
    138127 
    139128      addMeta(key, value); 
     129      in.skipBytes(2); 
    140130 
    141131      if (key.equals("TagCount")) count += Integer.parseInt(value); 
  • trunk/loci/formats/in/BMPReader.java

    r2876 r2922  
    121121        for (int y=core.sizeY[0]-1; y>=0; y--) { 
    122122          for (int x=0; x<core.sizeX[0]; x++) { 
    123             buf[y*core.sizeX[0] + x] = (byte) in.read(); 
     123            buf[y*core.sizeX[0] + x] = (byte) (in.read() & 0xff); 
    124124          } 
    125125        } 
     
    129129          for (int x=0; x<core.sizeX[0]; x++) { 
    130130            int off = y*core.sizeX[0] + x;  
    131             buf[2*core.sizeX[0]*core.sizeY[0] + off] = (byte) in.read(); 
    132             buf[core.sizeX[0]*core.sizeY[0] + off] = (byte) in.read(); 
    133             buf[off] = (byte) in.read(); 
     131            buf[2*core.sizeX[0]*core.sizeY[0] + off] = (byte)(in.read() & 0xff); 
     132            buf[core.sizeX[0]*core.sizeY[0] + off] = (byte) (in.read() & 0xff); 
     133            buf[off] = (byte) (in.read() & 0xff); 
    134134          } 
    135           in.skipBytes(2);  
    136135        } 
    137136      } 
     
    161160    // read the first header - 14 bytes 
    162161 
    163     byte[] two = new byte[2]; 
    164     in.read(two); 
    165     addMeta("Magic identifier", new String(two)); 
     162    addMeta("Magic identifier", in.readString(2)); 
    166163 
    167164    addMeta("File size (in bytes)", "" + in.readInt()); 
     
    226223      for (int i=0; i<nColors; i++) { 
    227224        for (int j=palette.length; j>0; j--) { 
    228           palette[j][i] = (byte) in.read(); 
     225          palette[j][i] = (byte) (in.read() & 0xff); 
    229226        } 
    230227        in.read(); 
  • trunk/loci/formats/in/BaseTiffReader.java

    r2857 r2922  
    492492    core.rgb[0] = samples > 1 || p == TiffTools.RGB_PALETTE || 
    493493      p == TiffTools.CFA_ARRAY || p == TiffTools.RGB; 
    494     //core.interleaved[0] = TiffTools.getSamplesPerPixel(ifds[0]) > 1; 
    495494    core.interleaved[0] = true; 
    496495    core.littleEndian[0] = TiffTools.isLittleEndian(ifds[0]); 
     
    513512    else if (bitFormat == 2) { 
    514513      switch (bps) { 
    515         case 8: 
    516           core.pixelType[0] = FormatTools.UINT8; 
    517           break; 
    518514        case 16: 
    519515          core.pixelType[0] = FormatTools.INT16; 
     
    528524    else { 
    529525      switch (bps) { 
    530         case 8: 
    531           core.pixelType[0] = FormatTools.UINT8; 
    532           break; 
    533526        case 16: 
    534527          core.pixelType[0] = FormatTools.UINT16; 
  • trunk/loci/formats/in/BioRadReader.java

    r2802 r2922  
    146146    byteFormat = in.readShort() != 0; 
    147147    int imageNumber = in.readShort(); 
    148     byte[] s = new byte[32]; 
    149     in.read(s); 
    150     String name = new String(s); 
     148    String name = in.readString(32); 
    151149    int merged = in.readShort(); 
    152150    int color1 = in.readShort(); 
     
    220218      int x = in.readShort(); 
    221219      int y = in.readShort(); 
    222       s = new byte[80]; 
    223       in.read(s); 
    224       String text = new String(s); 
     220      String text = in.readString(80);  
    225221 
    226222      // be sure to remove binary data from the note text 
     
    765761    for (int i=0; i<core.sizeC[0]; i++) { 
    766762      store.setLogicalChannel(i, null, null, null, null, null, null, null); 
    767  
    768       double white = ramp1max; 
    769       double black = ramp1min; 
    770  
    771       store.setDisplayChannel(new Integer(i),  new Double(black), 
    772         new Double(white), null, null); 
     763      store.setDisplayChannel(new Integer(i), new Double(ramp1max), 
     764        new Double(ramp1min), null, null); 
    773765    } 
    774766    store.setDisplayOptions(zoom == null ? null : new Float(zoom), 
  • trunk/loci/formats/in/DeltavisionReader.java

    r2762 r2922  
    5151  private int bytesPerPixel; 
    5252 
    53   /** Offset where the ExtHdr starts. */ 
    54   protected int initExtHdrOffset = 1024; 
    55  
    5653  /** Size of one wave in the extended header. */ 
    5754  protected int wSize; 
     
    6461 
    6562  /** 
    66    * the Number of ints in each extended header section. These fields appear 
     63   * The number of ints in each extended header section. These fields appear 
    6764   * to be all blank but need to be skipped to get to the floats afterwards 
    6865   */ 
     
    8481  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
    8582  public boolean isThisType(byte[] block) { 
    86     return (DataTools.bytesToShort(block, 0, 2, core.littleEndian[0]) == 
    87       LITTLE_ENDIAN); 
     83    return false;  
    8884  } 
    8985 
     
    347343      new DVExtHdrFields[core.sizeZ[0]][core.sizeC[0]][core.sizeT[0]]; 
    348344 
     345    hstream.close(); 
     346 
    349347    store.setPixels(new Integer(core.sizeX[0]), new Integer(core.sizeY[0]), 
    350348      new Integer(core.sizeZ[0]), new Integer(core.sizeC[0]), 
     
    361359    // Run through every timeslice, for each wavelength, for each z section 
    362360    // and fill in the Extended Header information array for that image 
    363     for (int z = 0; z < core.sizeZ[0]; z++) { 
    364       for (int t = 0; t < core.sizeT[0]; t++) { 
    365         for (int w = 0; w < core.sizeC[0]; w++) { 
     361    for (int z=0; z<core.sizeZ[0]; z++) { 
     362      for (int t=0; t<core.sizeT[0]; t++) { 
     363        for (int w=0; w<core.sizeC[0]; w++) { 
    366364          extHdrFields[z][w][t] = new DVExtHdrFields(getTotalOffset(z, w, t), 
    367365            numIntsPerSection, extHeader, core.littleEndian[0]); 
     
    572570      byte[] extHeader, boolean little) 
    573571    { 
    574       // skip over the int values that have nothing in them 
    575       offsetWithInts = startingOffset + (numIntsPerSection * 4); 
    576  
    577       // DV files store the ND (neuatral density) Filter (normally expressed as 
    578       // a %T (transmittance)) as an OD (optical density) rating. 
    579       // To convert from one to the other the formula is %T = 10^(-OD) X 100. 
    580       oDFilter = Float.intBitsToFloat( 
    581         DataTools.bytesToInt(extHeader, offsetWithInts + 36, 4, little)); 
    582  
    583       // fill in the extended header information for the floats 
    584       photosensorReading = 
    585         Float.intBitsToFloat( 
    586           DataTools.bytesToInt(extHeader, offsetWithInts, 4, little)); 
    587       timeStampSeconds = 
    588         Float.intBitsToFloat( 
    589           DataTools.bytesToInt(extHeader, offsetWithInts + 4, 4, little)); 
    590       stageXCoord = 
    591         Float.intBitsToFloat( 
    592           DataTools.bytesToInt(extHeader, offsetWithInts + 8, 4, little)); 
    593       stageYCoord = 
    594         Float.intBitsToFloat( 
    595           DataTools.bytesToInt(extHeader, offsetWithInts + 12, 4, little)); 
    596       stageZCoord = 
    597         Float.intBitsToFloat( 
    598           DataTools.bytesToInt(extHeader, offsetWithInts + 16, 4, little)); 
    599       minInten = 
    600         Float.intBitsToFloat( 
    601           DataTools.bytesToInt(extHeader, offsetWithInts + 20, 4, little)); 
    602       maxInten = 
    603         Float.intBitsToFloat( 
    604           DataTools.bytesToInt(extHeader, offsetWithInts + 24, 4, little)); 
    605       meanInten = 
    606         Float.intBitsToFloat( 
    607           DataTools.bytesToInt(extHeader, offsetWithInts + 28, 4, little)); 
    608       expTime = 
    609         Float.intBitsToFloat( 
    610           DataTools.bytesToInt(extHeader, offsetWithInts + 32, 4, little)); 
    611       ndFilter = (float) Math.pow(10.0, -oDFilter); 
    612       exFilter = 
    613         Float.intBitsToFloat( 
    614           DataTools.bytesToInt(extHeader, offsetWithInts + 40, 4, little)); 
    615       emFilter = 
    616         Float.intBitsToFloat( 
    617           DataTools.bytesToInt(extHeader, offsetWithInts + 44, 4, little)); 
    618       exWavelen = 
    619         Float.intBitsToFloat( 
    620           DataTools.bytesToInt(extHeader, offsetWithInts + 48, 4, little)); 
    621       emWavelen = 
    622         Float.intBitsToFloat( 
    623           DataTools.bytesToInt(extHeader, offsetWithInts + 52, 4, little)); 
    624       intenScaling = 
    625         Float.intBitsToFloat( 
    626           DataTools.bytesToInt(extHeader, offsetWithInts + 56, 4, little)); 
    627       energyConvFactor = 
    628         Float.intBitsToFloat( 
    629           DataTools.bytesToInt(extHeader, offsetWithInts + 60, 4, little)); 
     572      try {  
     573        RandomAccessStream ext = new RandomAccessStream(extHeader);  
     574        ext.order(little);  
     575 
     576        // skip over the int values that have nothing in them 
     577        offsetWithInts = startingOffset + (numIntsPerSection * 4); 
     578 
     579        // DV files store the ND (neuatral density) Filter  
     580        // (normally expressed as a %T (transmittance)) as an OD  
     581        // (optical density) rating. 
     582        // To convert from one to the other the formula is %T = 10^(-OD) X 100. 
     583        ext.seek(offsetWithInts + 36); 
     584        oDFilter = ext.readFloat(); 
     585 
     586        // fill in the extended header information for the floats 
     587        ext.seek(offsetWithInts);  
     588        photosensorReading = ext.readFloat();  
     589        timeStampSeconds = ext.readFloat();  
     590        stageXCoord = ext.readFloat();  
     591        stageYCoord = ext.readFloat(); 
     592        stageZCoord = ext.readFloat(); 
     593        minInten = ext.readFloat();  
     594        maxInten = ext.readFloat();  
     595        meanInten = ext.readFloat(); 
     596        expTime = ext.readFloat();  
     597        ndFilter = (float) Math.pow(10.0, -oDFilter); 
     598        ext.skipBytes(4);  
     599      
     600        exFilter = ext.readFloat(); 
     601        emFilter = ext.readFloat(); 
     602        exWavelen = ext.readFloat();   
     603        emWavelen = ext.readFloat(); 
     604        intenScaling = ext.readFloat(); 
     605        energyConvFactor = ext.readFloat();  
     606      } 
     607      catch (IOException e) { 
     608        LogTools.trace(e); 
     609      } 
    630610    } 
    631611 
  • trunk/loci/formats/in/DicomReader.java

    r2905 r2922  
    9393  // "Digital Imaging and Communications in Medicine" is nasty long. 
    9494  public DicomReader() { 
    95     super("Digital Img. & Comm. in Med.", 
    96       new String[] {"dcm", "dicom"}); 
     95    super("Digital Img. & Comm. in Med.", new String[] {"dcm", "dicom"}); 
    9796  } 
    9897 
     
    154153    status("Verifying DICOM format"); 
    155154 
    156     byte[] four = new byte[4]; 
    157     long pos = 0; 
    158155    in.seek(128); 
    159     in.read(four); 
    160     if ((new String(four)).equals("DICM")) { 
     156    if (in.readString(4).equals("DICM")) { 
    161157      // header exists, so we'll read it 
    162       in.seek(pos); 
    163       byte[] header = new byte[128]; 
    164       in.read(header); 
    165       addMeta("Header information", new String(header)); 
     158      in.seek(0); 
     159      addMeta("Header information", in.readString(128)); 
    166160      in.readInt(); 
    167161      location = 128; 
    168162    } 
    169     else in.seek(pos); 
     163    else in.seek(0); 
    170164 
    171165    status("Reading tags"); 
     
    188182      switch (tag) { 
    189183        case TRANSFER_SYNTAX_UID: 
    190           byte[] st = new byte[elementLength]; 
    191           in.read(st); 
    192           s = new String(st); 
     184          s = in.readString(elementLength);  
    193185          addInfo(tag, s); 
    194186          if (s.indexOf("1.2.4") > -1 || s.indexOf("1.2.5") > -1) { 
     
    201193          break; 
    202194        case NUMBER_OF_FRAMES: 
    203           st = new byte[elementLength]; 
    204           in.read(st); 
    205           s = new String(st); 
     195          s = in.readString(elementLength); 
    206196          addInfo(tag, s); 
    207197          double frames = Double.parseDouble(s); 
     
    213203          break; 
    214204        case PHOTOMETRIC_INTERPRETATION: 
    215           st = new byte[elementLength]; 
    216           in.read(st); 
    217           String photoInterpretation = new String(st); 
    218           addInfo(tag, photoInterpretation); 
     205          addInfo(tag, in.readString(elementLength)); 
    219206          break; 
    220207        case PLANAR_CONFIGURATION: 
    221           int planarConfiguration = in.readShort(); 
    222           addInfo(tag, planarConfiguration); 
     208          addInfo(tag, in.readShort()); 
    223209          break; 
    224210        case ROWS: 
     
    231217          break; 
    232218        case PIXEL_SPACING: 
    233           st = new byte[elementLength]; 
    234           in.read(st); 
    235           String scale = new String(st); 
    236           addInfo(tag, scale); 
     219          addInfo(tag, in.readString(elementLength)); 
    237220          break; 
    238221        case SLICE_SPACING: 
    239           st = new byte[elementLength]; 
    240           in.read(st); 
    241           String spacing = new String(st); 
    242           addInfo(tag, spacing); 
     222          addInfo(tag, in.readString(elementLength)); 
    243223          break; 
    244224        case BITS_ALLOCATED: 
     
    247227          break; 
    248228        case PIXEL_REPRESENTATION: 
    249           int pixelRepresentation = in.readShort(); 
    250           addInfo(tag, pixelRepresentation); 
     229          addInfo(tag, in.readShort()); 
    251230          break; 
    252231        case WINDOW_CENTER: 
     
    254233        case RESCALE_INTERCEPT: 
    255234        case RESCALE_SLOPE: 
    256           st = new byte[elementLength]; 
    257           in.read(st); 
    258           String c = new String(st); 
    259           addInfo(tag, c); 
     235          addInfo(tag, in.readString(elementLength)); 
    260236          break; 
    261237        case PIXEL_DATA: 
     
    403379      case TM: 
    404380      case UI: 
    405         byte[] s = new byte[elementLength]; 
    406         in.read(s); 
    407         value = new String(s); 
     381        value = in.readString(elementLength); 
    408382        break; 
    409383      case US: 
     
    418392        break; 
    419393      case IMPLICIT_VR: 
    420         s = new byte[elementLength]; 
    421         in.read(s); 
    422         value = new String(s); 
     394        value = in.readString(elementLength); 
    423395        if (elementLength <= 4 || elementLength > 44) value = null; 
    424396        break; 
  • trunk/loci/formats/in/EPSReader.java

    r2857 r2922  
    8383      throw new FormatException("Invalid image number: " + no); 
    8484    } 
    85     if (buf.length < core.sizeX[0] * core.sizeY[0] * core.sizeC[0] * (bps / 8)) { 
     85    if (buf.length < core.sizeX[0] * core.sizeY[0] * core.sizeC[0] * (bps / 8)) 
     86    { 
    8687      throw new FormatException("Buffer too small."); 
    8788    } 
  • trunk/loci/formats/in/FitsReader.java

    r2805 r2922  
    9999    count = 1; 
    100100 
    101     byte[] b = new byte[80]; 
    102     in.read(b); 
    103     String line = new String(b); 
     101    String line = in.readString(80); 
    104102    if (!line.startsWith("SIMPLE")) { 
    105103      throw new FormatException("Unsupported FITS file."); 
     
    108106    while (true) { 
    109107      count++; 
    110       in.read(b); 
    111       line = new String(b); 
    112      
     108      line = in.readString(80);  
     109 
    113110      // parse key/value pair  
    114111      int ndx = line.indexOf("="); 
  • trunk/loci/formats/in/FluoviewReader.java

    r2687 r2922  
    2525package loci.formats.in; 
    2626 
     27import java.awt.image.BufferedImage; 
    2728import java.io.*; 
    2829import java.util.*; 
     
    5960  private float voxelX = 0f, voxelY = 0f, voxelZ = 0f, voxelC = 0f, voxelT = 0f; 
    6061 
     62  /** First image. */ 
     63  private BufferedImage zeroImage = null; 
     64 
    6165  // -- Constructor -- 
    6266 
    6367  /** Constructs a new Fluoview TIFF reader. */ 
    6468  public FluoviewReader() { 
    65     super("Olympus Fluoview/Andor Bio-imaging TIFF", 
    66       new String[] {"tif", "tiff"}); 
     69    super("Olympus Fluoview/ABD TIFF", new String[] {"tif", "tiff"}); 
    6770  } 
    6871 
     
    98101  } 
    99102 
     103  /* @see loci.formats.IFormatReader#openBytes(int) */ 
     104  public byte[] openBytes(int no) throws FormatException, IOException { 
     105    if (core.sizeY[0] == TiffTools.getImageLength(ifds[0])) { 
     106      return super.openBytes(no); 
     107    }  
     108    return openBytes(no, new byte[core.sizeX[0] *  
     109      FormatTools.getBytesPerPixel(core.pixelType[0])]);  
     110  } 
     111 
     112  /* @see loci.formats.IFormatReader#openBytes(int, byte[]) */ 
     113  public byte[] openBytes(int no, byte[] buf) 
     114    throws FormatException, IOException 
     115  { 
     116    if (core.sizeY[0] == TiffTools.getImageLength(ifds[0])) { 
     117      return super.openBytes(no, buf); 
     118    }  
     119    FormatTools.assertId(currentId, false, 1); 
     120    if (no < 0 || no >= core.imageCount[0]) { 
     121      throw new FormatException("Invalid image number: " + no); 
     122    }  
     123    if (buf.length < core.sizeX[0] *  
     124      FormatTools.getBytesPerPixel(core.pixelType[0]))  
     125    { 
     126      throw new FormatException("Buffer too small."); 
     127    } 
     128   
     129    byte[] b = super.openBytes(0); 
     130    System.arraycopy(b, 0, buf, 0, buf.length); 
     131    return buf; 
     132  } 
     133 
     134  /* @see loci.formats.IFormatReader#openImage(int) */ 
     135  public BufferedImage openImage(int no) throws FormatException, IOException { 
     136    if (core.sizeY[0] == TiffTools.getImageLength(ifds[0])) { 
     137      return super.openImage(no); 
     138    }  
     139     
     140    if (zeroImage == null) zeroImage = super.openImage(0); 
     141    return zeroImage.getSubimage(0, no, core.sizeX[0], 1);  
     142  } 
     143 
     144  /* @see loci.formats.IFormatReader#close() */ 
     145  public void close() throws IOException { 
     146    super.close(); 
     147    zeroImage = null; 
     148  } 
     149 
    100150  // -- IFormatHandler API methods -- 
    101151 
     
    138188    put("Image Type", (char) ras.read()); 
    139189 
    140     byte[] nameBytes = new byte[257]; 
    141     ras.read(nameBytes); 
    142     put("Image name", new String(nameBytes)); 
     190    put("Image name", ras.readString(257)); 
    143191 
    144192    ras.skipBytes(4); // skip pointer to data field 
     
    152200 
    153201    // read dimension information 
    154     byte[] dimNameBytes = new byte[16]; 
    155     byte[] dimCalibrationUnits = new byte[64]; 
    156202    String[] names = new String[10]; 
    157203    int[] sizes = new int[10]; 
    158204    double[] resolutions = new double[10]; 
    159205    for (int i=0; i<10; i++) { 
    160       ras.read(dimNameBytes); 
    161       names[i] = new String(dimNameBytes); 
     206      names[i] = ras.readString(16); 
    162207      sizes[i] = ras.readInt(); 
    163208      double origin = ras.readDouble(); 
    164209      resolutions[i] = ras.readDouble(); 
    165       ras.read(dimCalibrationUnits); 
    166210 
    167211      put("Dimension " + (i+1) + " Name", names[i]); 
     
    169213      put("Dimension " + (i+1) + " Origin", origin); 
    170214      put("Dimension " + (i+1) + " Resolution", resolutions[i]); 
    171       put("Dimension " + (i+1) + " Units", new String(dimCalibrationUnits)); 
     215      put("Dimension " + (i+1) + " Units", ras.readString(64)); 
    172216    } 
    173217 
     
    186230 
    187231    // read gray channel data 
    188     ras.read(dimNameBytes); 
    189     put("Gray Channel Name", new String(dimNameBytes)); 
     232    put("Gray Channel Name", ras.readString(16)); 
    190233    put("Gray Channel Size", ras.readInt()); 
    191234    put("Gray Channel Origin", ras.readDouble()); 
    192235    put("Gray Channel Resolution", ras.readDouble()); 
    193     ras.read(dimCalibrationUnits); 
    194     put("Gray Channel Units", new String(dimCalibrationUnits)); 
     236    put("Gray Channel Units", ras.readString(64)); 
    195237 
    196238    ras.skipBytes(4); // skip pointer to thumbnail data 
     
    267309    core.imageCount[0] = ifds.length; 
    268310 
     311    if (core.imageCount[0] == 1 && (core.sizeT[0] == core.sizeY[0] ||  
     312      core.sizeZ[0] == core.sizeY[0]) && (core.sizeT[0] > core.imageCount[0] || 
     313      core.sizeZ[0] > core.imageCount[0]))  
     314    { 
     315      core.sizeY[0] = 1; 
     316      core.imageCount[0] = core.sizeZ[0] * core.sizeT[0] * core.sizeC[0]; 
     317    }  
     318     
    269319    // cut up the comment, if necessary 
    270320    String comment = (String) getMeta("Comment"); 
  • trunk/loci/formats/in/GIFReader.java

    r2701 r2922  
    2525package loci.formats.in; 
    2626 
    27 import java.awt.Rectangle; 
    2827import java.awt.image.BufferedImage; 
    2928import java.io.*; 
     
    4039  // -- Constants -- 
    4140 
    42   /** Status codes. */ 
    43   private static final int STATUS_OK = 0; 
    44   private static final int STATUS_FORMAT_ERROR = 1; 
    45   private static final int STATUS_OPEN_ERROR = 2; 
    46  
    4741  /** Maximum buffer size. */ 
    4842  private static final int MAX_STACK_SIZE = 4096; 
     
    5044  // -- Fields -- 
    5145 
    52   private int status; 
    53  
    5446  /** Global color table used. */ 
    5547  private boolean gctFlag; 
     
    5850  private int gctSize; 
    5951 
    60   /** Iterations; 0 = repeat forever. */ 
    61   private int loopCount; 
    62  
    6352  /** Global color table. */ 
    6453  private int[] gct; 
     
    7665  private int bgColor; 
    7766 
    78   /** Previous bg color. */ 
    79   private int lastBgColor; 
    80  
    81   /** Pixel aspect ratio. */ 
    82   private int pixelAspect; 
    83  
    8467  /** Local color table flag. */ 
    8568  private boolean lctFlag; 
     
    9477  private int ix, iy, iw, ih; 
    9578 
    96   /** Last image rectangle. */ 
    97   private Rectangle lastRect; 
    98  
    9979  /** Current data block. */ 
    10080  private byte[] dBlock = new byte[256]; 
     
    10888  /** Use transparent color. */ 
    10989  private boolean transparency = false; 
    110  
    111   /** Delay in ms. */ 
    112   private int delay = 0; 
    11390 
    11491  /** Transparent color index. */ 
     
    127104  /** Constructs a new GIF reader. */ 
    128105  public GIFReader() { 
    129     super("Graphics Interchange Format (GIF)", "gif"); 
     106    super("Graphics Interchange Format", "gif"); 
    130107  } 
    131108 
     
    155132 
    156133    int[] ints = (int[]) images.get(no); 
     134    if (no > 0) { 
     135      int[] prev = (int[]) images.get(no - 1);  
     136      for (int i=0; i<ints.length; i++) { 
     137        if ((ints[i] & 0x00ffffff) == 0) { 
     138          ints[i] = prev[i]; 
     139        } 
     140      } 
     141      images.setElementAt(ints, no);  
     142    } 
    157143 
    158144    for (int i=0; i<ints.length; i++) { 
     
    183169    status("Verifying GIF format"); 
    184170 
    185     status = STATUS_OK; 
    186171    in = new RandomAccessStream(id); 
     172    in.order(true); 
    187173    images = new Vector(); 
    188174 
    189     byte[] buf = new byte[6]; 
    190     in.read(buf); 
    191     String ident = new String(buf); 
     175    String ident = in.readString(6); 
    192176 
    193177    if (!ident.startsWith("GIF")) { 
     
    197181    status("Reading dimensions"); 
    198182 
    199     core.sizeX[0] = DataTools.read2UnsignedBytes(in, true); 
    200     core.sizeY[0] = DataTools.read2UnsignedBytes(in, true); 
    201  
    202     int packed = DataTools.readUnsignedByte(in); 
     183    core.sizeX[0] = in.readShort(); 
     184    core.sizeY[0] = in.readShort(); 
     185 
     186    int packed = in.read() & 0xff; 
    203187    gctFlag = (packed & 0x80) != 0; 
    204188    gctSize = 2 << (packed & 7); 
    205     bgIndex = DataTools.readUnsignedByte(in); 
    206     pixelAspect = DataTools.readUnsignedByte(in); 
     189    bgIndex = in.read() & 0xff; 
     190    in.skipBytes(1);  
    207191 
    208192    if (gctFlag) { 
    209193      int nbytes = 3 * gctSize; 
    210194      byte[] c = new byte[nbytes]; 
    211       int n = in.read(c); 
     195      in.read(c); 
    212196 
    213197      gct = new int[256]; 
     
    229213    boolean done = false; 
    230214    while (!done) { 
    231       int code = DataTools.readUnsignedByte(in); 
     215      int code = in.read() & 0xff; 
    232216      switch (code) { 
    233217        case 0x2c: // image separator: 
    234           ix = DataTools.read2UnsignedBytes(in, true); 
    235           iy = DataTools.read2UnsignedBytes(in, true); 
    236           iw = DataTools.read2UnsignedBytes(in, true); 
    237           ih = DataTools.read2UnsignedBytes(in, true); 
    238  
    239           packed = DataTools.readUnsignedByte(in); 
     218          ix = in.readShort(); 
     219          iy = in.readShort(); 
     220          iw = in.readShort(); 
     221          ih = in.readShort(); 
     222           
     223          packed = in.read(); 
    240224          lctFlag = (packed & 0x80) != 0; 
    241225          interlace = (packed & 0x40) != 0; 
     
    290274 
    291275          lastDispose = dispose; 
    292           lastRect = new Rectangle(ix, iy, iw, ih); 
    293           lastBgColor = bgColor; 
    294276          lct = null; 
    295277 
    296278          break; 
    297279        case 0x21: // extension 
    298           code = DataTools.readUnsignedByte(in); 
     280          code = in.read() & 0xff; 
    299281          switch (code) { 
    300282            case 0xf9: // graphics control extension 
    301               in.read(); 
    302               packed = DataTools.readUnsignedByte(in); 
     283              in.skipBytes(1);  
     284              packed = in.read() & 0xff; 
    303285              dispose = (packed & 0x1c) >> 1; 
    304286              transparency = (packed & 1) != 0; 
    305               delay = DataTools.read2UnsignedBytes(in, true) * 10; 
    306               transIndex = DataTools.readUnsignedByte(in); 
    307               in.read(); 
     287              in.skipBytes(2);  
     288              transIndex = in.read() & 0xff; 
     289              in.skipBytes(1);  
    308290              break; 
    309291            case 0xff:  // application extension 
     
    320302                    int b1 = ((int) dBlock[1]) & 0xff; 
    321303                    int b2 = ((int) dBlock[2]) & 0xff; 
    322                     loopCount = (b2 << 8) | b1; 
    323304                  } 
    324305                } 
     
    381362  private int readBlock() throws IOException { 
    382363    if (in.getFilePointer() == in.length()) return -1; 
    383     blockSize = DataTools.readUnsignedByte(in); 
     364    blockSize = in.read() & 0xff; 
    384365    int n = 0; 
    385366    int count; 
     
    413394 
    414395    // initialize GIF data stream decoder 
    415  
    416     dataSize = DataTools.readUnsignedByte(in); 
     396     
     397    dataSize = in.read() & 0xff; 
    417398 
    418399    clear = 1 << dataSize; 
     
    422403    codeSize = dataSize + 1; 
    423404    codeMask = (1 << codeSize) - 1; 
    424     for (code=0; code < clear; code++) { 
     405    for (code=0; code<clear; code++) { 
    425406      prefix[code] = 0; 
    426407      suffix[code] = (byte) code; 
  • trunk/loci/formats/in/GatanReader.java

    r2701 r2922  
    3737public class GatanReader extends FormatReader { 
    3838 
    39   // -- Constants -- 
    40  
    41   private static final byte[] GATAN_MAGIC_BLOCK_1 = {0, 0, 0, 3}; 
    42  
    4339  // -- Fields -- 
    4440 
     
    6359  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
    6460  public boolean isThisType(byte[] block) { 
    65     if (block == null) return false; 
    66     if (block.length != GATAN_MAGIC_BLOCK_1.length) return false; 
    67     for (int i=0; i<block.length; i++) { 
    68       if (block[i] != GATAN_MAGIC_BLOCK_1[i]) return false; 
    69     } 
    70     return true; 
     61    if (block == null || block.length < 4) return false; 
     62    return DataTools.bytesToInt(block, false) == 3;  
    7163  } 
    7264 
     
    9789  /* @see loci.formats.IFormatReader#openImage(int) */ 
    9890  public BufferedImage openImage(int no) throws FormatException, IOException { 
    99     FormatTools.assertId(currentId, true, 1); 
    100     if (no < 0 || no >= getImageCount()) { 
    101       throw new FormatException("Invalid image number: " + no); 
    102     } 
    103  
    10491    return ImageTools.makeImage(openBytes(no), core.sizeX[0], core.sizeY[0], 
    10592      1, false, bytesPerPixel, core.littleEndian[0]); 
     
    120107    pixelSizes = new Vector(); 
    121108 
    122     byte[] tmp = new byte[4]; 
    123     in.read(tmp); 
     109    in.order(false); 
     110 
    124111    // only support version 3 
    125     if (!isThisType(tmp)) { 
     112    if (in.readInt() != 3) { 
    126113      throw new FormatException("invalid header"); 
    127114    } 
     
    130117 
    131118    in.skipBytes(4); 
    132     in.read(tmp); 
    133     core.littleEndian[0] = DataTools.bytesToInt(tmp, core.littleEndian[0]) == 1; 
     119    core.littleEndian[0] = in.readInt() == 1; 
    134120 
    135121    // TagGroup instance 
    136122 
    137123    in.skipBytes(2); 
    138     in.read(tmp); 
    139     parseTags(DataTools.bytesToInt(tmp, !core.littleEndian[0]), "initFile"); 
     124    in.order(!core.littleEndian[0]); 
     125    parseTags(in.readInt(), "initFile"); 
    140126 
    141127    status("Populating metadata"); 
     
    143129    switch (datatype) { 
    144130      case 1: 
     131      case 10: 
    145132        core.pixelType[0] = FormatTools.UINT16; 
    146133        break; 
    147134      case 2: 
    148         core.pixelType[0] = FormatTools.FLOAT; 
    149         break; 
    150135      case 3: 
    151         core.pixelType[0] = FormatTools.FLOAT; 
    152         break; 
    153       // there is no case 4 
    154136      case 5: 
    155         core.pixelType[0] = FormatTools.FLOAT; 
    156         break; 
    157       case 6: 
    158         core.pixelType[0] = FormatTools.UINT8; 
    159         break; 
    160       case 7: 
    161         core.pixelType[0] = FormatTools.INT32; 
    162         break; 
    163       case 8: 
    164         core.pixelType[0] = FormatTools.UINT32; 
    165         break; 
    166       case 9: 
    167         core.pixelType[0] = FormatTools.INT8; 
    168         break; 
    169       case 10: 
    170         core.pixelType[0] = FormatTools.UINT16; 
    171         break; 
    172       case 11: 
    173         core.pixelType[0] = FormatTools.UINT32; 
    174         break; 
    175137      case 12: 
    176         core.pixelType[0] = FormatTools.FLOAT; 
    177         break; 
    178138      case 13: 
    179139        core.pixelType[0] = FormatTools.FLOAT; 
    180140        break; 
    181       case 14: 
    182         core.pixelType[0] = FormatTools.UINT8; 
    183         break; 
     141      case 7: 
     142      case 8: 
     143      case 11: 
    184144      case 23: 
    185         core.pixelType[0] = FormatTools.INT32; 
     145        core.pixelType[0] = FormatTools.UINT32; 
    186146        break; 
    187147      default: 
    188         core.pixelType[0] = FormatTools.INT8; 
     148        core.pixelType[0] = FormatTools.UINT8; 
    189149    } 
    190150 
     
    212172      null); // Use pixels index 0 
    213173 
    214     Float pixX = null; 
    215     Float pixY = null; 
    216     Float pixZ = null; 
     174    Float pixX = new Float(1); 
     175    Float pixY = new Float(1); 
     176    Float pixZ = new Float(1); 
    217177 
    218178    if (pixelSizes.size() > 0) { 
    219179      pixX = new Float((String) pixelSizes.get(0)); 
    220180    } 
    221     else pixX = new Float(1); 
    222181 
    223182    if (pixelSizes.size() > 1) { 
    224183      pixY = new Float((String) pixelSizes.get(1)); 
    225184    } 
    226     else pixY = new Float(1); 
    227185 
    228186    if (pixelSizes.size() > 2) { 
    229187      pixZ = new Float((String) pixelSizes.get(2)); 
    230188    } 
    231     else pixZ = new Float(1); 
    232189 
    233190    store.setDimensions(pixX, pixY, pixZ, null, null, null); 
     
    254211   */ 
    255212  private void parseTags(int numTags, String parent) throws IOException { 
    256     byte[] temp = new byte[4]; 
    257213    for (int i=0; i<numTags; i++) { 
    258214      byte type = in.readByte();  // can be 21 (data) or 20 (tag group) 
    259       byte[] twobytes = new byte[2]; 
    260       in.read(twobytes); 
    261       int length = DataTools.bytesToInt(twobytes, !core.littleEndian[0]); 
    262       byte[] label = new byte[length]; 
    263       in.read(label); 
    264       String labelString = new String(label); 
     215      int length = in.readShort();  
     216      String labelString = in.readString(length); 
    265217 
    266218      // image data is in tag with type 21 and label 'Data' 
     
    270222      if (type == 21) { 
    271223        in.skipBytes(4);  // equal to '%%%%' 
    272         in.read(temp); 
    273         int n = DataTools.bytesToInt(temp, !core.littleEndian[0]); 
     224        int n = in.readInt();  
    274225        int dataType = 0; 
    275226        if (n == 1) { 
    276           in.read(temp); 
    277           dataType = DataTools.bytesToInt(temp, !core.littleEndian[0]); 
     227          dataType = in.readInt();  
    278228          String data; 
     229          in.order(core.littleEndian[0]);  
    279230          switch (dataType) { 
    280231            case 2: 
    281               data = "" + DataTools.read2SignedBytes(in, core.littleEndian[0]); 
     232            case 4:  
     233              data = "" + in.readShort(); 
    282234              break; 
    283235            case 3: 
    284               data = "" + DataTools.read4SignedBytes(in, core.littleEndian[0]); 
    285               break; 
    286             case 4: 
    287               data = 
    288                 "" + DataTools.read2UnsignedBytes(in, core.littleEndian[0]); 
    289               break; 
    290             case 5: 
    291               data = 
    292                 "" + DataTools.read4UnsignedBytes(in, core.littleEndian[0]); 
     236            case 5:   
     237              data = "" + in.readInt(); 
    293238              break; 
    294239            case 6: 
    295               data = "" + DataTools.readFloat(in, core.littleEndian[0]); 
     240              data = "" + in.readFloat(); 
    296241              break; 
    297242            case 7: 
    298               data = "" + DataTools.readFloat(in, core.littleEndian[0]); 
     243              data = "" + in.readFloat(); 
    299244              in.skipBytes(4); 
    300245              break; 
    301246            case 8: 
    302               data = "" + DataTools.readSignedByte(in); 
    303               break; 
    304247            case 9: 
    305               data = "" + DataTools.readSignedByte(in); 
    306               break; 
    307248            case 10: 
    308               data = "" + DataTools.readSignedByte(in); 
     249              data = "" + in.read(); 
    309250              break; 
    310251            default: 
     
    325266          addMeta(labelString, data); 
    326267          if (labelString.equals("DataType")) datatype = Integer.parseInt(data); 
     268          in.order(!core.littleEndian[0]);  
    327269        } 
    328270        else if (n == 2) { 
    329           in.read(temp); 
    330           dataType = DataTools.bytesToInt(temp, core.littleEndian[0]); 
     271          in.order(core.littleEndian[0]); 
     272          dataType = in.readInt(); 
    331273          if (dataType == 18) { // this should always be true 
    332             in.read(temp); 
    333             length = DataTools.bytesToInt(temp, core.littleEndian[0]); 
    334           } 
    335           byte[] data = new byte[length]; 
    336           in.read(data); 
    337           addMeta(labelString, new String(label)); 
     274            length = in.readInt();  
     275          } 
     276          addMeta(labelString, in.readString(length)); 
     277          in.order(!core.littleEndian[0]);  
    338278        } 
    339279        else if (n == 3) { 
    340           in.read(temp); 
    341           dataType = DataTools.bytesToInt(temp, !core.littleEndian[0]); 
     280          dataType = in.readInt(); 
    342281          if (dataType == 20) { // this should always be true 
    343             in.read(temp); 
    344             dataType = DataTools.bytesToInt(temp, !core.littleEndian[0]); 
    345             in.read(temp); 
    346             length = DataTools.bytesToInt(temp, !core.littleEndian[0]); 
     282            dataType = in.readInt();  
     283            length = in.readInt();  
    347284 
    348285            if ("Data".equals(labelString)) pixelDataNum++; 
     
    365302                check = in.readByte(); 
    366303              } 
    367               in.seek((int) (pos + bpp * length)); 
     304              in.seek((long) (pos + bpp * length)); 
    368305            } 
    369306            else { 
     
    371308              for (int j=0; j<length; j++) { 
    372309                if (dataType == 2 || dataType == 4) { 
    373                   byte[] two = new byte[2]; 
    374                   in.read(two); 
    375                   data[j] = (int) DataTools.bytesToShort(two, 
    376                     !core.littleEndian[0]); 
     310                  data[j] = in.readShort(); 
    377311                } 
    378312                else if (dataType == 7) in.skipBytes(8); 
    379313                else if (dataType == 8 || dataType == 9) in.skipBytes(1); 
    380314                else { 
    381                   in.read(temp); 
    382                   data[j] = DataTools.bytesToInt(temp, !core.littleEndian[0]); 
     315                  data[j] = in.readInt(); 
    383316                } 
    384317              } 
     
    387320        } 
    388321        else { 
    389           in.read(temp); 
    390           dataType = DataTools.bytesToInt(temp, !core.littleEndian[0]); 
     322          dataType = in.readInt(); 
    391323          // this is a normal struct of simple types 
    392324          if (dataType == 15) { 
    393             int skip = 0; 
    394             in.read(temp); 
    395             skip += DataTools.bytesToInt(temp, !core.littleEndian[0]); 
    396             in.read(temp); 
    397             int numFields = DataTools.bytesToInt(temp, !core.littleEndian[0]); 
     325            int skip = in.readInt(); 
     326            int numFields = in.readInt();  
    398327            for (int j=0; j<numFields; j++) { 
    399               in.read(temp); 
    400               skip += DataTools.bytesToInt(temp, !core.littleEndian[0]); 
    401               in.read(temp); 
    402               dataType = DataTools.bytesToInt(temp, !core.littleEndian[0]); 
     328              skip += in.readInt();  
     329              dataType = in.readInt();  
    403330 
    404331              switch (dataType) { 
    405332                case 2: 
     333                case 4: 
    406334                  skip += 2; 
    407335                  break; 
    408336                case 3: 
    409                   skip += 4; 
    410                   break; 
    411                 case 4: 
    412                   skip += 2; 
    413                   break; 
    414337                case 5: 
    415                   skip += 4; 
    416                   break; 
    417338                case 6: 
    418339                  skip += 4; 
     
    422343                  break; 
    423344                case 8: 
    424                   skip += 1; 
    425                   break; 
    426345                case 9: 
    427346                  skip += 1; 
     
    434353            // this is an array of structs 
    435354            int skip = 0; 
    436             in.read(temp); 
    437             dataType = DataTools.bytesToInt(temp, !core.littleEndian[0]); 
     355            dataType = in.readInt(); 
    438356            if (dataType == 15) { // should always be true 
    439               in.read(temp); 
    440               skip += DataTools.bytesToInt(temp, !core.littleEndian[0]); 
    441               in.read(temp); 
    442               int numFields = DataTools.bytesToInt(temp, !core.littleEndian[0]); 
     357              skip += in.readInt();  
     358              int numFields = in.readInt();  
    443359              for (int j=0; j<numFields; j++) { 
    444                 in.read(temp); 
    445                 skip += DataTools.bytesToInt(temp, !core.littleEndian[0]); 
    446                 in.read(temp); 
    447                 dataType = DataTools.bytesToInt(temp, !core.littleEndian[0]); 
     360                skip += in.readInt();  
     361                dataType = in.readInt();  
    448362 
    449363                switch (dataType) { 
    450364                  case 2: 
     365                  case 4:   
    451366                    skip += 2; 
    452367                    break; 
    453368                  case 3: 
    454                     skip += 4; 
    455                     break; 
    456                   case 4: 
    457                     skip += 2; 
    458                     break; 
    459369                  case 5: 
    460                     skip += 4; 
    461                     break; 
    462370                  case 6: 
    463371                    skip += 4; 
     
    467375                    break; 
    468376                  case 8: 
    469                     skip += 1; 
    470                     break; 
    471377                  case 9: 
    472378                    skip += 1; 
     
    475381              } 
    476382            } 
    477             in.read(temp); 
    478             skip *= DataTools.bytesToInt(temp, !core.littleEndian[0]); 
     383            skip *= in.readInt(); 
    479384            in.skipBytes(skip); 
    480385          } 
     
    483388      else if (type == 20) { 
    484389        in.skipBytes(2); 
    485         in.read(temp); 
    486         parseTags(DataTools.bytesToInt(temp, !core.littleEndian[0]), 
    487           labelString); 
     390        parseTags(in.readInt(), labelString);  
    488391      } 
    489392    } 
  • trunk/loci/formats/in/ICSReader.java

    r2800 r2922  
    159159    if (bytes == 4) { 
    160160      float[] f = new float[core.sizeX[0] * core.sizeY[0] * channels]; 
    161       int pt = 0; 
    162161      for (int i=0; i<f.length; i++) { 
    163162        int p = DataTools.bytesToInt(plane, i*4, 4, core.littleEndian[0]); 
     
    256255    StringTokenizer t; 
    257256    String token; 
    258     b = new byte[(int) reader.length()]; 
    259     reader.read(b); 
     257    String s = reader.readString((int) reader.length()); 
    260258    reader.close(); 
    261     String s = new String(b); 
    262259    StringTokenizer st = new StringTokenizer(s, "\n"); 
    263260    String line = st.nextToken(); 
  • trunk/loci/formats/in/IPLabReader.java

    r2701 r2922  
    6868  /* @see loci.formats.IFormatReader#openBytes(int) */ 
    6969  public byte[] openBytes(int no) throws FormatException, IOException { 
    70     FormatTools.assertId(currentId, true, 1); 
    7170    byte[] buf = new byte[core.sizeX[0] * core.sizeY[0] * bps * core.sizeC[0]]; 
    7271    return openBytes(no, buf); 
     
    9493  /* @see loci.formats.IFormatReader#openImage(int) */ 
    9594  public BufferedImage openImage(int no) throws FormatException, IOException { 
    96     FormatTools.assertId(currentId, true, 1); 
    9795    return ImageTools.makeImage(openBytes(no), core.sizeX[0], core.sizeY[0], 
    9896      core.rgb[0] ? core.sizeC[0] : 1, false, bps, core.littleEndian[0]); 
     
    109107    status("Populating metadata"); 
    110108 
    111     byte[] fourBytes = new byte[4]; 
    112     in.read(fourBytes); 
    113     core.littleEndian[0] = new String(fourBytes).equals("iiii"); 
     109    core.littleEndian[0] = in.readString(4).equals("iiii"); 
    114110 
    115111    in.order(core.littleEndian[0]); 
     
    144140      case 1: 
    145141        ptype = "16 bit signed short"; 
    146         core.pixelType[0] = FormatTools.INT16; 
     142        core.pixelType[0] = FormatTools.UINT16; 
    147143        bps = 2; 
    148144        break; 
     
    154150      case 3: 
    155151        ptype = "32 bit signed long"; 
    156         core.pixelType[0] = FormatTools.INT32; 
     152        core.pixelType[0] = FormatTools.UINT32; 
    157153        bps = 4; 
    158154        break; 
     
    164160      case 5: 
    165161        ptype = "Color24"; 
    166         core.pixelType[0] = FormatTools.INT32; 
     162        core.pixelType[0] = FormatTools.UINT32; 
    167163        bps = 1; 
    168164        break; 
    169165      case 6: 
    170166        ptype = "Color48"; 
    171         core.pixelType[0] = FormatTools.INT32; 
     167        core.pixelType[0] = FormatTools.UINT32; 
    172168        bps = 2; 
    173169        break; 
     
    212208    status("Reading tags"); 
    213209 
    214     in.read(fourBytes); 
    215     String tag = new String(fourBytes); 
     210    String tag = in.readString(4); 
    216211    while (!tag.equals("fini") && in.getFilePointer() < in.length() - 4) { 
    217212      if (tag.equals("clut")) { 
     
    220215        if (size == 8) { 
    221216          // indexed lookup table 
    222           in.readInt(); 
     217          in.skipBytes(4);  
    223218          int type = in.readInt(); 
    224219 
    225           String clutType = "unknown"; 
    226           switch ((int) type) { 
    227             case 0: 
    228               clutType = "monochrome"; 
    229               break; 
    230             case 1: 
    231               clutType = "reverse monochrome"; 
    232               break; 
    233             case 2: 
    234               clutType = "BGR"; 
    235               break; 
    236             case 3: 
    237               clutType = "classify"; 
    238               break; 
    239             case 4: 
    240               clutType = "rainbow"; 
    241               break; 
    242             case 5: 
    243               clutType = "red"; 
    244               break; 
    245             case 6: 
    246               clutType = "green"; 
    247               break; 
    248             case 7: 
    249               clutType = "blue"; 
    250               break; 
    251             case 8: 
    252               clutType = "cyan"; 
    253               break; 
    254             case 9: 
    255               clutType = "magenta"; 
    256               break; 
    257             case 10: 
    258               clutType = "yellow"; 
    259               break; 
    260             case 11: 
    261               clutType = "saturated pixels"; 
    262               break; 
    263           } 
     220          String[] types = new String[] { 
     221            "monochrome", "reverse monochrome", "BGR", "classify", "rainbow", 
     222            "red", "green", "blue", "cyan", "magenta", "yellow",  
     223            "saturated pixels" 
     224          }; 
     225          String clutType = (type >= 0 && type < types.length) ? types[type] : 
     226            "unknown"; 
    264227          addMeta("LUT type", clutType); 
    265228        } 
     
    267230          // explicitly defined lookup table 
    268231          // length is 772 
    269           in.readInt(); 
    270           byte[] colorTable = new byte[256*3]; 
    271           in.read(colorTable); 
     232          in.skipBytes(4 + 256 * 3); 
    272233        } 
    273234      } 
     
    283244 
    284245        for (int i=0; i<core.sizeC[0]; i++) { 
    285           long source = in.readInt(); 
    286  
    287           String sourceType; 
    288           switch ((int) source) { 
    289             case 0: 
    290               sourceType = "user"; 
    291               break; 
    292             case 1: 
    293               sourceType = "plane"; 
    294               break; 
    295             case 2: 
    296               sourceType = "sequence"; 
    297               break; 
    298             case 3: 
    299               sourceType = "saturated plane"; 
    300               break; 
    301             case 4: 
    302               sourceType = "saturated sequence"; 
    303               break; 
    304             case 5: 
    305               sourceType = "ROI"; 
    306               break; 
    307             default: 
    308               sourceType = "user"; 
    309           } 
     246          int source = in.readInt(); 
     247          String[] types = new String[] { 
     248            "user", "plane", "sequence", "saturated plane",  
     249            "saturated sequence", "ROI" 
     250          }; 
     251 
     252          String sourceType = (source >= 0 && source < types.length) ?  
     253            types[source] : "user"; 
    310254          addMeta("NormalizationSource" + i, sourceType); 
    311255 
     
    335279        int size = in.readInt(); 
    336280 
    337         byte[] headerString = new byte[20]; 
    338         for (int i=0; i<size / (headerString.length + 2); i++) { 
     281        for (int i=0; i<size / 22; i++) { 
    339282          int num = in.readShort(); 
    340           in.read(headerString); 
    341           String name = new String(fourBytes); 
     283          String name = in.readString(20); 
    342284          addMeta("Header" + num, name); 
    343285        } 
     
    356298        int numRoiPts = in.readInt(); 
    357299 
    358         Integer x0 = new Integer((int) roiLeft); 
    359         Integer x1 = new Integer((int) roiRight); 
    360         Integer y0 = new Integer((int) roiBottom); 
    361         Integer y1 = new Integer((int) roiTop); 
     300        Integer x0 = new Integer(roiLeft); 
     301        Integer x1 = new Integer(roiRight); 
     302        Integer y0 = new Integer(roiBottom); 
     303        Integer y1 = new Integer(roiTop); 
    362304        store.setDisplayROI( 
    363305          x0, y0, null, x1, y1, null, null, null, null, null); 
     
    367309      else if (tag.equals("mask")) { 
    368310        // read in Segmentation Mask 
    369         int size = in.readInt(); 
    370         in.skipBytes(size); 
     311        in.skipBytes(in.readInt()); 
    371312      } 
    372313      else if (tag.equals("unit")) { 
    373314        // read in units 
    374         in.readInt(); // size is 48 
     315        in.skipBytes(4);  
    375316 
    376317        for (int i=0; i<4; i++) { 
     
    402343        // read in notes (image info) 
    403344        in.readInt(); // size is 576 
    404         byte[] temp = new byte[64]; 
    405         in.read(temp); 
    406         String descriptor = new String(temp); 
    407         temp = new byte[512]; 
    408         in.read(temp); 
    409         String notes = new String(temp); 
     345        String descriptor = in.readString(64); 
     346        String notes = in.readString(512); 
    410347        addMeta("Descriptor", descriptor); 
    411348        addMeta("Notes", notes); 
     
    415352 
    416353      if (in.getFilePointer() + 4 <= in.length()) { 
    417         in.read(fourBytes); 
    418         tag = new String(fourBytes); 
     354        tag = in.readString(4); 
    419355      } 
    420356      else { 
  • trunk/loci/formats/in/IPWReader.java

    r2857 r2922  
    144144  /* @see loci.formats.IFormatReader#openImage(int) */ 
    145145  public BufferedImage openImage(int no) throws FormatException, IOException { 
    146     FormatTools.assertId(currentId, true, 1); 
    147     if (no < 0 || no >= getImageCount()) { 
    148       throw new FormatException("Invalid image number: " + no); 
    149     } 
    150  
    151146    byte[] b = openBytes(no); 
    152147    int bytes = b.length / (core.sizeX[0] * core.sizeY[0]); 
     
    291286    } 
    292287 
    293     // TODO : look into removing this logic, as it appears to be copied directly 
    294     // from BaseTiffReader 
    295  
    296288    int bitsPerSample = TiffTools.getIFDIntValue(ifds[0], 
    297289      TiffTools.BITS_PER_SAMPLE); 
     
    374366      if (debug) trace(t); 
    375367    } 
     368   
     369    core.interleaved[0] = true;  
    376370  } 
    377371 
     
    408402        r.exec("dis.read(data)"); 
    409403 
     404        RandomAccessStream ds = new RandomAccessStream(data); 
     405        ds.order(true); 
     406 
    410407        String entryName = (String) r.getVar("entryName"); 
    411408        String dirName = (String) r.getVar("dirName"); 
     
    420417          // should always be exactly 4 bytes 
    421418          // only exists if the file has more than one image 
    422           addMeta("Frame Rate", new Long(DataTools.bytesToInt(data, true))); 
     419          addMeta("Frame Rate", new Long(ds.readInt())); 
    423420        } 
    424421        else if (entryName.equals("FrameInfo")) { 
    425422          // should always be 16 bytes (if present) 
    426423          for(int i=0; i<data.length/2; i++) { 
    427             addMeta("FrameInfo "+i, 
    428               new Short(DataTools.bytesToShort(data, i*2, true))); 
     424            addMeta("FrameInfo "+i, new Short(ds.readShort())); 
    429425          } 
    430426        } 
     
    449445          core.imageCount[0]++; 
    450446        } 
     447        ds.close();  
    451448        r.exec("dis.close()"); 
    452449        if (debug) { 
    453           print(depth + 1, ((byte[]) 
    454             r.getVar("data")).length + " bytes read."); 
     450          print(depth + 1, data.length + " bytes read."); 
    455451        } 
    456452      } 
  • trunk/loci/formats/in/ImarisReader.java

    r2802 r2922  
    9393  /* @see loci.formats.IFormatReader#openImage(int) */ 
    9494  public BufferedImage openImage(int no) throws FormatException, IOException { 
    95     FormatTools.assertId(currentId, true, 1); 
    9695    return ImageTools.makeImage(openBytes(no), core.sizeX[0], 
    9796      core.sizeY[0], 1, false); 
     
    137136    in.readInt(); 
    138137 
    139     byte[] name = new byte[128]; 
    140     in.read(name); 
    141     String iName = new String(name); 
    142     addMeta("Image name", iName); 
     138    addMeta("Image name", in.readString(128)); 
    143139 
    144140    core.sizeX[0] = in.readShort(); 
     
    151147    in.skipBytes(2); 
    152148 
    153     byte[] date = new byte[32]; 
    154     in.read(date); 
    155     String origDate = new String(date); 
    156     addMeta("Original date", origDate); 
     149    addMeta("Original date", in.readString(32)); 
    157150 
    158151    float dx = in.readFloat(); 
     
    161154    int mag = in.readShort(); 
    162155 
    163     byte[] com = new byte[128]; 
    164     in.read(com); 
    165     String comment = new String(com); 
    166     addMeta("Image comment", comment); 
     156    addMeta("Image comment", in.readString(128)); 
    167157    int isSurvey = in.readInt(); 
    168158    addMeta("Survey performed", isSurvey == 0 ? "true" : "false"); 
  • trunk/loci/formats/in/ImarisTiffReader.java

    r2687 r2922  
    145145    int bitFormat = TiffTools.getIFDIntValue(ifds[0], TiffTools.SAMPLE_FORMAT); 
    146146 
    147     // TODO : look into removing this logic, since it's copied directly from 
    148     // BaseTiffReader 
    149  
    150147    while (bitsPerSample % 8 != 0) bitsPerSample++; 
    151148    if (bitsPerSample == 24 || bitsPerSample == 48) bitsPerSample /= 3; 
  • trunk/loci/formats/in/KhorosReader.java

    r2898 r2922  
    127127    int dependency = in.readInt(); 
    128128 
    129     byte[] comment = new byte[512]; 
    130     in.read(comment); 
    131     addMeta("Comment", new String(comment)); 
     129    addMeta("Comment", in.readString(512)); 
    132130 
    133131    in.order(dependency == 4 || dependency == 8); 
     
    144142    switch (type) { 
    145143      case 0:  
    146         core.pixelType[0] = FormatTools.UINT8;  
    147         break; 
    148144      case 1:  
    149145        core.pixelType[0] = FormatTools.UINT8;  
  • trunk/loci/formats/in/LIFReader.java

    r2839 r2922  
    5858  private int[] extraDimensions; 
    5959 
    60   /** Number of valid bits per pixel */ 
    61   private int[][] validBits; 
    62  
    6360  private int bpp; 
    6461  private Vector xcal; 
     
    6663  private Vector zcal; 
    6764  private Vector seriesNames; 
    68  
    69   private Vector channelMins; 
    70   private Vector channelMaxs; 
    7165 
    7266  // -- Constructor -- 
     
    119113  /* @see loci.formats.IFormatReader#openImage(int) */ 
    120114  public BufferedImage openImage(int no) throws FormatException, IOException { 
    121     FormatTools.assertId(currentId, true, 1); 
    122115    return ImageTools.makeImage(openBytes(no), core.sizeX[series], 
    123       core.sizeY[series], isRGB() ? core.sizeC[series] : 1, false, bpp / 8, 
    124       core.littleEndian[series], validBits[series]); 
     116      core.sizeY[series], getRGBChannelCount(), false, bpp / 8, 
     117      core.littleEndian[series]); 
    125118  } 
    126119 
     
    135128 
    136129    core.littleEndian[0] = true; 
     130    in.order(core.littleEndian[0]); 
    137131 
    138132    xcal = new Vector(); 
    139133    ycal = new Vector(); 
    140134    zcal = new Vector(); 
    141     channelMins = new Vector(); 
    142     channelMaxs = new Vector(); 
    143135 
    144136    // read the header 
     
    163155    // number of Unicode characters in the XML block 
    164156 
    165     int nc = DataTools.read4SignedBytes(in, core.littleEndian[0]); 
    166     byte[] s = new byte[nc * 2]; 
    167     in.read(s); 
    168     String xml = DataTools.stripString(new String(s)); 
     157    int nc = in.readInt(); 
     158    String xml = DataTools.stripString(in.readString(nc * 2)); 
    169159 
    170160    status("Finding image offsets"); 
    171161 
    172162    while (in.getFilePointer() < in.length()) { 
    173       if (DataTools.read4SignedBytes(in, core.littleEndian[0]) != 0x70) { 
     163      if (in.readInt() != 0x70) { 
    174164        throw new FormatException("Invalid Memory Block"); 
    175165      } 
     
    180170      } 
    181171 
    182       int blockLength = DataTools.read4SignedBytes(in, core.littleEndian[0]); 
     172      int blockLength = in.readInt(); 
    183173      if (in.read() != 0x2a) { 
    184174        throw new FormatException("Invalid Memory Description"); 
    185175      } 
    186176 
    187       int descrLength = DataTools.read4SignedBytes(in, core.littleEndian[0]); 
    188       byte[] memDescr = new byte[2*descrLength]; 
    189       in.read(memDescr); 
     177      int descrLength = in.readInt(); 
     178      in.skipBytes(descrLength * 2);  
    190179 
    191180      if (blockLength > 0) { 
     
    359348              if (numChannels == 1) { 
    360349                bps.add(new Integer((String) tmp.get("Resolution"))); 
    361                 String sMin = (String) tmp.get("Min"); 
    362                 String sMax = (String) tmp.get("Max"); 
    363                 if (sMin != null && sMax != null) { 
    364                   double min = Double.parseDouble(sMin); 
    365                   double max = Double.parseDouble(sMax); 
    366                   channelMins.add(new Integer((int) min)); 
    367                   channelMaxs.add(new Integer((int) max)); 
    368                 } 
    369350              } 
    370351            } 
     
    433414    core = new CoreMetadata(numDatasets); 
    434415    Arrays.fill(core.orderCertain, true); 
    435     validBits = new int[numDatasets][]; 
    436416 
    437417    for (int i=0; i<numDatasets; i++) { 
     
    458438      core.imageCount[i] = core.sizeZ[i] * core.sizeT[i]; 
    459439      if (!core.rgb[i]) core.imageCount[i] *= core.sizeC[i]; 
    460  
    461       validBits[i] = new int[core.sizeC[i] != 2 ? core.sizeC[i] : 3]; 
    462       for (int j=0; j<validBits[i].length; j++) { 
    463         validBits[i][j] = bitsPerPixel[i]; 
    464       } 
    465440 
    466441      while (bitsPerPixel[i] % 8 != 0) bitsPerPixel[i]++; 
  • trunk/loci/formats/in/LegacyPictReader.java

    r2701 r2922  
    5454  /* @see loci.formats.IFormatReader#openBytes(int) */ 
    5555  public byte[] openBytes(int no) throws FormatException, IOException { 
    56     FormatTools.assertId(currentId, true, 1); 
    5756    return ImageTools.getBytes(openImage(no), false, 3); 
    5857  } 
  • trunk/loci/formats/in/LegacyZVIReader.java

    r2857 r2922  
    135135    super.initFile(id); 
    136136    in = new RandomAccessStream(id); 
     137    in.order(true); 
    137138 
    138139    // Highly questionable decoding strategy: 
     
    226227 
    227228      // read potential header information 
    228       int theZ = (int) DataTools.read4UnsignedBytes(in, true); 
    229       int theC = (int) DataTools.read4UnsignedBytes(in, true); 
    230       int theT = (int) DataTools.read4UnsignedBytes(in, true); 
     229      int theZ = in.readInt(); 
     230      int theC = in.readInt(); 
     231      int theT = in.readInt(); 
    231232      pos += 12; 
    232233 
     
    287288 
    288289      // read more header information 
    289       core.sizeX[0] = (int) DataTools.read4UnsignedBytes(in, true); 
    290       core.sizeY[0] = (int) DataTools.read4UnsignedBytes(in, true); 
     290      core.sizeX[0] = in.readInt(); 
     291      core.sizeY[0] = in.readInt(); 
    291292      // don't know what this is for 
    292       int alwaysOne = (int) DataTools.read4UnsignedBytes(in, true); 
    293       bytesPerPixel = (int) DataTools.read4UnsignedBytes(in, true); 
     293      int alwaysOne = in.readInt(); 
     294      bytesPerPixel = in.readInt(); 
    294295      // not clear what this value signifies 
    295       int pixType = (int) DataTools.read4UnsignedBytes(in, true); 
     296      int pixType = in.readInt();  
    296297      // doesn't always equal bytesPerPixel * 8 
    297       int bitDepth = (int) DataTools.read4UnsignedBytes(in, true); 
     298      int bitDepth = in.readInt();  
    298299      pos += 24; 
    299300 
     
    302303        case 1: 
    303304          type = "8 bit rgb tuple, 24 bpp"; 
    304           core.pixelType[0] = FormatTools.INT8; 
     305          core.pixelType[0] = FormatTools.UINT8; 
    305306          break; 
    306307        case 2: 
    307308          type = "8 bit rgb quad, 32 bpp"; 
    308           core.pixelType[0] = FormatTools.INT8; 
     309          core.pixelType[0] = FormatTools.UINT8; 
    309310          break; 
    310311        case 3: 
    311312          type = "8 bit grayscale"; 
    312           core.pixelType[0] = FormatTools.INT8; 
     313          core.pixelType[0] = FormatTools.UINT8; 
    313314          break; 
    314315        case 4: 
    315316          type = "16 bit signed int, 16 bpp"; 
    316           core.pixelType[0] = FormatTools.INT16; 
     317          core.pixelType[0] = FormatTools.UINT16; 
    317318          break; 
    318319        case 5: 
    319320          type = "32 bit int, 32 bpp"; 
    320           core.pixelType[0] = FormatTools.INT32; 
     321          core.pixelType[0] = FormatTools.UINT32; 
    321322          break; 
    322323        case 6: 
     
    330331        case 8: 
    331332          type = "16 bit unsigned short triple, 48 bpp"; 
    332           core.pixelType[0] = FormatTools.INT16; 
     333          core.pixelType[0] = FormatTools.UINT16; 
    333334          break; 
    334335        case 9: 
    335336          type = "32 bit int triple, 96 bpp"; 
    336           core.pixelType[0] = FormatTools.INT32; 
     337          core.pixelType[0] = FormatTools.UINT32; 
    337338          break; 
    338339        default: 
     
    357358      // sorry not a very clever way to find dimension order 
    358359 
    359       if ((numI == 2) && (cSet.size() == 2))  cFlag = 1; 
    360       if ((numI == 2) && (zSet.size() == 2))  zFlag = 1; 
    361       if ((numI == 2) && (tSet.size() == 2))  tFlag = 1; 
     360      if ((numI == 2) && (cSet.size() == 2)) cFlag = 1; 
     361      if ((numI == 2) && (zSet.size() == 2)) zFlag = 1; 
     362      if ((numI == 2) && (tSet.size() == 2)) tFlag = 1; 
    362363 
    363364      if ((numI % 3 == 0) && (zSet.size() > 1) && (cFlag == 1)) { 
  • trunk/loci/formats/in/MNGReader.java

    r2701 r2922  
    4848 
    4949  /** Constructs a new MNG reader. */ 
    50   public MNGReader() { super("Multiple Network Graphics (MNG)", "mng"); } 
     50  public MNGReader() { super("Multiple Network Graphics", "mng"); } 
    5151 
    5252  // -- IFormatReader API methods -- 
     
    6262  /* @see loci.formats.IFormatReader#openBytes(int) */ 
    6363  public byte[] openBytes(int no) throws FormatException, IOException { 
    64     FormatTools.assertId(currentId, true, 1); 
    6564    return ImageTools.getBytes(openImage(no), true, core.sizeC[0]); 
    6665  } 
     
    9796    super.initFile(id); 
    9897    in = new RandomAccessStream(id); 
     98    in.order(false); 
    9999 
    100100    status("Verifying MNG format"); 
     
    114114    status("Reading dimensions"); 
    115115 
    116     core.sizeX[0] = (int) DataTools.read4UnsignedBytes(in, false); 
    117     core.sizeY[0] = (int) DataTools.read4UnsignedBytes(in, false); 
    118     long fps = DataTools.read4UnsignedBytes(in, false); 
    119     long layerCounter = DataTools.read4UnsignedBytes(in, false); 
     116    core.sizeX[0] = in.readInt(); 
     117    core.sizeY[0] = in.readInt(); 
     118    int fps = in.readInt(); 
     119    int layerCounter = in.readInt(); 
    120120    in.skipBytes(4); 
    121121 
    122     long playTime = DataTools.read4UnsignedBytes(in, false); 
    123     long profile = DataTools.read4UnsignedBytes(in, false); 
     122    int playTime = in.readInt(); 
     123    int profile = in.readInt(); 
    124124 
    125125    in.skipBytes(4); // skip the CRC 
     
    132132 
    133133    while (in.getFilePointer() < in.length()) { 
    134       long len = DataTools.read4UnsignedBytes(in, false); 
     134      int len = in.readInt(); 
    135135      in.read(b); 
    136136      String code = new String(b); 
     
    148148        stack.add(new Long(in.getFilePointer() + len + 4)); 
    149149        in.skipBytes(1); 
    150         maxIterations = DataTools.read4SignedBytes(in, false); 
     150        maxIterations = in.readInt(); 
    151151      } 
    152152      else if (code.equals("ENDL")) { 
     
    163163      } 
    164164 
    165       in.seek(fp + (int) len + 4); 
     165      in.seek(fp + len + 4); 
    166166    } 
    167167 
  • trunk/loci/formats/in/MRCReader.java

    r2701 r2922  
    6363  /* @see loci.formats.IFormatReader#openBytes(int) */ 
    6464  public byte[] openBytes(int no) throws FormatException, IOException { 
    65     FormatTools.assertId(currentId, true, 1); 
    6665    byte[] buf = new byte[core.sizeX[0] * core.sizeY[0] * bpp]; 
    6766    return openBytes(no, buf); 
     
    8685  /* @see loci.formats.IFormatReader#openImage(int) */ 
    8786  public BufferedImage openImage(int no) throws FormatException, IOException { 
    88     FormatTools.assertId(currentId, true, 1); 
    8987    return ImageTools.makeImage(openBytes(no), core.sizeX[0], 
    9088      core.sizeY[0], 1, true, bpp, core.littleEndian[0]); 
     
    124122        break; 
    125123      case 1: 
     124      case 6: 
    126125        bpp = 2; 
    127126        core.pixelType[0] = FormatTools.UINT16; 
     
    141140        core.pixelType[0] = FormatTools.DOUBLE; 
    142141        break; 
    143       case 6: 
    144         bpp = 2; 
    145         core.pixelType[0] = FormatTools.UINT16; 
    146         break; 
    147142      case 16: 
    148143        bpp = 2; 
     
    170165    addMeta("Pixel size (Z)", "" + (zlen / mz)); 
    171166 
    172     float alpha = in.readFloat(); 
    173     float beta = in.readFloat(); 
    174     float gamma = in.readFloat(); 
    175  
    176     addMeta("Alpha angle", "" + alpha); 
    177     addMeta("Beta angle", "" + beta); 
    178     addMeta("Gamma angle", "" + gamma); 
     167    addMeta("Alpha angle", "" + in.readFloat()); 
     168    addMeta("Beta angle", "" + in.readFloat()); 
     169    addMeta("Gamma angle", "" + in.readFloat()); 
    179170 
    180171    in.skipBytes(12); 
     
    182173    // min, max and mean pixel values 
    183174 
    184     float min = in.readFloat(); 
    185     float max = in.readFloat(); 
    186     float mean = in.readFloat(); 
    187  
    188     addMeta("Minimum pixel value", "" + min); 
    189     addMeta("Maximum pixel value", "" + max); 
    190     addMeta("Mean pixel value", "" + mean); 
     175    addMeta("Minimum pixel value", "" + in.readFloat()); 
     176    addMeta("Maximum pixel value", "" + in.readFloat()); 
     177    addMeta("Mean pixel value", "" + in.readFloat()); 
    191178 
    192179    in.skipBytes(4); 
    193180 
    194181    extHeaderSize = in.readInt(); 
    195     int creator = in.readShort(); 
    196  
    197     in.skipBytes(30); 
    198  
    199     int nint = in.readShort(); 
    200     int nreal = in.readShort(); 
    201  
    202     in.skipBytes(28); 
     182      
     183    in.skipBytes(64); 
    203184 
    204185    int idtype = in.readShort(); 
    205     int lens = in.readShort(); 
    206     int nd1 = in.readShort(); 
    207     int nd2 = in.readShort(); 
    208     int vd1 = in.readShort(); 
    209     int vd2 = in.readShort(); 
    210  
    211     String type = ""; 
    212     switch (idtype) { 
    213       case 0: 
    214         type = "mono"; 
    215         break; 
    216       case 1: 
    217         type = "tilt"; 
    218         break; 
    219       case 2: 
    220         type = "tilts"; 
    221         break; 
    222       case 3: 
    223         type = "lina"; 
    224         break; 
    225       case 4: 
    226         type = "lins"; 
    227         break; 
    228       default: 
    229         type = "unknown"; 
    230     } 
     186 
     187    String[] types = new String[] {"mono", "tilt", "tilts", "lina", "lins"}; 
     188    String type = (idtype >= 0 && idtype < types.length) ? types[idtype] : 
     189      "unknown"; 
    231190 
    232191    addMeta("Series type", type); 
    233     addMeta("Lens", "" + lens); 
    234     addMeta("ND1", "" + nd1); 
    235     addMeta("ND2", "" + nd2); 
    236     addMeta("VD1", "" + vd1); 
    237     addMeta("VD2", "" + vd2); 
     192    addMeta("Lens", "" + in.readShort()); 
     193    addMeta("ND1", "" + in.readShort()); 
     194    addMeta("ND2", "" + in.readShort()); 
     195    addMeta("VD1", "" + in.readShort()); 
     196    addMeta("VD2", "" + in.readShort()); 
    238197 
    239198    float[] angles = new float[6]; 
     
    248207    addMeta("Number of useful labels", "" + nUsefulLabels); 
    249208 
    250     byte[] b = new byte[80]; 
    251209    for (int i=0; i<10; i++) { 
    252       in.read(b); 
    253       addMeta("Label " + (i+1), new String(b)); 
     210      addMeta("Label " + (i+1), in.readString(80)); 
    254211    } 
    255212 
  • trunk/loci/formats/in/ND2Reader.java

    r2879 r2922  
    122122  /** Array of image offsets. */ 
    123123  private long[] offsets; 
    124  
    125   /** Number of valid bits per pixel */ 
    126   private int[] validBits; 
    127124 
    128125  /** Whether or not the pixel data is compressed using JPEG 2000. */ 
     
    176173          pixels[i].length); 
    177174      } 
     175      pixels = null;  
    178176    } 
    179177    else { 
     
    328326      pos = in.getFilePointer(); 
    329327      length = in.readInt(); 
    330       if (pos + length >= in.length()) lastBoxFound = true; 
     328      if (pos + length >= in.length() || length == 0) lastBoxFound = true; 
    331329      box = in.readInt(); 
    332330      pos = in.getFilePointer(); 
     
    343341      offsets[i] = ((Long) vs.get(i)).longValue(); 
    344342    } 
     343    vs.clear(); 
     344    vs = null; 
    345345 
    346346    status("Finding XML metadata"); 
     
    377377      } 
    378378    } 
     379 
     380    buf = null; 
    379381 
    380382    status("Parsing XML"); 
     
    476478        } 
    477479      } 
     480      b = null;  
     481      xml = null;  
     482      st = null;  
    478483    } 
    479484 
     
    483488    core.sizeX[0] = img.getWidth(); 
    484489    core.sizeY[0] = img.getHeight(); 
     490    core.sizeC[0] = img.getRaster().getNumBands(); 
     491    core.rgb[0] = core.sizeC[0] > 1; 
    485492 
    486493    int numInvalid = 0; 
     
    527534    } 
    528535 
    529     if (core.sizeC[0] == 0) { 
    530       core.sizeC[0] = openImage(0).getRaster().getNumBands(); 
    531     } 
    532536    if (core.sizeC[0] == 2) core.sizeC[0] = 1; 
    533537 
     
    543547    // we calculate this directly (instead of calling getEffectiveSizeC) because 
    544548    // sizeZ and sizeT have not been accurately set yet 
    545     int effectiveC = (core.sizeC[0] / 3) + 1; 
     549    int effectiveC = ((core.sizeC[0] - 1) / 3) + 1; 
    546550 
    547551    if (core.imageCount[0] < core.sizeZ[0] * core.sizeT[0]) { 
     
    593597    } 
    594598 
    595     if (bits != 0) { 
    596       validBits = new int[core.sizeC[0] == 2 ? 3 : core.sizeC[0]]; 
    597       for (int i=0; i<validBits.length; i++) validBits[i] = bits; 
    598     } 
    599     else validBits = null; 
    600  
    601     if (validBits == null) core.pixelType[0] = FormatTools.UINT8; 
     599    if (bits == 0) core.pixelType[0] = FormatTools.UINT8; 
    602600    else { 
    603       int bpp = validBits[0]; 
     601      int bpp = bits;  
    604602      while (bpp % 8 != 0) bpp++; 
    605603      switch (bpp) { 
     
    628626 
    629627    if (core.sizeZ[0] * core.sizeT[0] * core.sizeC[0] < core.imageCount[0]) { 
    630       core.sizeC[0] = 1; 
    631628      core.sizeT[0] = 1; 
    632629      core.sizeZ[0] = core.imageCount[0]; 
  • trunk/loci/formats/in/NRRDReader.java

    r2762 r2922  
    6060  public boolean isThisType(byte[] block) { 
    6161    if (block.length < 4) return false; 
    62     return block[0] == 'N' && block[1] == 'R' && block[2] == 'R' && 
    63       block[3] == 'D'; 
     62    return new String(block).startsWith("NRRD");  
    6463  } 
    6564 
  • trunk/loci/formats/in/OIBReader.java

    r2857 r2922  
    112112  private Vector[] tIndices; 
    113113 
    114   /** Number of valid bits per pixel. */ 
    115   private int[][] validBits; 
    116  
    117114  private Vector rgb; 
    118115 
     
    148145 
    149146    return ImageTools.makeImage(b, core.sizeX[series], core.sizeY[series], 
    150       getRGBChannelCount(), false, bytes, core.littleEndian[series], 
    151       validBits[series]); 
     147      getRGBChannelCount(), false, bytes, core.littleEndian[series]); 
    152148  } 
    153149 
     
    318314      core = new CoreMetadata(numSeries); 
    319315 
    320       validBits = new int[numSeries][]; 
    321  
    322316      for (int i=0; i<numSeries; i++) { 
    323317        core.sizeX[i] = ((Integer) width.get(i)).intValue(); 
     
    393387        nImages.setElementAt(new Integer(core.imageCount[i]), i); 
    394388        setSeries(oldSeries); 
    395  
    396         validBits[i] = new int[core.sizeC[i] == 2 ? 3 : core.sizeC[i]]; 
    397         int vb = 0; 
    398         Enumeration k = metadata.keys(); 
    399         while (k.hasMoreElements()) { 
    400           String key = k.nextElement().toString(); 
    401           if (key.indexOf("ValidBitCounts") != -1) { 
    402             vb = Integer.parseInt((String) getMeta(key)); 
    403           } 
    404         } 
    405         if (vb > 0) { 
    406           for (int j=0; j<validBits[i].length; j++) validBits[i][j] = vb; 
    407         } 
    408         else validBits[i] = null; 
    409389 
    410390        core.rgb[i] = ((Boolean) rgb.get(i)).booleanValue(); 
     
    457437    for (int i=0; i<width.size(); i++) { 
    458438      switch (((Integer) bpp.get(0)).intValue() % 3) { 
    459         case 0: 
    460         case 1: 
    461           core.pixelType[i] = FormatTools.UINT8; 
    462           break; 
    463439        case 2: 
    464440          core.pixelType[i] = FormatTools.UINT16; 
    465441          break; 
    466         case 4: 
    467           core.pixelType[i] = FormatTools.UINT32; 
    468           break; 
    469         default: 
    470           throw new RuntimeException( 
    471             "Unknown matching for pixel byte width of: " + bpp); 
     442        default: core.pixelType[i] = FormatTools.UINT8;  
    472443      } 
    473444 
  • trunk/loci/formats/in/OIFReader.java

    r2859 r2922  
    4848  /** Helper reader to open the thumbnail. */ 
    4949  protected BMPReader thumbReader; 
    50  
    51   /** Number of valid bits per pixel. */ 
    52   protected int[] validBits; 
    5350 
    5451  /** List of files in the current OIF dataset. */ 
     
    109106    BufferedImage b = tiffReader[no].openImage(0); 
    110107    ColorModel cm = ImageTools.makeColorModel(b.getRaster().getNumBands(), 
    111       b.getRaster().getTransferType(), validBits); 
     108      b.getRaster().getTransferType(), null); 
    112109    b = ImageTools.makeBuffered(b, cm); 
    113110    tiffReader[no].close(); 
     
    334331 
    335332    for (int i=0; i<9; i++) { 
    336       if (code[i].equals("\"X\"")) core.sizeX[0] = Integer.parseInt(size[i]); 
    337       else if (code[i].equals("\"Y\"")) { 
    338         core.sizeY[0] = Integer.parseInt(size[i]); 
    339       } 
    340       else if (code[i].equals("\"C\"")) { 
    341         core.sizeC[0] = Integer.parseInt(size[i]); 
    342       } 
    343       else if (code[i].equals("\"T\"")) { 
    344         core.sizeT[0] = Integer.parseInt(size[i]); 
    345       } 
    346       else if (code[i].equals("\"Z\"")) { 
    347         core.sizeZ[0] = Integer.parseInt(size[i]); 
    348       } 
     333      int ss = Integer.parseInt(size[i]);  
     334      if (code[i].equals("\"X\"")) core.sizeX[0] = ss; 
     335      else if (code[i].equals("\"Y\"")) core.sizeY[0] = ss;  
     336      else if (code[i].equals("\"C\"")) core.sizeC[0] = ss;  
     337      else if (code[i].equals("\"T\"")) core.sizeT[0] = ss;  
     338      else if (code[i].equals("\"Z\"")) core.sizeZ[0] = ss;  
    349339    } 
    350340 
     
    396386    } 
    397387 
    398     validBits = new int[core.sizeC[0]]; 
    399     if (validBits.length == 2) validBits = new int[3]; 
    400     for (int i=0; i<validBits.length; i++) { 
    401       s = (String) getMeta("[Reference Image Parameter] - ValidBitCounts"); 
    402       if (s != null) { 
    403         validBits[i] = Integer.parseInt(s); 
    404       } 
    405       else { 
    406         i = validBits.length; 
    407       } 
    408     } 
    409  
    410     int len = validBits.length; 
    411     for (int i=0; i<len; i++) { 
    412       if (validBits[i] == 0) { 
    413         validBits = null; 
    414         break; 
    415       } 
    416     } 
    417  
    418388    core.rgb[0] = tiffReader[0].isRGB(); 
    419389    core.littleEndian[0] = true; 
  • trunk/loci/formats/in/OMEXMLReader.java

    r2857 r2922  
    114114    data = null; 
    115115 
    116     //byte[] pixels = Compression.base64Decode(pix); 
    117116    Base64Codec e = new Base64Codec(); 
    118117    byte[] pixels = e.base64Decode(pix); 
     
    198197          if (ndx != -1) { 
    199198            found = true; 
    200             String endian = test.substring(ndx + 11); 
     199            String endian = test.substring(ndx + 11).trim(); 
     200            if (endian.startsWith("\"")) endian = endian.substring(1); 
    201201            endianness.add(new Boolean(!endian.toLowerCase().startsWith("t"))); 
    202202            bigEndianPos.add(new Long(in.getFilePointer() - read - 9 + ndx)); 
  • trunk/loci/formats/in/OpenlabRawReader.java

    r2701 r2922  
    9595  /* @see loci.formats.IFormatReader#openImage(int) */ 
    9696  public BufferedImage openImage(int no) throws FormatException, IOException { 
    97     FormatTools.assertId(currentId, true, 1); 
    9897    return ImageTools.makeImage(openBytes(no), core.sizeX[0], 
    9998      core.sizeY[0], core.sizeC[0], false, bytesPerPixel, false); 
     
    150149    addMeta("Bytes per pixel", new Integer(bytesPerPixel)); 
    151150 
     151    int plane = core.sizeX[0] * core.sizeY[0] * bytesPerPixel; 
    152152    for (int i=1; i<core.imageCount[0]; i++) { 
    153       offsets[i] = 
    154         offsets[i-1] + 288 + core.sizeX[0] * core.sizeY[0] * bytesPerPixel; 
     153      offsets[i] = offsets[i - 1] + 288 + plane; 
    155154    } 
    156155 
     
    167166    switch (bytesPerPixel) { 
    168167      case 1: 
     168      case 3:   
    169169        core.pixelType[0] = FormatTools.UINT8; 
    170170        break; 
    171171      case 2: 
    172172        core.pixelType[0] = FormatTools.UINT16; 
    173         break; 
    174       case 3: 
    175         core.pixelType[0] = FormatTools.INT8; 
    176173        break; 
    177174      default: 
  • trunk/loci/formats/in/OpenlabReader.java

    r2857 r2922  
    103103 
    104104    in.skipBytes(24); 
    105     int volumeType = DataTools.read2SignedBytes(in, false); 
     105    int volumeType = in.readShort(); 
    106106    in.skipBytes(272); 
    107107 
     
    110110    if (version == 2) { 
    111111      in.skipBytes(2); 
    112       top = DataTools.read2SignedBytes(in, false); 
    113       left = DataTools.read2SignedBytes(in, false); 
    114       bottom = DataTools.read2SignedBytes(in, false); 
    115       right = DataTools.read2SignedBytes(in, false); 
     112      top = in.readShort(); 
     113      left = in.readShort(); 
     114      bottom = in.readShort(); 
     115      right = in.readShort(); 
    116116 
    117117      if (core.sizeX[series] == 0) core.sizeX[series] = right - left; 
     
    119119    } 
    120120    else { 
    121       core.sizeX[series] = DataTools.read4SignedBytes(in, false); 
    122       core.sizeY[series] = DataTools.read4SignedBytes(in, false); 
     121      core.sizeX[series] = in.readInt(); 
     122      core.sizeY[series] = in.readInt(); 
    123123    } 
    124124 
     
    226226 
    227227      in.skipBytes(24); 
    228       volumeType = DataTools.read2SignedBytes(in, false); 
     228      volumeType = in.readShort();  
    229229 
    230230      in.skipBytes(280); 
    231       int size = DataTools.read4SignedBytes(in, false); 
    232       int compressedSize = DataTools.read4SignedBytes(in, false); 
     231      int size = in.readInt(); 
     232      int compressedSize = in.readInt(); 
    233233      b = new byte[size]; 
    234234      byte[] c = new byte[compressedSize]; 
     
    352352    status("Verifying Openlab LIFF format"); 
    353353 
     354    in.order(false); 
    354355    in.skipBytes(4); 
    355     byte[] b = new byte[4]; 
    356     in.read(b); 
    357     String s = new String(b); 
    358     if (!s.equals("impr")) throw new FormatException("Invalid LIFF file."); 
    359  
    360     version = DataTools.read4SignedBytes(in, false); 
     356    if (!in.readString(4).equals("impr")) { 
     357      throw new FormatException("Invalid LIFF file."); 
     358    } 
     359 
     360    version = in.readInt(); 
    361361 
    362362    if (version != 2 && version != 5) { 
     
    368368 
    369369    // read offset to first plane 
    370     int offset = DataTools.read4SignedBytes(in, false); 
     370    int offset = in.readInt(); 
    371371    in.seek(offset); 
    372372 
     
    404404 
    405405          in.skipBytes(24); 
    406           int volumeType = DataTools.read2SignedBytes(in, false); 
     406          int volumeType = in.readShort(); 
    407407 
    408408          if (volumeType == MAC_1_BIT || volumeType == MAC_256_GREYS || 
     
    411411          { 
    412412            in.skipBytes(16); 
    413             b = new byte[128]; 
    414             in.read(b); 
    415             info.layerName = new String(b); 
     413            info.layerName = in.readString(128); 
    416414 
    417415            if (!info.layerName.trim().equals("Original Image")) { 
    418               info.timestamp = DataTools.read8SignedBytes(in, false); 
     416              info.timestamp = in.readLong(); 
    419417              layerInfoList[0].add(info); 
    420418            } 
     
    424422        else if (tag == 69) { 
    425423          in.skipBytes(4); 
    426           int units = DataTools.read2SignedBytes(in, false); 
     424          int units = in.readShort(); 
    427425          in.skipBytes(12); 
    428426 
    429           xCal = Float.intBitsToFloat(DataTools.read4SignedBytes(in, false)); 
    430           yCal = Float.intBitsToFloat(DataTools.read4SignedBytes(in, false)); 
     427          xCal = in.readFloat(); 
     428          yCal = in.readFloat(); 
    431429        } 
    432430        else if (tag == 72 || fmt.equals("USER")) { 
     
    444442 
    445443            if (aChar == 1) { 
    446               int numVars = DataTools.read2SignedBytes(in, false); 
     444              int numVars = in.readShort(); 
    447445              while (numVars > 0) { 
    448446                aChar = (char) in.read(); 
     
    466464 
    467465                if (className.equals("CStringVariable")) { 
    468                   int strSize = DataTools.read4SignedBytes(in, false); 
    469                   b = new byte[strSize]; 
    470                   in.read(b); 
    471                   varStringValue = new String(b); 
     466                  int strSize = in.readInt(); 
     467                  varStringValue = in.readString(strSize); 
    472468                  varNumValue = Float.parseFloat(varStringValue); 
    473469 
     
    475471                } 
    476472                else if (className.equals("CFloatVariable")) { 
    477                   varNumValue = Double.longBitsToDouble( 
    478                     DataTools.read8SignedBytes(in, false)); 
     473                  varNumValue = in.readDouble(); 
    479474                  varStringValue = "" + varNumValue; 
    480475                } 
     
    482477                int baseClassVersion = in.read(); 
    483478                if (baseClassVersion == 1 || baseClassVersion == 2) { 
    484                   int strSize = DataTools.read4SignedBytes(in, false); 
    485                   b = new byte[strSize]; 
    486                   in.read(b); 
    487                   varName = new String(b); 
     479                  int strSize = in.readInt(); 
     480                  varName = in.readString(strSize); 
    488481                  in.skipBytes(baseClassVersion == 1 ? 3 : 2); 
    489482                } 
     
    532525      if (fmt.equals("PICT")) { 
    533526        in.skipBytes(24); 
    534         int volumeType = DataTools.read2SignedBytes(in, false); 
     527        int volumeType = in.readShort(); 
    535528        in.skipBytes(272); 
    536529 
     
    539532        if (version == 2) { 
    540533          in.skipBytes(2); 
    541           top = DataTools.read2SignedBytes(in, false); 
    542           left = DataTools.read2SignedBytes(in, false); 
    543           bottom = DataTools.read2SignedBytes(in, false); 
    544           right = DataTools.read2SignedBytes(in, false); 
     534          top = in.readShort(); 
     535          left = in.readShort(); 
     536          bottom = in.readShort(); 
     537          right = in.readShort(); 
    545538 
    546539          if (core.sizeX[series] == 0) core.sizeX[series] = right - left; 
     
    548541        } 
    549542        else { 
    550           core.sizeX[series] = DataTools.read4SignedBytes(in, false); 
    551           core.sizeY[series] = DataTools.read4SignedBytes(in, false); 
     543          core.sizeX[series] = in.readInt(); 
     544          core.sizeY[series] = in.readInt(); 
    552545        } 
    553546 
    554547        in.seek(layer.layerStart); 
    555  
    556         b = new byte[0]; 
    557548 
    558549        if (version == 2) { 
     
    566557          // open image using pict reader 
    567558          try { 
    568             b = new byte[(int) (nextTag - in.getFilePointer())]; 
     559            byte[] b = new byte[(int) (nextTag - in.getFilePointer())]; 
    569560            in.read(b); 
    570561            BufferedImage img = pict.open(b); 
     
    672663      switch (bpp[i]) { 
    673664        case 1: 
    674           core.pixelType[i] = FormatTools.INT8; 
    675           break; 
    676         case 2: 
    677           core.pixelType[i] = FormatTools.UINT16; 
    678           break; 
    679665        case 3: 
    680666          core.pixelType[i] = FormatTools.UINT8; 
    681667          break; 
     668        case 2: 
     669        case 6:  
     670          core.pixelType[i] = FormatTools.UINT16; 
     671          break; 
    682672        case 4: 
    683           core.pixelType[i] = FormatTools.INT32; 
    684           break; 
    685         case 6: 
    686           core.pixelType[i] = FormatTools.INT16; 
     673          core.pixelType[i] = FormatTools.UINT32; 
    687674          break; 
    688675      } 
     
    715702    throws IOException 
    716703  { 
    717     tag = DataTools.read2SignedBytes(in, false); 
    718     subTag = DataTools.read2SignedBytes(in, false); 
    719  
    720     long nextTag = (version == 2 ? DataTools.read4SignedBytes(in, false) : 
    721       DataTools.read8SignedBytes(in, false)); 
     704    tag = in.readShort(); 
     705    subTag = in.readShort(); 
     706 
     707    long nextTag = (version == 2 ? in.readInt() : in.readLong()); 
    722708 
    723709    byte[] b = new byte[4]; 
  • trunk/loci/formats/in/PGMReader.java

    r2804 r2922  
    3131 
    3232/** 
    33  * PGMReader is the file format reader for 
    34  * Portable Gray Map (PGM) images. 
     33 * PGMReader is the file format reader for Portable Gray Map (PGM) images. 
    3534 * 
    3635 * Much of this code was adapted from ImageJ (http://rsb.info.nih.gov/ij).  
     
    124123    boolean isBlackAndWhite = false; 
    125124 
    126     if (magic.equals("P1") || magic.equals("P2")) { 
    127       rawBits = false;  
    128       core.sizeC[0] = 1;  
    129       isBlackAndWhite = magic.equals("P1");  
    130     }  
    131     else if (magic.equals("P3")) { 
    132       rawBits = false; 
    133       core.sizeC[0] = 3; 
    134     } 
    135     else if (magic.equals("P4") || magic.equals("P5")) { 
    136       rawBits = true; 
    137       core.sizeC[0] = 1; 
    138       isBlackAndWhite = magic.equals("P4");  
    139     } 
    140     else if (magic.equals("P6")) { 
    141       rawBits = true; 
    142       core.sizeC[0] = 3; 
    143     } 
    144     else throw new FormatException("Unsupported magic number: " + magic);  
    145   
     125    rawBits = magic.equals("P4") || magic.equals("P5") || magic.equals("P6"); 
     126    core.sizeC[0] = (magic.equals("P3") || magic.equals("P6")) ? 3 : 1; 
     127    isBlackAndWhite = magic.equals("P1") || magic.equals("P4"); 
     128 
    146129    String line = in.readLine().trim(); 
    147130    while (line.startsWith("#") || line.length() == 0) line = in.readLine(); 
  • trunk/loci/formats/in/PNGReader.java

    r2842 r2922  
    3636 
    3737  /** Constructs a new PNGReader. */ 
    38   public PNGReader() { super("Portable Network Graphics", new String[] {"png", "pnm"}); } 
    39  
     38  public PNGReader() {  
     39    super("Portable Network Graphics", new String[] {"png", "pnm"}); 
     40  } 
    4041} 
  • trunk/loci/formats/in/PerkinElmerReader.java

    r2857 r2922  
    213213        ((prefix != null) && (s.startsWith(prefix)))) 
    214214      { 
    215         if (cfgPos == -1) { 
    216           if (filename.endsWith(".cfg")) { 
    217             cfgPos = i; 
    218             prefix = ls[i].substring(0, d); 
    219           } 
    220         } 
    221  
    222         if (anoPos == -1) { 
    223           if (filename.endsWith(".ano")) { 
    224             anoPos = i; 
    225             prefix = ls[i].substring(0, d); 
    226           } 
    227         } 
    228  
    229         if (recPos == -1) { 
    230           if (filename.endsWith(".rec")) { 
    231             recPos = i; 
    232             prefix = ls[i].substring(0, d); 
    233           } 
    234         } 
    235  
    236         if (timPos == -1) { 
    237           if (filename.endsWith(".tim")) { 
    238             timPos = i; 
    239             prefix = ls[i].substring(0, d); 
    240           } 
    241         } 
    242         if (csvPos == -1) { 
    243           if (filename.endsWith(".csv")) { 
    244             csvPos = i; 
    245             prefix = ls[i].substring(0, d); 
    246           } 
    247         } 
    248         if (zpoPos == -1) { 
    249           if (filename.endsWith(".zpo")) { 
    250             zpoPos = i; 
    251             prefix = ls[i].substring(0, d); 
    252           } 
    253         } 
    254         if (htmPos == -1) { 
    255           if (filename.endsWith(".htm")) { 
    256             htmPos = i; 
    257             prefix = ls[i].substring(0, d); 
    258           } 
     215        if (cfgPos == -1 && filename.endsWith(".cfg")) { 
     216          cfgPos = i; 
     217          prefix = ls[i].substring(0, d); 
     218        } 
     219        if (anoPos == -1 && filename.endsWith(".ano")) { 
     220          anoPos = i; 
     221          prefix = ls[i].substring(0, d); 
     222        } 
     223        if (recPos == -1 && filename.endsWith(".rec")) { 
     224          recPos = i; 
     225          prefix = ls[i].substring(0, d); 
     226        } 
     227        if (timPos == -1 && filename.endsWith(".tim")) { 
     228          timPos = i; 
     229          prefix = ls[i].substring(0, d); 
     230        } 
     231        if (csvPos == -1 && filename.endsWith(".csv")) { 
     232          csvPos = i; 
     233          prefix = ls[i].substring(0, d); 
     234        } 
     235        if (zpoPos == -1 && filename.endsWith(".zpo")) { 
     236          zpoPos = i; 
     237          prefix = ls[i].substring(0, d); 
     238        } 
     239        if (htmPos == -1 && filename.endsWith(".htm")) { 
     240          htmPos = i; 
     241          prefix = ls[i].substring(0, d); 
    259242        } 
    260243 
     
    345328      tiff[i] = new TiffReader(); 
    346329      if (i > 0) tiff[i].setMetadataCollected(false); 
    347       //tiff[i].setId(files[i]); 
    348     } 
    349  
    350     // highly questionable metadata parsing 
     330    } 
    351331 
    352332    // we always parse the .tim and .htm files if they exist, along with 
     
    562542      switch (bpp) { 
    563543        case 1: 
    564           core.pixelType[0] = FormatTools.INT8; 
     544        case 3:  
     545          core.pixelType[0] = FormatTools.UINT8; 
    565546          break; 
    566547        case 2: 
    567548          core.pixelType[0] = FormatTools.UINT16; 
    568549          break; 
    569         case 3: 
    570           core.pixelType[0] = FormatTools.INT8; 
    571           break; 
    572550        case 4: 
    573           core.pixelType[0] = FormatTools.INT32; 
     551          core.pixelType[0] = FormatTools.UINT32; 
    574552          break; 
    575553      } 
     
    631609      new Integer(core.sizeT[0]), // SizeT 
    632610      new Integer(core.pixelType[0]), // PixelType 
    633       new Boolean(!isLittleEndian()), // BigEndian 
     611      new Boolean(!core.littleEndian[0]), // BigEndian 
    634612      core.currentOrder[0], // DimensionOrder 
    635613      null, // Use image index 0 
  • trunk/loci/formats/in/PictReader.java

    r2857 r2922  
    6565  static { 
    6666    int index = 0; 
    67     for (int i = 0; i < 256; i++) { 
     67    for (int i=0; i<256; i++) { 
    6868      EXPANSION_TABLE[index++] = (i & 128) == 0 ? (byte) 0 : (byte) 1; 
    6969      EXPANSION_TABLE[index++] = (i & 64) == 0 ? (byte) 0 : (byte) 1; 
     
    7979  // -- Fields -- 
    8080 
     81  /** Stream for reading pixel data. */ 
     82  protected RandomAccessStream ras; 
     83 
    8184  /** Pixel bytes. */ 
    8285  protected byte[] bytes; 
     
    9093  /** Image state. */ 
    9194  protected int pictState; 
    92  
    93   /** Pointer into the array of bytes representing the file. */ 
    94   protected int pt; 
    9595 
    9696  /** Vector of byte arrays representing individual rows. */ 
     
    125125 
    126126  /** Open a PICT image from an array of bytes (used by OpenlabReader). */ 
    127   public BufferedImage open(byte[] pix) throws FormatException { 
     127  public BufferedImage open(byte[] pix) throws FormatException, IOException { 
    128128    // handles case when we call this method directly, instead of 
    129129    // through initFile(String) 
     
    137137    pictState = INITIAL; 
    138138    bytes = pix; 
    139     pt = 0; 
     139    ras = new RandomAccessStream(bytes); 
     140    ras.order(false); 
    140141 
    141142    try { 
     
    340341 
    341342  /** Loop through the remainder of the file and find relevant opcodes. */ 
    342   private boolean driveDecoder() throws FormatException { 
     343  private boolean driveDecoder() throws FormatException, IOException { 
    343344    if (debug) debug("driveDecoder"); 
    344345    int opcode; 
     
    346347    switch (pictState) { 
    347348      case INITIAL: 
    348         pt += 2; 
    349         // skip over frame 
    350         pt += 8; 
    351         int verOpcode = 
    352           DataTools.bytesToInt(bytes, pt, 1, core.littleEndian[0]); 
    353         pt++; 
    354         int verNumber = 
    355           DataTools.bytesToInt(bytes, pt, 1, core.littleEndian[0]); 
    356         pt++; 
     349        ras.skipBytes(10);  
     350        int verOpcode = ras.read();  
     351        int verNumber = ras.read();  
    357352 
    358353        if (verOpcode == 0x11 && verNumber == 0x01) versionOne = true; 
    359354        else if (verOpcode == 0x00 && verNumber == 0x11) { 
    360355          versionOne = false; 
    361           int verNumber2 = 
    362             DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    363           pt += 2; 
     356          int verNumber2 = ras.readShort();  
    364357 
    365358          if (verNumber2 != 0x02ff) { 
     
    368361 
    369362          // skip over v2 header -- don't need it here 
    370           pt += 26; 
     363          ras.skipBytes(26);  
    371364        } 
    372365        else throw new FormatException("Invalid PICT file"); 
     
    377370 
    378371      case STATE2: 
    379         if (versionOne) { 
    380           opcode = DataTools.bytesToInt(bytes, pt, 1, core.littleEndian[0]); 
    381           pt++; 
    382         } 
     372        if (versionOne) opcode = ras.read();  
    383373        else { 
    384374          // if at odd boundary skip a byte for opcode in PICT v2 
    385375 
    386           if ((pt & 0x1L) != 0) { 
    387             pt++; 
     376          if ((ras.getFilePointer() & 0x1L) != 0) { 
     377            ras.skipBytes(1);  
    388378          } 
    389           opcode = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    390           pt += 2; 
     379          opcode = ras.readShort();  
    391380        } 
    392381        return drivePictDecoder(opcode); 
     
    396385 
    397386  /** Handles the opcodes in the PICT file. */ 
    398   private boolean drivePictDecoder(int opcode) throws FormatException { 
     387  private boolean drivePictDecoder(int opcode)  
     388    throws FormatException, IOException 
     389  { 
    399390    if (debug) debug("drivePictDecoder"); 
    400391 
     
    408399        break; 
    409400      case PICT_CLIP_RGN: 
    410         int x = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    411         pt += x; 
     401        int x = ras.readShort();  
     402        ras.skipBytes(x - 2);  
    412403        break; 
    413404      case PICT_LONGCOMMENT: 
    414         pt += 2; 
    415         x = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    416         pt += x + 2; 
     405        ras.skipBytes(2);  
     406        x = ras.readShort(); 
     407        ras.skipBytes(x); 
    417408        break; 
    418409      case PICT_END: // end of PICT 
     
    421412    } 
    422413 
    423     return (pt < bytes.length); 
     414    return ras.getFilePointer() < ras.length(); 
    424415  } 
    425416 
    426417  /** Handles bitmap and pixmap opcodes of PICT format. */ 
    427   private void handlePackBits(int opcode) throws FormatException { 
     418  private void handlePackBits(int opcode)  
     419    throws FormatException, IOException  
     420  { 
    428421    if (debug) debug("handlePackBits(" + opcode + ")"); 
    429422    if (opcode == PICT_9A) { 
     
    432425    } 
    433426    else { 
    434       rowBytes = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    435       pt += 2; 
     427      rowBytes = ras.readShort(); 
    436428      if (versionOne || (rowBytes & 0x8000) == 0) handleBitmap(opcode); 
    437429      else handlePixmap(opcode); 
     
    440432 
    441433  /** Extract the image data in a PICT bitmap structure. */ 
    442   private void handleBitmap(int opcode) throws FormatException { 
     434  private void handleBitmap(int opcode)  
     435    throws FormatException, IOException  
     436  { 
    443437    if (debug) debug("handleBitmap(" + opcode + ")"); 
    444438    int row; 
     
    451445    // read the bitmap data -- 3 rectangles + mode 
    452446 
    453     int tlY = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    454     pt += 2; 
    455     int tlX = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    456     pt += 2; 
    457     int brY = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    458     pt += 2; 
    459     int brX = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    460     pt += 2; 
     447    int tlY = ras.readShort(); 
     448    int tlX = ras.readShort();  
     449    int brY = ras.readShort();  
     450    int brX = ras.readShort();  
    461451 
    462452    // skip next two rectangles 
    463     pt += 18; 
     453    ras.skipBytes(18);  
    464454 
    465455    core.sizeX[0] = brX - tlX; 
     
    479469    for (row=0; row < core.sizeY[0]; ++row) { 
    480470      if (rowBytes < 8) {  // data is not compressed 
    481         System.arraycopy(bytes, pt, buf, 0, rowBytes); 
     471        ras.read(buf, 0, rowBytes);  
    482472 
    483473        for (int j=buf.length; --j >= 0;) { 
     
    488478      else { 
    489479        int rawLen; 
    490         if (rowBytes > 250) { 
    491           rawLen = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    492           pt += 2; 
    493         } 
    494         else { 
    495           rawLen = DataTools.bytesToInt(bytes, pt, 1, core.littleEndian[0]); 
    496           pt++; 
    497         } 
     480        if (rowBytes > 250) rawLen = ras.readShort();  
     481        else rawLen = ras.read();  
    498482 
    499483        try { 
    500           System.arraycopy(bytes, pt, buf, 0, rawLen); 
    501           pt += rawLen; 
     484          ras.read(buf, 0, rawLen); 
    502485        } 
    503486        catch (ArrayIndexOutOfBoundsException e) { 
     
    519502 
    520503  /** Extracts the image data in a PICT pixmap structure. */ 
    521   private void handlePixmap(int opcode) throws FormatException { 
     504  private void handlePixmap(int opcode)  
     505    throws FormatException, IOException 
     506  { 
    522507    if (debug) debug("handlePixmap(" + opcode + ")"); 
    523508    int pixelSize; 
     
    530515      // read the pixmap (9A) 
    531516 
    532       pt += 4; // skip fake length and fake EOF 
    533  
    534       pt += 2; 
     517      ras.skipBytes(6); 
    535518 
    536519      // read the bounding box 
    537       int tlY = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    538       pt += 2; 
    539       int tlX = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    540       pt += 2; 
    541       int brY = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    542       pt += 2; 
    543       int brX = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    544       pt += 2; 
    545  
    546       pt += 2; // undocumented extra short in the data structure 
    547  
    548       pt += 16; 
    549  
    550       pixelSize = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    551       pt += 2; 
    552       compCount = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    553       pt += 16; // reserved 
     520      int tlY = ras.readShort();  
     521      int tlX = ras.readShort();  
     522      int brY = ras.readShort();  
     523      int brX = ras.readShort();  
     524 
     525      ras.skipBytes(18); 
     526 
     527      pixelSize = ras.readShort(); 
     528      compCount = ras.readShort();  
     529      ras.skipBytes(14);  
    554530 
    555531      core.sizeX[0] = brX - tlX; 
     
    570546    else { 
    571547      rowBytes &= 0x3fff;  // mask off flags 
    572  
    573       int tlY = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    574       pt += 2; 
    575       int tlX = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    576       pt += 2; 
    577       int brY = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    578       pt += 2; 
    579       int brX = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    580       pt += 2; 
    581  
    582       // unnecessary data 
    583       pt += 18; 
    584  
    585       pixelSize = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    586       pt += 2; 
    587       compCount = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    588       pt += 2; 
    589  
    590       // unnecessary data 
    591       pt += 14; 
     548       
     549      int tlY = ras.readShort(); 
     550      int tlX = ras.readShort();  
     551      int brY = ras.readShort();  
     552      int brX = ras.readShort();  
     553 
     554      ras.skipBytes(18); 
     555 
     556      pixelSize = ras.readShort(); 
     557      compCount = ras.readShort();  
     558 
     559      ras.skipBytes(14); 
    592560 
    593561      // read the lookup table 
    594562 
    595       pt += 4; 
    596       int flags = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    597       pt += 2; 
    598       int count = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    599       pt += 2; 
     563      ras.skipBytes(4); 
     564      int flags = ras.readShort();  
     565      int count = ras.readShort();  
    600566 
    601567      count++; 
     
    603569 
    604570      for (int i=0; i<count; i++) { 
    605         int index = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    606         pt += 2; 
     571        int index = ras.readShort();  
    607572        if ((flags & 0x8000) != 0) index = i; 
    608         lookup[0][index] = 
    609           DataTools.bytesToShort(bytes, pt, 2, core.littleEndian[0]); 
    610         pt += 2; 
    611         lookup[1][index] = 
    612           DataTools.bytesToShort(bytes, pt, 2, core.littleEndian[0]); 
    613         pt += 2; 
    614         lookup[2][index] = 
    615           DataTools.bytesToShort(bytes, pt, 2, core.littleEndian[0]); 
    616         pt += 2; 
     573        lookup[0][index] = ras.readShort(); 
     574        lookup[1][index] = ras.readShort(); 
     575        lookup[2][index] = ras.readShort(); 
    617576      } 
    618577 
     
    622581 
    623582    // skip over two rectangles 
    624     pt += 18; 
    625  
    626     if (opcode == PICT_BITSRGN || opcode == PICT_PACKBITSRGN) pt += 2; 
     583    ras.skipBytes(18); 
     584 
     585    if (opcode == PICT_BITSRGN || opcode == PICT_PACKBITSRGN) ras.skipBytes(2); 
    627586 
    628587    handlePixmap(rowBytes, pixelSize, compCount); 
     
    631590  /** Handles the unpacking of the image data. */ 
    632591  private void handlePixmap(int rBytes, int pixelSize, int compCount) 
    633     throws FormatException 
     592    throws FormatException, IOException 
    634593  { 
    635594    if (debug) { 
     
    676635      buf = new byte[bufSize]; 
    677636      for (int row=0; row<core.sizeY[0]; row++) { 
    678         System.arraycopy(bytes, pt, buf, 0, rBytes); 
     637        ras.read(buf, 0, rBytes); 
    679638 
    680639        switch (pixelSize) { 
     
    701660      buf = new byte[bufSize + 1 + bufSize / 128]; 
    702661      for (int row=0; row<core.sizeY[0]; row++) { 
    703         if (rBytes > 250) { 
    704           rawLen = DataTools.bytesToInt(bytes, pt, 2, core.littleEndian[0]); 
    705           pt += 2; 
    706         } 
    707         else { 
    708           rawLen = DataTools.bytesToInt(bytes, pt, 1, core.littleEndian[0]); 
    709           pt++; 
    710         } 
     662        if (rBytes > 250) rawLen = ras.readShort();  
     663        else rawLen = ras.read();  
    711664 
    712665        if (rawLen > buf.length) rawLen = buf.length; 
    713666 
    714         if ((bytes.length - pt) <= rawLen) { 
    715           rawLen = bytes.length - pt - 1; 
     667        if ((ras.length() - ras.getFilePointer()) <= rawLen) { 
     668          rawLen = (int) (ras.length() - ras.getFilePointer() - 1);  
    716669        } 
    717670 
    718671        if (rawLen < 0) { 
    719672          rawLen = 0; 
    720           pt = bytes.length - 1; 
    721         } 
    722  
    723         System.arraycopy(bytes, pt, buf, 0, rawLen); 
    724         pt += rawLen; 
     673          ras.seek(ras.length() - 1); 
     674        } 
     675 
     676        ras.read(buf, 0, rawLen); 
    725677 
    726678        if (pixelSize == 16) { 
     
    806758    int t; 
    807759    byte v; 
    808     int count = 0; // number of pixels in a byte 
    809     int maskshift = 1; // num bits to shift mask 
    810     int pixelshift = 0; // num bits to shift pixel 
     760    int count = 8 / bitSize; // number of pixels in a byte 
     761    int maskshift = bitSize; // num bits to shift mask 
     762    int pixelshift = 8 - bitSize; // num bits to shift pixel 
    811763    int tpixelshift = 0; 
    812     int pixelshiftdelta = 0; 
     764    int pixelshiftdelta = bitSize; 
    813765    int mask = 0; 
    814766    int tmask; // temp mask 
     
    821773      case 1: 
    822774        mask = 0x80; 
    823         maskshift = 1; 
    824         count = 8; 
    825         pixelshift = 7; 
    826         pixelshiftdelta = 1; 
    827775        break; 
    828776      case 2: 
    829777        mask = 0xC0; 
    830         maskshift = 2; 
    831         count = 4; 
    832         pixelshift = 6; 
    833         pixelshiftdelta = 2; 
    834778        break; 
    835779      case 4: 
    836780        mask = 0xF0; 
    837         maskshift = 4; 
    838         count = 2; 
    839         pixelshift = 4; 
    840         pixelshiftdelta = 4; 
    841781        break; 
    842782    } 
  • trunk/loci/formats/in/QTReader.java

    r2914 r2922  
    331331      case 0: 
    332332      case 1: 
     333      case 3:   
    333334        core.pixelType[0] = FormatTools.UINT8; 
    334335        break; 
    335336      case 2: 
    336         core.pixelType[0] = FormatTools.INT16; 
     337        core.pixelType[0] = FormatTools.UINT16; 
    337338        break; 
    338       case 3: 
    339         core.pixelType[0] = FormatTools.UINT8; 
    340         break; 
    341     } 
    342  
    343     /* 
    344     if (flip) { 
    345       int tmp = core.sizeX[0]; 
    346       core.sizeX[0] = core.sizeY[0]; 
    347       core.sizeY[0] = tmp; 
    348     } 
    349     */ 
     339    } 
    350340 
    351341    core.rgb[0] = bitsPerPixel < 40; 
     
    484474 
    485475      // read the atom type 
    486       byte[] four = new byte[4]; 
    487       in.read(four); 
    488       String atomType = new String(four); 
     476      String atomType = in.readString(4); 
    489477 
    490478      // if atomSize is 1, then there is an 8 byte extended size 
     
    609597 
    610598          for (int i=0; i<numEntries; i++) { 
    611             byte[] b = new byte[4]; 
    612             in.read(b); 
    613599            if (i == 0) { 
    614               codec = new String(b); 
     600              codec = in.readString(4);  
    615601              in.skipBytes(74); 
    616602 
     
    627613            } 
    628614            else { 
    629               altCodec = new String(b); 
     615              altCodec = in.readString(4);  
    630616              addMeta("Second codec", altCodec); 
    631617            } 
     
    738724    String test = null; 
    739725    boolean found = false; 
    740     byte[] b = new byte[4]; 
    741726    while (!found && in.getFilePointer() < (in.length() - 4)) { 
    742       in.read(b); 
    743       test = new String(b); 
     727      test = in.readString(4); 
    744728      if (test.equals("moov")) { 
    745729        found = true; 
  • trunk/loci/formats/in/SlidebookReader.java

    r2916 r2922  
    102102    super.initFile(id); 
    103103    in = new RandomAccessStream(id); 
     104    in.order(true); 
    104105 
    105106    status("Finding offsets to pixel data"); 
     
    216217      if (n == 'i') { 
    217218        in.skipBytes(79);  
    218         core.sizeX[0] = DataTools.read2UnsignedBytes(in, true);  
    219         core.sizeY[0] = DataTools.read2UnsignedBytes(in, true);  
     219        core.sizeX[0] = in.readShort();  
     220        core.sizeY[0] = in.readShort();  
    220221        iCount++;  
    221222      } 
  • trunk/loci/formats/in/ZeissLSMReader.java

    r2857 r2922  
    159159 
    160160      RandomAccessStream ras = new RandomAccessStream(cz); 
    161  
    162       put("MagicNumber", DataTools.read4UnsignedBytes(ras, little)); 
    163       put("StructureSize", DataTools.read4SignedBytes(ras, little)); 
    164       put("DimensionX", DataTools.read4SignedBytes(ras, little)); 
    165       put("DimensionY", DataTools.read4SignedBytes(ras, little)); 
    166  
    167       core.sizeZ[0] = DataTools.read4SignedBytes(ras, little); 
    168       int c = DataTools.read4SignedBytes(ras, little); 
    169       core.sizeT[0] = DataTools.read4SignedBytes(ras, little); 
     161      ras.order(little); 
     162 
     163      put("MagicNumber", ras.readInt()); 
     164      put("StructureSize", ras.readInt()); 
     165      put("DimensionX", ras.readInt()); 
     166      put("DimensionY", ras.readInt()); 
     167 
     168      core.sizeZ[0] = ras.readInt(); 
     169      int c = ras.readInt(); 
     170      core.sizeT[0] = ras.readInt(); 
    170171 
    171172      if (c > core.sizeC[0] || c != 1) core.sizeC[0] = c; 
     
    188189      put("DimensionTime", core.sizeT[0]); 
    189190 
    190       int dataType = DataTools.read4SignedBytes(ras, little); 
     191      int dataType = ras.readInt(); 
    191192      switch (dataType) { 
    192193        case 1: 
     
    214215        int[] bps = TiffTools.getBitsPerSample(ifd); 
    215216        switch (bps[0]) { 
    216           case 8: 
    217             core.pixelType[0] = FormatTools.UINT8; 
    218             break; 
    219217          case 16: 
    220218            core.pixelType[0] = FormatTools.UINT16; 
     
    228226      } 
    229227 
    230       put("ThumbnailX", DataTools.read4SignedBytes(ras, little)); 
    231       put("ThumbnailY", DataTools.read4SignedBytes(ras, little)); 
    232  
    233       put("VoxelSizeX", DataTools.readDouble(ras, little)); 
    234       put("VoxelSizeY", DataTools.readDouble(ras, little)); 
    235       put("VoxelSizeZ", DataTools.readDouble(ras, little)); 
    236  
    237       put("OriginX", DataTools.readDouble(ras, little)); 
    238       put("OriginY", DataTools.readDouble(ras, little)); 
    239       put("OriginZ", DataTools.readDouble(ras, little)); 
    240  
    241       int scanType = DataTools.read2UnsignedBytes(ras, little); 
     228      put("ThumbnailX", ras.readInt()); 
     229      put("ThumbnailY", ras.readInt()); 
     230 
     231      put("VoxelSizeX", ras.readDouble()); 
     232      put("VoxelSizeY", ras.readDouble()); 
     233      put("VoxelSizeZ", ras.readDouble()); 
     234 
     235      put("OriginX", ras.readDouble()); 
     236      put("OriginY", ras.readDouble()); 
     237      put("OriginZ", ras.readDouble()); 
     238 
     239      int scanType = ras.readShort(); 
    242240      switch (scanType) { 
    243241        case 0: 
     
    307305      } 
    308306 
    309       int spectralScan = DataTools.read2UnsignedBytes(ras, little); 
     307      int spectralScan = ras.readShort(); 
    310308      switch (spectralScan) { 
    311309        case 0: 
     
    319317      } 
    320318 
    321       long type = DataTools.read4UnsignedBytes(ras, little); 
     319      long type = ras.readInt(); 
    322320      switch ((int) type) { 
    323321        case 0: 
     
    334332      } 
    335333 
    336       long overlayOffset = DataTools.read4UnsignedBytes(ras, little); 
    337       long inputLUTOffset = DataTools.read4UnsignedBytes(ras, little); 
    338       long outputLUTOffset = DataTools.read4UnsignedBytes(ras, little); 
    339       long channelColorsOffset = DataTools.read4UnsignedBytes(ras, little); 
    340  
    341       put("TimeInterval", DataTools.readDouble(ras, little)); 
    342  
    343       long channelDataTypesOffset = DataTools.read4UnsignedBytes(ras, little); 
    344       long scanInformationOffset = DataTools.read4UnsignedBytes(ras, little); 
    345       long ksDataOffset = DataTools.read4UnsignedBytes(ras, little); 
    346       long timeStampOffset = DataTools.read4UnsignedBytes(ras, little); 
    347       long eventListOffset = DataTools.read4UnsignedBytes(ras, little); 
    348       long roiOffset = DataTools.read4UnsignedBytes(ras, little); 
    349       long bleachRoiOffset = DataTools.read4UnsignedBytes(ras, little); 
    350       long nextRecordingOffset = DataTools.read4UnsignedBytes(ras, little); 
    351  
    352       put("DisplayAspectX", DataTools.readDouble(ras, little)); 
    353       put("DisplayAspectY", DataTools.readDouble(ras, little)); 
    354       put("DisplayAspectZ", DataTools.readDouble(ras, little)); 
    355       put("DisplayAspectTime", DataTools.readDouble(ras, little)); 
    356  
    357       long meanOfRoisOverlayOffset = DataTools.read4UnsignedBytes(ras, little); 
    358       long topoIsolineOverlayOffset = DataTools.read4UnsignedBytes(ras, little); 
    359       long topoProfileOverlayOffset = DataTools.read4UnsignedBytes(ras, little); 
    360       long linescanOverlayOffset = DataTools.read4UnsignedBytes(ras, little); 
    361  
    362       put("ToolbarFlags", DataTools.read4UnsignedBytes(ras, little)); 
    363       long channelWavelengthOffset = DataTools.read4UnsignedBytes(ras, little); 
    364       long channelFactorsOffset = DataTools.read4UnsignedBytes(ras, little); 
    365  
    366       double objectiveSphereCorrection = DataTools.readDouble(ras, little); 
    367       long unmixParamsOffset = DataTools.read4UnsignedBytes(ras, little); 
     334      long overlayOffset = ras.readInt(); 
     335      long inputLUTOffset = ras.readInt(); 
     336      long outputLUTOffset = ras.readInt(); 
     337      long channelColorsOffset = ras.readInt(); 
     338 
     339      put("TimeInterval", ras.readDouble()); 
     340 
     341      long channelDataTypesOffset = ras.readInt(); 
     342      long scanInformationOffset = ras.readInt(); 
     343      long ksDataOffset = ras.readInt(); 
     344      long timeStampOffset = ras.readInt(); 
     345      long eventListOffset = ras.readInt(); 
     346      long roiOffset = ras.readInt(); 
     347      long bleachRoiOffset = ras.readInt(); 
     348      long nextRecordingOffset = ras.readInt(); 
     349 
     350      put("DisplayAspectX", ras.readDouble()); 
     351      put("DisplayAspectY", ras.readDouble()); 
     352      put("DisplayAspectZ", ras.readDouble()); 
     353      put("DisplayAspectTime", ras.readDouble()); 
     354 
     355      long meanOfRoisOverlayOffset = ras.readInt(); 
     356      long topoIsolineOverlayOffset = ras.readInt(); 
     357      long topoProfileOverlayOffset = ras.readInt(); 
     358      long linescanOverlayOffset = ras.readInt(); 
     359 
     360      put("ToolbarFlags", ras.readInt()); 
     361      long channelWavelengthOffset = ras.readInt(); 
     362      long channelFactorsOffset = ras.readInt(); 
     363 
     364      double objectiveSphereCorrection = ras.readDouble(); 
     365      long unmixParamsOffset = ras.readInt(); 
    368366 
    369367      // read referenced structures 
     
    420418      if (timeStampOffset != 0) { 
    421419        in.seek(timeStampOffset); 
    422         int blockSize = DataTools.read4SignedBytes(in, little); 
    423         int numberOfStamps = DataTools.read4SignedBytes(in, little); 
     420        int blockSize = in.readInt(); 
     421        int numberOfStamps = in.readInt(); 
    424422        for (int i=0; i<numberOfStamps; i++) { 
    425           put("TimeStamp" + i, DataTools.readDouble(in, little)); 
     423          put("TimeStamp" + i, in.readDouble()); 
    426424        } 
    427425      } 
  • trunk/loci/formats/ome/OMEXMLMetadataStore.java

    r2857 r2922  
    2929import java.io.IOException; 
    3030import java.lang.reflect.Constructor; 
    31 import java.util.Arrays; 
    32 import java.util.Vector; 
     31import java.util.*; 
    3332import javax.xml.parsers.ParserConfigurationException; 
    3433import javax.xml.transform.TransformerException; 
     
    9695  } 
    9796 
    98   /** Creates a new key/value pair. */ 
    99   public void setOriginalMetadata(String key, String value) { 
    100     if (firstImageCA == null) {  
    101       ImageNode image = (ImageNode) getChild(root, "Image", 0); 
    102       CustomAttributesNode ca =  
    103         (CustomAttributesNode) getChild(image, "CustomAttributes", 0); 
    104       firstImageCA = ca.getDOMElement(); 
    105  
    106       Vector original = DOMUtil.getChildElements("OriginalMetadata",  
    107         ca.getDOMElement()); 
    108       if (original.size() == 0) { 
    109         Element el = DOMUtil.createChild(root.getDOMElement(), 
    110           "SemanticTypeDefinitions"); 
    111         OMEXMLNode node = OMEXMLNode.createNode(el); 
    112         node.setAttribute("xmlns", 
    113           "http://www.openmicroscopy.org/XMLschemas/STD/RC2/STD.xsd"); 
    114         el = DOMUtil.createChild(el, "SemanticType"); 
    115         node = OMEXMLNode.createNode(el); 
    116         node.setAttribute("Name", "OriginalMetadata"); 
    117         node.setAttribute("AppliesTo", "I"); 
    118  
    119         Element nameElement = DOMUtil.createChild(el, "Element"); 
    120         OMEXMLNode nameNode = OMEXMLNode.createNode(nameElement); 
    121         nameNode.setAttribute("Name", "name"); 
    122         nameNode.setAttribute("DBLocation", "ORIGINAL_METADATA.NAME"); 
    123         nameNode.setAttribute("DataType", "string"); 
    124  
    125         Element valueElement = DOMUtil.createChild(el, "Element"); 
    126         OMEXMLNode valueNode = OMEXMLNode.createNode(valueElement); 
    127         valueElement.setAttribute("Name", "value"); 
    128         valueElement.setAttribute("DBLocation", "ORIGINAL_METADATA.VALUE"); 
    129         valueElement.setAttribute("DataType", "string"); 
    130       } 
    131     } 
    132  
    133     Element el = DOMUtil.createChild(firstImageCA, "OriginalMetadata"); 
    134     OMEXMLNode node = new AttributeNode(el); 
    135     node.setAttribute("name", key); 
    136     node.setAttribute("value", value); 
     97  /**  
     98   * Add each of the key/value pairs in the hashtable as a new 
     99   * OriginalMetadata node. 
     100   */ 
     101  public void populateOriginalMetadata(Hashtable h) { 
     102    ImageNode image = (ImageNode) getChild(root, "Image", 0); 
     103    CustomAttributesNode ca =  
     104      (CustomAttributesNode) getChild(image, "CustomAttributes", 0); 
     105    firstImageCA = ca.getDOMElement(); 
     106 
     107    Vector original = DOMUtil.getChildElements("OriginalMetadata",  
     108      ca.getDOMElement()); 
     109    if (original.size() == 0) { 
     110      Element el = DOMUtil.createChild(root.getDOMElement(), 
     111        "SemanticTypeDefinitions"); 
     112      OMEXMLNode node = OMEXMLNode.createNode(el); 
     113      node.setAttribute("xmlns", 
     114        "http://www.openmicroscopy.org/XMLschemas/STD/RC2/STD.xsd"); 
     115      el = DOMUtil.createChild(el, "SemanticType"); 
     116      node = OMEXMLNode.createNode(el); 
     117      node.setAttribute("Name", "OriginalMetadata"); 
     118      node.setAttribute("AppliesTo", "I"); 
     119 
     120      Element nameElement = DOMUtil.createChild(el, "Element"); 
     121      OMEXMLNode nameNode = OMEXMLNode.createNode(nameElement); 
     122      nameNode.setAttribute("Name", "name"); 
     123      nameNode.setAttribute("DBLocation", "ORIGINAL_METADATA.NAME"); 
     124      nameNode.setAttribute("DataType", "string"); 
     125 
     126      Element valueElement = DOMUtil.createChild(el, "Element"); 
     127      OMEXMLNode valueNode = OMEXMLNode.createNode(valueElement); 
     128      valueElement.setAttribute("Name", "value"); 
     129      valueElement.setAttribute("DBLocation", "ORIGINAL_METADATA.VALUE"); 
     130      valueElement.setAttribute("DataType", "string"); 
     131    } 
     132 
     133    Object[] keys = h.keySet().toArray(); 
     134    for (int i=0; i<h.size(); i++) { 
     135      Element el = DOMUtil.createChild(firstImageCA, "OriginalMetadata"); 
     136      OMEXMLNode node = new AttributeNode(el); 
     137      node.setAttribute("name", keys[i].toString()); 
     138      node.setAttribute("value", h.get(keys[i]).toString()); 
     139    }  
    137140  } 
    138141 
  • trunk/loci/formats/test/ConfigurationFiles.java

    r2880 r2922  
    141141              s.substring(ndx, s.indexOf(" ", ndx))); 
    142142            ndx = s.indexOf("little") + 7; 
    143             entry.littleEndian[i] = s.substring(ndx).equals("true"); 
     143            entry.littleEndian[i] =  
     144              s.substring(ndx, s.indexOf(" ", ndx)).equals("true"); 
    144145            ndx = s.indexOf("md5") + 4; 
    145             entry.md5[i] = s.substring(ndx, s.indexOf(" ", ndx)); 
     146            entry.md5[i] = s.substring(ndx); 
    146147          } 
    147148 
Note: See TracChangeset for help on using the changeset viewer.