Changeset 2291


Ignore:
Timestamp:
02/16/07 14:42:11 (13 years ago)
Author:
melissa
Message:

Added new channel min/max logic.

Location:
trunk/loci/formats
Files:
45 edited

Legend:

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

    r2290 r2291  
    310310    } 
    311311    return max; 
     312  } 
     313 
     314  /* @see IFormatReader#getChannelKnownMinimum(String, int) */ 
     315  public Double getChannelKnownMinimum(String id, int theC) 
     316    throws FormatException, IOException 
     317  { 
     318    int[] include = getIncludeList(id, theC); 
     319    Double min = new Double(Double.MAX_VALUE); 
     320    for (int i=0; i<readers.length; i++) { 
     321      if (include[i] >= 0) { 
     322        Double d = readers[i].getChannelKnownMinimum(files[i], include[i]); 
     323        if (d.compareTo(min) < 0) min = d; 
     324      } 
     325    } 
     326    return min; 
     327  } 
     328 
     329  /* @see IFormatReader#getChannelKnownMaximum(String, int) */ 
     330  public Double getChannelKnownMaximum(String id, int theC) 
     331    throws FormatException, IOException 
     332  { 
     333    int[] include = getIncludeList(id, theC); 
     334    Double max = new Double(Double.MIN_VALUE); 
     335    for (int i=0; i<readers.length; i++) { 
     336      if (include[i] >= 0) { 
     337        Double d = readers[i].getChannelKnownMaximum(files[i], include[i]); 
     338        if (d.compareTo(max) > 0) max = d; 
     339      } 
     340    } 
     341    return max; 
     342  } 
     343 
     344  /* @see IFormatReader#getPlaneMinimum(String, int) */ 
     345  public Double getPlaneMinimum(String id, int no) 
     346    throws FormatException, IOException 
     347  { 
     348    int[] q = computeIndices(id, no); 
     349    int fno = q[0], ino = q[1]; 
     350    return readers[fno].getPlaneMinimum(files[fno], ino);  
     351  } 
     352 
     353  /* @see IFormatReader#getPlaneMaximum(String, int) */ 
     354  public Double getPlaneMaximum(String id, int no) 
     355    throws FormatException, IOException 
     356  { 
     357    int[] q = computeIndices(id, no); 
     358    int fno = q[0], ino = q[1]; 
     359    return readers[fno].getPlaneMaximum(files[fno], ino);  
     360  } 
     361 
     362  /* @see IFormatReader#isMinMaxPopulated(String) */ 
     363  public boolean isMinMaxPopulated(String id) 
     364    throws FormatException, IOException 
     365  { 
     366    for (int i=0; i<readers.length; i++) { 
     367      if (!readers[i].isMinMaxPopulated(files[i])) return false; 
     368    } 
     369    return true; 
    312370  } 
    313371 
  • trunk/loci/formats/FormatReader.java

    r2288 r2291  
    2929import java.io.*; 
    3030import java.lang.reflect.Method; 
    31 import java.util.Arrays; 
    32 import java.util.Hashtable; 
     31import java.util.*; 
    3332import javax.swing.filechooser.FileFilter; 
    3433 
     
    107106  protected double[][][] channelMinMax; 
    108107 
     108  /** Min and max values for each plane. */ 
     109  protected double[][][] planeMinMax; 
     110 
    109111  /** Whether or not we're doing channel stat calculation (no by default). */ 
    110112  protected boolean enableChannelStatCalculation = false; 
     113   
     114  /** List of image indices that have been read. */ 
     115  protected Vector[] imagesRead; 
     116 
     117  /** List of minimum values for each image. */ 
     118  protected Vector[] minimumValues; 
     119 
     120  /** List of maximum values for each image. */ 
     121  protected Vector[] maximumValues; 
     122 
     123  /** Whether or not min/max computation has finished. */ 
     124  protected boolean[] minMaxFinished; 
     125 
     126  /**  
     127   * Flag indicating min/max values are stored in  
     128   * metadata (disables calculation).  
     129   */ 
     130  protected boolean metadataMinMax = false; 
    111131 
    112132  /** Whether or not to ignore color tables, if present. */ 
     
    153173    currentId = id; 
    154174    metadata = new Hashtable(); 
     175    imagesRead = new Vector[1]; 
     176    minimumValues = new Vector[1]; 
     177    maximumValues = new Vector[1]; 
     178    Arrays.fill(imagesRead, new Vector()); 
     179    Arrays.fill(minimumValues, new Vector()); 
     180    Arrays.fill(maximumValues, new Vector()); 
     181    minMaxFinished = new boolean[1]; 
    155182 
    156183    sizeX = new int[1]; 
     
    292319      throw new FormatException("Invalid channel index: " + theC); 
    293320    } 
    294     if (enableChannelStatCalculation) { 
    295       if (channelMinMax != null) { 
    296         return new Double(channelMinMax[getSeries(id)][theC][MIN]); 
    297       } 
    298       computeMinMax(id); 
    299       return new Double(channelMinMax[getSeries(id)][theC][MIN]); 
     321    if (enableChannelStatCalculation && minMaxFinished[series]) { 
     322      return new Double(channelMinMax[series][theC][MIN]); 
    300323    } 
    301324    return null; 
     
    310333      throw new FormatException("Invalid channel index: " + theC); 
    311334    } 
     335    if (enableChannelStatCalculation && minMaxFinished[series]) { 
     336      return new Double(channelMinMax[series][theC][MAX]); 
     337    } 
     338    return null; 
     339  } 
     340   
     341  /* @see IFormatReader#getChannelKnownMinimum(String, int) */ 
     342  public Double getChannelKnownMinimum(String id, int theC)  
     343    throws FormatException, IOException 
     344  { 
     345    if (!id.equals(currentId)) initFile(id); 
    312346    if (enableChannelStatCalculation) { 
    313       if (channelMinMax != null) { 
    314         return new Double(channelMinMax[getSeries(id)][theC][MAX]); 
    315       } 
    316       computeMinMax(id); 
    317       return new Double(channelMinMax[getSeries(id)][theC][MAX]); 
     347      return new Double(channelMinMax[series][theC][MIN]); 
    318348    } 
    319349    return null; 
     350  } 
     351 
     352  /* @see IFormatReader#getChannelKnownMaximum(String, int) */ 
     353  public Double getChannelKnownMaximum(String id, int theC) 
     354    throws FormatException, IOException 
     355  { 
     356    if (!id.equals(currentId)) initFile(id); 
     357    if (enableChannelStatCalculation) { 
     358      return new Double(channelMinMax[series][theC][MAX]); 
     359    } 
     360    return null; 
     361  } 
     362 
     363  /* @see IFormatReader#getPlaneMinimum(String, int) */ 
     364  public Double getPlaneMinimum(String id, int no)  
     365    throws FormatException, IOException 
     366  { 
     367    if (!id.equals(currentId)) initFile(id); 
     368    if (enableChannelStatCalculation &&  
     369      imagesRead[series].contains(new Integer(no)))  
     370    { 
     371      int ndx = no * getRGBChannelCount(id); 
     372      double min = Double.MAX_VALUE; 
     373      for (int i=ndx; i<ndx+getRGBChannelCount(id); i++) { 
     374        if (planeMinMax[series][i][MIN] < min) { 
     375          min = planeMinMax[series][i][MIN]; 
     376        } 
     377      } 
     378      return new Double(min); 
     379    } 
     380    return null; 
     381  } 
     382 
     383  /* @see IFormatReader#getPlaneMaximum(String, int) */ 
     384  public Double getPlaneMaximum(String id, int no) 
     385    throws FormatException, IOException 
     386  { 
     387    if (!id.equals(currentId)) initFile(id); 
     388    if (enableChannelStatCalculation &&  
     389      imagesRead[series].contains(new Integer(no)))  
     390    { 
     391      int ndx = no * getRGBChannelCount(id); 
     392      double max = Double.MIN_VALUE; 
     393      for (int i=ndx; i<ndx+getRGBChannelCount(id); i++) { 
     394        if (planeMinMax[series][i][MAX] > max) { 
     395          max = planeMinMax[series][i][MAX]; 
     396        } 
     397      } 
     398      return new Double(max); 
     399    } 
     400    return null; 
     401  } 
     402 
     403  /* @see IFormatReader#isMinMaxPopulated(String) */ 
     404  public boolean isMinMaxPopulated(String id) 
     405    throws FormatException, IOException 
     406  { 
     407    if (!id.equals(currentId)) initFile(id); 
     408    return minMaxFinished[series]; 
    320409  } 
    321410 
     
    526615    return filterMetadata; 
    527616  } 
    528  
    529617 
    530618  /* @see IFormatReader#setMetadataStore(MetadataStore) */ 
     
    10441132  } 
    10451133 
    1046   /** Compute the minimum and maximum values for each channel. */ 
    1047   private void computeMinMax(String id) throws FormatException, IOException { 
    1048     int oldSeries = getSeries(id); 
    1049     if (channelMinMax == null) { 
    1050       channelMinMax = new double[getSeriesCount(id)][][]; 
    1051       for (int i=0; i<getSeriesCount(id); i++) { 
    1052         setSeries(id, i); 
    1053         channelMinMax[i] = new double[getSizeC(id)][2]; 
    1054       } 
    1055       setSeries(id, oldSeries); 
    1056     } 
    1057     else return; 
    1058   
    1059     for (int i=0; i<getSeriesCount(id); i++) { 
    1060       setSeries(id, i); 
     1134  /**  
     1135   * Updates min/max values based on the given BufferedImage. 
     1136   * Should be called by each format reader's openImage method. 
     1137   */ 
     1138  public void updateMinMax(BufferedImage b, int ndx)  
     1139    throws FormatException, IOException 
     1140  { 
     1141    Integer ii = new Integer(ndx); 
     1142    if (!imagesRead[series].contains(ii) && enableChannelStatCalculation) { 
     1143      if (channelMinMax == null) { 
     1144        channelMinMax =  
     1145          new double[getSeriesCount(currentId)][getSizeC(currentId)][2]; 
     1146      } 
     1147      if (planeMinMax == null) { 
     1148        planeMinMax = new double[getSeriesCount(currentId)][ 
     1149          getSizeZ(currentId) * getSizeC(currentId) * getSizeT(currentId)][2]; 
     1150      } 
     1151 
     1152      imagesRead[series].add(ii); 
     1153      int[] coords = getZCTCoords(currentId, ndx); 
    10611154      int numRGB = getRGBChannelCount(currentId); 
    1062       for (int c=0; c<getSizeC(id); c+=numRGB) { 
    1063         for (int t=0; t<getSizeT(id); t++) { 
    1064           for (int z=0; z<getSizeZ(id); z++) { 
    1065             int ndx = getIndex(id, z, c / numRGB, t); 
    1066             WritableRaster pixels = openImage(id, ndx).getRaster(); 
    1067             for (int x=0; x<getSizeX(currentId); x++) { 
    1068               for (int y=0; y<getSizeY(currentId); y++) { 
    1069                 for (int cc=0; cc<numRGB; cc++) { 
    1070                   double pixelValue = pixels.getSampleDouble(x, y, cc); 
    1071                   if (pixelValue < channelMinMax[i][c + cc][MIN]) { 
    1072                     channelMinMax[i][c + cc][MIN] = pixelValue; 
    1073                   } 
    1074                   if (pixelValue > channelMinMax[i][c + cc][MAX]) { 
    1075                     channelMinMax[i][c + cc][MAX] = pixelValue; 
    1076                   } 
    1077                 } 
    1078               } 
     1155      WritableRaster pixels = b.getRaster(); 
     1156      for (int x=0; x<b.getWidth(); x++) { 
     1157        for (int y=0; y<b.getHeight(); y++) { 
     1158          for (int c=0; c<numRGB; c++) { 
     1159            double value = pixels.getSampleDouble(x, y, c); 
     1160            if (value > channelMinMax[series][coords[1]*numRGB + c][MAX]) { 
     1161              channelMinMax[series][coords[1]*numRGB + c][MAX] = value; 
     1162            } 
     1163            if (value < channelMinMax[series][coords[1]*numRGB + c][MIN]) { 
     1164              channelMinMax[series][coords[1]*numRGB + c][MIN] = value; 
     1165            } 
     1166            if (value > planeMinMax[series][ndx*numRGB + c][MAX]) { 
     1167              planeMinMax[series][ndx*numRGB + c][MAX] = value; 
     1168            } 
     1169            if (value < planeMinMax[series][ndx*numRGB + c][MIN]) { 
     1170              planeMinMax[series][ndx*numRGB + c][MIN] = value; 
    10791171            } 
    10801172          } 
    10811173        } 
    10821174      } 
    1083       MetadataStore store = getMetadataStore(id); 
    1084       for (int c=0; c<getSizeC(id); c++) { 
    1085         store.setChannelGlobalMinMax(c, new Double(channelMinMax[i][c][MIN]), 
    1086           new Double(channelMinMax[i][c][MAX]), null); 
    1087       } 
    1088     } 
    1089     setSeries(id, oldSeries); 
     1175 
     1176      if (imagesRead[series].size() == getImageCount(currentId)) { 
     1177        minMaxFinished[series] = true; 
     1178      } 
     1179    } 
     1180  } 
     1181 
     1182  /** 
     1183   * Updates min/max values based on given byte array. 
     1184   * Should be called by each format reader's openBytes method. 
     1185   */ 
     1186  public void updateMinMax(byte[] b, int ndx)  
     1187    throws FormatException, IOException  
     1188  { 
     1189    if (b == null) return; 
     1190    Integer ii = new Integer(ndx); 
     1191    if (!imagesRead[series].contains(ii) && enableChannelStatCalculation) { 
     1192      if (channelMinMax == null) { 
     1193        channelMinMax =  
     1194          new double[getSeriesCount(currentId)][getSizeC(currentId)][2]; 
     1195      } 
     1196      if (planeMinMax == null) { 
     1197        planeMinMax = new double[getSeriesCount(currentId)][ 
     1198          getSizeZ(currentId) * getSizeC(currentId) * getSizeT(currentId)][2]; 
     1199      } 
     1200       
     1201      boolean little = isLittleEndian(currentId); 
     1202      int bytes = getBytesPerPixel(getPixelType(currentId)); 
     1203      int numRGB = getRGBChannelCount(currentId); 
     1204      int pixels = getSizeX(currentId) * getSizeY(currentId); 
     1205      boolean interleaved = isInterleaved(currentId); 
     1206 
     1207      byte[] value = new byte[bytes]; 
     1208      int[] coords = getZCTCoords(currentId, ndx); 
     1209 
     1210      for (int i=0; i<pixels; i++) { 
     1211        for (int c=0; c<numRGB; c++) { 
     1212          int idx = interleaved ? i*numRGB + c : c*pixels + i; 
     1213          idx *= bytes; 
     1214          System.arraycopy(b, idx, value, 0, bytes); 
     1215          double v =  
     1216            Double.longBitsToDouble(DataTools.bytesToLong(value, little)); 
     1217          if (v > channelMinMax[series][coords[1]*numRGB + c][MAX]) { 
     1218            channelMinMax[series][coords[1]*numRGB + c][MAX] = v; 
     1219          } 
     1220          if (v < channelMinMax[series][coords[1]*numRGB + c][MIN]) { 
     1221            channelMinMax[series][coords[1]*numRGB + c][MIN] = v; 
     1222          } 
     1223          if (v > planeMinMax[series][ndx*numRGB + c][MAX]) { 
     1224            planeMinMax[series][ndx*numRGB + c][MAX] = v; 
     1225          } 
     1226          if (v < planeMinMax[series][ndx*numRGB + c][MIN]) { 
     1227            planeMinMax[series][ndx*numRGB + c][MIN] = v; 
     1228          } 
     1229        } 
     1230      } 
     1231    } 
    10901232  } 
    10911233 
  • trunk/loci/formats/IFormatReader.java

    r2288 r2291  
    7878  /** 
    7979   * Retrieves a specified channel's global minimum. 
     80   * Returns null if channel stat calculation is disabled or if some of the image 
     81   * planes have not been read. 
    8082   * @param id the filename of the base image. 
    8183   * @param theC the channel whose minimum is required. 
     
    9496  /** 
    9597   * Retrieves a specified channel's global maximum. 
     98   * Returns null if channel stat calculation is disabled or if some of the image 
     99   * planes have not been read. 
    96100   * @param id the filename of the base image. 
    97101   * @param theC the channel whose maximum is required. 
     
    108112    throws FormatException, IOException; 
    109113 
     114  /** 
     115   * Retrieves the specified channel's minimum based on the images that have 
     116   * been read. 
     117   * Returns null if channel stat calculation is disabled. 
     118   */ 
     119  Double getChannelKnownMinimum(String id, int theC) 
     120    throws FormatException, IOException; 
     121 
     122 
     123  /** 
     124   * Retrieves the specified channel's maximum based on the images that have 
     125   * been read. 
     126   * Returns null if channel stat calculation is disabled. 
     127   */ 
     128  Double getChannelKnownMaximum(String id, int theC) 
     129    throws FormatException, IOException; 
     130 
     131  /**  
     132   * Retrieves the minimum pixel value for the specified plane. 
     133   * Returns null if the plane has not already been read. 
     134   */ 
     135  Double getPlaneMinimum(String id, int no) throws FormatException, IOException; 
     136 
     137  /** 
     138   * Retrieves the maximum pixel value for the specified plane. 
     139   * Returns null if the plane has not already been read. 
     140   */ 
     141  Double getPlaneMaximum(String id, int no) throws FormatException, IOException; 
     142 
     143  /** 
     144   * Returns true if the values returned by getChannelGlobalMinimum/Maximum  
     145   * can be trusted. 
     146   */ 
     147  boolean isMinMaxPopulated(String id) throws FormatException, IOException; 
     148 
    110149  /** Get the size of the X dimension for the thumbnail. */ 
    111150  int getThumbSizeX(String id) throws FormatException, IOException; 
  • trunk/loci/formats/ImageReader.java

    r2288 r2291  
    247247  } 
    248248 
    249   /* @see IFormatReader#getChannelGlobalMinimum(int) */ 
     249  /* @see IFormatReader#getChannelGlobalMinimum(String, int) */ 
    250250  public Double getChannelGlobalMinimum(String id, int theC) 
    251251    throws FormatException, IOException 
     
    254254  } 
    255255 
    256   /* @see IFormatReader#getChannelGlobalMaximum(int) */ 
     256  /* @see IFormatReader#getChannelGlobalMaximum(String, int) */ 
    257257  public Double getChannelGlobalMaximum(String id, int theC) 
    258258    throws FormatException, IOException 
    259259  { 
    260260    return getReader(id).getChannelGlobalMaximum(id, theC); 
     261  } 
     262 
     263  /* @see IFormatReader#getChannelKnownMinimum(String, int) */ 
     264  public Double getChannelKnownMinimum(String id, int theC) 
     265    throws FormatException, IOException 
     266  { 
     267    return getReader(id).getChannelKnownMinimum(id, theC); 
     268  } 
     269 
     270  /* @see IFormatReader#getChannelKnownMaximum(String, int) */ 
     271  public Double getChannelKnownMaximum(String id, int theC) 
     272    throws FormatException, IOException 
     273  { 
     274    return getReader(id).getChannelKnownMaximum(id, theC); 
     275  } 
     276 
     277  /* @see IFormatReader#getPlaneMinimum(String, int) */ 
     278  public Double getPlaneMinimum(String id, int no)  
     279    throws FormatException, IOException 
     280  { 
     281    return getReader(id).getPlaneMinimum(id, no); 
     282  } 
     283 
     284  /* @see IFormatReader#getPlaneMaximum(String, int) */ 
     285  public Double getPlaneMaximum(String id, int no) 
     286    throws FormatException, IOException 
     287  { 
     288    return getReader(id).getPlaneMaximum(id, no); 
     289  } 
     290 
     291  /* @see IFormatReader#isMinMaxPopulated(String) */ 
     292  public boolean isMinMaxPopulated(String id)  
     293    throws FormatException, IOException 
     294  { 
     295    return getReader(id).isMinMaxPopulated(id); 
    261296  } 
    262297 
  • trunk/loci/formats/ReaderWrapper.java

    r2288 r2291  
    118118  } 
    119119 
     120  public Double getChannelKnownMinimum(String id, int theC) 
     121    throws FormatException, IOException 
     122  { 
     123    return reader.getChannelKnownMinimum(id, theC); 
     124  } 
     125 
     126  public Double getChannelKnownMaximum(String id, int theC) 
     127    throws FormatException, IOException 
     128  { 
     129    return reader.getChannelKnownMaximum(id, theC); 
     130  } 
     131 
     132  public Double getPlaneMinimum(String id, int no) 
     133    throws FormatException, IOException 
     134  { 
     135    return reader.getPlaneMinimum(id, no); 
     136  } 
     137 
     138  public Double getPlaneMaximum(String id, int no) 
     139    throws FormatException, IOException 
     140  { 
     141    return reader.getPlaneMaximum(id, no); 
     142  } 
     143 
     144  public boolean isMinMaxPopulated(String id)  
     145    throws FormatException, IOException 
     146  { 
     147    return reader.isMinMaxPopulated(id); 
     148  } 
     149 
    120150  public int getThumbSizeX(String id) throws FormatException, IOException { 
    121151    return reader.getThumbSizeX(id); 
  • trunk/loci/formats/in/AVIReader.java

    r2288 r2291  
    161161 
    162162    if (rawData.length == dwWidth * bmpHeight * (bmpBitsPerPixel / 8)) { 
     163      updateMinMax(rawData, no); 
    163164      return rawData; 
    164165    } 
     
    166167      byte[] t = new byte[dwWidth * bmpHeight * (bmpBitsPerPixel / 8)]; 
    167168      System.arraycopy(rawData, 0, t, 0, t.length); 
     169      updateMinMax(t, no); 
    168170      return t; 
    169171    } 
     
    174176    throws FormatException, IOException 
    175177  { 
    176     return ImageTools.makeImage(openBytes(id, no), dwWidth, bmpHeight, 
     178    BufferedImage b = ImageTools.makeImage(openBytes(id, no), dwWidth, bmpHeight, 
    177179      !isRGB(id) ? 1 : 3, true); 
     180    updateMinMax(b, no); 
     181    return b; 
    178182  } 
    179183 
  • trunk/loci/formats/in/AliconaReader.java

    r2288 r2291  
    130130        data[i*2 + 1] = msbData[i]; 
    131131      } 
     132      updateMinMax(data, no); 
    132133      return data; 
    133134    } 
     135    updateMinMax(lsbData, no); 
    134136    return lsbData; 
    135137  } 
     
    139141    throws FormatException, IOException 
    140142  { 
    141     return ImageTools.makeImage(openBytes(id, no), width, height, 1, false, 
    142       numBytes, true); 
     143    BufferedImage b = ImageTools.makeImage(openBytes(id, no), width, height, 1,  
     144      false, numBytes, true); 
     145    updateMinMax(b, no); 
     146    return b; 
    143147  } 
    144148 
  • trunk/loci/formats/in/BMPReader.java

    r2288 r2291  
    213213        tempPx[i].length); 
    214214    } 
     215    updateMinMax(p, no); 
    215216    return p; 
    216217  } 
     
    220221    throws FormatException, IOException 
    221222  { 
    222     if (!id.equals(currentId)) initFile(id); 
    223  
    224     if (no < 0 || no >= getImageCount(id)) { 
    225       throw new FormatException("Invalid image number: " + no); 
    226     } 
    227  
    228     return ImageTools.makeImage(openBytes(id, no), width, height, 
     223    BufferedImage b = ImageTools.makeImage(openBytes(id, no), width, height, 
    229224      !isRGB(id) ? 1 : 3, false); 
     225    updateMinMax(b, no); 
     226    return b; 
    230227  } 
    231228 
  • trunk/loci/formats/in/BaseTiffReader.java

    r2288 r2291  
    701701      System.arraycopy(p[i], 0, buf, i * p[0].length, p[0].length); 
    702702    } 
     703    updateMinMax(buf, no); 
    703704    return buf; 
    704705  } 
     
    770771    } 
    771772 
    772     return TiffTools.getImage(ifds[no], in, ignoreColorTable); 
     773    BufferedImage b = TiffTools.getImage(ifds[no], in, ignoreColorTable); 
     774    updateMinMax(b, no); 
     775    return b; 
    773776  } 
    774777 
  • trunk/loci/formats/in/BioRadReader.java

    r2288 r2291  
    125125    if (!id.equals(currentId)) initFile(id); 
    126126    return new Double(((Integer) getMeta("ramp1_max")).intValue()); 
     127  } 
     128 
     129  /* @see IFormatReader#isMinMaxPopulated(String) */ 
     130  public boolean isMinMaxPopulated(String id) 
     131    throws FormatException, IOException 
     132  { 
     133    if (!id.equals(currentId)) initFile(id); 
     134    return getMeta("ramp1_min") != null && getMeta("ramp1_max") != null; 
    127135  } 
    128136 
     
    144152    in.seek(offset + 76); 
    145153    in.read(data); 
     154    updateMinMax(data, no); 
    146155    return data; 
    147156  } 
     
    151160    throws FormatException, IOException 
    152161  { 
    153     return ImageTools.makeImage(openBytes(id, no), nx, ny, 1, false, 
     162    BufferedImage b = ImageTools.makeImage(openBytes(id, no), nx, ny, 1, false, 
    154163      byteFormat ? 1 : 2, LITTLE_ENDIAN); 
     164    updateMinMax(b, no); 
     165    return b; 
    155166  } 
    156167 
  • trunk/loci/formats/in/DeltavisionReader.java

    r2288 r2291  
    163163  } 
    164164 
     165  /* @see IFormatReader#isMinMaxPopulated(String) */ 
     166  public boolean isMinMaxPopulated(String id) 
     167    throws FormatException, IOException 
     168  { 
     169    return true;  
     170  } 
     171 
    165172  /* @see IFormatReader#isRGB(String) */ 
    166173  public boolean isRGB(String id) throws FormatException, IOException { 
     
    203210    in.seek(offset); 
    204211    in.read(buf); 
    205  
     212    updateMinMax(buf, no); 
    206213    return buf; 
    207214  } 
     
    211218    throws FormatException, IOException 
    212219  { 
    213     return ImageTools.makeImage(openBytes(id, no), width, height, 1, 
     220    BufferedImage b = ImageTools.makeImage(openBytes(id, no), width, height, 1, 
    214221      false, bytesPerPixel, little); 
     222    updateMinMax(b, no); 
     223    return b; 
    215224  } 
    216225  
  • trunk/loci/formats/in/DicomReader.java

    r2288 r2291  
    223223      } 
    224224    } 
     225    updateMinMax(data, no); 
    225226    return data; 
    226227  } 
     
    230231    throws FormatException, IOException 
    231232  { 
    232     return ImageTools.makeImage(openBytes(id, no), width, height, 1, false, 
    233       bitsPerPixel / 8, little); 
     233    BufferedImage b = ImageTools.makeImage(openBytes(id, no), width, height,  
     234      1, false, bitsPerPixel / 8, little); 
     235    updateMinMax(b, no); 
     236    return b; 
    234237  } 
    235238 
  • trunk/loci/formats/in/EPSReader.java

    r2288 r2291  
    150150    } 
    151151    ras.close(); 
    152  
     152    updateMinMax(p, no); 
    153153    return p; 
    154154  } 
     
    158158    throws FormatException, IOException 
    159159  { 
    160     return ImageTools.makeImage(openBytes(id, no), width, height, 
     160    BufferedImage b = ImageTools.makeImage(openBytes(id, no), width, height, 
    161161      !isRGB(id) ? 1 : 3, true); 
     162    updateMinMax(b, no); 
     163    return b; 
    162164  } 
    163165 
  • trunk/loci/formats/in/FluoviewReader.java

    r2219 r2291  
    9090    s = s.substring(s.indexOf("to") + 2).trim(); 
    9191    return new Double(Integer.parseInt(s)); 
     92  } 
     93 
     94  /* @see IFormatReader#isMinMaxPopulated(String) */ 
     95  public boolean isMinMaxPopulated(String id) 
     96    throws FormatException, IOException 
     97  { 
     98    return true; 
    9299  } 
    93100 
  • trunk/loci/formats/in/GIFReader.java

    r2265 r2291  
    192192      for (int i=0; i<b.length; i++) b[i] = (byte) ints[i]; 
    193193    } 
     194    updateMinMax(b, no); 
    194195    return b; 
    195196  } 
     
    199200    throws FormatException, IOException 
    200201  { 
    201     if (!id.equals(currentId)) initFile(id); 
    202  
    203     if (no < 0 || no >= getImageCount(id)) { 
    204       throw new FormatException("Invalid image number: " + no); 
    205     } 
    206  
    207     byte[] b = openBytes(id, no); 
    208     return ImageTools.makeImage(b, width, height, b.length / (width * height), 
    209       false, 1, true); 
     202    byte[] bytes = openBytes(id, no); 
     203    BufferedImage b = ImageTools.makeImage(bytes, width, height,  
     204      bytes.length / (width * height), false, 1, true); 
     205    updateMinMax(b, no); 
     206    return b; 
    210207  } 
    211208 
  • trunk/loci/formats/in/GatanReader.java

    r2265 r2291  
    118118  } 
    119119 
     120  /* @see IFormatReader#isMinMaxPopulated(String) */ 
     121  public boolean isMinMaxPopulated(String id) 
     122    throws FormatException, IOException 
     123  { 
     124    return true; 
     125  } 
     126 
    120127  /** Obtains the specified image from the given Gatan file as a byte array. */ 
    121128  public byte[] openBytes(String id, int no) 
     
    127134      throw new FormatException("Invalid image number: " + no); 
    128135    } 
    129  
     136    updateMinMax(pixelData, no); 
    130137    return pixelData; 
    131138  } 
     
    145152    int channels = 1; 
    146153 
    147     return ImageTools.makeImage(pixelData, width, height, channels, 
     154    BufferedImage b = ImageTools.makeImage(pixelData, width, height, channels, 
    148155      false, dims[2], littleEndian); 
     156    updateMinMax(b, no); 
     157    return b; 
    149158  } 
    150159 
  • trunk/loci/formats/in/ICSReader.java

    r2265 r2291  
    143143        newOff += len; 
    144144      } 
     145      updateMinMax(t, no); 
    145146      return t; 
    146147    } 
    147  
     148    updateMinMax(plane, no); 
    148149    return plane; 
    149150  } 
     
    172173      if (normalizeData) f = DataTools.normalizeFloats(f); 
    173174 
    174       return ImageTools.makeImage(f, width, height, channels, true); 
    175     } 
    176  
    177     return ImageTools.makeImage(plane, width, height, channels, true, 
     175      BufferedImage b = ImageTools.makeImage(f, width, height, channels, true); 
     176      updateMinMax(b, no); 
     177    } 
     178 
     179    BufferedImage b = ImageTools.makeImage(plane, width, height, channels, true, 
    178180      bytes, littleEndian); 
     181    updateMinMax(b, no); 
     182    return b; 
    179183  } 
    180184 
  • trunk/loci/formats/in/IPLabReader.java

    r2288 r2291  
    126126  } 
    127127 
     128  /* @see IFormatReader#isMinMaxPopulated(String) */ 
     129  public boolean isMinMaxPopulated(String id) 
     130    throws FormatException, IOException 
     131  { 
     132    return true; 
     133  } 
     134 
    128135  /** Obtains the specified image from the given IPLab file as a byte array. */ 
    129136  public byte[] openBytes(String id, int no) 
     
    141148    byte[] rawData = new byte[numPixels * bps]; 
    142149    in.read(rawData); 
     150    updateMinMax(rawData, no); 
    143151    return rawData; 
    144152  } 
     
    148156    throws FormatException, IOException 
    149157  { 
    150     return ImageTools.makeImage(openBytes(id, no), width, height, 
     158    BufferedImage b = ImageTools.makeImage(openBytes(id, no), width, height, 
    151159      !isRGB(id) ? 1 : c, false, bps, littleEndian); 
     160    updateMinMax(b, no); 
     161    return b; 
    152162  } 
    153163 
  • trunk/loci/formats/in/IPWReader.java

    r2277 r2291  
    154154      } 
    155155      stream.close(); 
     156      updateMinMax(rtn, no); 
    156157      return rtn; 
    157158    } 
     
    173174    byte[] b = openBytes(id, no); 
    174175    int bytes = b.length / (sizeX[0] * sizeY[0]); 
    175     return ImageTools.makeImage(b, sizeX[0], sizeY[0], bytes == 3 ? 3 : 1, 
    176       false, bytes == 3 ? 1 : bytes, little); 
     176    BufferedImage bi = ImageTools.makeImage(b, sizeX[0], sizeY[0],  
     177      bytes == 3 ? 3 : 1, false, bytes == 3 ? 1 : bytes, little); 
     178    updateMinMax(bi, no); 
     179    return bi; 
    177180  } 
    178181 
  • trunk/loci/formats/in/ImageIOReader.java

    r2265 r2291  
    9595      } 
    9696    } 
     97    updateMinMax(b, no); 
    9798    return b; 
    9899  } 
     
    112113    ras.close(); 
    113114    dis.close(); 
     115    updateMinMax(b, no); 
    114116    return b; 
    115117  } 
  • trunk/loci/formats/in/ImageJReader.java

    r2281 r2291  
    110110    throws FormatException, IOException 
    111111  { 
    112     return ImageTools.getBytes(openImage(id, no), false, no); 
     112    byte[] b = ImageTools.getBytes(openImage(id, no), false, no); 
     113    updateMinMax(b, no); 
     114    return b; 
    113115  } 
    114116 
     
    147149      r.exec("size = image.getStackSize()"); 
    148150      Image img = (Image) r.exec("image.getImage()"); 
    149  
    150       return ImageTools.makeBuffered(img); 
     151       
     152      BufferedImage b = ImageTools.makeBuffered(img); 
     153      updateMinMax(b, no); 
     154      return b; 
    151155    } 
    152156    catch (ReflectException exc) { 
  • trunk/loci/formats/in/ImarisReader.java

    r2288 r2291  
    213213      row--; 
    214214    } 
    215  
     215    updateMinMax(data, no); 
    216216    return data; 
    217217  } 
     
    221221    throws FormatException, IOException 
    222222  { 
    223     return ImageTools.makeImage(openBytes(id, no), dims[0], dims[1], 1, false); 
     223    BufferedImage b = ImageTools.makeImage(openBytes(id, no), dims[0],  
     224      dims[1], 1, false); 
     225    updateMinMax(b, no); 
     226    return b; 
    224227  } 
    225228  
  • trunk/loci/formats/in/LIFReader.java

    r2265 r2291  
    138138  } 
    139139 
     140  /* @see IFormatReader#isMinMaxPopulated(String) */ 
     141  public boolean isMinMaxPopulated(String id) 
     142    throws FormatException, IOException 
     143  { 
     144    return true; 
     145  } 
     146 
    140147  /** Obtains the specified image from the given LIF file as a byte array. */ 
    141148  public byte[] openBytes(String id, int no) 
     
    169176    byte[] data = new byte[(int) (width * height * bytesPerPixel * c)]; 
    170177    in.read(data); 
     178    updateMinMax(data, no); 
    171179    return data; 
    172180  } 
     
    176184    throws FormatException, IOException 
    177185  { 
    178     return ImageTools.makeImage(openBytes(id, no), width, height, 
     186    BufferedImage b = ImageTools.makeImage(openBytes(id, no), width, height, 
    179187      !isRGB(id) ? 1 : c, false, bpp / 8, littleEndian, validBits[series]); 
     188    updateMinMax(b, no); 
     189    return b; 
    180190  } 
    181191 
  • trunk/loci/formats/in/LegacyPictReader.java

    r2182 r2291  
    7676    throws FormatException, IOException 
    7777  { 
    78     return ImageTools.getBytes(openImage(id, no), false, 3); 
     78    byte[] b = ImageTools.getBytes(openImage(id, no), false, 3); 
     79    updateMinMax(b, no); 
     80    return b; 
    7981  } 
    8082 
     
    101103    } 
    102104    fin.close(); 
    103     return ImageTools.makeBuffered(qtTools.pictToImage(bytes)); 
     105    BufferedImage b = ImageTools.makeBuffered(qtTools.pictToImage(bytes)); 
     106    updateMinMax(b, no); 
     107    return b; 
    104108  } 
    105109 
  • trunk/loci/formats/in/LegacyQTReader.java

    r2182 r2291  
    9999    throws FormatException, IOException 
    100100  { 
    101     if (!id.equals(currentId)) initFile(id); 
    102  
    103     if (no < 0 || no >= getImageCount(id)) { 
    104       throw new FormatException("Invalid image number: " + no); 
    105     } 
    106  
    107     return ImageTools.getBytes(openImage(id, no), false, 3); 
     101    byte[] b = ImageTools.getBytes(openImage(id, no), false, 3); 
     102    updateMinMax(b, no); 
     103    return b; 
    108104  } 
    109105 
     
    134130    } 
    135131 
    136     return ImageTools.makeBuffered(image); 
     132    BufferedImage b = ImageTools.makeBuffered(image); 
     133    updateMinMax(b, no); 
     134    return b; 
    137135  } 
    138136 
  • trunk/loci/formats/in/LegacyZVIReader.java

    r2265 r2291  
    118118  public byte[] openBytes(String id, int no) throws FormatException, IOException 
    119119  { 
    120     return ImageTools.getBytes(openImage(id, no), false, no); 
     120    byte[] b = ImageTools.getBytes(openImage(id, no), false, no); 
     121    updateMinMax(b, no); 
     122    return b; 
    121123  } 
    122124 
     
    141143    ZVIBlock zviBlock = (ZVIBlock) blockList.elementAt(no); 
    142144 
    143     return zviBlock.readImage(in); 
     145    BufferedImage b = zviBlock.readImage(in); 
     146    updateMinMax(b, no); 
     147    return b; 
    144148  } 
    145149 
  • trunk/loci/formats/in/LeicaReader.java

    r2265 r2291  
    171171    byte[] b = tiff[series][no].openBytes((String) files[series].get(no), 0); 
    172172    tiff[series][no].close(); 
     173    updateMinMax(b, no); 
    173174    return b; 
    174175  } 
     
    193194    b = ImageTools.makeBuffered(b, cm); 
    194195    tiff[series][no].close(); 
     196    updateMinMax(b, no); 
    195197    return b; 
    196198  } 
  • trunk/loci/formats/in/MNGReader.java

    r2265 r2291  
    9898    throws FormatException, IOException 
    9999  { 
    100     if (!id.equals(currentId)) initFile(id); 
    101  
    102     if (no < 0 || no >= getImageCount(id)) { 
    103       throw new FormatException("Invalid image number: " + no); 
    104     } 
    105     return ImageTools.getBytes(openImage(id, no), true, getSizeC(id)); 
     100    byte[] b = ImageTools.getBytes(openImage(id, no), true, getSizeC(id)); 
     101    updateMinMax(b, no); 
     102    return b; 
    106103  } 
    107104 
     
    130127    b[7] = 0x0a; 
    131128 
    132     return ImageIO.read(new ByteArrayInputStream(b)); 
     129    BufferedImage bi = ImageIO.read(new ByteArrayInputStream(b)); 
     130    updateMinMax(bi, no); 
     131    return bi; 
    133132  } 
    134133 
  • trunk/loci/formats/in/MRCReader.java

    r2265 r2291  
    104104    byte[] b = new byte[sizeX[0] * sizeY[0] * bpp]; 
    105105    in.read(b); 
     106    updateMinMax(b, no); 
    106107    return b; 
    107108  } 
     
    111112    throws FormatException, IOException 
    112113  { 
    113     return ImageTools.makeImage(openBytes(id, no), sizeX[0], sizeY[0], 1, 
    114       true, bpp, little); 
     114    BufferedImage b = ImageTools.makeImage(openBytes(id, no), sizeX[0],  
     115      sizeY[0], 1, true, bpp, little); 
     116    updateMinMax(b, no); 
     117    return b; 
    115118  } 
    116119 
  • trunk/loci/formats/in/MetamorphReader.java

    r2288 r2291  
    119119    if (!id.equals(currentId)) initFile(id); 
    120120    return (Double) getMeta("grayMax"); 
     121  } 
     122 
     123  /* @see IFormatReader#isMinMaxPopulated(String) */ 
     124  public boolean isMinMaxPopulated(String id) 
     125    throws FormatException, IOException 
     126  { 
     127    return true; 
    121128  } 
    122129 
  • trunk/loci/formats/in/ND2Reader.java

    r2277 r2291  
    185185      System.arraycopy(pixels[i], 0, b, i*pixels[0].length, pixels[i].length); 
    186186    } 
     187    updateMinMax(b, no); 
    187188    return b; 
    188189  } 
     
    252253 
    253254    ColorModel cm = ImageTools.makeColorModel(sizeC[0], dataType, validBits); 
    254     return ImageTools.makeBuffered(img); 
     255    BufferedImage bi = ImageTools.makeBuffered(img); 
     256    updateMinMax(bi, no); 
     257    return bi; 
    255258  } 
    256259 
  • trunk/loci/formats/in/OIBReader.java

    r2277 r2291  
    180180    try { return new Double(s); } 
    181181    catch (NumberFormatException exc) { return null; } 
     182  } 
     183 
     184  /* @see IFormatReader#isMinMaxPopulated(String) */ 
     185  public boolean isMinMaxPopulated(String id) 
     186    throws FormatException, IOException 
     187  { 
     188    return true; 
    182189  } 
    183190 
     
    221228 
    222229      stream.close(); 
    223  
     230      updateMinMax(rtn, no); 
    224231      return rtn; 
    225232    } 
     
    241248    int s = getSeries(id); 
    242249    int bytes = b.length / (sizeX[s] * sizeY[s]); 
    243     return ImageTools.makeImage(b, sizeX[s], sizeY[s], bytes == 3 ? 3 : 1, 
    244       false, bytes == 3 ? 1 : bytes, !littleEndian[s], validBits[s]); 
     250    BufferedImage bi = ImageTools.makeImage(b, sizeX[s], sizeY[s],  
     251      bytes == 3 ? 3 : 1, false, bytes == 3 ? 1 : bytes, !littleEndian[s],  
     252      validBits[s]); 
     253    updateMinMax(bi, no); 
     254    return bi; 
    245255  } 
    246256 
  • trunk/loci/formats/in/OIFReader.java

    r2265 r2291  
    134134  } 
    135135 
     136  /* @see IFormatReader#isMinMaxPopulated(String) */ 
     137  public boolean isMinMaxPopulated(String id) 
     138    throws FormatException, IOException 
     139  { 
     140    return true; 
     141  } 
     142 
    136143  /** Obtains the specified image from the given OIF file as a byte array. */ 
    137144  public byte[] openBytes(String id, int no) 
     
    144151    byte[] b = tiffReader[no].openBytes((String) tiffs.get(no), 0); 
    145152    tiffReader[no].close(); 
     153    updateMinMax(b, no); 
    146154    return b; 
    147155  } 
     
    165173    b = ImageTools.makeBuffered(b, cm); 
    166174    tiffReader[no].close(); 
     175    updateMinMax(b, no); 
    167176    return b; 
    168177  } 
  • trunk/loci/formats/in/OMEReader.java

    r2265 r2291  
    137137    try { 
    138138      byte[] b = pf.getPlane(pixels, indices[0], indices[1], indices[2], false); 
     139      updateMinMax(b, no); 
    139140      return b; 
    140141    } 
     
    148149    throws FormatException, IOException 
    149150  { 
    150     if (!id.equals(currentId)) initFile(id); 
    151     if (no < 0 || no >= numImages) { 
    152       throw new FormatException("Invalid image number: " + no); 
    153     } 
    154     return ImageTools.makeImage(openBytes(id, no), sizeX[0], sizeY[0],  
    155       1, false, FormatReader.getBytesPerPixel(pixelType[0]), true); 
     151    BufferedImage b = ImageTools.makeImage(openBytes(id, no), sizeX[0],  
     152      sizeY[0], 1, false, FormatReader.getBytesPerPixel(pixelType[0]), true); 
     153    updateMinMax(b, no); 
     154    return b; 
    156155  } 
    157156 
  • trunk/loci/formats/in/OMEXMLReader.java

    r2277 r2291  
    209209      } 
    210210    } 
    211  
     211    updateMinMax(pixels, no); 
    212212    return pixels; 
    213213  } 
     
    217217    throws FormatException, IOException 
    218218  { 
    219     return ImageTools.makeImage(openBytes(id, no), width[series], 
     219    BufferedImage b = ImageTools.makeImage(openBytes(id, no), width[series], 
    220220      height[series], 1, false, bpp[series], littleEndian[series]); 
     221    updateMinMax(b, no); 
     222    return b; 
    221223  } 
    222224 
  • trunk/loci/formats/in/OpenlabRawReader.java

    r2288 r2291  
    118118      } 
    119119    } 
    120  
     120    updateMinMax(data, no); 
    121121    return data; 
    122122  } 
     
    126126    throws FormatException, IOException 
    127127  { 
    128     return ImageTools.makeImage(openBytes(id, no), width, height, 
     128    BufferedImage b = ImageTools.makeImage(openBytes(id, no), width, height, 
    129129      !isRGB(id) ? 1 : channels, false, bytesPerPixel, false); 
     130    updateMinMax(b, no); 
     131    return b; 
    130132  } 
    131133 
  • trunk/loci/formats/in/OpenlabReader.java

    r2265 r2291  
    354354      System.arraycopy(tmp, 0, b, 0, b.length); 
    355355    } 
     356    updateMinMax(b, no); 
    356357    return b; 
    357358  } 
     
    369370    bytesPerPixel = b.length / (width[series] * height[series]); 
    370371    if (bytesPerPixel > 3) bytesPerPixel = 3; 
    371     return ImageTools.makeImage(b, width[series], height[series], 
     372    BufferedImage bi = ImageTools.makeImage(b, width[series], height[series], 
    372373      bytesPerPixel == 3 ? 3 : 1, false, 
    373374      bytesPerPixel == 3 ? 1 : bytesPerPixel, false); 
     375    updateMinMax(bi, no); 
     376    return bi; 
    374377  } 
    375378 
  • trunk/loci/formats/in/PerkinElmerReader.java

    r2265 r2291  
    122122    ras.read(b); 
    123123    ras.close(); 
     124    updateMinMax(b, no); 
    124125    return b; 
    125126  } 
     
    143144    byte[] b = openBytes(id, no); 
    144145    int bpp = b.length / (sizeX[0] * sizeY[0]); 
    145     return ImageTools.makeImage(b, sizeX[0], sizeY[0], 1, false, bpp, true); 
     146    BufferedImage bi = ImageTools.makeImage(b, sizeX[0], sizeY[0], 1,  
     147      false, bpp, true); 
     148    updateMinMax(bi, no); 
     149    return bi; 
    146150  } 
    147151 
  • trunk/loci/formats/in/PictReader.java

    r2265 r2291  
    156156    throws FormatException, IOException 
    157157  { 
    158     return ImageTools.getBytes(openImage(id, no), false, no % 3); 
     158    byte[] b = ImageTools.getBytes(openImage(id, no), false, no % 3); 
     159    updateMinMax(b, no); 
     160    return b; 
    159161  } 
    160162 
     
    168170    } 
    169171 
    170     return open(bytes); 
     172    BufferedImage b = open(bytes); 
     173    updateMinMax(b, no); 
     174    return b; 
    171175  } 
    172176 
  • trunk/loci/formats/in/PrairieReader.java

    r2265 r2291  
    173173      throw new FormatException("Invalid image number: " + no); 
    174174    } 
    175     return tiff.openBytes(files[no], 0); 
     175    byte[] b = tiff.openBytes(files[no], 0); 
     176    updateMinMax(b, no); 
     177    return b; 
    176178  } 
    177179 
     
    184186      throw new FormatException("Invalid image number: " + no); 
    185187    } 
    186     return tiff.openImage(files[no], 0); 
     188    BufferedImage b = tiff.openImage(files[no], 0); 
     189    updateMinMax(b, no); 
     190    return b; 
    187191  } 
    188192 
  • trunk/loci/formats/in/QTReader.java

    r2265 r2291  
    352352 
    353353    if (code.equals("jpeg") || code.equals("mjpb")) { 
    354       return ImageTools.getBytes(openImage(id, no), false, no); 
     354      byte[] s = ImageTools.getBytes(openImage(id, no), false, no); 
     355      updateMinMax(s, no); 
     356      return s; 
    355357    } 
    356358 
     
    459461        bytes[i] = (byte) (255 - bytes[i]); 
    460462      } 
    461  
     463      updateMinMax(bytes, no); 
    462464      return bytes; 
    463465    } 
     
    475477        System.arraycopy(data[i], 0, rtn, i * data[0].length, data[i].length); 
    476478      } 
    477  
     479      updateMinMax(rtn, no); 
    478480      return rtn; 
    479481    } 
    480     else return bytes; 
     482    else { 
     483      updateMinMax(bytes, no); 
     484      return bytes; 
     485    } 
    481486  } 
    482487 
     
    531536    canUsePrevious = (prevPixels != null) && (prevPlane == no - 1); 
    532537 
     538    BufferedImage b = null; 
     539 
    533540    if (code.equals("jpeg")) { 
    534       return bufferedJPEG(pixs); 
     541      b = bufferedJPEG(pixs); 
    535542    } 
    536543    else if (code.equals("mjpb")) { 
    537       return mjpbUncompress(pixs); 
     544      b = mjpbUncompress(pixs); 
    538545    } 
    539546    else { 
    540547      int bpp = bitsPerPixel / 8; 
    541548      if (bpp == 3 || bpp == 4 || bpp == 5) bpp = 1; 
    542       return ImageTools.makeImage(openBytes(id, no), flip ? height : width, 
     549      b = ImageTools.makeImage(openBytes(id, no), flip ? height : width, 
    543550        flip ? width : height, isRGB(id) ? 3 : 1, false, bpp, little); 
    544551    } 
     552    updateMinMax(b, no); 
     553    return b; 
    545554  } 
    546555 
  • trunk/loci/formats/in/SDTReader.java

    r2265 r2291  
    177177      } 
    178178    } 
     179    updateMinMax(data, no); 
    179180    return data; 
    180181  } 
     
    184185    throws FormatException, IOException 
    185186  { 
    186     return ImageTools.makeImage(openBytes(id, no), 
     187    BufferedImage b = ImageTools.makeImage(openBytes(id, no), 
    187188      sizeX[series], sizeY[series], 1, false, 2, true); 
     189    updateMinMax(b, no); 
     190    return b; 
    188191  } 
    189192 
  • trunk/loci/formats/in/SlidebookReader.java

    r2271 r2291  
    111111    byte[] b = new byte[width * height * 2]; 
    112112    in.read(b); 
     113    updateMinMax(b, no); 
    113114    return b; 
    114115  } 
     
    118119    throws FormatException, IOException 
    119120  { 
    120     return ImageTools.makeImage(openBytes(id, no), width, height, 1, true, 
    121       bpp, true); 
     121    BufferedImage b = ImageTools.makeImage(openBytes(id, no), width, height,  
     122      1, true, bpp, true); 
     123    updateMinMax(b, no); 
     124    return b; 
    122125  } 
    123126 
  • trunk/loci/formats/in/ZeissLSMReader.java

    r2289 r2291  
    128128 
    129129    ifds = TiffTools.getIFDs(in); 
    130     return TiffTools.getImage(ifds[2*no], in); 
     130    BufferedImage b = TiffTools.getImage(ifds[2*no], in); 
     131    updateMinMax(b, no); 
     132    return b; 
    131133  } 
    132134 
     
    147149      System.arraycopy(p[i], 0, b, i*p[0].length, p[i].length); 
    148150    } 
    149  
     151    updateMinMax(b, no); 
    150152    return b; 
    151153  } 
  • trunk/loci/formats/in/ZeissZVIReader.java

    r2277 r2291  
    284284        System.arraycopy(tmp, 0, a, 0, a.length); 
    285285      } 
     286      updateMinMax(a, no); 
    286287      return a; 
    287288    } 
     
    296297    throws FormatException, IOException 
    297298  { 
    298     if (!id.equals(currentId)) initFile(id); 
    299     if (noPOI || needLegacy) return legacy.openImage(id, no); 
    300     if (no < 0 || no >= getImageCount(id)) { 
    301       throw new FormatException("Invalid image number: " + no); 
    302     } 
    303  
    304     return ImageTools.makeImage(openBytes(id, no), width, height, 
     299    BufferedImage b = ImageTools.makeImage(openBytes(id, no), width, height, 
    305300      isRGB(id) ? 3 : 1, true, bpp == 3 ? 1 : bpp, true, validBits); 
     301    updateMinMax(b, no); 
     302    return b; 
    306303  } 
    307304 
Note: See TracChangeset for help on using the changeset viewer.