Changeset 2377


Ignore:
Timestamp:
03/02/07 13:27:08 (13 years ago)
Author:
melissa
Message:
  • Changed BaseTiffReader.initStandardMetadata to throw IOException.
  • Implemented openBytes(String, int, byte[]) in most readers.
Location:
trunk/loci/formats
Files:
29 edited

Legend:

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

    r2182 r2377  
    811811    boolean ignore) throws FormatException, IOException 
    812812  { 
     813    int samplesPerPixel = getSamplesPerPixel(ifd); 
     814    int photoInterp = getPhotometricInterpretation(ifd); 
     815    if (samplesPerPixel == 1 && (photoInterp == RGB_PALETTE || 
     816      photoInterp == CFA_ARRAY)) 
     817    { 
     818      samplesPerPixel = 3; 
     819    } 
     820    int bpp = getBitsPerSample(ifd)[0] / 8;  
     821    long width = getImageWidth(ifd); 
     822    long length = getImageLength(ifd); 
     823    byte[] b = new byte[(int) (width * length * samplesPerPixel * bpp)]; 
     824     
     825    getSamples(ifd, in, ignore, b); 
     826    byte[][] samples = new byte[samplesPerPixel][(int) (width * length * bpp)]; 
     827    for (int i=0; i<samplesPerPixel; i++) { 
     828      System.arraycopy(b, (int) (i*width*length*bpp), samples[i], 0,  
     829        samples[i].length); 
     830    }  
     831    b = null; 
     832    return samples; 
     833  } 
     834   
     835  public static byte[] getSamples(Hashtable ifd, RandomAccessStream in, 
     836    boolean ignore, byte[] buf) throws FormatException, IOException 
     837  { 
    813838    if (DEBUG) debug("parsing IFD entries"); 
    814839 
     
    950975          } 
    951976 
    952           byte[] row = new byte[(int) imageWidth]; 
    953977          in.seek((int) stripOffsets[i]); 
    954           in.read(row); 
     978          in.read(buf, (int) (i*imageWidth), (int) imageWidth); 
    955979          boolean isZero = true; 
    956           for (int j=0; j<row.length; j++) { 
    957             if (row[j] != 0) { 
     980          for (int j=0; j<imageWidth; j++) { 
     981            if (buf[(int) (i*imageWidth + j)] != 0) { 
    958982              isZero = false; 
    959983              break; 
     
    962986 
    963987          while (isZero) { 
    964             stripOffsets[i] -= row.length; 
     988            stripOffsets[i] -= imageWidth; 
    965989            in.seek((int) stripOffsets[i]); 
    966             in.read(row); 
    967             for (int j=0; j<row.length; j++) { 
    968               if (row[j] != 0) { 
     990            in.read(buf, (int) (i*imageWidth), (int) imageWidth);  
     991            for (int j=0; j<imageWidth; j++) { 
     992              if (buf[(int) (i*imageWidth + j)] != 0) { 
    969993                isZero = false; 
    970                 stripOffsets[i] -= (stripByteCounts[i] - row.length); 
     994                stripOffsets[i] -= (stripByteCounts[i] - imageWidth); 
    971995                break; 
    972996              } 
     
    13121336    // Since the lowest common denominator for all pixel operations is "byte" 
    13131337    // we're going to normalize everything to byte. 
    1314     byte[][] byteData = null; 
    13151338 
    13161339    if (bitsPerSample[0] == 12) bitsPerSample[0] = 16; 
     
    13221345 
    13231346    if (bitsPerSample[0] == 16) { 
    1324       byteData = new byte[samplesPerPixel][numSamples * 2]; 
     1347      int pt = 0;  
    13251348      for (int i = 0; i < samplesPerPixel; i++) { 
    13261349        for (int j = 0; j < numSamples; j++) { 
    1327           byteData[i][j * 2]     = (byte) ((samples[i][j] & 0xFF00) >> 8); 
    1328           byteData[i][j * 2 + 1] = (byte) (samples[i][j] & 0x00FF); 
     1350          buf[pt++] = (byte) ((samples[i][j] & 0xff00) >> 8); 
     1351          buf[pt++] = (byte) (samples[i][j] & 0xff); 
    13291352        } 
    13301353      } 
    13311354    } 
    13321355    else if (bitsPerSample[0] == 32) { 
    1333       byteData = new byte[samplesPerPixel][numSamples * 4]; 
     1356      int pt = 0;  
    13341357      for (int i=0; i<samplesPerPixel; i++) { 
    13351358        for (int j=0; j<numSamples; j++) { 
    1336           byteData[i][j * 4] = (byte) ((samples[i][j] & 0xff000000) >> 24); 
    1337           byteData[i][j * 4 + 1] = (byte) ((samples[i][j] & 0xff0000) >> 16); 
    1338           byteData[i][j * 4 + 2] = (byte) ((samples[i][j] & 0xff00) >> 8); 
    1339           byteData[i][j * 4 + 3] = (byte) (samples[i][j] & 0xff); 
     1359          buf[pt++] = (byte) ((samples[i][j] & 0xff000000) >> 24);  
     1360          buf[pt++] = (byte) ((samples[i][j] & 0xff0000) >> 16);  
     1361          buf[pt++] = (byte) ((samples[i][j] & 0xff00) >> 8);  
     1362          buf[pt++] = (byte) (samples[i][j] & 0xff);  
    13401363        } 
    13411364      } 
    13421365    } 
    13431366    else { 
    1344       byteData = new byte[samplesPerPixel][numSamples]; 
    13451367      for (int i=0; i<samplesPerPixel; i++) { 
    13461368        for (int j=0; j<numSamples; j++) { 
    1347           byteData[i][j] = (byte) samples[i][j]; 
    1348         } 
    1349       } 
    1350     } 
    1351  
    1352     return byteData; 
     1369          buf[j + i*numSamples] = (byte) samples[i][j]; 
     1370        } 
     1371      } 
     1372    } 
     1373 
     1374    return buf;  
    13531375  } 
    13541376 
     
    13791401    if (ignore && (photoInterp == RGB_PALETTE || photoInterp == CFA_ARRAY)) { 
    13801402      photoInterp = BLACK_IS_ZERO; 
     1403      samplesPerPixel = 1; 
    13811404    } 
    13821405 
  • trunk/loci/formats/in/AVIReader.java

    r2320 r2377  
    123123    throws FormatException, IOException 
    124124  { 
     125    if (!id.equals(currentId)) initFile(id);  
     126    byte[] buf = new byte[bmpHeight * bmpScanLineSize * (bmpBitsPerPixel / 8)]; 
     127    return openBytes(id, no, buf); 
     128  } 
     129 
     130  public byte[] openBytes(String id, int no, byte[] buf) 
     131    throws FormatException, IOException 
     132  { 
    125133    if (!id.equals(currentId)) initFile(id); 
    126  
    127134    if (no < 0 || no >= getImageCount(id)) { 
    128135      throw new FormatException("Invalid image number: " + no); 
    129136    } 
    130137 
     138    if (buf.length < bmpHeight*bmpScanLineSize*(bmpBitsPerPixel / 8)) { 
     139      throw new FormatException("Buffer too small."); 
     140    } 
     141 
    131142    long fileOff = ((Long) offsets.get(no)).longValue(); 
    132143    in.seek((int) fileOff); 
    133144 
    134     int len = bmpScanLineSize; 
    135  
    136145    int pad = bmpScanLineSize - dwWidth*(bmpBitsPerPixel / 8); 
    137     rawData = new byte[bmpActualSize]; 
    138     int rawOffset = rawData.length - len; 
     146    int rawOffset = bmpActualSize - bmpScanLineSize; 
    139147    int offset = 0; 
    140148 
     
    143151    for (int i=bmpHeight - 1; i>=0; i--) { 
    144152      if (bmpBitsPerPixel == 8) { 
    145         in.read(rawData, rawOffset, len); 
     153        in.read(buf, rawOffset, bmpScanLineSize); 
    146154      } 
    147155      else { 
    148         byte[] b = new byte[dwWidth * 3]; 
    149         in.read(b); 
     156        in.read(buf, rawOffset, dwWidth * 3); 
    150157        for (int j=0; j<dwWidth; j++) { 
    151           rawData[rawOffset + j*3 + 2] = b[j*3]; 
    152           rawData[rawOffset + j*3 + 1] = b[j*3 + 1]; 
    153           rawData[rawOffset + j*3] = b[j*3 + 2]; 
     158          byte r = buf[rawOffset + j*3 + 2]; 
     159          buf[rawOffset + j*3 + 2] = buf[rawOffset + j*3]; 
     160          buf[rawOffset + j*3] = r; 
    154161        } 
    155162        in.skipBytes(pad); 
    156163      } 
    157  
    158       rawOffset -= (len - pad); 
     164      rawOffset -= (bmpScanLineSize - pad); 
    159165      offset += dwWidth; 
    160166    } 
    161  
    162     if (rawData.length == dwWidth * bmpHeight * (bmpBitsPerPixel / 8)) { 
    163       updateMinMax(rawData, no); 
    164       return rawData; 
    165     } 
    166     else { 
    167       byte[] t = new byte[dwWidth * bmpHeight * (bmpBitsPerPixel / 8)]; 
    168       System.arraycopy(rawData, 0, t, 0, t.length); 
    169       updateMinMax(t, no); 
    170       return t; 
    171     } 
     167    updateMinMax(buf, no); 
     168    return buf; 
    172169  } 
    173170 
     
    177174  { 
    178175    BufferedImage b = ImageTools.makeImage(openBytes(id, no), 
    179       dwWidth, bmpHeight, !isRGB(id) ? 1 : 3, true); 
     176      dwWidth, bmpHeight, sizeC[0], true); 
    180177    updateMinMax(b, no); 
    181178    return b; 
  • trunk/loci/formats/in/AliconaReader.java

    r2320 r2377  
    9696    throws FormatException, IOException 
    9797  { 
     98    if (!id.equals(currentId)) initFile(id);  
     99    byte[] buf = new byte[width * height * numBytes]; 
     100    return openBytes(id, no, buf); 
     101  } 
     102 
     103  public byte[] openBytes(String id, int no, byte[] buf) 
     104    throws FormatException, IOException 
     105  { 
    98106    if (!id.equals(currentId)) initFile(id); 
    99  
    100107    if (no < 0 || no >= getImageCount(id)) { 
    101108      throw new FormatException("Invalid image number: " + no); 
    102109    } 
    103110 
    104     int pad = 8 - (width % 8); 
    105     if (pad == 8) pad = 0; 
    106  
    107     in.seek(textureOffset + 
    108       (no * (width + pad) * height * numBytes)); 
    109  
    110     byte[] plane = new byte[(width + pad) * height * numBytes]; 
    111     in.read(plane); 
    112  
    113     byte[] lsbData = new byte[width * height]; 
    114     byte[] msbData = new byte[width * height]; 
    115  
    116     for (int i=0; i<height * numBytes; i++) { 
    117       if (i < height) { 
    118         System.arraycopy(plane, i*(width+pad), lsbData, i*width, width); 
     111    int pad = (8 - (width % 8)) % 8; 
     112 
     113    if (buf.length < width * height * numBytes) { 
     114      throw new FormatException("Buffer to small."); 
     115    } 
     116 
     117    for (int i=0; i<numBytes; i++) { 
     118      in.seek(textureOffset + (no * (width + pad) * height * (i+1))); 
     119      for (int j=0; j<width*height; j++) { 
     120        buf[j*numBytes + i] = (byte) in.read(); 
     121        if (j % width == width - 1) in.skipBytes(pad); 
    119122      } 
    120       else { 
    121         System.arraycopy(plane, (i % height)*(width + pad), msbData, 
    122           (i % height)*width, width); 
    123       } 
    124     } 
    125  
    126     if (numBytes == 2) { 
    127       byte[] data = new byte[width * height * 2]; 
    128       for (int i=0; i<width*height; i++) { 
    129         data[i*2] = lsbData[i]; 
    130         data[i*2 + 1] = msbData[i]; 
    131       } 
    132       updateMinMax(data, no); 
    133       return data; 
    134     } 
    135     updateMinMax(lsbData, no); 
    136     return lsbData; 
     123    } 
     124 
     125    updateMinMax(buf, no); 
     126    return buf; 
    137127  } 
    138128 
     
    235225    ); 
    236226 
    237     store.setDimensions( 
    238       new Float(((String) getMeta("PlanePntX")).trim()), 
    239       new Float(((String) getMeta("PlanePntY")).trim()), 
    240       new Float(((String) getMeta("PlanePntZ")).trim()), null, null, null); 
     227    if (getMeta("Voltage") != null) { 
     228      store.setDetector(null, null, null, null, null,  
     229        new Float((String) getMeta("Voltage")), null, null, null); 
     230    } 
     231    if (getMeta("Magnification") != null) { 
     232      store.setObjective(null, null, null, null,  
     233        new Float((String) getMeta("Magnification")), null, null); 
     234    } 
     235 
     236    if (getMeta("PlanePntX") != null && getMeta("PlanePntY") != null && 
     237      getMeta("PlanePntZ") != null) 
     238    { 
     239      store.setDimensions( 
     240        new Float(((String) getMeta("PlanePntX")).trim()), 
     241        new Float(((String) getMeta("PlanePntY")).trim()), 
     242        new Float(((String) getMeta("PlanePntZ")).trim()), null, null, null); 
     243    } 
    241244 
    242245    for (int i=0; i<sizeC[0]; i++) { 
  • trunk/loci/formats/in/BMPReader.java

    r2320 r2377  
    115115  } 
    116116 
     117  public byte[] openBytes(String id, int no, byte[] buf) 
     118    throws FormatException, IOException 
     119  { 
     120    if (!id.equals(currentId)) initFile(id); 
     121    if (no < 0 || no >= getImageCount(id)) { 
     122      throw new FormatException("Invalid image number: " + no); 
     123    } 
     124    
     125    if (width % 2 == 1) width++; 
     126    
     127    if (buf.length < width * height * (bpp / 8)) { 
     128      throw new FormatException("Buffer too small."); 
     129    } 
     130 
     131    if (compression != 0) { 
     132      throw new FormatException("Compression type " + compression + 
     133        " not supported"); 
     134    } 
     135 
     136    in.seek(global); 
     137    int pixels = width * height; 
     138 
     139    if (palette != null && palette[0].length > 0 && !ignoreColorTable) { 
     140      for (int y=height-1; y>=0; y--) { 
     141        for (int x=0; x<width; x++) { 
     142          int val = in.read(); 
     143          if (val < 0) val += 127; 
     144          buf[y*width + x] = palette[0][val]; 
     145          buf[y*width + x + pixels] = palette[1][val]; 
     146          buf[y*width + x + 2*pixels] = palette[2][val]; 
     147        } 
     148      } 
     149    } 
     150    else { 
     151      if (bpp <= 8) { 
     152        for (int y=height-1; y>=0; y--) { 
     153          for (int x=0; x<width; x++) { 
     154            buf[y*width + x] = (byte) in.read(); 
     155          } 
     156        } 
     157      } 
     158      else { 
     159        for (int y=height-1; y>=0; y--) { 
     160          for (int x=0; x<width; x++) { 
     161            buf[y*width + x + 2*pixels] = (byte) in.read(); 
     162            buf[y*width + x + pixels] = (byte) in.read(); 
     163            buf[y*width + x] = (byte) in.read(); 
     164            for (int j=0; j<(bpp - 24) / 8; j++) in.read();  
     165          }  
     166        } 
     167      } 
     168    } 
     169    updateMinMax(buf, no); 
     170    return buf; 
     171  } 
     172 
    117173  /** Obtains the specified image from the given BMP file as a byte array. */ 
    118174  public byte[] openBytes(String id, int no) 
     
    120176  { 
    121177    if (!id.equals(currentId)) initFile(id); 
    122  
    123     if (no < 0 || no >= getImageCount(id)) { 
    124       throw new FormatException("Invalid image number: " + no); 
    125     } 
    126  
    127     in.seek(global); 
    128  
    129     if (width % 2 == 1) width++; 
    130  
    131     byte[] pix = new byte[width * height * (bpp / 8)]; 
    132     in.read(pix); 
    133  
    134     byte[][] pixels = new byte[0][0]; 
    135  
    136     // check to make sure that the pixel data is uncompressed 
    137     // we aren't going to support compressed data, since only crazy people 
    138     // compress bitmaps :-) 
    139  
    140     if (compression != 0) { 
    141       throw new FormatException("Compression type " + compression + 
    142         " not supported"); 
    143     } 
    144  
    145     if (palette == null) palette = new byte[1][0]; 
    146  
    147     if (palette[0].length != 0 && !ignoreColorTable) { 
    148       pixels = new byte[3][pix.length]; 
    149       int pt = pix.length; 
    150       for (int i=0; i<pix.length; i++) { 
    151         if (pix[i] < 0) pix[i] += 127; 
    152         pixels[0][pt] = palette[0][pix[i]]; 
    153         pixels[1][pt] = palette[1][pix[i]]; 
    154         pixels[2][pt] = palette[2][pix[i]]; 
    155         pt--; 
    156       } 
    157     } 
    158     else { 
    159       if (bpp <= 8) { 
    160         pixels = new byte[3][pix.length]; 
    161  
    162         int pt = pix.length - 1; 
    163         for (int i=0; i<pix.length; i++) { 
    164           pixels[0][i] = pix[pt]; 
    165           pixels[1][i] = pix[pt]; 
    166           pixels[2][i] = pix[pt]; 
    167           pt--; 
    168         } 
    169       } 
    170       else if (bpp == 24) { 
    171         pixels = new byte[3][pix.length / 3]; 
    172         int pt = pix.length - 1; 
    173         for (int j=0; j<pixels[0].length; j++) { 
    174           pixels[0][j] = pix[pt]; 
    175           pixels[1][j] = pix[pt - 1]; 
    176           pixels[2][j] = pix[pt - 2]; 
    177           pt -= 3; 
    178         } 
    179       } 
    180       else if (bpp == 32) { 
    181         pixels = new byte[3][pix.length / 4]; 
    182         int pt = pix.length - 1; 
    183         for (int j=0; j<pixels[0].length; j++) { 
    184           pixels[0][j] = pix[pt]; 
    185           pixels[1][j] = pix[pt - 1]; 
    186           pixels[2][j] = pix[pt - 2]; 
    187           pt -= 4; 
    188         } 
    189         bpp = 24; 
    190       } 
    191     } 
    192  
    193     // need to reverse each row 
    194  
    195     byte[][] tempPx = new byte[pixels.length][pixels[0].length]; 
    196  
    197     for (int j=0; j < height; j++) { 
    198       int oldOff = width * j; 
    199       int newOff = width * (j+1) - 1; 
    200       for (int k=0; k < width; k++) { 
    201         tempPx[0][oldOff] = pixels[0][newOff]; 
    202         tempPx[1][oldOff] = pixels[1][newOff]; 
    203         tempPx[2][oldOff] = pixels[2][newOff]; 
    204  
    205         oldOff++; 
    206         newOff--; 
    207       } 
    208     } 
    209  
    210     byte[] p = new byte[sizeC[0] * tempPx[0].length]; 
    211     for (int i=0; i<sizeC[0]; i++) { 
    212       System.arraycopy(tempPx[i], 0, p, i * tempPx[i].length, 
    213         tempPx[i].length); 
    214     } 
    215     updateMinMax(p, no); 
    216     return p; 
     178    if (width % 2 == 1) width++;  
     179    byte[] buf = new byte[width * height * (bpp / 8)]; 
     180    return openBytes(id, no, buf); 
    217181  } 
    218182 
  • trunk/loci/formats/in/BaseTiffReader.java

    r2320 r2377  
    2929import java.nio.ByteBuffer; 
    3030import java.nio.ShortBuffer; 
     31import java.text.*; 
    3132import java.util.*; 
    3233import loci.formats.*; 
     
    8081 
    8182  /** Populates the metadata hashtable and metadata store. */ 
    82   protected void initMetadata() throws FormatException { 
     83  protected void initMetadata() throws FormatException, IOException { 
    8384    initStandardMetadata(); 
    8485    initMetadataStore(); 
     
    9293   * overwritten if you do so. 
    9394   */ 
    94   protected void initStandardMetadata() throws FormatException { 
     95  protected void initStandardMetadata() throws FormatException, IOException { 
    9596    Hashtable ifd = ifds[0]; 
    9697    if (metadata == null) metadata = new Hashtable(); 
     
    545546      } 
    546547 
     548      // format the creation date to ISO 8061  
     549 
     550      String creationDate = getImageCreationDate(); 
     551      try { 
     552        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss"); 
     553        Date date = DateFormat.getDateTimeInstance().parse(creationDate); 
     554        creationDate = sdf.format(date); 
     555      } 
     556      catch (Exception e) { 
     557        if (debug) e.printStackTrace(); 
     558        creationDate = "";  
     559      } 
     560 
    547561      // populate Image element 
     562       
    548563      store.setImage(getImageName(), 
    549         getImageCreationDate(), getImageDescription(), null); 
     564        creationDate, getImageDescription(), null); 
    550565 
    551566      // populate Logical Channel elements 
     
    562577      } 
    563578 
    564       // populate the default display options 
    565 //      store.setDefaultDisplaySettings(null); 
    566  
    567       // use a default "real" pixel dimension of 1 for each dimensionality. 
    568       Float f = new Float(1); 
    569       store.setDimensions(f, f, f, f, f, null); 
    570  
    571       // populate Dimensions element 
    572       int pixelSizeX = TiffTools.getIFDIntValue(ifd, 
    573         TiffTools.CELL_WIDTH, false, 0); 
    574       int pixelSizeY = TiffTools.getIFDIntValue(ifd, 
    575         TiffTools.CELL_LENGTH, false, 0); 
    576       int pixelSizeZ = TiffTools.getIFDIntValue(ifd, 
    577         TiffTools.ORIENTATION, false, 0); 
    578       store.setDimensions(new Float(pixelSizeX), new Float(pixelSizeY), 
    579                           new Float(pixelSizeZ), null, null, null); 
    580  
    581 //      OMETools.setAttribute(ome, "ChannelInfo", "SamplesPerPixel", "" + 
    582 //        TiffTools.getIFDIntValue(ifd, TiffTools.SAMPLES_PER_PIXEL)); 
     579      // set the X and Y pixel dimensions 
     580 
     581      int resolutionUnit = TiffTools.getIFDIntValue(ifd,  
     582        TiffTools.RESOLUTION_UNIT); 
     583      TiffRational xResolution = TiffTools.getIFDRationalValue(ifd,  
     584        TiffTools.X_RESOLUTION, false); 
     585      TiffRational yResolution = TiffTools.getIFDRationalValue(ifd, 
     586        TiffTools.Y_RESOLUTION, false); 
     587      float pixX = xResolution == null ? 0f : xResolution.floatValue();  
     588      float pixY = yResolution == null ? 0f : yResolution.floatValue();  
     589 
     590      switch (resolutionUnit) { 
     591        case 2: 
     592          // resolution is expressed in pixels per inch 
     593          pixX *= 2.54; 
     594          pixY *= 2.54; 
     595        case 3: 
     596          // resolution is expressed in pixels per centimeter 
     597          pixX /= 100;  
     598          pixY /= 100;  
     599          break; 
     600      } 
     601 
     602      store.setDimensions(new Float(pixX), new Float(pixY), null,  
     603        null, null, null); 
    583604 
    584605      // populate StageLabel element 
     
    695716    } 
    696717 
    697     byte[][] p = null; 
    698     p = TiffTools.getSamples(ifds[no], in, ignoreColorTable); 
    699     for (int i=0; i<p.length; i++) { 
    700       swapIfRequired(p[i]); 
    701       System.arraycopy(p[i], 0, buf, i * p[0].length, p[0].length); 
    702     } 
     718    TiffTools.getSamples(ifds[no], in, ignoreColorTable, buf);   
    703719    updateMinMax(buf, no); 
    704720    return buf; 
     
    716732 
    717733    int bytesPerPixel = FormatReader.getBytesPerPixel(getPixelType(id)); 
    718     byte[] buf = null; 
    719     if (isRGB(id)) { 
    720       buf = 
    721         new byte[getSizeX(id) * getSizeY(id) * getSizeC(id) * bytesPerPixel]; 
    722     } 
    723     else buf = new byte[getSizeX(id) * getSizeY(id) * bytesPerPixel]; 
    724  
     734    byte[] buf =  
     735      new byte[getSizeX(id) * getSizeY(id) * bytesPerPixel * getSizeC(id)]; 
    725736    return openBytes(id, no, buf); 
    726737  } 
  • trunk/loci/formats/in/BioRadReader.java

    r2320 r2377  
    139139    throws FormatException, IOException 
    140140  { 
    141     if(!id.equals(currentId)) initFile(id); 
    142  
    143     if(no < 0 || no >= npic) { 
     141    if (!id.equals(currentId)) initFile(id);  
     142    byte[] buf = new byte[nx * ny * (byteFormat ? 1 : 2)]; 
     143    return openBytes(id, no, buf); 
     144  } 
     145   
     146  public byte[] openBytes(String id, int no, byte[] buf) 
     147    throws FormatException, IOException 
     148  { 
     149    if (!id.equals(currentId)) initFile(id); 
     150    if (no < 0 || no >= npic) { 
    144151      throw new FormatException("Invalid image number: " + no); 
    145152    } 
    146  
    147     // read image bytes 
    148     int imageLen = nx * ny; 
    149     byte[] data = new byte[imageLen * ((byteFormat) ? 1 : 2)]; 
    150     int offset = no * imageLen; 
    151     if (!byteFormat) offset *= 2; 
     153    if (buf.length < nx * ny * (byteFormat ? 1 : 2)) { 
     154      throw new FormatException("Buffer too small."); 
     155    } 
     156 
     157    int offset = no * nx * ny * (byteFormat ? 1 : 2); 
    152158    in.seek(offset + 76); 
    153     in.read(data); 
    154     updateMinMax(data, no); 
    155     return data; 
     159    in.read(buf); 
     160    updateMinMax(buf, no); 
     161    return buf; 
    156162  } 
    157163 
  • trunk/loci/formats/in/DeltavisionReader.java

    r2320 r2377  
    190190    throws FormatException, IOException 
    191191  { 
     192    if (!id.equals(currentId)) initFile(id);  
    192193    byte[] buf = new byte[width * height * bytesPerPixel]; 
    193194    return openBytes(id, no, buf); 
  • trunk/loci/formats/in/DicomReader.java

    r2320 r2377  
    144144  { 
    145145    if (!id.equals(currentId)) initFile(id); 
    146  
     146    byte[] buf = new byte[width * height * (bitsPerPixel / 8)]; 
     147    return openBytes(id, no, buf); 
     148  } 
     149 
     150  public byte[] openBytes(String id, int no, byte[] buf) 
     151    throws FormatException, IOException 
     152  { 
     153    if (!id.equals(currentId)) initFile(id); 
    147154    if (no < 0 || no >= getImageCount(id)) { 
    148155      throw new FormatException("Invalid image number: " + no); 
    149156    } 
    150  
    151     byte[] data = new byte[width * height * (bitsPerPixel / 8)]; 
    152  
    153     in.seek(offsets + data.length * no); 
    154     in.read(data); 
    155  
    156     if (bitsPerPixel == 16) { 
    157       // may still be broken on some samples, but it's better than it was 
    158  
    159       for (int i=0; i<data.length; i++) { 
    160         data[i] = (byte) (255 - data[i]); 
    161       } 
    162  
    163       String windowCenter = (String) getMeta("Window Center"); 
    164       String windowWidth = (String) getMeta("Window Width"); 
    165       if (windowCenter != null && windowCenter.indexOf("\\") != -1) { 
    166         windowCenter = windowCenter.substring(windowCenter.indexOf("\\") + 1); 
    167       } 
    168       if (windowWidth != null && windowWidth.indexOf("\\") != -1) { 
    169         windowWidth = windowWidth.substring(windowWidth.indexOf("\\") + 1); 
    170       } 
    171  
    172       double wCenter = 0; 
    173       if (windowCenter != null) wCenter = Double.parseDouble(windowCenter); 
    174       double wWidth = 0; 
    175       if (windowWidth != null) wWidth = Double.parseDouble(windowWidth); 
    176  
    177       double min = (wCenter - wWidth / 2) + 3964; 
    178       double max = (wCenter + wWidth / 2) - 2540; 
    179  
    180       short[] shortData = new short[width * height]; 
    181       int minValue = Integer.MAX_VALUE; 
    182       int maxValue = Integer.MIN_VALUE; 
    183       for (int i=0; i<data.length; i+=2) { 
    184         shortData[i/2] = DataTools.bytesToShort(data, i, 2, little); 
    185         if (shortData[i/2] < minValue) minValue = shortData[i/2]; 
    186         if (shortData[i/2] > maxValue) maxValue = shortData[i/2]; 
    187       } 
    188  
    189       String rescale = (String) getMeta("Rescale Intercept"); 
    190       double scale = 0; 
    191       if (rescale != null) { 
    192         rescale = rescale.trim(); 
    193         scale = Double.parseDouble(rescale); 
    194       } 
    195  
    196       if (min < minValue) { 
    197         for (int i=0; i<shortData.length; i++) { 
    198           shortData[i] = (short) (shortData[i] - (minValue - min) + scale); 
    199         } 
    200       } 
    201       else { 
    202         for (int i=0; i<shortData.length; i++) { 
    203           shortData[i] = (short) (shortData[i] + (min - minValue) + scale); 
    204         } 
    205       } 
    206  
    207       if (max < maxValue) { 
    208         for (int i=0; i<shortData.length; i++) { 
    209           shortData[i] = (short) (shortData[i] - (maxValue - max)); 
    210         } 
    211       } 
    212       else { 
    213         for (int i=0; i<shortData.length; i++) { 
    214           shortData[i] = (short) (shortData[i] - (max - maxValue)); 
    215         } 
    216       } 
    217  
    218       data = new byte[shortData.length * 2]; 
    219       for (int i=0; i<shortData.length; i++) { 
    220         byte[] b = DataTools.shortToBytes(shortData[i], little); 
    221         data[2*i] = b[0]; 
    222         data[2*i + 1] = b[1]; 
    223       } 
    224     } 
    225     updateMinMax(data, no); 
    226     return data; 
     157    if (buf.length < width * height * (bitsPerPixel / 8)) { 
     158      throw new FormatException("Buffer too small."); 
     159    } 
     160     
     161    in.seek(offsets + (width * height * (bitsPerPixel / 8) * no)); 
     162    in.read(buf); 
     163    updateMinMax(buf, no); 
     164    return buf; 
    227165  } 
    228166 
  • trunk/loci/formats/in/EPSReader.java

    r2307 r2377  
    103103    throws FormatException, IOException 
    104104  { 
     105    if (!id.equals(currentId)) initFile(id);  
     106    byte[] buf = new byte[width * height * channels * (bps / 8)]; 
     107    return openBytes(id, no, buf); 
     108  } 
     109 
     110  public byte[] openBytes(String id, int no, byte[] buf) 
     111    throws FormatException, IOException 
     112  { 
    105113    if (!id.equals(currentId)) initFile(id); 
    106  
    107114    if (no < 0 || no >= getImageCount(id)) { 
    108115      throw new FormatException("Invalid image number: " + no); 
    109116    } 
    110  
    111     close(); 
    112  
    113     byte[] p = new byte[width * height * channels * (bps / 8)]; 
    114  
     117    if (buf.length < width * height * channels * (bps / 8)) { 
     118      throw new FormatException("Buffer too small."); 
     119    } 
     120  
    115121    RandomAccessStream ras = new RandomAccessStream(id); 
    116122    int line = 0; 
     
    122128 
    123129    if (binary) { 
    124       ras.read(p, 0, p.length); 
     130      ras.read(buf, 0, buf.length); 
    125131    } 
    126132    else { 
     
    128134      String len = ras.readLine(); 
    129135      ras.seek(pos); 
    130       int numLines = p.length / len.trim().length(); 
    131  
    132       byte[] tmp = new byte[p.length * 2 + 3*numLines]; 
    133       ras.read(tmp, 0, tmp.length); 
    134       String pixels = new String(tmp); 
    135       pixels = pixels.replaceAll("\n", ""); 
    136  
    137       // every 2 characters in the pixels string represents 1 byte 
    138  
    139       for (int i=0; i<p.length; i++) { 
    140         if (i < p.length - 1) { 
    141           String s = pixels.substring(i*2, (i+1)*2); 
    142           p[i] = (byte) Integer.parseInt(s, 16); 
    143         } 
    144         else { 
    145           String s = pixels.substring(i*2); 
    146           if (s.length() > 2) s = s.substring(0, 2); 
    147           p[i] = (byte) Integer.parseInt(s, 16); 
    148         } 
     136      int numLines = buf.length / len.trim().length(); 
     137 
     138      for (int i=0; i<buf.length; i++) { 
     139        char msb = (char) ras.read(); 
     140        while (msb == '\n') msb = (char) ras.read(); 
     141        char lsb = (char) ras.read(); 
     142        while (lsb == '\n') lsb = (char) ras.read(); 
     143        String s = new String(new char[] {msb, lsb}); 
     144        buf[i] = (byte) Integer.parseInt(s, 16); 
    149145      } 
    150146    } 
    151147    ras.close(); 
    152     updateMinMax(p, no); 
    153     return p; 
    154   } 
     148    updateMinMax(buf, no); 
     149    return buf; 
     150  } 
     151 
    155152 
    156153  /** Obtains the specified image from the given EPS file. */ 
  • trunk/loci/formats/in/GIFReader.java

    r2320 r2377  
    171171  public byte[] openBytes(String id, int no) throws FormatException, IOException 
    172172  { 
     173    if (!id.equals(currentId)) initFile(id);  
     174    byte[] buf = new byte[width * height * sizeC[0]]; 
     175    return openBytes(id, no, buf); 
     176  } 
     177 
     178  public byte[] openBytes(String id, int no, byte[] buf) 
     179    throws FormatException, IOException 
     180  { 
    173181    if (!id.equals(currentId)) initFile(id); 
    174  
    175182    if (no < 0 || no >= getImageCount(id)) { 
    176183      throw new FormatException("Invalid image number: " + no); 
    177184    } 
    178  
    179     byte[] b = new byte[1]; 
     185    if (buf.length < width * height * sizeC[0]) { 
     186      throw new FormatException("Buffer too small."); 
     187    } 
     188 
    180189    int[] ints = (int[]) images.get(no); 
    181190 
    182     if (!ignoreColorTable) { 
    183       b = new byte[width * height * 3]; 
     191    if (ignoreColorTable) { 
     192      for (int i=0; i<buf.length; i++) buf[i] = (byte) ints[i];  
     193    } 
     194    else { 
    184195      for (int i=0; i<ints.length; i++) { 
    185         b[i] = (byte) ((ints[i] & 0xff0000) >> 16); 
    186         b[i + ints.length] = (byte) ((ints[i] & 0xff00) >> 8); 
    187         b[i + 2*ints.length] = (byte) (ints[i] & 0xff); 
    188       } 
    189     } 
    190     else { 
    191       b = new byte[width * height]; 
    192       for (int i=0; i<b.length; i++) b[i] = (byte) ints[i]; 
    193     } 
    194     updateMinMax(b, no); 
    195     return b; 
     196        buf[i] = (byte) ((ints[i] & 0xff0000) >> 16); 
     197        buf[i + ints.length] = (byte) ((ints[i] & 0xff00) >> 8); 
     198        buf[i + 2*ints.length] = (byte) (ints[i] & 0xff); 
     199      } 
     200    } 
     201    updateMinMax(buf, no);  
     202    return buf;  
    196203  } 
    197204 
     
    542549 
    543550  private void setPixels() { 
    544  
    545551    // expose destination image's pixels as an int array 
    546552    int[] dest = new int[width * height]; 
  • trunk/loci/formats/in/GatanReader.java

    r2320 r2377  
    4949  protected boolean littleEndian; 
    5050 
    51   /** Array of pixel bytes. */ 
    52   protected byte[] pixelData; 
     51  /** Offset to pixel data. */ 
     52  private long pixelOffset; 
    5353 
    5454  /** List of pixel sizes. */ 
     
    129129    throws FormatException, IOException 
    130130  { 
     131    if (!id.equals(currentId)) initFile(id);  
     132    byte[] buf = new byte[dims[0] * dims[1] * dims[2]]; 
     133    return openBytes(id, no, buf); 
     134  } 
     135 
     136  public byte[] openBytes(String id, int no, byte[] buf) 
     137    throws FormatException, IOException 
     138  { 
    131139    if (!id.equals(currentId)) initFile(id); 
    132  
    133     if (no < 0 || no >= getImageCount(id)) { 
     140    if (no != 0) { 
    134141      throw new FormatException("Invalid image number: " + no); 
    135142    } 
    136     updateMinMax(pixelData, no); 
    137     return pixelData; 
     143    if (buf.length < dims[0] * dims[1] * dims[2]) { 
     144      throw new FormatException("Buffer too small."); 
     145    }  
     146  
     147    in.seek(pixelOffset); 
     148    in.read(buf); 
     149    return buf; 
    138150  } 
    139151 
     
    148160    } 
    149161 
    150     int width = dims[0]; 
    151     int height = dims[1]; 
    152     int channels = 1; 
    153  
    154     BufferedImage b = ImageTools.makeImage(pixelData, width, height, channels, 
    155       false, dims[2], littleEndian); 
     162    BufferedImage b = ImageTools.makeImage(openBytes(id, no), dims[0], dims[1], 
     163      1, false, dims[2], littleEndian); 
    156164    updateMinMax(b, no); 
    157165    return b; 
     
    169177    in = null; 
    170178    currentId = null; 
    171     pixelData = null; 
     179    pixelOffset = 0;  
    172180  } 
    173181 
     
    285293    store.setDimensions(pixX, pixY, pixZ, null, null, null); 
    286294 
     295    String gamma = (String) getMeta("Gamma"); 
    287296    for (int i=0; i<sizeC[0]; i++) { 
    288297      store.setLogicalChannel(i, null, null, null, null, null, null, null); 
    289     } 
     298      store.setDisplayChannel(new Integer(i), null, null,  
     299        gamma == null ? null : new Float(gamma), null); 
     300    } 
     301 
     302    String mag = (String) getMeta("Indicated Magnification"); 
     303    store.setObjective(null, null, null, null,  
     304      mag == null ? null : new Float(mag), null, null); 
    290305 
    291306  } 
     
    402417                bpp *= 2; 
    403418                in.seek(pos); 
    404                 pixelData = new byte[(int) bpp * length]; 
    405                 in.read(pixelData); 
     419                pixelOffset = pos; 
     420                in.skipBytes((int) (bpp * length)); 
    406421                check = in.readByte(); 
    407422              } 
  • trunk/loci/formats/in/GelReader.java

    r2320 r2377  
    6262 
    6363  /* @see loci.formats.BaseTiffReader#initStandardMetadata() */ 
    64   protected void initStandardMetadata() throws FormatException { 
     64  protected void initStandardMetadata() throws FormatException, IOException { 
    6565    super.initStandardMetadata(); 
    6666 
     
    9898    sizeT[series] = numImages; 
    9999 
    100     try { 
    101       MetadataStore store = getMetadataStore(currentId); 
    102       store.setDimensions(new Float(scale.floatValue()), 
    103         new Float(scale.floatValue()), null, null, null, null); 
    104     } 
    105     catch (IOException e) { 
    106       throw new FormatException(e); 
    107     } 
     100    MetadataStore store = getMetadataStore(currentId); 
     101    store.setDimensions(new Float(scale.floatValue()), 
     102      new Float(scale.floatValue()), null, null, null, null); 
    108103  } 
    109104 
  • trunk/loci/formats/in/IPLabReader.java

    r2320 r2377  
    137137    throws FormatException, IOException 
    138138  { 
     139    if (!id.equals(currentId)) initFile(id);  
     140    byte[] buf = new byte[width * height * bps * c]; 
     141    return openBytes(id, no, buf); 
     142  } 
     143 
     144  public byte[] openBytes(String id, int no, byte[] buf) 
     145    throws FormatException, IOException 
     146  { 
    139147    if (!id.equals(currentId)) initFile(id); 
    140  
    141148    if (no < 0 || no >= getImageCount(id)) { 
    142149      throw new FormatException("Invalid image number: " + no); 
    143150    } 
    144  
     151     
    145152    int numPixels = width * height * c; 
     153    if (buf.length < numPixels * bps) { 
     154      throw new FormatException("Buffer too small."); 
     155    }  
    146156    in.seek(numPixels * bps * (no / c) + 44); 
    147157 
    148     byte[] rawData = new byte[numPixels * bps]; 
    149     in.read(rawData); 
    150     updateMinMax(rawData, no); 
    151     return rawData; 
     158    in.read(buf); 
     159    updateMinMax(buf, no); 
     160    return buf; 
    152161  } 
    153162 
     
    392401          store.setChannelGlobalMinMax(i, new Double(min), 
    393402            new Double(max), null); 
    394           // TODO : set DisplayChannel here 
     403         
     404          store.setDisplayChannel(new Integer(c), new Double(black), 
     405            new Double(white), new Float(gamma), null); 
    395406        } 
    396407      } 
     
    398409        // read in header labels 
    399410 
    400         in.readInt(); // size is defined to 2200 
    401  
    402         for (int i=0; i<100; i++) { 
     411        int size = in.readInt(); 
     412 
     413        byte[] headerString = new byte[20]; 
     414        for (int i=0; i<size / (headerString.length + 2); i++) { 
    403415          int num = in.readShort(); 
    404           in.read(fourBytes); 
     416          in.read(headerString); 
    405417          String name = new String(fourBytes); 
    406418          addMeta("Header" + num, name); 
    407419        } 
     420      } 
     421      else if (tag.equals("mmrc")) { 
     422        in.skipBytes(in.readInt()); 
    408423      } 
    409424      else if (tag.equals("roi ")) { 
     
    428443      else if (tag.equals("mask")) { 
    429444        // read in Segmentation Mask 
     445        int size = in.readInt(); 
     446        in.skipBytes(size); 
    430447      } 
    431448      else if (tag.equals("unit")) { 
     
    442459 
    443460          if (i == 0) { 
    444             Float pixelSize = new Float(unitsPerPixel); 
     461            Float pixelSize = new Float(1 / (float) unitsPerPixel); 
    445462            store.setDimensions(pixelSize, pixelSize, null, null, null, null); 
    446463          } 
  • trunk/loci/formats/in/IPWReader.java

    r2320 r2377  
    111111  { 
    112112    if (!id.equals(currentId)) initFile(id); 
    113  
     113    int c = getRGBChannelCount(id); 
     114    if (c == 2) c++; 
     115    byte[] buf = new byte[sizeX[0] * sizeY[0] * c *  
     116      FormatReader.getBytesPerPixel(pixelType[0])]; 
     117    return openBytes(id, no, buf); 
     118  } 
     119 
     120  public byte[] openBytes(String id, int no, byte[] buf) 
     121    throws FormatException, IOException 
     122  { 
     123    if (!id.equals(currentId)) initFile(id); 
    114124    if (no < 0 || no >= getImageCount(id)) { 
    115125      throw new FormatException("Invalid image number: " + no); 
    116126    } 
    117  
     127  
    118128    try { 
    119129      String directory = (String) pixels.get(new Integer(no)); 
     
    131141        r.setVar("entryName", name); 
    132142        r.exec("document = root.getEntry(entryName)"); 
    133       } 
    134  
     143      }  
     144     
    135145      r.exec("dis = new DocumentInputStream(document)"); 
    136146      r.exec("numBytes = dis.available()"); 
    137147      int numBytes = ((Integer) r.getVar("numBytes")).intValue(); 
    138       byte[] b = new byte[numBytes + 4]; // append 0 for final offset 
     148      byte[] b = new byte[numBytes + 4];  
    139149      r.setVar("data", b); 
    140150      r.exec("dis.read(data)"); 
     
    143153      ifds = TiffTools.getIFDs(stream); 
    144154      little = TiffTools.isLittleEndian(ifds[0]); 
    145       byte[][] samples = 
    146         TiffTools.getSamples(ifds[0], stream, ignoreColorTable); 
    147  
    148       byte[] rtn = new byte[samples.length * samples[0].length]; 
    149       for (int i=0; i<samples.length; i++) { 
    150         System.arraycopy(samples[i], 0, rtn, i*samples[i].length, 
    151           samples[i].length); 
    152       } 
     155      TiffTools.getSamples(ifds[0], stream, ignoreColorTable, buf); 
    153156      stream.close(); 
    154       updateMinMax(rtn, no); 
    155       return rtn; 
    156     } 
    157     catch (ReflectException e) { 
     157      updateMinMax(buf, no); 
     158      return buf; 
     159    } 
     160    catch (ReflectException e) {  
    158161      noPOI = true; 
    159       return new byte[0]; 
     162      return null; 
    160163    } 
    161164  } 
  • trunk/loci/formats/in/ImarisReader.java

    r2320 r2377  
    203203    throws FormatException, IOException 
    204204  { 
     205    if (!id.equals(currentId)) initFile(id);  
     206    byte[] buf = new byte[dims[0] * dims[1]]; 
     207    return openBytes(id, no, buf); 
     208  } 
     209 
     210  public byte[] openBytes(String id, int no, byte[] buf) 
     211    throws FormatException, IOException 
     212  { 
    205213    if (!id.equals(currentId)) initFile(id); 
    206  
    207214    if (no < 0 || no >= getImageCount(id)) { 
    208215      throw new FormatException("Invalid image number: " + no); 
    209216    } 
     217    if (buf.length < dims[0] * dims[1]) { 
     218      throw new FormatException("Buffer too small."); 
     219    } 
    210220 
    211221    in.seek(offsets[no]); 
    212     byte[] data = new byte[dims[0] * dims[1]]; 
    213  
    214222    int row = dims[1] - 1; 
    215223    for (int i=0; i<dims[1]; i++) { 
    216       in.read(data, row*dims[0], dims[0]); 
     224      in.read(buf, row*dims[0], dims[0]); 
    217225      row--; 
    218226    } 
    219     updateMinMax(data, no); 
    220     return data; 
     227    updateMinMax(buf, no); 
     228    return buf; 
    221229  } 
    222230 
  • trunk/loci/formats/in/LIFReader.java

    r2320 r2377  
    149149    throws FormatException, IOException 
    150150  { 
    151     if (!id.equals(currentId)) initFile(id); 
    152  
     151    if (!id.equals(currentId)) initFile(id);  
     152    byte[] buf = new byte[sizeX[series] * sizeY[series] *  
     153      (bpp / 8) * sizeC[series]]; 
     154    return openBytes(id, no, buf); 
     155  } 
     156 
     157  public byte[] openBytes(String id, int no, byte[] buf) 
     158    throws FormatException, IOException 
     159  { 
     160    if (!id.equals(currentId)) initFile(id); 
    153161    if (no < 0 || no >= getImageCount(id)) { 
    154162      throw new FormatException("Invalid image number: " + no); 
    155163    } 
    156  
    157     // determine which dataset the plane is part of 
    158  
    159     int z = getSizeZ(id); 
    160     int t = getSizeT(id); 
    161  
    162     width = dims[series][0]; 
    163     height = dims[series][1]; 
    164     c = dims[series][4]; 
    165     //if (c == 2) c--; 
    166164    bpp = dims[series][5]; 
    167165    while (bpp % 8 != 0) bpp++; 
    168     int bytesPerPixel = bpp / 8; 
     166    int bytes = bpp / 8; 
     167    if (buf.length < sizeX[series] * sizeY[series] * bytes * sizeC[series]) { 
     168      throw new FormatException("Buffer too small."); 
     169    } 
    169170 
    170171    int offset = ((Long) offsets.get(series)).intValue(); 
    171  
    172     // get the image number within this dataset 
    173  
    174     in.seek(offset + width * height * bytesPerPixel * no * c); 
    175  
    176     byte[] data = new byte[(int) (width * height * bytesPerPixel * c)]; 
    177     in.read(data); 
    178     updateMinMax(data, no); 
    179     return data; 
     172    in.seek(offset + sizeX[series] * sizeY[series] * bytes * no * sizeC[series]); 
     173    in.read(buf); 
     174    updateMinMax(buf, no); 
     175    return buf; 
    180176  } 
    181177 
     
    185181  { 
    186182    BufferedImage b = ImageTools.makeImage(openBytes(id, no), width, height, 
    187       !isRGB(id) ? 1 : c, false, bpp / 8, littleEndian, validBits[series]); 
     183      c, false, bpp / 8, littleEndian, validBits[series]); 
    188184    updateMinMax(b, no); 
    189185    return b; 
  • trunk/loci/formats/in/LegacyZVIReader.java

    r2320 r2377  
    118118  public byte[] openBytes(String id, int no) throws FormatException, IOException 
    119119  { 
    120     byte[] b = ImageTools.getBytes(openImage(id, no), false, no); 
    121     updateMinMax(b, no); 
    122     return b; 
     120    if (!id.equals(currentId)) initFile(id); 
     121    byte[] buf = new byte[((ZVIBlock) blockList.elementAt(no)).imageSize]; 
     122    return openBytes(id, no, buf);  
     123  } 
     124 
     125  public byte[] openBytes(String id, int no, byte[] buf) 
     126    throws FormatException, IOException 
     127  { 
     128    if (!id.equals(currentId)) initFile(id); 
     129    if (no < 0 || no >= getImageCount(id)) { 
     130      throw new FormatException("Invalid image number: " + no); 
     131    } 
     132     
     133    ZVIBlock zviBlock = (ZVIBlock) blockList.elementAt(no); 
     134    zviBlock.readBytes(in, buf); 
     135    updateMinMax(buf, no); 
     136    return buf; 
    123137  } 
    124138 
     
    550564    } 
    551565 
    552     /** Reads in this block's image data from the given file. */ 
    553     public BufferedImage readImage(RandomAccessStream raf) 
     566    /** Reads in this block's image bytes from the given file. */ 
     567    public byte[] readBytes(RandomAccessStream raf, byte[] buf) 
    554568      throws IOException, FormatException 
    555569    { 
     
    561575          "; fileSize=" + fileSize + "). " + WHINING); 
    562576      } 
     577      if (buf.length < imageSize) throw new FormatException("Buffer too small."); 
    563578 
    564579      // read image 
    565       byte[] imageBytes = new byte[imageSize]; 
    566580      raf.seek(imagePos); 
    567       raf.readFully(imageBytes); 
     581      raf.readFully(buf); 
     582      return buf;  
     583    } 
     584 
     585    /** Reads in this block's image data from the given file. */ 
     586    public BufferedImage readImage(RandomAccessStream raf) 
     587      throws IOException, FormatException 
     588    { 
     589      byte[] imageBytes = readBytes(raf, new byte[imageSize]); 
    568590 
    569591      // convert image bytes into BufferedImage 
  • trunk/loci/formats/in/MRCReader.java

    r2320 r2377  
    6565  // -- IFormatReader API methods -- 
    6666 
     67  /* @see IFormatReader#getChannelGlobalMinimum(String, int) */ 
     68  public Double getChannelGlobalMinimum(String id, int theC) 
     69    throws FormatException, IOException 
     70  { 
     71    if (!id.equals(currentId)) initFile(id); 
     72    return new Double((String) getMeta("Minimum pixel value"));  
     73  } 
     74 
     75  /* @see IFormatReader#getChannelGlobalMaximum(String, int) */ 
     76  public Double getChannelGlobalMaximum(String id, int theC) 
     77    throws FormatException, IOException 
     78  { 
     79    if (!id.equals(currentId)) initFile(id); 
     80    return new Double((String) getMeta("Maximum pixel value")); 
     81  } 
     82 
     83  /* @see IFormatReader#isMinMaxPopulated(String) */ 
     84  public boolean isMinMaxPopulated(String id)  
     85    throws FormatException, IOException  
     86  { 
     87    return true; 
     88  } 
     89 
    6790  /** Checks if the given block is a valid header for an MRC file. */ 
    6891  public boolean isThisType(byte[] block) { 
     
    95118    throws FormatException, IOException 
    96119  { 
     120    if (!id.equals(currentId)) initFile(id);  
     121    byte[] buf = new byte[sizeX[0] * sizeY[0] * bpp]; 
     122    return openBytes(id, no, buf); 
     123  } 
     124 
     125  public byte[] openBytes(String id, int no, byte[] buf) 
     126    throws FormatException, IOException 
     127  { 
    97128    if (!id.equals(currentId)) initFile(id); 
    98  
    99129    if (no < 0 || no >= getImageCount(id)) { 
    100130      throw new FormatException("Invalid image number: " + no); 
    101131    } 
    102  
     132    if (buf.length < sizeX[0] * sizeY[0] * bpp) { 
     133      throw new FormatException("Buffer too small."); 
     134    } 
    103135    in.seek(1024 + extHeaderSize + (no * sizeX[0] * sizeY[0] * bpp)); 
    104     byte[] b = new byte[sizeX[0] * sizeY[0] * bpp]; 
    105     in.read(b); 
    106     updateMinMax(b, no); 
    107     return b; 
     136    in.read(buf); 
     137    updateMinMax(buf, no); 
     138    return buf; 
    108139  } 
    109140 
     
    346377    for (int i=0; i<sizeC[0]; i++) { 
    347378      store.setLogicalChannel(i, null, null, null, null, null, null, null); 
     379      store.setChannelGlobalMinMax(i, getChannelGlobalMinimum(id, i), 
     380        getChannelGlobalMaximum(id, i), null); 
    348381    } 
    349382  } 
  • trunk/loci/formats/in/MetamorphReader.java

    r2291 r2377  
    131131 
    132132  /** Populates the metadata hashtable. */ 
    133   protected void initStandardMetadata() throws FormatException { 
     133  protected void initStandardMetadata() throws FormatException, IOException { 
    134134    super.initStandardMetadata(); 
    135135 
  • trunk/loci/formats/in/NikonReader.java

    r2292 r2377  
    234234 
    235235  /* @see BaseTiffReader#initStandardMetadata() */ 
    236   protected void initStandardMetadata() throws FormatException { 
     236  protected void initStandardMetadata() throws FormatException, IOException { 
    237237    super.initStandardMetadata(); 
    238238 
  • trunk/loci/formats/in/OIBReader.java

    r2320 r2377  
    194194  { 
    195195    if (!id.equals(currentId)) initFile(id); 
     196    byte[] buf = new byte[sizeX[series] * sizeY[series] * sizeC[series] *  
     197      FormatReader.getBytesPerPixel(pixelType[series])]; 
     198    return openBytes(id, no, buf); 
     199  } 
     200   
     201  public byte[] openBytes(String id, int no, byte[] buf) 
     202    throws FormatException, IOException 
     203  { 
     204    if (!id.equals(currentId)) initFile(id); 
    196205    if (no < 0 || no >= getImageCount(id)) { 
    197206      throw new FormatException("Invalid image number: " + no); 
    198207    } 
    199  
     208   
    200209    try { 
    201       int s = getSeries(id); 
    202       String directory = 
    203         (String) ((Hashtable) pixels.get(s)).get(new Integer(no)); 
    204       String name = (String) ((Hashtable) names.get(s)).get(new Integer(no)); 
     210      Integer ii = new Integer(no);  
     211      String directory = (String) ((Hashtable) pixels.get(series)).get(ii); 
     212      String name = (String) ((Hashtable) names.get(series)).get(ii); 
    205213 
    206214      r.setVar("dirName", directory); 
     
    211219      r.exec("dis = new DocumentInputStream(document)"); 
    212220      r.exec("numBytes = dis.available()"); 
    213       int numbytes = ((Integer) r.getVar("numBytes")).intValue(); 
    214       byte[] b = new byte[numbytes + 4]; // append 0 for final offset 
     221      int numBytes = ((Integer) r.getVar("numBytes")).intValue(); 
     222      byte[] b = new byte[numBytes + 4]; // append 0 for final offset 
    215223      r.setVar("data", b); 
    216224      r.exec("dis.read(data)"); 
     
    218226      RandomAccessStream stream = new RandomAccessStream(b); 
    219227      Hashtable[] ifds = TiffTools.getIFDs(stream); 
    220       littleEndian[s] = TiffTools.isLittleEndian(ifds[0]); 
    221       byte[][] samples = TiffTools.getSamples(ifds[0], stream); 
    222  
    223       byte[] rtn = new byte[samples.length * samples[0].length]; 
    224       for (int i=0; i<samples.length; i++) { 
    225         System.arraycopy(samples[i], 0, rtn, i*samples[i].length, 
    226           samples[i].length); 
    227       } 
    228  
     228      littleEndian[series] = TiffTools.isLittleEndian(ifds[0]); 
     229      TiffTools.getSamples(ifds[0], stream, ignoreColorTable, buf); 
    229230      stream.close(); 
    230       updateMinMax(rtn, no); 
    231       return rtn; 
     231      updateMinMax(buf, no); 
     232      return buf; 
    232233    } 
    233234    catch (ReflectException e) { 
  • trunk/loci/formats/in/OIFReader.java

    r2320 r2377  
    153153    updateMinMax(b, no); 
    154154    return b; 
     155  } 
     156 
     157  public byte[] openBytes(String id, int no, byte[] buf) 
     158    throws FormatException, IOException 
     159  { 
     160    if (!id.equals(currentId) && !DataTools.samePrefix(id, currentId)) { 
     161      initFile(id); 
     162    } 
     163    if (no < 0 || no >= getImageCount(id)) { 
     164      throw new FormatException("Invalid image number: " + no); 
     165    } 
     166      
     167    tiffReader[no].setColorTableIgnored(ignoreColorTable); 
     168    tiffReader[no].openBytes((String) tiffs.get(no), 0, buf); 
     169    tiffReader[no].close(); 
     170    updateMinMax(buf, no); 
     171    return buf; 
    155172  } 
    156173 
     
    455472    store.setDimensions(pixX, pixY, null, null, null, null); 
    456473    for (int i=0; i<sizeC[0]; i++) { 
    457       store.setLogicalChannel(i, null, null, null, null, null, null, null); 
    458     } 
     474      prefix = "[Channel " + (i+1) + " Parameters] - "; 
     475      String name = (String) getMeta(prefix + "CH Name"); 
     476      String emWave = (String) getMeta(prefix + "EmissionWavelength"); 
     477      String exWave = (String) getMeta(prefix + "ExcitationWavelength"); 
     478      store.setLogicalChannel(i, name, null, emWave == null ? null :  
     479        new Integer(emWave), exWave == null ? null : new Integer(exWave),  
     480        null, null, null); 
     481    } 
     482 
     483    for (int i=0; i<sizeC[0]; i++) { 
     484      prefix = "[Channel " + (i+1) + " Parameters] - "; 
     485      String gain = (String) getMeta(prefix + "CountingPMTGain"); 
     486      String voltage = (String) getMeta(prefix + "CountingPMTVoltage"); 
     487      String offset = (String) getMeta(prefix + "CountingPMTOffset"); 
     488 
     489      if (gain != null) gain.replaceAll("\"", ""); 
     490      if (voltage != null) voltage.replaceAll("\"", ""); 
     491      if (offset != null) offset.replaceAll("\"", ""); 
     492    
     493      if (gain != null || voltage != null || offset != null) { 
     494        store.setDetector(null, null, null, null, new Float(gain),  
     495          new Float(voltage), new Float(offset), null, new Integer(i)); 
     496      } 
     497    } 
     498 
     499    String mag = (String) getMeta("Image 0 : Magnification"); 
     500    if (mag != null) { 
     501      store.setObjective(null, null, null, null, new Float(mag), null, null); 
     502    } 
     503 
     504    String num =  
     505      (String) getMeta("[Acquisition Parameters Common] - Number of use Laser"); 
     506    if (num != null) { 
     507      int numLasers = Integer.parseInt(num); 
     508      for (int i=0; i<numLasers; i++) { 
     509        String wave = (String) getMeta("[Acquisition Parameters Common] - " + 
     510          "LaserWavelength0" + (i+1));  
     511        if (wave != null) { 
     512          store.setLaser(null, null, new Integer(wave), null, null, null, null,  
     513            null, null, null, new Integer(i)); 
     514        } 
     515      } 
     516    } 
     517 
    459518  } 
    460519 
  • trunk/loci/formats/in/OpenlabRawReader.java

    r2313 r2377  
    2727import java.awt.image.BufferedImage; 
    2828import java.io.*; 
     29import java.text.SimpleDateFormat; 
     30import java.util.Date; 
    2931 
    3032import loci.formats.*; 
     
    101103    throws FormatException, IOException 
    102104  { 
     105    if (!id.equals(currentId)) initFile(id);  
     106    byte[] buf = new byte[width * height * bytesPerPixel]; 
     107    return openBytes(id, no, buf); 
     108  } 
     109 
     110  public byte[] openBytes(String id, int no, byte[] buf) 
     111    throws FormatException, IOException 
     112  { 
    103113    if (!id.equals(currentId)) initFile(id); 
    104  
    105114    if (no < 0 || no >= getImageCount(id)) { 
    106115      throw new FormatException("Invalid image number: " + no); 
    107116    } 
    108  
     117    if (buf.length < width * height * bytesPerPixel) { 
     118      throw new FormatException("Buffer too small."); 
     119    } 
     120     
    109121    in.seek(offsets[no / channels] + 288); 
    110  
    111     byte[] data = new byte[width*height*bytesPerPixel]; 
    112     in.read(data); 
     122    in.read(buf); 
    113123 
    114124    if (bytesPerPixel == 1) { 
    115125      // need to invert the pixels 
    116       for (int i=0; i<data.length; i++) { 
    117         data[i] = (byte) (255 - data[i]); 
     126      for (int i=0; i<buf.length; i++) { 
     127        buf[i] = (byte) (255 - buf[i]); 
    118128      } 
    119129    } 
    120     updateMinMax(data, no); 
    121     return data; 
     130    updateMinMax(buf, no); 
     131    return buf; 
    122132  } 
    123133 
     
    171181    height = in.readInt(); 
    172182    in.read(); 
    173     //bytesPerPixel = in.read(); 
    174     //channels = in.read(); 
    175183    channels = in.read(); 
    176184    bytesPerPixel = in.read(); 
    177185    in.read(); 
    178     addMeta("Timestamp", "" + in.readLong()); 
     186    Date timestamp = new Date(in.readLong()); 
     187    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss"); 
     188    addMeta("Timestamp", sdf.format(timestamp)); 
    179189    in.skipBytes(4); 
    180190    byte[] s = new byte[256]; 
    181191    in.read(s); 
    182     ///* debug */ System.out.println("name : " + new String(s).trim()); 
    183192    int len = s[0] > 0 ? s[0] : (s[0] + 256); 
    184193    addMeta("Image name", new String(s, 1, len).trim()); 
     
    220229    } 
    221230 
     231    store.setImage((String) getMeta("Image name"), sdf.format(timestamp), 
     232      null, null); 
    222233    store.setPixels( 
    223234      (Integer) getMeta("Width"), 
  • trunk/loci/formats/in/PrairieReader.java

    r2320 r2377  
    176176    updateMinMax(b, no); 
    177177    return b; 
     178  } 
     179 
     180  public byte[] openBytes(String id, int no, byte[] buf) 
     181    throws FormatException, IOException 
     182  { 
     183    if (!id.equals(currentId)) initFile(id); 
     184    if (no < 0 || no >= getImageCount(id)) { 
     185      throw new FormatException("Invalid image number: " + no); 
     186    } 
     187    tiff.openBytes(files[no], 0, buf); 
     188    updateMinMax(buf, no); 
     189    return buf;  
    178190  } 
    179191 
  • trunk/loci/formats/in/SDTReader.java

    r2313 r2377  
    135135    throws FormatException, IOException 
    136136  { 
    137     if (!id.equals(currentId)) initFile(id); 
    138  
     137    if (!id.equals(currentId)) initFile(id);  
     138    byte[] buf = new byte[2 * sizeX[series] * sizeY[series]]; 
     139    return openBytes(id, no, buf); 
     140  } 
     141 
     142  public byte[] openBytes(String id, int no, byte[] buf) 
     143    throws FormatException, IOException 
     144  { 
     145    if (!id.equals(currentId)) initFile(id); 
    139146    if (no < 0 || no >= timeBins * channels) { 
    140147      throw new FormatException("Invalid image number: " + no); 
    141148    } 
    142  
    143     int w = sizeX[series]; 
    144     int h = sizeY[series]; 
    145     byte[] pixel = new byte[2 * timeBins]; 
    146     byte[] data = new byte[2 * w * h]; 
     149    if (buf.length < 2 * sizeX[series] * sizeY[series]) { 
     150      throw new FormatException("Buffer too small."); 
     151    } 
     152     
    147153    if (intensity) { 
    148       int c = no; 
    149       in.seek(off + 2 * w * h * timeBins * c); 
    150       for (int y=0; y<h; y++) { 
    151         for (int x=0; x<w; x++) { 
     154      in.seek(off + 2 * sizeX[series] * sizeY[series] * timeBins * no); 
     155      for (int y=0; y<sizeY[series]; y++) { 
     156        for (int x=0; x<sizeX[series]; x++) { 
    152157          // read all lifetime bins at this pixel for this channel 
    153           in.readFully(pixel, 0, 2 * timeBins); 
    154  
     158           
    155159          // combine lifetime bins into intensity value 
    156160          short sum = 0; 
    157161          for (int t=0; t<timeBins; t++) { 
    158             sum += DataTools.bytesToShort(pixel, 2 * t, 2, true); 
     162            sum += DataTools.read2SignedBytes(in, true);  
    159163          } 
    160           int ndx = 2 * (w * y + x); 
    161           data[ndx] = (byte) (sum & 0xff); 
    162           data[ndx + 1] = (byte) ((sum >> 8) & 0xff); 
     164          int ndx = 2 * (sizeX[0] * y + x); 
     165          buf[ndx] = (byte) (sum & 0xff); 
     166          buf[ndx + 1] = (byte) ((sum >> 8) & 0xff); 
    163167        } 
    164168      } 
     
    167171      int t = no % timeBins; 
    168172      int c = no / timeBins; 
    169       in.seek(off + 2 * (w * h * timeBins * c + t)); 
    170       for (int y=0; y<h; y++) { 
    171         for (int x=0; x<w; x++) { 
     173      in.seek(off + 2 * (sizeX[series] * sizeY[series] * timeBins * c + t)); 
     174      for (int y=0; y<sizeY[series]; y++) { 
     175        for (int x=0; x<sizeX[series]; x++) { 
    172176          // read data only for the given lifetime bin 
    173           int ndx = 2 * (w * y + x); 
    174           in.readFully(data, ndx, 2); 
     177          int ndx = 2 * (sizeX[series] * y + x); 
     178          in.readFully(buf, ndx, 2); 
    175179          in.skipBytes(timeBins); 
    176180        } 
    177181      } 
    178182    } 
    179     updateMinMax(data, no); 
    180     return data; 
     183    updateMinMax(buf, no); 
     184    return buf; 
    181185  } 
    182186 
  • trunk/loci/formats/in/SEQReader.java

    r2219 r2377  
    6161 
    6262  /** Overridden to include the three SEQ-specific tags. */ 
    63   protected void initStandardMetadata() throws FormatException { 
     63  protected void initStandardMetadata() throws FormatException, IOException { 
    6464    super.initStandardMetadata(); 
    6565 
  • trunk/loci/formats/in/SlidebookReader.java

    r2320 r2377  
    102102    throws FormatException, IOException 
    103103  { 
     104    if (!id.equals(currentId)) initFile(id);  
     105    byte[] buf = new byte[width * height * 2]; 
     106    return openBytes(id, no, buf); 
     107  } 
     108 
     109  public byte[] openBytes(String id, int no, byte[] buf) 
     110    throws FormatException, IOException 
     111  { 
    104112    if (!id.equals(currentId)) initFile(id); 
    105  
    106113    if (no < 0 || no >= getImageCount(id)) { 
    107114      throw new FormatException("Invalid image number: " + no); 
    108115    } 
    109  
     116    if (buf.length < width * height * 2) { 
     117      throw new FormatException("Buffer too small."); 
     118    } 
    110119    in.seek(offset + (no * width * height * 2)); 
    111     byte[] b = new byte[width * height * 2]; 
    112     in.read(b); 
    113     updateMinMax(b, no); 
    114     return b; 
     120    in.read(buf); 
     121    updateMinMax(buf, no); 
     122    return buf; 
    115123  } 
    116124 
  • trunk/loci/formats/in/TiffReader.java

    r2327 r2377  
    6767 
    6868  /** Parses standard metadata. */ 
    69   protected void initStandardMetadata() throws FormatException { 
     69  protected void initStandardMetadata() throws FormatException, IOException { 
    7070    super.initStandardMetadata(); 
    7171    String comment = (String) getMeta("Comment"); 
  • trunk/loci/formats/in/ZeissZVIReader.java

    r2320 r2377  
    2727import java.awt.image.BufferedImage; 
    2828import java.io.*; 
    29 import java.util.Hashtable; 
    30 import java.util.Iterator; 
    31 import java.util.Vector; 
     29import java.util.*; 
    3230import loci.formats.*; 
    3331 
     
    235233    throws FormatException, IOException 
    236234  { 
     235    if (!id.equals(currentId)) initFile(id);  
     236    byte[] buf = new byte[sizeX[0] * sizeY[0] * bpp]; 
     237    return openBytes(id, no, buf); 
     238  } 
     239 
     240  public byte[] openBytes(String id, int no, byte[] buf) 
     241    throws FormatException, IOException 
     242  { 
    237243    if (!id.equals(currentId)) initFile(id); 
    238     if (noPOI || needLegacy) return legacy.openBytes(id, no); 
     244    if (noPOI || needLegacy) return legacy.openBytes(id, no, buf); 
    239245    if (no < 0 || no >= getImageCount(id)) { 
    240246      throw new FormatException("Invalid image number: " + no); 
     247    } 
     248 
     249    if (buf.length < sizeX[0] * sizeY[0] * bpp) { 
     250      throw new FormatException("Buffer too small."); 
    241251    } 
    242252 
     
    250260      r.exec("dis = new DocumentInputStream(document)"); 
    251261      r.exec("numBytes = dis.available()"); 
    252       int numbytes = ((Integer) r.getVar("numBytes")).intValue(); 
    253       byte[] b = new byte[numbytes + 4]; // append 0 for final offset 
    254       r.setVar("data", b); 
     262      int numBytes = ((Integer) r.getVar("numBytes")).intValue(); 
     263      r.setVar("skipBytes",  
     264        ((Integer) offsets.get(new Integer(no))).longValue()); 
     265      r.exec("blah = dis.skip(skipBytes)"); 
     266      r.setVar("data", buf); 
    255267      r.exec("dis.read(data)"); 
    256  
    257       // remove extra bytes 
    258  
    259       int offset = ((Integer) offsets.get(new Integer(no))).intValue(); 
    260       byte[] a = new byte[b.length - offset]; 
    261       System.arraycopy(b, b.length - a.length, a, 0, a.length); 
    262268 
    263269      if (bpp > 6) bpp = 1; 
     
    265271      if (bpp == 3) { 
    266272        // reverse bytes in groups of 3 to account for BGR storage 
    267  
    268         byte[] tmp = a; 
    269         a = new byte[tmp.length]; 
    270  
    271         for (int i=0; i<tmp.length; i+=3) { 
    272           if (i + 2 < tmp.length) { 
    273             a[i] = tmp[i + 2]; 
    274             a[i + 1] = tmp[i + 1]; 
    275             a[i + 2] = tmp[i]; 
    276           } 
     273        for (int i=0; i<buf.length; i+=3) { 
     274          byte r = buf[i + 2]; 
     275          buf[i + 2] = buf[i]; 
     276          buf[i] = r; 
    277277        } 
    278278      } 
    279       b = null; 
    280  
    281       if (a.length != bpp * sizeX[0] * sizeY[0]) { 
    282         byte[] tmp = a; 
    283         a = new byte[bpp * sizeX[0] * sizeY[0]]; 
    284         System.arraycopy(tmp, 0, a, 0, a.length); 
    285       } 
    286       updateMinMax(a, no); 
    287       return a; 
     279 
     280      updateMinMax(buf, no); 
     281      return buf; 
    288282    } 
    289283    catch (ReflectException e) { 
    290284      needLegacy = true; 
    291       return openBytes(id, no); 
     285      return openBytes(id, no, buf); 
    292286    } 
    293287  } 
     
    474468  private void initMetadata() throws FormatException, IOException { 
    475469    MetadataStore store = getMetadataStore(currentId); 
    476     store.setImage((String) getMeta("File Name"), null, null, null); 
     470 
     471    store.setImage((String) getMeta("Title"), null, null, null); 
    477472 
    478473    if (bpp == 1 || bpp == 3) pixelType[0] = FormatReader.UINT8; 
Note: See TracChangeset for help on using the changeset viewer.