Changeset 2320


Ignore:
Timestamp:
02/22/07 16:58:14 (13 years ago)
Author:
curtis
Message:

Whitespace.

Location:
trunk/loci/formats
Files:
51 edited

Legend:

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

    r2307 r2320  
    237237  } 
    238238 
    239   /* @see MetadataStore#setImagingEnvironment(Float, Float, Float,  
    240    * Float, Integer)  
     239  /* @see MetadataStore#setImagingEnvironment(Float, Float, Float, 
     240   * Float, Integer) 
    241241   */ 
    242242  public void setImagingEnvironment(Float temperature, Float airPressure, 
     
    245245    for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    246246      MetadataStore s = (MetadataStore) iter.next(); 
    247       s.setImagingEnvironment(temperature, airPressure, humidity,  
     247      s.setImagingEnvironment(temperature, airPressure, humidity, 
    248248        co2Percent, i); 
    249249    } 
     
    280280  } 
    281281 
    282   /* @see MetadataStore#setLightSource(String, String, String,  
    283    * Integer, Integer)  
     282  /* @see MetadataStore#setLightSource(String, String, String, 
     283   * Integer, Integer) 
    284284   */ 
    285285  public void setLightSource(String manufacturer, String model, 
     
    288288    for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    289289      MetadataStore s = (MetadataStore) iter.next(); 
    290       s.setLightSource(manufacturer, model, serialNumber, instrumentNdx,  
     290      s.setLightSource(manufacturer, model, serialNumber, instrumentNdx, 
    291291        lightNdx); 
    292292    } 
     
    308308 
    309309  /* @see MetadataStore#setFilament(String, Float, Integer, Integer) */ 
    310   public void setFilament(String type, Float power, Integer lightNdx,  
    311     Integer filamentNdx)  
    312   {  
     310  public void setFilament(String type, Float power, Integer lightNdx, 
     311    Integer filamentNdx) 
     312  { 
    313313    for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    314314      MetadataStore s = (MetadataStore) iter.next(); 
     
    340340  } 
    341341 
    342   /* @see MetadataStore#setObjective(String, String, String, Float, Float,  
    343    * Integer, Integer)  
    344    */ 
    345   public void setObjective(String manufacturer, String model,  
    346     String serialNumber, Float lensNA, Float magnification,  
     342  /* @see MetadataStore#setObjective(String, String, String, Float, Float, 
     343   * Integer, Integer) 
     344   */ 
     345  public void setObjective(String manufacturer, String model, 
     346    String serialNumber, Float lensNA, Float magnification, 
    347347    Integer instrumentNdx, Integer objectiveNdx) 
    348348  { 
    349349    for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    350350      MetadataStore s = (MetadataStore) iter.next(); 
    351       s.setObjective(manufacturer, model, serialNumber, lensNA, magnification,  
     351      s.setObjective(manufacturer, model, serialNumber, lensNA, magnification, 
    352352        instrumentNdx, objectiveNdx); 
    353353    } 
     
    376376  } 
    377377 
    378   /* @see MetadataStore#setEmissionFilter(String, String, String,  
     378  /* @see MetadataStore#setEmissionFilter(String, String, String, 
    379379   * String, Integer) 
    380380   */ 
     
    388388  } 
    389389 
    390   /* @see MetadataStore#setFilterSet(String, String, String, Integer,  
    391    * Integer)  
     390  /* @see MetadataStore#setFilterSet(String, String, String, Integer, 
     391   * Integer) 
    392392   */ 
    393393  public void setFilterSet(String manufacturer, String model, String lotNumber, 
     
    400400  } 
    401401 
    402   /* @see MetadataStore#setOTF(Integer, Integer, String, String,  
     402  /* @see MetadataStore#setOTF(Integer, Integer, String, String, 
    403403   * Boolean, Integer, Integer, Integer, Integer) 
    404404   */ 
  • trunk/loci/formats/ChannelMerger.java

    r2307 r2320  
    5757 
    5858  /* @see IFormatReader#getDimensionOrder(String) */ 
    59   public String getDimensionOrder(String id)  
     59  public String getDimensionOrder(String id) 
    6060    throws FormatException, IOException 
    6161  { 
  • trunk/loci/formats/ChannelSeparator.java

    r2288 r2320  
    3030/** Logic to automatically separate the channels in a file. */ 
    3131public class ChannelSeparator extends ReaderWrapper { 
    32   
     32 
    3333  // -- Fields -- 
    3434 
     
    5151  /** Determines the number of images in the given file. */ 
    5252  public int getImageCount(String id) throws FormatException, IOException { 
    53     return reader.isRGB(id) ?  
     53    return reader.isRGB(id) ? 
    5454      (getSizeC(id) / reader.getEffectiveSizeC(id)) * reader.getImageCount(id) : 
    5555      reader.getImageCount(id); 
  • trunk/loci/formats/DummyMetadataStore.java

    r2307 r2320  
    124124  } 
    125125 
    126   public void setFilament(String type, Float power, Integer lightNdx,  
    127     Integer filamentNdx)  
    128   {  
     126  public void setFilament(String type, Float power, Integer lightNdx, 
     127    Integer filamentNdx) 
     128  { 
    129129  } 
    130130 
    131131  public void setArc(String type, Float power, Integer lightNdx, Integer arcNdx) 
    132   {  
     132  { 
    133133  } 
    134134 
     
    139139  } 
    140140 
    141   public void setObjective(String manufacturer, String model,  
    142     String serialNumber, Float lensNA, Float magnification,  
     141  public void setObjective(String manufacturer, String model, 
     142    String serialNumber, Float lensNA, Float magnification, 
    143143    Integer instrumentNdx, Integer objectiveNdx) 
    144144  { 
  • trunk/loci/formats/FileStitcher.java

    r2315 r2320  
    109109  public FileStitcher() { this(new ImageReader()); } 
    110110 
    111   /**  
    112    * Constructs a FileStitcher around a new image reader.  
     111  /** 
     112   * Constructs a FileStitcher around a new image reader. 
    113113   * @param patternIds Whether string ids given should be treated as file 
    114114   *    patterns rather than single file paths. 
     
    348348    int[] q = computeIndices(id, no); 
    349349    int fno = q[0], ino = q[1]; 
    350     return readers[fno].getPlaneMinimum(files[fno], ino);  
     350    return readers[fno].getPlaneMinimum(files[fno], ino); 
    351351  } 
    352352 
     
    357357    int[] q = computeIndices(id, no); 
    358358    int fno = q[0], ino = q[1]; 
    359     return readers[fno].getPlaneMaximum(files[fno], ino);  
     359    return readers[fno].getPlaneMaximum(files[fno], ino); 
    360360  } 
    361361 
     
    572572        usedFiles = new String[total]; 
    573573        for (int i=0, off=0; i<used.length; i++) { 
    574           System.arraycopy(used[i], 0, usedFiles, off, used[i].length);  
     574          System.arraycopy(used[i], 0, usedFiles, off, used[i].length); 
    575575          off += used[i].length; 
    576576        } 
     
    812812    } 
    813813    setSeries(currentId, oldSeries); 
    814    
     814 
    815815    // initialize used files list only when requested 
    816816    usedFiles = null; 
     
    902902    } 
    903903    int fno = positionToRaster(count, pos); 
    904     int ino = FormatReader.getIndex(order[sno], sizeZ[sno],  
    905       reader.getEffectiveSizeC(files[0]), sizeT[sno], imagesPerFile[sno],  
     904    int ino = FormatReader.getIndex(order[sno], sizeZ[sno], 
     905      reader.getEffectiveSizeC(files[0]), sizeT[sno], imagesPerFile[sno], 
    906906      posZ[0], posC[0], posT[0]); 
    907907 
  • trunk/loci/formats/FormatReader.java

    r2317 r2320  
    111111  /** Whether or not we're doing channel stat calculation (no by default). */ 
    112112  protected boolean enableChannelStatCalculation = false; 
    113    
     113 
    114114  /** List of image indices that have been read. */ 
    115115  protected Vector[] imagesRead; 
     
    181181    sizeC = new int[1]; 
    182182    sizeT = new int[1]; 
    183     rgbChannelCount = new int[1];  
     183    rgbChannelCount = new int[1]; 
    184184    pixelType = new int[1]; 
    185185    currentOrder = new String[1]; 
     
    333333    return null; 
    334334  } 
    335    
     335 
    336336  /* @see IFormatReader#getChannelKnownMinimum(String, int) */ 
    337   public Double getChannelKnownMinimum(String id, int theC)  
     337  public Double getChannelKnownMinimum(String id, int theC) 
    338338    throws FormatException, IOException 
    339339  { 
     
    357357 
    358358  /* @see IFormatReader#getPlaneMinimum(String, int) */ 
    359   public Double getPlaneMinimum(String id, int no)  
    360     throws FormatException, IOException 
    361   { 
    362     if (!id.equals(currentId)) initFile(id); 
    363     if (enableChannelStatCalculation &&  
    364       imagesRead[series].contains(new Integer(no)))  
     359  public Double getPlaneMinimum(String id, int no) 
     360    throws FormatException, IOException 
     361  { 
     362    if (!id.equals(currentId)) initFile(id); 
     363    if (enableChannelStatCalculation && 
     364      imagesRead[series].contains(new Integer(no))) 
    365365    { 
    366366      int ndx = no * getRGBChannelCount(id); 
     
    381381  { 
    382382    if (!id.equals(currentId)) initFile(id); 
    383     if (enableChannelStatCalculation &&  
    384       imagesRead[series].contains(new Integer(no)))  
     383    if (enableChannelStatCalculation && 
     384      imagesRead[series].contains(new Integer(no))) 
    385385    { 
    386386      int ndx = no * getRGBChannelCount(id); 
     
    11541154  } 
    11551155 
    1156   /**  
     1156  /** 
    11571157   * Updates min/max values based on the given BufferedImage. 
    11581158   * Should be called by each format reader's openImage method. 
    11591159   */ 
    1160   public void updateMinMax(BufferedImage b, int ndx)  
     1160  public void updateMinMax(BufferedImage b, int ndx) 
    11611161    throws FormatException, IOException 
    11621162  { 
     
    11641164    if (!imagesRead[series].contains(ii) && enableChannelStatCalculation) { 
    11651165      if (channelMinMax == null) { 
    1166         channelMinMax =  
     1166        channelMinMax = 
    11671167          new double[getSeriesCount(currentId)][getSizeC(currentId)][2]; 
    11681168      } 
     
    12061206   * Should be called by each format reader's openBytes method. 
    12071207   */ 
    1208   public void updateMinMax(byte[] b, int ndx)  
    1209     throws FormatException, IOException  
     1208  public void updateMinMax(byte[] b, int ndx) 
     1209    throws FormatException, IOException 
    12101210  { 
    12111211    if (b == null) return; 
     
    12131213    if (!imagesRead[series].contains(ii) && enableChannelStatCalculation) { 
    12141214      if (channelMinMax == null) { 
    1215         channelMinMax =  
     1215        channelMinMax = 
    12161216          new double[getSeriesCount(currentId)][getSizeC(currentId)][2]; 
    12171217      } 
     
    12201220          getSizeZ(currentId) * getSizeC(currentId) * getSizeT(currentId)][2]; 
    12211221      } 
    1222        
     1222 
    12231223      boolean little = isLittleEndian(currentId); 
    12241224      int bytes = getBytesPerPixel(getPixelType(currentId)); 
     
    12351235          idx *= bytes; 
    12361236          System.arraycopy(b, idx, value, 0, bytes); 
    1237           double v =  
     1237          double v = 
    12381238            Double.longBitsToDouble(DataTools.bytesToLong(value, little)); 
    12391239          if (v > channelMinMax[series][coords[1]*numRGB + c][MAX]) { 
  • trunk/loci/formats/FormatWriter.java

    r2182 r2320  
    9999  /* @see IFormatWriter#getPixelTypes(String) */ 
    100100  public int[] getPixelTypes(String id) throws FormatException, IOException { 
    101     return new int[] {FormatReader.UINT8, FormatReader.UINT16,  
     101    return new int[] {FormatReader.UINT8, FormatReader.UINT16, 
    102102      FormatReader.UINT32, FormatReader.FLOAT}; 
    103103  } 
    104104 
    105105  /* @see IFormatWriter#isSupportedType(String, int) */ 
    106   public boolean isSupportedType(String id, int type)  
     106  public boolean isSupportedType(String id, int type) 
    107107    throws FormatException, IOException 
    108108  { 
  • trunk/loci/formats/IFormatReader.java

    r2291 r2320  
    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. 
     80   * Returns null if channel stat calculation is disabled or if some of the 
     81   * image planes have not been read. 
    8282   * @param id the filename of the base image. 
    8383   * @param theC the channel whose minimum is required. 
     
    9696  /** 
    9797   * 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. 
     98   * Returns null if channel stat calculation is disabled or if some of the 
     99   * image planes have not been read. 
    100100   * @param id the filename of the base image. 
    101101   * @param theC the channel whose maximum is required. 
     
    120120    throws FormatException, IOException; 
    121121 
    122  
    123122  /** 
    124123   * Retrieves the specified channel's maximum based on the images that have 
     
    129128    throws FormatException, IOException; 
    130129 
    131   /**  
     130  /** 
    132131   * Retrieves the minimum pixel value for the specified plane. 
    133132   * Returns null if the plane has not already been read. 
     
    142141 
    143142  /** 
    144    * Returns true if the values returned by getChannelGlobalMinimum/Maximum  
     143   * Returns true if the values returned by getChannelGlobalMinimum/Maximum 
    145144   * can be trusted. 
    146145   */ 
     
    219218  byte[] openThumbBytes(String id, int no) throws FormatException, IOException; 
    220219 
    221   /**  
     220  /** 
    222221   * Closes the currently open file. If the flag is set, this is all that 
    223222   * happens; if unset, it is equivalent to calling close(). 
     
    225224  void close(boolean fileOnly) throws FormatException, IOException; 
    226225 
    227   /**  
    228    * Closes the currently open file and frees memory  
    229    * allocated by this reader.  
     226  /** 
     227   * Closes the currently open file and frees memory 
     228   * allocated by this reader. 
    230229   */ 
    231230  void close() throws FormatException, IOException; 
  • trunk/loci/formats/IFormatWriter.java

    r2182 r2320  
    6464 
    6565  /** Checks if the given pixel type is supported. */ 
    66   boolean isSupportedType(String id, int type)  
     66  boolean isSupportedType(String id, int type) 
    6767    throws FormatException, IOException; 
    68    
     68 
    6969  /** Sets the current compression type. */ 
    7070  void setCompression(String compress) throws FormatException; 
  • trunk/loci/formats/ImageReader.java

    r2291 r2320  
    276276 
    277277  /* @see IFormatReader#getPlaneMinimum(String, int) */ 
    278   public Double getPlaneMinimum(String id, int no)  
     278  public Double getPlaneMinimum(String id, int no) 
    279279    throws FormatException, IOException 
    280280  { 
     
    290290 
    291291  /* @see IFormatReader#isMinMaxPopulated(String) */ 
    292   public boolean isMinMaxPopulated(String id)  
     292  public boolean isMinMaxPopulated(String id) 
    293293    throws FormatException, IOException 
    294294  { 
  • trunk/loci/formats/ImageWriter.java

    r2182 r2320  
    239239 
    240240  /* @see IFormatWriter#isSupportedType(String, int) */ 
    241   public boolean isSupportedType(String id, int type)  
    242     throws FormatException, IOException  
     241  public boolean isSupportedType(String id, int type) 
     242    throws FormatException, IOException 
    243243  { 
    244244    return getWriter(id).isSupportedType(id, type); 
  • trunk/loci/formats/JPEGCompressor.java

    r2178 r2320  
    5454 
    5555  /** 
    56    * Decodes an image strip using JPEG compression algorithm  
     56   * Decodes an image strip using JPEG compression algorithm 
    5757   * 
    5858   * @param b input data to be decompressed 
     
    7171      return null; 
    7272    } 
    73        
    7473 
    7574    byte[][] buf = ImageTools.getBytes(b); 
  • trunk/loci/formats/LegacyQTTools.java

    r2279 r2320  
    149149      } 
    150150    } 
    151     catch (Throwable t) {  
    152       noQT = true;  
     151    catch (Throwable t) { 
     152      noQT = true; 
    153153    } 
    154154    finally { 
  • trunk/loci/formats/MetadataStore.java

    r2307 r2320  
    250250 
    251251  /** Sets various display options for a particular pixels set. */ 
    252   void setDisplayOptions(Float zoom, Boolean redChannelOn,  
     252  void setDisplayOptions(Float zoom, Boolean redChannelOn, 
    253253    Boolean greenChannelOn, Boolean blueChannelOn, Boolean displayRGB, 
    254     String colorMap, Integer zstart, Integer zstop, Integer tstart,  
     254    String colorMap, Integer zstart, Integer zstop, Integer tstart, 
    255255    Integer tstop, Integer imageNdx, Integer pixelsNdx, Integer redChannel, 
    256256    Integer greenChannel, Integer blueChannel, Integer grayChannel); 
    257257 
    258258  /** Sets a light source for a particular instrument. */ 
    259   void setLightSource(String manufacturer, String model, String serialNumber,  
     259  void setLightSource(String manufacturer, String model, String serialNumber, 
    260260    Integer instrumentIndex, Integer lightIndex); 
    261261 
     
    266266 
    267267  /** Sets a filament for a particular instrument. */ 
    268   void setFilament(String type, Float power, Integer lightNdx,  
     268  void setFilament(String type, Float power, Integer lightNdx, 
    269269    Integer filamentNdx); 
    270270 
    271271  /** Sets an arc for a particular instrument. */ 
    272272  void setArc(String type, Float power, Integer lightNdx, Integer arcNdx); 
    273   
     273 
    274274  /** Sets a detector for a particular instrument. */ 
    275275  void setDetector(String manufacturer, String model, String serialNumber, 
     
    279279  /** Sets an objective for a particular instrument. */ 
    280280  void setObjective(String manufacturer, String model, String serialNumber, 
    281     Float lensNA, Float magnification, Integer instrumentNdx,  
     281    Float lensNA, Float magnification, Integer instrumentNdx, 
    282282    Integer objectiveNdx); 
    283283 
     
    287287 
    288288  /** Sets a dichroic for a particular instrument. */ 
    289   void setDichroic(String manufacturer, String model, String lotNumber,  
     289  void setDichroic(String manufacturer, String model, String lotNumber, 
    290290    Integer dichroicNdx); 
    291291 
     
    295295 
    296296  /** Sets a filter set for a particular instrument. */ 
    297   void setFilterSet(String manufacturer, String model, String lotNumber,  
     297  void setFilterSet(String manufacturer, String model, String lotNumber, 
    298298    Integer filterSetNdx, Integer filterNdx); 
    299299 
  • trunk/loci/formats/OMEXMLMetadataStore.java

    r2307 r2320  
    7878  } 
    7979 
    80   /**  
     80  /** 
    8181   * Copies all of the data from this OMEXMLMetadataStore to a different 
    8282   * MetadataStore. 
     
    444444    int img = imageNo == null ? 0 : imageNo.intValue(); 
    445445    int pix = pixelsNo == null ? 0 : pixelsNo.intValue(); 
    446     
     446 
    447447    ImageNode image = (ImageNode) getChild(root, "Image", img); 
    448448    CustomAttributesNode ca = (CustomAttributesNode) 
     
    616616  } 
    617617 
    618  
    619618  /* @see MetadataStore#setImagingEnvironment(Float, Float, Float, 
    620619   * Float, Integer) 
     
    627626    CustomAttributesNode ca = (CustomAttributesNode) 
    628627      getChild(image, "CustomAttributes", 0); 
    629     ImagingEnvironmentNode env =  
     628    ImagingEnvironmentNode env = 
    630629      (ImagingEnvironmentNode) getChild(ca, "ImagingEnvironment", 0); 
    631630    env.setTemperature(temperature); 
     
    645644    CustomAttributesNode ca = (CustomAttributesNode) 
    646645      getChild(image, "CustomAttributes", 0); 
    647     DisplayChannelNode display = (DisplayChannelNode)  
    648       getChild(ca, "DisplayChannel", channelNumber.intValue());     
     646    DisplayChannelNode display = (DisplayChannelNode) 
     647      getChild(ca, "DisplayChannel", channelNumber.intValue()); 
    649648    display.setChannelNumber(channelNumber); 
    650649    display.setBlackLevel(blackLevel); 
     
    660659    Boolean greenChannelOn, Boolean blueChannelOn, Boolean displayRGB, 
    661660    String colorMap, Integer zstart, Integer zstop, Integer tstart, 
    662     Integer tstop, Integer imageNdx, Integer pixelsNdx, Integer redChannel,  
     661    Integer tstop, Integer imageNdx, Integer pixelsNdx, Integer redChannel, 
    663662    Integer greenChannel, Integer blueChannel, Integer grayChannel) 
    664663  { 
    665664    int ndx = imageNdx == null ? 0 : imageNdx.intValue(); 
    666665    int pixNdx = pixelsNdx == null ? 0 : pixelsNdx.intValue(); 
    667      
     666 
    668667    ImageNode image = (ImageNode) getChild(root, "Image", ndx); 
    669668    CustomAttributesNode ca = (CustomAttributesNode) 
     
    672671    DisplayChannelNode red = redChannel == null ? null : (DisplayChannelNode) 
    673672      getChild(ca, "DisplayChannel", redChannel.intValue()); 
    674     DisplayChannelNode green = greenChannel == null ? null :  
    675       (DisplayChannelNode) getChild(ca, "DisplayChannel",  
     673    DisplayChannelNode green = greenChannel == null ? null : 
     674      (DisplayChannelNode) getChild(ca, "DisplayChannel", 
    676675      greenChannel.intValue()); 
    677676    DisplayChannelNode blue = blueChannel == null ? null : (DisplayChannelNode) 
     
    699698  } 
    700699 
    701   /* @see MetadataStore#setLightSource(String, String, String,  
    702    * Integer, Integer)  
     700  /* @see MetadataStore#setLightSource(String, String, String, 
     701   * Integer, Integer) 
    703702   */ 
    704703  public void setLightSource(String manufacturer, String model, 
     
    710709      getChild(root, "CustomAttributes", 0); 
    711710    InstrumentNode inst = (InstrumentNode) getChild(ca, "Instrument", ndx); 
    712     LightSourceNode light =  
     711    LightSourceNode light = 
    713712      (LightSourceNode) getChild(ca, "LightSource", lightNdx); 
    714713    light.setManufacturer(manufacturer); 
     
    732731    CustomAttributesNode ca = (CustomAttributesNode) 
    733732      getChild(root, "CustomAttributes", 0); 
    734     LightSourceNode lightNode =  
     733    LightSourceNode lightNode = 
    735734      (LightSourceNode) getChild(ca, "LightSource", light); 
    736735    LightSourceNode pumpNode = 
    737736      (LightSourceNode) getChild(ca, "LightSource", pump); 
    738737    LaserNode laser = (LaserNode) getChild(ca, "Laser", laserNdx); 
    739      
     738 
    740739    laser.setType(type); 
    741740    laser.setMedium(medium); 
     
    750749 
    751750  /* @see MetadataStore#setFilament(String, Float, Integer, Integer) */ 
    752   public void setFilament(String type, Float power, Integer lightSource,  
    753     Integer num)  
    754   {  
     751  public void setFilament(String type, Float power, Integer lightSource, 
     752    Integer num) 
     753  { 
    755754    int lightNdx = lightSource == null ? 0 : lightSource.intValue(); 
    756755    int n = num == null ? 0 : num.intValue(); 
     
    758757    CustomAttributesNode ca = (CustomAttributesNode) 
    759758      getChild(root, "CustomAttributes", 0); 
    760     LightSourceNode light =  
     759    LightSourceNode light = 
    761760      (LightSourceNode) getChild(ca, "LightSource", lightNdx); 
    762761 
     
    768767 
    769768  /* @see MetadataStore#setArc(String, Float, Integer, Integer) */ 
    770   public void setArc(String type, Float power, Integer lightSource,  
    771     Integer num)  
    772   {  
     769  public void setArc(String type, Float power, Integer lightSource, 
     770    Integer num) 
     771  { 
    773772    int lightNdx = lightSource == null ? 0 : lightSource.intValue(); 
    774773    int n = num == null ? 0 : num.intValue(); 
     
    776775    CustomAttributesNode ca = (CustomAttributesNode) 
    777776      getChild(root, "CustomAttributes", 0); 
    778     LightSourceNode light =  
     777    LightSourceNode light = 
    779778      (LightSourceNode) getChild(ca, "LightSource", lightNdx); 
    780779    ArcNode arc = (ArcNode) getChild(ca, "Arc", n); 
     
    793792    int ndx = instrumentNdx == null ? 0 : instrumentNdx.intValue(); 
    794793    int dNdx = detectorNdx == null ? 0 : detectorNdx.intValue(); 
    795   
     794 
    796795    CustomAttributesNode ca = (CustomAttributesNode) 
    797796      getChild(root, "CustomAttributes", 0); 
     
    808807  } 
    809808 
    810   /* @see MetadataStore#setObjective(String, String, String, Float, Float,  
    811    * Integer, Integer)  
    812    */ 
    813   public void setObjective(String manufacturer, String model,  
     809  /* @see MetadataStore#setObjective(String, String, String, Float, Float, 
     810   * Integer, Integer) 
     811   */ 
     812  public void setObjective(String manufacturer, String model, 
    814813    String serialNumber, Float lensNA, 
    815814    Float magnification, Integer instrument, Integer objective) 
     
    830829  } 
    831830 
    832   /* @see MetadataStore#setExcitationFilter(String, String, String,  
     831  /* @see MetadataStore#setExcitationFilter(String, String, String, 
    833832   * String, Integer) 
    834833   */ 
     
    840839    CustomAttributesNode ca = (CustomAttributesNode) 
    841840      getChild(root, "CustomAttributes", 0); 
    842     ExcitationFilterNode f =  
     841    ExcitationFilterNode f = 
    843842      (ExcitationFilterNode) getChild(ca, "ExcitationFilter", fNdx); 
    844843    f.setManufacturer(manufacturer); 
     
    862861  } 
    863862 
    864   /* @see MetadataStore#setEmissionFilter(String, String, String,  
     863  /* @see MetadataStore#setEmissionFilter(String, String, String, 
    865864   * String, Integer) 
    866865   */ 
     
    872871    CustomAttributesNode ca = (CustomAttributesNode) 
    873872      getChild(root, "CustomAttributes", 0); 
    874     EmissionFilterNode f = (EmissionFilterNode)  
     873    EmissionFilterNode f = (EmissionFilterNode) 
    875874      getChild(ca, "EmissionFilter", fNdx); 
    876875    f.setManufacturer(manufacturer); 
     
    880879  } 
    881880 
    882   /* @see MetadataStore#setFilterSet(String, String, String, Integer,  
    883    * Integer)  
     881  /* @see MetadataStore#setFilterSet(String, String, String, Integer, 
     882   * Integer) 
    884883   */ 
    885884  public void setFilterSet(String manufacturer, String model, String lotNumber, 
     
    899898  } 
    900899 
    901   /* @see MetadataStore#setOTF(Integer, Integer, String, String,  
     900  /* @see MetadataStore#setOTF(Integer, Integer, String, String, 
    902901   * Boolean, Integer, Integer, Integer, Integer) 
    903902   */ 
  • trunk/loci/formats/RandomAccessStream.java

    r2219 r2320  
    139139 
    140140  /** Return the underlying InputStream */ 
    141   public DataInputStream getInputStream() {  
     141  public DataInputStream getInputStream() { 
    142142    try { 
    143143      if (fileCache.get(this) == Boolean.FALSE) reopen(); 
     
    146146      return null; 
    147147    } 
    148     return dis;  
     148    return dis; 
    149149  } 
    150150 
     
    166166 
    167167  /** Gets the number of bytes in the file. */ 
    168   public long length() throws IOException {  
     168  public long length() throws IOException { 
    169169    if (fileCache.get(this) == Boolean.FALSE) reopen(); 
    170     return raf.length();  
     170    return raf.length(); 
    171171  } 
    172172 
     
    545545  private void cleanCache() { 
    546546    int toClose = MAX_FILES - 10; 
    547     RandomAccessStream[] files = (RandomAccessStream[])  
     547    RandomAccessStream[] files = (RandomAccessStream[]) 
    548548      fileCache.keySet().toArray(new RandomAccessStream[0]); 
    549549    int closed = 0; 
    550550    int ndx = 0; 
    551      
     551 
    552552    while (closed < toClose) { 
    553       if (!this.equals(files[ndx]) &&  
    554         !fileCache.get(files[ndx]).equals(Boolean.FALSE))  
     553      if (!this.equals(files[ndx]) && 
     554        !fileCache.get(files[ndx]).equals(Boolean.FALSE)) 
    555555      { 
    556556        try { files[ndx].close(); } 
  • trunk/loci/formats/ReaderWrapper.java

    r2291 r2320  
    101101    return getSizeC(id) / getRGBChannelCount(id); 
    102102  } 
    103   
     103 
    104104  public int getRGBChannelCount(String id) throws FormatException, IOException { 
    105105    return getSizeC(id) / (getImageCount(id) / (getSizeZ(id) * getSizeT(id))); 
     
    142142  } 
    143143 
    144   public boolean isMinMaxPopulated(String id)  
     144  public boolean isMinMaxPopulated(String id) 
    145145    throws FormatException, IOException 
    146146  { 
  • trunk/loci/formats/in/AVIReader.java

    r2313 r2320  
    176176    throws FormatException, IOException 
    177177  { 
    178     BufferedImage b = ImageTools.makeImage(openBytes(id, no), dwWidth, bmpHeight, 
    179       !isRGB(id) ? 1 : 3, true); 
     178    BufferedImage b = ImageTools.makeImage(openBytes(id, no), 
     179      dwWidth, bmpHeight, !isRGB(id) ? 1 : 3, true); 
    180180    updateMinMax(b, no); 
    181181    return b; 
     
    187187      if (in != null) in.close(); 
    188188    } 
    189     else close();  
     189    else close(); 
    190190  } 
    191191 
     
    286286                addMeta("Length", new Integer(dwLength)); 
    287287 
    288                 if (spos + size <= in.length()) {   
     288                if (spos + size <= in.length()) { 
    289289                  in.seek((int) (spos + size)); 
    290290                } 
     
    331331                addMeta("Stream sample size", new Integer(dwStreamSampleSize)); 
    332332 
    333                 if (spos + size <= in.length()) {   
     333                if (spos + size <= in.length()) { 
    334334                  in.seek((int) (spos + size)); 
    335335                } 
     
    446446          } 
    447447 
    448           if (startPos + streamSize + 8 <= in.length()) {   
     448          if (startPos + streamSize + 8 <= in.length()) { 
    449449            in.seek(startPos + 8 + streamSize); 
    450450          } 
     
    506506        // skipping unknown block 
    507507        type = readStringBytes(); 
    508         if (in.getFilePointer() + size + 4 <= in.length()) {   
     508        if (in.getFilePointer() + size + 4 <= in.length()) { 
    509509          size = in.readInt(); 
    510510          in.skipBytes(size); 
     
    543543      null, // Use image index 0 
    544544      null); // Use pixels index 0 
    545    
     545 
    546546    for (int i=0; i<sizeC[0]; i++) { 
    547       store.setLogicalChannel(i, null, null, null, null,  
     547      store.setLogicalChannel(i, null, null, null, null, 
    548548        sizeC[0] == 1 ? "monochrome" : "RGB", null, null); 
    549549    } 
  • trunk/loci/formats/in/AliconaReader.java

    r2313 r2320  
    141141    throws FormatException, IOException 
    142142  { 
    143     BufferedImage b = ImageTools.makeImage(openBytes(id, no), width, height, 1,  
     143    BufferedImage b = ImageTools.makeImage(openBytes(id, no), width, height, 1, 
    144144      false, numBytes, true); 
    145145    updateMinMax(b, no); 
     
    239239      new Float(((String) getMeta("PlanePntY")).trim()), 
    240240      new Float(((String) getMeta("PlanePntZ")).trim()), null, null, null); 
    241   
     241 
    242242    for (int i=0; i<sizeC[0]; i++) { 
    243243      store.setLogicalChannel(i, null, null, null, null, null, null, null); 
  • trunk/loci/formats/in/BMPReader.java

    r2313 r2320  
    376376    store.setDimensions(new Float(correctedX), new Float(correctedY), null, 
    377377      null, null, null); 
    378   
     378 
    379379    for (int i=0; i<sizeC[0]; i++) { 
    380380      store.setLogicalChannel(i, null, null, null, null, null, null, null); 
  • trunk/loci/formats/in/BaseTiffReader.java

    r2291 r2320  
    455455      TiffTools.getIFDIntValue(ifds[0], TiffTools.IMAGE_LENGTH, false, 0); 
    456456    sizeZ[0] = 1; 
    457      
     457 
    458458    try { 
    459459      sizeC[0] = isRGB(currentId) ? 3 : 1; 
     
    462462      throw new FormatException(e); 
    463463    } 
    464      
     464 
    465465    sizeT[0] = ifds.length; 
    466466 
     
    645645  public boolean isRGB(String id) throws FormatException, IOException { 
    646646    if (!id.equals(currentId)) initFile(id); 
    647     if (TiffTools.getIFDIntValue(ifds[0],  
     647    if (TiffTools.getIFDIntValue(ifds[0], 
    648648      TiffTools.SAMPLES_PER_PIXEL, false, 1) > 1) 
    649649    { 
    650650      return true; 
    651651    } 
    652     int p = TiffTools.getIFDIntValue(ifds[0],  
     652    int p = TiffTools.getIFDIntValue(ifds[0], 
    653653      TiffTools.PHOTOMETRIC_INTERPRETATION, true, 0); 
    654654    return (!isColorTableIgnored() && (p == TiffTools.RGB_PALETTE || 
  • trunk/loci/formats/in/BioRadReader.java

    r2313 r2320  
    320320          switch (y) { 
    321321            case 1: 
    322               keys = new String[] {"Scan Channel", "Both Mode", "Speed",  
    323                 "Filter", "Factor", "Number of scans",  
     322              keys = new String[] {"Scan Channel", "Both Mode", "Speed", 
     323                "Filter", "Factor", "Number of scans", 
    324324                "Photon counting mode (channel 1)", 
    325325                "Photon counting detector (channel 1)", 
    326                 "Photon counting mode (channel 2)",  
    327                 "Photon counting detector (channel 2)", "Photon mode",  
    328                 "Objective lens magnification", "Zoom factor (user selected)",  
    329                 "Motor on", "Z step size"};    
     326                "Photon counting mode (channel 2)", 
     327                "Photon counting detector (channel 2)", "Photon mode", 
     328                "Objective lens magnification", "Zoom factor (user selected)", 
     329                "Motor on", "Z step size"}; 
    330330              break; 
    331331            case 2: 
    332               keys = new String[] {"Z start", "Z stop", "Scan area - cx",  
     332              keys = new String[] {"Z start", "Z stop", "Scan area - cx", 
    333333                "Scan area - cy", "Scan area - lx", "Scan area - ly"}; 
    334334              break; 
    335335            case 3: 
    336               keys = new String[] {"PMT 1 Iris", "PMT 1 Gain",  
    337                 "PMT 1 Black level", "PMT 1 Emission filter", "PMT 2 Iris",  
    338                 "PMT 2 Gain", "PMT 2 Black level", "PMT 2 Emission filter",  
    339                 "PMT 3 Iris", "PMT 3 Gain", "PMT 3 Black level",  
    340                 "PMT 3 Emission filter", "Multiplier of channel 1",  
    341                 "Multiplier of channel 2", "Multiplier of channel 3"};  
     336              keys = new String[] {"PMT 1 Iris", "PMT 1 Gain", 
     337                "PMT 1 Black level", "PMT 1 Emission filter", "PMT 2 Iris", 
     338                "PMT 2 Gain", "PMT 2 Black level", "PMT 2 Emission filter", 
     339                "PMT 3 Iris", "PMT 3 Gain", "PMT 3 Black level", 
     340                "PMT 3 Emission filter", "Multiplier of channel 1", 
     341                "Multiplier of channel 2", "Multiplier of channel 3"}; 
    342342              break; 
    343343            case 4: 
    344               keys = new String[] {"Number of lasers",  
    345                 "Number of transmission detectors", "Number of PMTs",  
     344              keys = new String[] {"Number of lasers", 
     345                "Number of transmission detectors", "Number of PMTs", 
    346346                "Shutter present for laser 1", 
    347347                "Shutter present for laser 2", "Shutter present for laser 3", 
    348                 "Neutral density filter for laser 1",  
    349                 "Excitation filter for laser 1", "Use laser 1",  
    350                 "Neutral density filter for laser 2",  
    351                 "Excitation filter for laser 2", "Use laser 2",  
    352                 "Neutral density filter for laser 3",  
    353                 "Excitation filter for laser 3", "Use laser 3",  
    354                 "Neutral density filter name - laser 1",  
    355                 "Neutral density filter name - laser 2",  
     348                "Neutral density filter for laser 1", 
     349                "Excitation filter for laser 1", "Use laser 1", 
     350                "Neutral density filter for laser 2", 
     351                "Excitation filter for laser 2", "Use laser 2", 
     352                "Neutral density filter for laser 3", 
     353                "Excitation filter for laser 3", "Use laser 3", 
     354                "Neutral density filter name - laser 1", 
     355                "Neutral density filter name - laser 2", 
    356356                "Neutral density filter name - laser 3"}; 
    357               break;  
     357              break; 
    358358            case 5: 
    359359              keys = new String[] {"Excitation filter name - laser 1", 
    360                 "Excitation filter name - laser 2",  
     360                "Excitation filter name - laser 2", 
    361361                "Excitation filter name - laser 3"}; 
    362362              break; 
    363363            case 6: 
    364               keys = new String[] {"Emission filter name - laser 1",  
    365                 "Emission filter name - laser 2",  
    366                 "Emission filter name - laser 3"};  
     364              keys = new String[] {"Emission filter name - laser 1", 
     365                "Emission filter name - laser 2", 
     366                "Emission filter name - laser 3"}; 
    367367              break; 
    368368            case 7: 
    369               keys = new String[] {"Mixer 0 - enhanced",  
     369              keys = new String[] {"Mixer 0 - enhanced", 
    370370                "Mixer 0 - PMT 1 percentage", 
    371371                "Mixer 0 - PMT 2 percentage", "Mixer 0 - PMT 3 percentage", 
    372                 "Mixer 0 - Transmission 1 percentage",  
    373                 "Mixer 0 - Transmission 2 percentage",  
     372                "Mixer 0 - Transmission 1 percentage", 
     373                "Mixer 0 - Transmission 2 percentage", 
    374374                "Mixer 0 - Transmission 3 percentage", "Mixer 1 - enhanced", 
    375375                "Mixer 1 - PMT 1 percentage", "Mixer 1 - PMT 2 percentage", 
     
    377377                "Mixer 1 - Transmission 1 percentage", 
    378378                "Mixer 1 - Transmission 2 percentage", 
    379                 "Mixer 1 - Transmission 3 percentage",  
     379                "Mixer 1 - Transmission 3 percentage", 
    380380                "Mixer 0 - low signal on", "Mixer 1 - low signal on"}; 
    381381              break; 
    382382            case 8: 
    383               keys = new String[] {"Laser 1 name"};  
     383              keys = new String[] {"Laser 1 name"}; 
    384384              break; 
    385385            case 9: 
    386               keys = new String[] {"Laser 2 name"};  
     386              keys = new String[] {"Laser 2 name"}; 
    387387              break; 
    388388            case 10: 
    389               keys = new String[] {"Laser 3 name"};  
     389              keys = new String[] {"Laser 3 name"}; 
    390390              break; 
    391391            case 11: 
    392392              keys = new String[] {"Transmission detector 1 - offset", 
    393                 "Transmission detector 1 - gain",  
    394                 "Transmission detector 1 - black level",  
    395                 "Transmission detector 2 - offset",  
    396                 "Transmission detector 2 - gain",  
    397                 "Transmission detector 2 - black level",  
    398                 "Transmission detector 3 - offset",  
    399                 "Transmission detector 3 - gain",  
     393                "Transmission detector 1 - gain", 
     394                "Transmission detector 1 - black level", 
     395                "Transmission detector 2 - offset", 
     396                "Transmission detector 2 - gain", 
     397                "Transmission detector 2 - black level", 
     398                "Transmission detector 3 - offset", 
     399                "Transmission detector 3 - gain", 
    400400                "Transmission detector 3 - black level"}; 
    401401              break; 
    402402            case 12: 
    403               keys = new String[] {"Part number of laser 1",  
    404                 "Part number of excitation filter for laser 1",  
    405                 "Part number of ND filter for laser 1",  
    406                 "Part number of emission filter for laser 1",  
    407                 "Part number of laser 2",  
    408                 "Part number of excitation filter for laser 2",  
    409                 "Part number of ND filter for laser 2",  
    410                 "Part number of emission filter for laser 2"};  
     403              keys = new String[] {"Part number of laser 1", 
     404                "Part number of excitation filter for laser 1", 
     405                "Part number of ND filter for laser 1", 
     406                "Part number of emission filter for laser 1", 
     407                "Part number of laser 2", 
     408                "Part number of excitation filter for laser 2", 
     409                "Part number of ND filter for laser 2", 
     410                "Part number of emission filter for laser 2"}; 
    411411              break; 
    412412            case 13: 
    413               keys = new String[] {"Part number of laser 3",  
    414                 "Part number of excitation filter for laser 3",  
    415                 "Part number of ND filter for laser 3",  
    416                 "Part number of emission filter for laser 3",  
    417                 "Part number of filter block 1",  
     413              keys = new String[] {"Part number of laser 3", 
     414                "Part number of excitation filter for laser 3", 
     415                "Part number of ND filter for laser 3", 
     416                "Part number of emission filter for laser 3", 
     417                "Part number of filter block 1", 
    418418                "Part number of filter block 2", 
    419419                "Filter block 1", "Filter block 2"}; 
    420420              break; 
    421421            case 14: 
    422               keys = new String[] {"Filter block 1 name",  
     422              keys = new String[] {"Filter block 1 name", 
    423423                "Filter block 2 name"}; 
    424424              break; 
    425425            case 15: 
    426               keys = new String[] {"Image band 1 status", "Image band 1 min",  
    427                 "Image band 1 max", "Image band 2 status", "Image band 2 min",  
    428                 "Image band 2 max", "Image band 3 status", "Image band 3 min",  
    429                 "Image band 3 max", "Image band 4 status", "Image band 4 min",  
    430                 "Image band 4 max", "Image band 5 status", "Image band 5 min",  
    431                 "Image band 5 max"};  
     426              keys = new String[] {"Image band 1 status", "Image band 1 min", 
     427                "Image band 1 max", "Image band 2 status", "Image band 2 min", 
     428                "Image band 2 max", "Image band 3 status", "Image band 3 min", 
     429                "Image band 3 max", "Image band 4 status", "Image band 4 min", 
     430                "Image band 4 max", "Image band 5 status", "Image band 5 min", 
     431                "Image band 5 max"}; 
    432432              break; 
    433433            case 16: 
    434               keys = new String[] {"Image band 5 status", "Image band 5 min",  
    435                 "Image band 5 max"};  
     434              keys = new String[] {"Image band 5 status", "Image band 5 min", 
     435                "Image band 5 max"}; 
    436436              break; 
    437437            case 17: 
    438               keys = new String[] {"Date stamp (seconds)",  
     438              keys = new String[] {"Date stamp (seconds)", 
    439439                "Date stamp (minutes)", 
    440440                "Date stamp (hours)", "Date stamp (day of month)", 
     
    444444              break; 
    445445            case 18: 
    446               keys = new String[] {"Mixer 3 - enhanced",  
     446              keys = new String[] {"Mixer 3 - enhanced", 
    447447                "Mixer 3 - PMT 1 percentage", 
    448448                "Mixer 3 - PMT 2 percentage", "Mixer 3 - PMT 3 percentage", 
    449                 "Mixer 3 - Transmission 1 percentage",  
    450                 "Mixer 3 - Transmission 2 percentage",  
    451                 "Mixer 3 - Transmission 3 percentage",  
     449                "Mixer 3 - Transmission 1 percentage", 
     450                "Mixer 3 - Transmission 2 percentage", 
     451                "Mixer 3 - Transmission 3 percentage", 
    452452                "Mixer 3 - low signal on", 
    453453                "Mixer 3 - photon counting 1", "Mixer 3 - photon counting 2", 
     
    455455              break; 
    456456            case 19: 
    457               keys = new String[] {"Mixer 1 - photon counting 1",  
    458                 "Mixer 1 - photon counting 2", "Mixer 1 - photon counting 3",  
    459                 "Mixer 1 - mode", "Mixer2 - photon counting 1",  
    460                 "Mixer 2 - photon counting 2", "Mixer 2 - photon counting 3",  
    461                 "Mixer 2 - mode"};  
     457              keys = new String[] {"Mixer 1 - photon counting 1", 
     458                "Mixer 1 - photon counting 2", "Mixer 1 - photon counting 3", 
     459                "Mixer 1 - mode", "Mixer2 - photon counting 1", 
     460                "Mixer 2 - photon counting 2", "Mixer 2 - photon counting 3", 
     461                "Mixer 2 - mode"}; 
    462462              break; 
    463463            case 20: 
    464               keys = new String[] {"Display mode", "Course",  
     464              keys = new String[] {"Display mode", "Course", 
    465465                "Time Course - experiment type", 
    466466                "Time Course - kd factor"}; 
    467467              break; 
    468468            case 21: 
    469               keys = new String[] {"Time Course - ion name"};  
     469              keys = new String[] {"Time Course - ion name"}; 
    470470              break; 
    471471            case 22: 
     
    480480          while (st.hasMoreTokens() && idx < keys.length) { 
    481481            addMeta(keys[idx], st.nextToken()); 
    482             idx++;    
     482            idx++; 
    483483          } 
    484484          break; 
    485485        default: 
    486           addMeta("note" + noteCount,  
     486          addMeta("note" + noteCount, 
    487487            noteString(num, level, status, type, x, y, text)); 
    488488      } 
    489        
     489 
    490490      // if the text of the note contains "AXIS", parse the text 
    491491      // more thoroughly (see pg. 21 of the BioRad specs) 
     
    588588    boolean eof = false; 
    589589    while (!eof && numLuts < 3) { 
    590       if (in.getFilePointer() + lut[numLuts].length <= in.length()) {   
     590      if (in.getFilePointer() + lut[numLuts].length <= in.length()) { 
    591591        in.read(lut[numLuts]); 
    592592        numLuts++; 
     
    694694    if (size >= 3) pixelSizeZ = new Float((String) pixelSize.get(2)); 
    695695    store.setDimensions(pixelSizeX, pixelSizeY, pixelSizeZ, null, null, null); 
    696    
     696 
    697697    store.setDefaultDisplaySettings(null); 
    698    
     698 
    699699    for (int i=0; i<sizeC[0]; i++) { 
    700700      store.setLogicalChannel(i, null, null, null, null, null, null, null); 
    701701      String black = (String) getMeta("PMT " + i + " Black level"); 
    702       store.setDisplayChannel(new Integer(i), black == null ? null :  
     702      store.setDisplayChannel(new Integer(i), black == null ? null : 
    703703        new Double(black), new Double(Math.pow(2, type == 1 ? 8 : 16)), 
    704704        null, null); 
     
    710710      new Boolean(sizeC[0] > 1), new Boolean(sizeC[0] >= 2), 
    711711      new Boolean(sizeC[0] >= 3), Boolean.FALSE, null, zstart == null ? null : 
    712       new Integer((int) (new Double(zstart).doubleValue())), zstop == null ?  
    713       null : new Integer((int) (new Double(zstop).doubleValue())), null, null,  
    714       null, null, sizeC[0] > 1 ? new Integer(0) : null,  
     712      new Integer((int) (new Double(zstart).doubleValue())), zstop == null ? 
     713      null : new Integer((int) (new Double(zstop).doubleValue())), null, null, 
     714      null, null, sizeC[0] > 1 ? new Integer(0) : null, 
    715715      sizeC[0] > 1 ? new Integer(1) : null, 
    716716      sizeC[0] > 1 ? new Integer(2) : null, new Integer(0)); 
     
    719719      String gain = (String) getMeta(prefix + "gain"); 
    720720      String offset = (String) getMeta(prefix + "offset"); 
    721       store.setDetector(null, null, null, null, gain == null ? null :  
    722         new Float(gain), null, offset == null ? null : new Float(offset),  
     721      store.setDetector(null, null, null, null, gain == null ? null : 
     722        new Float(gain), null, offset == null ? null : new Float(offset), 
    723723        null, new Integer(i)); 
    724724 
     
    733733    } 
    734734    String mag = (String) getMeta("Objective lens magnification"); 
    735     store.setObjective(null, null, null, null,  
     735    store.setObjective(null, null, null, null, 
    736736      mag == null ? null : new Float(mag), null, null); 
    737    
     737 
    738738  } 
    739739 
  • trunk/loci/formats/in/DeltavisionReader.java

    r2291 r2320  
    167167    throws FormatException, IOException 
    168168  { 
    169     return true;  
     169    return true; 
    170170  } 
    171171 
     
    223223    return b; 
    224224  } 
    225   
     225 
    226226  /* @see IFormatReader#close(boolean) */ 
    227227  public void close(boolean fileOnly) throws FormatException, IOException { 
     
    496496 
    497497    String description = (String) getMeta("Title 1"); 
    498     if (description == null) description = "";  
     498    if (description == null) description = ""; 
    499499    description = description.length() == 0 ? null : description; 
    500500    store.setImage(id, null, description, null); 
  • trunk/loci/formats/in/DicomReader.java

    r2313 r2320  
    231231    throws FormatException, IOException 
    232232  { 
    233     BufferedImage b = ImageTools.makeImage(openBytes(id, no), width, height,  
     233    BufferedImage b = ImageTools.makeImage(openBytes(id, no), width, height, 
    234234      1, false, bitsPerPixel / 8, little); 
    235235    updateMinMax(b, no); 
     
    525525    if (skip) { 
    526526      long skipCount = (long) elementLength; 
    527       if (in.getFilePointer() + skipCount <= in.length()) {   
     527      if (in.getFilePointer() + skipCount <= in.length()) { 
    528528        in.skipBytes((int) skipCount); 
    529529      } 
  • trunk/loci/formats/in/GIFReader.java

    r2307 r2320  
    201201  { 
    202202    byte[] bytes = openBytes(id, no); 
    203     BufferedImage b = ImageTools.makeImage(bytes, width, height,  
     203    BufferedImage b = ImageTools.makeImage(bytes, width, height, 
    204204      bytes.length / (width * height), false, 1, true); 
    205205    updateMinMax(b, no); 
  • trunk/loci/formats/in/GatanReader.java

    r2313 r2320  
    5454  /** List of pixel sizes. */ 
    5555  private Vector pixelSizes; 
    56    
     56 
    5757  /** Dimensions -- width, height, bytes per pixel. */ 
    5858  protected int[] dims = new int[3]; 
     
    268268      null, // Use image index 0 
    269269      null); // Use pixels index 0 
    270    
     270 
    271271    Float pixX = null; 
    272272    Float pixY = null; 
     
    284284 
    285285    store.setDimensions(pixX, pixY, pixZ, null, null, null); 
    286   
     286 
    287287    for (int i=0; i<sizeC[0]; i++) { 
    288288      store.setLogicalChannel(i, null, null, null, null, null, null, null); 
  • trunk/loci/formats/in/GelReader.java

    r2288 r2320  
    9797 
    9898    sizeT[series] = numImages; 
    99    
     99 
    100100    try { 
    101101      MetadataStore store = getMetadataStore(currentId); 
    102       store.setDimensions(new Float(scale.floatValue()),  
     102      store.setDimensions(new Float(scale.floatValue()), 
    103103        new Float(scale.floatValue()), null, null, null, null); 
    104104    } 
  • trunk/loci/formats/in/ICSReader.java

    r2313 r2320  
    128128    int height = dimensions[2]; 
    129129 
    130     int offset = width * height * (dimensions[0] / 8) * no *  
     130    int offset = width * height * (dimensions[0] / 8) * no * 
    131131      (rgb ? dimensions[4] : 1); 
    132     byte[] plane =  
     132    byte[] plane = 
    133133      new byte[width*height * (dimensions[0] / 8) * (rgb ? dimensions[4] : 1)]; 
    134134    System.arraycopy(data, offset, plane, 0, plane.length); 
     
    457457      null, // Use image index 0 
    458458      null); // Use pixels index 0 
    459    
     459 
    460460    for (int i=0; i<sizeC[0]; i++) { 
    461461      store.setLogicalChannel(i, null, null, null, null, null, null, null); 
  • trunk/loci/formats/in/IPLabReader.java

    r2313 r2320  
    388388          addMeta("NormalizationBlack" + i, new Double(black)); 
    389389          addMeta("NormalizationWhite" + i, new Double(white)); 
    390          
     390 
    391391          store = getMetadataStore(currentId); 
    392           store.setChannelGlobalMinMax(i, new Double(min),  
     392          store.setChannelGlobalMinMax(i, new Double(min), 
    393393            new Double(max), null); 
    394394          // TODO : set DisplayChannel here 
     
    472472        store.setImage(id, null, notes, null); 
    473473      } 
    474        
    475       if (in.getFilePointer() + 4 <= in.length()) {   
     474 
     475      if (in.getFilePointer() + 4 <= in.length()) { 
    476476        in.read(fourBytes); 
    477477        tag = new String(fourBytes); 
  • trunk/loci/formats/in/IPWReader.java

    r2313 r2320  
    172172    byte[] b = openBytes(id, no); 
    173173    int bytes = b.length / (sizeX[0] * sizeY[0]); 
    174     BufferedImage bi = ImageTools.makeImage(b, sizeX[0], sizeY[0],  
     174    BufferedImage bi = ImageTools.makeImage(b, sizeX[0], sizeY[0], 
    175175      bytes == 3 ? 3 : 1, false, bytes == 3 ? 1 : bytes, little); 
    176176    updateMinMax(bi, no); 
  • trunk/loci/formats/in/ImageIOReader.java

    r2307 r2320  
    108108 
    109109    RandomAccessStream ras = new RandomAccessStream(id); 
    110     DataInputStream dis =  
     110    DataInputStream dis = 
    111111      new DataInputStream(new BufferedInputStream(ras, 4096)); 
    112112    BufferedImage b = ImageIO.read(dis); 
     
    133133    sizeY[0] = img.getHeight(); 
    134134 
    135     rgb = img.getRaster().getNumBands() > 1;  
     135    rgb = img.getRaster().getNumBands() > 1; 
    136136 
    137137    sizeZ[0] = 1; 
  • trunk/loci/formats/in/ImageJReader.java

    r2307 r2320  
    149149      r.exec("size = image.getStackSize()"); 
    150150      Image img = (Image) r.exec("image.getImage()"); 
    151        
     151 
    152152      BufferedImage b = ImageTools.makeBuffered(img); 
    153153      updateMinMax(b, no); 
     
    173173    pixelType[0] = ImageTools.getPixelType(img); 
    174174    currentOrder[0] = "XYCZT"; 
    175    
     175 
    176176    MetadataStore store = getMetadataStore(id); 
    177177 
  • trunk/loci/formats/in/ImarisReader.java

    r2313 r2320  
    162162      new Float(1), 
    163163      null); 
    164    
     164 
    165165    for (int i=0; i<sizeC[0]; i++) { 
    166166      store.setLogicalChannel(i, null, null, null, null, null, null, null); 
     
    225225    throws FormatException, IOException 
    226226  { 
    227     BufferedImage b = ImageTools.makeImage(openBytes(id, no), dims[0],  
     227    BufferedImage b = ImageTools.makeImage(openBytes(id, no), dims[0], 
    228228      dims[1], 1, false); 
    229229    updateMinMax(b, no); 
    230230    return b; 
    231231  } 
    232   
     232 
    233233  /* @see IFormatReader#close(boolean) */ 
    234234  public void close(boolean fileOnly) throws FormatException, IOException { 
  • trunk/loci/formats/in/LIFReader.java

    r2313 r2320  
    374374        else if (token.indexOf("dblVoxel") != -1) { 
    375375          int index = token.indexOf("Variant") + 7; 
    376           String size = token.substring(index + 2,  
     376          String size = token.substring(index + 2, 
    377377            token.indexOf("\"", index + 3)); 
    378378          float cal = Float.parseFloat(size) * 1000000; 
     
    401401              prefix = (String) seriesNames.get(seriesNames.size() - 1); 
    402402            } 
    403              
     403 
    404404            Hashtable tmp = new Hashtable(); 
    405405            while (token.length() > 2) { 
     
    463463 
    464464          ndx++; 
    465           if (elements != null && ndx < elements.size()) {   
     465          if (elements != null && ndx < elements.size()) { 
    466466            token = (String) elements.get(ndx); 
    467467          } 
  • trunk/loci/formats/in/LegacyPictReader.java

    r2313 r2320  
    121121    pixelType[0] = FormatReader.INT8; 
    122122    currentOrder[0] = "XYCZT"; 
    123    
     123 
    124124    MetadataStore store = getMetadataStore(id); 
    125125    store.setPixels(new Integer(sizeX[0]), new Integer(sizeY[0]), 
    126126      new Integer(1), new Integer(sizeC[0]), new Integer(1), 
    127       new Integer(pixelType[0]), Boolean.TRUE, currentOrder[0], null, null);  
    128      
     127      new Integer(pixelType[0]), Boolean.TRUE, currentOrder[0], null, null); 
     128 
    129129    for (int i=0; i<sizeC[0]; i++) { 
    130130      store.setLogicalChannel(i, null, null, null, null, null, null, null); 
  • trunk/loci/formats/in/LegacyQTReader.java

    r2313 r2320  
    242242      pixelType[0] = ImageTools.getPixelType(img); 
    243243      currentOrder[0] = "XYCTZ"; 
    244      
     244 
    245245      MetadataStore store = getMetadataStore(id); 
    246246      store.setPixels(new Integer(sizeX[0]), new Integer(sizeY[0]), 
    247247        new Integer(1), new Integer(sizeC[0]), new Integer(sizeT[0]), 
    248248        new Integer(pixelType[0]), Boolean.TRUE, currentOrder[0], null, null); 
    249      
     249 
    250250      for (int i=0; i<sizeC[0]; i++) { 
    251251        store.setLogicalChannel(i, null, null, null, null, null, null, null); 
  • trunk/loci/formats/in/LegacyZVIReader.java

    r2313 r2320  
    435435        null, // Use image index 0 
    436436        null); // Use pixels index 0 
    437      
     437 
    438438      for (int i=0; i<sizeC[0]; i++) { 
    439439        store.setLogicalChannel(i, null, null, null, null, null, null, null); 
  • trunk/loci/formats/in/LeicaReader.java

    r2313 r2320  
    148148    if (!id.equals(currentId) && !usedFile(id) && !id.equals(leiFilename)) { 
    149149      initFile(id); 
    150     }  
     150    } 
    151151    return littleEndian; 
    152152  } 
     
    212212    return (String[]) v.toArray(new String[0]); 
    213213  } 
    214   
     214 
    215215  /* @see IFormatReader#close(boolean) */ 
    216216  public void close(boolean fileOnly) throws FormatException, IOException { 
     
    254254    String idLow = id.toLowerCase(); 
    255255    close(); 
    256      
     256 
    257257    if (idLow.endsWith("tif") || idLow.endsWith("tiff")) { 
    258258      if (ifds == null) super.initFile(id); 
     
    270270      ifds = TiffTools.getIFDs(in); 
    271271      if (ifds == null) throw new FormatException("No IFDs found"); 
    272       String descr = (String) TiffTools.getIFDValue(ifds[0],  
     272      String descr = (String) TiffTools.getIFDValue(ifds[0], 
    273273        TiffTools.IMAGE_DESCRIPTION); 
    274274 
     
    415415          new Location(id).getAbsoluteFile().getParent(); 
    416416        dirPrefix = dirPrefix == null ? "" : (dirPrefix + File.separator); 
    417          
     417 
    418418        String[] listing = (new Location(dirPrefix)).list(); 
    419419        Vector list = new Vector(); 
     
    434434        for (int j=0; j<tempImages; j++) { 
    435435          // read in each filename 
    436           prefix = DataTools.stripString(new String(tempData,  
     436          prefix = DataTools.stripString(new String(tempData, 
    437437            20 + 2*(j*nameLength), 2*nameLength)); 
    438           f.add(dirPrefix + prefix);  
     438          f.add(dirPrefix + prefix); 
    439439          // test to make sure the path is valid 
    440440          Location test = new Location((String) f.get(f.size() - 1)); 
     
    443443 
    444444        // at least one of the TIFF files was renamed 
    445          
     445 
    446446        if (!tiffsExist) { 
    447447          // first thing is to get original LEI name associate with each TIFF 
     
    454454            Hashtable ifd = TiffTools.getFirstIFD(ras); 
    455455            ras.close(); 
    456             String descr =  
     456            String descr = 
    457457              (String) ifd.get(new Integer(TiffTools.IMAGE_DESCRIPTION)); 
    458458            int ndx = descr.indexOf("=", descr.indexOf("Series Name")); 
     
    462462            leiMapping.put(listing[j], leiFile); 
    463463          } 
    464         
     464 
    465465          // compare original TIFF prefix with original LEI prefix 
    466          
     466 
    467467          f.clear(); 
    468468          String[] keys = (String[]) leiMapping.keySet().toArray(new String[0]); 
     
    473473            } 
    474474          } 
    475          
     475 
    476476          // now that we have our list of files, all that remains is to figure 
    477477          // out how they should be ordered 
     
    482482            if (usedFiles != null) { 
    483483              for (int k=0; k<usedFiles.length; k++) { 
    484                 if (usedFiles[k].equals((String) f.get(j)) ||  
    485                   usedFile((String) f.get(j)))  
     484                if (usedFiles[k].equals((String) f.get(j)) || 
     485                  usedFile((String) f.get(j))) 
    486486                { 
    487487                  k = 0; 
     
    491491            } 
    492492            if (j >= f.size()) break; 
    493              
     493 
    494494            FilePattern fp = new FilePattern(new Location((String) f.get(j))); 
    495495            if (fp != null) usedFiles = fp.getFiles(); 
     
    497497              files[i] = new Vector(); 
    498498              for (int k=0; k<usedFiles.length; k++) { 
    499                 files[i].add(new Location(dirPrefix,  
     499                files[i].add(new Location(dirPrefix, 
    500500                  usedFiles[k]).getAbsolutePath()); 
    501501              } 
     
    514514                new Location(dirPrefix, listing[j]).getAbsolutePath()); 
    515515              Hashtable fd = TiffTools.getFirstIFD(ras); 
    516               String stamp =  
     516              String stamp = 
    517517                (String) TiffTools.getIFDValue(fd, TiffTools.DATE_TIME); 
    518518              if (h.size() == tempImages) { 
     
    520520                Arrays.sort(ks); 
    521521                for (int k=0; k<ks.length; k++) { 
    522                   files[i].add(new Location(dirPrefix,  
     522                  files[i].add(new Location(dirPrefix, 
    523523                    (String) h.get(ks[k])).getAbsolutePath()); 
    524524                } 
     
    539539              Arrays.sort(ks); 
    540540              for (int k=0; k<ks.length; k++) { 
    541                 files[i].add(new Location(dirPrefix,  
     541                files[i].add(new Location(dirPrefix, 
    542542                  (String) h.get(ks[k])).getAbsolutePath()); 
    543543              } 
     
    556556            for (int j=0; j<i; j++) ndx += files[j].size(); 
    557557            for (int j=ndx; j<ndx+tempImages; j++) { 
    558               files[i].add(new Location(dirPrefix,  
     558              files[i].add(new Location(dirPrefix, 
    559559                listing[j]).getAbsolutePath()); 
    560560            } 
     
    565565          // 1) Don't use a detectable naming convention, and remove datestamps 
    566566          //    from TIFF files. 
    567           // 2) Use a naming convention such as plane 0 -> "5.tif",  
     567          // 2) Use a naming convention such as plane 0 -> "5.tif", 
    568568          //    plane 1 -> "4.tif", plane 2 -> "3.tif", etc. 
    569569          // 3) Place two datasets in the same folder: 
     
    622622      if (ndx == -1) return false; 
    623623 
    624       String dir = new Location(name).getAbsoluteFile().getParent();  
     624      String dir = new Location(name).getAbsoluteFile().getParent(); 
    625625      String[] listing = new Location(dir).list(); 
    626626      for (int i=0; i<listing.length; i++) { 
     
    847847 
    848848      temp = (byte[]) headerIFDs[i].get(new Integer(40)); 
    849        
     849 
    850850      if (temp != null) { 
    851851        // time data 
     
    853853        int nDims = DataTools.bytesToInt(temp, 0, 4, littleEndian); 
    854854        addMeta("Number of time-stamped dimensions", new Integer(nDims)); 
    855         addMeta("Time-stamped dimension",  
     855        addMeta("Time-stamped dimension", 
    856856          new Integer(DataTools.bytesToInt(temp, 4, 4, littleEndian))); 
    857857 
     
    11061106      store.setImage(null, timestamp == null ? null : timestamp.substring(3), 
    11071107        description, new Integer(i)); 
    1108      
    1109      
     1108 
    11101109      for (int j=0; j<sizeC[0]; j++) { 
    1111         store.setLogicalChannel(j, null, null, null, null, null,  
     1110        store.setLogicalChannel(j, null, null, null, null, null, 
    11121111          null, new Integer(i)); 
    11131112      } 
  • trunk/loci/formats/in/MNGReader.java

    r2307 r2320  
    219219    currentOrder[0] = "XYCZT"; 
    220220    pixelType[0] = FormatReader.UINT8; 
    221    
     221 
    222222    MetadataStore store = getMetadataStore(id); 
    223223 
  • trunk/loci/formats/in/MRCReader.java

    r2313 r2320  
    112112    throws FormatException, IOException 
    113113  { 
    114     BufferedImage b = ImageTools.makeImage(openBytes(id, no), sizeX[0],  
     114    BufferedImage b = ImageTools.makeImage(openBytes(id, no), sizeX[0], 
    115115      sizeY[0], 1, true, bpp, little); 
    116116    updateMinMax(b, no); 
  • trunk/loci/formats/in/ND2Reader.java

    r2313 r2320  
    393393                    boolean parse = true; 
    394394                    for (int i=0; i<v.length(); i++) { 
    395                       if (Character.isLetter(v.charAt(i)) ||  
     395                      if (Character.isLetter(v.charAt(i)) || 
    396396                        Character.isWhitespace(v.charAt(i))) 
    397397                      { 
    398398                        parse = false; 
    399399                        break; 
    400                       }  
     400                      } 
    401401                    } 
    402402                    if (parse) { 
     
    460460    } 
    461461 
    462     String c = (String)  
     462    String c = (String) 
    463463      getMeta("MetadataSeq _SEQUENCE_INDEX=\"0\" uiCompCount value"); 
    464464    if (c != null) sizeC[0] = Integer.parseInt(c); 
     
    492492    currentOrder[0] = "XY"; 
    493493    long deltaT = timestamps.length > 1 ? timestamps[1] - timestamps[0] : 1; 
    494     long deltaZ = zstamps.length > 1 ? zstamps[1] - zstamps[0] : 1;  
     494    long deltaZ = zstamps.length > 1 ? zstamps[1] - zstamps[0] : 1; 
    495495 
    496496    if (deltaT < deltaZ || deltaZ == 0) currentOrder[0] += "CTZ"; 
     
    510510        } 
    511511      } 
    512        
     512 
    513513      if (numImages < sizeZ[0] * sizeT[0] * getEffectiveSizeC(id)) { 
    514514        if (sizeZ[0] < sizeT[0]) { 
  • trunk/loci/formats/in/OIBReader.java

    r2313 r2320  
    248248    int s = getSeries(id); 
    249249    int bytes = b.length / (sizeX[s] * sizeY[s]); 
    250     BufferedImage bi = ImageTools.makeImage(b, sizeX[s], sizeY[s],  
    251       bytes == 3 ? 3 : 1, false, bytes == 3 ? 1 : bytes, !littleEndian[s],  
     250    BufferedImage bi = ImageTools.makeImage(b, sizeX[s], sizeY[s], 
     251      bytes == 3 ? 3 : 1, false, bytes == 3 ? 1 : bytes, !littleEndian[s], 
    252252      validBits[s]); 
    253253    updateMinMax(bi, no); 
     
    429429 
    430430        int numImages = ((Integer) nImages.get(i)).intValue(); 
    431         
     431 
    432432        if (numImages > sizeZ[i] * sizeT[i] * sizeC[i]) { 
    433433          int diff = numImages - (sizeZ[i] * sizeT[i] * sizeC[i]); 
     
    529529      store.setDimensions(pixX, pixY, null, null, null, new Integer(i)); 
    530530      for (int j=0; j<sizeC[0]; j++) { 
    531         store.setLogicalChannel(j, null, null, null, null, null,  
     531        store.setLogicalChannel(j, null, null, null, null, null, 
    532532          null, new Integer(i)); 
    533533      } 
  • trunk/loci/formats/in/OIFReader.java

    r2313 r2320  
    325325    String tiffPath = null; 
    326326    RandomAccessStream ptyReader; 
    327      
     327 
    328328    for (int i=0; i<numImages; i++) { 
    329329      String file = (String) filenames.get(new Integer(i)); 
  • trunk/loci/formats/in/OMEReader.java

    r2313 r2320  
    3333import org.openmicroscopy.is.*; 
    3434 
    35 /**  
    36  * OMEReader retrieves images on demand from an OME database.  
     35/** 
     36 * OMEReader retrieves images on demand from an OME database. 
    3737 * Authentication with the OME server is handled, provided the 'id' parameter 
    38  * is properly formed.   
     38 * is properly formed. 
    3939 * The 'id' parameter should take one of the following forms: 
    4040 * 
     
    5050  /** String containing authentication information */ 
    5151  private String loginString; 
    52    
     52 
    5353  /** Number of images */ 
    5454  private int numImages; 
     
    126126    return false; 
    127127  } 
    128   
     128 
    129129  /* @see IFormatReader#openBytes(String, int) */ 
    130130  public byte[] openBytes(String id, int no) throws FormatException, IOException 
     
    149149    throws FormatException, IOException 
    150150  { 
    151     BufferedImage b = ImageTools.makeImage(openBytes(id, no), sizeX[0],  
     151    BufferedImage b = ImageTools.makeImage(openBytes(id, no), sizeX[0], 
    152152      sizeY[0], 1, false, FormatReader.getBytesPerPixel(pixelType[0]), true); 
    153153    updateMinMax(b, no); 
     
    262262 
    263263    rc = rs.getRemoteCaller(); 
    264      
     264 
    265265    if (user != null && pass != null) rc.login(user, pass); 
    266266    else if (sessionKey != null) rc.setSessionKey(sessionKey); 
     
    305305    } 
    306306  } 
    307    
     307 
    308308  // -- Main method -- 
    309309 
  • trunk/loci/formats/in/OMEXMLReader.java

    r2313 r2320  
    486486    for (int i=0; i<sizeC.length; i++) { 
    487487      for (int j=0; j<sizeC[i]; j++) { 
    488         store.setLogicalChannel(j, null, null, null, null, null,  
     488        store.setLogicalChannel(j, null, null, null, null, null, 
    489489          null, new Integer(i)); 
    490490      } 
  • trunk/loci/formats/in/OpenlabReader.java

    r2313 r2320  
    682682    minMaxFinished = new boolean[numSeries]; 
    683683    Arrays.fill(minMaxFinished, false); 
    684      
     684 
    685685    int oldSeries = getSeries(currentId); 
    686686    for (int i=0; i<bpp.length; i++) { 
     
    755755        null, null, new Integer(i)); 
    756756      for (int j=0; j<sizeC[0]; j++) { 
    757         store.setLogicalChannel(j, null, null, null, null, null,  
     757        store.setLogicalChannel(j, null, null, null, null, null, 
    758758          null, new Integer(i)); 
    759759      } 
  • trunk/loci/formats/in/PerkinElmerReader.java

    r2313 r2320  
    144144    byte[] b = openBytes(id, no); 
    145145    int bpp = b.length / (sizeX[0] * sizeY[0]); 
    146     BufferedImage bi = ImageTools.makeImage(b, sizeX[0], sizeY[0], 1,  
     146    BufferedImage bi = ImageTools.makeImage(b, sizeX[0], sizeY[0], 1, 
    147147      false, bpp, true); 
    148148    updateMinMax(bi, no); 
     
    594594    String originY = (String) getMeta("Origin Y"); 
    595595    String originZ = (String) getMeta("Origin Z"); 
    596      
     596 
    597597    try { 
    598       store.setStageLabel(null, originX == null ? null : new Float(originX),  
     598      store.setStageLabel(null, originX == null ? null : new Float(originX), 
    599599        originY == null ? null : new Float(originY), 
    600600        originZ == null ? null : new Float(originZ), null); 
  • trunk/loci/formats/in/PrairieReader.java

    r2313 r2320  
    8585    int xmlCount = 0; 
    8686    for (int i=0; i<listing.length; i++) { 
    87       if (listing[i].toLowerCase().endsWith(".xml")) xmlCount++;  
     87      if (listing[i].toLowerCase().endsWith(".xml")) xmlCount++; 
    8888    } 
    8989 
     
    350350        for (int i=0; i<listing.length; i++) { 
    351351          String path = listing[i].toLowerCase(); 
    352           if ((!readXML && path.endsWith(".xml")) ||  
     352          if ((!readXML && path.endsWith(".xml")) || 
    353353            (readXML && path.endsWith(".cfg"))) 
    354354          { 
  • trunk/loci/formats/in/SlidebookReader.java

    r2313 r2320  
    119119    throws FormatException, IOException 
    120120  { 
    121     BufferedImage b = ImageTools.makeImage(openBytes(id, no), width, height,  
     121    BufferedImage b = ImageTools.makeImage(openBytes(id, no), width, height, 
    122122      1, true, bpp, true); 
    123123    updateMinMax(b, no); 
     
    272272    if (sizeC[0] == 0) sizeC[0] = 1; 
    273273    if (sizeT[0] == 0) sizeT[0] = 1; 
    274    
     274 
    275275    MetadataStore store = getMetadataStore(currentId); 
    276276    store.setPixels(new Integer(sizeX[0]), new Integer(sizeY[0]), 
    277277      new Integer(sizeZ[0]), new Integer(sizeC[0]), new Integer(sizeT[0]), 
    278       new Integer(pixelType[0]), new Boolean(!little), currentOrder[0],  
    279       null, null);  
     278      new Integer(pixelType[0]), new Boolean(!little), currentOrder[0], 
     279      null, null); 
    280280    for (int i=0; i<sizeC[0]; i++) { 
    281281      store.setLogicalChannel(i, null, null, null, null, null, null, null); 
  • trunk/loci/formats/in/ZeissLSMReader.java

    r2313 r2320  
    252252 
    253253      RandomAccessStream ras = new RandomAccessStream(cz); 
    254     
     254 
    255255      put("MagicNumber", DataTools.read4UnsignedBytes(ras, little)); 
    256256      put("StructureSize", DataTools.read4SignedBytes(ras, little)); 
     
    299299          pixelType[0] = -1; 
    300300      } 
    301       
     301 
    302302      if (pixelType[0] == -1) { 
    303303        int[] bps = TiffTools.getBitsPerSample(ifd); 
     
    316316      put("VoxelSizeY", DataTools.readDouble(ras, little)); 
    317317      put("VoxelSizeZ", DataTools.readDouble(ras, little)); 
    318        
     318 
    319319      put("OriginX", DataTools.readDouble(ras, little)); 
    320320      put("OriginY", DataTools.readDouble(ras, little)); 
     
    323323      int scanType = DataTools.read2UnsignedBytes(ras, little); 
    324324      switch (scanType) { 
    325         case 0:  
    326           put("ScanType", "x-y-z scan");  
    327           currentOrder[0] = "XYZCT"; 
    328           break; 
    329         case 1:  
    330           put("ScanType", "z scan (x-z plane)");  
    331           currentOrder[0] = "XYZCT"; 
    332           break; 
    333         case 2:  
    334           put("ScanType", "line scan");  
    335           currentOrder[0] = "XYZCT"; 
    336           break; 
    337         case 3:  
    338           put("ScanType", "time series x-y");  
    339           currentOrder[0] = "XYTCZ"; 
    340           break; 
    341         case 4:  
    342           put("ScanType", "time series x-z");  
    343           currentOrder[0] = "XYZTC"; 
    344           break; 
    345         case 5: 
    346           put("ScanType", "time series 'Mean of ROIs'");  
    347           currentOrder[0] = "XYTCZ"; 
    348           break; 
    349         case 6:  
    350           put("ScanType", "time series x-y-z");  
    351           currentOrder[0] = "XYZTC"; 
    352           break; 
    353         case 7:  
    354           put("ScanType", "spline scan");  
    355           currentOrder[0] = "XYCTZ"; 
    356           break; 
    357         case 8:  
    358           put("ScanType", "spline scan x-z");  
    359           currentOrder[0] = "XYCZT"; 
    360           break; 
    361         case 9:  
    362           put("ScanType", "time series spline plane x-z");  
    363           currentOrder[0] = "XYTCZ"; 
    364           break; 
    365         case 10:  
    366           put("ScanType", "point mode");  
    367           currentOrder[0] = "XYZCT"; 
    368           break; 
    369         default:  
     325        case 0: 
    370326          put("ScanType", "x-y-z scan"); 
    371327          currentOrder[0] = "XYZCT"; 
    372       }  
    373       
     328          break; 
     329        case 1: 
     330          put("ScanType", "z scan (x-z plane)"); 
     331          currentOrder[0] = "XYZCT"; 
     332          break; 
     333        case 2: 
     334          put("ScanType", "line scan"); 
     335          currentOrder[0] = "XYZCT"; 
     336          break; 
     337        case 3: 
     338          put("ScanType", "time series x-y"); 
     339          currentOrder[0] = "XYTCZ"; 
     340          break; 
     341        case 4: 
     342          put("ScanType", "time series x-z"); 
     343          currentOrder[0] = "XYZTC"; 
     344          break; 
     345        case 5: 
     346          put("ScanType", "time series 'Mean of ROIs'"); 
     347          currentOrder[0] = "XYTCZ"; 
     348          break; 
     349        case 6: 
     350          put("ScanType", "time series x-y-z"); 
     351          currentOrder[0] = "XYZTC"; 
     352          break; 
     353        case 7: 
     354          put("ScanType", "spline scan"); 
     355          currentOrder[0] = "XYCTZ"; 
     356          break; 
     357        case 8: 
     358          put("ScanType", "spline scan x-z"); 
     359          currentOrder[0] = "XYCZT"; 
     360          break; 
     361        case 9: 
     362          put("ScanType", "time series spline plane x-z"); 
     363          currentOrder[0] = "XYTCZ"; 
     364          break; 
     365        case 10: 
     366          put("ScanType", "point mode"); 
     367          currentOrder[0] = "XYZCT"; 
     368          break; 
     369        default: 
     370          put("ScanType", "x-y-z scan"); 
     371          currentOrder[0] = "XYZCT"; 
     372      } 
     373 
    374374      MetadataStore store = getMetadataStore(currentId); 
    375375 
     
    395395        default: put("SpectralScan", "no spectral scan"); 
    396396      } 
    397        
     397 
    398398      long type = DataTools.read4UnsignedBytes(ras, little); 
    399399      switch ((int) type) { 
     
    403403        default: put("DataType2", "original scan data"); 
    404404      } 
    405        
     405 
    406406      long overlayOffset = DataTools.read4UnsignedBytes(ras, little); 
    407407      long inputLUTOffset = DataTools.read4UnsignedBytes(ras, little); 
     
    429429      long topoProfileOverlayOffset = DataTools.read4UnsignedBytes(ras, little); 
    430430      long linescanOverlayOffset = DataTools.read4UnsignedBytes(ras, little); 
    431        
     431 
    432432      put("ToolbarFlags", DataTools.read4UnsignedBytes(ras, little)); 
    433433      long channelWavelengthOffset = DataTools.read4UnsignedBytes(ras, little); 
     
    438438 
    439439      // read referenced structures 
    440     
     440 
    441441      if (overlayOffset != 0) { 
    442442        parseOverlays(overlayOffset, "OffsetVectorOverlay", little); 
     
    444444 
    445445      if (inputLUTOffset != 0) { 
    446         parseSubBlocks(inputLUTOffset, "OffsetInputLut", little);  
     446        parseSubBlocks(inputLUTOffset, "OffsetInputLut", little); 
    447447      } 
    448448 
     
    464464        } 
    465465 
    466         long namesOffset = in.readInt() + channelColorsOffset;  
     466        long namesOffset = in.readInt() + channelColorsOffset; 
    467467        int nameData = in.readInt(); 
    468468 
     
    475475 
    476476        // read in the channel names 
    477    
     477 
    478478        for (int i=0; i<numNames; i++) { 
    479479          // we want to read until we find a null char 
     
    520520 
    521521      if (meanOfRoisOverlayOffset != 0) { 
    522         parseOverlays(meanOfRoisOverlayOffset,  
     522        parseOverlays(meanOfRoisOverlayOffset, 
    523523          "OffsetMeanOfRoisOverlay", little); 
    524524      } 
    525525 
    526526      if (topoIsolineOverlayOffset != 0) { 
    527         parseOverlays(topoIsolineOverlayOffset,  
     527        parseOverlays(topoIsolineOverlayOffset, 
    528528          "OffsetTopoIsolineOverlay", little); 
    529529      } 
    530530 
    531531      if (topoProfileOverlayOffset != 0) { 
    532         parseOverlays(topoProfileOverlayOffset,  
     532        parseOverlays(topoProfileOverlayOffset, 
    533533          "OffsetTopoProfileOverlay", little); 
    534534      } 
  • trunk/loci/formats/in/ZeissZVIReader.java

    r2313 r2320  
    384384      zSize = zIndices.size(); 
    385385      tSize = tIndices.size(); 
    386       if (nChannels != cIndices.size()) nChannels *= cIndices.size();  
     386      if (nChannels != cIndices.size()) nChannels *= cIndices.size(); 
    387387 
    388388      sizeX[0] = width; 
     
    430430 
    431431        currentOrder[0] = "XY" + axes[maxNdx] + axes[medNdx] + axes[minNdx]; 
    432         
     432 
    433433        if (zIndex != null && tIndex != null) { 
    434434          int z = Integer.parseInt(DataTools.stripString(zIndex)); 
     
    494494    String pixY = (String) getMeta("Scale Factor for Y"); 
    495495    String pixZ = (String) getMeta("Scale Factor for Z"); 
    496      
     496 
    497497    store.setDimensions( 
    498498      pixX == null ? null : new Float(pixX), 
     
    500500      pixZ == null ? null : new Float(pixZ), 
    501501      null, null, null); 
    502      
     502 
    503503    for (int i=0; i<sizeC[0]; i++) { 
    504504      store.setLogicalChannel(i, null, null, null, null, null, null, null); 
     
    536536        byte[] data = new byte[numbytes + 4]; // append 0 for final offset 
    537537        r.setVar("data", data); 
    538          
     538 
    539539        // Suppressing an exception here looks like poor style. 
    540540        // However, this at least gives us a chance at reading files with 
     
    543543          r.exec("dis.read(data)"); 
    544544        } 
    545         catch (ReflectException e) {  
     545        catch (ReflectException e) { 
    546546          if (debug) e.printStackTrace(); 
    547547        } 
     
    758758          pt += 2; 
    759759          if (data[pt] == 0 && data[pt + 1] == 0) pt += 2; 
    760            
     760 
    761761          String typeDescription = ""; 
    762762          if (pt + len <= data.length) { 
Note: See TracChangeset for help on using the changeset viewer.