Changeset 2288


Ignore:
Timestamp:
02/16/07 08:19:56 (13 years ago)
Author:
melissa
Message:
  • Added "int getRGBChannelCount(String)" to IFormatReader.
  • Enhanced BioRad metadata parsing.
  • Moved channel min/max calculation logic from BaseTiffReader to FormatReader. Note that this is not the final version of the channel min/max changes.
  • Added simple caching scheme to ChannelSeparator.
Location:
trunk/loci/formats
Files:
20 edited

Legend:

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

    r2178 r2288  
    3030/** Logic to automatically separate the channels in a file. */ 
    3131public class ChannelSeparator extends ReaderWrapper { 
     32  
     33  // -- Fields -- 
     34 
     35  /** Last image opened. */ 
     36  private byte[] lastImage; 
     37 
     38  /** Index of last image opened. */ 
     39  private int lastImageIndex = -1; 
    3240 
    3341  // -- Constructors -- 
     
    127135      int channel = no % c; 
    128136 
    129       byte[] sourceBytes = reader.openBytes(id, source); 
    130       return ImageTools.splitChannels(sourceBytes, c, 
     137      if (source != lastImageIndex) { 
     138        lastImage = reader.openBytes(id, source); 
     139        lastImageIndex = source; 
     140      } 
     141 
     142      return ImageTools.splitChannels(lastImage, c, 
    131143        false, isInterleaved(id))[channel]; 
    132144    } 
     
    140152    return ImageTools.scale(openImage(id, no), getThumbSizeX(id), 
    141153      getThumbSizeY(id), true); 
     154  } 
     155 
     156  public void close() { 
     157    lastImage = null; 
     158    lastImageIndex = -1; 
    142159  } 
    143160 
  • trunk/loci/formats/FileStitcher.java

    r2265 r2288  
    274274  /* @see IFormatReader#getEffectiveSizeC(String) */ 
    275275  public int getEffectiveSizeC(String id) throws FormatException, IOException { 
    276     return FormatReader.getEffectiveSizeC(isRGB(id), getSizeC(id)); 
     276    return reader.getEffectiveSizeC(id); 
     277  } 
     278 
     279  /* @see IFormatReader#getRGBChannelCount(String) */ 
     280  public int getRGBChannelCount(String id) throws FormatException, IOException { 
     281    return reader.getRGBChannelCount(id); 
    277282  } 
    278283 
  • trunk/loci/formats/FormatReader.java

    r2280 r2288  
    2626 
    2727import java.awt.image.BufferedImage; 
    28 //import java.awt.image.DataBuffer; 
     28import java.awt.image.WritableRaster; 
    2929import java.io.*; 
    3030import java.lang.reflect.Method; 
     
    3939 
    4040  // -- Constants -- 
     41 
     42  /** Indices into the channel min/max array. */ 
     43  protected static final int MIN = 0; 
     44  protected static final int MAX = 1; 
    4145 
    4246  /** Default thumbnail width and height. */ 
     
    98102 
    99103  /** Dimension fields. */ 
    100   protected int[] sizeX, sizeY, sizeZ, sizeC, sizeT, pixelType; 
     104  protected int[] sizeX, sizeY, sizeZ, sizeC, sizeT, pixelType, rgbChannelCount; 
    101105  protected String[] currentOrder; 
    102106  protected boolean[] orderCertain; 
     107  protected double[][][] channelMinMax; 
    103108 
    104109  /** Whether or not we're doing channel stat calculation (no by default). */ 
     
    154159    sizeC = new int[1]; 
    155160    sizeT = new int[1]; 
     161    rgbChannelCount = new int[1];  
    156162    pixelType = new int[1]; 
    157163    currentOrder = new String[1]; 
     
    228234 
    229235  /* @see IFormatReader#isRGB(String) */ 
    230   public abstract boolean isRGB(String id) 
    231     throws FormatException, IOException; 
     236  public boolean isRGB(String id) throws FormatException, IOException { 
     237    return getRGBChannelCount(id) > 1; 
     238  } 
    232239 
    233240  /* @see IFormatReader#getSizeX(String) */ 
     
    269276  /* @see IFormatReader#getEffectiveSizeC(String) */ 
    270277  public int getEffectiveSizeC(String id) throws FormatException, IOException { 
    271     return getEffectiveSizeC(isRGB(id), getSizeC(id)); 
     278    return getSizeC(id) / getRGBChannelCount(id); 
     279  } 
     280 
     281  /* @see IFormatReader#getRGBChannelCount(String) */ 
     282  public int getRGBChannelCount(String id) throws FormatException, IOException { 
     283    return getSizeC(id) / (getImageCount(id) / (getSizeZ(id) * getSizeT(id))); 
    272284  } 
    273285 
     
    276288    throws FormatException, IOException 
    277289  { 
     290    if (!id.equals(currentId)) initFile(id); 
     291    if (theC < 0 || theC >= getSizeC(id)) { 
     292      throw new FormatException("Invalid channel index: " + theC); 
     293    } 
     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]); 
     300    } 
    278301    return null; 
    279302  } 
     
    283306    throws FormatException, IOException 
    284307  { 
     308    if (!id.equals(currentId)) initFile(id); 
     309    if (theC < 0 || theC >= getSizeC(id)) { 
     310      throw new FormatException("Invalid channel index: " + theC); 
     311    } 
     312    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]); 
     318    } 
    285319    return null; 
    286320  } 
     
    10101044  } 
    10111045 
    1012   /** 
    1013    * Gets the effective size of the C dimension. 
    1014    * @see IFormatReader#getEffectiveSizeC(String) 
    1015    */ 
    1016   public static int getEffectiveSizeC(boolean rgb, int sizeC) { 
    1017     if (sizeC <= 4) { 
    1018       return rgb ? (sizeC + 3) / 4 : sizeC; 
    1019     } 
    1020     else if (sizeC % 3 == 0) return rgb ? sizeC / 3 : sizeC; 
    1021     return rgb ? sizeC / 4 : sizeC; 
     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); 
     1061      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              } 
     1079            } 
     1080          } 
     1081        } 
     1082      } 
     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); 
    10221090  } 
    10231091 
  • trunk/loci/formats/IFormatReader.java

    r2182 r2288  
    7272   */ 
    7373  int getEffectiveSizeC(String id) throws FormatException, IOException; 
     74 
     75  /** Get the number of channels per RGB image (if not RGB, this returns 1). */ 
     76  int getRGBChannelCount(String id) throws FormatException, IOException; 
    7477 
    7578  /** 
  • trunk/loci/formats/ImageReader.java

    r2192 r2288  
    239239  /* @see IFormatReader#getEffectiveSizeC(String) */ 
    240240  public int getEffectiveSizeC(String id) throws FormatException, IOException { 
    241     return FormatReader.getEffectiveSizeC(isRGB(id), getSizeC(id)); 
     241    return getReader(id).getEffectiveSizeC(id); 
     242  } 
     243 
     244  /* @see IFormatReader#getRGBChannelCount(String) */ 
     245  public int getRGBChannelCount(String id) throws FormatException, IOException { 
     246    return getReader(id).getRGBChannelCount(id); 
    242247  } 
    243248 
  • trunk/loci/formats/ReaderWrapper.java

    r2182 r2288  
    9999 
    100100  public int getEffectiveSizeC(String id) throws FormatException, IOException { 
    101     return FormatReader.getEffectiveSizeC(isRGB(id), getSizeC(id)); 
     101    return getSizeC(id) / getRGBChannelCount(id); 
     102  } 
     103  
     104  public int getRGBChannelCount(String id) throws FormatException, IOException { 
     105    return getSizeC(id) / (getImageCount(id) / (getSizeZ(id) * getSizeT(id))); 
    102106  } 
    103107 
  • trunk/loci/formats/in/AVIReader.java

    r2265 r2288  
    102102  } 
    103103 
    104   /** Checks if the images in the file are RGB. */ 
     104  /* @see IFormatReader#isRGB(String) */ 
    105105  public boolean isRGB(String id) throws FormatException, IOException { 
    106106    if (!id.equals(currentId)) initFile(id); 
    107     return (bmpBitsPerPixel > 8); 
     107    return bmpBitsPerPixel > 8; 
    108108  } 
    109109 
  • trunk/loci/formats/in/AliconaReader.java

    r2265 r2288  
    7474  } 
    7575 
    76   /** Checks if the images in the file are RGB. */ 
     76  /* @see IFormatReader#isRGB(String) */ 
    7777  public boolean isRGB(String id) throws FormatException, IOException { 
    7878    return false; 
     
    235235      new Float(((String) getMeta("PlanePntY")).trim()), 
    236236      new Float(((String) getMeta("PlanePntZ")).trim()), null, null, null); 
     237   
    237238  } 
    238239 
  • trunk/loci/formats/in/BMPReader.java

    r2265 r2288  
    9898  } 
    9999 
    100   /** Checks if the images in the file are RGB. */ 
     100  /* @see IFormatReader#isRGB(String) */ 
    101101  public boolean isRGB(String id) throws FormatException, IOException { 
    102102    if (!id.equals(currentId)) initFile(id); 
    103     return (bpp > 8); 
     103    return bpp > 8; 
    104104  } 
    105105 
  • trunk/loci/formats/in/BaseTiffReader.java

    r2265 r2288  
    2929import java.nio.ByteBuffer; 
    3030import java.nio.ShortBuffer; 
    31 import java.util.Hashtable; 
     31import java.util.*; 
    3232import loci.formats.*; 
    3333 
     
    4141public abstract class BaseTiffReader extends FormatReader { 
    4242 
    43   /** The minimum index in the channelMinMax array */ 
    44   private static final int MIN = 0; 
    45  
    46   /** The maximum index in the channelMinMax array */ 
    47   private static final int MAX = 1; 
    48  
    4943  // -- Fields -- 
    5044 
     
    5751  /** Number of images in the current TIFF stack. */ 
    5852  protected int numImages; 
    59  
    60   /** The global min and max for each channel. */ 
    61   protected Double[][] channelMinMax; 
    6253 
    6354  // -- Constructors -- 
     
    562553        try { 
    563554          setLogicalChannel(i); 
    564           if ((getChannelGlobalMinimum(currentId, 0) == null || 
    565             getChannelGlobalMaximum(currentId, 0) == null) && 
    566             enableChannelStatCalculation) 
    567           { 
    568             setChannelGlobalMinMax(i); 
    569           } 
    570555        } 
    571556        catch (FormatException e) { 
     
    657642  } 
    658643 
    659   /** Checks if the images in the file are RGB. */ 
     644  /* @see IFormatReader#isRGB(String) */ 
    660645  public boolean isRGB(String id) throws FormatException, IOException { 
    661646    if (!id.equals(currentId)) initFile(id); 
    662     if (TiffTools.getIFDIntValue(ifds[0], 
     647    if (TiffTools.getIFDIntValue(ifds[0],  
    663648      TiffTools.SAMPLES_PER_PIXEL, false, 1) > 1) 
    664649    { 
    665650      return true; 
    666651    } 
    667     int p = TiffTools.getIFDIntValue(ifds[0], 
     652    int p = TiffTools.getIFDIntValue(ifds[0],  
    668653      TiffTools.PHOTOMETRIC_INTERPRETATION, true, 0); 
    669     return (!isColorTableIgnored() && 
    670       (p == TiffTools.RGB_PALETTE || p == TiffTools.CFA_ARRAY)) || 
    671       p == TiffTools.RGB; 
     654    return (!isColorTableIgnored() && (p == TiffTools.RGB_PALETTE || 
     655      p == TiffTools.CFA_ARRAY)) || p == TiffTools.RGB; 
    672656  } 
    673657 
     
    685669    } 
    686670    return getMeta(field); 
    687   } 
    688  
    689   /* @see loci.formats.IFormatReader#getChannelGlobalMinimum(int) */ 
    690   public Double getChannelGlobalMinimum(String id, int theC) 
    691     throws FormatException, IOException 
    692   { 
    693     if (!id.equals(currentId)) initFile(id); 
    694     if (channelMinMax == null || channelMinMax[theC] == null) 
    695       return null; 
    696     return channelMinMax[theC][MIN]; 
    697   } 
    698  
    699   /* @see loci.formats.IFormatReader#getChannelGlobalMaximum(int) */ 
    700   public Double getChannelGlobalMaximum(String id, int theC) 
    701     throws FormatException, IOException 
    702   { 
    703     if (!id.equals(currentId)) initFile(id); 
    704     if (channelMinMax == null || channelMinMax[theC] == null) 
    705       return null; 
    706     return channelMinMax[theC][MAX]; 
    707671  } 
    708672 
     
    837801 
    838802  // -- Helper methods -- 
    839  
    840   /** 
    841    * Sets the channels global min and max in the metadata store. 
    842    * @param channelIdx the channel to set. 
    843    * @throws FormatException if there is an error parsing metadata. 
    844    * @throws IOException if there is an error reading the file. 
    845    */ 
    846   protected void setChannelGlobalMinMax(int channelIdx) 
    847     throws FormatException, IOException 
    848   { 
    849     getChannelGlobalMinMax(); 
    850     getMetadataStore(currentId).setChannelGlobalMinMax(channelIdx, 
    851         channelMinMax[channelIdx][MIN], channelMinMax[channelIdx][MAX], null); 
    852   } 
    853  
    854   /** 
    855    * Retrieves the global min and max for each channel. 
    856    * @throws FormatException if there is an error parsing metadata. 
    857    * @throws IOException if there is an error reading the file. 
    858    */ 
    859   public void getChannelGlobalMinMax() throws FormatException, IOException { 
    860     if (channelMinMax == null) { 
    861       channelMinMax = new Double[getSizeC(currentId)][2]; 
    862     } 
    863     else return; 
    864  
    865     for (int c = 0; c < getSizeC(currentId); c++) { 
    866       double min = Double.MAX_VALUE; 
    867       double max = Double.MIN_VALUE; 
    868       for (int t = 0; t < getSizeT(currentId); t++) { 
    869         for (int z = 0; z < getSizeZ(currentId); z++) { 
    870           int index = getIndex(currentId, z, isRGB(currentId) ? 0 : c, t); 
    871           WritableRaster pixels = openImage(currentId, index).getRaster(); 
    872           for (int x = 0; x < getSizeX(currentId); x++) { 
    873             for (int y = 0; y < getSizeY(currentId); y++) { 
    874               double pixelValue = pixels.getSampleDouble(x, y,  
    875                 isRGB(currentId) ? c : 0); 
    876               if (pixelValue < min) min = pixelValue; 
    877               if (pixelValue > max) max = pixelValue; 
    878             } 
    879           } 
    880         } 
    881       } 
    882       channelMinMax[c][MIN] = new Double(min); 
    883       channelMinMax[c][MAX] = new Double(max); 
    884     } 
    885   } 
    886803 
    887804  /** 
  • trunk/loci/formats/in/BioRadReader.java

    r2265 r2288  
    7474  private int npic; 
    7575 
    76   /** Dimension order in current Bio-Rad PIC. */ 
    77   private String order; 
    78  
    7976  /** Flag indicating current Bio-Rad PIC is packed with bytes. */ 
    8077  private boolean byteFormat; 
     
    9996  } 
    10097 
    101   /** Checks if the images in the file are RGB. */ 
     98  /* @see IFormatReader#isRGB(String) */ 
    10299  public boolean isRGB(String id) throws FormatException, IOException { 
    103100    return false; 
     
    172169  } 
    173170 
    174   /** Initializes the given IPLab file. */ 
     171  /** Initializes the given Bio-Rad file. */ 
    175172  protected void initFile(String id) throws FormatException, IOException { 
    176173    if (debug) debug("BioRadReader.initFile(" + id + ")"); 
     
    271268      noteCount++; 
    272269 
    273       addMeta("note" + noteCount, 
    274         noteString(num, level, status, type, x, y, text)); 
    275  
     270      switch (type) { 
     271        case 8: // NOTE_TYPE_SCALEBAR 
     272          int eq = text.indexOf("="); 
     273          if (eq != -1) { 
     274            text = text.substring(eq + 1).trim(); 
     275            String len = text.substring(0, text.indexOf(" ")).trim(); 
     276            String angle = text.substring(text.indexOf(" ")).trim(); 
     277            addMeta("Scalebar length (in microns)", len); 
     278            addMeta("Scalebar angle (in degrees)", angle); 
     279          } 
     280          break; 
     281        case 11: // NOTE_TYPE_ARROW 
     282          eq = text.indexOf("="); 
     283          if (eq != -1) { 
     284            text = text.substring(eq + 1).trim(); 
     285            StringTokenizer st = new StringTokenizer(text, " "); 
     286            addMeta("Arrow width", st.nextToken()); 
     287            addMeta("Arrow height", st.nextToken()); 
     288            addMeta("Arrow angle", st.nextToken()); 
     289            addMeta("Arrow fill type", st.nextToken()); 
     290          } 
     291          break; 
     292        case 20: // NOTE_TYPE_VARIABLE 
     293          eq = text.indexOf("="); 
     294          if (eq != -1) { 
     295            String key = text.substring(0, eq); 
     296            String value = text.substring(eq + 1); 
     297            addMeta(key, value); 
     298          } 
     299          break; 
     300        case 21: // NOTE_TYPE_STRUCTURE 
     301          int structType = (x & 0xff00) >> 8; 
     302          int structVersion = x & 0xff; 
     303 
     304          StringTokenizer st = new StringTokenizer(text, " "); 
     305 
     306          String[] keys = new String[0]; 
     307          int idx = 0; 
     308 
     309          switch (y) { 
     310            case 1: 
     311              keys = new String[] {"Scan Channel", "Both Mode", "Speed",  
     312                "Filter", "Factor", "Number of scans",  
     313                "Photon counting mode (channel 1)", 
     314                "Photon counting detector (channel 1)", 
     315                "Photon counting mode (channel 2)",  
     316                "Photon counting detector (channel 2)", "Photon mode",  
     317                "Objective lens magnification", "Zoom factor (user selected)",  
     318                "Motor on", "Z step size"};    
     319              break; 
     320            case 2: 
     321              keys = new String[] {"Z start", "Z stop", "Scan area - cx",  
     322                "Scan area - cy", "Scan area - lx", "Scan area - ly"}; 
     323              break; 
     324            case 3: 
     325              keys = new String[] {"PMT 1 Iris", "PMT 1 Gain",  
     326                "PMT 1 Black level", "PMT 1 Emission filter", "PMT 2 Iris",  
     327                "PMT 2 Gain", "PMT 2 Black level", "PMT 2 Emission filter",  
     328                "PMT 3 Iris", "PMT 3 Gain", "PMT 3 Black level",  
     329                "PMT 3 Emission filter", "Multiplier of channel 1",  
     330                "Multiplier of channel 2", "Multiplier of channel 3"};  
     331              break; 
     332            case 4: 
     333              keys = new String[] {"Number of lasers",  
     334                "Number of transmission detectors", "Number of PMTs",  
     335                "Shutter present for laser 1", 
     336                "Shutter present for laser 2", "Shutter present for laser 3", 
     337                "Neutral density filter for laser 1",  
     338                "Excitation filter for laser 1", "Use laser 1",  
     339                "Neutral density filter for laser 2",  
     340                "Excitation filter for laser 2", "Use laser 2",  
     341                "Neutral density filter for laser 3",  
     342                "Excitation filter for laser 3", "Use laser 3",  
     343                "Neutral density filter name - laser 1",  
     344                "Neutral density filter name - laser 2",  
     345                "Neutral density filter name - laser 3"}; 
     346              break;  
     347            case 5: 
     348              keys = new String[] {"Excitation filter name - laser 1", 
     349                "Excitation filter name - laser 2",  
     350                "Excitation filter name - laser 3"}; 
     351              break; 
     352            case 6: 
     353              keys = new String[] {"Emission filter name - laser 1",  
     354                "Emission filter name - laser 2",  
     355                "Emission filter name - laser 3"};  
     356              break; 
     357            case 7: 
     358              keys = new String[] {"Mixer 0 - enhanced",  
     359                "Mixer 0 - PMT 1 percentage", 
     360                "Mixer 0 - PMT 2 percentage", "Mixer 0 - PMT 3 percentage", 
     361                "Mixer 0 - Transmission 1 percentage",  
     362                "Mixer 0 - Transmission 2 percentage",  
     363                "Mixer 0 - Transmission 3 percentage", "Mixer 1 - enhanced", 
     364                "Mixer 1 - PMT 1 percentage", "Mixer 1 - PMT 2 percentage", 
     365                "Mixer 1 - PMT 3 percentage", 
     366                "Mixer 1 - Transmission 1 percentage", 
     367                "Mixer 1 - Transmission 2 percentage", 
     368                "Mixer 1 - Transmission 3 percentage",  
     369                "Mixer 0 - low signal on", "Mixer 1 - low signal on"}; 
     370              break; 
     371            case 8: 
     372              keys = new String[] {"Laser 1 name"};  
     373              break; 
     374            case 9: 
     375              keys = new String[] {"Laser 2 name"};  
     376              break; 
     377            case 10: 
     378              keys = new String[] {"Laser 3 name"};  
     379              break; 
     380            case 11: 
     381              keys = new String[] {"Transmission detector 1 - offset", 
     382                "Transmission detector 1 - gain",  
     383                "Transmission detector 1 - black level",  
     384                "Transmission detector 2 - offset",  
     385                "Transmission detector 2 - gain",  
     386                "Transmission detector 2 - black level",  
     387                "Transmission detector 3 - offset",  
     388                "Transmission detector 3 - gain",  
     389                "Transmission detector 3 - black level"}; 
     390              break; 
     391            case 12: 
     392              keys = new String[] {"Part number of laser 1",  
     393                "Part number of excitation filter for laser 1",  
     394                "Part number of ND filter for laser 1",  
     395                "Part number of emission filter for laser 1",  
     396                "Part number of laser 2",  
     397                "Part number of excitation filter for laser 2",  
     398                "Part number of ND filter for laser 2",  
     399                "Part number of emission filter for laser 2"};  
     400              break; 
     401            case 13: 
     402              keys = new String[] {"Part number of laser 3",  
     403                "Part number of excitation filter for laser 3",  
     404                "Part number of ND filter for laser 3",  
     405                "Part number of emission filter for laser 3",  
     406                "Part number of filter block 1",  
     407                "Part number of filter block 2", 
     408                "Filter block 1", "Filter block 2"}; 
     409              break; 
     410            case 14: 
     411              keys = new String[] {"Filter block 1 name",  
     412                "Filter block 2 name"}; 
     413              break; 
     414            case 15: 
     415              keys = new String[] {"Image band 1 status", "Image band 1 min",  
     416                "Image band 1 max", "Image band 2 status", "Image band 2 min",  
     417                "Image band 2 max", "Image band 3 status", "Image band 3 min",  
     418                "Image band 3 max", "Image band 4 status", "Image band 4 min",  
     419                "Image band 4 max", "Image band 5 status", "Image band 5 min",  
     420                "Image band 5 max"};  
     421              break; 
     422            case 16: 
     423              keys = new String[] {"Image band 5 status", "Image band 5 min",  
     424                "Image band 5 max"};  
     425              break; 
     426            case 17: 
     427              keys = new String[] {"Date stamp (seconds)",  
     428                "Date stamp (minutes)", 
     429                "Date stamp (hours)", "Date stamp (day of month)", 
     430                "Date stamp (month)", "Date stamp (year: actual year - 1900)", 
     431                "Date stamp (day of week)", "Date stamp (day of year)", 
     432                "Daylight savings?"}; 
     433              break; 
     434            case 18: 
     435              keys = new String[] {"Mixer 3 - enhanced",  
     436                "Mixer 3 - PMT 1 percentage", 
     437                "Mixer 3 - PMT 2 percentage", "Mixer 3 - PMT 3 percentage", 
     438                "Mixer 3 - Transmission 1 percentage",  
     439                "Mixer 3 - Transmission 2 percentage",  
     440                "Mixer 3 - Transmission 3 percentage",  
     441                "Mixer 3 - low signal on", 
     442                "Mixer 3 - photon counting 1", "Mixer 3 - photon counting 2", 
     443                "Mixer 3 - photon counting 3", "Mixer 3 - mode"}; 
     444              break; 
     445            case 19: 
     446              keys = new String[] {"Mixer 1 - photon counting 1",  
     447                "Mixer 1 - photon counting 2", "Mixer 1 - photon counting 3",  
     448                "Mixer 1 - mode", "Mixer2 - photon counting 1",  
     449                "Mixer 2 - photon counting 2", "Mixer 2 - photon counting 3",  
     450                "Mixer 2 - mode"};  
     451              break; 
     452            case 20: 
     453              keys = new String[] {"Display mode", "Course",  
     454                "Time Course - experiment type", 
     455                "Time Course - kd factor"}; 
     456              break; 
     457            case 21: 
     458              keys = new String[] {"Time Course - ion name"};  
     459              break; 
     460            case 22: 
     461              keys = new String[] {"PIC file generated on Isoscan (lite)", 
     462                "Photon counting used (PMT 1)", "Photon counting used (PMT 2)", 
     463                "Photon counting used (PMT 3)", "Hot spot filter used (PMT 1)", 
     464                "Hot spot filter used (PMT 2)", "Hot spot filter used (PMT 3)", 
     465                "Tx selector used (TX 1)", "Tx selected used (TX 2)", 
     466                "Tx selector used (TX 3)"}; 
     467              break; 
     468          } 
     469          while (st.hasMoreTokens() && idx < keys.length) { 
     470            addMeta(keys[idx], st.nextToken()); 
     471            idx++;    
     472          } 
     473          break; 
     474        default: 
     475          addMeta("note" + noteCount,  
     476            noteString(num, level, status, type, x, y, text)); 
     477      } 
     478       
    276479      // if the text of the note contains "AXIS", parse the text 
    277480      // more thoroughly (see pg. 21 of the BioRad specs) 
     
    453656    nz = zSize; 
    454657    nt = tSize; 
    455     order = dimOrder; 
    456658 
    457659    sizeX[0] = nx; 
    458660    sizeY[0] = ny; 
    459     sizeZ[0] = nz; 
    460     sizeC[0] = 1; 
    461     sizeT[0] = nt; 
    462     currentOrder[0] = order; 
     661    sizeZ[0] = zSize; 
     662    sizeC[0] = cSize; 
     663    sizeT[0] = tSize; 
     664    currentOrder[0] = dimOrder; 
     665 
     666    store.setImage(name, null /* creation date */, null /* description */, null); 
     667 
     668    store.setInstrument(null /* manufacturer */, null /* model */, 
     669      null /* serial number */, null /* type */, null); 
     670 
     671    store.setLogicalChannel(0 /* channel index */, null /* name */, 
     672     null /* ND filter */, null /* EM wave */, null /* excitation wavelength */, 
     673     null /* photometric interpretation */, null /* mode */, null); 
     674 
     675    store.setChannelGlobalMinMax(0 /* channel */, null /* double min */, 
     676      null /* double max */, null); 
     677 
     678    // TODO do this for each plane 
     679    //store.setPlaneInfo(theZ, theC, theT, Float timestamp, Float exposureTime, 
     680    //  null); 
    463681 
    464682    store.setPixels( 
     
    481699    if (size >= 3) pixelSizeZ = new Float((String) pixelSize.get(2)); 
    482700    store.setDimensions(pixelSizeX, pixelSizeY, pixelSizeZ, null, null, null); 
     701   
     702    store.setDefaultDisplaySettings(null); 
    483703  } 
    484704 
  • trunk/loci/formats/in/DeltavisionReader.java

    r2265 r2288  
    115115  } 
    116116 
    117   /** Checks if the images in the file are RGB. */ 
    118   public boolean isRGB(String id) throws FormatException, IOException { 
    119     return false; 
    120   } 
    121  
    122117  /** Get the size of the X dimension. */ 
    123118  public int getSizeX(String id) throws FormatException, IOException { 
     
    166161    Float v = (Float) getMeta("Wavelength " + (theC + 1) + " max. intensity"); 
    167162    return new Double(v.floatValue()); 
     163  } 
     164 
     165  /* @see IFormatReader#isRGB(String) */ 
     166  public boolean isRGB(String id) throws FormatException, IOException { 
     167    return false; 
    168168  } 
    169169 
  • trunk/loci/formats/in/DicomReader.java

    r2265 r2288  
    391391    sizeT[0] = 1; 
    392392    currentOrder[0] = "XYZTC"; 
     393    rgbChannelCount[0] = sizeC[0]; 
    393394 
    394395    // The metadata store we're working with. 
  • trunk/loci/formats/in/EPSReader.java

    r2265 r2288  
    264264    sizeT[0] = 1; 
    265265    currentOrder[0] = "XYCZT"; 
     266    rgbChannelCount[0] = sizeC[0]; 
    266267 
    267268    // Populate metadata store 
  • trunk/loci/formats/in/GelReader.java

    r2178 r2288  
    9797 
    9898    sizeT[series] = numImages; 
     99   
     100    try { 
     101      MetadataStore store = getMetadataStore(currentId); 
     102      store.setDimensions(new Float(scale.floatValue()),  
     103        new Float(scale.floatValue()), null, null, null, null); 
     104    } 
     105    catch (IOException e) { 
     106      throw new FormatException(e); 
     107    } 
    99108  } 
    100109 
  • trunk/loci/formats/in/IPLabReader.java

    r2265 r2288  
    374374          addMeta("NormalizationBlack" + i, new Double(black)); 
    375375          addMeta("NormalizationWhite" + i, new Double(white)); 
     376         
     377          store = getMetadataStore(currentId); 
     378          store.setChannelGlobalMinMax(i, new Double(min),  
     379            new Double(max), null); 
     380          // TODO : set DisplayChannel here 
    376381        } 
    377382      } 
  • trunk/loci/formats/in/ImarisReader.java

    r2265 r2288  
    107107    float dy = in.readFloat(); 
    108108    float dz = in.readFloat(); 
    109     in.readShort(); 
     109    int mag = in.readShort(); // TODO : set Objective:Magnification 
    110110 
    111111    byte[] com = new byte[128]; 
  • trunk/loci/formats/in/MetamorphReader.java

    r2219 r2288  
    103103      return false; // we went through the IFD; the ID wasn't found. 
    104104    } 
     105  } 
     106 
     107  /* @see IFormatReader#getChannelGlobalMinimum(String, int) */ 
     108  public Double getChannelGlobalMinimum(String id, int theC) 
     109    throws FormatException, IOException 
     110  { 
     111    if (!id.equals(currentId)) initFile(id); 
     112    return (Double) getMeta("grayMin"); 
     113  } 
     114 
     115  /* @see IFormatReader#getChannelGlobalMaximum(String, int) */ 
     116  public Double getChannelGlobalMaximum(String id, int theC) 
     117    throws FormatException, IOException 
     118  { 
     119    if (!id.equals(currentId)) initFile(id); 
     120    return (Double) getMeta("grayMax"); 
    105121  } 
    106122 
     
    315331  } 
    316332 
    317   protected void setChannelGlobalMinMax(int i) 
    318     throws FormatException, IOException 
    319   { 
    320     Double globalMin = (Double) getMeta("grayMin"); 
    321     Double globalMax = (Double) getMeta("grayMax"); 
    322     if (globalMin != null || globalMax != null) { 
    323       getMetadataStore(currentId).setChannelGlobalMinMax(i, 
    324         globalMin, globalMax, null); 
    325     } 
    326     super.setChannelGlobalMinMax(i); 
    327   } 
    328  
    329333  Integer getEmWave(int i) { 
    330334    if (emWavelength[i] == 0)  return null; 
  • trunk/loci/formats/in/OpenlabRawReader.java

    r2265 r2288  
    168168    width = in.readInt(); 
    169169    height = in.readInt(); 
    170     in.readShort(); 
     170    in.read(); 
     171    //bytesPerPixel = in.read(); 
     172    //channels = in.read(); 
     173    channels = in.read(); 
    171174    bytesPerPixel = in.read(); 
    172     channels = in.read(); 
     175    in.read(); 
     176    addMeta("Timestamp", "" + in.readLong()); 
     177    in.skipBytes(4); 
     178    byte[] s = new byte[256]; 
     179    in.read(s); 
     180    ///* debug */ System.out.println("name : " + new String(s).trim()); 
     181    int len = s[0] > 0 ? s[0] : (s[0] + 256); 
     182    addMeta("Image name", new String(s, 1, len).trim()); 
    173183 
    174184    if (channels <= 1) channels = 1; 
  • trunk/loci/formats/in/ZeissLSMReader.java

    r2265 r2288  
    163163 
    164164    int numThumbs = 0; 
    165     //try { 
    166       long prevOffset = 0; 
    167       byte[] b = new byte[48]; 
    168       byte[] c = new byte[48]; 
    169       for (int i=0; i<ifds.length; i++) { 
    170         long subFileType = TiffTools.getIFDLongValue(ifds[i], 
    171           TiffTools.NEW_SUBFILE_TYPE, true, 0); 
    172         long[] offsets = TiffTools.getStripOffsets(ifds[i]); 
    173  
    174         if (subFileType == 1) { 
    175           ifds[i] = null; 
    176           numThumbs++; 
    177         } 
    178         else if (i > 0) { 
    179           // make sure that we don't grab the thumbnail by accident 
    180           // there's probably a better way to do this 
    181  
    182           in.seek(prevOffset); 
    183           in.read(b); 
    184           in.seek(offsets[0]); 
    185           in.read(c); 
    186  
    187           boolean equal = true; 
    188           for (int j=0; j<48; j++) { 
    189             if (b[j] != c[j]) { 
    190               equal = false; 
    191               j = 48; 
    192             } 
     165    long prevOffset = 0; 
     166    byte[] b = new byte[48]; 
     167    byte[] c = new byte[48]; 
     168    for (int i=0; i<ifds.length; i++) { 
     169      long subFileType = TiffTools.getIFDLongValue(ifds[i], 
     170        TiffTools.NEW_SUBFILE_TYPE, true, 0); 
     171      long[] offsets = TiffTools.getStripOffsets(ifds[i]); 
     172 
     173      if (subFileType == 1) { 
     174        ifds[i] = null; 
     175        numThumbs++; 
     176      } 
     177      else if (i > 0) { 
     178        // make sure that we don't grab the thumbnail by accident 
     179        // there's probably a better way to do this 
     180 
     181        in.seek(prevOffset); 
     182        in.read(b); 
     183        in.seek(offsets[0]); 
     184        in.read(c); 
     185 
     186        boolean equal = true; 
     187        for (int j=0; j<48; j++) { 
     188          if (b[j] != c[j]) { 
     189            equal = false; 
     190            j = 48; 
    193191          } 
    194  
    195           if (equal) { 
    196             offsets[0] += (offsets[0] - prevOffset); 
    197             TiffTools.putIFDValue(ifds[i], TiffTools.STRIP_OFFSETS, offsets); 
    198           } 
    199         } 
    200         prevOffset = offsets[0]; 
    201       } 
    202     /* 
    203     } 
    204     catch (Exception e) { 
    205       // CTR TODO - eliminate catch-all exception handling 
    206       if (debug) e.printStackTrace(); 
    207     } 
    208     */ 
     192        } 
     193 
     194        if (equal) { 
     195          offsets[0] += (offsets[0] - prevOffset); 
     196          TiffTools.putIFDValue(ifds[i], TiffTools.STRIP_OFFSETS, offsets); 
     197        } 
     198      } 
     199      prevOffset = offsets[0]; 
     200    } 
    209201 
    210202    // now copy ifds to a temp array so that we can get rid of 
     
    460452 
    461453      sizeC[0] = channels; 
     454      sizeZ[0] = zSize; 
     455      sizeT[0] = tSize; 
    462456      while (numImages > zSize * tSize * getEffectiveSizeC(currentId)) { 
    463457        numImages--; 
     
    674668      if (debug) e.printStackTrace(); 
    675669    } 
    676     /* 
    677     catch (Exception e) { 
    678       // CTR TODO - eliminate catch-all exception handling 
    679       if (debug) e.printStackTrace(); 
    680     } 
    681     */ 
    682670 
    683671    sizeZ[0] = zSize > 0 ? zSize : 1; 
Note: See TracChangeset for help on using the changeset viewer.