Changeset 2905


Ignore:
Timestamp:
06/26/07 10:58:31 (12 years ago)
Author:
callan
Message:
  • Optimizations to avoid millions of getSeries() invocations
  • Optimizing away some array copies using ByteBuffer logic
  • Fixes to min/max calculation logic when the channel counts are different across series
  • Length of DICOM reader name changes
Location:
trunk/loci/formats
Files:
5 edited

Legend:

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

    r2876 r2905  
    102102    } 
    103103 
     104    series = 0; 
    104105    close(); 
    105106    currentId = id; 
  • trunk/loci/formats/MinMaxCalculator.java

    r2701 r2905  
    7171    } 
    7272 
     73    int series = getSeries(); 
     74     
    7375    // check that all planes have been reade 
    74     if (minMaxDone == null || minMaxDone[getSeries()] < getImageCount()) { 
     76    if (minMaxDone == null || minMaxDone[series] < getImageCount()) { 
    7577      return null; 
    7678    } 
    77     return new Double(chanMin[getSeries()][theC]); 
     79    return new Double(chanMin[series][theC]); 
    7880  } 
    7981 
     
    9092    } 
    9193 
     94    int series = getSeries(); 
     95     
    9296    // check that all planes have been reade 
    93     if (minMaxDone == null || minMaxDone[getSeries()] < getImageCount()) { 
     97    if (minMaxDone == null || minMaxDone[series] < getImageCount()) { 
    9498      return null; 
    9599    } 
    96     return new Double(chanMax[getSeries()][theC]); 
     100    return new Double(chanMax[series][theC]); 
    97101  } 
    98102 
     
    131135    int numRGB = getRGBChannelCount(); 
    132136    int pBase = no * numRGB; 
    133     if (planeMin[getSeries()][pBase] != planeMin[getSeries()][pBase]) { 
     137    int series = getSeries(); 
     138    if (planeMin[series][pBase] != planeMin[series][pBase]) { 
    134139      return null; 
    135140    } 
     
    137142    Double[] min = new Double[numRGB]; 
    138143    for (int c=0; c<numRGB; c++) { 
    139       min[c] = new Double(planeMin[getSeries()][pBase + c]); 
     144      min[c] = new Double(planeMin[series][pBase + c]); 
    140145    } 
    141146    return min; 
     
    154159    int numRGB = getRGBChannelCount(); 
    155160    int pBase = no * numRGB; 
    156     if (planeMax[getSeries()][pBase] != planeMax[getSeries()][pBase]) { 
     161    int series = getSeries(); 
     162    if (planeMax[series][pBase] != planeMax[series][pBase]) { 
    157163      return null; 
    158164    } 
     
    160166    Double[] max = new Double[numRGB]; 
    161167    for (int c=0; c<numRGB; c++) { 
    162       max[c] = new Double(planeMax[getSeries()][pBase + c]); 
     168      max[c] = new Double(planeMax[series][pBase + c]); 
    163169    } 
    164170    return max; 
     
    222228 
    223229    int numRGB = getRGBChannelCount(); 
    224  
     230    int series = getSeries(); 
     231     
    225232    // check whether min/max values have already been computed for this plane 
    226     if (planeMin[getSeries()][ndx * numRGB] == 
    227       planeMin[getSeries()][ndx * numRGB]) 
     233    if (planeMin[series][ndx * numRGB] == 
     234      planeMin[series][ndx * numRGB]) 
    228235    { 
    229236      return; 
     
    234241    int pBase = ndx * numRGB; 
    235242    for (int c=0; c<numRGB; c++) { 
    236       planeMin[getSeries()][pBase + c] = Double.POSITIVE_INFINITY; 
    237       planeMax[getSeries()][pBase + c] = Double.NEGATIVE_INFINITY; 
     243      planeMin[series][pBase + c] = Double.POSITIVE_INFINITY; 
     244      planeMax[series][pBase + c] = Double.NEGATIVE_INFINITY; 
    238245    } 
    239246 
     
    243250        for (int c=0; c<numRGB; c++) { 
    244251          double v = pixels.getSampleDouble(x, y, c); 
    245           if (v > chanMax[getSeries()][cBase + c]) { 
    246             chanMax[getSeries()][cBase + c] = v; 
     252          if (v > chanMax[series][cBase + c]) { 
     253            chanMax[series][cBase + c] = v; 
    247254          } 
    248           if (v < chanMin[getSeries()][cBase + c]) { 
    249             chanMin[getSeries()][cBase + c] = v; 
     255          if (v < chanMin[series][cBase + c]) { 
     256            chanMin[series][cBase + c] = v; 
    250257          } 
    251           if (v > planeMax[getSeries()][pBase + c]) { 
    252             planeMax[getSeries()][pBase + c] = v; 
     258          if (v > planeMax[series][pBase + c]) { 
     259            planeMax[series][pBase + c] = v; 
    253260          } 
    254           if (v < planeMin[getSeries()][pBase + c]) { 
    255             planeMin[getSeries()][pBase + c] = v; 
     261          if (v < planeMin[series][pBase + c]) { 
     262            planeMin[series][pBase + c] = v; 
    256263          } 
    257264        } 
     
    259266    } 
    260267 
    261     minMaxDone[getSeries()]++; 
    262  
    263     if (minMaxDone[getSeries()] == getImageCount()) { 
     268    minMaxDone[series]++; 
     269 
     270    if (minMaxDone[series] == getImageCount()) { 
    264271      MetadataStore store = getMetadataStore(); 
    265272      for (int c=0; c<getSizeC(); c++) { 
    266         store.setChannelGlobalMinMax(c, new Double(chanMin[getSeries()][c]), 
    267           new Double(chanMax[getSeries()][c]), new Integer(getSeries())); 
     273        store.setChannelGlobalMinMax(c, new Double(chanMin[series][c]), 
     274          new Double(chanMax[series][c]), new Integer(getSeries())); 
    268275      } 
    269276    } 
     
    278285 
    279286    int numRGB = getRGBChannelCount(); 
    280  
     287    int series = getSeries(); 
    281288    // check whether min/max values have already been computed for this plane 
    282     if (planeMin[getSeries()][ndx * numRGB] == 
    283       planeMin[getSeries()][ndx * numRGB]) 
     289    if (planeMin[series][ndx * numRGB] == 
     290      planeMin[series][ndx * numRGB]) 
    284291    { 
    285292      return; 
     
    295302    int pBase = ndx * numRGB; 
    296303    for (int c=0; c<numRGB; c++) { 
    297       planeMin[getSeries()][pBase + c] = Double.POSITIVE_INFINITY; 
    298       planeMax[getSeries()][pBase + c] = Double.NEGATIVE_INFINITY; 
     304      planeMin[series][pBase + c] = Double.POSITIVE_INFINITY; 
     305      planeMax[series][pBase + c] = Double.NEGATIVE_INFINITY; 
    299306    } 
    300307 
     
    307314        long bits = DataTools.bytesToLong(b, idx, bytes, little); 
    308315        double v = fp ? Double.longBitsToDouble(bits) : (double) bits; 
    309         if (v > chanMax[getSeries()][cBase + c]) { 
    310           chanMax[getSeries()][cBase + c] = v; 
     316        if (v > chanMax[series][cBase + c]) { 
     317          chanMax[series][cBase + c] = v; 
    311318        } 
    312         if (v < chanMin[getSeries()][cBase + c]) { 
    313           chanMin[getSeries()][cBase + c] = v; 
     319        if (v < chanMin[series][cBase + c]) { 
     320          chanMin[series][cBase + c] = v; 
    314321        } 
    315         if (v > planeMax[getSeries()][ndx]) { 
    316           planeMax[getSeries()][ndx] = v; 
     322        if (v > planeMax[series][ndx]) { 
     323          planeMax[series][ndx] = v; 
    317324        } 
    318         if (v < planeMin[getSeries()][pBase + c]) { 
    319           planeMin[getSeries()][pBase + c] = v; 
     325        if (v < planeMin[series][pBase + c]) { 
     326          planeMin[series][pBase + c] = v; 
    320327        } 
    321328      } 
    322329    } 
    323330 
    324     minMaxDone[getSeries()]++; 
    325  
    326     if (minMaxDone[getSeries()] == getImageCount()) { 
     331    minMaxDone[series]++; 
     332 
     333    if (minMaxDone[series] == getImageCount()) { 
    327334      MetadataStore store = getMetadataStore(); 
    328335      for (int c=0; c<getSizeC(); c++) { 
    329         store.setChannelGlobalMinMax(c, new Double(chanMin[getSeries()][c]), 
    330           new Double(chanMax[getSeries()][c]), new Integer(getSeries())); 
     336        store.setChannelGlobalMinMax(c, new Double(chanMin[series][c]), 
     337          new Double(chanMax[series][c]), new Integer(getSeries())); 
    331338      } 
    332339    } 
     
    336343  protected void initMinMax() throws FormatException, IOException { 
    337344    int seriesCount = getSeriesCount(); 
     345    int oldSeries = getSeries(); 
    338346 
    339347    if (chanMin == null) { 
    340348      chanMin = new double[seriesCount][]; 
    341349      for (int i=0; i<seriesCount; i++) { 
     350        setSeries(i); 
    342351        chanMin[i] = new double[getSizeC()]; 
    343352        Arrays.fill(chanMin[i], Double.POSITIVE_INFINITY); 
    344353      } 
     354      setSeries(oldSeries); 
    345355    } 
    346356    if (chanMax == null) { 
    347357      chanMax = new double[seriesCount][]; 
    348358      for (int i=0; i<seriesCount; i++) { 
     359        setSeries(i);   
    349360        chanMax[i] = new double[getSizeC()]; 
    350361        Arrays.fill(chanMax[i], Double.NEGATIVE_INFINITY); 
    351362      } 
     363      setSeries(oldSeries); 
    352364    } 
    353365    if (planeMin == null) { 
    354366      planeMin = new double[seriesCount][]; 
    355       int oldSeries = getSeries(); 
    356367      for (int i=0; i<seriesCount; i++) { 
    357368        setSeries(i); 
     
    364375    if (planeMax == null) { 
    365376      planeMax = new double[seriesCount][]; 
    366       int oldSeries = getSeries(); 
    367377      for (int i=0; i<seriesCount; i++) { 
    368378        setSeries(i); 
  • trunk/loci/formats/TiffTools.java

    r2897 r2905  
    15941594    boolean noDiv8 = bps0 % 8 != 0; 
    15951595    boolean bps8 = bps0 == 8; 
     1596    boolean bps16 = bps0 == 16; 
    15961597 
    15971598    int width = 0; 
     
    16281629 
    16291630    BitBuffer bb = new BitBuffer(bytes); 
     1631     
     1632    byte[] copyByteArray = new byte[numBytes]; 
     1633    ByteBuffer nioBytes = MappedByteBuffer.wrap(bytes); 
     1634    if (!littleEndian) 
     1635      nioBytes.order(ByteOrder.LITTLE_ENDIAN); 
    16301636 
    16311637    for (int j=0; j<sampleCount; j++) { 
     
    17181724            } 
    17191725          } 
    1720         } 
    1721         else { 
    1722           byte[] b = new byte[numBytes]; 
     1726        }  // End if (bps8) 
     1727        else if (bps16) { 
     1728          int ndx = startIndex + j; 
    17231729          if (numBytes + index < bytes.length) { 
    1724             System.arraycopy(bytes, index, b, 0, numBytes); 
    1725           } 
    1726           else { 
    1727             System.arraycopy(bytes, bytes.length - numBytes, b, 0, numBytes); 
     1730            samples[i][ndx] = nioBytes.getShort(index); 
     1731          } else { 
     1732            samples[i][ndx] = nioBytes.getShort(bytes.length - numBytes); 
    17281733          } 
    17291734          index += numBytes; 
    1730           int ndx = startIndex + j; 
    1731           samples[i][ndx] = 
    1732             (short) DataTools.bytesToLong(b, !littleEndian); 
    17331735 
    17341736          if (photoInterp == WHITE_IS_ZERO) { // invert color value 
     
    17431745            int cndx = i == 0 ? x : (i == 1 ? (x + bpsPow) : (x + 2*bpsPow)); 
    17441746            int cm = colorMap[cndx]; 
    1745  
    17461747            samples[i][ndx] = (short) (maxValue == 0 ? 
    17471748              (cm % (bpsPow - 1)) : cm); 
     
    17501751            samples[i][ndx] = (short) (Integer.MAX_VALUE - samples[i][ndx]); 
    17511752          } 
    1752         } 
     1753        }  // End if (bps16) 
     1754        else { 
     1755          if (numBytes + index < bytes.length) { 
     1756              System.arraycopy(bytes, index, copyByteArray, 0, numBytes); 
     1757          } else { 
     1758              System.arraycopy(bytes, bytes.length - numBytes, copyByteArray, 0, numBytes); 
     1759          } 
     1760          index += numBytes; 
     1761          int ndx = startIndex + j; 
     1762          samples[i][ndx] = 
     1763              (short) DataTools.bytesToLong(copyByteArray, !littleEndian); 
     1764 
     1765          if (photoInterp == WHITE_IS_ZERO) { // invert color value 
     1766            long max = 1; 
     1767            for (int q=0; q<numBytes; q++) max *= 8; 
     1768            samples[i][ndx] = (short) (max - samples[i][ndx]); 
     1769          } 
     1770          else if (photoInterp == RGB_PALETTE) { 
     1771            index -= numBytes; 
     1772 
     1773            int x = samples[i][ndx];  // this is the index into the color table 
     1774            int cndx = i == 0 ? x : (i == 1 ? (x + bpsPow) : (x + 2*bpsPow)); 
     1775            int cm = colorMap[cndx]; 
     1776 
     1777            samples[i][ndx] = (short) (maxValue == 0 ? 
     1778              (cm % (bpsPow - 1)) : cm); 
     1779          } 
     1780          else if (photoInterp == CMYK) { 
     1781            samples[i][ndx] = (short) (Integer.MAX_VALUE - samples[i][ndx]); 
     1782          } 
     1783        } // end else 
    17531784      } 
    17541785      if (photoInterp == RGB_PALETTE) index += (bps0 / 8); 
  • trunk/loci/formats/in/DicomReader.java

    r2704 r2905  
    9191 
    9292  /** Constructs a new DICOM reader. */ 
     93  // "Digital Imaging and Communications in Medicine" is nasty long. 
    9394  public DicomReader() { 
    94     super("Digital Imaging and Communications in Medicine", 
     95    super("Digital Img. & Comm. in Med.", 
    9596      new String[] {"dcm", "dicom"}); 
    9697  } 
  • trunk/loci/formats/in/LeicaReader.java

    r2867 r2905  
    10761076      store.setImage((String) seriesNames.get(i), timestamp, description, ii); 
    10771077 
    1078       for (int j=0; j<core.sizeC[0]; j++) { 
     1078      for (int j=0; j<core.sizeC[i]; j++) { 
    10791079        store.setLogicalChannel(j, null, null, null, null, null, null, ii); 
    10801080        // TODO: get channel min/max from metadata 
Note: See TracChangeset for help on using the changeset viewer.