Changeset 1195


Ignore:
Timestamp:
07/26/06 09:11:20 (14 years ago)
Author:
melissa
Message:
  • Minor adjustments to several readers
  • Added endianness flag to RandomAccessStream
  • fixed ZVI readers (all ZVI files work)
  • improved file stitching and channel merging
Location:
trunk/loci/formats
Files:
32 edited

Legend:

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

    r1139 r1195  
    2727import java.awt.image.BufferedImage; 
    2828import java.io.*; 
     29import java.util.Hashtable; 
    2930 
    3031/** Logic to automatically merge channels in a file. */ 
     
    9091  } 
    9192 
     93  /** 
     94   * Obtains the hashtable containing the metadata field/value pairs from 
     95   * the given file. 
     96   */ 
     97  public Hashtable getMetadata(String id) throws FormatException, IOException { 
     98    if (!id.equals(currentId)) initFile(id); 
     99    return reader.getMetadata(id); 
     100  } 
     101 
     102  /** 
     103   * Retrieves the current metadata store for this reader. 
     104   */ 
     105  public MetadataStore getMetadataStore() { 
     106    return reader.getMetadataStore(); 
     107  } 
     108 
    92109  /** Checks if the images in the file are RGB. */ 
    93110  public boolean isRGB(String id) throws FormatException, IOException { 
     
    96113    int channels = getSizeC(id); 
    97114    boolean multipleChannels = channels > 1; 
    98     return multipleChannels && (channels == 3 && reader.isRGB(id)) && 
    99       !separated; 
     115    //return multipleChannels && (channels == 3 && reader.isRGB(id)) && 
     116    //  !separated; 
     117    return multipleChannels && !separated; 
    100118  } 
    101119 
  • trunk/loci/formats/FileStitcher.java

    r1141 r1195  
    2828import java.io.*; 
    2929import java.lang.*; 
     30import java.util.Hashtable; 
     31import java.util.Vector; 
    3032import loci.util.FilePattern; 
    3133 
     
    3335public class FileStitcher extends FormatReader { 
    3436 
     37  // -- Constants -- 
     38 
     39  /** Prefix endings indicating time dimension. */ 
     40  private static final String[] T = { 
     41    "T", "TP", "TL", "Tl", "t", "tp", "Tp", "tP", "tL", "tl" 
     42  }; 
     43 
     44  /** Prefix endings indicating space dimension. */ 
     45  private static final String[] Z = { 
     46    "Z", "ZS", "FP", "SEC", "Focal", "z", "zs", "Zs", "zS", "fp", "Fp", "fP", 
     47    "BF" 
     48  }; 
     49 
     50  /** Prefix endings indicating channel dimension. */ 
     51  private static final String[] C = {"C", "CH", "W", "Ch", "ch"}; 
     52 
    3553  // -- Fields -- 
    3654 
     
    3856  private FormatReader reader; 
    3957 
    40   /** The Z, C and T dimensions. */ 
     58  /** FilePattern used to build the list of files. */ 
     59  private FilePattern fp; 
     60 
     61  /** The X, Y, Z, C and T dimensions. */ 
    4162  private int[] dimensions; 
    4263 
     
    5071  private String[] files; 
    5172 
     73  /** Dimension order. */ 
     74  private String order; 
     75 
    5276  /** Next plane number to open. */ 
    5377  private int number; 
     78 
     79  private boolean varyZ, varyC, varyT; 
    5480 
    5581  // -- Constructor -- 
     
    79105  } 
    80106 
     107  /** 
     108   * Obtains the hashtable containing the metadata field/value pairs from 
     109   * the given file. 
     110   */ 
     111  public Hashtable getMetadata(String id) throws FormatException, IOException { 
     112    if (!id.equals(currentId)) initFile(id); 
     113    return reader.getMetadata(id); 
     114  } 
     115 
     116  /** 
     117   * Retrieves the current metadata store for this reader. 
     118   */ 
     119  public MetadataStore getMetadataStore() { 
     120    return reader.getMetadataStore(); 
     121  } 
     122 
    81123  /** Determines the number of images in the given file. */ 
    82124  public int getImageCount(String id) throws FormatException, IOException { 
     
    92134  /** Get the size of the X dimension. */ 
    93135  public int getSizeX(String id) throws FormatException, IOException { 
    94     return reader.getSizeX(id); 
     136    if (!id.equals(currentId)) initFile(id); 
     137    return dimensions[0]; 
    95138  } 
    96139 
    97140  /** Get the size of the Y dimension. */ 
    98141  public int getSizeY(String id) throws FormatException, IOException { 
    99     return reader.getSizeY(id); 
     142    if (!id.equals(currentId)) initFile(id); 
     143    return dimensions[1]; 
    100144  } 
    101145 
     
    103147  public int getSizeZ(String id) throws FormatException, IOException { 
    104148    if (!id.equals(currentId)) initFile(id); 
    105     return dimensions[0]; 
     149    return dimensions[2]; 
    106150  } 
    107151 
     
    109153  public int getSizeC(String id) throws FormatException, IOException { 
    110154    if (!id.equals(currentId)) initFile(id); 
    111     return dimensions[1]; 
     155    return dimensions[3]; 
    112156  } 
    113157 
     
    115159  public int getSizeT(String id) throws FormatException, IOException { 
    116160    if (!id.equals(currentId)) initFile(id); 
    117     return dimensions[2]; 
     161    return dimensions[4]; 
    118162  } 
    119163 
     
    130174  public String getDimensionOrder(String id) throws FormatException, IOException 
    131175  { 
    132     return reader.getDimensionOrder(id); 
     176    if (!id.equals(currentId)) initFile(id); 
     177    return order; 
    133178  } 
    134179 
     
    158203    currentId = id; 
    159204    numImages = 0; 
    160     dimensions = new int[3]; 
     205    dimensions = new int[5]; 
    161206 
    162207    // get the matching files 
    163208 
    164     FilePattern fp = new FilePattern(new File(id)); 
     209    fp = new FilePattern(new File(id)); 
    165210    files = fp.getFiles(); 
    166211    imageCounts = new int[files.length]; 
     
    169214    // for each file 
    170215 
    171     int[][] dims = new int[files.length][3]; 
     216    int[][] dims = new int[files.length][5]; 
    172217 
    173218    for (int i=0; i<files.length; i++) { 
    174219      imageCounts[i] = reader.getImageCount(files[i]); 
    175220      numImages += imageCounts[i]; 
    176       dims[i][0] = reader.getSizeZ(files[i]); 
    177       dims[i][1] = reader.getSizeC(files[i]); 
    178       dims[i][2] = reader.getSizeT(files[i]); 
     221      dims[i][0] = reader.getSizeX(files[i]); 
     222      dims[i][1] = reader.getSizeY(files[i]); 
     223      dims[i][2] = reader.getSizeZ(files[i]); 
     224      dims[i][3] = reader.getSizeC(files[i]); 
     225      dims[i][4] = reader.getSizeT(files[i]); 
    179226    } 
    180227 
    181228    // determine how many varying dimensions there are 
    182229 
    183     boolean varyZ = false; 
    184     boolean varyC = false; 
    185     boolean varyT = false; 
    186  
    187230    for (int i=1; i<dims.length; i++) { 
    188       varyZ = dims[i][0] != dims[i-1][0]; 
    189       varyC = dims[i][1] != dims[i-1][1]; 
    190       varyT = dims[i][2] != dims[i-1][2]; 
    191     } 
    192  
    193     if (!varyZ && !varyC && !varyT) { 
    194       dimensions[0] = dims[0][0]; 
    195       dimensions[1] = dims[0][1]; 
    196       dimensions[2] = dims[0][2]; 
    197  
    198       String o = getDimensionOrder(id); 
    199       if (o.endsWith("Z")) dimensions[0] *= files.length; 
    200       else if (o.endsWith("C")) dimensions[1] *= files.length; 
    201       else dimensions[2] *= files.length; 
    202     } 
    203     else { 
     231      varyZ = dims[i][2] != dims[i-1][2]; 
     232      varyC = dims[i][3] != dims[i-1][3]; 
     233      varyT = dims[i][4] != dims[i-1][4]; 
     234    } 
     235 
     236    if (varyZ || varyC || varyT) { 
     237      // this case is probably broken 
    204238      for (int j=0; j<3; j++) { 
    205239        int max = 0; 
     
    215249      } 
    216250    } 
     251    else { 
     252      dimensions[0] = dims[0][0]; 
     253      dimensions[1] = dims[0][1]; 
     254      dimensions[2] = dims[0][2]; 
     255      dimensions[3] = dims[0][3]; 
     256      dimensions[4] = dims[0][4]; 
     257    } 
     258    setDimensions(dims); 
    217259  } 
    218260 
    219261  // -- Helper methods -- 
    220262 
     263  /** 
     264   * Set the X, Y, Z, C, and T dimensions; uses some special heuristics on the 
     265   * filename patterns to determine how Z, C and T should be set. 
     266   * 
     267   * @param dims - the dimensions of each file in the dataset 
     268   */ 
     269  private void setDimensions(int[][] dims) throws FormatException, IOException 
     270  { 
     271    // first set X and Y 
     272    // this is relatively easy - we can just take the maximum value 
     273 
     274    int maxX = 0; 
     275    int maxY = 0; 
     276    int maxXIndex = 0; 
     277    int maxYIndex = 0; 
     278 
     279    for (int i=0; i<dims.length; i++) { 
     280      if (dims[i][0] > maxX) { 
     281        maxX = dims[i][0]; 
     282        maxXIndex = i; 
     283      } 
     284      if (dims[i][1] > maxY) { 
     285        maxY = dims[i][1]; 
     286        maxYIndex = i; 
     287      } 
     288    } 
     289 
     290    for (int i=0; i<dimensions.length; i++) { 
     291      if (dimensions[i] == 0) dimensions[i]++; 
     292    } 
     293 
     294    // now the tricky part - setting Z, C and T 
     295 
     296    // first we'll get a list of the prefix blocks 
     297 
     298    Vector prefixes = new Vector(); 
     299    int i = 0; 
     300    String prefix = fp.getPrefix(i); 
     301    while (prefix != null) { 
     302      prefixes.add(prefix); 
     303      i++; 
     304      prefix = fp.getPrefix(i); 
     305    } 
     306 
     307    int[] counts = fp.getCount(); 
     308 
     309    int sizeZ = 1; 
     310    int sizeC = 1; 
     311    int sizeT = 1; 
     312 
     313    String ordering = ""; 
     314 
     315    for (int j=0; j<counts.length; j++) { 
     316      // which dimension is this? 
     317 
     318      int zndx = -1; 
     319      int cndx = -1; 
     320      int tndx = -1; 
     321 
     322      String p = (String) prefixes.get(j); 
     323      for (int k=0; k<Z.length; k++) { 
     324        if (p.indexOf(Z[k]) != -1) { 
     325          zndx = k; 
     326        } 
     327      } 
     328 
     329      if (counts[j] <= 4) { 
     330        for (int k=0; k<C.length; k++) { 
     331          if (p.indexOf(C[k]) != -1) { 
     332            cndx = k; 
     333          } 
     334        } 
     335      } 
     336 
     337      for (int k=0; k<T.length; k++) { 
     338        if (p.indexOf(T[k]) != -1) { 
     339          tndx = k; 
     340        } 
     341      } 
     342 
     343      if (zndx != -1 || cndx != -1 || tndx != -1) { 
     344        // the largest of these three is the dimension we will choose 
     345        int zpos = zndx == -1 ? -1 : p.indexOf(Z[zndx]); 
     346        int cpos = cndx == -1 ? -1 : p.indexOf(C[cndx]); 
     347        int tpos = tndx == -1 ? -1 : p.indexOf(T[tndx]); 
     348 
     349        int max = zpos; 
     350        if (cpos > max) max = cpos; 
     351        if (tpos > max) max = tpos; 
     352 
     353        if (max == zpos) { 
     354          ordering += "Z"; 
     355          sizeZ = counts[j]; 
     356        } 
     357        else if (max == cpos) { 
     358          ordering += "C"; 
     359          sizeC = counts[j]; 
     360        } 
     361        else { 
     362          ordering += "T"; 
     363          sizeT = counts[j]; 
     364        } 
     365      } 
     366      else { 
     367        // our simple check failed, so let's try some more complex stuff 
     368 
     369        // if the count is 2 or 3, it's probably a C size 
     370        if (counts[j] == 2 || counts[j] == 3) { 
     371          if (!varyZ && !varyC && !varyT) { 
     372            if (counts[j] != 1) { 
     373              // we already set this dimension 
     374              if (sizeZ == 1) { 
     375                sizeZ = sizeC; 
     376                ordering += "Z"; 
     377              } 
     378              else if (sizeT == 1) { 
     379                sizeT = sizeC; 
     380                ordering += "T"; 
     381              } 
     382            } 
     383 
     384            if (ordering.indexOf("C") == -1) ordering += "C"; 
     385            sizeC = counts[j]; 
     386          } 
     387        } 
     388        else { 
     389          // the most likely choice is whichever dimension is currently set to 1 
     390 
     391          if (dimensions[2] == 1) { 
     392            ordering += "Z"; 
     393            sizeZ = counts[j]; 
     394          } 
     395          else if (dimensions[4] == 1) { 
     396            ordering += "T"; 
     397            sizeT = counts[j]; 
     398          } 
     399        } 
     400      } 
     401    } 
     402 
     403    // reset the dimensions, preserving internal sizes 
     404 
     405    dimensions[3] *= sizeC; 
     406 
     407    if (sizeZ > 1 && dimensions[2] > 1) { 
     408      if (dimensions[4] == 1) { 
     409        dimensions[4] = dimensions[2]; 
     410        dimensions[2] = sizeZ; 
     411      } 
     412      else dimensions[2] *= sizeZ; 
     413    } 
     414    else dimensions[2] *= sizeZ; 
     415 
     416    if (sizeT > 1 && dimensions[4] > 1) { 
     417      if (dimensions[2] == 1) { 
     418        dimensions[2] = dimensions[4]; 
     419        dimensions[4] = sizeT; 
     420      } 
     421      else dimensions[4] *= sizeT; 
     422    } 
     423    else dimensions[4] *= sizeT; 
     424 
     425    // make sure ordering is right 
     426    String begin = ""; 
     427    String readerOrder = reader.getDimensionOrder(currentId); 
     428    for (int j=0; j<readerOrder.length(); j++) { 
     429      if (ordering.indexOf(readerOrder.substring(j, j+1)) == -1) { 
     430        begin += readerOrder.substring(j, j+1); 
     431      } 
     432    } 
     433 
     434    ordering = begin + ordering; 
     435    order = ordering.substring(0, 5); 
     436  } 
     437 
     438  /** Determine which file to open, if we want the specified image. */ 
    221439  private String findFile(int no) { 
    222440    boolean found = false; 
  • trunk/loci/formats/FormatReader.java

    r1161 r1195  
    2929import java.util.Arrays; 
    3030import java.util.Hashtable; 
    31 import java.util.Vector; 
    3231import javax.swing.filechooser.FileFilter; 
    3332import loci.util.FilePattern; 
     
    287286    System.out.println(isThisType(id) ? "[yes]" : "[no]"); 
    288287 
     288 
     289    ChannelMerger cm = new ChannelMerger(stitch ? 
     290      new FileStitcher(this) : this); 
     291 
    289292    // read pixels 
    290293    if (pixels) { 
     
    292295        FilePattern.findPattern(new File(id)) : id) + " pixel data "); 
    293296      long s1 = System.currentTimeMillis(); 
    294       ChannelMerger cm = new ChannelMerger(stitch ? 
    295         new FileStitcher(this) : this); 
    296297      cm.setSeparated(separate); 
    297298      int num = cm.getImageCount(id); 
     
    323324    System.out.println(); 
    324325    System.out.print("Reading " + id + " metadata "); 
    325     int imageCount = getImageCount(id); 
    326     boolean rgb = isRGB(id); 
    327     int sizeX = getSizeX(id); 
    328     int sizeY = getSizeY(id); 
    329     int sizeZ = getSizeZ(id); 
    330     int sizeC = getSizeC(id); 
    331     int sizeT = getSizeT(id); 
    332     boolean little = isLittleEndian(id); 
    333     String dimOrder = getDimensionOrder(id); 
     326    int imageCount = cm.getImageCount(id); 
     327    boolean rgb = cm.isRGB(id); 
     328    int sizeX = cm.getSizeX(id); 
     329    int sizeY = cm.getSizeY(id); 
     330    int sizeZ = cm.getSizeZ(id); 
     331    int sizeC = cm.getSizeC(id); 
     332    int sizeT = cm.getSizeT(id); 
     333    boolean little = cm.isLittleEndian(id); 
     334    String dimOrder = cm.getDimensionOrder(id); 
    334335    Hashtable meta = getMetadata(id); 
    335336    System.out.println("[done]"); 
     
    378379  } 
    379380 
    380   // -- File stitching API methods -- 
    381  
    382   /** Gets a list of files matching the pattern in the given file name. */ 
    383   public String[] getMatchingFiles(String id) 
    384     throws FormatException, IOException 
    385   { 
    386     if (!id.equals(currentId)) initFile(id); 
    387     FilePattern fp = new FilePattern(new File(id)); 
    388     return fp.getFiles(); 
    389   } 
    390  
    391   /** 
    392    * Open all of the files matching the given file, and return the corresponding 
    393    * array of BufferedImages. 
    394    */ 
    395   public BufferedImage[] openAllImages(String id) 
    396     throws FormatException, IOException 
    397   { 
    398     String[] files = getMatchingFiles(id); 
    399     Vector v = new Vector(); 
    400     for (int i=0; i<files.length; i++) { 
    401       for (int j=0; j<getImageCount(id); j++) { 
    402         v.add(openImage(files[i], j)); 
    403       } 
    404     } 
    405     return (BufferedImage[]) v.toArray(new BufferedImage[0]); 
    406   } 
    407  
    408   /** Get the total number of images in the given file and all matching files.*/ 
    409   public int getTotalImageCount(String id) throws FormatException, IOException { 
    410     String[] files = getMatchingFiles(id); 
    411     int num = 0; 
    412     for (int i=0; i<files.length; i++) { 
    413       num += getImageCount(files[i]); 
    414     } 
    415     return num; 
    416   } 
    417  
    418   /** 
    419    * Open the given image from the appropriate file matching the 
    420    * given file name.  The number given should be between 0 and 
    421    * getTotalImageCount(id); this method will automatically adjust the file 
    422    * name and plane number accordingly. 
    423    */ 
    424   public BufferedImage openStitchedImage(String id, int no) 
    425     throws FormatException, IOException 
    426   { 
    427     String[] files = getMatchingFiles(id); 
    428  
    429     // first find the appropriate file 
    430     boolean found = false; 
    431     String file = files[0]; 
    432     int ndx = 1;  // index into the array of file names 
    433     while (!found) { 
    434       if (no < getImageCount(file)) { 
    435         found = true; 
    436       } 
    437       else { 
    438         no -= getImageCount(file); 
    439         file = files[ndx]; 
    440         ndx++; 
    441       } 
    442     } 
    443  
    444     return openImage(file, no); 
    445   } 
    446  
    447   /** 
    448    * Open the given image from the appropriate file matching the 
    449    * given file name.  The number given should be between 0 and 
    450    * getTotalImageCount(id); this method will automatically adjust the file 
    451    * name and plane number accordingly. 
    452    */ 
    453   public byte[] openStitchedBytes(String id, int no) 
    454     throws FormatException, IOException 
    455   { 
    456     String[] files = getMatchingFiles(id); 
    457  
    458     // first find the appropriate file 
    459     boolean found = false; 
    460     String file = files[0]; 
    461     int ndx = 1;  // index into the array of file names 
    462     while (!found) { 
    463       if (no < getImageCount(file)) { 
    464         found = true; 
    465       } 
    466       else { 
    467         no -= getImageCount(file); 
    468         file = files[ndx]; 
    469         ndx++; 
    470       } 
    471     } 
    472  
    473     return openBytes(file, no); 
    474   } 
    475  
    476381  // -- FormatHandler API methods -- 
    477382 
  • trunk/loci/formats/ImageViewer.java

    r1127 r1195  
    142142      //images = reader.open(id); 
    143143      FormatReader r = reader.getReader(id); 
    144       ChannelMerger cm = new ChannelMerger(r); 
    145       int num = cm.getTotalImageCount(id); 
     144      FileStitcher fs = new FileStitcher(r); 
     145      ChannelMerger cm = new ChannelMerger(fs); 
     146 
     147      int num = cm.getImageCount(id); 
    146148      ProgressMonitor progress = new ProgressMonitor(this, 
    147149        "Reading " + id, null, 0, num); 
     
    150152        if (progress.isCanceled()) break; 
    151153        progress.setProgress(i); 
    152         img[i] = cm.openStitchedImage(id, i); 
     154        img[i] = cm.openImage(id, i); 
    153155        if (i == 0) setImages(id, format, img); 
    154156      } 
  • trunk/loci/formats/RandomAccessStream.java

    r1124 r1195  
    7777  protected Vector recent; 
    7878 
     79  /** Endianness of the stream. */ 
     80  protected boolean littleEndian = false; 
    7981 
    8082  // -- Constructors -- 
     
    152154  /** Read four input bytes and return an int value. */ 
    153155  public int readInt() throws IOException { 
    154     return DataTools.read4SignedBytes(this, false); 
     156    return DataTools.read4SignedBytes(this, littleEndian); 
    155157  } 
    156158 
     
    168170  /** Read eight input bytes and return a long value. */ 
    169171  public long readLong() throws IOException { 
    170     return DataTools.read8SignedBytes(this, false); 
     172    return DataTools.read8SignedBytes(this, littleEndian); 
    171173  } 
    172174 
    173175  /** Read two input bytes and return a short value. */ 
    174176  public short readShort() throws IOException { 
    175     return DataTools.read2SignedBytes(this, false); 
     177    return DataTools.read2SignedBytes(this, littleEndian); 
    176178  } 
    177179 
     
    183185  /** Read two bytes and return an int in the range 0 through 65535. */ 
    184186  public int readUnsignedShort() throws IOException { 
    185     return DataTools.read2UnsignedBytes(this, false); 
     187    return DataTools.read2UnsignedBytes(this, littleEndian); 
    186188  } 
    187189 
     
    316318  } 
    317319 
     320  /** Set the endianness of the stream. */ 
     321  public void order(boolean little) { 
     322    littleEndian = little; 
     323  } 
    318324 
    319325  // -- Helper methods -- 
  • trunk/loci/formats/TiffTools.java

    r1124 r1195  
    228228      if (ifd.size() <= 1) break; 
    229229      v.add(ifd); 
    230       offset = DataTools.read4UnsignedBytes(in, littleEndian); 
     230      offset = in.readInt(); 
    231231      if (offset == 0) break; 
    232232    } 
     
    241241   * if the given file is not a valid TIFF file. 
    242242   */ 
    243   public static Hashtable getFirstIFD(RandomAccessStream in) 
    244     throws IOException 
     243  public static Hashtable getFirstIFD(RandomAccessStream in) throws IOException 
    245244  { 
    246245    return getFirstIFD(in, 0); 
     
    270269   *         or null if not a TIFF. 
    271270   */ 
    272   public static Boolean checkHeader(RandomAccessStream in, 
    273     long globalOffset) throws IOException 
     271  public static Boolean checkHeader(RandomAccessStream in, long globalOffset) 
     272    throws IOException 
    274273  { 
    275274    if (DEBUG) debug("getIFDs: reading IFD entries"); 
    276275 
    277276    // start at the beginning of the file 
    278     in.seek(globalOffset); 
     277    in.seek((int) globalOffset); 
    279278 
    280279    // determine byte order (II = little-endian, MM = big-endian) 
    281280    byte[] order = new byte[2]; 
    282     in.readFully(order); 
     281    in.read(order); 
    283282    boolean littleEndian = order[0] == LITTLE && order[1] == LITTLE; // II 
    284283    boolean bigEndian = order[0] == BIG && order[1] == BIG; // MM 
     
    286285 
    287286    // check magic number (42) 
    288     int magic = DataTools.read2UnsignedBytes(in, littleEndian); 
     287    int magic = in.readShort(); 
    289288    if (magic != MAGIC_NUMBER) return null; 
    290289 
     
    296295   * Assumes the stream is positioned properly (checkHeader just called). 
    297296   */ 
    298   public static long getFirstOffset(RandomAccessStream in, 
    299     boolean littleEndian) throws IOException 
     297  public static long getFirstOffset(RandomAccessStream in, boolean littleEndian) 
     298    throws IOException 
    300299  { 
    301300    // get offset to first IFD 
    302     return DataTools.read4UnsignedBytes(in, littleEndian); 
     301    return in.readInt(); 
    303302  } 
    304303 
     
    318317        (globalOffset != 0 ? (globalOffset + "+" + offset) : ("" + offset))); 
    319318    } 
    320     in.seek(globalOffset + offset); 
    321     int numEntries = DataTools.read2UnsignedBytes(in, littleEndian); 
     319    in.seek((int) (globalOffset + offset)); 
     320    int numEntries = in.readShort(); 
     321    if (numEntries < 0) numEntries += 65536; 
    322322    if (DEBUG) debug("getIFDs: " + numEntries + " directory entries to read"); 
    323323    if (numEntries == 0 || numEntries == 1) return ifd; 
    324324 
    325325    for (int i=0; i<numEntries; i++) { 
    326       in.seek(globalOffset + offset + 2 + 12 * i); 
    327       int tag = DataTools.read2UnsignedBytes(in, littleEndian); 
    328       int type = DataTools.read2UnsignedBytes(in, littleEndian); 
    329       int count = (int) DataTools.read4UnsignedBytes(in, littleEndian); 
     326      in.seek((int) (globalOffset + offset + 2 + 12 * i)); 
     327      int tag = in.readShort(); 
     328      if (tag < 0) tag += 65536; 
     329      int type = in.readShort(); 
     330      if (type < 0) type += 65536; 
     331      int count = in.readInt(); 
     332 
    330333      if (DEBUG) { 
    331334        debug("getIFDs: read " + getIFDTagName(tag) + 
     
    339342        short[] bytes = new short[count]; 
    340343        if (count > 4) { 
    341           long pointer = DataTools.read4UnsignedBytes(in, littleEndian); 
    342           in.seek(globalOffset + pointer); 
     344          long pointer = in.readInt(); 
     345          in.seek((int) (globalOffset + pointer)); 
    343346        } 
    344347        for (int j=0; j<count; j++) { 
    345           bytes[j] = DataTools.readUnsignedByte(in); 
     348          bytes[j] = (byte) in.read(); 
     349          if (bytes[j] < 0) bytes[j] += 255; 
    346350        } 
    347351        if (bytes.length == 1) value = new Short(bytes[0]); 
     
    353357        byte[] ascii = new byte[count]; 
    354358        if (count > 4) { 
    355           long pointer = DataTools.read4UnsignedBytes(in, littleEndian); 
    356           in.seek(globalOffset + pointer); 
    357         } 
    358         in.readFully(ascii); 
     359          long pointer = in.readInt(); 
     360          in.seek((int) (globalOffset + pointer)); 
     361        } 
     362        in.read(ascii); 
    359363 
    360364        // count number of null terminators 
     
    384388        int[] shorts = new int[count]; 
    385389        if (count > 2) { 
    386           long pointer = DataTools.read4UnsignedBytes(in, littleEndian); 
    387           in.seek(globalOffset + pointer); 
     390          long pointer = in.readInt(); 
     391          in.seek((int) (globalOffset + pointer)); 
    388392        } 
    389393        for (int j=0; j<count; j++) { 
    390           shorts[j] = DataTools.read2UnsignedBytes(in, littleEndian); 
     394          shorts[j] = in.readShort(); 
     395          if (shorts[j] < 0) shorts[j] += 65536; 
    391396        } 
    392397        if (shorts.length == 1) value = new Integer(shorts[0]); 
     
    397402        long[] longs = new long[count]; 
    398403        if (count > 1) { 
    399           long pointer = DataTools.read4UnsignedBytes(in, littleEndian); 
    400           in.seek(globalOffset + pointer); 
     404          long pointer = in.readInt(); 
     405          in.seek((int) (globalOffset + pointer)); 
    401406        } 
    402407        for (int j=0; j<count; j++) { 
    403           longs[j] = DataTools.read4UnsignedBytes(in, littleEndian); 
     408          longs[j] = in.readInt(); 
    404409        } 
    405410        if (longs.length == 1) value = new Long(longs[0]); 
     
    410415        // the second, the denominator 
    411416        TiffRational[] rationals = new TiffRational[count]; 
    412         long pointer = DataTools.read4UnsignedBytes(in, littleEndian); 
    413         in.seek(globalOffset + pointer); 
     417        long pointer = in.readInt(); 
     418        in.seek((int) (globalOffset + pointer)); 
    414419        for (int j=0; j<count; j++) { 
    415           long numer = DataTools.read4UnsignedBytes(in, littleEndian); 
    416           long denom = DataTools.read4UnsignedBytes(in, littleEndian); 
     420          long numer = in.readInt(); 
     421          long denom = in.readInt(); 
    417422          rationals[j] = new TiffRational(numer, denom); 
    418423        } 
     
    426431        byte[] sbytes = new byte[count]; 
    427432        if (count > 4) { 
    428           long pointer = DataTools.read4UnsignedBytes(in, littleEndian); 
    429           in.seek(globalOffset + pointer); 
    430         } 
    431         in.readFully(sbytes); 
     433          long pointer = in.readInt(); 
     434          in.seek((int) (globalOffset + pointer)); 
     435        } 
     436        in.read(sbytes); 
    432437        if (sbytes.length == 1) value = new Byte(sbytes[0]); 
    433438        else value = sbytes; 
     
    437442        short[] sshorts = new short[count]; 
    438443        if (count > 2) { 
    439           long pointer = DataTools.read4UnsignedBytes(in, littleEndian); 
    440           in.seek(globalOffset + pointer); 
     444          long pointer = in.readInt(); 
     445          in.seek((int) (globalOffset + pointer)); 
    441446        } 
    442447        for (int j=0; j<count; j++) { 
    443           sshorts[j] = DataTools.read2SignedBytes(in, littleEndian); 
     448          sshorts[j] = in.readShort(); 
    444449        } 
    445450        if (sshorts.length == 1) value = new Short(sshorts[0]); 
     
    450455        int[] slongs = new int[count]; 
    451456        if (count > 1) { 
    452           long pointer = DataTools.read4UnsignedBytes(in, littleEndian); 
    453           in.seek(globalOffset + pointer); 
     457          long pointer = in.readInt(); 
     458          in.seek((int) (globalOffset + pointer)); 
    454459        } 
    455460        for (int j=0; j<count; j++) { 
    456           slongs[j] = DataTools.read4SignedBytes(in, littleEndian); 
     461          slongs[j] = in.readInt(); 
    457462        } 
    458463        if (slongs.length == 1) value = new Integer(slongs[0]); 
     
    463468        // the second the denominator 
    464469        TiffRational[] srationals = new TiffRational[count]; 
    465         long pointer = DataTools.read4UnsignedBytes(in, littleEndian); 
    466         in.seek(globalOffset + pointer); 
     470        long pointer = in.readInt(); 
     471        in.seek((int) (globalOffset + pointer)); 
    467472        for (int j=0; j<count; j++) { 
    468           int numer = DataTools.read4SignedBytes(in, littleEndian); 
    469           int denom = DataTools.read4SignedBytes(in, littleEndian); 
     473          int numer = in.readInt(); 
     474          int denom = in.readInt(); 
    470475          srationals[j] = new TiffRational(numer, denom); 
    471476        } 
     
    477482        float[] floats = new float[count]; 
    478483        if (count > 1) { 
    479           long pointer = DataTools.read4UnsignedBytes(in, littleEndian); 
    480           in.seek(globalOffset + pointer); 
     484          long pointer = in.readInt(); 
     485          in.seek((int) (globalOffset + pointer)); 
    481486        } 
    482487        for (int j=0; j<count; j++) { 
    483           floats[j] = DataTools.readFloat(in, littleEndian); 
     488          floats[j] = in.readFloat(); 
    484489        } 
    485490        if (floats.length == 1) value = new Float(floats[0]); 
     
    489494        // Double precision (8-byte) IEEE format 
    490495        double[] doubles = new double[count]; 
    491         long pointer = DataTools.read4UnsignedBytes(in, littleEndian); 
    492         in.seek(globalOffset + pointer); 
     496        long pointer = in.readInt(); 
     497        in.seek((int) (globalOffset + pointer)); 
    493498        for (int j=0; j<count; j++) { 
    494           doubles[j] = DataTools.readDouble(in, littleEndian); 
     499          doubles[j] = in.readDouble(); 
    495500        } 
    496501        if (doubles.length == 1) value = new Double(doubles[0]); 
     
    499504      if (value != null) ifd.put(new Integer(tag), value); 
    500505    } 
    501     in.seek(globalOffset + offset + 2 + 12 * numEntries); 
     506    in.seek((int) (globalOffset + offset + 2 + 12 * numEntries)); 
    502507 
    503508    return ifd; 
     
    783788          bps[0] = (byte) (bitsPerSample[0] & 0xff); 
    784789          bps[1] = (byte) ((bitsPerSample[0] >>> 8) & 0xff); 
    785           //bps[2] = (byte) ((bitsPerSample[0] >>> 16) & 0xff); 
    786           //bps[3] = (byte) ((bitsPerSample[0] >>> 24) & 0xff); 
    787790 
    788791          int ndx = stripOffsets.length - 1; 
     
    801804        } 
    802805        else { 
    803           //bps[3] = (byte) (bitsPerSample[0] & 0xff); 
    804           //bps[2] = (byte) ((bitsPerSample[0] >>> 8) & 0xff); 
    805806          bps[1] = (byte) ((bitsPerSample[0] >>> 16) & 0xff); 
    806807          bps[0] = (byte) ((bitsPerSample[0] >>> 24) & 0xff); 
     
    830831          48 * imageWidth); 
    831832        byte[] row = new byte[(int) imageWidth]; 
    832         in.seek(stripOffsets[0]); 
     833        in.seek((int) stripOffsets[0]); 
    833834        in.read(row); 
    834835        boolean isZero = true; 
     
    842843        while (isZero) { 
    843844          stripOffsets[0] -= row.length; 
    844           in.seek(stripOffsets[0]); 
     845          in.seek((int) stripOffsets[0]); 
    845846          in.read(row); 
    846847          for (int i=0; i<row.length; i++) { 
     
    10671068      long actualRows = (row + rowsPerStrip > imageLength) ? 
    10681069        imageLength - row : rowsPerStrip; 
    1069       in.seek(stripOffsets[strip]); 
     1070      in.seek((int) stripOffsets[strip]); 
    10701071 
    10711072      if (stripByteCounts[strip] > Integer.MAX_VALUE) { 
     
    10741075      } 
    10751076      byte[] bytes = new byte[(int) stripByteCounts[strip]]; 
    1076       in.readFully(bytes); 
     1077      in.read(bytes); 
    10771078      if (compression != PACK_BITS) { 
    10781079        bytes = uncompress(bytes, compression); 
  • trunk/loci/formats/in/AVIReader.java

    r1134 r1195  
    7878  short bmpPlanes, bmpBitsPerPixel; 
    7979  boolean bmpTopDown; 
    80   short[] intData = null; 
    81   byte[] byteData = null; 
    8280  byte[] rawData = null; 
    8381  byte[] pr = null; 
     
    167165    } 
    168166 
    169     byteData = new byte[dwWidth * bmpHeight]; 
    170  
    171167    int c = (isRGB(id) && separated) ? 3 : 1; 
    172168    long fileOff = ((Long) offsets.get(no / c)).longValue(); 
    173     in.seek(fileOff); 
     169    in.seek((int) fileOff); 
    174170 
    175171    int len = bmpScanLineSize; 
     
    177173    int pad = bmpScanLineSize - dwWidth*(bmpBitsPerPixel / 8); 
    178174    rawData = new byte[bmpActualSize]; 
    179     int rawOffset = 0; 
    180     int offset = (bmpHeight - 1) * dwWidth; 
     175    int rawOffset = rawData.length - len; 
     176    int offset = 0; 
    181177 
    182178    for (int i=bmpHeight - 1; i>=0; i--) { 
    183       int n = in.read(rawData, rawOffset, len); 
    184       if (n < len) { 
    185         whine("Scan line " + i + " ended prematurely."); 
    186       } 
    187  
    188       unpack(rawData, rawOffset, byteData, offset, dwWidth); 
    189       rawOffset += (len - pad); 
    190       offset -= dwWidth; 
    191     } 
    192  
    193     // reverse scanline ordering 
    194  
    195     byte[] temp = rawData; 
    196     rawData = new byte[temp.length]; 
    197     int off = (bmpHeight - 1) * dwWidth * (bmpBitsPerPixel / 8); 
    198     int newOff = 0; 
    199     int length = dwWidth * (bmpBitsPerPixel / 8); 
    200     for (int q=0; q<bmpHeight; q++) { 
    201179      if (bmpBitsPerPixel == 8) { 
    202         System.arraycopy(temp, off, rawData, newOff, length); 
     180        in.read(rawData, rawOffset, len); 
    203181      } 
    204182      else { 
    205         // reverse bytes in groups of 3 
    206  
    207         for (int p=0; p<dwWidth; p++) { 
    208           rawData[newOff + p*3] = temp[off + p*3 + 2]; 
    209           rawData[newOff + p*3 + 1] = temp[off + p*3 + 1]; 
    210           rawData[newOff + p*3 + 2] = temp[off + p*3]; 
     183        byte b, g, r; 
     184        for (int j=0; j<dwWidth; j++) { 
     185          b = (byte) in.read(); 
     186          g = (byte) in.read(); 
     187          r = (byte) in.read(); 
     188          rawData[rawOffset + j*3] = r; 
     189          rawData[rawOffset + j*3 + 1] = g; 
     190          rawData[rawOffset + j*3 + 2] = b; 
    211191        } 
    212192      } 
    213193 
    214       off -= length; 
    215       newOff += length; 
     194      rawOffset -= (len - pad); 
     195      offset += dwWidth; 
    216196    } 
    217197 
     
    256236    super.initFile(id); 
    257237    in = new RandomAccessStream(id); 
     238    in.order(true); 
    258239 
    259240    offsets = new Vector(); 
     
    263244 
    264245    type = readStringBytes(); 
    265     size = DataTools.read4SignedBytes(in, little); 
     246    size = in.readInt(); 
    266247    fcc = readStringBytes(); 
    267248 
     
    279260    long spos = pos; 
    280261 
    281     while (in.read(list) == 4) { 
    282       in.seek(pos); 
     262    while ((in.length() - in.getFilePointer()) > 4) { 
     263      in.read(list); 
     264      in.seek((int) pos); 
    283265      listString = new String(list); 
    284266 
    285267      if (listString.equals("JUNK")) { 
    286268        type = readStringBytes(); 
    287         size = DataTools.read4SignedBytes(in, little); 
     269        size = in.readInt(); 
    288270 
    289271        if (type.equals("JUNK")) { 
     
    294276        spos = in.getFilePointer(); 
    295277        type = readStringBytes(); 
    296         size = DataTools.read4SignedBytes(in, little); 
     278        size = in.readInt(); 
    297279        fcc = readStringBytes(); 
    298280 
    299         in.seek(spos); 
     281        in.seek((int) spos); 
    300282        if (fcc.equals("hdrl")) { 
    301283          type = readStringBytes(); 
    302           size = DataTools.read4SignedBytes(in, little); 
     284          size = in.readInt(); 
    303285          fcc = readStringBytes(); 
    304286 
     
    306288            if (fcc.equals("hdrl")) { 
    307289              type = readStringBytes(); 
    308               size = DataTools.read4SignedBytes(in, little); 
     290              size = in.readInt(); 
    309291              if (type.equals("avih")) { 
    310292                spos = in.getFilePointer(); 
    311293 
    312                 dwMicroSecPerFrame = DataTools.read4SignedBytes(in, little); 
    313                 dwMaxBytesPerSec = DataTools.read4SignedBytes(in, little); 
    314                 dwReserved1 = DataTools.read4SignedBytes(in, little); 
    315                 dwFlags = DataTools.read4SignedBytes(in, little); 
    316                 dwTotalFrames = DataTools.read4SignedBytes(in, little); 
    317                 dwInitialFrames = DataTools.read4SignedBytes(in, little); 
    318                 dwStreams = DataTools.read4SignedBytes(in, little); 
    319                 dwSuggestedBufferSize = 
    320                   DataTools.read4SignedBytes(in, little); 
    321                 dwWidth = DataTools.read4SignedBytes(in, little); 
    322                 dwHeight = DataTools.read4SignedBytes(in, little); 
    323                 dwScale = DataTools.read4SignedBytes(in, little); 
    324                 dwRate = DataTools.read4SignedBytes(in, little); 
    325                 dwStart = DataTools.read4SignedBytes(in, little); 
    326                 dwLength = DataTools.read4SignedBytes(in, little); 
     294                dwMicroSecPerFrame = in.readInt(); 
     295                dwMaxBytesPerSec = in.readInt(); 
     296                dwReserved1 = in.readInt(); 
     297                dwFlags = in.readInt(); 
     298                dwTotalFrames = in.readInt(); 
     299                dwInitialFrames = in.readInt(); 
     300                dwStreams = in.readInt(); 
     301                dwSuggestedBufferSize = in.readInt(); 
     302                dwWidth = in.readInt(); 
     303                dwHeight = in.readInt(); 
     304                dwScale= in.readInt(); 
     305                dwRate = in.readInt(); 
     306                dwStart = in.readInt(); 
     307                dwLength = in.readInt(); 
    327308 
    328309                metadata.put("Microseconds per frame", 
     
    339320                metadata.put("Length", new Integer(dwLength)); 
    340321 
    341                 in.seek(spos + size); 
     322                try { 
     323                  in.seek((int) (spos + size)); 
     324                } 
     325                catch (Exception e) { } 
    342326              } 
    343327            } 
     
    349333 
    350334          type = readStringBytes(); 
    351           size = DataTools.read4SignedBytes(in, little); 
     335          size = in.readInt(); 
    352336          fcc = readStringBytes(); 
    353337 
     
    355339            if (fcc.equals("strl")) { 
    356340              type = readStringBytes(); 
    357               size = DataTools.read4SignedBytes(in, little); 
     341              size = in.readInt(); 
    358342 
    359343              if (type.equals("strh")) { 
     
    367351 
    368352                fccStreamHandler = readStringBytes(); 
    369                 dwStreamFlags = DataTools.read4SignedBytes(in, little); 
    370                 dwStreamReserved1 = DataTools.read4SignedBytes(in, little); 
    371                 dwStreamInitialFrames = DataTools.read4SignedBytes(in, little); 
    372                 dwStreamScale = DataTools.read4SignedBytes(in, little); 
    373                 dwStreamRate = DataTools.read4SignedBytes(in, little); 
    374                 dwStreamStart = DataTools.read4SignedBytes(in, little); 
    375                 dwStreamLength = DataTools.read4SignedBytes(in, little); 
    376                 dwStreamSuggestedBufferSize = 
    377                   DataTools.read4SignedBytes(in, little); 
    378                 dwStreamQuality = DataTools.read4SignedBytes(in, little); 
    379                 dwStreamSampleSize = DataTools.read4SignedBytes(in, little); 
     353 
     354                dwStreamFlags = in.readInt(); 
     355                dwStreamReserved1 = in.readInt(); 
     356                dwStreamInitialFrames = in.readInt(); 
     357                dwStreamScale = in.readInt(); 
     358                dwStreamRate = in.readInt(); 
     359                dwStreamStart = in.readInt(); 
     360                dwStreamLength = in.readInt(); 
     361                dwStreamSuggestedBufferSize = in.readInt(); 
     362                dwStreamQuality = in.readInt(); 
     363                dwStreamSampleSize = in.readInt(); 
    380364 
    381365                metadata.put("Stream quality", new Integer(dwStreamQuality)); 
     
    383367                  new Integer(dwStreamSampleSize)); 
    384368 
    385                 in.seek(spos + size); 
     369                try { 
     370                  in.seek((int) (spos + size)); 
     371                } 
     372                catch (Exception e) { } 
    386373              } 
    387374 
    388375              type = readStringBytes(); 
    389               size = DataTools.read4SignedBytes(in, little); 
     376              size = in.readInt(); 
    390377              if (type.equals("strf")) { 
    391378                spos = in.getFilePointer(); 
    392                 bmpSize = DataTools.read4SignedBytes(in, little); 
    393                 bmpWidth = DataTools.read4SignedBytes(in, little); 
    394                 bmpHeight = DataTools.read4SignedBytes(in, little); 
    395                 bmpPlanes = DataTools.read2SignedBytes(in, little); 
    396                 bmpBitsPerPixel = DataTools.read2SignedBytes(in, little); 
    397                 bmpCompression = DataTools.read4SignedBytes(in, little); 
    398                 bmpSizeOfBitmap = DataTools.read4SignedBytes(in, little); 
    399                 bmpHorzResolution = DataTools.read4SignedBytes(in, little); 
    400                 bmpVertResolution = DataTools.read4SignedBytes(in, little); 
    401                 bmpColorsUsed = DataTools.read4SignedBytes(in, little); 
    402                 bmpColorsImportant = DataTools.read4SignedBytes(in, little); 
     379 
     380                bmpSize = in.readInt(); 
     381                bmpWidth = in.readInt(); 
     382                bmpHeight = in.readInt(); 
     383                bmpPlanes = in.readShort(); 
     384                bmpBitsPerPixel = in.readShort(); 
     385                bmpCompression = in.readInt(); 
     386                bmpSizeOfBitmap = in.readInt(); 
     387                bmpHorzResolution = in.readInt(); 
     388                bmpVertResolution = in.readInt(); 
     389                bmpColorsUsed = in.readInt(); 
     390                bmpColorsImportant = in.readInt(); 
    403391 
    404392                bmpTopDown = (bmpHeight < 0); 
     
    470458                } 
    471459 
    472                 in.seek(spos + size); 
     460                in.seek((int) (spos + size)); 
    473461              } 
    474462            } 
     
    476464            spos = in.getFilePointer(); 
    477465            type = readStringBytes(); 
    478             size = DataTools.read4SignedBytes(in, little); 
     466            size = in.readInt(); 
    479467            if (type.equals("strd")) { 
    480468              in.skipBytes(size); 
     
    486474            spos = in.getFilePointer(); 
    487475            type = readStringBytes(); 
    488             size = DataTools.read4SignedBytes(in, little); 
     476            size = in.readInt(); 
    489477            if (type.equals("strn")) { 
    490478              in.skipBytes(size); 
     
    495483          } 
    496484 
    497           in.seek((int) (startPos + 8 + streamSize)); 
     485          try { 
     486            in.seek(startPos + 8 + streamSize); 
     487          } 
     488          catch (Exception e) { } 
    498489        } 
    499490        else if (fcc.equals("movi")) { 
    500491          type = readStringBytes(); 
    501           size = DataTools.read4SignedBytes(in, little); 
     492          size = in.readInt(); 
    502493          fcc = readStringBytes(); 
    503494 
     
    506497              spos = in.getFilePointer(); 
    507498              type = readStringBytes(); 
    508               size = DataTools.read4SignedBytes(in, little); 
     499              size = in.readInt(); 
    509500              fcc = readStringBytes(); 
    510501              if (!(type.equals("LIST") && fcc.equals("rec "))) { 
    511                 in.seek(spos); 
     502                in.seek((int) spos); 
    512503              } 
    513504 
    514505              spos = in.getFilePointer(); 
    515506              type = readStringBytes(); 
    516               size = DataTools.read4SignedBytes(in, little); 
     507              size = in.readInt(); 
    517508 
    518509              while (type.substring(2).equals("db") || 
     
    530521 
    531522                type = readStringBytes(); 
    532                 size = DataTools.read4SignedBytes(in, little); 
     523                size = in.readInt(); 
    533524                if (type.equals("JUNK")) { 
    534525                  in.skipBytes(size); 
    535526                  spos = in.getFilePointer(); 
    536527                  type = readStringBytes(); 
    537                   size = DataTools.read4SignedBytes(in, little); 
     528                  size = in.readInt(); 
    538529                } 
    539530              } 
     
    544535        else { 
    545536          // skipping unknown block 
    546           in.skipBytes(8 + size); 
     537          try { 
     538            in.skipBytes(8 + size); 
     539          } 
     540          catch (IllegalArgumentException iae) { } 
    547541        } 
    548542      } 
     
    550544        // skipping unknown block 
    551545        type = readStringBytes(); 
    552         size = DataTools.read4SignedBytes(in, little); 
    553         in.skipBytes(size); 
     546        try { 
     547          size = in.readInt(); 
     548          in.skipBytes(size); 
     549        } 
     550        catch (Exception iae) { } 
    554551      } 
    555552      pos = in.getFilePointer(); 
     
    584581  } 
    585582 
    586   /** Unpacks a byte array into a new byte array. */ 
    587   public void unpack(byte[] rawData, int rawOffset, byte[] byteData, 
    588     int byteOffset, int w) 
    589   { 
    590     for (int i=0; i<w; i++) { 
    591       byteData[byteOffset + i] = rawData[rawOffset + i]; 
    592     } 
    593   } 
    594  
    595583  /** Reads a 4-byte String. */ 
    596584  public String readStringBytes() throws IOException { 
  • trunk/loci/formats/in/AndorReader.java

    r1134 r1195  
    313313    } 
    314314 
    315     order = new String(); 
     315    order = "XY"; 
    316316    for (int i=0; i<dimOrder.length; i++) { 
    317317      String name = names[dimOrder[i]].trim(); 
  • trunk/loci/formats/in/BMPReader.java

    r1134 r1195  
    267267 
    268268    littleEndian = true; 
     269    in.order(littleEndian); 
    269270 
    270271    // read the first header - 14 bytes 
     
    274275    metadata.put("Magic identifier", new String(two)); 
    275276 
    276     byte[] four = new byte[4]; 
    277     in.read(four); 
    278     metadata.put("File size (in bytes)", 
    279       "" + DataTools.bytesToInt(four, littleEndian)); 
    280  
    281     in.skipBytes(4);  // reserved 
     277    metadata.put("File size (in bytes)", "" + in.readInt()); 
     278    in.skipBytes(4); // reserved 
    282279 
    283280    // read the offset to the image data 
    284     in.read(four); 
    285     offset = DataTools.bytesToInt(four, littleEndian); 
     281    offset = in.readInt(); 
    286282 
    287283    // read the second header - 40 bytes 
     
    291287    // get the dimensions 
    292288 
    293     in.read(four); 
    294     width = DataTools.bytesToInt(four, littleEndian); 
    295     in.read(four); 
    296     height = DataTools.bytesToInt(four, littleEndian); 
     289    width = in.readInt(); 
     290    height = in.readInt(); 
     291 
    297292    if (width < 1 || height < 1) { 
    298293      throw new FormatException("Invalid image dimensions: " + 
     
    302297    metadata.put("Image height", "" + height); 
    303298 
    304     in.read(two); 
    305     metadata.put("Color planes", "" + DataTools.bytesToInt(two, littleEndian)); 
    306  
    307     in.read(two); 
    308     bpp = DataTools.bytesToInt(two, littleEndian); 
     299    metadata.put("Color planes", "" + in.readShort()); 
     300    bpp = in.readShort(); 
    309301    metadata.put("Bits per pixel", "" + bpp); 
    310302 
    311     in.read(four); 
    312     compression = DataTools.bytesToInt(four, littleEndian); 
     303    compression = in.readInt(); 
    313304    String comp = "invalid"; 
    314305 
     
    323314 
    324315    in.skipBytes(4); 
    325  
    326     in.read(four); 
    327     metadata.put("X resolution", "" + 
    328       DataTools.bytesToInt(four, littleEndian)); 
    329     in.read(four); 
    330     metadata.put("Y resolution", "" + 
    331       DataTools.bytesToInt(four, littleEndian)); 
    332  
    333     in.read(four); 
    334     int nColors = DataTools.bytesToInt(four, littleEndian); 
    335  
     316    metadata.put("X resolution", "" + in.readInt()); 
     317    metadata.put("Y resolution", "" + in.readInt()); 
     318    int nColors = in.readInt(); 
    336319    in.skipBytes(4); 
    337320 
  • trunk/loci/formats/in/BaseTiffReader.java

    r1134 r1195  
    4141  // -- Fields -- 
    4242 
    43   /** Random access file for the current TIFF. */ 
     43  /** Current TIFF file. */ 
    4444  protected RandomAccessStream in; 
    4545 
     
    571571    super.initFile(id); 
    572572    in = new RandomAccessStream(id); 
     573    if (in.readShort() == 0x4949) in.order(true); 
    573574 
    574575    ifds = TiffTools.getIFDs(in); 
  • trunk/loci/formats/in/BioRadReader.java

    r1134 r1195  
    214214    if (!byteFormat) offset *= 2; 
    215215    in.seek(offset + 76); 
    216     in.readFully(data); 
     216    in.read(data); 
    217217    return data; 
    218218  } 
     
    228228  /** Closes any open files. */ 
    229229  public void close() throws FormatException, IOException { 
    230     if (currentId == null) return; 
    231     in.close(); 
    232230    currentId = null; 
     231    if (in != null) in.close(); 
    233232    in = null; 
    234233    metadata = null; 
     
    239238    super.initFile(id); 
    240239    in = new RandomAccessStream(id); 
     240    in.order(true); 
    241241 
    242242    // read header 
    243     byte[] header = new byte[76]; 
    244     in.readFully(header); 
    245  
    246     nx = DataTools.bytesToInt(header, 0, 2, LITTLE_ENDIAN); 
    247     ny = DataTools.bytesToInt(header, 2, 2, LITTLE_ENDIAN); 
    248     npic = DataTools.bytesToInt(header, 4, 2, LITTLE_ENDIAN); 
    249     byteFormat = DataTools.bytesToInt(header, 14, 2, LITTLE_ENDIAN) != 0; 
    250  
    251     int ramp1min = DataTools.bytesToInt(header, 6, 2, LITTLE_ENDIAN); 
    252     int ramp1max = DataTools.bytesToInt(header, 8, 2, LITTLE_ENDIAN); 
    253     boolean notes = (header[10] | header[11] | header[12] | header[13]) != 0; 
    254     int imageNumber = DataTools.bytesToInt(header, 16, 2, LITTLE_ENDIAN); 
    255     String name = new String(header, 18, 32); 
    256     int merged = DataTools.bytesToInt(header, 50, 2, LITTLE_ENDIAN); 
    257     int color1 = DataTools.bytesToInt(header, 52, 2, LITTLE_ENDIAN); 
    258     int fileId = DataTools.bytesToInt(header, 54, 2, LITTLE_ENDIAN); 
    259     int ramp2min = DataTools.bytesToInt(header, 56, 2, LITTLE_ENDIAN); 
    260     int ramp2max = DataTools.bytesToInt(header, 58, 2, LITTLE_ENDIAN); 
    261     int color2 = DataTools.bytesToInt(header, 60, 2, LITTLE_ENDIAN); 
    262     int edited = DataTools.bytesToInt(header, 62, 2, LITTLE_ENDIAN); 
    263     int lens = DataTools.bytesToInt(header, 64, 2, LITTLE_ENDIAN); 
    264     float magFactor = 
    265       Float.intBitsToFloat(DataTools.bytesToInt(header, 66, 4, LITTLE_ENDIAN)); 
     243 
     244    nx = in.readShort(); 
     245    ny = in.readShort(); 
     246    npic = in.readShort(); 
     247 
     248    int ramp1min = in.readShort(); 
     249    int ramp1max = in.readShort(); 
     250    boolean notes = (in.read() | in.read() | in.read() | in.read()) != 0; 
     251    byteFormat = in.readShort() != 0; 
     252    int imageNumber = in.readShort(); 
     253    byte[] s = new byte[32]; 
     254    in.read(s); 
     255    String name = new String(s); 
     256    int merged = in.readShort(); 
     257    int color1 = in.readShort(); 
     258    int fileId = in.readShort(); 
     259    int ramp2min = in.readShort(); 
     260    int ramp2max = in.readShort(); 
     261    int color2 = in.readShort(); 
     262    int edited = in.readShort(); 
     263    int lens = in.readShort(); 
     264    float magFactor = in.readFloat(); 
    266265 
    267266    // check validity of header 
     
    293292    int imageLen = nx * ny; 
    294293    int bpp = byteFormat ? 1 : 2; 
    295     in.skipBytes(bpp * npic * imageLen); 
     294    in.skipBytes(bpp * npic * imageLen + 6); 
    296295 
    297296    Vector pixelSize = new Vector(); 
     
    305304    while (notes) { 
    306305      // read in note 
    307       byte[] note = new byte[96]; 
    308       in.readFully(note); 
    309       int level = DataTools.bytesToInt(note, 0, 2, LITTLE_ENDIAN); 
    310       notes = (note[2] | note[3] | note[4] | note[5]) != 0; 
    311       int num = DataTools.bytesToInt(note, 6, 2, LITTLE_ENDIAN); 
    312       int status = DataTools.bytesToInt(note, 8, 2, LITTLE_ENDIAN); 
    313       int type = DataTools.bytesToInt(note, 10, 2, LITTLE_ENDIAN); 
    314       int x = DataTools.bytesToInt(note, 12, 2, LITTLE_ENDIAN); 
    315       int y = DataTools.bytesToInt(note, 14, 2, LITTLE_ENDIAN); 
    316       String text = new String(note, 16, 80); 
     306 
     307      int level = in.readShort(); 
     308      notes = (in.read() | in.read() | in.read() | in.read()) != 0; 
     309      int num = in.readShort(); 
     310      int status = in.readShort(); 
     311      int type = in.readShort(); 
     312      int x = in.readShort(); 
     313      int y = in.readShort(); 
     314      s = new byte[80]; 
     315      in.read(s); 
     316      String text = new String(s); 
    317317 
    318318      // add note to list 
    319319      noteCount++; 
     320 
    320321      metadata.put("note" + noteCount, 
    321322        noteString(num, level, status, type, x, y, text)); 
     
    421422    while (!eof && numLuts < 3) { 
    422423      try { 
    423         in.readFully(lut[numLuts]); 
     424        in.read(lut[numLuts]); 
    424425        numLuts++; 
    425426      } 
    426       catch (IOException exc) { 
     427      catch (Exception exc) { 
    427428        eof = true; 
    428429        if (DEBUG) exc.printStackTrace(); 
     
    458459 
    459460    // populate Pixels element 
    460     int type = DataTools.bytesToInt(header, 14, 2, LITTLE_ENDIAN); 
     461    in.seek(14); 
     462    //int type = DataTools.bytesToInt(header, 14, 2, LITTLE_ENDIAN); 
     463    int type = in.readShort(); 
    461464    String fmt; 
    462465    if (type == 1) fmt = "Uint8"; 
  • trunk/loci/formats/in/DicomReader.java

    r1134 r1195  
    280280    super.initFile(id); 
    281281    in = new RandomAccessStream(id); 
     282    in.order(true); 
    282283 
    283284    little = true; 
     
    287288 
    288289    byte[] four = new byte[4]; 
    289     long pos = in.getFilePointer(); 
    290     in.skipBytes(128); 
     290    long pos = 0; 
     291    in.seek(128); 
    291292    in.read(four); 
    292293    if ((new String(four)).equals("DICM")) { 
     
    296297      in.read(header); 
    297298      metadata.put("Header information", new String(header)); 
    298       in.skipBytes(4); 
     299      in.readInt(); 
    299300      location = 128; 
    300301    } 
     
    340341          break; 
    341342        case SAMPLES_PER_PIXEL: 
    342           int samplesPerPixel = DataTools.read2SignedBytes(in, little); 
     343          int samplesPerPixel = in.readShort(); 
    343344          addInfo(tag, samplesPerPixel); 
    344345          break; 
     
    350351          break; 
    351352        case PLANAR_CONFIGURATION: 
    352           int planarConfiguration = DataTools.read2SignedBytes(in, little); 
     353          int planarConfiguration = in.readShort(); 
    353354          addInfo(tag, planarConfiguration); 
    354355          break; 
    355356        case ROWS: 
    356           height = DataTools.read2SignedBytes(in, little); 
     357          height = in.readShort(); 
    357358          addInfo(tag, height); 
    358359          break; 
    359360        case COLUMNS: 
    360           width = DataTools.read2SignedBytes(in, little); 
     361          width = in.readShort(); 
    361362          addInfo(tag, width); 
    362363          break; 
     
    374375          break; 
    375376        case BITS_ALLOCATED: 
    376           bitsPerPixel = DataTools.read2SignedBytes(in, little); 
     377          bitsPerPixel = in.readShort(); 
    377378          addInfo(tag, bitsPerPixel); 
    378379          break; 
    379380        case PIXEL_REPRESENTATION: 
    380           int pixelRepresentation = DataTools.read2SignedBytes(in, little); 
     381          int pixelRepresentation = in.readShort(); 
    381382          signed = pixelRepresentation == 1; 
    382383          addInfo(tag, pixelRepresentation); 
     
    503504      case US: 
    504505        if (elementLength == 2) { 
    505           value = Integer.toString(DataTools.read2SignedBytes(in, little)); 
     506          value = Integer.toString(in.readShort()); 
    506507        } 
    507508        else { 
     
    510511          for (int i=0; i<n; i++) 
    511512            value += 
    512               Integer.toString(DataTools.read2SignedBytes(in, little)) + " "; 
     513              Integer.toString(in.readShort()) + " "; 
    513514          } 
    514515          break; 
     
    529530    if (skip) { 
    530531      long skipCount = (long) elementLength; 
    531       while ((skipCount > 0) && (in.length() - in.getFilePointer()) > 0) { 
    532         skipCount -= in.skipBytes((int) skipCount); 
    533       } 
     532      try { 
     533        in.skipBytes((int) skipCount); 
     534      } 
     535      catch (Exception e) { } 
    534536      location += elementLength; 
    535537      value = ""; 
     
    561563        // Explicit VR with 32-bit length if other two bytes are zero 
    562564        if ((b[2] == 0) || (b[3] == 0)) { 
    563           return (int) DataTools.read4SignedBytes(in, little); 
     565          return in.readInt(); 
    564566        } 
    565567        vr = IMPLICIT_VR; 
     
    600602 
    601603  private int getNextTag() throws IOException { 
    602     int groupWord = DataTools.read2SignedBytes(in, little); 
     604    int groupWord = in.readShort(); 
    603605    if (groupWord == 0x0800 && bigEndianTransferSyntax) { 
    604606      little = false; 
    605607      groupWord = 0x0008; 
     608      in.order(false); 
    606609    } 
    607610 
    608     int elementWord = DataTools.read2SignedBytes(in, little); 
     611    int elementWord = in.readShort(); 
    609612    int tag = groupWord << 16 | elementWord; 
    610613    elementLength = getLength(); 
  • trunk/loci/formats/in/FluoviewReader.java

    r1134 r1195  
    139139      // determine byte order 
    140140      boolean little = TiffTools.isLittleEndian(ifd); 
     141 
     142      in.order(little); 
    141143 
    142144      // set file pointer to start reading MM_HEAD metadata 
     
    221223      // read in comments field 
    222224      if (commentSize > 0) { 
    223         in.seek(commentOffset); 
     225        in.seek((int) commentOffset); 
    224226        byte[] comments = new byte[(int) commentSize]; 
    225227        in.read(comments); 
     
    250252          dimName = new char[16]; 
    251253          for (int i=0; i<16; i++) { 
    252             dimName[i] = in.readChar(); 
     254            dimName[i] = (char) in.read(); 
     255            in.read(); 
    253256          } 
    254257 
    255           newNum = DataTools.read4SignedBytes(in, little); 
    256           origin = (float) DataTools.readDouble(in, little); 
     258          newNum = in.readInt(); 
     259          origin = (float) in.readDouble(); 
    257260          if (j == 1) stageX = origin; 
    258261          else if (j == 2) stageY = origin; 
    259262          else if (j == 3) stageZ = origin; 
    260263 
    261           DataTools.readDouble(in, little); // skip next double 
     264          in.readDouble(); // skip next double 
    262265        } 
    263266      } 
     
    424427      } 
    425428    } 
    426     catch (NullPointerException e) { /* most likely MMHEADER not found */ } 
    427     catch (IOException e) { e.printStackTrace(); } 
    428     catch (FormatException e) { e.printStackTrace(); } 
     429    catch (Exception e) { e.printStackTrace(); } 
    429430  } 
    430431 
  • trunk/loci/formats/in/IPLabReader.java

    r1134 r1195  
    163163 
    164164    byte[] rawData = new byte[numPixels * bps]; 
    165     in.readFully(rawData); 
     165    in.read(rawData); 
    166166 
    167167    if (isRGB(id) && separated) { 
     
    195195    littleEndian = new String(fourBytes).equals("iiii"); 
    196196 
     197    in.order(littleEndian); 
     198 
    197199    // populate standard metadata hashtable and OME root node 
    198200    in.skipBytes(12); 
    199201 
    200     dataSize = (int) DataTools.read4UnsignedBytes(in, littleEndian); 
    201     dataSize -= 28; // size of raw image data, in bytes 
    202     width = (int) DataTools.read4UnsignedBytes(in, littleEndian); 
    203     height = (int) DataTools.read4UnsignedBytes(in, littleEndian); 
    204     c = (int) DataTools.read4UnsignedBytes(in, littleEndian); 
    205     long zDepth = DataTools.read4UnsignedBytes(in, littleEndian); 
    206     long tDepth = DataTools.read4UnsignedBytes(in, littleEndian); 
    207     pixelType = (int) DataTools.read4UnsignedBytes(in, littleEndian); 
    208  
    209     numImages = (int) (zDepth * tDepth); 
     202    dataSize = in.readInt() - 28; 
     203    width = in.readInt(); 
     204    height = in.readInt(); 
     205    c = in.readInt(); 
     206    int zDepth = in.readInt(); 
     207    int tDepth = in.readInt(); 
     208    pixelType = in.readInt(); 
     209 
     210    numImages = zDepth * tDepth; 
    210211 
    211212    metadata.put("Width", new Long(width)); 
     
    246247 
    247248    metadata.put("PixelType", ptype); 
    248     in.skipBytes((int) dataSize); 
     249    in.skipBytes(dataSize); 
    249250 
    250251    String typeAsString; 
     
    284285      if (tag.equals("clut")) { 
    285286        // read in Color Lookup Table 
    286         long size = DataTools.read4UnsignedBytes(in, littleEndian); 
     287        int size = in.readInt(); 
    287288        if (size == 8) { 
    288289          // indexed lookup table 
    289           in.skipBytes(4); 
    290           long type=DataTools.read4UnsignedBytes(in, littleEndian); 
     290          in.readInt(); 
     291          int type = in.readInt(); 
    291292          String clutType; 
    292293          switch ((int) type) { 
     
    308309          // explicitly defined lookup table 
    309310          // length is 772 
    310           in.skipBytes(4); 
     311          in.readInt(); 
    311312          byte[] colorTable = new byte[256*3]; 
    312313          in.read(colorTable); 
     
    316317        // read in normalization information 
    317318 
    318         long size = DataTools.read4UnsignedBytes(in, littleEndian); 
     319        int size = in.readInt(); 
    319320        // error checking 
    320321 
     
    324325 
    325326        for (int i=0; i<c; i++) { 
    326           long source = DataTools.read4UnsignedBytes(in, littleEndian); 
     327          long source = in.readInt(); 
    327328 
    328329          String sourceType; 
     
    338339          metadata.put("NormalizationSource" + i, sourceType); 
    339340 
    340           double min=DataTools.read8SignedBytes(in, littleEndian); 
    341           double max=DataTools.read8SignedBytes(in, littleEndian); 
    342           double gamma=DataTools.read8SignedBytes(in, littleEndian); 
    343           double black=DataTools.read8SignedBytes(in, littleEndian); 
    344           double white=DataTools.read8SignedBytes(in, littleEndian); 
     341          double min = in.readDouble(); 
     342          double max = in.readDouble(); 
     343          double gamma = in.readDouble(); 
     344          double black = in.readDouble(); 
     345          double white = in.readDouble(); 
    345346 
    346347          metadata.put("NormalizationMin" + i, new Double(min)); 
     
    354355        // read in header labels 
    355356 
    356         in.skipBytes(4); // size is defined to 2200 
     357        in.readInt(); // size is defined to 2200 
    357358 
    358359        for (int i=0; i<100; i++) { 
    359           int num = DataTools.read2UnsignedBytes(in, littleEndian); 
     360          int num = in.readShort(); 
    360361          in.read(fourBytes); 
    361362          String name = new String(fourBytes); 
     
    366367        // read in ROI information 
    367368 
    368         long size = DataTools.read4UnsignedBytes(in, littleEndian); 
    369         long roiType = DataTools.read4UnsignedBytes(in, littleEndian); 
    370         long roiLeft = DataTools.read4UnsignedBytes(in, littleEndian); 
    371         long roiTop = DataTools.read4UnsignedBytes(in, littleEndian); 
    372         long roiRight = DataTools.read4UnsignedBytes(in, littleEndian); 
    373         long roiBottom = DataTools.read4UnsignedBytes(in, littleEndian); 
    374         long numRoiPts = DataTools.read4UnsignedBytes(in, littleEndian); 
     369        int size = in.readInt(); 
     370        int roiType = in.readInt(); 
     371        int roiLeft = in.readInt(); 
     372        int roiTop = in.readInt(); 
     373        int roiRight = in.readInt(); 
     374        int roiBottom = in.readInt(); 
     375        int numRoiPts = in.readInt(); 
    375376 
    376377        Integer x0 = new Integer((int) roiLeft); 
     
    382383 
    383384        for (int i=0; i<numRoiPts; i++) { 
    384           long ptX = DataTools.read4UnsignedBytes(in, littleEndian); 
    385           long ptY = DataTools.read4UnsignedBytes(in, littleEndian); 
     385          int ptX = in.readInt(); 
     386          int ptY = in.readInt(); 
    386387        } 
    387388      } 
     
    391392      else if (tag.equals("unit")) { 
    392393        // read in units 
    393         in.skipBytes(4); // size is 48 
     394        in.readInt(); // size is 48 
    394395 
    395396        for (int i=0; i<4; i++) { 
    396           long xResStyle = DataTools.read4UnsignedBytes(in, littleEndian); 
    397           long unitsPerPixel = DataTools.read4UnsignedBytes(in, littleEndian); 
    398           long xUnitName = DataTools.read4UnsignedBytes(in, littleEndian); 
     397          int xResStyle = in.readInt(); 
     398          int unitsPerPixel = in.readInt(); 
     399          int xUnitName = in.readInt(); 
    399400 
    400401          metadata.put("ResolutionStyle" + i, new Long(xResStyle)); 
     
    411412      else if (tag.equals("view")) { 
    412413        // read in view 
    413         in.skipBytes(4); 
     414        in.readInt(); 
    414415      } 
    415416      else if (tag.equals("plot")) { 
    416417        // read in plot 
    417418        // skipping this field for the moment 
    418         in.skipBytes(4); // size is 2508 
    419         in.skipBytes(2508); 
     419        in.skipBytes(2512); 
    420420      } 
    421421      else if (tag.equals("notes")) { 
    422422        // read in notes (image info) 
    423         in.skipBytes(4); // size is 576 
     423        in.readInt(); // size is 576 
    424424        byte[] temp = new byte[64]; 
    425425        in.read(temp); 
     
    433433        store.setImage(id, null, notes, null); 
    434434      } 
    435       int r = in.read(fourBytes); 
    436       if (r > 0) { 
     435      try { 
     436        in.read(fourBytes); 
    437437        tag = new String(fourBytes); 
    438438      } 
    439       else { // eof 
    440         tag = "fini"; 
    441       } 
     439      catch (Exception e) { tag = "fini"; } 
     440 
    442441    } 
    443442  } 
  • trunk/loci/formats/in/IPWReader.java

    r1135 r1195  
    122122  public int getSizeZ(String id) throws FormatException, IOException { 
    123123    if (!id.equals(currentId)) initFile(id); 
    124     return Integer.parseInt((String) metadata.get("frames")); 
     124    return Integer.valueOf(metadata.get("frames").toString()).intValue(); 
    125125  } 
    126126 
     
    164164    ifds = (Hashtable[]) allIFDs.get(new Integer(no)); 
    165165    ra = new RandomAccessStream(pixels); 
     166    ra.order(true); 
     167 
    166168    return TiffTools.getImage(ifds[0], ra); 
    167169  } 
     
    169171  /** Closes any open files. */ 
    170172  public void close() throws FormatException, IOException { 
     173    if (ra != null) ra.close(); 
     174    ra = null; 
    171175    if (in != null) in.close(); 
    172176    in = null; 
     
    178182    if (noPOI) throw new FormatException(NO_POI_MSG); 
    179183    currentId = id; 
     184 
    180185    in = new RandomAccessStream(id); 
     186 
    181187    metadata = new Hashtable(); 
    182188    allIFDs = new Hashtable(); 
     
    191197        Integer key = new Integer(i); 
    192198        ra = new RandomAccessStream((byte[]) pixelData.get(key)); 
     199        ra.order(true); 
    193200        allIFDs.put(key, TiffTools.getIFDs(ra)); 
    194201      } 
     
    209216  { 
    210217    ifds = (Hashtable[]) allIFDs.get(new Integer(0)); 
    211     //super.initMetadata(); 
    212218 
    213219    // parse the image description 
  • trunk/loci/formats/in/ImarisReader.java

    r1134 r1195  
    174174    super.initFile(id); 
    175175    in = new RandomAccessStream(id); 
     176    in.order(IS_LITTLE); 
     177 
    176178    dims = new int[4]; 
    177179 
    178     long magic = DataTools.read4UnsignedBytes(in, IS_LITTLE); 
     180    long magic = in.readInt(); 
    179181    if (magic != IMARIS_MAGIC_NUMBER) { 
    180182      throw new FormatException("Imaris magic number not found."); 
    181183    } 
    182184 
    183     int version = DataTools.read4SignedBytes(in, IS_LITTLE); 
     185    int version = in.readInt(); 
    184186    metadata.put("Version", new Integer(version)); 
    185     in.skipBytes(4); 
     187    in.readInt(); 
    186188 
    187189    byte[] name = new byte[128]; 
     
    190192    metadata.put("Image name", iName); 
    191193 
    192     dims[0] = DataTools.read2SignedBytes(in, IS_LITTLE); 
    193     dims[1] = DataTools.read2SignedBytes(in, IS_LITTLE); 
    194     dims[2] = DataTools.read2SignedBytes(in, IS_LITTLE); 
    195  
    196     in.skipBytes(2); // data type, ignore for now 
    197  
    198     dims[3] = DataTools.read4SignedBytes(in, IS_LITTLE); 
     194    dims[0] = in.readShort(); 
     195    dims[1] = in.readShort(); 
     196    dims[2] = in.readShort(); 
     197 
     198    in.skipBytes(2); 
     199 
     200    dims[3] = in.readInt(); 
    199201    in.skipBytes(2); 
    200202 
     
    204206    metadata.put("Original date", origDate); 
    205207 
    206     float dx = DataTools.readFloat(in, IS_LITTLE); 
    207     float dy = DataTools.readFloat(in, IS_LITTLE); 
    208     float dz = DataTools.readFloat(in, IS_LITTLE); 
    209     short mag = DataTools.read2SignedBytes(in, IS_LITTLE); 
     208    float dx = in.readFloat(); 
     209    float dy = in.readFloat(); 
     210    float dz = in.readFloat(); 
     211    short mag = in.readShort(); 
    210212 
    211213    byte[] com = new byte[128]; 
     
    213215    String comment = new String(com); 
    214216    metadata.put("Image comment", comment); 
    215     int isSurvey = DataTools.read4SignedBytes(in, IS_LITTLE); 
     217    int isSurvey = in.readInt(); 
    216218    metadata.put("Survey performed", isSurvey == 0 ? "true" : "false"); 
    217219 
  • trunk/loci/formats/in/LIFReader.java

    r1147 r1195  
    4141 
    4242  /** Current file. */ 
    43   protected RandomAccessFile in; 
     43  protected RandomAccessStream in; 
    4444 
    4545  /** Flag indicating whether current file is little endian. */ 
     
    100100  public int getSizeX(String id) throws FormatException, IOException { 
    101101    if (!id.equals(currentId)) initFile(id); 
    102      
     102 
    103103    int max = 0; 
    104104    int maxIndex = 0; 
     
    109109      } 
    110110    } 
    111      
     111 
    112112    return dims[maxIndex][0]; 
    113113  } 
     
    124124      } 
    125125    } 
    126      
     126 
    127127    return dims[maxIndex][1]; 
    128128  } 
     
    137137      tSum += dims[i][3]; 
    138138    } 
    139   
    140     if (zSum > tSum) return getImageCount(id);  
     139 
     140    if (zSum > tSum) return getImageCount(id); 
    141141    else return 1; 
    142142  } 
     
    243243  protected void initFile(String id) throws FormatException, IOException { 
    244244    super.initFile(id); 
     245    in = new RandomAccessStream(id); 
    245246    offsets = new Vector(); 
    246     in = new RandomAccessFile(id, "r"); 
    247247 
    248248    littleEndian = true; 
     249    in.order(littleEndian); 
    249250 
    250251    // read the header 
    251252 
    252     byte[] header = new byte[8]; 
    253     in.read(header); 
    254  
    255     if ((header[0] != 0x70) && (header[3] != 0x70)) { 
     253    byte checkOne = (byte) in.read(); 
     254    in.skipBytes(2); 
     255    byte checkTwo = (byte) in.read(); 
     256    if (checkOne != 0x70 && checkTwo != 0x70) { 
    256257      throw new FormatException(id + " is not a valid Leica LIF file"); 
    257258    } 
    258259 
    259     int chunkLength = DataTools.bytesToInt(header, 4, 4, littleEndian); 
     260    int chunkLength = in.readInt(); 
    260261 
    261262    // read and parse the XML description 
    262263 
    263     byte[] xmlChunk = new byte[chunkLength]; 
    264     in.read(xmlChunk); 
    265  
    266     if (xmlChunk[0] != 0x2a) { 
     264    if (in.read() != 0x2a) { 
    267265      throw new FormatException("Invalid XML description"); 
    268266    } 
    269267 
    270268    // number of Unicode characters in the XML block 
    271     int nc = DataTools.bytesToInt(xmlChunk, 1, 4, littleEndian); 
    272     String xml = new String(xmlChunk, 5, nc*2); 
    273     xml = DataTools.stripString(xml); 
     269 
     270    int nc = in.readInt(); 
     271    byte[] s = new byte[nc * 2]; 
     272    in.read(s); 
     273    String xml = DataTools.stripString(new String(s)); 
    274274 
    275275    while (in.getFilePointer() < in.length()) { 
    276       byte[] four = new byte[4]; 
    277       in.read(four); 
    278       int check = DataTools.bytesToInt(four, littleEndian); 
    279       if (check != 0x70) { 
     276      if (in.readInt() != 0x70) { 
    280277        throw new FormatException("Invalid Memory Block"); 
    281278      } 
    282279 
    283       in.read(four); 
    284       int memLength = DataTools.bytesToInt(four, littleEndian); 
    285  
     280      int memLength = in.readInt(); 
    286281      if (in.read() != 0x2a) { 
    287282        throw new FormatException("Invalid Memory Description"); 
    288283      } 
    289284 
    290       in.read(four); 
    291       int blockLength = DataTools.bytesToInt(four, littleEndian); 
    292  
     285      int blockLength = in.readInt(); 
    293286      if (in.read() != 0x2a) { 
    294287        throw new FormatException("Invalid Memory Description"); 
    295288      } 
    296289 
    297       in.read(four); 
    298       int descrLength = DataTools.bytesToInt(four, littleEndian); 
    299  
     290      int descrLength = in.readInt(); 
    300291      byte[] memDescr = new byte[2*descrLength]; 
    301292      in.read(memDescr); 
    302       String descr = new String(memDescr); 
    303       descr = DataTools.stripString(descr); 
     293      String descr = DataTools.stripString(new String(memDescr)); 
    304294 
    305295      if (blockLength > 0) { 
    306296        offsets.add(new Long(in.getFilePointer())); 
    307297      } 
     298 
    308299      in.skipBytes(blockLength); 
    309300    } 
  • trunk/loci/formats/in/LeicaReader.java

    r1134 r1195  
    4848 
    4949  // -- Fields -- 
    50  
    51   /** Current file. */ 
    52   //protected RandomAccessStream in; 
    5350 
    5451  /** Flag indicating whether current file is little endian. */ 
     
    196193      initFile(id); 
    197194    } 
    198     return tiff.openBytes(currentId, no); 
     195    return tiff.openBytes(files[no], no); 
    199196  } 
    200197 
     
    225222    { 
    226223      if (ifds == null) super.initFile(id); 
     224 
    227225      in = new RandomAccessStream(id); 
     226 
     227      if (in.readShort() == 0x4949) { 
     228        in.order(true); 
     229      } 
     230 
     231      in.seek(0); 
    228232      numChannels = 0; 
    229233 
     
    295299        if (currentId != id) currentId = id; 
    296300      } 
     301 
    297302      in = new RandomAccessStream(id); 
    298303 
     
    304309        fourBytes[3] == TiffTools.LITTLE); 
    305310 
     311      in.order(littleEndian); 
     312 
    306313      in.skipBytes(8); 
    307       int addr = (int) DataTools.read4UnsignedBytes(in, littleEndian); 
     314      int addr = in.readInt(); 
    308315      Vector v = new Vector(); 
    309316      while (addr != 0) { 
     
    313320        in.seek(addr); 
    314321 
    315         int numEntries = (int) DataTools.read4UnsignedBytes(in, littleEndian); 
    316         int tag = (int) DataTools.read4UnsignedBytes(in, littleEndian); 
     322        int numEntries = in.readInt(); 
     323        int tag = in.readInt(); 
    317324 
    318325        int numIFDs = 0; 
    319326        while (tag != 0) { 
    320327          // create the IFD structure 
    321           int offset = (int) DataTools.read4UnsignedBytes(in, littleEndian); 
     328          int offset = in.readInt(); 
    322329 
    323330          long pos = in.getFilePointer(); 
    324331          in.seek(offset + 12); 
    325332 
    326           int size = (int) DataTools.read4UnsignedBytes(in, littleEndian); 
     333          int size = in.readInt(); 
    327334          byte[] data = new byte[size]; 
    328335          in.read(data); 
    329336          ifd.put(new Integer(tag), (Object) data); 
    330337          in.seek(pos); 
    331           tag = (int) DataTools.read4UnsignedBytes(in, littleEndian); 
     338          tag = in.readInt(); 
    332339        } 
    333340 
    334         addr = (int) DataTools.read4UnsignedBytes(in, littleEndian); 
     341        addr = in.readInt(); 
    335342      } 
    336343      headerIFDs = new Hashtable[v.size()]; 
     
    661668    MetadataStore store = getMetadataStore(); 
    662669 
     670    if (numChannels == 0) numChannels++; 
     671 
    663672    try { 
    664673      if (isRGB(currentId)) numChannels *= 3; 
  • trunk/loci/formats/in/MetamorphReader.java

    r1138 r1195  
    224224 
    225225      while ((currentcode < 66) && ((in.length() - in.getFilePointer()) > 2)) { 
    226         currentcode = DataTools.read2SignedBytes(in, little); 
     226        currentcode = in.readShort(); 
    227227 
    228228        // variable declarations, because switch is dumb 
     
    233233        switch (currentcode) { 
    234234          case 0: 
    235             String autoscale = DataTools.read4SignedBytes(in, little) == 0 ? 
     235            String autoscale = in.readInt() == 0 ? 
    236236              "no auto-scaling" : "16-bit to 8-bit scaling"; 
    237237            put("AutoScale", autoscale); 
    238238            break; 
    239239          case 1: 
    240             put("MinScale", DataTools.read4SignedBytes(in, little)); 
     240            put("MinScale", in.readInt()); 
    241241            break; 
    242242          case 2: 
    243             put("MaxScale", DataTools.read4SignedBytes(in, little)); 
     243            put("MaxScale", in.readInt()); 
    244244            break; 
    245245          case 3: 
    246             int calib = DataTools.read4SignedBytes(in, little); 
     246            int calib = in.readInt(); 
    247247            String calibration = calib == 0 ? "on" : "off"; 
    248248            put("Spatial Calibration", calibration); 
    249249            break; 
    250250          case 4: 
    251             num = DataTools.read4SignedBytes(in, little); 
    252             denom = DataTools.read4SignedBytes(in, little); 
     251            num = in.readInt(); 
     252            denom = in.readInt(); 
    253253            put("XCalibration", new TiffRational(num, denom)); 
    254254            break; 
    255255          case 5: 
    256             num = DataTools.read4SignedBytes(in, little); 
    257             denom = DataTools.read4SignedBytes(in, little); 
     256            num = in.readInt(); 
     257            denom = in.readInt(); 
    258258            put("YCalibration", new TiffRational(num, denom)); 
    259259            break; 
    260260          case 6: 
    261             num = DataTools.read4SignedBytes(in, little); 
     261            num = in.readInt(); 
    262262            toread = new byte[num]; 
    263263            in.read(toread); 
     
    265265            break; 
    266266          case 7: 
    267             num = DataTools.read4SignedBytes(in, little); 
     267            num = in.readInt(); 
    268268            toread = new byte[num]; 
    269269            in.read(toread); 
     
    273273            break; 
    274274          case 8: 
    275             int thresh = DataTools.read4SignedBytes(in, little); 
     275            int thresh = in.readInt(); 
    276276            String threshState = "off"; 
    277277            if (thresh == 1) threshState = "inside"; 
     
    280280            break; 
    281281          case 9: 
    282             put("ThreshStateRed", DataTools.read4SignedBytes(in, little)); 
     282            put("ThreshStateRed", in.readInt()); 
    283283            break; 
    284284          // there is no 10 
    285285          case 11: 
    286             put("ThreshStateGreen", DataTools.read4SignedBytes(in, little)); 
     286            put("ThreshStateGreen", in.readInt()); 
    287287            break; 
    288288          case 12: 
    289             put("ThreshStateBlue", DataTools.read4SignedBytes(in, little)); 
     289            put("ThreshStateBlue", in.readInt()); 
    290290            break; 
    291291          case 13: 
    292             put("ThreshStateLo", DataTools.read4SignedBytes(in, little)); 
     292            put("ThreshStateLo", in.readInt()); 
    293293            break; 
    294294          case 14: 
    295             put("ThreshStateHi", DataTools.read4SignedBytes(in, little)); 
     295            put("ThreshStateHi", in.readInt()); 
    296296            break; 
    297297          case 15: 
    298             int zoom = DataTools.read4SignedBytes(in, little); 
     298            int zoom = in.readInt(); 
    299299            put("Zoom", zoom); 
    300300//            OMETools.setAttribute(ome, "DisplayOptions", "Zoom", "" + zoom); 
    301301            break; 
    302302          case 16: // oh how we hate you Julian format... 
    303             thedate = decodeDate(DataTools.read4SignedBytes(in, little)); 
    304             thetime = decodeTime(DataTools.read4SignedBytes(in, little)); 
     303            thedate = decodeDate(in.readInt()); 
     304            thetime = decodeTime(in.readInt()); 
    305305            put("DateTime", thedate + " " + thetime); 
    306306            imageCreationDate = thedate + " " + thetime; 
    307307            break; 
    308308          case 17: 
    309             thedate = decodeDate(DataTools.read4SignedBytes(in, little)); 
    310             thetime = decodeTime(DataTools.read4SignedBytes(in, little)); 
     309            thedate = decodeDate(in.readInt()); 
     310            thetime = decodeTime(in.readInt()); 
    311311            put("LastSavedTime", thedate + " " + thetime); 
    312312            break; 
    313313          case 18: 
    314             put("currentBuffer", DataTools.read4SignedBytes(in, little)); 
     314            put("currentBuffer", in.readInt()); 
    315315            break; 
    316316          case 19: 
    317             put("grayFit", DataTools.read4SignedBytes(in, little)); 
     317            put("grayFit", in.readInt()); 
    318318            break; 
    319319          case 20: 
    320             put("grayPointCount", DataTools.read4SignedBytes(in, little)); 
     320            put("grayPointCount", in.readInt()); 
    321321            break; 
    322322          case 21: 
    323             num = DataTools.read4SignedBytes(in, little); 
    324             denom = DataTools.read4SignedBytes(in, little); 
     323            num = in.readInt(); 
     324            denom = in.readInt(); 
    325325            put("grayX", new TiffRational(num, denom)); 
    326326            break; 
    327327          case 22: 
    328             num = DataTools.read4SignedBytes(in, little); 
    329             denom = DataTools.read4SignedBytes(in, little); 
     328            num = in.readInt(); 
     329            denom = in.readInt(); 
    330330            put("gray", new TiffRational(num, denom)); 
    331331            break; 
    332332          case 23: 
    333             num = DataTools.read4SignedBytes(in, little); 
    334             denom = DataTools.read4SignedBytes(in, little); 
     333            num = in.readInt(); 
     334            denom = in.readInt(); 
    335335            put("grayMin", new TiffRational(num, denom)); 
    336336            break; 
    337337          case 24: 
    338             num = DataTools.read4SignedBytes(in, little); 
    339             denom = DataTools.read4SignedBytes(in, little); 
     338            num = in.readInt(); 
     339            denom = in.readInt(); 
    340340            put("grayMax", new TiffRational(num, denom)); 
    341341            break; 
    342342          case 25: 
    343             num = DataTools.read4SignedBytes(in, little); 
     343            num = in.readInt(); 
    344344            toread = new byte[num]; 
    345345            in.read(toread); 
     
    347347            break; 
    348348          case 26: 
    349             int standardLUT = DataTools.read4SignedBytes(in, little); 
     349            int standardLUT = in.readInt(); 
    350350            String standLUT; 
    351351            switch (standardLUT) { 
     
    361361            break; 
    362362          case 27: 
    363             put("Wavelength", DataTools.read4SignedBytes(in, little)); 
     363            put("Wavelength", in.readInt()); 
    364364            break; 
    365365          case 28: 
    366366            for (int i = 0; i < planes; i++) { 
    367                 xnum = DataTools.read4SignedBytes(in, little); 
    368                 xdenom = DataTools.read4SignedBytes(in, little); 
    369                 ynum = DataTools.read4SignedBytes(in, little); 
    370                 ydenom = DataTools.read4SignedBytes(in, little); 
     367                xnum = in.readInt(); 
     368                xdenom = in.readInt(); 
     369                ynum = in.readInt(); 
     370                ydenom = in.readInt(); 
    371371                xpos = xnum / xdenom; 
    372372                ypos = ynum / ydenom; 
     
    377377          case 29: 
    378378            for (int i = 0; i < planes; i++) { 
    379               xnum = DataTools.read4SignedBytes(in, little); 
    380               xdenom = DataTools.read4SignedBytes(in, little); 
    381               ynum = DataTools.read4SignedBytes(in, little); 
    382               ydenom = DataTools.read4SignedBytes(in, little); 
     379              xnum = in.readInt(); 
     380              xdenom = in.readInt(); 
     381              ynum = in.readInt(); 
     382              ydenom = in.readInt(); 
    383383              xpos = xnum / xdenom; 
    384384              ypos = ynum / ydenom; 
     
    388388            break; 
    389389          case 30: 
    390             put("OverlayMask", DataTools.read4SignedBytes(in, little)); 
     390            put("OverlayMask", in.readInt()); 
    391391            break; 
    392392          case 31: 
    393             put("OverlayCompress", DataTools.read4SignedBytes(in, little)); 
     393            put("OverlayCompress", in.readInt()); 
    394394            break; 
    395395          case 32: 
    396             put("Overlay", DataTools.read4SignedBytes(in, little)); 
     396            put("Overlay", in.readInt()); 
    397397            break; 
    398398          case 33: 
    399             put("SpecialOverlayMask", DataTools.read4SignedBytes(in, little)); 
     399            put("SpecialOverlayMask", in.readInt()); 
    400400            break; 
    401401          case 34: 
    402             put("SpecialOverlayCompress", 
    403               DataTools.read4SignedBytes(in, little)); 
     402            put("SpecialOverlayCompress", in.readInt()); 
    404403            break; 
    405404          case 35: 
    406             put("SpecialOverlay", DataTools.read4SignedBytes(in, little)); 
     405            put("SpecialOverlay", in.readInt()); 
    407406            break; 
    408407          case 36: 
    409             put("ImageProperty", DataTools.read4SignedBytes(in, little)); 
     408            put("ImageProperty", in.readInt()); 
    410409            break; 
    411410          case 37: 
    412411            for (int i = 0; i<planes; i++) { 
    413               num = DataTools.read4SignedBytes(in, little); 
     412              num = in.readInt(); 
    414413              toread = new byte[num]; 
    415414              in.read(toread); 
     
    419418            break; 
    420419          case 38: 
    421             num = DataTools.read4SignedBytes(in, little); 
    422             denom = DataTools.read4SignedBytes(in, little); 
     420            num = in.readInt(); 
     421            denom = in.readInt(); 
    423422            put("AutoScaleLoInfo", new TiffRational(num, denom)); 
    424423            break; 
    425424          case 39: 
    426             num = DataTools.read4SignedBytes(in, little); 
    427             denom = DataTools.read4SignedBytes(in, little); 
     425            num = in.readInt(); 
     426            denom = in.readInt(); 
    428427            put("AutoScaleHiInfo", new TiffRational(num, denom)); 
    429428            break; 
    430429          case 40: 
    431430            for (int i=0;i<planes;i++) { 
    432               num = DataTools.read4SignedBytes(in, little); 
    433               denom = DataTools.read4SignedBytes(in, little); 
     431              num = in.readInt(); 
     432              denom = in.readInt(); 
    434433              put("AbsoluteZ Plane " + i, new TiffRational(num, denom)); 
    435434            } 
     
    437436          case 41: 
    438437            for (int i=0; i<planes; i++) { 
    439               put("AbsoluteZValid Plane " + i, 
    440                 DataTools.read4SignedBytes(in, little)); 
     438              put("AbsoluteZValid Plane " + i, in.readInt()); 
    441439            } 
    442440            break; 
    443441          case 42: 
    444             put("Gamma", DataTools.read4SignedBytes(in, little)); 
     442            put("Gamma", in.readInt()); 
    445443            break; 
    446444          case 43: 
    447             put("GammaRed", DataTools.read4SignedBytes(in, little)); 
     445            put("GammaRed", in.readInt()); 
    448446            break; 
    449447          case 44: 
    450             put("GammaGreen", DataTools.read4SignedBytes(in, little)); 
     448            put("GammaGreen", in.readInt()); 
    451449            break; 
    452450          case 45: 
    453             put("GammaBlue", DataTools.read4SignedBytes(in, little)); 
     451            put("GammaBlue", in.readInt()); 
    454452            break; 
    455453        } // end switch 
     
    457455    } 
    458456    catch (NullPointerException n) { n.printStackTrace(); } 
    459     catch (IOException e) { e.printStackTrace(); } 
     457    catch (IOException io) { io.printStackTrace(); } 
    460458    catch (FormatException e) { e.printStackTrace(); } 
    461459 
  • trunk/loci/formats/in/NikonReader.java

    r1124 r1195  
    232232      } 
    233233    } 
    234     catch (IOException io) { } 
     234    catch (Exception io) { } 
    235235  } 
    236236 
  • trunk/loci/formats/in/OIBReader.java

    r1134 r1195  
    143143    byte[] pixels = (byte[]) pixelData.get(new Integer(no)); 
    144144    RandomAccessStream ra = new RandomAccessStream(pixels); 
     145    ra.order(true); 
    145146 
    146147    Hashtable[] fds = TiffTools.getIFDs(ra, 0); 
    147     BufferedImage img = TiffTools.getImage(fds[0], ra); 
    148     ra.close(); 
    149     return img; 
     148    return TiffTools.getImage(fds[0], ra); 
    150149  } 
    151150 
     
    180179            // get the width and height 
    181180            RandomAccessStream ras = new RandomAccessStream(data); 
     181            ras.order(true); 
    182182            Hashtable[] ifds = TiffTools.getIFDs(ras); 
    183183            width = TiffTools.getIFDIntValue(ifds[0], TiffTools.IMAGE_WIDTH, 
     
    191191          else { 
    192192            RandomAccessStream ra = new RandomAccessStream(data); 
     193            ra.order(true); 
    193194            try { 
    194195              Hashtable[] ifds = TiffTools.getIFDs(ra); 
     
    202203            } 
    203204            catch (IOException e) { } 
     205            catch (IllegalArgumentException e) { } 
    204206            ra.close(); 
    205207            ra = null; 
     
    227229 
    228230    TiffReader btr = new TiffReader(); 
    229     Hashtable[] tiffIFDs = TiffTools.getIFDs(new RandomAccessStream( 
    230       (byte[]) pixelData.get(new Integer(0)))); 
     231    RandomAccessStream b = 
     232      new RandomAccessStream((byte[]) pixelData.get(new Integer(0))); 
     233    b.order(true); 
     234    Hashtable[] tiffIFDs = TiffTools.getIFDs(b); 
    231235 
    232236    btr.ifds = tiffIFDs; 
    233237    btr.setInitialSizeZ(numImages); 
    234     btr.in = new RandomAccessStream((byte[]) pixelData.get(new Integer(0))); 
     238 
    235239    try { 
    236240      btr.initFile(id); 
  • trunk/loci/formats/in/OLEParser.java

    r1142 r1195  
    327327 
    328328        String name = sb.toString(); 
    329  
    330329        if (name.trim().equals("")) return; 
    331330 
  • trunk/loci/formats/in/OMEXMLReader.java

    r1185 r1195  
    7777  private String order; 
    7878 
    79   /**  
     79  /** 
    8080   * Internal OME-XML metadata store that we use for parsing metadata from the 
    8181   * OME-XML file itself. 
  • trunk/loci/formats/in/OpenlabRawReader.java

    r1134 r1195  
    185185    // read the 12 byte file header 
    186186 
    187     byte[] header = new byte[12]; 
     187    byte[] header = new byte[4]; 
    188188    in.read(header); 
    189     if (header[0] != 'O' || header[1] != 'L' || 
    190       header[2] != 'R' || header[3] != 'W') 
    191     { 
     189    String check = new String(header); 
     190    if (!check.equals("OLRW")) { 
    192191      throw new FormatException("Openlab RAW magic string not found."); 
    193192    } 
    194193 
    195     int version = DataTools.bytesToInt(header, 4, 4, false); 
     194    int version = in.readInt(); 
    196195    metadata.put("Version", new Integer(version)); 
    197196 
    198     numImages = DataTools.bytesToInt(header, 8, 4, false); 
     197    numImages = in.readInt(); 
    199198    offsets = new int[numImages]; 
    200199    offsets[0] = 12; 
    201200 
    202     in.skipBytes(8); 
    203     width = DataTools.read4SignedBytes(in, false); 
    204     height = DataTools.read4SignedBytes(in, false); 
    205     in.skipBytes(2); 
    206     bpp = DataTools.readUnsignedByte(in); 
    207     channels = DataTools.readUnsignedByte(in); 
     201    in.readLong(); 
     202    width = in.readInt(); 
     203    height = in.readInt(); 
     204    in.readShort(); 
     205    bpp = in.read(); 
     206    channels = in.read(); 
     207 
    208208    if (channels <= 1) channels = 1; 
    209209    else channels = 3; 
  • trunk/loci/formats/in/OpenlabReader.java

    r1144 r1195  
    190190    in.seek(offsets[no] + 12); 
    191191 
    192     byte[] toRead = new byte[4]; 
    193     in.read(toRead); 
    194     int blockSize = batoi(toRead); 
    195     toRead = new byte[1]; 
    196     in.read(toRead); 
     192    int blockSize = in.readInt(); 
     193 
     194    byte toRead = (byte) in.read(); 
     195 
    197196    // right now I'm gonna skip all the header info 
    198197    // check to see whether or not this is v2 data 
    199     if (toRead[0] == 1) in.skipBytes(128); 
     198    if (toRead == 1) in.skipBytes(128); 
    200199    in.skipBytes(169); 
    201200    // read in the block of data 
    202     toRead = new byte[blockSize]; 
    203     int read = 0; 
    204     int left = blockSize; 
    205     while (left > 0) { 
    206       int i = in.read(toRead, read, left); 
    207       read += i; 
    208       left -= i; 
    209     } 
     201    byte[] b = new byte[blockSize]; 
     202    in.read(b); 
    210203    byte[] pixelData = new byte[blockSize]; 
    211204    int pixPos = 0; 
    212205 
    213206    Dimension dim; 
    214     try { dim = pictReader.getDimensions(toRead); } 
     207    try { dim = pictReader.getDimensions(b); } 
    215208    catch (Exception e) { dim = new Dimension(0, 0); } 
    216209 
    217     int length = toRead.length; 
     210    int length = b.length; 
    218211    int num, size, blockEnd; 
    219212    int totalBlocks = -1; // set to allow loop to start. 
     
    240233 
    241234      while (pos + 7 < length && 
    242         (toRead[pos] != 73 || toRead[pos + 1] != 86 || 
    243         toRead[pos + 2] != 69 || toRead[pos + 3] != 65 || 
    244         toRead[pos + 4] != 100 || toRead[pos + 5] != 98 || 
    245         toRead[pos + 6] != 112 || toRead[pos + 7] != 113)) 
     235        (b[pos] != 73 || b[pos + 1] != 86 || b[pos + 2] != 69 || 
     236        b[pos + 3] != 65 || b[pos + 4] != 100 || b[pos + 5] != 98 || 
     237        b[pos + 6] != 112 || b[pos + 7] != 113)) 
    246238      { 
    247239        pos++; 
     
    253245          // to be a pict... *crosses fingers* 
    254246          try { 
    255             if (!isRGB(id) || !separated) { 
    256               return pictReader.open(toRead); 
     247            if (!separated) { 
     248              return pictReader.open(b); 
    257249            } 
    258250            else { 
    259               return ImageTools.splitChannels(pictReader.open(toRead))[no%3]; 
     251              return ImageTools.splitChannels(pictReader.open(b))[no%3]; 
    260252            } 
    261253          } 
     
    274266      // Read info from the iPic comment. This serves as a 
    275267      // starting point to read the rest. 
    276       temp = new byte[] { 
    277         toRead[pos], toRead[pos+1], toRead[pos+2], toRead[pos+3] 
    278       }; 
     268      temp = new byte[] { b[pos], b[pos+1], b[pos+2], b[pos+3] }; 
    279269      num = batoi(temp); 
    280270      if (num != expectedBlock) { 
     
    282272      } 
    283273      expectedBlock++; 
    284       temp = new byte[] { 
    285         toRead[pos+4], toRead[pos+5], toRead[pos+6], toRead[pos+7] 
    286       }; 
     274      temp = new byte[] { b[pos+4], b[pos+5], b[pos+6], b[pos+7] }; 
    287275      if (totalBlocks == -1) { 
    288276        totalBlocks = batoi(temp); 
     
    296284      // skip to size 
    297285      pos += 16; 
    298       temp = new byte[] { 
    299         toRead[pos], toRead[pos+1], toRead[pos+2], toRead[pos+3] 
    300       }; 
     286      temp = new byte[] { b[pos], b[pos+1], b[pos+2], b[pos+3] }; 
    301287      size = batoi(temp); 
    302288      pos += 8; 
     
    304290 
    305291      // copy into our data array. 
    306       System.arraycopy(toRead, pos, pixelData, pixPos, size); 
     292      System.arraycopy(b, pos, pixelData, pixPos, size); 
    307293      pixPos += size; 
    308294    } 
     
    347333    // images 
    348334 
    349     byte[] toRead = new byte[4]; 
    350     in.read(toRead); 
    351     long order = batoi(toRead);  // byte ordering 
    352     little = toRead[2] != 0xff || toRead[3] != 0xff; 
    353  
    354     //toRead = new byte[4]; 
     335    long order = in.readInt(); 
     336    little = order == 0x0000ffff; 
     337    //in.order(little); 
     338 
    355339    Vector v = new Vector(); // a temp vector containing offsets. 
    356340 
    357341    // Get first offset. 
    358     //in.seek(16); 
     342 
    359343    in.skipBytes(12); 
    360     in.read(toRead); 
    361     int nextOffset = batoi(toRead); 
     344    int nextOffset = in.readInt(); 
    362345    int nextOffsetTemp; 
    363346 
    364347    boolean first = true; 
    365     while(nextOffset != 0) { 
     348    while(nextOffset != 0 && nextOffset < in.length()) { 
     349      // get next tag, but still need this one 
     350 
    366351      in.seek(nextOffset + 4); 
    367       in.read(toRead); 
    368       // get next tag, but still need this one 
    369       nextOffsetTemp = batoi(toRead); 
     352      nextOffsetTemp = in.readInt(); 
     353 
     354      byte[] toRead = new byte[4]; 
    370355      in.read(toRead); 
    371356      if ((new String(toRead)).equals("PICT")) { 
     
    400385 
    401386    // populate the imageTypes that the file uses 
    402     toRead = new byte[2]; 
    403387    imageType = new int[numBlocks]; 
    404388    for (int i = 0; i < numBlocks; i++) { 
    405       in.seek(offsets[i]); 
    406       in.skipBytes(40); 
    407       in.read(toRead); 
    408       imageType[i] = batoi(toRead); 
     389      in.seek(offsets[i] + 40); 
     390      imageType[i] = in.readShort(); 
    409391    } 
    410392 
     
    417399  /** Populates the metadata hashtable. */ 
    418400  private void initMetadata() throws FormatException, IOException { 
    419     in.seek(0); 
     401    in.seek(8); 
     402 
     403    in.order(false); 
    420404 
    421405    // start by reading the file header 
    422     byte[] toRead = new byte[4]; 
    423     in.read(toRead); 
    424     long order = batoi(toRead);  // byte ordering 
    425     little = toRead[2] != 0xff || toRead[3] != 0xff; 
    426406    metadata.put("Byte Order", new Boolean(little)); 
    427407 
    428     in.skipBytes(4); 
    429     in.read(toRead); 
    430     long version = DataTools.bytesToLong(toRead, false); 
     408    long version = in.readInt(); 
    431409    metadata.put("Version", new Long(version)); 
    432410 
    433     byte[] er = new byte[2]; 
    434     in.read(er); 
    435     short count = DataTools.bytesToShort(er, false); 
     411    short count = in.readShort(); 
    436412    metadata.put("Count", new Short(count)); 
    437413 
    438     in.skipBytes(2); 
    439  
    440     in.read(toRead); 
    441     long offset = DataTools.bytesToLong(toRead, false); 
     414    in.readShort(); 
     415 
     416    int offset = in.readInt(); 
    442417 
    443418    // skip to first tag 
     
    447422 
    448423    for (int i=0; i<count; i++) { 
    449       in.read(er); 
    450       short tag = DataTools.bytesToShort(er, false); 
    451       in.skipBytes(2); 
    452  
    453       in.read(toRead); 
    454       offset = DataTools.bytesToLong(toRead, false); 
    455  
    456       in.read(toRead); 
    457       long fmt = DataTools.bytesToLong(toRead, false); 
     424      short tag = in.readShort(); 
     425      in.readShort(); 
     426 
     427      offset = in.readInt(); 
     428      long fmt = in.readInt(); 
    458429      metadata.put("Format", new Long(fmt)); 
    459430 
    460       in.read(toRead); 
    461       long numBytes = DataTools.bytesToLong(toRead, false); 
     431      long numBytes = in.readInt(); 
    462432      metadata.put("NumBytes", new Long(numBytes)); 
    463433 
    464434      if (tag == 67 || tag == 68) { 
    465         byte[] b = new byte[1]; 
    466         in.read(b); 
    467         boolean isOpenlab2; 
    468         if (b[0] == '0') isOpenlab2 = false; 
    469         else isOpenlab2 = true; 
     435        boolean isOpenlab2 = in.read() == 0; 
    470436        metadata.put("isOpenlab2", new Boolean(isOpenlab2)); 
    471437 
    472         in.skipBytes(2); 
    473         in.read(er); 
    474         short layerId = DataTools.bytesToShort(er, false); 
     438        in.readShort(); 
     439        short layerId = in.readShort(); 
    475440        metadata.put("LayerID", new Short(layerId)); 
    476441 
    477         in.read(er); 
    478         short layerType = DataTools.bytesToShort(er, false); 
     442        short layerType = in.readShort(); 
    479443        metadata.put("LayerType", new Short(layerType)); 
    480444 
    481         in.read(er); 
    482         short bitDepth = DataTools.bytesToShort(er, false); 
     445        short bitDepth = in.readShort(); 
    483446        metadata.put("BitDepth", new Short(bitDepth)); 
    484447 
    485         in.read(er); 
    486         short opacity = DataTools.bytesToShort(er, false); 
     448        short opacity = in.readShort(); 
    487449        metadata.put("Opacity", new Short(opacity)); 
    488450 
     
    490452        in.skipBytes(10); 
    491453 
    492         in.read(toRead); 
    493         long type = DataTools.bytesToLong(toRead, false); 
     454        long type = in.readInt(); 
    494455        metadata.put("ImageType", new Long(type)); 
    495456 
     
    497458        in.skipBytes(10); 
    498459 
    499         in.read(toRead); 
    500         long timestamp = DataTools.bytesToLong(toRead, false); 
     460        long timestamp = in.readInt(); 
    501461        metadata.put("Timestamp", new Long(timestamp)); 
    502462 
     
    508468          metadata.put("LayerName", new String(layerName)); 
    509469 
    510           in.read(toRead); 
    511           long timestampMS = DataTools.bytesToLong(toRead, false); 
     470          long timestampMS = in.readInt(); 
    512471          metadata.put("Timestamp-MS", new Long(timestampMS)); 
    513472 
    514           in.skipBytes(1); 
     473          in.read(); 
    515474          byte[] notes = new byte[118]; 
    516475          in.read(notes); 
     
    520479      } 
    521480      else if (tag == 69) { 
    522         in.read(toRead); 
    523         long platform = DataTools.bytesToLong(toRead, false); 
     481        long platform = in.readInt(); 
    524482        metadata.put("Platform", new Long(platform)); 
    525483 
    526         in.read(er); 
    527         short units = DataTools.bytesToShort(er, false); 
     484        short units = in.readShort(); 
    528485        metadata.put("Units", new Short(units)); 
    529486 
    530         in.read(er); 
    531         short imageId = DataTools.bytesToShort(er, false); 
     487        short imageId = in.readShort(); 
    532488        metadata.put("ID", new Short(imageId)); 
    533         in.skipBytes(1); 
    534  
    535         byte[] toRead2 = new byte[8]; 
    536         double xOrigin = DataTools.readDouble(in, false); 
     489        in.read(); 
     490 
     491        double xOrigin = in.readDouble(); 
    537492        metadata.put("XOrigin", new Double(xOrigin)); 
    538         double yOrigin = DataTools.readDouble(in, false); 
     493        double yOrigin = in.readDouble(); 
    539494        metadata.put("YOrigin", new Double(yOrigin)); 
    540         double xScale = DataTools.readDouble(in, false); 
     495        double xScale = in.readDouble(); 
    541496        metadata.put("XScale", new Double(xScale)); 
    542         double yScale = DataTools.readDouble(in, false); 
     497        double yScale = in.readDouble(); 
    543498        metadata.put("YScale", new Double(yScale)); 
    544         in.skipBytes(1); 
     499        in.read(); 
    545500 
    546501        byte[] other = new byte[31]; 
     
    608563   */ 
    609564  private int checkType() throws FormatException, IOException { 
     565    if (firstPlane == null) firstPlane = openImage(currentId, 0); 
    610566    WritableRaster r = firstPlane.getRaster(); 
    611567    int b = r.getNumBands(); 
     
    616572    in.seek(offsets[3] + 12); 
    617573 
    618     byte[] toRead = new byte[4]; 
    619     in.read(toRead); 
    620     int blockSize = batoi(toRead); 
    621     toRead = new byte[1]; 
    622     in.read(toRead); 
     574    int blockSize = in.readInt(); 
     575 
    623576    // right now I'm gonna skip all the header info 
    624577    // check to see whether or not this is v2 data 
    625     if (toRead[0] == 1) in.skipBytes(128); 
     578    if (in.read() == 1) in.skipBytes(128); 
    626579    in.skipBytes(169); 
    627580    // read in the block of data 
    628     toRead = new byte[blockSize]; 
    629     int read = 0; 
    630     int left = blockSize; 
    631     while (left > 0) { 
    632       int i = in.read(toRead, read, left); 
    633       read += i; 
    634       left -= i; 
    635     } 
     581    byte[] toRead = new byte[blockSize]; 
     582    in.read(toRead); 
    636583    byte[] pixelData = new byte[blockSize]; 
    637584    int pixPos = 0; 
  • trunk/loci/formats/in/PerkinElmerReader.java

    r1134 r1195  
    9595      initFile(id); 
    9696    } 
    97     return Integer.parseInt((String) metadata.get("Image Height")); 
     97    return Integer.parseInt((String) metadata.get("Image Length")); 
    9898  } 
    9999 
  • trunk/loci/formats/in/PictReader.java

    r1134 r1195  
    223223    super.initFile(id); 
    224224    in = new RandomAccessStream(id); 
     225 
    225226    little = false; 
    226227 
     
    228229    int len = (int) (in.length() - 512); 
    229230    bytes = new byte[len]; 
    230     in.skipBytes(512); 
     231    in.seek(512); 
    231232    in.read(bytes); 
    232233 
  • trunk/loci/formats/in/QTReader.java

    r1190 r1195  
    2626 
    2727import java.awt.image.BufferedImage; 
    28 import java.awt.image.WritableRaster; 
    2928import java.io.*; 
    3029import java.util.Vector; 
     
    186185  private int numImages; 
    187186 
    188   /** Pixel data stored in "mdat" atom. */ 
    189   private byte[] pixels; 
     187  /** Offset to start of pixel data. */ 
     188  private int pixelOffset; 
     189 
     190  /** Total number of bytes of pixel data. */ 
     191  private int pixelBytes; 
    190192 
    191193  /** Width of a single plane. */ 
     
    328330 
    329331    int offset = ((Integer) offsets.get(no / c)).intValue(); 
    330     int nextOffset = pixels.length; 
     332    int nextOffset = pixelBytes; 
    331333 
    332334    if (no == 0) { 
     
    349351    byte[] pixs = new byte[nextOffset - offset]; 
    350352 
    351     for (int i=0; i<pixs.length; i++) { 
    352       if ((offset + i) < pixels.length) { 
    353         pixs[i] = pixels[offset + i]; 
    354       } 
    355     } 
     353    in.seek(pixelOffset + offset); 
     354    in.read(pixs); 
    356355 
    357356    if (codec.equals("jpeg") || codec.equals("mjpb")) { 
     
    447446 
    448447    int offset = ((Integer) offsets.get(no / c)).intValue(); 
    449     int nextOffset = pixels.length; 
     448    int nextOffset = pixelBytes; 
    450449 
    451450    if ((no / c) == 0) { 
     
    468467    byte[] pixs = new byte[nextOffset - offset]; 
    469468 
    470     for (int i=0; i<pixs.length; i++) { 
    471       if ((offset + i) < pixels.length) { 
    472         pixs[i] = pixels[offset + i]; 
    473       } 
    474     } 
     469    in.seek(pixelOffset + offset); 
     470    in.read(pixs); 
    475471 
    476472    if (codec.equals("jpeg")) { 
     
    509505    super.initFile(id); 
    510506    in = new RandomAccessFile(id, "r"); 
     507    //in.order(little); 
     508 
    511509    spork = true; 
    512510    offsets = new Vector(); 
     
    532530      new Integer(1), 
    533531      pixelType, 
    534       new Boolean(little), 
     532      new Boolean(!little), 
    535533      "XYCZT", 
    536534      null); 
     
    553551      if (f.exists()) { 
    554552        in = new RandomAccessFile(f.getAbsolutePath(), "r"); 
     553 
    555554        stripHeader(); 
    556         parse(0, in.getFilePointer(), in.length()); 
     555        parse(0, 0, in.length()); 
    557556        numImages = offsets.size(); 
    558557        return; 
     
    564563          in = new RandomAccessFile(f.getAbsolutePath(), "r"); 
    565564          stripHeader(); 
    566           parse(0, in.getFilePointer(), in.length()); 
     565          parse(0, 0, in.length()); 
    567566          numImages = offsets.size(); 
    568567          return; 
     
    573572            in = new RandomAccessFile(f.getAbsolutePath(), "r"); 
    574573            stripHeader(); 
    575             parse(0, in.getFilePointer(), in.length()); 
     574            parse(0, 0, in.length()); 
    576575            numImages = offsets.size(); 
    577576            return; 
     
    638637 
    639638      // first 4 bytes are the atom size 
    640       long atomSize = DataTools.read4UnsignedBytes(in, little); 
     639      long atomSize = in.readInt(); 
     640      if (atomSize < 0) atomSize += 4294967296L; 
    641641 
    642642      // read the atom type 
     
    647647      // if atomSize is 1, then there is an 8 byte extended size 
    648648      if (atomSize == 1) { 
    649         atomSize = DataTools.read8SignedBytes(in, little); 
     649        atomSize = in.readLong(); 
    650650      } 
    651651 
     
    662662      else { 
    663663        if (atomSize == 0) atomSize = in.length(); 
    664         data = new byte[(int) atomSize]; 
    665         in.read(data); 
     664        int oldpos = (int) in.getFilePointer(); 
    666665 
    667666        if (atomType.equals("mdat")) { 
    668667          // we've found the pixel data 
    669           pixels = data; 
     668          pixelOffset = (int) in.getFilePointer(); 
     669          pixelBytes = (int) atomSize; 
     670 
     671          if (pixelBytes > (in.length() - pixelOffset)) { 
     672            pixelBytes = (int) (in.length() - pixelOffset); 
     673          } 
    670674        } 
    671675        else if (atomType.equals("tkhd")) { 
    672676          // we've found the dimensions 
    673677 
    674           int off = 74; 
    675           width = DataTools.bytesToInt(data, off, little); 
    676           off += 4; 
    677           height = DataTools.bytesToInt(data, off, little); 
     678          in.skipBytes(74); 
     679          width = in.readInt(); 
     680          height = in.readInt(); 
    678681        } 
    679682        else if (atomType.equals("stco")) { 
     
    681684 
    682685          spork = false; 
    683           int numPlanes = DataTools.bytesToInt(data, 4, little); 
     686          in.readInt(); 
     687          int numPlanes = in.readInt(); 
    684688          if (numPlanes != numImages) { 
    685             int off = DataTools.bytesToInt(data, 4, little); 
     689            in.seek(in.getFilePointer() - 4); 
     690            int off = in.readInt(); 
    686691            offsets.add(new Integer(off)); 
    687692            for (int i=1; i<numImages; i++) { 
     
    695700          } 
    696701          else { 
    697             int j = 8; 
    698702            for (int i=0; i<numPlanes; i++) { 
    699               offsets.add(new Integer(DataTools.bytesToInt(data, j, little))); 
    700               j += 4; 
     703              offsets.add(new Integer(in.readInt())); 
    701704            } 
    702705          } 
     
    704707        else if (atomType.equals("stsd")) { 
    705708          // found video codec and pixel depth information 
    706           codec = new String(data, 12, 4); 
    707  
    708           int fieldsPerPlane = DataTools.bytesToInt(data, 102, 1, little); 
     709 
     710          in.readDouble(); 
     711          in.readInt(); 
     712          byte[] b = new byte[4]; 
     713          in.read(b); 
     714          codec = new String(b); 
     715 
     716          in.skipBytes(74); 
     717 
     718          bitsPerPixel = in.readShort(); 
     719          in.readShort(); 
     720          in.readDouble(); 
     721          int fieldsPerPlane = in.read(); 
    709722          interlaced = fieldsPerPlane == 2; 
    710           bitsPerPixel = DataTools.bytesToInt(data, 90, 2, little); 
    711723          metadata.put("Codec", codec); 
    712724          metadata.put("Bits per pixel", new Integer(bitsPerPixel)); 
     
    714726        else if (atomType.equals("stsz")) { 
    715727          // found the number of planes 
    716           rawSize = DataTools.bytesToInt(data, 4, 4, little); 
    717           numImages = DataTools.bytesToInt(data, 8, 4, little); 
     728          in.readInt(); 
     729          rawSize = in.readInt(); 
     730          numImages = in.readInt(); 
    718731 
    719732          if (rawSize == 0) { 
     733            in.seek(in.getFilePointer() - 4); 
    720734            for (int b=0; b<numImages; b++) { 
    721               chunkSizes.add(new Integer(DataTools.bytesToInt( 
    722                 data, 8+b*4, 4, little))); 
     735              chunkSizes.add(new Integer(in.readInt())); 
    723736            } 
    724737          } 
    725738        } 
    726739        else if (atomType.equals("stts")) { 
    727           int fps = DataTools.bytesToInt(data, 12, 4, little); 
     740          in.readDouble(); 
     741          in.readInt(); 
     742          int fps = in.readInt(); 
    728743          metadata.put("Frames per second", new Integer(fps)); 
    729744        } 
     745        if (oldpos + atomSize < in.length()) { 
     746          in.seek(oldpos + atomSize); 
     747        } 
     748        else break; 
    730749      } 
    731750 
     
    10811100      v2.add((byte) 0xd9); 
    10821101 
    1083       // this takes less time than it used to, but may not be the 
    1084       // most intelligent way of doing things 
    1085  
    10861102      BufferedImage top = bufferedJPEG(v.toByteArray()); 
    10871103      BufferedImage bottom = bufferedJPEG(v2.toByteArray()); 
    10881104 
    1089       byte[][] scanlines = 
    1090         new byte[(bitsPerPixel >= 40) ? 1 : 3][width * height]; 
    1091  
    1092       WritableRaster topRaster = top.getWritableTile(0, 0); 
    1093       WritableRaster bottomRaster = bottom.getWritableTile(0, 0); 
    1094  
    1095       byte[] topPixs = (byte[]) topRaster.getDataElements(0, 0, top.getWidth(), 
    1096         top.getHeight(), null); 
    1097       byte[] bottomPixs = (byte[]) bottomRaster.getDataElements(0, 0, 
    1098         bottom.getWidth(), bottom.getHeight(), null); 
    1099       top.releaseWritableTile(0, 0); 
    1100       bottom.releaseWritableTile(0, 0); 
    1101  
    1102       int topLine = 0; 
    1103       int bottomLine = 0; 
    1104  
    1105       if (bitsPerPixel >= 40) { 
    1106         for (int i=0; i<height; i++) { 
    1107           if (i % 2 == 0) { 
    1108             System.arraycopy(topPixs, topLine*width, scanlines[0], 
    1109               width*i, width); 
    1110             topLine++; 
     1105      BufferedImage result = new BufferedImage(top.getWidth(), 
     1106        top.getHeight() + bottom.getHeight(), top.getType()); 
     1107 
     1108      int topCount = 0; 
     1109      int bottomCount = 0; 
     1110 
     1111      for (int i=0; i<result.getHeight(); i++) { 
     1112        if (i % 2 == 0) { 
     1113          for (int j=0; j<result.getWidth(); j++) { 
     1114            result.setRGB(j, i, top.getRGB(j, topCount)); 
    11111115          } 
    1112           else { 
    1113             System.arraycopy(bottomPixs, bottomLine*width, scanlines[0], 
    1114               width*i, width); 
    1115             bottomLine++; 
     1116          topCount++; 
     1117        } 
     1118        else { 
     1119          for (int j=0; j<result.getWidth(); j++) { 
     1120            result.setRGB(j, i, bottom.getRGB(j, bottomCount)); 
    11161121          } 
    1117         } 
    1118       } 
    1119       else { 
    1120         for (int i=0; i<height; i++) { 
    1121           if ((i % 2) == 0) { 
    1122             for (int j=0; j<3*width; j++) { 
    1123               scanlines[j % 3][(width * i) + (j / 3)] = 
    1124                 topPixs[topLine*width*3 + j]; 
    1125             } 
    1126             topLine++; 
    1127           } 
    1128           else { 
    1129             for (int j=0; j<3*width; j++) { 
    1130               scanlines[j % 3][(width * i) + (j / 3)] = 
    1131                 topPixs[bottomLine*width*3 + j]; 
    1132             } 
    1133             bottomLine++; 
    1134           } 
    1135         } 
    1136       } 
    1137  
    1138       return ImageTools.makeImage(scanlines, width, height); 
     1122          bottomCount++; 
     1123        } 
     1124      } 
     1125 
     1126      return result; 
    11391127    } 
    11401128    else { 
  • trunk/loci/formats/in/SDTReader.java

    r1134 r1195  
    144144      for (int x=0; x<width; x++) { 
    145145        int ndx = width * y + x; 
    146         byte[] pix = new byte[2 * TIME_BINS]; 
    147         in.readFully(pix); 
    148146        int sum = 0; 
    149147        for (int decay=0; decay<TIME_BINS; decay++) { 
    150           sum += DataTools.bytesToInt(pix, 2 * decay, 2, true); 
     148          sum += in.readShort(); 
    151149        } 
    152150        data[ndx] = (short) sum; 
     
    181179  protected void initFile(String id) throws FormatException, IOException { 
    182180    super.initFile(id); 
    183     File file = new File(id); 
    184181    in = new RandomAccessStream(id); 
     182    in.order(true); 
    185183 
    186184    // skip 14 byte header 
    187     in.seek(14); 
     185    in.skipBytes(14); 
    188186 
    189187    // read offset 
    190     offset = DataTools.read2UnsignedBytes(in, true) + 22; 
     188    offset = in.readShort() + 22; 
    191189 
    192190    // skip to data 
     
    194192 
    195193    // compute number of image planes 
    196     numImages = (int) ((file.length() - offset) / (2 * 64 * width * height)); 
     194    numImages = (int) ((in.length() - offset) / (2 * 64 * width * height)); 
    197195  } 
    198196 
  • trunk/loci/formats/in/SEQReader.java

    r1134 r1195  
    3737 
    3838  /** Number of optical sections in the file */ 
    39   private int sizeZ = 1; 
     39  private int sizeZ = 0; 
    4040 
    4141  /** Number of timepoints in the file */ 
     
    6767  public int getSizeZ(String id) throws FormatException, IOException { 
    6868    if (!id.equals(currentId)) initFile(id); 
    69     return sizeZ; 
     69    return Integer.parseInt((String) metadata.get("frames")); 
    7070  } 
    7171 
     
    7373  public int getSizeT(String id) throws FormatException, IOException { 
    7474    if (!id.equals(currentId)) initFile(id); 
    75     return sizeT; 
     75    return Integer.parseInt((String) metadata.get("slices")); 
     76  } 
     77 
     78  /** Get the size of the C dimension. */ 
     79  public int getSizeC(String id) throws FormatException, IOException { 
     80    if (!id.equals(currentId)) initFile(id); 
     81    return Integer.parseInt((String) metadata.get("channels")); 
    7682  } 
    7783 
     
    102108    } 
    103109 
     110    if (sizeZ == 0) sizeZ++; 
     111 
     112    if (sizeZ == 1 && sizeT == 1) { 
     113      sizeZ = ifds.length; 
     114    } 
     115 
    104116    // default values 
    105     metadata.put("slices", new Integer(sizeT)); 
    106     metadata.put("channels", new Integer(1)); 
    107     metadata.put("frames", new Integer(sizeZ)); 
     117    metadata.put("frames", "" + sizeZ); 
     118    metadata.put("channels", metadata.get("NumberOfChannels").toString()); 
     119    metadata.put("slices", "" + sizeT); 
    108120 
    109121    // parse the description to get channels, slices and times where applicable 
  • trunk/loci/formats/in/ZeissLSMReader.java

    r1134 r1195  
    2828import java.util.Hashtable; 
    2929import loci.formats.*; 
    30  
    3130 
    3231/** 
     
    182181      // determine byte order 
    183182      boolean little = TiffTools.isLittleEndian(ifd); 
    184  
    185       put("NewSubfileType", ifd, TiffTools.NEW_SUBFILE_TYPE); 
    186       put("ImageWidth", ifd, TiffTools.IMAGE_WIDTH); 
    187       put("ImageLength", ifd, TiffTools.IMAGE_LENGTH); 
    188       put("BitsPerSample", ifd, TiffTools.BITS_PER_SAMPLE); 
    189  
    190       int comp = TiffTools.getIFDIntValue(ifd, 
    191         TiffTools.COMPRESSION, false, TiffTools.UNCOMPRESSED); 
    192       String compression; 
    193       switch (comp) { 
    194         case 1: compression = "None"; break; 
    195         case 2: 
    196           compression = "CCITT Group 3 1-Dimensional Modified Huffman"; 
    197           break; 
    198         case 3: compression = "CCITT T.4 bilevel encoding"; break; 
    199         case 4: compression = "CCITT T.6 bilevel encoding"; break; 
    200         case 5: compression = "LZW"; break; 
    201         case 6: compression = "JPEG"; break; 
    202         case 32773: compression = "PackBits"; break; 
    203         default: compression = "None"; 
    204       } 
    205       put("Compression", compression); 
    206  
    207       int photo = TiffTools.getIFDIntValue(ifd, 
    208         TiffTools.PHOTOMETRIC_INTERPRETATION, true, -1); 
    209  
    210       String photoInterp; 
    211       switch (photo) { 
    212         case 0: photoInterp = "WhiteIsZero"; break; 
    213         case 1: photoInterp = "BlackIsZero"; break; 
    214         case 2: photoInterp = "RGB"; break; 
    215         case 3: photoInterp = "Palette"; break; 
    216         case 4: photoInterp = "Transparency Mask"; break; 
    217         default: photoInterp = "unknown"; break; 
    218       } 
    219       put("PhotometricInterpretation", photoInterp); 
    220  
    221       putInt("StripOffsets", ifd, TiffTools.STRIP_OFFSETS); 
    222       putInt("SamplesPerPixel", ifd, TiffTools.SAMPLES_PER_PIXEL); 
    223       putInt("StripByteCounts", ifd, TiffTools.STRIP_BYTE_COUNTS); 
    224       putInt("ColorMap", ifd, TiffTools.COLOR_MAP); 
    225  
    226       int planar = TiffTools.getIFDIntValue(ifd, 
    227         TiffTools.PLANAR_CONFIGURATION); 
    228       String planarConfig; 
    229       switch (planar) { 
    230         case 1: planarConfig = "Chunky"; break; 
    231         case 2: planarConfig = "Planar"; break; 
    232         default: planarConfig = "Chunky"; 
    233       } 
    234       put("PlanarConfiguration", planarConfig); 
    235  
    236       int predict = TiffTools.getIFDIntValue(ifd, TiffTools.PREDICTOR); 
    237       String predictor; 
    238       switch (predict) { 
    239         case 1: predictor = "No prediction scheme"; break; 
    240         case 2: predictor = "Horizontal differencing"; break; 
    241         default: predictor = "No prediction scheme"; 
    242       } 
    243       put("Predictor", predictor); 
     183      in.order(little); 
     184 
     185      super.initMetadata(); 
    244186 
    245187      // get Zeiss LSM-specific data 
     
    328270      p += 4; 
    329271 
    330       int pos = in.getFilePointer(); 
    331  
    332       // the following 4 are file offsets 
    333       data = DataTools.bytesToLong(cz, p, 4, little); 
    334       parseOverlays(data, "OffsetVectorOverlay", little); 
    335       p += 4; 
    336       data = DataTools.bytesToLong(cz, p, 4, little); 
    337       parseSubBlocks(data, "OffsetInputLut", little); 
    338       p += 4; 
    339       data = DataTools.bytesToLong(cz, p, 4, little); 
    340       parseSubBlocks(data, "OffsetOutputLut", little); 
    341       p += 4; 
    342       data = DataTools.bytesToLong(cz, p, 4, little); 
    343       // seek to this offset and read in the structure there 
    344       // first we have to make sure that the structure actually exists 
    345       if (data != 0) { 
    346         pos = in.getFilePointer(); 
    347  
    348         in.seek(data); 
    349  
    350         int blockSize = DataTools.read4SignedBytes(in, little); 
    351         int numColors = DataTools.read4SignedBytes(in, little); 
    352         int numNames = DataTools.read4SignedBytes(in, little); 
    353         idata = DataTools.read4SignedBytes(in, little); 
    354         long offset = data + idata; // will seek to this later 
    355         idata = DataTools.read4SignedBytes(in, little); 
    356         long offsetNames = data + idata; // will seek to this 
    357  
    358         // read in the intensity value for each color 
    359  
    360         in.skipBytes(idata - 16); 
    361  
    362         for (int i=0; i<numColors; i++) { 
    363           data = DataTools.read4UnsignedBytes(in, little); 
    364           put("Intensity" + i, data); 
    365         } 
    366  
    367         // read in the channel names 
    368  
    369         pos = in.getFilePointer(); 
    370         in.seek((int) (pos + offsetNames)); 
    371  
    372         for (int i=0; i<numNames; i++) { 
    373           // we want to read until we find a null char 
    374           String name = ""; 
    375           char[] current = new char[1]; 
    376           current[0] = in.readChar(); 
    377           while (current[0] != 0) { 
    378             name.concat(new String(current)); 
    379             current[0] = in.readChar(); 
    380           } 
    381           put("ChannelName" + i, name); 
    382         } 
    383         in.seek(pos); 
    384       } 
    385       p += 4; 
    386  
    387       put("TimeInterval", Double.longBitsToDouble( 
    388         DataTools.bytesToLong(cz, p, little))); 
    389       p += 8; 
    390  
    391       // the following 8 are file offsets 
    392  
    393       data = DataTools.bytesToLong(cz, p, 4, little); 
    394       if (data != 0) { 
    395         in.skipBytes((int) data); 
    396  
    397         for (int i=0; i<dimensionChannels; i++) { 
    398           data = DataTools.read4UnsignedBytes(in, little); 
    399           put("OffsetChannelDataTypes" + i, data); 
    400         } 
    401         in.seek(pos); 
    402       } 
    403       p += 4; 
    404  
    405       put("OffsetScanInformation", DataTools.bytesToLong(cz, p, 4, little)); 
    406       p += 4; 
    407  
    408       put("OffsetKsData", DataTools.bytesToLong(cz, p, 4, little)); 
    409       p += 4; 
    410  
    411       data = DataTools.bytesToLong(cz, p, 4, little); 
    412       if (data != 0) { 
    413         pos = in.getFilePointer(); 
    414         in.skipBytes((int) data); 
    415  
    416         in.skipBytes(4); 
    417         int numStamps = DataTools.read4SignedBytes(in, little); 
    418         if (numStamps > 1000) numStamps = 1000; 
    419         for (int i=0; i<numStamps; i++) { 
    420           ddata = DataTools.readDouble(in, little); 
    421           put("TimeStamp" + i, ddata); 
    422         } 
    423         in.seek(pos); 
    424       } 
    425       p += 4; 
    426  
    427       data = DataTools.bytesToLong(cz, p, 4, little); 
    428       if (data != 0) { 
    429         pos = in.getFilePointer(); 
    430  
    431         long numBytes = DataTools.read4UnsignedBytes(in, little); 
    432         int numEvents = DataTools.read4SignedBytes(in, little); 
    433         in.seek((int) (pos + data + 8)); 
    434  
    435         for (int i=0; i<numEvents; i++) { 
    436           in.skipBytes(4); 
    437           ddata = DataTools.readDouble(in, little); 
    438           put("Time" + i, ddata); 
    439  
    440           data = DataTools.read4UnsignedBytes(in, little); 
    441           put("EventType" + i, data); 
    442  
    443           byte[] descr = new byte[(int) (numBytes - 16)]; 
    444           in.read(descr); 
    445           put("Description" + i, new String(descr)); 
    446         } 
    447         in.seek(pos); 
    448       } 
    449       p += 4; 
    450  
    451       data = DataTools.bytesToLong(cz, p, 4, little); 
    452       parseOverlays(data, "OffsetRoi", little); 
    453       p += 4; 
    454       data = DataTools.bytesToLong(cz, p, 4, little); 
    455       parseOverlays(data, "OffsetBleachRoi", little); 
    456       p += 4; 
    457       put("OffsetNextRecording", DataTools.bytesToLong(cz, p, 4, little)); 
    458       p += 4; 
    459  
    460       put("DisplayAspectX", Double.longBitsToDouble( 
    461         DataTools.bytesToLong(cz, p, little))); 
    462       p += 8; 
    463       put("DisplayAspectY", Double.longBitsToDouble( 
    464         DataTools.bytesToLong(cz, p, little))); 
    465       p += 8; 
    466       put("DisplayAspectZ", Double.longBitsToDouble( 
    467         DataTools.bytesToLong(cz, p, little))); 
    468       p += 8; 
    469       put("DisplayAspectTime", Double.longBitsToDouble( 
    470         DataTools.bytesToLong(cz, p, little))); 
    471       p += 8; 
    472  
    473       // the following 4 are file offsets 
    474       data = DataTools.bytesToLong(cz, p, 4, little); 
    475       parseOverlays(data, "OffsetMeanOfRoisOverlay", little); 
    476       p += 4; 
    477       data = DataTools.bytesToLong(cz, p, 4, little); 
    478       parseOverlays(data, "OffsetTopoIsolineOverlay", little); 
    479       p += 4; 
    480       data = DataTools.bytesToLong(cz, p, 4, little); 
    481       parseOverlays(data, "OffsetTopoProfileOverlay", little); 
    482       p += 4; 
    483       data = DataTools.bytesToLong(cz, p, 4, little); 
    484       parseOverlays(data, "OffsetLinescanOverlay", little); 
    485       p += 4; 
    486  
    487       put("ToolbarFlags", DataTools.bytesToLong(cz, p, 4, little)); 
    488  
    489       // the following 2 are file offsets 
    490       put("OffsetChannelWavelength", DataTools.bytesToLong(cz, p, 4, little)); 
    491       p += 4; 
    492       put("OffsetChannelFactors", DataTools.bytesToLong(cz, p, 4, little)); 
    493       p += 4; 
    494  
    495       put("ObjectiveSphereCorrection", Double.longBitsToDouble( 
    496         DataTools.bytesToLong(cz, p, little))); 
    497       p += 8; 
    498  
    499       // the following is a file offset 
    500       put("OffsetUnmixParameters", DataTools.bytesToLong(cz, p, 4, little)); 
    501       p += 4; 
    502  
    503  
    504272      // -- Parse OME-XML metadata -- 
    505273 
     
    557325      } 
    558326 
     327      if (cSize == 0) cSize++; 
     328 
    559329      channels = cSize; 
    560330      if (isRGB(currentId)) channels *= 3; 
     
    574344        null); 
    575345 
     346      int pos = in.getFilePointer(); 
     347 
     348      // the following 4 are file offsets 
     349      data = DataTools.bytesToLong(cz, p, 4, little); 
     350      parseOverlays(data, "OffsetVectorOverlay", little); 
     351      p += 4; 
     352      data = DataTools.bytesToLong(cz, p, 4, little); 
     353      parseSubBlocks(data, "OffsetInputLut", little); 
     354      p += 4; 
     355      data = DataTools.bytesToLong(cz, p, 4, little); 
     356      parseSubBlocks(data, "OffsetOutputLut", little); 
     357      p += 4; 
     358      data = DataTools.bytesToLong(cz, p, 4, little); 
     359      // seek to this offset and read in the structure there 
     360      // first we have to make sure that the structure actually exists 
     361 
     362      if (data != 0) { 
     363        pos = in.getFilePointer(); 
     364 
     365        in.seek(data); 
     366 
     367        int blockSize = in.readInt(); 
     368        int numColors = in.readInt(); 
     369        int numNames = in.readInt(); 
     370        idata = in.readInt(); 
     371        long offset = data + idata; // will seek to this later 
     372        idata = in.readInt(); 
     373        long offsetNames = data + idata; // will seek to this 
     374 
     375        // read in the intensity value for each color 
     376 
     377        in.skipBytes(idata - 16); 
     378 
     379        for (int i=0; i<numColors; i++) { 
     380          data = in.readInt(); 
     381          put("Intensity" + i, data); 
     382        } 
     383 
     384        // read in the channel names 
     385 
     386        pos = in.getFilePointer(); 
     387        in.seek(pos + offsetNames); 
     388 
     389        for (int i=0; i<numNames; i++) { 
     390          // we want to read until we find a null char 
     391          String name = ""; 
     392          char[] current = new char[1]; 
     393          current[0] = (char) in.read(); 
     394          in.read(); 
     395          while (current[0] != 0) { 
     396            name.concat(new String(current)); 
     397            current[0] = (char) in.read(); 
     398            in.read(); 
     399          } 
     400          put("ChannelName" + i, name); 
     401        } 
     402        in.seek(pos); 
     403      } 
     404      p += 4; 
     405 
     406      put("TimeInterval", Double.longBitsToDouble( 
     407        DataTools.bytesToLong(cz, p, little))); 
     408      p += 8; 
     409 
     410      // the following 8 are file offsets 
     411 
     412      data = DataTools.bytesToLong(cz, p, 4, little); 
     413      if (data != 0) { 
     414        in.skipBytes((int) data); 
     415 
     416        for (int i=0; i<dimensionChannels; i++) { 
     417          put("OffsetChannelDataTypes" + i, in.readInt()); 
     418        } 
     419        in.seek(pos); 
     420      } 
     421      p += 4; 
     422 
     423      put("OffsetScanInformation", DataTools.bytesToLong(cz, p, 4, little)); 
     424      p += 4; 
     425 
     426      put("OffsetKsData", DataTools.bytesToLong(cz, p, 4, little)); 
     427      p += 4; 
     428 
     429      data = DataTools.bytesToLong(cz, p, 4, little); 
     430      if (data != 0) { 
     431        pos = in.getFilePointer(); 
     432        in.skipBytes((int) data + 4); 
     433 
     434        int numStamps = in.readInt(); 
     435        if (numStamps > 1000) numStamps = 1000; 
     436        for (int i=0; i<numStamps; i++) { 
     437          ddata = in.readDouble(); 
     438          put("TimeStamp" + i, ddata); 
     439        } 
     440        in.seek(pos); 
     441      } 
     442      p += 4; 
     443 
     444      data = DataTools.bytesToLong(cz, p, 4, little); 
     445      if (data != 0) { 
     446        pos = in.getFilePointer(); 
     447 
     448        long numBytes = in.readInt(); 
     449        int numEvents = in.readInt(); 
     450        in.seek((int) (pos + data + 8)); 
     451 
     452        for (int i=0; i<numEvents; i++) { 
     453          in.readInt(); 
     454          ddata = in.readDouble(); 
     455          put("Time" + i, ddata); 
     456 
     457          data = in.readInt(); 
     458          put("EventType" + i, data); 
     459 
     460          byte[] descr = new byte[(int) (numBytes - 16)]; 
     461          in.read(descr); 
     462          put("Description" + i, new String(descr)); 
     463        } 
     464        in.seek(pos); 
     465      } 
     466      p += 4; 
     467 
     468      data = DataTools.bytesToLong(cz, p, 4, little); 
     469      parseOverlays(data, "OffsetRoi", little); 
     470      p += 4; 
     471      data = DataTools.bytesToLong(cz, p, 4, little); 
     472      parseOverlays(data, "OffsetBleachRoi", little); 
     473      p += 4; 
     474      put("OffsetNextRecording", DataTools.bytesToLong(cz, p, 4, little)); 
     475      p += 4; 
     476 
     477      put("DisplayAspectX", Double.longBitsToDouble( 
     478        DataTools.bytesToLong(cz, p, little))); 
     479      p += 8; 
     480      put("DisplayAspectY", Double.longBitsToDouble( 
     481        DataTools.bytesToLong(cz, p, little))); 
     482      p += 8; 
     483      put("DisplayAspectZ", Double.longBitsToDouble( 
     484        DataTools.bytesToLong(cz, p, little))); 
     485      p += 8; 
     486      put("DisplayAspectTime", Double.longBitsToDouble( 
     487        DataTools.bytesToLong(cz, p, little))); 
     488      p += 8; 
     489 
     490      // the following 4 are file offsets 
     491      data = DataTools.bytesToLong(cz, p, 4, little); 
     492      parseOverlays(data, "OffsetMeanOfRoisOverlay", little); 
     493      p += 4; 
     494      data = DataTools.bytesToLong(cz, p, 4, little); 
     495      parseOverlays(data, "OffsetTopoIsolineOverlay", little); 
     496      p += 4; 
     497      data = DataTools.bytesToLong(cz, p, 4, little); 
     498      parseOverlays(data, "OffsetTopoProfileOverlay", little); 
     499      p += 4; 
     500      data = DataTools.bytesToLong(cz, p, 4, little); 
     501      parseOverlays(data, "OffsetLinescanOverlay", little); 
     502      p += 4; 
     503 
     504      put("ToolbarFlags", DataTools.bytesToLong(cz, p, 4, little)); 
     505 
     506      // the following 2 are file offsets 
     507      put("OffsetChannelWavelength", DataTools.bytesToLong(cz, p, 4, little)); 
     508      p += 4; 
     509      put("OffsetChannelFactors", DataTools.bytesToLong(cz, p, 4, little)); 
     510      p += 4; 
     511 
     512      put("ObjectiveSphereCorrection", Double.longBitsToDouble( 
     513        DataTools.bytesToLong(cz, p, little))); 
     514      p += 8; 
     515 
     516      // the following is a file offset 
     517      put("OffsetUnmixParameters", DataTools.bytesToLong(cz, p, 4, little)); 
     518      p += 4; 
     519 
    576520      in.seek(pos); 
    577521    } 
    578522    catch (FormatException e) { e.printStackTrace(); } 
    579523    catch (IOException e) { e.printStackTrace(); } 
    580   } 
    581  
     524    catch (Exception e) { } 
     525  } 
    582526 
    583527  // -- Helper methods -- 
     
    589533    if (data == 0) return; 
    590534 
    591     in.seek((int) data); 
    592  
    593     int nde = DataTools.read4SignedBytes(in, little); 
     535    in.seek(data); 
     536 
     537    int nde = in.readInt(); 
    594538    put("NumberDrawingElements-" + suffix, nde); 
    595     int size = DataTools.read4SignedBytes(in, little); 
    596     int idata = DataTools.read4SignedBytes(in, little); 
     539    int size = in.readInt(); 
     540    int idata = in.readInt(); 
    597541    put("LineWidth-" + suffix, idata); 
    598     idata = DataTools.read4SignedBytes(in, little); 
     542    idata = in.readInt(); 
    599543    put("Measure-" + suffix, idata); 
    600     in.skipBytes(8); 
    601     put("ColorRed-" + suffix, DataTools.readSignedByte(in)); 
    602     put("ColorGreen-" + suffix, DataTools.readSignedByte(in)); 
    603     put("ColorBlue-" + suffix, DataTools.readSignedByte(in)); 
    604     in.skipBytes(1); 
    605  
    606     put("Valid-" + suffix, DataTools.read4SignedBytes(in, little)); 
    607     put("KnotWidth-" + suffix, DataTools.read4SignedBytes(in, little)); 
    608     put("CatchArea-" + suffix, DataTools.read4SignedBytes(in, little)); 
     544    in.readDouble(); 
     545    put("ColorRed-" + suffix, in.read()); 
     546    put("ColorGreen-" + suffix, in.read()); 
     547    put("ColorBlue-" + suffix, in.read()); 
     548    in.read(); 
     549 
     550    put("Valid-" + suffix, in.readInt()); 
     551    put("KnotWidth-" + suffix, in.readInt()); 
     552    put("CatchArea-" + suffix, in.readInt()); 
    609553 
    610554    // some fields describing the font 
    611     put("FontHeight-" + suffix, DataTools.read4SignedBytes(in, little)); 
    612     put("FontWidth-" + suffix, DataTools.read4SignedBytes(in, little)); 
    613     put("FontEscapement-" + suffix, DataTools.read4SignedBytes(in, little)); 
    614     put("FontOrientation-" + suffix, DataTools.read4SignedBytes(in, little)); 
    615     put("FontWeight-" + suffix, DataTools.read4SignedBytes(in, little)); 
    616     put("FontItalic-" + suffix, DataTools.read4SignedBytes(in, little)); 
    617     put("FontUnderline-" + suffix, DataTools.read4SignedBytes(in, little)); 
    618     put("FontStrikeOut-" + suffix, DataTools.read4SignedBytes(in, little)); 
    619     put("FontCharSet-" + suffix, DataTools.read4SignedBytes(in, little)); 
    620     put("FontOutPrecision-" + suffix, DataTools.read4SignedBytes(in, little)); 
    621     put("FontClipPrecision-" + suffix, DataTools.read4SignedBytes(in, little)); 
    622     put("FontQuality-" + suffix, DataTools.read4SignedBytes(in, little)); 
    623     put("FontPitchAndFamily-" + suffix, 
    624       DataTools.read4SignedBytes(in, little)); 
     555    put("FontHeight-" + suffix, in.readInt()); 
     556    put("FontWidth-" + suffix, in.readInt()); 
     557    put("FontEscapement-" + suffix, in.readInt()); 
     558    put("FontOrientation-" + suffix, in.readInt()); 
     559    put("FontWeight-" + suffix, in.readInt()); 
     560    put("FontItalic-" + suffix, in.readInt()); 
     561    put("FontUnderline-" + suffix, in.readInt()); 
     562    put("FontStrikeOut-" + suffix, in.readInt()); 
     563    put("FontCharSet-" + suffix, in.readInt()); 
     564    put("FontOutPrecision-" + suffix, in.readInt()); 
     565    put("FontClipPrecision-" + suffix, in.readInt()); 
     566    put("FontQuality-" + suffix, in.readInt()); 
     567    put("FontPitchAndFamily-" + suffix, in.readInt()); 
    625568    byte[] temp = new byte[64]; 
    626569    in.read(temp); 
     
    628571 
    629572    // some flags for measuring values of different drawing element types 
    630     put("ClosedPolyline-" + suffix, DataTools.readUnsignedByte(in)); 
    631     put("OpenPolyline-" + suffix, DataTools.readUnsignedByte(in)); 
    632     put("ClosedBezierCurve-" + suffix, DataTools.readUnsignedByte(in)); 
    633     put("OpenBezierCurve-" + suffix, DataTools.readUnsignedByte(in)); 
    634     put("ArrowWithClosedTip-" + suffix, DataTools.readUnsignedByte(in)); 
    635     put("ArrowWithOpenTip-" + suffix, DataTools.readUnsignedByte(in)); 
    636     put("Ellipse-" + suffix, DataTools.readUnsignedByte(in)); 
    637     put("Circle-" + suffix, DataTools.readUnsignedByte(in)); 
    638     put("Rectangle-" + suffix, DataTools.readUnsignedByte(in)); 
    639     put("Line-" + suffix, DataTools.readUnsignedByte(in)); 
     573    put("ClosedPolyline-" + suffix, in.read()); 
     574    put("OpenPolyline-" + suffix, in.read()); 
     575    put("ClosedBezierCurve-" + suffix, in.read()); 
     576    put("OpenBezierCurve-" + suffix, in.read()); 
     577    put("ArrowWithClosedTip-" + suffix, in.read()); 
     578    put("ArrowWithOpenTip-" + suffix, in.read()); 
     579    put("Ellipse-" + suffix, in.read()); 
     580    put("Circle-" + suffix, in.read()); 
     581    put("Rectangle-" + suffix, in.read()); 
     582    put("Line-" + suffix, in.read()); 
    640583    int drawingEl = (size - 194) / nde; 
    641584    for (int i=0; i<nde; i++) { 
     
    654597    in.seek((int) data); 
    655598 
    656     long size = DataTools.read4UnsignedBytes(in, little); 
    657     long numSubBlocks = DataTools.read4UnsignedBytes(in, little); 
     599    in.order(little); 
     600 
     601    long size = in.readInt(); 
     602    if (size < 0) size += 4294967296L; 
     603    long numSubBlocks = in.readInt(); 
     604    if (numSubBlocks < 0) numSubBlocks += 4294967296L; 
    658605    put("NumSubBlocks-" + suffix, numSubBlocks); 
    659     long numChannels = DataTools.read4UnsignedBytes(in, little); 
     606    long numChannels = in.readInt(); 
     607    if (numChannels < 0) numChannels += 4294967296L; 
    660608    put("NumChannels-" + suffix, numChannels); 
    661     data = DataTools.read4UnsignedBytes(in, little); 
     609    data = in.readInt(); 
     610    if (data < 0) data += 4294967296L; 
    662611    put("LutType-" + suffix, data); 
    663     data = DataTools.read4UnsignedBytes(in, little); 
     612    data = in.readInt(); 
     613    if (data < 0) data += 4294967296L; 
    664614    put("Advanced-" + suffix, data); 
    665     data = DataTools.read4UnsignedBytes(in, little); 
     615    data = in.readInt(); 
     616    if (data < 0) data += 4294967296L; 
    666617    put("CurrentChannel-" + suffix, data); 
    667618    in.skipBytes(36); 
    668619 
     620    if (numSubBlocks > 100) numSubBlocks = 20; 
     621 
    669622    for (int i=0; i<numSubBlocks; i++) { 
    670       data = DataTools.read4UnsignedBytes(in, little); 
     623      data = in.readInt(); 
     624      if (data < 0) data += 4294967296L; 
    671625      put("Type" + i + "-" + suffix, data); 
    672  
    673       put("Size" + i + "-" + suffix, 
    674         DataTools.read4UnsignedBytes(in, little)); 
     626      put("Size" + i + "-" + suffix, in.readInt()); 
    675627 
    676628      switch ((int) data) { 
    677629        case 1: 
    678630          for (int j=0; j<numChannels; j++) { 
    679             put("GammaChannel" + j + "-" + i + "-" + suffix, 
    680               DataTools.readDouble(in, little)); 
     631            put("GammaChannel" + j + "-" + i + "-" + suffix, in.readDouble()); 
    681632          } 
    682633          break; 
     
    684635          for (int j=0; j<numChannels; j++) { 
    685636            put("BrightnessChannel" + j + "-" + i + "-" + suffix, 
    686               DataTools.readDouble(in, little)); 
     637              in.readDouble()); 
    687638          } 
    688639          break; 
     
    691642          for (int j=0; j<numChannels; j++) { 
    692643            put("ContrastChannel" + j + "-" + i + "-" + suffix, 
    693               DataTools.readDouble(in, little)); 
     644              in.readDouble()); 
    694645          } 
    695646          break; 
     
    698649          for (int j=0; j<numChannels; j++) { 
    699650            put("RampStartXChannel" + j + "-" + i + "-" + suffix, 
    700               DataTools.readDouble(in, little)); 
     651              in.readDouble()); 
    701652            put("RampStartYChannel" + j + "-" + i + "-" + suffix, 
    702               DataTools.readDouble(in, little)); 
     653              in.readDouble()); 
    703654            put("RampEndXChannel" + j + "-" + i + "-" + suffix, 
    704               DataTools.readDouble(in, little)); 
     655              in.readDouble()); 
    705656            put("RampEndYChannel" + j + "-" + i + "-" + suffix, 
    706               DataTools.readDouble(in, little)); 
     657              in.readDouble()); 
    707658            j += 4; 
    708659          } 
  • trunk/loci/formats/in/ZeissZVIReader.java

    r1138 r1195  
    7070  private int tSize; 
    7171  private int cSize; 
     72  private int oldBpp; 
    7273 
    7374  // -- Constructor -- 
     
    101102  public int getSizeX(String id) throws FormatException, IOException { 
    102103    if (!id.equals(currentId)) initFile(id); 
     104    if (needLegacy) return legacy.getSizeX(id); 
    103105    return width; 
    104106  } 
     
    107109  public int getSizeY(String id) throws FormatException, IOException { 
    108110    if (!id.equals(currentId)) initFile(id); 
     111    if (needLegacy) return legacy.getSizeY(id); 
    109112    return height; 
    110113  } 
     
    113116  public int getSizeZ(String id) throws FormatException, IOException { 
    114117    if (!id.equals(currentId)) initFile(id); 
     118    if (needLegacy) return legacy.getSizeZ(id); 
    115119    return zSize; 
    116120  } 
     
    119123  public int getSizeC(String id) throws FormatException, IOException { 
    120124    if (!id.equals(currentId)) initFile(id); 
     125    if (needLegacy) return legacy.getSizeC(id); 
    121126    return isRGB(id) ? 3*cSize : cSize; 
    122127  } 
     
    125130  public int getSizeT(String id) throws FormatException, IOException { 
    126131    if (!id.equals(currentId)) initFile(id); 
     132    if (needLegacy) return legacy.getSizeT(id); 
    127133    return tSize; 
    128134  } 
     
    141147  { 
    142148    if (!id.equals(currentId)) initFile(id); 
     149    if (needLegacy) return legacy.getDimensionOrder(id); 
    143150    return dimensionOrder; 
    144151  } 
     
    155162 
    156163    if (needLegacy) return legacy.openBytes(id, no); 
     164 
     165    //int tbitsPerSample = bitsPerSample; 
     166    //int tbytesPerPixel = bytesPerPixel; 
    157167 
    158168    // read image header data 
     
    301311      } 
    302312 
     313      //bitsPerSample = tbitsPerSample; 
     314      //bytesPerPixel = tbytesPerPixel; 
     315 
    303316      if (!isRGB(id) || !separated) { 
    304317        return tempPx; 
     
    323336    if (bpp == 0) bpp = bytesPerPixel; 
    324337    if (bpp > 4) bpp /= 3; 
     338    //if (bpp == 0) bpp = oldBpp; 
     339   // else oldBpp = bpp; 
    325340    return ImageTools.makeImage(data, width, height, 
    326341      (!isRGB(id) || separated) ? 1 : 3, true, bpp, false); 
     
    416431                (num.indexOf("Item") != -1)) 
    417432              { 
     433                int itemIndex = num.lastIndexOf("Item"); 
     434                int parenIndex = num.lastIndexOf(")"); 
     435                if (parenIndex < itemIndex) { 
     436                  itemIndex = num.lastIndexOf("Item", itemIndex - 1); 
     437                } 
     438 
     439                String s = num.substring(itemIndex + 5, parenIndex); 
     440                imageNum = Integer.parseInt(s); 
     441                num = num.substring(0, num.lastIndexOf("Item")); 
     442 
     443                /* 
    418444                String s = num.substring(num.lastIndexOf("Item") + 5, 
    419445                  num.lastIndexOf(")")); 
    420446                imageNum = Integer.parseInt(s); 
    421447                num = num.substring(0, num.lastIndexOf("Item")); 
     448                */ 
    422449              } 
    423450            } 
     
    554581            } 
    555582          } 
    556           else break; 
     583          //else break; 
     584          else { 
     585            if (legacy.getImageCount(id) == 1) break; 
     586          } 
    557587        } 
    558588        else if (isContents && isImage) { 
     
    653683      } 
    654684    } 
     685    if (nImages == 0) nImages = 1; 
    655686    openBytes(id, 0);  // set needLegacy appropriately 
    656687    initMetadata(); 
Note: See TracChangeset for help on using the changeset viewer.