Changeset 4031


Ignore:
Timestamp:
05/09/08 14:51:37 (12 years ago)
Author:
melissa
Message:
  • Removed some obsolete logic from LSM reader.
  • Improved RandomAccessStream, so reading from the first 256KB of the file is significantly faster.
Location:
trunk/loci/formats
Files:
2 edited

Legend:

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

    r3839 r4031  
    4949  protected static final int MAX_OVERHEAD = 262144; 
    5050 
    51   /** Maximum number of buffer sizes to keep. */ 
    52   protected static final int MAX_HISTORY = 50; 
    53  
    5451  /** Maximum number of open files. */ 
    5552  protected static final int MAX_FILES = 100; 
     
    6764  /** Number of currently open files. */ 
    6865  private static int openFiles = 0; 
    69  
    70   /** Recent buffer sizes. */ 
    71   private static int[] bufferSizes = new int[MAX_HISTORY]; 
    7266 
    7367  // -- Fields -- 
     
    201195        raf.readFully(buf); 
    202196        raf.seek(0); 
    203         bufferSizes[0] = MAX_OVERHEAD / 2; 
    204197        lastValid = 1; 
    205198        nextMark = MAX_OVERHEAD; 
     
    526519  // -- Helper methods - I/O -- 
    527520 
    528   /** Naive heuristic for determining a "good" buffer size for the DIS. */ 
    529   protected int determineBuffer() { 
    530     // first we want the weighted average of previous buffer sizes 
    531  
    532     int sum = 0; 
    533     int div = 0; 
    534     int ndx = 0; 
    535  
    536     while ((ndx < lastValid) && (ndx < MAX_HISTORY)) { 
    537       int size = bufferSizes[ndx]; 
    538       sum += (size * ((ndx / (MAX_HISTORY / 5)) + 1)); 
    539       div += (ndx / (MAX_HISTORY / 5)) + 1; 
    540       ndx++; 
    541     } 
    542  
    543     int newSize = sum / div; 
    544     if (newSize > MAX_OVERHEAD) newSize = MAX_OVERHEAD; 
    545     if (lastValid < MAX_HISTORY) { 
    546       bufferSizes[lastValid] = newSize; 
    547       lastValid++; 
    548     } 
    549     else { 
    550       bufferSizes[0] = newSize; 
    551     } 
    552  
    553     return newSize; 
    554   } 
    555  
    556521  /** 
    557522   * Determine whether it is more efficient to use the DataInputStream or 
     
    562527  protected int checkEfficiency(int toRead) throws IOException { 
    563528    if (Boolean.FALSE.equals(fileCache.get(this))) reopen(); 
    564     int oldBufferSize = bufferSizes[bufferSizes.length - 1]; 
    565529 
    566530    if (compressed) { 
     
    596560 
    597561      return DIS; 
     562    } 
     563 
     564    if (dis != null && raf != null && 
     565      afp + toRead < MAX_OVERHEAD && afp + toRead < length() && 
     566      afp + toRead < buf.length) 
     567    { 
     568      // this is a really special case that allows us to read directly from 
     569      // an array when working with the first MAX_OVERHEAD bytes of the file 
     570      // ** also note that it doesn't change the stream 
     571      return ARRAY; 
    598572    } 
    599573 
     
    621595    } 
    622596 
    623     if (dis != null && raf != null && 
    624       afp + toRead < MAX_OVERHEAD && afp + toRead < length() && 
    625       afp + toRead < buf.length) 
    626     { 
    627       // this is a really special case that allows us to read directly from 
    628       // an array when working with the first MAX_OVERHEAD bytes of the file 
    629       // ** also note that it doesn't change the stream 
    630       return ARRAY; 
    631     } 
    632     else if (afp >= fp && dis != null) { 
     597    if (afp >= fp && dis != null) { 
    633598      while (fp < afp) { 
    634599        while (afp - fp > Integer.MAX_VALUE) { 
     
    640605      } 
    641606 
    642       if (lastValid < MAX_HISTORY) { 
    643         bufferSizes[lastValid] = MAX_OVERHEAD; 
    644         lastValid++; 
    645       } 
    646       else { 
    647         bufferSizes[0] = MAX_OVERHEAD; 
    648       } 
    649  
    650607      if (fp >= nextMark) { 
    651608        dis.mark(MAX_OVERHEAD); 
     
    657614    } 
    658615    else { 
    659       if (dis != null && afp >= mark && fp < mark + oldBufferSize) { 
    660         int newBufferSize = determineBuffer(); 
    661  
     616      if (dis != null && afp >= mark && fp < mark + MAX_OVERHEAD) { 
    662617        boolean valid = true; 
    663618 
     
    670625 
    671626        if (valid) { 
    672           dis.mark(newBufferSize); 
    673           //fp = mark; 
     627          dis.mark(MAX_OVERHEAD); 
    674628 
    675629          fp = length() - dis.available(); 
     
    684638 
    685639          if (fp >= nextMark) { 
    686             dis.mark(newBufferSize); 
     640            dis.mark(MAX_OVERHEAD); 
    687641          } 
    688           nextMark = fp + newBufferSize; 
     642          nextMark = fp + MAX_OVERHEAD; 
    689643          mark = fp; 
    690644 
  • trunk/loci/formats/in/ZeissLSMReader.java

    r4002 r4031  
    177177    FormatTools.checkBufferSize(this, buf.length, w, h); 
    178178 
    179     // check that predictor is set to 1 if anything other 
    180     // than LZW compression is used 
    181     if (TiffTools.getCompression(ifds[no]) != TiffTools.LZW) { 
    182       ifds[no].put(new Integer(TiffTools.PREDICTOR), new Integer(1)); 
    183     } 
    184  
    185179    TiffTools.getSamples(ifds[no], in, buf, x, y, w, h); 
    186180    return buf; 
     
    194188    if (!thumbnailsRemoved) return; 
    195189    Hashtable ifd = ifds[0]; 
     190 
     191    status("Reading LSM metadata"); 
    196192 
    197193    MetadataStore store = 
     
    225221        case 2: 
    226222          put("DataType", "12 bit unsigned integer"); 
    227           core.pixelType[0] = FormatTools.UINT16; 
    228223          break; 
    229224        case 5: 
    230225          put("DataType", "32 bit float"); 
    231           core.pixelType[0] = FormatTools.FLOAT; 
    232226          break; 
    233227        case 0: 
    234228          put("DataType", "varying data types"); 
    235           core.pixelType[0] = -1; 
    236229          break; 
    237230        default: 
    238231          put("DataType", "8 bit unsigned integer"); 
    239           core.pixelType[0] = -1; 
    240       } 
    241  
    242       if (core.pixelType[0] == -1) { 
    243         int[] bps = TiffTools.getBitsPerSample(ifd); 
    244         switch (bps[0]) { 
    245           case 16: 
    246             core.pixelType[0] = FormatTools.UINT16; 
    247             break; 
    248           case 32: 
    249             core.pixelType[0] = FormatTools.FLOAT; 
    250             break; 
    251           default: 
    252             core.pixelType[0] = FormatTools.UINT8; 
    253         } 
    254232      } 
    255233 
     
    334312      } 
    335313 
    336       long type = ras.readInt(); 
    337       switch ((int) type) { 
     314      int type = ras.readInt(); 
     315      switch (type) { 
    338316        case 1: 
    339317          put("DataType2", "calculated data"); 
     
    346324      } 
    347325 
    348       long overlayOffset = ras.readInt(); 
    349       long inputLUTOffset = ras.readInt(); 
    350       long outputLUTOffset = ras.readInt(); 
     326      long[] overlayOffsets = new long[9]; 
     327      String[] overlayKeys = new String[] {"VectorOverlay", "InputLut", 
     328        "OutputLut", "ROI", "BleachROI", "MeanOfRoisOverlay", 
     329        "TopoIsolineOverlay", "TopoProfileOverlay", "LinescanOverlay"}; 
     330 
     331      overlayOffsets[0] = ras.readInt(); 
     332      overlayOffsets[1] = ras.readInt(); 
     333      overlayOffsets[2] = ras.readInt(); 
     334 
    351335      long channelColorsOffset = ras.readInt(); 
    352336 
     
    357341      long timeStampOffset = ras.readInt(); 
    358342      long eventListOffset = ras.readInt(); 
    359       long roiOffset = ras.readInt(); 
    360       long bleachRoiOffset = ras.readInt(); 
     343      overlayOffsets[3] = ras.readInt(); 
     344      overlayOffsets[4] = ras.readInt(); 
    361345      ras.skipBytes(4); 
    362346 
     
    366350      put("DisplayAspectTime", ras.readDouble()); 
    367351 
    368       long meanOfRoisOverlayOffset = ras.readInt(); 
    369       long topoIsolineOverlayOffset = ras.readInt(); 
    370       long topoProfileOverlayOffset = ras.readInt(); 
    371       long linescanOverlayOffset = ras.readInt(); 
     352      overlayOffsets[5] = ras.readInt(); 
     353      overlayOffsets[6] = ras.readInt(); 
     354      overlayOffsets[7] = ras.readInt(); 
     355      overlayOffsets[8] = ras.readInt(); 
     356 
     357      for (int i=0; i<overlayOffsets.length; i++) { 
     358        parseOverlays(overlayOffsets[i], overlayKeys[i]); 
     359      } 
    372360 
    373361      put("ToolbarFlags", ras.readInt()); 
     
    375363 
    376364      // read referenced structures 
    377  
    378       if (overlayOffset != 0) { 
    379         parseOverlays(overlayOffset, "OffsetVectorOverlay"); 
    380       } 
    381  
    382       if (inputLUTOffset != 0) { 
    383         parseSubBlocks(inputLUTOffset, "OffsetInputLut"); 
    384       } 
    385  
    386       if (outputLUTOffset != 0) { 
    387         parseSubBlocks(outputLUTOffset, "OffsetOutputLut"); 
    388       } 
    389365 
    390366      core.indexed[0] = lut != null && getSizeC() == 1; 
     
    399375 
    400376      if (channelColorsOffset != 0) { 
    401         in.seek(channelColorsOffset + 4); 
    402         int numColors = in.readInt(); 
    403         int numNames = in.readInt(); 
    404  
    405         long namesOffset = in.readInt(); 
     377        in.seek(channelColorsOffset + 12); 
     378        int namesOffset = in.readInt(); 
    406379 
    407380        // read in the intensity value for each color 
    408381 
    409382        if (namesOffset > 0) { 
    410           in.seek(namesOffset + channelColorsOffset); 
    411  
    412           for (int i=0; i<numNames; i++) { 
     383          in.skipBytes(namesOffset - 16); 
     384 
     385          for (int i=0; i<core.sizeC[0]; i++) { 
    413386            if (in.getFilePointer() >= in.length() - 1) break; 
    414387            // we want to read until we find a null char 
    415             StringBuffer sb = new StringBuffer(); 
    416             char current = (char) in.read(); 
    417             while (current != 0) { 
    418               if (current < 128) sb.append(current); 
    419               current = (char) in.read(); 
    420             } 
    421             if (sb.length() <= 128) put("ChannelName" + i, sb.toString()); 
     388            String name = in.readCString(); 
     389            if (name.length() <= 128) put("ChannelName" + i, name); 
    422390          } 
    423391        } 
     
    453421          } 
    454422        } 
    455       } 
    456  
    457       if (roiOffset != 0) parseOverlays(roiOffset, "ROIOffset"); 
    458  
    459       if (bleachRoiOffset != 0) { 
    460         parseOverlays(bleachRoiOffset, "BleachROIOffset"); 
    461       } 
    462  
    463       if (meanOfRoisOverlayOffset != 0) { 
    464         parseOverlays(meanOfRoisOverlayOffset, "OffsetMeanOfRoisOverlay"); 
    465       } 
    466  
    467       if (topoIsolineOverlayOffset != 0) { 
    468         parseOverlays(topoIsolineOverlayOffset, "OffsetTopoIsolineOverlay"); 
    469       } 
    470  
    471       if (topoProfileOverlayOffset != 0) { 
    472         parseOverlays(topoProfileOverlayOffset, "OffsetTopoProfileOverlay"); 
    473       } 
    474  
    475       if (linescanOverlayOffset != 0) { 
    476         parseOverlays(linescanOverlayOffset, "OffsetLinescanOverlay"); 
    477423      } 
    478424 
     
    777723        TiffTools.NEW_SUBFILE_TYPE, true, 0); 
    778724 
    779       if (subFileType == 0) newIFDs.add(ifds[i]); 
     725      if (subFileType == 0) { 
     726        // check that predictor is set to 1 if anything other 
     727        // than LZW compression is used 
     728        if (TiffTools.getCompression(ifds[i]) != TiffTools.LZW) { 
     729          ifds[i].put(new Integer(TiffTools.PREDICTOR), new Integer(1)); 
     730        } 
     731        newIFDs.add(ifds[i]); 
     732      } 
    780733    } 
    781734 
     
    804757    idata = in.readInt(); 
    805758    put("Measure-" + suffix, idata); 
    806     in.readDouble(); 
     759    in.skipBytes(8); 
    807760    put("ColorRed-" + suffix, in.read()); 
    808761    put("ColorGreen-" + suffix, in.read()); 
    809762    put("ColorBlue-" + suffix, in.read()); 
    810     in.read(); 
     763    in.skipBytes(1); 
    811764 
    812765    put("Valid-" + suffix, in.readInt()); 
     
    841794    put("Rectangle-" + suffix, in.read()); 
    842795    put("Line-" + suffix, in.read()); 
     796    /* 
    843797    try { 
    844798      int drawingEl = (size - 194) / nde; 
     799      if (drawingEl <= 0) return; 
     800      if (DataTools.swap(nde) < nde) nde = DataTools.swap(nde); 
    845801      for (int i=0; i<nde; i++) { 
    846802        put("DrawingElement" + i + "-" + suffix, in.readString(drawingEl)); 
     
    850806      if (debug) trace(exc); 
    851807    } 
    852   } 
    853  
    854   /** Parses subblock-related fields. */ 
    855   protected void parseSubBlocks(long data, String suffix) 
    856     throws IOException, FormatException 
    857   { 
    858     if (data == 0) return; 
    859  
    860     in.seek(data); 
    861  
    862     in.order(core.littleEndian[0]); 
    863  
    864     long size = in.readInt() & 0xffffffff; 
    865     long numSubBlocks = in.readInt() & 0xffffffff; 
    866     put("NumSubBlocks-" + suffix, numSubBlocks); 
    867     long numChannels = in.readInt() & 0xffffffff; 
    868     put("NumChannels-" + suffix, numChannels); 
    869     data = in.readInt() & 0xffffffff; 
    870     put("LutType-" + suffix, data); 
    871     data = in.readInt() & 0xffffffff; 
    872     put("Advanced-" + suffix, data); 
    873     data = in.readInt() & 0xffffffff; 
    874     put("CurrentChannel-" + suffix, data); 
    875     in.skipBytes(36); 
    876  
    877     if (numSubBlocks > 100) numSubBlocks = 20; 
    878  
    879     for (int i=0; i<numSubBlocks; i++) { 
    880       data = in.readInt() & 0xffffffff; 
    881       put("Type" + i + "-" + suffix, data); 
    882       int v = in.readInt(); 
    883       put("Size" + i + "-" + suffix, v); 
    884  
    885       switch ((int) data) { 
    886         case SUBBLOCK_GAMMA: 
    887           for (int j=0; j<numChannels; j++) { 
    888             put("GammaChannel" + j + "-" + i + "-" + suffix, in.readDouble()); 
    889           } 
    890           break; 
    891         case SUBBLOCK_BRIGHTNESS: 
    892           for (int j=0; j<numChannels; j++) { 
    893             put("BrightnessChannel" + j + "-" + i + "-" + suffix, 
    894               in.readDouble()); 
    895           } 
    896           break; 
    897         case SUBBLOCK_CONTRAST: 
    898           for (int j=0; j<numChannels; j++) { 
    899             put("ContrastChannel" + j + "-" + i + "-" + suffix, 
    900               in.readDouble()); 
    901           } 
    902           break; 
    903         case SUBBLOCK_RAMP: 
    904           for (int j=0; j<numChannels; j++) { 
    905             put("RampStartXChannel" + j + "-" + i + "-" + suffix, 
    906               in.readDouble()); 
    907             put("RampStartYChannel" + j + "-" + i + "-" + suffix, 
    908               in.readDouble()); 
    909             put("RampEndXChannel" + j + "-" + i + "-" + suffix, 
    910               in.readDouble()); 
    911             put("RampEndYChannel" + j + "-" + i + "-" + suffix, 
    912               in.readDouble()); 
    913             j += 4; 
    914           } 
    915           break; 
    916         case SUBBLOCK_KNOTS: 
    917           for (int j=0; j<numChannels; j++) { 
    918             double knotX = -1, knotY = -1; 
    919             int n = 0; 
    920             while (knotX < 255) { 
    921               knotX = in.readDouble(); 
    922               knotY = in.readDouble(); 
    923               addMeta("Channel " + j + " Knot " + n + " X", new Double(knotX)); 
    924               addMeta("Channel " + j + " Knot " + n + " Y", new Double(knotY)); 
    925               n++; 
    926             } 
    927           } 
    928           break; 
    929         case SUBBLOCK_PALETTE: 
    930           if (lut == null) { 
    931             lut = new byte[(int) (8192 * numChannels)]; 
    932             in.read(lut); 
    933           } 
    934           else in.skipBytes((int) (8192 * numChannels)); 
    935           break; 
    936       } 
    937     } 
     808    */ 
    938809  } 
    939810 
Note: See TracChangeset for help on using the changeset viewer.