Changeset 2976 for trunk


Ignore:
Timestamp:
07/13/07 14:43:38 (13 years ago)
Author:
curtis
Message:

Whitespace.

Location:
trunk/loci/formats
Files:
61 edited

Legend:

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

    r2895 r2976  
    145145      } 
    146146 
    147       return ImageTools.splitChannels(lastImage, c,  
     147      return ImageTools.splitChannels(lastImage, c, 
    148148        FormatTools.getBytesPerPixel(getPixelType()), 
    149149        false, isInterleaved())[channel]; 
  • trunk/loci/formats/FileStitcher.java

    r2957 r2976  
    531531  /* @see IFormatReader#isOriginalMetadataPopulated() */ 
    532532  public boolean isOriginalMetadataPopulated() { 
    533     return reader.isOriginalMetadataPopulated();  
     533    return reader.isOriginalMetadataPopulated(); 
    534534  } 
    535535 
  • trunk/loci/formats/FormatReader.java

    r2958 r2976  
    6969 
    7070  /** Whether or not to save proprietary metadata in the MetadataStore. */ 
    71   protected boolean saveOriginalMetadata = false;  
     71  protected boolean saveOriginalMetadata = false; 
    7272 
    7373  /** Whether or not to group multi-file formats. */ 
     
    167167      if (!key.matches(".*[a-zA-Z].*")) return; 
    168168    } 
    169      
     169 
    170170    if (saveOriginalMetadata) { 
    171171      try { 
     
    184184      } 
    185185    } 
    186      
     186 
    187187    metadata.put(key, value); 
    188188  } 
  • trunk/loci/formats/IFormatReader.java

    r2957 r2976  
    192192  boolean isMetadataCollected(); 
    193193 
    194   /**  
    195    * Specifies whether or not to save proprietary metadata  
    196    * in the MetadataStore.  
     194  /** 
     195   * Specifies whether or not to save proprietary metadata 
     196   * in the MetadataStore. 
    197197   */ 
    198198  void setOriginalMetadataPopulated(boolean populate); 
    199199 
    200   /**  
    201    * Returns true if we should save proprietary metadata  
    202    * in the MetadataStore.  
     200  /** 
     201   * Returns true if we should save proprietary metadata 
     202   * in the MetadataStore. 
    203203   */ 
    204204  boolean isOriginalMetadataPopulated(); 
  • trunk/loci/formats/ImageReader.java

    r2957 r2976  
    435435  /* @see IFormatReader#isOriginalMetadataPopulated() */ 
    436436  public boolean isOriginalMetadataPopulated() { 
    437     return readers[0].isOriginalMetadataPopulated();  
     437    return readers[0].isOriginalMetadataPopulated(); 
    438438  } 
    439439 
  • trunk/loci/formats/ImageTools.java

    r2882 r2976  
    10261026   * channels are in BGR order. 
    10271027   */ 
    1028   public static byte[][] splitChannels(byte[] array, int c, int bytes,  
     1028  public static byte[][] splitChannels(byte[] array, int c, int bytes, 
    10291029    boolean reverse, boolean interleaved) 
    10301030  { 
     
    10531053              if (next < rtn[j].length) { 
    10541054                rtn[c - j - 1][next] = array[i + j*bytes + k]; 
    1055               }  
    1056               next++;  
     1055              } 
     1056              next++; 
    10571057            } 
    1058             next -= bytes;  
    1059           }  
    1060           next += bytes;  
     1058            next -= bytes; 
     1059          } 
     1060          next += bytes; 
    10611061        } 
    10621062      } 
     
    10671067            for (int k=0; k<bytes; k++) { 
    10681068              if (next < rtn[j].length) rtn[j][next] = array[i + j*bytes + k]; 
    1069               next++;  
     1069              next++; 
    10701070            } 
    1071             next -= bytes;  
    1072           }  
    1073           next += bytes;  
     1071            next -= bytes; 
     1072          } 
     1073          next += bytes; 
    10741074        } 
    10751075      } 
     
    18891889 
    18901890    BufferedImage result = null; 
    1891     try {  
     1891    try { 
    18921892      result = makeBuffered(scaleAWT(source, width, height, 
    18931893        Image.SCALE_AREA_AVERAGING), source.getColorModel()); 
    18941894    } 
    18951895    catch (Exception e) { 
    1896       result = makeBuffered(scaleAWT(source, width, height,  
     1896      result = makeBuffered(scaleAWT(source, width, height, 
    18971897        Image.SCALE_AREA_AVERAGING)); 
    1898     }  
     1898    } 
    18991899    return padImage(result, finalWidth, finalHeight); 
    19001900  } 
  • trunk/loci/formats/MinMaxCalculator.java

    r2905 r2976  
    7272 
    7373    int series = getSeries(); 
    74      
     74 
    7575    // check that all planes have been reade 
    7676    if (minMaxDone == null || minMaxDone[series] < getImageCount()) { 
     
    9393 
    9494    int series = getSeries(); 
    95      
     95 
    9696    // check that all planes have been reade 
    9797    if (minMaxDone == null || minMaxDone[series] < getImageCount()) { 
     
    229229    int numRGB = getRGBChannelCount(); 
    230230    int series = getSeries(); 
    231      
     231 
    232232    // check whether min/max values have already been computed for this plane 
    233233    if (planeMin[series][ndx * numRGB] == 
     
    357357      chanMax = new double[seriesCount][]; 
    358358      for (int i=0; i<seriesCount; i++) { 
    359         setSeries(i);   
     359        setSeries(i); 
    360360        chanMax[i] = new double[getSizeC()]; 
    361361        Arrays.fill(chanMax[i], Double.NEGATIVE_INFINITY); 
  • trunk/loci/formats/RandomAccessStream.java

    r2918 r2976  
    188188    else if (file.startsWith("http")) { 
    189189      raf = new RAUrl(Location.getMappedId(file), "r"); 
    190       length = raf.length();  
     190      length = raf.length(); 
    191191    } 
    192192    else throw new IOException("File not found : " + file); 
     
    699699    else { 
    700700      raf = new RAUrl(Location.getMappedId(file), "r"); 
    701       length = raf.length();  
     701      length = raf.length(); 
    702702    } 
    703703    fileCache.put(this, Boolean.TRUE); 
  • trunk/loci/formats/ReaderWrapper.java

    r2957 r2976  
    219219 
    220220  public void setOriginalMetadataPopulated(boolean populate) { 
    221     reader.setOriginalMetadataPopulated(populate);  
     221    reader.setOriginalMetadataPopulated(populate); 
    222222  } 
    223223 
    224224  public boolean isOriginalMetadataPopulated() { 
    225     return reader.isOriginalMetadataPopulated();  
     225    return reader.isOriginalMetadataPopulated(); 
    226226  } 
    227227 
  • trunk/loci/formats/TiffTools.java

    r2971 r2976  
    16421642 
    16431643    BitBuffer bb = new BitBuffer(bytes); 
    1644      
     1644 
    16451645    byte[] copyByteArray = new byte[numBytes]; 
    16461646    ByteBuffer nioBytes = MappedByteBuffer.wrap(bytes); 
  • trunk/loci/formats/cache/RectangleStrategy.java

    r2973 r2976  
    2424 * corresponding to the current dimensional position (Z2-T3). 
    2525 * <pre> 
    26  *      T  0  1  2  3  4  5  6  
     26 *      T  0  1  2  3  4  5  6 
    2727 *    Z /--------------------- 
    28  *    0 |    24 20  6 14 22    
    29  *    1 |    18 12  2 10 16   
    30  *    2 |     8  4  0  3  7    
    31  *    3 |    17 11  1  9 15    
    32  *    4 |    23 19  5 13 21    
     28 *    0 |    24 20  6 14 22 
     29 *    1 |    18 12  2 10 16 
     30 *    2 |     8  4  0  3  7 
     31 *    3 |    17 11  1  9 15 
     32 *    4 |    23 19  5 13 21 
    3333 * </pre> 
    3434 */ 
  • trunk/loci/formats/codec/AdobeDeflateCodec.java

    r2914 r2976  
    6464   *                         decompressor 
    6565   */ 
    66   public byte[] decompress(byte[] input, Object options)  
    67     throws FormatException  
     66  public byte[] decompress(byte[] input, Object options) 
     67    throws FormatException 
    6868  { 
    6969    try { 
  • trunk/loci/formats/codec/Base64Codec.java

    r2914 r2976  
    168168   * @throws FormatException if data is not valid Base64 data 
    169169   */ 
    170   public byte[] decompress(byte[] base64Data, Object options)  
    171     throws FormatException  
     170  public byte[] decompress(byte[] base64Data, Object options) 
     171    throws FormatException 
    172172  { 
    173173    // TODO: Add checks for invalid data. 
  • trunk/loci/formats/codec/BaseCodec.java

    r2914 r2976  
    164164   *   appropriate type. 
    165165   */ 
    166   public byte[] decompress(byte[][] data, Object options)  
    167     throws FormatException  
     166  public byte[] decompress(byte[][] data, Object options) 
     167    throws FormatException 
    168168  { 
    169169    int len = 0; 
  • trunk/loci/formats/codec/JPEGCodec.java

    r2914 r2976  
    6969      while (s.read() != (byte) 0xff || s.read() != (byte) 0xd8); 
    7070      int offset = (int) s.getFilePointer() - 2; 
    71       b = ImageIO.read(new BufferedInputStream(new ByteArrayInputStream(input,  
     71      b = ImageIO.read(new BufferedInputStream(new ByteArrayInputStream(input, 
    7272        offset, input.length - offset))); 
    7373    } 
  • trunk/loci/formats/codec/MJPBCodec.java

    r2914 r2976  
    3333    int x = o[0]; 
    3434    int y = o[1]; 
    35     int bits = o[2];  
     35    int bits = o[2]; 
    3636    boolean interlaced = o[3] == 1; 
    3737 
     
    4141    try { 
    4242      RandomAccessStream ras = new RandomAccessStream(data); 
    43       ras.order(false);  
     43      ras.order(false); 
    4444      ras.skipBytes(20); 
    45    
     45 
    4646      byte[] lumDcBits = null, lumAcBits = null, lumDc = null, lumAc = null; 
    4747      byte[] quant = null; 
     
    5252      ras.seek(ras.getFilePointer() - 20); 
    5353      ras.read(a); 
    54       String s2 = new String(a);  
    55       ras.skipBytes(12);  
     54      String s2 = new String(a); 
     55      ras.skipBytes(12); 
    5656      if (s1.equals("mjpg") || s2.equals("mjpg")) { 
    5757        int extra = 16; 
     
    6060          ras.seek(4); 
    6161        } 
    62         ras.skipBytes(12);  
    63      
     62        ras.skipBytes(12); 
     63 
    6464        int offset = ras.readInt() + extra; 
    6565        int quantOffset = ras.readInt() + extra; 
     
    7676          ras.read(quant); 
    7777        } 
    78     
     78 
    7979        if (huffmanOffset != 0) { 
    8080          ras.seek(huffmanOffset); 
     
    109109          tables[i] = ras.read(); 
    110110        } 
    111    
     111 
    112112        ras.seek(sod); 
    113113        int numBytes = (int) (offset - ras.getFilePointer()); 
     
    121121          ras.skipBytes(n); 
    122122          ras.seek(ras.getFilePointer() - 40); 
    123       
     123 
    124124          numBytes = (int) (ras.length() - ras.getFilePointer()); 
    125125          raw2 = new byte[numBytes]; 
     
    154154 
    155155      v.add(new byte[] {(byte) 0xff, (byte) 0xdb}); 
    156      
     156 
    157157      int length = 67; 
    158158      v.add((byte) ((length >>> 8) & 0xff)); 
     
    162162 
    163163      v.add(new byte[] {(byte) 0xff, (byte) 0xc4}); 
    164       length = (lumDcBits.length + lumDc.length + lumAcBits.length +  
     164      length = (lumDcBits.length + lumDc.length + lumAcBits.length + 
    165165        lumAc.length)*2 + 6; 
    166166      v.add((byte) ((length >>> 8) & 0xff)); 
     
    186186      v.add((byte) ((length >>> 8) & 0xff)); 
    187187      v.add((byte) (length & 0xff)); 
    188    
     188 
    189189      int fieldHeight = y; 
    190190      if (interlaced) fieldHeight /= 2; 
     
    230230        v.add((byte) 1); 
    231231      } 
    232   
     232 
    233233      v.add((byte) 0); 
    234234      v.add((byte) 0x3f); 
    235235      v.add((byte) 0); 
    236    
     236 
    237237      if (interlaced) { 
    238238        ByteVector v2 = new ByteVector(v.size()); 
     
    249249        byte[] top = jpeg.decompress(v.toByteArray()); 
    250250        byte[] bottom = jpeg.decompress(v2.toByteArray()); 
    251   
     251 
    252252        int bpp = bits < 40 ? bits / 8 : (bits - 32) / 8; 
    253         int ch = bits < 40 ? 3 : 1;  
     253        int ch = bits < 40 ? 3 : 1; 
    254254        byte[] result = new byte[x * y * bpp * ch]; 
    255   
     255 
    256256        int topNdx = 0; 
    257257        int bottomNdx = 0; 
    258          
     258 
    259259        for (int yy=0; yy<y; yy++) { 
    260260          if (yy % 2 == 0) { 
    261             System.arraycopy(top, topNdx*x*bpp, result, yy*x*bpp, x*bpp);  
    262             topNdx++;  
     261            System.arraycopy(top, topNdx*x*bpp, result, yy*x*bpp, x*bpp); 
     262            topNdx++; 
    263263          } 
    264264          else { 
    265265            System.arraycopy(bottom, bottomNdx*x*bpp, result, yy*x*bpp, x*bpp); 
    266             bottomNdx++;  
     266            bottomNdx++; 
    267267          } 
    268268        } 
  • trunk/loci/formats/codec/MSRLECodec.java

    r2917 r2976  
    1515  { 
    1616    throw new FormatException("MSRLE compression not supported."); 
    17   }  
     17  } 
    1818 
    1919  /* @see Codec#decompress(byte[], Object) */ 
    2020  public byte[] decompress(byte[] data, Object options) throws FormatException { 
    21     if (options == null || !(options instanceof Object[])) return null;  
     21    if (options == null || !(options instanceof Object[])) return null; 
    2222 
    2323    Object[] o = (Object[]) options; 
     
    6464            return prev; 
    6565          } 
    66         
     66 
    6767          code = stream; 
    6868          extra = (short) (stream & 0x01); 
     
    7474            pixelPt++; 
    7575          } 
    76           if (extra != 0) pt++;  
     76          if (extra != 0) pt++; 
    7777        } 
    7878      } 
     
    8181          return prev; 
    8282        } 
    83       
     83 
    8484        stream = data[pt++]; 
    8585 
     
    8989        } 
    9090      } 
    91     }  
     91    } 
    9292 
    9393    return prev; 
  • trunk/loci/formats/codec/QTRLECodec.java

    r2914 r2976  
    1616  { 
    1717    throw new FormatException("QTRLE compression not supported."); 
    18   }  
     18  } 
    1919 
    2020  /* @see Codec#decompress(byte[], Object) */ 
    2121  public byte[] decompress(byte[] data, Object options) throws FormatException { 
    22     if (options == null || !(options instanceof Object[])) return null;  
     22    if (options == null || !(options instanceof Object[])) return null; 
    2323 
    2424    Object[] o = (Object[]) options; 
     
    5252            off = i * x * bpp; 
    5353            System.arraycopy(prev, off, output, off, x * bpp); 
    54           }  
     54          } 
    5555        } 
    5656        off += x * bpp; 
     
    6565      else throw new FormatException("Unsupported header : " + header); 
    6666 
    67       // uncompress remaining lines  
    68   
     67      // uncompress remaining lines 
     68 
    6969      int skip = 0; // number of bytes to skip 
    7070      byte rle = 0; // RLE code 
     
    7878        if (prev != null) { 
    7979          try { 
    80             System.arraycopy(prev, rowPointer, output, rowPointer,  
     80            System.arraycopy(prev, rowPointer, output, rowPointer, 
    8181              (skip - 1) * bpp); 
    8282          } 
    83           catch (ArrayIndexOutOfBoundsException e) { }  
     83          catch (ArrayIndexOutOfBoundsException e) { } 
    8484        } 
    85      
     85 
    8686        off = rowPointer + ((skip - 1) * bpp); 
    8787        while (true) { 
     
    9797              catch (ArrayIndexOutOfBoundsException e) { } 
    9898            } 
    99          
    100             off += (skip - 1) * bpp;  
     99 
     100            off += (skip - 1) * bpp; 
    101101          } 
    102102          else if (rle == -1) { 
    103103            if (off < (rowPointer + (x * bpp)) && prev != null) { 
    104               System.arraycopy(prev, off, output, off, rowPointer +  
     104              System.arraycopy(prev, off, output, off, rowPointer + 
    105105                (x * bpp) - off); 
    106106            } 
    107             break;  
     107            break; 
    108108          } 
    109109          else if (rle < -1) { 
     
    115115                off += bpp; 
    116116              } 
    117               else break;  
     117              else break; 
    118118            } 
    119             s.skipBytes(bpp);  
     119            s.skipBytes(bpp); 
    120120          } 
    121121          else { 
     
    128128            if (len < 0) len = 0; 
    129129            if (off > output.length) off = output.length; 
    130             s.read(output, off, len);  
    131             off += len;  
     130            s.read(output, off, len); 
     131            off += len; 
    132132          } 
    133           if (s.getFilePointer() >= s.length()) return output;  
     133          if (s.getFilePointer() >= s.length()) return output; 
    134134        } 
    135         rowPointer += x * bpp;  
     135        rowPointer += x * bpp; 
    136136      } 
    137       return output;  
     137      return output; 
    138138    } 
    139139    catch (IOException e) { 
  • trunk/loci/formats/codec/RPZACodec.java

    r2914 r2976  
    22// RPZACodec.java 
    33// 
    4  
    54 
    65/* 
     
    3332 */ 
    3433public class RPZACodec extends BaseCodec implements Codec { 
    35   
     34 
    3635  /* @see Codec#compress(byte[], int, int, int[], Object) */ 
    3736  public byte[] compress(byte[] input, int x, int y, int[] dims, 
     
    6766    while (data[streamPtr] != (byte) 0xe1) streamPtr++; 
    6867    streamPtr += 4; 
    69      
     68 
    7069    totalBlocks = ((x + 3) / 4) * ((y + 3) / 4); 
    7170 
     
    8483        } 
    8584      } 
    86     
     85 
    8786      switch (opcode & 0xe0) { 
    8887        case 0x80: 
     
    9392              rowPtr += stride * 4; 
    9493            } 
    95             totalBlocks--;  
     94            totalBlocks--; 
    9695          } 
    9796          break; 
     
    107106 
    108107                short s = (short) (pixels[blockPtr] & 0x7fff); 
    109                 unpack(s, rtn, blockPtr, pixels.length);  
     108                unpack(s, rtn, blockPtr, pixels.length); 
    110109                blockPtr++; 
    111110              } 
    112               blockPtr += rowInc;  
     111              blockPtr += rowInc; 
    113112            } 
    114113            pixelPtr += 4; 
     
    117116              rowPtr += stride * 4; 
    118117            } 
    119             totalBlocks--;  
     118            totalBlocks--; 
    120119          } 
    121120          break; 
     
    125124            colorA = DataTools.bytesToInt(data, streamPtr, 2, false); 
    126125            streamPtr += 2; 
    127           }  
    128        
     126          } 
     127 
    129128          colorB = DataTools.bytesToInt(data, streamPtr, 2, false); 
    130129          streamPtr += 2; 
     
    134133          color4[2] = 0; 
    135134          color4[3] = colorA; 
    136          
     135 
    137136          ta = (colorA >> 10) & 0x1f; 
    138137          tb = (colorB >> 10) & 0x1f; 
     
    171170              rowPtr += stride * 4; 
    172171            } 
    173             totalBlocks--;  
     172            totalBlocks--; 
    174173          } 
    175174          break; 
     
    189188              blockPtr++; 
    190189            } 
    191             blockPtr += rowInc;  
     190            blockPtr += rowInc; 
    192191          } 
    193192          pixelPtr += 4; 
     
    200199      } 
    201200    } 
    202     return rtn;  
     201    return rtn; 
    203202  } 
    204203 
  • trunk/loci/formats/gui/CacheComponent.java

    r2967 r2976  
    1414 
    1515/** GUI component for managing a cache. */ 
    16 public class CacheComponent extends JPanel  
     16public class CacheComponent extends JPanel 
    1717  implements ActionListener, ChangeListener 
    1818{ 
     
    2121 
    2222  /** The cache that this component controls. */ 
    23   private Cache cache;  
     23  private Cache cache; 
    2424 
    2525  /** File that the cache is working with. */ 
     
    4141 
    4242  public CacheComponent(Cache cache, boolean doSource, String[] axisLabels, 
    43     String file, int[] lengths)  
     43    String file, int[] lengths) 
    4444  { 
    4545    super(); 
     
    6161    top.setLayout(layout); 
    6262 
    63     // add source choices, if desired  
    64     JComboBox sourceChooser = null;  
     63    // add source choices, if desired 
     64    JComboBox sourceChooser = null; 
    6565    if (doSource) { 
    6666      JLabel label = new JLabel("Objects to cache: "); 
    6767      top.add(label, cc.xy(2, 2)); 
    68       String[] sources =  
     68      String[] sources = 
    6969        new String[] {"byte arrays", "BufferedImages", "ImageProcessors"}; 
    7070      sourceChooser = new JComboBox(sources); 
     
    7878    JLabel label = new JLabel("Caching strategy: "); 
    7979    top.add(label, cc.xy(2, doSource ? 4 : 2)); 
    80     String[] strategies = new String[] {"Crosshair - forward first",  
    81       "Crosshair - backward first", "Rectangle - forward first",  
     80    String[] strategies = new String[] {"Crosshair - forward first", 
     81      "Crosshair - backward first", "Rectangle - forward first", 
    8282      "Rectangle - backward first"}; 
    83     JComboBox strategyChooser = new JComboBox(strategies);  
    84     strategyChooser.setActionCommand("strategy");  
    85     strategyChooser.addActionListener(this);  
     83    JComboBox strategyChooser = new JComboBox(strategies); 
     84    strategyChooser.setActionCommand("strategy"); 
     85    strategyChooser.addActionListener(this); 
    8686    top.add(strategyChooser, cc.xy(4, doSource ? 4 : 2)); 
    8787 
     
    112112      middle.add(f, cc.xy(4, i*2 + 4)); 
    113113      JSpinner b = new JSpinner(new SpinnerNumberModel(1, 0, lengths[i], 1)); 
    114       middle.add(b, cc.xy(6, i*2 + 4));  
     114      middle.add(b, cc.xy(6, i*2 + 4)); 
    115115      forward.add(f); 
    116116      backward.add(b); 
     
    139139 
    140140    for (int i=0; i<axisLabels.length; i++) { 
    141       JLabel l = new JLabel("");  
     141      JLabel l = new JLabel(""); 
    142142      if (i % skip == 0) { 
    143143        l = new JLabel(priorities[i / skip]); 
     
    148148      for (int j=0; j<axisLabels.length; j++) { 
    149149        JRadioButton button = new JRadioButton(axisLabels[j], i == j); 
    150         priority[i][j] = button;  
    151         button.addChangeListener(this);  
    152         g.add(button);  
    153         bottom.add(button, cc.xy((j + 2) * 2, (i + 1) * 2));  
     150        priority[i][j] = button; 
     151        button.addChangeListener(this); 
     152        g.add(button); 
     153        bottom.add(button, cc.xy((j + 2) * 2, (i + 1) * 2)); 
    154154      } 
    155155    } 
     
    158158 
    159159    JButton reset = new JButton("Reset"); 
    160     reset.setActionCommand("reset");  
     160    reset.setActionCommand("reset"); 
    161161    reset.addActionListener(this); 
    162     add(reset);  
     162    add(reset); 
    163163  } 
    164164 
     
    169169  } 
    170170 
    171   // -- ActionListener API methods --  
     171  // -- ActionListener API methods -- 
    172172 
    173173  public void actionPerformed(ActionEvent e) { 
     
    178178    } 
    179179    else if (cmd.equals("source")) { 
    180       updateSource((JComboBox) e.getSource());  
     180      updateSource((JComboBox) e.getSource()); 
    181181    } 
    182182    else if (cmd.equals("strategy")) { 
    183       updateStrategy((JComboBox) e.getSource());  
     183      updateStrategy((JComboBox) e.getSource()); 
    184184    } 
    185185  } 
     
    188188 
    189189  public void stateChanged(ChangeEvent e) { 
    190     // make sure each axis is chosen only once  
     190    // make sure each axis is chosen only once 
    191191    for (int ct=0; ct<priority.length; ct++) { 
    192192      for (int col=0; col<priority.length; col++) { 
    193193        int chosenNdx = -1; 
    194          
     194 
    195195        for (int row=0; row<priority.length; row++) { 
    196196          if (priority[row][col].equals(e.getSource()) && 
    197             priority[row][col].isSelected())  
     197            priority[row][col].isSelected()) 
    198198          { 
    199199            chosenNdx = row; 
     
    203203            chosenNdx = row; 
    204204          } 
    205         }  
    206          
     205        } 
     206 
    207207        for (int row=0; row<priority.length; row++) { 
    208208          if (priority[row][col].isSelected() && row != chosenNdx) { 
     
    211211        } 
    212212      } 
    213     }  
    214    
    215     // reset the cache's priorities  
     213    } 
     214 
     215    // reset the cache's priorities 
    216216    ICacheStrategy strategy = cache.getStrategy(); 
    217217 
     
    219219      for (int col=0; col<priority.length; col++) { 
    220220        if (priority[row][col].isSelected()) { 
    221           strategy.setPriority(row, col);  
     221          strategy.setPriority(row, col); 
    222222        } 
    223223      } 
    224224    } 
    225     
     225 
    226226    for (int i=0; i<forward.size(); i++) { 
    227227      JSpinner f = (JSpinner) forward.get(i); 
     
    239239      n[i] = ((Integer) ((JSpinner) forward.get(i)).getValue()).intValue(); 
    240240    } 
    241     return n;  
     241    return n; 
    242242  } 
    243243 
     
    247247      n[i] = ((Integer) ((JSpinner) backward.get(i)).getValue()).intValue(); 
    248248    } 
    249     return n;  
    250   }  
     249    return n; 
     250  } 
    251251 
    252252  private void updateSource(JComboBox box) { 
    253     String s = (String) box.getSelectedItem();  
     253    String s = (String) box.getSelectedItem(); 
    254254 
    255255    CacheSource source = null; 
    256256    try { 
    257257      if (s.equals("byte arrays")) { 
    258         source = new ByteArraySource(file);   
     258        source = new ByteArraySource(file); 
    259259      } 
    260260      else if (s.equals("BufferedImages")) { 
    261         source = new BufferedImageSource(file);   
     261        source = new BufferedImageSource(file); 
    262262      } 
    263263      else if (s.equals("ImageProcessors")) { 
    264         source = new ImageProcessorSource(file);   
     264        source = new ImageProcessorSource(file); 
    265265      } 
    266266      cache.setSource(source); 
     
    289289      int[] bwd = getBackward(); 
    290290//      for (int i=0; i<bwd.length; i++) strategy.setBackward(bwd[i], i); 
    291       cache.setStrategy(strategy);  
     291      cache.setStrategy(strategy); 
    292292    } 
    293293    catch (CacheException exc) { 
  • trunk/loci/formats/in/AVIReader.java

    r2917 r2976  
    127127 
    128128      MSRLECodec codec = new MSRLECodec(); 
    129       b = codec.decompress(b, options);  
    130       lastImage = b;  
     129      b = codec.decompress(b, options); 
     130      lastImage = b; 
    131131      if (no == core.imageCount[0] - 1) lastImage = null; 
    132132      byte[] colors = new byte[b.length * 3]; 
  • trunk/loci/formats/in/BMPReader.java

    r2922 r2976  
    128128        for (int y=core.sizeY[0]-1; y>=0; y--) { 
    129129          for (int x=0; x<core.sizeX[0]; x++) { 
    130             int off = y*core.sizeX[0] + x;  
     130            int off = y*core.sizeX[0] + x; 
    131131            buf[2*core.sizeX[0]*core.sizeY[0] + off] = (byte)(in.read() & 0xff); 
    132132            buf[core.sizeX[0]*core.sizeY[0] + off] = (byte) (in.read() & 0xff); 
     
    233233 
    234234    status("Populating metadata"); 
    235      
     235 
    236236    core.sizeC[0] = (palette == null && bpp == 8) ? 1 : 3; 
    237237    if (bpp > 8) bpp /= 3; 
  • trunk/loci/formats/in/BioRadReader.java

    r2922 r2976  
    8686  public String[] getUsedFiles() { 
    8787    FormatTools.assertId(currentId, true, 1); 
    88     return (String[]) used.toArray(new String[0]);  
     88    return (String[]) used.toArray(new String[0]); 
    8989  } 
    9090 
     
    218218      int x = in.readShort(); 
    219219      int y = in.readShort(); 
    220       String text = in.readString(80);  
     220      String text = in.readString(80); 
    221221 
    222222      // be sure to remove binary data from the note text 
     
    652652          new Location(parent.getAbsolutePath(), list[i]).getAbsolutePath()); 
    653653        used.add(new Location( 
    654           parent.getAbsolutePath(), list[i]).getAbsolutePath());  
     654          parent.getAbsolutePath(), list[i]).getAbsolutePath()); 
    655655        String line = raw.readLine(); 
    656656        while (line != null && line.length() > 0) { 
     
    668668          new Location(parent.getAbsolutePath(), list[i]).getAbsolutePath()); 
    669669        used.add(new Location( 
    670           parent.getAbsolutePath(), list[i]).getAbsolutePath());  
     670          parent.getAbsolutePath(), list[i]).getAbsolutePath()); 
    671671        byte[] b = new byte[(int) raw.length()]; 
    672672        raw.read(b); 
  • trunk/loci/formats/in/DeltavisionReader.java

    r2922 r2976  
    8181  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
    8282  public boolean isThisType(byte[] block) { 
    83     return false;  
     83    return false; 
    8484  } 
    8585 
     
    570570      byte[] extHeader, boolean little) 
    571571    { 
    572       try {  
    573         RandomAccessStream ext = new RandomAccessStream(extHeader);  
    574         ext.order(little);  
     572      try { 
     573        RandomAccessStream ext = new RandomAccessStream(extHeader); 
     574        ext.order(little); 
    575575 
    576576        // skip over the int values that have nothing in them 
    577577        offsetWithInts = startingOffset + (numIntsPerSection * 4); 
    578578 
    579         // DV files store the ND (neuatral density) Filter  
    580         // (normally expressed as a %T (transmittance)) as an OD  
     579        // DV files store the ND (neuatral density) Filter 
     580        // (normally expressed as a %T (transmittance)) as an OD 
    581581        // (optical density) rating. 
    582582        // To convert from one to the other the formula is %T = 10^(-OD) X 100. 
     
    585585 
    586586        // fill in the extended header information for the floats 
    587         ext.seek(offsetWithInts);  
    588         photosensorReading = ext.readFloat();  
    589         timeStampSeconds = ext.readFloat();  
    590         stageXCoord = ext.readFloat();  
     587        ext.seek(offsetWithInts); 
     588        photosensorReading = ext.readFloat(); 
     589        timeStampSeconds = ext.readFloat(); 
     590        stageXCoord = ext.readFloat(); 
    591591        stageYCoord = ext.readFloat(); 
    592592        stageZCoord = ext.readFloat(); 
    593         minInten = ext.readFloat();  
    594         maxInten = ext.readFloat();  
     593        minInten = ext.readFloat(); 
     594        maxInten = ext.readFloat(); 
    595595        meanInten = ext.readFloat(); 
    596         expTime = ext.readFloat();  
     596        expTime = ext.readFloat(); 
    597597        ndFilter = (float) Math.pow(10.0, -oDFilter); 
    598         ext.skipBytes(4);  
    599       
     598        ext.skipBytes(4); 
     599 
    600600        exFilter = ext.readFloat(); 
    601601        emFilter = ext.readFloat(); 
    602         exWavelen = ext.readFloat();   
     602        exWavelen = ext.readFloat(); 
    603603        emWavelen = ext.readFloat(); 
    604604        intenScaling = ext.readFloat(); 
    605         energyConvFactor = ext.readFloat();  
     605        energyConvFactor = ext.readFloat(); 
    606606      } 
    607607      catch (IOException e) { 
  • trunk/loci/formats/in/DicomReader.java

    r2922 r2976  
    182182      switch (tag) { 
    183183        case TRANSFER_SYNTAX_UID: 
    184           s = in.readString(elementLength);  
     184          s = in.readString(elementLength); 
    185185          addInfo(tag, s); 
    186186          if (s.indexOf("1.2.4") > -1 || s.indexOf("1.2.5") > -1) { 
  • trunk/loci/formats/in/EPSReader.java

    r2922 r2976  
    6464  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
    6565  public boolean isThisType(byte[] block) { 
    66     return false;  
     66    return false; 
    6767  } 
    6868 
     
    9191      long[] offsets = TiffTools.getStripOffsets(ifds[0]); 
    9292      in.seek(offsets[0]); 
    93       
    94       int[] map = TiffTools.getIFDIntArray(ifds[0], TiffTools.COLOR_MAP, false);  
     93 
     94      int[] map = TiffTools.getIFDIntArray(ifds[0], TiffTools.COLOR_MAP, false); 
    9595      if (map == null) { 
    9696        in.read(buf); 
    97         return buf;  
     97        return buf; 
    9898      } 
    9999 
     
    101101      for (int i=0; i<b.length; i++) { 
    102102        b[i] = (byte) in.read(); 
    103         in.read();  
     103        in.read(); 
    104104      } 
    105105 
    106106      for (int i=0; i<b.length; i++) { 
    107         int ndx = b[i];  
    108         if (ndx < 0) ndx += 256;  
     107        int ndx = b[i]; 
     108        if (ndx < 0) ndx += 256; 
    109109        for (int j=0; j<core.sizeC[0]; j++) { 
    110110          buf[i*core.sizeC[0] + j] = (byte) map[ndx + j*256]; 
    111111        } 
    112112      } 
    113        
    114       return buf;  
     113 
     114      return buf; 
    115115    } 
    116116 
     
    151151    FormatTools.assertId(currentId, true, 1); 
    152152    return ImageTools.makeImage(openBytes(no), core.sizeX[0], core.sizeY[0], 
    153       core.sizeC[0], core.interleaved[0],  
     153      core.sizeC[0], core.interleaved[0], 
    154154      FormatTools.getBytesPerPixel(core.pixelType[0]), core.littleEndian[0]); 
    155155  } 
     
    167167    String line = in.readLine(); 
    168168    if (!line.trim().startsWith("%!PS")) { 
    169       // read the TIFF preview  
    170      
     169      // read the TIFF preview 
     170 
    171171      isTiff = true; 
    172172 
     
    188188      core.sizeT[0] = 1; 
    189189      core.sizeC[0] = TiffTools.getSamplesPerPixel(ifds[0]); 
    190       if (core.sizeC[0] == 2) core.sizeC[0] = 3;  
     190      if (core.sizeC[0] == 2) core.sizeC[0] = 3; 
    191191      core.littleEndian[0] = TiffTools.isLittleEndian(ifds[0]); 
    192192      core.interleaved[0] = true; 
    193193      core.rgb[0] = core.sizeC[0] > 1; 
    194        
     194 
    195195      bps = TiffTools.getBitsPerSample(ifds[0])[0]; 
    196196      switch (bps) { 
    197         case 16: core.pixelType[0] = FormatTools.UINT16; break;  
    198         case 32: core.pixelType[0] = FormatTools.UINT32; break;  
    199         default: core.pixelType[0] = FormatTools.UINT8;  
    200       }  
    201     
     197        case 16: core.pixelType[0] = FormatTools.UINT16; break; 
     198        case 32: core.pixelType[0] = FormatTools.UINT32; break; 
     199        default: core.pixelType[0] = FormatTools.UINT8; 
     200      } 
     201 
    202202      core.imageCount[0] = 1; 
    203203      core.currentOrder[0] = "XYCZT"; 
    204204 
    205       return;  
     205      return; 
    206206    } 
    207207 
  • trunk/loci/formats/in/FitsReader.java

    r2970 r2976  
    3333 * Flexible Image Transport System (FITS) images. 
    3434 * 
    35  * Much of this code was adapted from ImageJ (http://rsb.info.nih.gov/ij).  
     35 * Much of this code was adapted from ImageJ (http://rsb.info.nih.gov/ij). 
    3636 */ 
    3737public class FitsReader extends FormatReader { 
     
    5050 
    5151  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
    52   public boolean isThisType(byte[] block) {  
     52  public boolean isThisType(byte[] block) { 
    5353    return true; 
    5454  } 
     
    5757  public byte[] openBytes(int no) throws FormatException, IOException { 
    5858    FormatTools.assertId(currentId, true, 1); 
    59     byte[] buf = new byte[core.sizeX[0] * core.sizeY[0] *  
     59    byte[] buf = new byte[core.sizeX[0] * core.sizeY[0] * 
    6060      FormatTools.getBytesPerPixel(core.pixelType[0])]; 
    61     return openBytes(no, buf);  
     61    return openBytes(no, buf); 
    6262  } 
    6363 
     
    7070      throw new FormatException("Invalid image number: " + no); 
    7171    } 
    72     if (buf.length < core.sizeX[0] * core.sizeY[0] *  
    73       FormatTools.getBytesPerPixel(core.pixelType[0]))  
     72    if (buf.length < core.sizeX[0] * core.sizeY[0] * 
     73      FormatTools.getBytesPerPixel(core.pixelType[0])) 
    7474    { 
    7575      throw new FormatException("Buffer too small."); 
     
    7777 
    7878    in.seek(2880 + 2880 * (((count * 80) - 1) / 2880)); 
    79     int line = core.sizeX[0] * FormatTools.getBytesPerPixel(core.pixelType[0]);  
     79    int line = core.sizeX[0] * FormatTools.getBytesPerPixel(core.pixelType[0]); 
    8080    for (int y=core.sizeY[0]-1; y>=0; y--) { 
    81       in.read(buf, y*line, line);  
     81      in.read(buf, y*line, line); 
    8282    } 
    8383    return buf; 
     
    8787  public BufferedImage openImage(int no) throws FormatException, IOException { 
    8888    return ImageTools.makeImage(openBytes(no), core.sizeX[0], core.sizeY[0], 
    89       core.sizeC[0], core.interleaved[0],  
     89      core.sizeC[0], core.interleaved[0], 
    9090      FormatTools.getBytesPerPixel(core.pixelType[0]), core.littleEndian[0]); 
    9191  } 
     
    103103      throw new FormatException("Unsupported FITS file."); 
    104104    } 
    105    
     105 
    106106    while (true) { 
    107107      count++; 
    108       line = in.readString(80);  
     108      line = in.readString(80); 
    109109 
    110       // parse key/value pair  
     110      // parse key/value pair 
    111111      int ndx = line.indexOf("="); 
    112112      int comment = line.indexOf("/", ndx); 
     
    120120      } 
    121121      else key = line.trim(); 
    122        
     122 
    123123      if (key.equals("END")) break; 
    124124 
     
    133133        } 
    134134      } 
    135       else if (key.equals("NAXIS1")) core.sizeX[0] = Integer.parseInt(value);  
    136       else if (key.equals("NAXIS2")) core.sizeY[0] = Integer.parseInt(value);  
    137       else if (key.equals("NAXIS3")) core.sizeZ[0] = Integer.parseInt(value);  
     135      else if (key.equals("NAXIS1")) core.sizeX[0] = Integer.parseInt(value); 
     136      else if (key.equals("NAXIS2")) core.sizeY[0] = Integer.parseInt(value); 
     137      else if (key.equals("NAXIS3")) core.sizeZ[0] = Integer.parseInt(value); 
    138138 
    139       addMeta(key, value);  
     139      addMeta(key, value); 
    140140    } 
    141    
    142     core.sizeC[0] = 1;   
    143     core.sizeT[0] = 1;   
     141 
     142    core.sizeC[0] = 1; 
     143    core.sizeT[0] = 1; 
    144144    if (core.sizeZ[0] == 0) core.sizeZ[0] = 1; 
    145145    core.imageCount[0] = core.sizeZ[0]; 
     
    148148    core.interleaved[0] = false; 
    149149    core.currentOrder[0] = "XYZCT"; 
    150    
     150 
    151151    MetadataStore store = getMetadataStore(); 
    152152    store.setPixels(new Integer(core.sizeX[0]), new Integer(core.sizeY[0]), 
     
    154154      new Integer(core.sizeT[0]), new Integer(core.pixelType[0]), 
    155155      new Boolean(!core.littleEndian[0]), core.currentOrder[0], null, null); 
    156    
    157     store.setLogicalChannel(0, null, null, null, null,  
     156 
     157    store.setLogicalChannel(0, null, null, null, null, 
    158158      "monochrome", null, null); 
    159159  } 
  • trunk/loci/formats/in/FluoviewReader.java

    r2922 r2976  
    105105    if (core.sizeY[0] == TiffTools.getImageLength(ifds[0])) { 
    106106      return super.openBytes(no); 
    107     }  
    108     return openBytes(no, new byte[core.sizeX[0] *  
    109       FormatTools.getBytesPerPixel(core.pixelType[0])]);  
     107    } 
     108    return openBytes(no, new byte[core.sizeX[0] * 
     109      FormatTools.getBytesPerPixel(core.pixelType[0])]); 
    110110  } 
    111111 
     
    116116    if (core.sizeY[0] == TiffTools.getImageLength(ifds[0])) { 
    117117      return super.openBytes(no, buf); 
    118     }  
     118    } 
    119119    FormatTools.assertId(currentId, false, 1); 
    120120    if (no < 0 || no >= core.imageCount[0]) { 
    121121      throw new FormatException("Invalid image number: " + no); 
    122     }  
    123     if (buf.length < core.sizeX[0] *  
    124       FormatTools.getBytesPerPixel(core.pixelType[0]))  
     122    } 
     123    if (buf.length < core.sizeX[0] * 
     124      FormatTools.getBytesPerPixel(core.pixelType[0])) 
    125125    { 
    126126      throw new FormatException("Buffer too small."); 
    127127    } 
    128    
     128 
    129129    byte[] b = super.openBytes(0); 
    130130    System.arraycopy(b, 0, buf, 0, buf.length); 
     
    136136    if (core.sizeY[0] == TiffTools.getImageLength(ifds[0])) { 
    137137      return super.openImage(no); 
    138     }  
    139      
     138    } 
     139 
    140140    if (zeroImage == null) zeroImage = super.openImage(0); 
    141     return zeroImage.getSubimage(0, no, core.sizeX[0], 1);  
     141    return zeroImage.getSubimage(0, no, core.sizeX[0], 1); 
    142142  } 
    143143 
     
    309309    core.imageCount[0] = ifds.length; 
    310310 
    311     if (core.imageCount[0] == 1 && (core.sizeT[0] == core.sizeY[0] ||  
     311    if (core.imageCount[0] == 1 && (core.sizeT[0] == core.sizeY[0] || 
    312312      core.sizeZ[0] == core.sizeY[0]) && (core.sizeT[0] > core.imageCount[0] || 
    313       core.sizeZ[0] > core.imageCount[0]))  
     313      core.sizeZ[0] > core.imageCount[0])) 
    314314    { 
    315315      core.sizeY[0] = 1; 
    316316      core.imageCount[0] = core.sizeZ[0] * core.sizeT[0] * core.sizeC[0]; 
    317     }  
    318      
     317    } 
     318 
    319319    // cut up the comment, if necessary 
    320320    String comment = (String) getMeta("Comment"); 
  • trunk/loci/formats/in/GIFReader.java

    r2922 r2976  
    133133    int[] ints = (int[]) images.get(no); 
    134134    if (no > 0) { 
    135       int[] prev = (int[]) images.get(no - 1);  
     135      int[] prev = (int[]) images.get(no - 1); 
    136136      for (int i=0; i<ints.length; i++) { 
    137137        if ((ints[i] & 0x00ffffff) == 0) { 
     
    139139        } 
    140140      } 
    141       images.setElementAt(ints, no);  
     141      images.setElementAt(ints, no); 
    142142    } 
    143143 
     
    188188    gctSize = 2 << (packed & 7); 
    189189    bgIndex = in.read() & 0xff; 
    190     in.skipBytes(1);  
     190    in.skipBytes(1); 
    191191 
    192192    if (gctFlag) { 
     
    220220          iw = in.readShort(); 
    221221          ih = in.readShort(); 
    222            
     222 
    223223          packed = in.read(); 
    224224          lctFlag = (packed & 0x80) != 0; 
     
    281281          switch (code) { 
    282282            case 0xf9: // graphics control extension 
    283               in.skipBytes(1);  
     283              in.skipBytes(1); 
    284284              packed = in.read() & 0xff; 
    285285              dispose = (packed & 0x1c) >> 1; 
    286286              transparency = (packed & 1) != 0; 
    287               in.skipBytes(2);  
     287              in.skipBytes(2); 
    288288              transIndex = in.read() & 0xff; 
    289               in.skipBytes(1);  
     289              in.skipBytes(1); 
    290290              break; 
    291291            case 0xff:  // application extension 
     
    394394 
    395395    // initialize GIF data stream decoder 
    396      
     396 
    397397    dataSize = in.read() & 0xff; 
    398398 
  • trunk/loci/formats/in/GatanReader.java

    r2922 r2976  
    6060  public boolean isThisType(byte[] block) { 
    6161    if (block == null || block.length < 4) return false; 
    62     return DataTools.bytesToInt(block, false) == 3;  
     62    return DataTools.bytesToInt(block, false) == 3; 
    6363  } 
    6464 
     
    213213    for (int i=0; i<numTags; i++) { 
    214214      byte type = in.readByte();  // can be 21 (data) or 20 (tag group) 
    215       int length = in.readShort();  
     215      int length = in.readShort(); 
    216216      String labelString = in.readString(length); 
    217217 
     
    222222      if (type == 21) { 
    223223        in.skipBytes(4);  // equal to '%%%%' 
    224         int n = in.readInt();  
     224        int n = in.readInt(); 
    225225        int dataType = 0; 
    226226        if (n == 1) { 
    227           dataType = in.readInt();  
     227          dataType = in.readInt(); 
    228228          String data; 
    229           in.order(core.littleEndian[0]);  
     229          in.order(core.littleEndian[0]); 
    230230          switch (dataType) { 
    231231            case 2: 
    232             case 4:  
     232            case 4: 
    233233              data = "" + in.readShort(); 
    234234              break; 
    235235            case 3: 
    236             case 5:   
     236            case 5: 
    237237              data = "" + in.readInt(); 
    238238              break; 
     
    266266          addMeta(labelString, data); 
    267267          if (labelString.equals("DataType")) datatype = Integer.parseInt(data); 
    268           in.order(!core.littleEndian[0]);  
     268          in.order(!core.littleEndian[0]); 
    269269        } 
    270270        else if (n == 2) { 
     
    272272          dataType = in.readInt(); 
    273273          if (dataType == 18) { // this should always be true 
    274             length = in.readInt();  
     274            length = in.readInt(); 
    275275          } 
    276276          addMeta(labelString, in.readString(length)); 
    277           in.order(!core.littleEndian[0]);  
     277          in.order(!core.littleEndian[0]); 
    278278        } 
    279279        else if (n == 3) { 
    280280          dataType = in.readInt(); 
    281281          if (dataType == 20) { // this should always be true 
    282             dataType = in.readInt();  
    283             length = in.readInt();  
     282            dataType = in.readInt(); 
     283            length = in.readInt(); 
    284284 
    285285            if ("Data".equals(labelString)) pixelDataNum++; 
     
    324324          if (dataType == 15) { 
    325325            int skip = in.readInt(); 
    326             int numFields = in.readInt();  
     326            int numFields = in.readInt(); 
    327327            for (int j=0; j<numFields; j++) { 
    328               skip += in.readInt();  
    329               dataType = in.readInt();  
     328              skip += in.readInt(); 
     329              dataType = in.readInt(); 
    330330 
    331331              switch (dataType) { 
     
    355355            dataType = in.readInt(); 
    356356            if (dataType == 15) { // should always be true 
    357               skip += in.readInt();  
    358               int numFields = in.readInt();  
     357              skip += in.readInt(); 
     358              int numFields = in.readInt(); 
    359359              for (int j=0; j<numFields; j++) { 
    360                 skip += in.readInt();  
    361                 dataType = in.readInt();  
     360                skip += in.readInt(); 
     361                dataType = in.readInt(); 
    362362 
    363363                switch (dataType) { 
    364364                  case 2: 
    365                   case 4:   
     365                  case 4: 
    366366                    skip += 2; 
    367367                    break; 
     
    388388      else if (type == 20) { 
    389389        in.skipBytes(2); 
    390         parseTags(in.readInt(), labelString);  
     390        parseTags(in.readInt(), labelString); 
    391391      } 
    392392    } 
  • trunk/loci/formats/in/IPLabReader.java

    r2922 r2976  
    215215        if (size == 8) { 
    216216          // indexed lookup table 
    217           in.skipBytes(4);  
     217          in.skipBytes(4); 
    218218          int type = in.readInt(); 
    219219 
    220220          String[] types = new String[] { 
    221221            "monochrome", "reverse monochrome", "BGR", "classify", "rainbow", 
    222             "red", "green", "blue", "cyan", "magenta", "yellow",  
     222            "red", "green", "blue", "cyan", "magenta", "yellow", 
    223223            "saturated pixels" 
    224224          }; 
     
    246246          int source = in.readInt(); 
    247247          String[] types = new String[] { 
    248             "user", "plane", "sequence", "saturated plane",  
     248            "user", "plane", "sequence", "saturated plane", 
    249249            "saturated sequence", "ROI" 
    250250          }; 
    251251 
    252           String sourceType = (source >= 0 && source < types.length) ?  
     252          String sourceType = (source >= 0 && source < types.length) ? 
    253253            types[source] : "user"; 
    254254          addMeta("NormalizationSource" + i, sourceType); 
     
    313313      else if (tag.equals("unit")) { 
    314314        // read in units 
    315         in.skipBytes(4);  
     315        in.skipBytes(4); 
    316316 
    317317        for (int i=0; i<4; i++) { 
  • trunk/loci/formats/in/IPWReader.java

    r2922 r2976  
    366366      if (debug) trace(t); 
    367367    } 
    368    
    369     core.interleaved[0] = true;  
     368 
     369    core.interleaved[0] = true; 
    370370  } 
    371371 
     
    445445          core.imageCount[0]++; 
    446446        } 
    447         ds.close();  
     447        ds.close(); 
    448448        r.exec("dis.close()"); 
    449449        if (debug) { 
  • trunk/loci/formats/in/ImarisReader.java

    r2922 r2976  
    199199    if (d == null || d.trim().length() == 0) d = null; 
    200200 
    201     store.setImage((String) getMeta("Image name"), d,  
     201    store.setImage((String) getMeta("Image name"), d, 
    202202      (String) getMeta("Image comment"), null); 
    203203 
  • trunk/loci/formats/in/ImprovisionTiffReader.java

    r2970 r2976  
    2929import loci.formats.*; 
    3030 
    31 /**  
    32  * ImprovisionTiffReader is the file format reader for  
    33  * Improvision TIFF files.  
     31/** 
     32 * ImprovisionTiffReader is the file format reader for 
     33 * Improvision TIFF files. 
    3434 */ 
    3535public class ImprovisionTiffReader extends BaseTiffReader { 
     
    5050  /* @see loci.formats.IFormatHandler#isThisType(String, boolean) */ 
    5151  public boolean isThisType(String name, boolean open) { 
    52     if (!name.toLowerCase().endsWith("tif") &&  
    53       !name.toLowerCase().endsWith("tiff"))  
    54     {   
    55       return false;  
    56     }  
    57      
     52    if (!name.toLowerCase().endsWith("tif") && 
     53      !name.toLowerCase().endsWith("tiff")) 
     54    { 
     55      return false; 
     56    } 
     57 
    5858    try { 
    5959      RandomAccessStream ras = new RandomAccessStream(name); 
     
    6161      ras.close(); 
    6262      if (ifd == null) return false; 
    63      
    64       String comment =  
    65         (String) ifd.get(new Integer(TiffTools.IMAGE_DESCRIPTION));  
    66       return comment.indexOf("Improvision") != -1;  
     63 
     64      String comment = 
     65        (String) ifd.get(new Integer(TiffTools.IMAGE_DESCRIPTION)); 
     66      return comment.indexOf("Improvision") != -1; 
    6767    } 
    68     catch (Exception e) { return false; }  
     68    catch (Exception e) { return false; } 
    6969  } 
    70    
     70 
    7171  // -- Internal BaseTiffReader API methods -- 
    72   
     72 
    7373  /* @see BaseTiffReader#initStandardMetadata() */ 
    7474  protected void initStandardMetadata() throws FormatException, IOException { 
     
    7676 
    7777    put("Improvision", "yes"); 
    78    
     78 
    7979    // parse key/value pairs in the comment 
    8080    String comment = (String) getMeta("Comment"); 
     
    9090      } 
    9191      metadata.remove("Comment"); 
    92     }  
    93   
     92    } 
     93 
    9494    core.sizeZ[0] = Integer.parseInt((String) getMeta("TotalZPlanes")); 
    9595    core.sizeC[0] = Integer.parseInt((String) getMeta("TotalChannels")); 
     
    104104 
    105105    for (int i=0; i<ifds.length; i++) { 
    106       comment = (String) TiffTools.getIFDValue(ifds[i],  
     106      comment = (String) TiffTools.getIFDValue(ifds[i], 
    107107        TiffTools.IMAGE_DESCRIPTION); 
    108108      comment = comment.replaceAll("\r\n", "\n"); 
    109109      comment = comment.replaceAll("\r", "\n"); 
    110110      StringTokenizer st = new StringTokenizer(comment, "\n"); 
    111       String channelName = null;  
     111      String channelName = null; 
    112112      while (st.hasMoreTokens()) { 
    113113        String line = st.nextToken(); 
     
    116116        String key = line.substring(0, equals); 
    117117        String value = line.substring(equals + 1); 
    118       
     118 
    119119        if (key.equals("TimeStampMicroSeconds")) { 
    120120          stamps[i] = Long.parseLong(value); 
     
    123123        else if (key.equals("ChannelNo")) { 
    124124          coords[i][1] = Integer.parseInt(value); 
    125         }  
     125        } 
    126126        else if (key.equals("TimepointName")) { 
    127127          coords[i][2] = Integer.parseInt(value); 
    128128        } 
    129129        else if (key.equals("ChannelName")) { 
    130           channelName = value;   
     130          channelName = value; 
    131131        } 
    132132        else if (key.equals("ChannelNo")) { 
     
    152152      int cDiff = coords[i][1] - coords[i - 1][1]; 
    153153      int tDiff = coords[i][2] - coords[i - 1][2]; 
    154     
     154 
    155155      if (zDiff > 0 && core.currentOrder[0].indexOf("Z") < 0) { 
    156156        core.currentOrder[0] += "Z"; 
     
    162162        core.currentOrder[0] += "T"; 
    163163      } 
    164       if (core.currentOrder[0].length() == 5) break;  
     164      if (core.currentOrder[0].length() == 5) break; 
    165165    } 
    166166 
     
    168168    if (core.currentOrder[0].indexOf("C") < 0) core.currentOrder[0] += "C"; 
    169169    if (core.currentOrder[0].indexOf("T") < 0) core.currentOrder[0] += "T"; 
    170   }  
     170  } 
    171171 
    172172  /* @see BaseTiffReader#initMetadataStore() */ 
  • trunk/loci/formats/in/KhorosReader.java

    r2970 r2976  
    3232public class KhorosReader extends FormatReader { 
    3333 
    34   // -- Fields --  
     34  // -- Fields -- 
    3535 
    3636  /** Global lookup table. */ 
     
    5454  /* @see loci.formats.IFormatReader#openBytes(int) */ 
    5555  public byte[] openBytes(int no) throws FormatException, IOException { 
    56     FormatTools.assertId(currentId, true, 1);  
     56    FormatTools.assertId(currentId, true, 1); 
    5757    byte[] buf = new byte[core.sizeX[0] * core.sizeY[0] * core.sizeC[0] * 
    5858      FormatTools.getBytesPerPixel(core.pixelType[0])]; 
     
    6464    throws FormatException, IOException 
    6565  { 
    66     FormatTools.assertId(currentId, true, 1);  
     66    FormatTools.assertId(currentId, true, 1); 
    6767    if (no < 0 || no >= core.imageCount[0]) { 
    6868      throw new FormatException("Invalid image number: " + no); 
    6969    } 
    70     
    71     in.seek(offset +  
     70 
     71    in.seek(offset + 
    7272      no * (core.sizeX[0] * core.sizeY[0] * getRGBChannelCount())); 
    7373    if (lut == null) in.read(buf); 
    7474    else { 
    75       int plane = core.sizeX[0] * core.sizeY[0] *  
    76         FormatTools.getBytesPerPixel(core.pixelType[0]);  
     75      int plane = core.sizeX[0] * core.sizeY[0] * 
     76        FormatTools.getBytesPerPixel(core.pixelType[0]); 
    7777 
    7878      for (int i=0; i<plane; i++) { 
     
    8787    return buf; 
    8888  } 
    89   
     89 
    9090  /* @see loci.formats.IFormatReader#openImage(int) */ 
    9191  public BufferedImage openImage(int no) throws FormatException, IOException { 
    92     FormatTools.assertId(currentId, true, 1);  
    93     
     92    FormatTools.assertId(currentId, true, 1); 
     93 
    9494    if (core.pixelType[0] == FormatTools.FLOAT) { 
    9595      byte[] b = openBytes(no); 
    9696      float[] f = new float[core.sizeX[0] * core.sizeY[0] * core.sizeC[0]]; 
    9797      for (int i=0; i<f.length; i++) { 
    98         f[i] = Float.intBitsToFloat(DataTools.bytesToInt(b,  
     98        f[i] = Float.intBitsToFloat(DataTools.bytesToInt(b, 
    9999          i*4, !core.littleEndian[0])); 
    100100      } 
    101        
    102       return ImageTools.makeImage(f, core.sizeX[0], core.sizeY[0],  
    103         core.sizeC[0], core.interleaved[0]);  
    104     } 
    105      
     101 
     102      return ImageTools.makeImage(f, core.sizeX[0], core.sizeY[0], 
     103        core.sizeC[0], core.interleaved[0]); 
     104    } 
     105 
    106106    return ImageTools.makeImage(openBytes(no), core.sizeX[0], core.sizeY[0], 
    107       core.sizeC[0], core.interleaved[0],  
     107      core.sizeC[0], core.interleaved[0], 
    108108      FormatTools.getBytesPerPixel(core.pixelType[0]), core.littleEndian[0]); 
    109109  } 
     
    124124    int release = in.read(); 
    125125    int version = in.read(); 
    126     in.order(true);  
     126    in.order(true); 
    127127    int dependency = in.readInt(); 
    128128 
     
    137137    if (core.imageCount[0] == 0) core.imageCount[0] = 1; 
    138138    core.sizeC[0] = in.readInt(); 
    139      
    140     int type = in.readInt();  
    141     
     139 
     140    int type = in.readInt(); 
     141 
    142142    switch (type) { 
    143       case 0:  
    144       case 1:  
    145         core.pixelType[0] = FormatTools.UINT8;  
    146         break; 
    147       case 2:  
     143      case 0: 
     144      case 1: 
     145        core.pixelType[0] = FormatTools.UINT8; 
     146        break; 
     147      case 2: 
    148148        core.pixelType[0] = FormatTools.UINT16; 
    149149        break; 
    150       case 4:  
    151         core.pixelType[0] = FormatTools.UINT32;  
    152         break; 
    153       case 5:  
    154         core.pixelType[0] = FormatTools.FLOAT;  
    155         break; 
    156       case 9:  
    157         core.pixelType[0] = FormatTools.DOUBLE;  
    158         break; 
    159       default: throw new FormatException("Unsupported pixel type : " + type);  
     150      case 4: 
     151        core.pixelType[0] = FormatTools.UINT32; 
     152        break; 
     153      case 5: 
     154        core.pixelType[0] = FormatTools.FLOAT; 
     155        break; 
     156      case 9: 
     157        core.pixelType[0] = FormatTools.DOUBLE; 
     158        break; 
     159      default: throw new FormatException("Unsupported pixel type : " + type); 
    160160    } 
    161161 
     
    165165      core.sizeC[0] = c; 
    166166      int n = in.readInt(); 
    167       lut = new byte[n * c];  
     167      lut = new byte[n * c]; 
    168168      in.skipBytes(436); 
    169169 
    170170      for (int i=0; i<lut.length; i++) { 
    171         int value = in.read();  
     171        int value = in.read(); 
    172172        if (i < n) { 
    173173          lut[i*3] = (byte) value; 
     
    183183      } 
    184184    } 
    185     else in.skipBytes(440);   
     185    else in.skipBytes(440); 
    186186    offset = in.getFilePointer(); 
    187187 
     
    192192    core.littleEndian[0] = dependency == 4 || dependency == 8; 
    193193    core.currentOrder[0] = "XYCZT"; 
    194    
     194 
    195195    MetadataStore store = getMetadataStore(); 
    196196    store.setPixels(new Integer(core.sizeX[0]), new Integer(core.sizeY[0]), 
     
    198198      new Integer(core.sizeT[0]), new Integer(core.pixelType[0]), 
    199199      new Boolean(core.littleEndian[0]), core.currentOrder[0], null, null); 
    200    
     200 
    201201    for (int i=0; i<core.sizeC[0]; i++) { 
    202202      store.setLogicalChannel(i, null, null, null, null, 
  • trunk/loci/formats/in/LIFReader.java

    r2960 r2976  
    177177 
    178178      int descrLength = in.readInt(); 
    179       in.skipBytes(descrLength * 2);  
     179      in.skipBytes(descrLength * 2); 
    180180 
    181181      if (blockLength > 0) { 
     
    196196    LIFHandler handler = new LIFHandler(); 
    197197 
    198     xml = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><LEICA>" + xml +  
     198    xml = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><LEICA>" + xml + 
    199199      "</LEICA>"; 
    200200 
     
    491491      while (keys.hasMoreElements()) { 
    492492        String k = (String) keys.nextElement(); 
    493         boolean use = true;  
     493        boolean use = true; 
    494494        for (int j=0; j<seriesNames.size(); j++) { 
    495495          if (j != i && k.startsWith((String) seriesNames.get(j))) { 
     
    516516        if (!attributes.getValue("Name").equals("DCROISet")) { 
    517517          series = attributes.getValue("Name"); 
    518         }  
     518        } 
    519519      } 
    520520      else if (qName.equals("Experiment")) { 
     
    555555          series = series.replaceAll(" - Master sequential setting", 
    556556            " - Sequential Setting 0"); 
    557         }  
    558          
     557        } 
     558 
    559559        if (series.indexOf("- Sequential Setting ") == -1) { 
    560           series += " - Master sequential setting";  
     560          series += " - Master sequential setting"; 
    561561        } 
    562562        else { 
     
    566566          series = series.substring(0, ndx) + String.valueOf(n); 
    567567        } 
    568        
     568 
    569569        for (int i=0; i<attributes.getLength(); i++) { 
    570570          addMeta(series + " - " + attributes.getQName(i), 
     
    634634      } 
    635635      else if (qName.equals("TimeStamp")) { 
    636         
     636 
    637637        long high = Long.parseLong(attributes.getValue("HighInteger")); 
    638638        long low = Long.parseLong(attributes.getValue("LowInteger")); 
    639   
     639 
    640640        long stamp = 0; 
    641641        high <<= 32; 
     
    644644        } 
    645645        stamp = high + low; 
    646          
    647         // Near as I can figure, this timestamp represents the number of  
     646 
     647        // Near as I can figure, this timestamp represents the number of 
    648648        // 100-nanosecond ticks since the ANSI/COBOL epoch (Jan 1, 1601). 
    649649        // Note that the following logic does not handle negative timestamp 
    650650        // values, so if the file in question was acquired prior to Jan 1 1601, 
    651651        // the timestamp will not be parsed correctly. 
    652          
    653         long seconds = stamp / 10000000;  
     652 
     653        long seconds = stamp / 10000000; 
    654654 
    655655        // subtract number of seconds until Unix epoch (Jan 1, 1970) 
    656656 
    657657        long secondsPerYear = (long) (60 * 60 * 24 * 365.25); 
    658         seconds -= secondsPerYear * (1970 - 1601);  
    659         
    660         Date d = new Date(seconds * 1000);  
     658        seconds -= secondsPerYear * (1970 - 1601); 
     659 
     660        Date d = new Date(seconds * 1000); 
    661661        SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS"); 
    662662        StringBuffer sb = new StringBuffer(); 
  • trunk/loci/formats/in/LegacyZVIReader.java

    r2922 r2976  
    294294      bytesPerPixel = in.readInt(); 
    295295      // not clear what this value signifies 
    296       int pixType = in.readInt();  
     296      int pixType = in.readInt(); 
    297297      // doesn't always equal bytesPerPixel * 8 
    298       int bitDepth = in.readInt();  
     298      int bitDepth = in.readInt(); 
    299299      pos += 24; 
    300300 
  • trunk/loci/formats/in/LeicaReader.java

    r2905 r2976  
    127127      FormatTools.getBytesPerPixel(core.pixelType[series])); 
    128128 
    129     b = ImageTools.splitChannels(b, c,  
     129    b = ImageTools.splitChannels(b, c, 
    130130      FormatTools.getBytesPerPixel(core.pixelType[series]), false, 
    131131      isInterleaved())[channelIndices[ndx]]; 
     
    149149    int c = buf.length / (core.sizeX[series] * core.sizeY[series] * 
    150150      FormatTools.getBytesPerPixel(core.pixelType[series])); 
    151     buf = ImageTools.splitChannels(buf, c,  
     151    buf = ImageTools.splitChannels(buf, c, 
    152152      FormatTools.getBytesPerPixel(core.pixelType[series]), false, 
    153153      isInterleaved())[channelIndices[ndx]]; 
     
    457457          Location test = new Location((String) f.get(f.size() - 1)); 
    458458          if (tiffsExist) tiffsExist = test.exists(); 
    459          
    460           // get the series name from the stored file name  
     459 
     460          // get the series name from the stored file name 
    461461          int firstUnderscore = prefix.indexOf("_") + 1; 
    462           int secondUnderscore = prefix.indexOf("_", firstUnderscore);  
     462          int secondUnderscore = prefix.indexOf("_", firstUnderscore); 
    463463          if (firstUnderscore != -1 && secondUnderscore != -1) { 
    464464            String s = prefix.substring(firstUnderscore, secondUnderscore); 
  • trunk/loci/formats/in/MRCReader.java

    r2922 r2976  
    180180 
    181181    extHeaderSize = in.readInt(); 
    182       
     182 
    183183    in.skipBytes(64); 
    184184 
  • trunk/loci/formats/in/MetamorphReader.java

    r2857 r2976  
    185185      // find an associated STK file 
    186186      String stkFile = id.substring(0, id.lastIndexOf(".")); 
    187       Location parent = new Location(id).getAbsoluteFile().getParentFile();  
    188       String[] dirList = parent.list();  
     187      Location parent = new Location(id).getAbsoluteFile().getParentFile(); 
     188      String[] dirList = parent.list(); 
    189189      for (int i=0; i<dirList.length; i++) { 
    190190        String s = dirList[i].toLowerCase(); 
    191191        if (s.endsWith(".stk") && (dirList[i].indexOf(stkFile.substring( 
    192           stkFile.lastIndexOf(File.separator) + 1) + "_w") != -1))  
     192          stkFile.lastIndexOf(File.separator) + 1) + "_w") != -1)) 
    193193        { 
    194           stkFile =  
     194          stkFile = 
    195195            new Location(parent.getPath(), dirList[i]).getAbsolutePath(); 
    196196          break; 
  • trunk/loci/formats/in/MicromanagerReader.java

    r2854 r2976  
    6666      throw new FormatException("Invalid image number: " + no); 
    6767    } 
    68     tiffReader.setId((String) tiffs.get(no));  
     68    tiffReader.setId((String) tiffs.get(no)); 
    6969    return tiffReader.openBytes(0); 
    7070  } 
     
    7878      throw new FormatException("Invalid image number: " + no); 
    7979    } 
    80     tiffReader.setId((String) tiffs.get(no));  
     80    tiffReader.setId((String) tiffs.get(no)); 
    8181    return tiffReader.openBytes(0, buf); 
    8282  } 
     
    8888      throw new FormatException("Invalid image number: " + no); 
    8989    } 
    90     tiffReader.setId((String) tiffs.get(no));  
     90    tiffReader.setId((String) tiffs.get(no)); 
    9191    return tiffReader.openImage(0); 
    9292  } 
     
    203203    } 
    204204    tiffReader.setId((String) tiffs.get(0)); 
    205     
     205 
    206206    String z = (String) metadata.get("Slices"); 
    207207    if (z != null) { 
     
    213213    if (t != null) { 
    214214      core.sizeT[0 ] = Integer.parseInt(t); 
    215     }  
     215    } 
    216216    else core.sizeT[0] = tiffs.size() / core.sizeC[0]; 
    217      
     217 
    218218    core.sizeX[0] = tiffReader.getSizeX(); 
    219219    core.sizeY[0] = tiffReader.getSizeY(); 
  • trunk/loci/formats/in/ND2Reader.java

    r2922 r2976  
    5757 
    5858  /** Factory for generating SAX parsers. */ 
    59   public static final SAXParserFactory SAX_FACTORY =  
     59  public static final SAXParserFactory SAX_FACTORY = 
    6060    SAXParserFactory.newInstance(); 
    6161 
     
    151151 
    152152  /* @see loci.formats.IFormatReader#openBytes(int, byte[]) */ 
    153   public byte[] openBytes(int no, byte[] buf)  
     153  public byte[] openBytes(int no, byte[] buf) 
    154154    throws FormatException, IOException 
    155155  { 
     
    157157    if (no < 0 || no >= core.imageCount[0]) { 
    158158      throw new FormatException("Invalid image number: " + no); 
    159     }  
     159    } 
    160160    if (buf.length < core.sizeX[0] * core.sizeY[0] * core.sizeC[0] * 
    161161      FormatTools.getBytesPerPixel(core.pixelType[0])) 
     
    163163      throw new FormatException("Buffer too small."); 
    164164    } 
    165     
     165 
    166166    in.seek(offsets[no]); 
    167167 
     
    170170 
    171171      for (int i=0; i<core.sizeC[0]; i++) { 
    172         System.arraycopy(pixels[i], 0, buf, i*pixels[i].length,  
     172        System.arraycopy(pixels[i], 0, buf, i*pixels[i].length, 
    173173          pixels[i].length); 
    174174      } 
    175       pixels = null;  
     175      pixels = null; 
    176176    } 
    177177    else { 
    178178      in.read(buf); 
    179179    } 
    180   
     180 
    181181    return buf; 
    182182  } 
     
    186186    if (!isJPEG) { 
    187187      return ImageTools.makeImage(openBytes(no), core.sizeX[0], core.sizeY[0], 
    188         core.sizeC[0], core.interleaved[0],  
     188        core.sizeC[0], core.interleaved[0], 
    189189        FormatTools.getBytesPerPixel(core.pixelType[0]), core.littleEndian[0]); 
    190190    } 
    191      
     191 
    192192    FormatTools.assertId(currentId, true, 1); 
    193193    if (no < 0 || no >= getImageCount()) { 
     
    196196 
    197197    in.seek(offsets[no]); 
    198      
     198 
    199199    long len = no < core.imageCount[0] - 1 ? offsets[no + 1] - offsets[no] : 
    200200      in.length() - offsets[no]; 
    201201 
    202     byte[] b = new byte[(int) len];  
     202    byte[] b = new byte[(int) len]; 
    203203    in.readFully(b); 
    204204 
     
    263263                FormatTools.getBytesPerPixel(core.pixelType[0])); 
    264264            } 
    265             offsets[ndx] = in.getFilePointer() - len + s.indexOf("!") + 9;  
     265            offsets[ndx] = in.getFilePointer() - len + s.indexOf("!") + 9; 
    266266          } 
    267267          else if (s.startsWith("Image")) { 
    268268            // XML metadata 
    269              
     269 
    270270            ND2Handler handler = new ND2Handler(); 
    271271 
     
    277277              if (Character.isISOControl(c) || !Character.isDefined(c)) { 
    278278                s = s.replace(c, ' '); 
    279               }  
     279              } 
    280280            } 
    281            
     281 
    282282            try { 
    283283              SAXParser parser = SAX_FACTORY.newSAXParser(); 
     
    286286            catch (ParserConfigurationException exc) { 
    287287              throw new FormatException(exc); 
    288             }  
     288            } 
    289289            catch (SAXException exc) { 
    290290              throw new FormatException(exc); 
     
    299299            if (in.read() != -38) in.skipBytes(15); 
    300300            else in.seek(in.getFilePointer() - 1); 
    301           }  
     301          } 
    302302        } 
    303303      } 
     
    308308      core.littleEndian[0] = true; 
    309309 
    310       return;  
     310      return; 
    311311    } 
    312312    else in.seek(0); 
     
    331331      length -= 8; 
    332332 
    333       if (box == 0x6a703263) {  
    334         vs.add(new Long(in.getFilePointer()));  
    335       } 
    336       if (!lastBoxFound) in.seek(pos + length);  
     333      if (box == 0x6a703263) { 
     334        vs.add(new Long(in.getFilePointer())); 
     335      } 
     336      if (!lastBoxFound) in.seek(pos + length); 
    337337    } 
    338338 
     
    396396      // strip out all comments 
    397397      xml = xml.replaceAll("<!--*-->", ""); 
    398        
     398 
    399399      // each chunk appears on a separate line, so split up the chunks 
    400400 
     
    427427                  if (prefix.startsWith("Metadata_V1.2")) { 
    428428                    prefix = ""; 
    429                   }  
     429                  } 
    430430                  String effectiveKey = prefix + " " + pre + " " + key; 
    431431                  if (!metadata.containsKey(effectiveKey)) { 
     
    478478        } 
    479479      } 
    480       b = null;  
    481       xml = null;  
    482       st = null;  
     480      b = null; 
     481      xml = null; 
     482      st = null; 
    483483    } 
    484484 
     
    599599    if (bits == 0) core.pixelType[0] = FormatTools.UINT8; 
    600600    else { 
    601       int bpp = bits;  
     601      int bpp = bits; 
    602602      while (bpp % 8 != 0) bpp++; 
    603603      switch (bpp) { 
     
    623623      core.sizeT[0] = core.imageCount[0]; 
    624624      core.sizeZ[0] = 1; 
    625     }  
     625    } 
    626626 
    627627    if (core.sizeZ[0] * core.sizeT[0] * core.sizeC[0] < core.imageCount[0]) { 
    628628      core.sizeT[0] = 1; 
    629629      core.sizeZ[0] = core.imageCount[0]; 
    630     }  
     630    } 
    631631 
    632632    core.rgb[0] = core.sizeC[0] == 3; 
     
    678678      } 
    679679      else if (qName.equals("uiWidthBytes")) { 
    680         int bytes =  
     680        int bytes = 
    681681          Integer.parseInt(attributes.getValue("value")) / core.sizeX[0]; 
    682682        switch (bytes) { 
     
    686686          case 4: 
    687687            core.pixelType[0] = FormatTools.UINT32; 
    688             break;  
     688            break; 
    689689          default: core.pixelType[0] = FormatTools.UINT8; 
    690690        } 
    691       }  
     691      } 
    692692      else if (qName.equals("uiHeight")) { 
    693693        core.sizeY[0] = Integer.parseInt(attributes.getValue("value")); 
    694694      } 
    695695      else if (qName.equals("uiCount")) { 
    696         int n = Integer.parseInt(attributes.getValue("value"));  
     696        int n = Integer.parseInt(attributes.getValue("value")); 
    697697        if (core.imageCount[0] == 0) { 
    698698          core.imageCount[0] = n; 
    699699          core.sizeZ[0] = n; 
    700         }  
     700        } 
    701701        core.sizeT[0] = 1; 
    702702      } 
  • trunk/loci/formats/in/NRRDReader.java

    r2970 r2976  
    6060  public boolean isThisType(byte[] block) { 
    6161    if (block.length < 4) return false; 
    62     return new String(block).startsWith("NRRD");  
     62    return new String(block).startsWith("NRRD"); 
    6363  } 
    6464 
     
    236236      new Integer(core.sizeT[0]), new Integer(core.pixelType[0]), 
    237237      new Boolean(core.littleEndian[0]), core.currentOrder[0], null, null); 
    238    
     238 
    239239    for (int i=0; i<core.sizeC[0]; i++) { 
    240240      store.setLogicalChannel(i, null, null, null, null, 
  • trunk/loci/formats/in/OIBReader.java

    r2922 r2976  
    440440          core.pixelType[i] = FormatTools.UINT16; 
    441441          break; 
    442         default: core.pixelType[i] = FormatTools.UINT8;  
     442        default: core.pixelType[i] = FormatTools.UINT8; 
    443443      } 
    444444 
  • trunk/loci/formats/in/OIFReader.java

    r2922 r2976  
    259259 
    260260    int reference = ((String) filenames.get(new Integer(0))).length(); 
    261     int numFiles = filenames.size();  
     261    int numFiles = filenames.size(); 
    262262    for (int i=0; i<numFiles; i++) { 
    263263      String value = (String) filenames.get(new Integer(i)); 
    264264      if (value.length() > reference) { 
    265         filenames.remove(new Integer(i));  
    266       }  
     265        filenames.remove(new Integer(i)); 
     266      } 
    267267    } 
    268268 
     
    309309          if (key.equals("DataName")) { 
    310310            value = value.substring(1, value.length() - 1); 
    311             if (value.indexOf("-R") == -1) {  
     311            if (value.indexOf("-R") == -1) { 
    312312              tiffs.add(i, tiffPath + File.separator + value); 
    313313              tiffReader[i].setId((String) tiffs.get(i)); 
    314             }  
     314            } 
    315315          } 
    316316          addMeta("Image " + i + " : " + key, value); 
     
    331331 
    332332    for (int i=0; i<9; i++) { 
    333       int ss = Integer.parseInt(size[i]);  
     333      int ss = Integer.parseInt(size[i]); 
    334334      if (code[i].equals("\"X\"")) core.sizeX[0] = ss; 
    335       else if (code[i].equals("\"Y\"")) core.sizeY[0] = ss;  
    336       else if (code[i].equals("\"C\"")) core.sizeC[0] = ss;  
    337       else if (code[i].equals("\"T\"")) core.sizeT[0] = ss;  
    338       else if (code[i].equals("\"Z\"")) core.sizeZ[0] = ss;  
     335      else if (code[i].equals("\"Y\"")) core.sizeY[0] = ss; 
     336      else if (code[i].equals("\"C\"")) core.sizeC[0] = ss; 
     337      else if (code[i].equals("\"T\"")) core.sizeT[0] = ss; 
     338      else if (code[i].equals("\"Z\"")) core.sizeZ[0] = ss; 
    339339    } 
    340340 
  • trunk/loci/formats/in/OMETiffReader.java

    r2943 r2976  
    3232import org.xml.sax.SAXException; 
    3333 
    34 /**  
     34/** 
    3535 * OMETiffReader is the file format reader for OME-TIFF files. 
    3636 * See http://www.loci.wisc.edu/ome/ome-tiff-spec.html 
     
    4848  /* @see loci.formats.IFormatHandler#isThisType(String, boolean) */ 
    4949  public boolean isThisType(String name, boolean open) { 
    50     if (!name.toLowerCase().endsWith("tif") &&  
    51       !name.toLowerCase().endsWith("tiff"))  
    52     {   
    53       return false;  
    54     }  
    55      
     50    if (!name.toLowerCase().endsWith("tif") && 
     51      !name.toLowerCase().endsWith("tiff")) 
     52    { 
     53      return false; 
     54    } 
     55 
    5656    try { 
    5757      RandomAccessStream ras = new RandomAccessStream(name); 
     
    5959      ras.close(); 
    6060      if (ifd == null) return false; 
    61      
     61 
    6262      String comment = (String) ifd.get(new Integer(TiffTools.IMAGE_DESCRIPTION)); 
    6363      if (comment == null) return false; 
    64       return comment.indexOf("ome.xsd") >= 0;  
    65     } 
    66     catch (Exception e) { return false; }  
     64      return comment.indexOf("ome.xsd") >= 0; 
     65    } 
     66    catch (Exception e) { return false; } 
    6767  } 
    68    
     68 
    6969  // -- Internal BaseTiffReader API methods -- 
    70   
     70 
    7171  /* @see BaseTiffReader#initStandardMetadata() */ 
    7272  protected void initStandardMetadata() throws FormatException, IOException { 
     
    8686    catch (SAXException exc) { } 
    8787    catch (IOException exc) { } 
    88    
    89     // extract TiffData elements from XML  
     88 
     89    // extract TiffData elements from XML 
    9090    Element[] pixels = null; 
    9191    Element[][] tiffData = null; 
     
    144144          core.pixelType[i]++; 
    145145        } 
    146          
     146 
    147147        // MAJOR HACK: adjust SizeT to match the number of IFDs, if this file 
    148148        // was written by a buggy version of WiscScan 
     
    171171          int numPlanes = nullNumPlanes ? (nullIfd ? core.imageCount[0] : 1) : 
    172172            Integer.parseInt(aNumPlanes); 
    173          
    174           // populate ZCT matrix  
     173 
     174          // populate ZCT matrix 
    175175          char d1st = core.currentOrder[i].charAt(2); 
    176176          char d2nd = core.currentOrder[i].charAt(3); 
     
    191191                        c++; 
    192192                      } 
    193                       break;  
     193                      break; 
    194194                    case 'C': 
    195195                      c++; 
     
    198198                        t++; 
    199199                      } 
    200                       break;  
     200                      break; 
    201201                  } 
    202202                } 
     
    220220                        z++; 
    221221                      } 
    222                       break;  
     222                      break; 
    223223                  } 
    224224                } 
     
    235235                        t++; 
    236236                      } 
    237                       break;  
     237                      break; 
    238238                    case 'T': 
    239239                      t++; 
     
    242242                        z++; 
    243243                      } 
    244                       break;  
     244                      break; 
    245245                  } 
    246246                } 
    247                 break;  
    248             } 
    249           } 
    250         } 
    251    
     247                break; 
     248            } 
     249          } 
     250        } 
     251 
    252252        // analyze ZCT matrix to determine best SizeZ, SizeC, and SizeT 
    253253        // for now, we only handle certain special cases: 
     
    268268          continue; 
    269269        } 
    270       
     270 
    271271        // 2) single Z, all T, all C 
    272272        success = true; 
     
    288288          continue; 
    289289        } 
    290        
     290 
    291291        // 3) all Z, single T, all C 
    292292        success = true; 
     
    328328          continue; 
    329329        } 
    330         
     330 
    331331        // 5) single Z, single T, all C 
    332332        success = true; 
     
    336336          for (int t=0; t<core.sizeT[i] && success; t++) { 
    337337            if (zct[z][0][t]) { 
    338               if (theZ < 0 && theT < 0) {  
     338              if (theZ < 0 && theT < 0) { 
    339339                theZ = z; 
    340340                theT = t; 
    341341              } 
    342               else success = false;  
     342              else success = false; 
    343343            } 
    344344            boolean state = theZ == z && theT == t; 
     
    346346              if (zct[z][c][t] != state) success = false; 
    347347            } 
    348           }  
     348          } 
    349349        } 
    350350 
     
    365365                theC = c; 
    366366              } 
    367               else success = false;  
     367              else success = false; 
    368368            } 
    369369            boolean state = theZ == z && theC == c; 
    370370            for (int t=0; t<core.sizeT[i] && success; t++) { 
    371               if (zct[z][c][t] != state) success = false;  
     371              if (zct[z][c][t] != state) success = false; 
    372372            } 
    373373          } 
     
    389389                theT = t; 
    390390              } 
    391               else success = false;  
    392             } 
    393             boolean state = theC == c && theT == t;  
     391              else success = false; 
     392            } 
     393            boolean state = theC == c && theT == t; 
    394394            for (int z=0; z<core.sizeZ[i] && success; z++) { 
    395395              if (zct[z][c][t] != state) success = false; 
     
    422422          continue; 
    423423        } 
    424        
     424 
    425425        // no easy way to chop up TiffData mappings into regular ZCT dims 
    426426        throw new FormatException("Unsupported ZCT index mapping"); 
    427       }  
    428     } 
    429   }  
     427      } 
     428    } 
     429  } 
    430430 
    431431  /* @see BaseTiffReader#initMetadataStore() */ 
     
    433433    String comment = (String) getMeta("Comment"); 
    434434    metadata.remove("Comment"); 
    435    
     435 
    436436    boolean isOMEXML; 
    437437    try { 
     
    442442      isOMEXML = false; 
    443443    } 
    444    
     444 
    445445    if (isOMEXML) { 
    446446      ReflectedUniverse r = new ReflectedUniverse(); 
     
    450450        r.setVar("comment", comment); 
    451451        r.exec("xmlStore.createRoot(comment)"); 
    452         return;  
     452        return; 
    453453      } 
    454454      catch (ReflectException exc) { 
  • trunk/loci/formats/in/OpenlabRawReader.java

    r2922 r2976  
    166166    switch (bytesPerPixel) { 
    167167      case 1: 
    168       case 3:   
     168      case 3: 
    169169        core.pixelType[0] = FormatTools.UINT8; 
    170170        break; 
  • trunk/loci/formats/in/OpenlabReader.java

    r2926 r2976  
    226226 
    227227      in.skipBytes(24); 
    228       volumeType = in.readShort();  
     228      volumeType = in.readShort(); 
    229229 
    230230      in.skipBytes(280); 
     
    275275      else if (volumeType == MAC_256_GREYS) { 
    276276        byte[] tmp = b; 
    277         b = new byte[core.sizeX[series] * core.sizeY[series]];  
     277        b = new byte[core.sizeX[series] * core.sizeY[series]]; 
    278278        for (int y=0; y<core.sizeY[series]; y++) { 
    279           System.arraycopy(tmp, y*(core.sizeX[series] + 16), b,  
     279          System.arraycopy(tmp, y*(core.sizeX[series] + 16), b, 
    280280            y*core.sizeX[series], core.sizeX[series]); 
    281281        } 
     
    629629    for (int i=0; i<bpp.length; i++) { 
    630630      setSeries(i); 
    631       if (core.sizeC[i] == 0) core.sizeC[i] = 1;  
     631      if (core.sizeC[i] == 0) core.sizeC[i] = 1; 
    632632      bpp[i] = openBytes(0).length / (core.sizeX[i] * core.sizeY[i]); 
    633633    } 
     
    676676          break; 
    677677        case 2: 
    678         case 6:  
     678        case 6: 
    679679          core.pixelType[i] = FormatTools.UINT16; 
    680680          break; 
  • trunk/loci/formats/in/PGMReader.java

    r2970 r2976  
    3333 * PGMReader is the file format reader for Portable Gray Map (PGM) images. 
    3434 * 
    35  * Much of this code was adapted from ImageJ (http://rsb.info.nih.gov/ij).  
     35 * Much of this code was adapted from ImageJ (http://rsb.info.nih.gov/ij). 
    3636 */ 
    3737public class PGMReader extends FormatReader { 
     
    4040 
    4141  private boolean rawBits; 
    42   
     42 
    4343  /** Offset to pixel data. */ 
    4444  private long offset; 
     
    4949  public PGMReader() { super("Portable Gray Map", "pgm"); } 
    5050 
    51   // -- IFormatReader API methods --  
     51  // -- IFormatReader API methods -- 
    5252 
    5353  /* @see loci.formats.IFormatReader#isThisType(byte[]) */ 
     
    6060    FormatTools.assertId(currentId, true, 1); 
    6161    byte[] buf = new byte[core.sizeX[0] * core.sizeY[0] * core.sizeC[0] * 
    62       FormatTools.getBytesPerPixel(core.pixelType[0])];  
    63     return openBytes(no, buf);  
     62      FormatTools.getBytesPerPixel(core.pixelType[0])]; 
     63    return openBytes(no, buf); 
    6464  } 
    6565 
     
    7777      throw new FormatException("Buffer too small."); 
    7878    } 
    79      
    80     in.seek(offset);  
     79 
     80    in.seek(offset); 
    8181    if (rawBits) in.read(buf); 
    8282    else { 
    83       int pt = 0;  
     83      int pt = 0; 
    8484      while (pt < buf.length) { 
    8585        String line = in.readLine().trim(); 
     
    8787        StringTokenizer t = new StringTokenizer(line, " "); 
    8888        while (t.hasMoreTokens()) { 
    89           int q = Integer.parseInt(t.nextToken().trim());  
     89          int q = Integer.parseInt(t.nextToken().trim()); 
    9090          if (core.pixelType[0] == FormatTools.UINT16) { 
    9191            short s = (short) q; 
     
    9999          } 
    100100        } 
    101       }  
     101      } 
    102102    } 
    103103 
     
    108108  public BufferedImage openImage(int no) throws FormatException, IOException { 
    109109    return ImageTools.makeImage(openBytes(no), core.sizeX[0], core.sizeY[0], 
    110       core.sizeC[0], core.interleaved[0],  
     110      core.sizeC[0], core.interleaved[0], 
    111111      FormatTools.getBytesPerPixel(core.pixelType[0]), core.littleEndian[0]); 
    112112  } 
     
    118118    super.initFile(id); 
    119119    in = new RandomAccessStream(id); 
    120    
     120 
    121121    String magic = in.readLine().trim(); 
    122122 
     
    129129    String line = in.readLine().trim(); 
    130130    while (line.startsWith("#") || line.length() == 0) line = in.readLine(); 
    131    
     131 
    132132    line = line.replaceAll("[^0-9]", " "); 
    133     core.sizeX[0] =  
     133    core.sizeX[0] = 
    134134      Integer.parseInt(line.substring(0, line.indexOf(" ")).trim()); 
    135     core.sizeY[0] =  
     135    core.sizeY[0] = 
    136136      Integer.parseInt(line.substring(line.indexOf(" ") + 1).trim()); 
    137    
     137 
    138138    if (!isBlackAndWhite) { 
    139139      int max = Integer.parseInt(in.readLine().trim()); 
     
    141141      else core.pixelType[0] = FormatTools.UINT8; 
    142142    } 
    143    
    144     offset = in.getFilePointer();  
    145      
     143 
     144    offset = in.getFilePointer(); 
     145 
    146146    core.rgb[0] = core.sizeC[0] == 3; 
    147147    core.currentOrder[0] = "XYCZT"; 
    148148    core.littleEndian[0] = true; 
    149149    core.interleaved[0] = false; 
    150     core.sizeZ[0] = 1;  
    151     core.sizeT[0] = 1;  
    152     core.imageCount[0] = 1;  
    153    
     150    core.sizeZ[0] = 1; 
     151    core.sizeT[0] = 1; 
     152    core.imageCount[0] = 1; 
     153 
    154154    MetadataStore store = getMetadataStore(); 
    155155    store.setPixels(new Integer(core.sizeX[0]), new Integer(core.sizeY[0]), 
     
    157157      new Integer(core.sizeT[0]), new Integer(core.pixelType[0]), 
    158158      new Boolean(!core.littleEndian[0]), core.currentOrder[0], null, null); 
    159      
     159 
    160160    for (int i=0; i<core.sizeC[0]; i++) { 
    161161      store.setLogicalChannel(i, null, null, null, null, 
  • trunk/loci/formats/in/PNGReader.java

    r2922 r2976  
    3636 
    3737  /** Constructs a new PNGReader. */ 
    38   public PNGReader() {  
     38  public PNGReader() { 
    3939    super("Portable Network Graphics", new String[] {"png", "pnm"}); 
    4040  } 
  • trunk/loci/formats/in/PerkinElmerReader.java

    r2922 r2976  
    542542      switch (bpp) { 
    543543        case 1: 
    544         case 3:  
     544        case 3: 
    545545          core.pixelType[0] = FormatTools.UINT8; 
    546546          break; 
  • trunk/loci/formats/in/PictReader.java

    r2922 r2976  
    347347    switch (pictState) { 
    348348      case INITIAL: 
    349         ras.skipBytes(10);  
    350         int verOpcode = ras.read();  
    351         int verNumber = ras.read();  
     349        ras.skipBytes(10); 
     350        int verOpcode = ras.read(); 
     351        int verNumber = ras.read(); 
    352352 
    353353        if (verOpcode == 0x11 && verNumber == 0x01) versionOne = true; 
    354354        else if (verOpcode == 0x00 && verNumber == 0x11) { 
    355355          versionOne = false; 
    356           int verNumber2 = ras.readShort();  
     356          int verNumber2 = ras.readShort(); 
    357357 
    358358          if (verNumber2 != 0x02ff) { 
     
    361361 
    362362          // skip over v2 header -- don't need it here 
    363           ras.skipBytes(26);  
     363          ras.skipBytes(26); 
    364364        } 
    365365        else throw new FormatException("Invalid PICT file"); 
     
    370370 
    371371      case STATE2: 
    372         if (versionOne) opcode = ras.read();  
     372        if (versionOne) opcode = ras.read(); 
    373373        else { 
    374374          // if at odd boundary skip a byte for opcode in PICT v2 
    375375 
    376376          if ((ras.getFilePointer() & 0x1L) != 0) { 
    377             ras.skipBytes(1);  
     377            ras.skipBytes(1); 
    378378          } 
    379           opcode = ras.readShort();  
     379          opcode = ras.readShort(); 
    380380        } 
    381381        return drivePictDecoder(opcode); 
     
    385385 
    386386  /** Handles the opcodes in the PICT file. */ 
    387   private boolean drivePictDecoder(int opcode)  
     387  private boolean drivePictDecoder(int opcode) 
    388388    throws FormatException, IOException 
    389389  { 
     
    399399        break; 
    400400      case PICT_CLIP_RGN: 
    401         int x = ras.readShort();  
    402         ras.skipBytes(x - 2);  
     401        int x = ras.readShort(); 
     402        ras.skipBytes(x - 2); 
    403403        break; 
    404404      case PICT_LONGCOMMENT: 
    405         ras.skipBytes(2);  
     405        ras.skipBytes(2); 
    406406        x = ras.readShort(); 
    407407        ras.skipBytes(x); 
     
    416416 
    417417  /** Handles bitmap and pixmap opcodes of PICT format. */ 
    418   private void handlePackBits(int opcode)  
    419     throws FormatException, IOException  
     418  private void handlePackBits(int opcode) 
     419    throws FormatException, IOException 
    420420  { 
    421421    if (debug) debug("handlePackBits(" + opcode + ")"); 
     
    432432 
    433433  /** Extract the image data in a PICT bitmap structure. */ 
    434   private void handleBitmap(int opcode)  
    435     throws FormatException, IOException  
     434  private void handleBitmap(int opcode) 
     435    throws FormatException, IOException 
    436436  { 
    437437    if (debug) debug("handleBitmap(" + opcode + ")"); 
     
    446446 
    447447    int tlY = ras.readShort(); 
    448     int tlX = ras.readShort();  
    449     int brY = ras.readShort();  
    450     int brX = ras.readShort();  
     448    int tlX = ras.readShort(); 
     449    int brY = ras.readShort(); 
     450    int brX = ras.readShort(); 
    451451 
    452452    // skip next two rectangles 
    453     ras.skipBytes(18);  
     453    ras.skipBytes(18); 
    454454 
    455455    core.sizeX[0] = brX - tlX; 
     
    469469    for (row=0; row < core.sizeY[0]; ++row) { 
    470470      if (rowBytes < 8) {  // data is not compressed 
    471         ras.read(buf, 0, rowBytes);  
     471        ras.read(buf, 0, rowBytes); 
    472472 
    473473        for (int j=buf.length; --j >= 0;) { 
     
    478478      else { 
    479479        int rawLen; 
    480         if (rowBytes > 250) rawLen = ras.readShort();  
    481         else rawLen = ras.read();  
     480        if (rowBytes > 250) rawLen = ras.readShort(); 
     481        else rawLen = ras.read(); 
    482482 
    483483        try { 
     
    502502 
    503503  /** Extracts the image data in a PICT pixmap structure. */ 
    504   private void handlePixmap(int opcode)  
     504  private void handlePixmap(int opcode) 
    505505    throws FormatException, IOException 
    506506  { 
     
    518518 
    519519      // read the bounding box 
    520       int tlY = ras.readShort();  
    521       int tlX = ras.readShort();  
    522       int brY = ras.readShort();  
    523       int brX = ras.readShort();  
     520      int tlY = ras.readShort(); 
     521      int tlX = ras.readShort(); 
     522      int brY = ras.readShort(); 
     523      int brX = ras.readShort(); 
    524524 
    525525      ras.skipBytes(18); 
    526526 
    527527      pixelSize = ras.readShort(); 
    528       compCount = ras.readShort();  
    529       ras.skipBytes(14);  
     528      compCount = ras.readShort(); 
     529      ras.skipBytes(14); 
    530530 
    531531      core.sizeX[0] = brX - tlX; 
     
    546546    else { 
    547547      rowBytes &= 0x3fff;  // mask off flags 
    548        
     548 
    549549      int tlY = ras.readShort(); 
    550       int tlX = ras.readShort();  
    551       int brY = ras.readShort();  
    552       int brX = ras.readShort();  
     550      int tlX = ras.readShort(); 
     551      int brY = ras.readShort(); 
     552      int brX = ras.readShort(); 
    553553 
    554554      ras.skipBytes(18); 
    555555 
    556556      pixelSize = ras.readShort(); 
    557       compCount = ras.readShort();  
     557      compCount = ras.readShort(); 
    558558 
    559559      ras.skipBytes(14); 
     
    562562 
    563563      ras.skipBytes(4); 
    564       int flags = ras.readShort();  
    565       int count = ras.readShort();  
     564      int flags = ras.readShort(); 
     565      int count = ras.readShort(); 
    566566 
    567567      count++; 
     
    569569 
    570570      for (int i=0; i<count; i++) { 
    571         int index = ras.readShort();  
     571        int index = ras.readShort(); 
    572572        if ((flags & 0x8000) != 0) index = i; 
    573573        lookup[0][index] = ras.readShort(); 
     
    660660      buf = new byte[bufSize + 1 + bufSize / 128]; 
    661661      for (int row=0; row<core.sizeY[0]; row++) { 
    662         if (rBytes > 250) rawLen = ras.readShort();  
    663         else rawLen = ras.read();  
     662        if (rBytes > 250) rawLen = ras.readShort(); 
     663        else rawLen = ras.read(); 
    664664 
    665665        if (rawLen > buf.length) rawLen = buf.length; 
    666666 
    667667        if ((ras.length() - ras.getFilePointer()) <= rawLen) { 
    668           rawLen = (int) (ras.length() - ras.getFilePointer() - 1);  
     668          rawLen = (int) (ras.length() - ras.getFilePointer() - 1); 
    669669        } 
    670670 
  • trunk/loci/formats/in/QTReader.java

    r2922 r2976  
    331331      case 0: 
    332332      case 1: 
    333       case 3:   
     333      case 3: 
    334334        core.pixelType[0] = FormatTools.UINT8; 
    335335        break; 
     
    598598          for (int i=0; i<numEntries; i++) { 
    599599            if (i == 0) { 
    600               codec = in.readString(4);  
     600              codec = in.readString(4); 
    601601              in.skipBytes(74); 
    602602 
     
    613613            } 
    614614            else { 
    615               altCodec = in.readString(4);  
     615              altCodec = in.readString(4); 
    616616              addMeta("Second codec", altCodec); 
    617617            } 
     
    691691  { 
    692692    if (code.equals("raw ")) return pixs; 
    693     else if (code.equals("rle ")) {  
     693    else if (code.equals("rle ")) { 
    694694      Object[] options = new Object[2]; 
    695       options[0] = new int[] {core.sizeX[0], core.sizeY[0],  
    696         bitsPerPixel < 40 ? bitsPerPixel / 8 : (bitsPerPixel - 32) / 8};  
     695      options[0] = new int[] {core.sizeX[0], core.sizeY[0], 
     696        bitsPerPixel < 40 ? bitsPerPixel / 8 : (bitsPerPixel - 32) / 8}; 
    697697      options[1] = canUsePrevious ? prevPixels : null; 
    698       return new QTRLECodec().decompress(pixs, options);  
    699     } 
    700     else if (code.equals("rpza")) {  
     698      return new QTRLECodec().decompress(pixs, options); 
     699    } 
     700    else if (code.equals("rpza")) { 
    701701      int[] options = new int[2]; 
    702702      options[0] = core.sizeX[0]; 
    703703      options[1] = core.sizeY[0]; 
    704       return new RPZACodec().decompress(pixs, options);  
    705     } 
    706     else if (code.equals("mjpb")) {  
     704      return new RPZACodec().decompress(pixs, options); 
     705    } 
     706    else if (code.equals("mjpb")) { 
    707707      int[] options = new int[4]; 
    708708      options[0] = core.sizeX[0]; 
     
    710710      options[2] = bitsPerPixel; 
    711711      options[3] = interlaced ? 1 : 0; 
    712       return new MJPBCodec().decompress(pixs, options);  
     712      return new MJPBCodec().decompress(pixs, options); 
    713713    } 
    714714    else if (code.equals("jpeg")) { 
    715715      return new JPEGCodec().decompress(pixs); 
    716716    } 
    717     else throw new FormatException("Unsupported codec : " + code);  
     717    else throw new FormatException("Unsupported codec : " + code); 
    718718  } 
    719719 
  • trunk/loci/formats/in/SlidebookReader.java

    r2970 r2976  
    8080 
    8181    int plane = core.sizeX[series] * core.sizeY[series] * 2; 
    82    
     82 
    8383    long relativeOffset = plane * no; 
    8484    long offset = ((Long) pixelOffsets.get(series)).longValue() + plane * no; 
    85     in.seek(offset);  
     85    in.seek(offset); 
    8686    in.read(buf); 
    8787    return buf; 
     
    125125      } 
    126126      else { 
    127         String s = null;  
    128         long fp = in.getFilePointer() - 6;  
     127        String s = null; 
     128        long fp = in.getFilePointer() - 6; 
    129129        in.seek(fp); 
    130130        int len = in.read(); 
    131         if (len > 0 && len <= 32) {  
     131        if (len > 0 && len <= 32) { 
    132132          byte[] b = new byte[len]; 
    133133          in.read(b); 
    134134          s = new String(b); 
    135         }  
     135        } 
    136136 
    137137        if (s != null && s.indexOf("Annotation") != -1) { 
    138138          if (s.equals("CTimelapseAnnotation")) { 
    139139            in.skipBytes(41); 
    140             if (in.read() == 0) in.skipBytes(10);  
     140            if (in.read() == 0) in.skipBytes(10); 
    141141            else in.seek(in.getFilePointer() - 1); 
    142           }  
     142          } 
    143143          else if (s.equals("CIntensityBarAnnotation")) { 
    144144            in.skipBytes(56); 
    145             int n = in.read();  
    146             while (n == 0 || n < 6 || n > 0x80) n = in.read();  
     145            int n = in.read(); 
     146            while (n == 0 || n < 6 || n > 0x80) n = in.read(); 
    147147            in.seek(in.getFilePointer() - 1); 
    148           }  
     148          } 
    149149          else if (s.equals("CCubeAnnotation")) { 
    150150            in.skipBytes(66); 
    151             int n = in.read();  
     151            int n = in.read(); 
    152152            if (n != 0) in.seek(in.getFilePointer() - 1); 
    153153          } 
    154154          else if (s.equals("CScaleBarAnnotation")) { 
    155             in.skipBytes(52);  
    156           }  
     155            in.skipBytes(52); 
     156          } 
    157157        } 
    158158        else if (s != null && s.indexOf("Decon") != -1) { 
     
    161161        } 
    162162        else { 
    163           in.seek(fp);  
     163          in.seek(fp); 
    164164          pixelOffsets.add(new Long(fp)); 
    165165          try { 
    166             byte[] buf = new byte[8192];  
     166            byte[] buf = new byte[8192]; 
    167167            boolean found = false; 
    168168            int n = in.read(buf); 
     
    172172                if (buf[i] == 'h' && buf[i+4] == 'I' && buf[i+5] == 'I') { 
    173173                  found = true; 
    174                   in.seek(in.getFilePointer() - n + i - 20);  
    175                   break;  
     174                  in.seek(in.getFilePointer() - n + i - 20); 
     175                  break; 
    176176                } 
    177177              } 
    178178              if (!found) { 
    179179                byte[] tmp = buf; 
    180                 buf = new byte[8192];  
     180                buf = new byte[8192]; 
    181181                System.arraycopy(tmp, tmp.length - 20, buf, 0, 20); 
    182182                n = in.read(buf, 20, buf.length - 20); 
    183               }  
     183              } 
    184184            } 
    185              
    186             if (in.getFilePointer() <= in.length()) {  
    187               pixelLengths.add(new Long(in.getFilePointer() - fp));  
     185 
     186            if (in.getFilePointer() <= in.length()) { 
     187              pixelLengths.add(new Long(in.getFilePointer() - fp)); 
    188188            } 
    189189            else pixelOffsets.remove(pixelOffsets.size() - 1); 
     
    204204    long pixelBytes = 0; 
    205205    for (int i=0; i<pixelLengths.size(); i++) { 
    206       pixelBytes += ((Long) pixelLengths.get(i)).longValue();  
    207     } 
    208  
    209     // try to find the width and height  
    210     int iCount = 0;  
    211     int hCount = 0;  
    212     int uCount = 0;  
     206      pixelBytes += ((Long) pixelLengths.get(i)).longValue(); 
     207    } 
     208 
     209    // try to find the width and height 
     210    int iCount = 0; 
     211    int hCount = 0; 
     212    int uCount = 0; 
    213213    for (int i=0; i<metadataOffsets.size(); i++) { 
    214214      long off = ((Long) metadataOffsets.get(i)).longValue(); 
    215215      in.seek(off); 
    216       int n = in.read();  
     216      int n = in.read(); 
    217217      if (n == 'i') { 
    218         in.skipBytes(79);  
    219         core.sizeX[0] = in.readShort();  
    220         core.sizeY[0] = in.readShort();  
    221         iCount++;  
    222       } 
    223       else if (n == 'h') hCount++;  
    224       else if (n == 'u') uCount++;  
     218        in.skipBytes(79); 
     219        core.sizeX[0] = in.readShort(); 
     220        core.sizeY[0] = in.readShort(); 
     221        iCount++; 
     222      } 
     223      else if (n == 'h') hCount++; 
     224      else if (n == 'u') uCount++; 
    225225    } 
    226226 
    227227    core.rgb[0] = false; 
    228228    core.sizeC[0] = iCount < 5 ? iCount : 1; 
    229      
     229 
    230230    if (core.sizeC[0] == 0) core.sizeC[0] = 1; 
    231231    if (core.sizeZ[0] == 0) core.sizeZ[0] = 1; 
    232232    if (core.sizeT[0] == 0) core.sizeT[0] = 1; 
    233233 
    234     if (core.sizeX[0] * core.sizeY[0] * 2 * core.sizeC[0] *  
    235       core.sizeZ[0] * core.sizeT[0] != pixelBytes && hCount > 0)  
    236     {  
     234    if (core.sizeX[0] * core.sizeY[0] * 2 * core.sizeC[0] * 
     235      core.sizeZ[0] * core.sizeT[0] != pixelBytes && hCount > 0) 
     236    { 
    237237      core.sizeZ[0] = hCount / core.sizeC[0]; 
    238238    } 
    239239 
    240240    int n = core.sizeZ[0] * core.sizeC[0] * core.sizeT[0]; 
    241      
    242     if (uCount == core.sizeZ[0] * core.sizeT[0]) uCount = n;  
    243     if (uCount < core.sizeZ[0] * core.sizeT[0] * core.sizeC[0]) {  
     241 
     242    if (uCount == core.sizeZ[0] * core.sizeT[0]) uCount = n; 
     243    if (uCount < core.sizeZ[0] * core.sizeT[0] * core.sizeC[0]) { 
    244244      int planesPerMontage = (n * 2) / uCount; 
    245245 
     
    256256    } 
    257257    else if (uCount > core.sizeZ[0] * core.sizeT[0] * core.sizeC[0]) { 
    258       int planesPerMontage =  
    259         (int) ((core.sizeX[0] * core.sizeY[0] * 2) / (pixelBytes / uCount));  
    260       if (planesPerMontage % 2 != 0) planesPerMontage++;  
    261       if (planesPerMontage == 2) planesPerMontage += 2;  
     258      int planesPerMontage = 
     259        (int) ((core.sizeX[0] * core.sizeY[0] * 2) / (pixelBytes / uCount)); 
     260      if (planesPerMontage % 2 != 0) planesPerMontage++; 
     261      if (planesPerMontage == 2) planesPerMontage += 2; 
    262262      if (planesPerMontage == 0) planesPerMontage++; 
    263263 
    264       int plane = core.sizeX[0] * core.sizeY[0];  
    265       while (uCount * core.sizeC[0] * (plane*2 / planesPerMontage) <  
    266         (pixelBytes - plane))  
     264      int plane = core.sizeX[0] * core.sizeY[0]; 
     265      while (uCount * core.sizeC[0] * (plane*2 / planesPerMontage) < 
     266        (pixelBytes - plane)) 
    267267      { 
    268268        uCount++; 
    269269      } 
    270270 
    271       while (planesPerMontage > 1 &&  
    272         core.sizeX[0] * core.sizeY[0] * 2 * uCount > pixelBytes)  
     271      while (planesPerMontage > 1 && 
     272        core.sizeX[0] * core.sizeY[0] * 2 * uCount > pixelBytes) 
    273273      { 
    274274        core.sizeY[0] /= 2; 
    275275        planesPerMontage /= 2; 
    276         if (planesPerMontage > 1 &&  
    277           core.sizeX[0] * core.sizeY[0] * 2 * uCount > pixelBytes)  
     276        if (planesPerMontage > 1 && 
     277          core.sizeX[0] * core.sizeY[0] * 2 * uCount > pixelBytes) 
    278278        { 
    279279          core.sizeX[0] /= 2; 
    280280          planesPerMontage /= 2; 
    281281        } 
    282         else planesPerMontage = 1;  
    283       } 
    284       core.sizeZ[0] = uCount;  
     282        else planesPerMontage = 1; 
     283      } 
     284      core.sizeZ[0] = uCount; 
    285285    } 
    286286 
     
    288288    if (core.sizeX[0] == 0) core.sizeX[0] = 512; 
    289289    if (core.sizeY[0] == 0) core.sizeY[0] = 512; 
    290   
     290 
    291291    for (int i=0; i<core.sizeX.length; i++) { 
    292292      core.sizeX[i] = core.sizeX[0]; 
    293293      core.sizeY[i] = core.sizeY[0]; 
    294       core.currentOrder[i] = "XYZCT";  
    295       core.pixelType[i] = FormatTools.UINT16;  
    296       core.littleEndian[i] = true;  
    297      
     294      core.currentOrder[i] = "XYZCT"; 
     295      core.pixelType[i] = FormatTools.UINT16; 
     296      core.littleEndian[i] = true; 
     297 
    298298      core.sizeC[i] = core.sizeC[0]; 
    299299      core.sizeT[i] = core.sizeT[0]; 
    300300      long len = ((Long) pixelLengths.get(i)).longValue(); 
    301       core.sizeZ[i] =  
     301      core.sizeZ[i] = 
    302302        (int) (len / (core.sizeX[i] * core.sizeY[i] * 2 * core.sizeC[i])); 
    303         
    304       core.imageCount[i] = core.sizeC[i] * core.sizeZ[i] * core.sizeT[i];  
    305     }  
    306    
    307     MetadataStore store = getMetadataStore();   
    308  
    309     for (int i=0; i<core.sizeX.length; i++) {  
     303 
     304      core.imageCount[i] = core.sizeC[i] * core.sizeZ[i] * core.sizeT[i]; 
     305    } 
     306 
     307    MetadataStore store = getMetadataStore(); 
     308 
     309    for (int i=0; i<core.sizeX.length; i++) { 
    310310      store.setPixels(new Integer(core.sizeX[i]), new Integer(core.sizeY[i]), 
    311311        new Integer(core.sizeZ[i]), new Integer(core.sizeC[i]), 
     
    318318          core.sizeC[i] == 1 ? "monochrome" : "RGB", null, new Integer(i)); 
    319319      } 
    320     }  
     320    } 
    321321  } 
    322322 
  • trunk/loci/formats/in/TCSReader.java

    r2940 r2976  
    3030import loci.formats.*; 
    3131 
    32 /**  
    33  * TCSReader is the file format reader for Leica TCS TIFF files.  
     32/** 
     33 * TCSReader is the file format reader for Leica TCS TIFF files. 
    3434 */ 
    3535public class TCSReader extends BaseTiffReader { 
     
    5050  /* @see loci.formats.IFormatHandler#isThisType(String, boolean) */ 
    5151  public boolean isThisType(String name, boolean open) { 
    52     if (!name.toLowerCase().endsWith("tif") &&  
    53       !name.toLowerCase().endsWith("tiff"))  
    54     {   
    55       return false;  
    56     }  
    57      
     52    if (!name.toLowerCase().endsWith("tif") && 
     53      !name.toLowerCase().endsWith("tiff")) 
     54    { 
     55      return false; 
     56    } 
     57 
    5858    try { 
    5959      RandomAccessStream ras = new RandomAccessStream(name); 
     
    6161      ras.close(); 
    6262      if (ifd == null) return false; 
    63      
    64       String document = (String) ifd.get(new Integer(TiffTools.DOCUMENT_NAME));  
     63 
     64      String document = (String) ifd.get(new Integer(TiffTools.DOCUMENT_NAME)); 
    6565      if (document == null) return false; 
    6666      return document.startsWith("CHANNEL"); 
    6767    } 
    68     catch (Exception e) { return false; }  
     68    catch (Exception e) { return false; } 
    6969  } 
    70    
     70 
    7171  // -- Internal BaseTiffReader API methods -- 
    72   
     72 
    7373  /* @see BaseTiffReader#initStandardMetadata() */ 
    7474  protected void initStandardMetadata() throws FormatException, IOException { 
     
    8383 
    8484    for (int i=0; i<ifds.length; i++) { 
    85       String document =  
     85      String document = 
    8686        (String) ifds[i].get(new Integer(TiffTools.DOCUMENT_NAME)); 
    87      
     87 
    8888      int index = document.indexOf("INDEX"); 
    8989      String c = document.substring(8, index).trim(); 
    9090      ch[i] = Integer.parseInt(c); 
    91       if (ch[i] > channelCount) channelCount = ch[i];  
     91      if (ch[i] > channelCount) channelCount = ch[i]; 
    9292 
    93       String n = document.substring(index + 6,  
    94         document.indexOf(" ", index + 6)).trim();  
    95       idx[i] = Integer.parseInt(n);  
    96     
    97       String date = document.substring(document.indexOf(" ", index + 6),  
    98         document.indexOf("FORMAT")).trim();  
    99       stamp[i] = fmt.parse(date, new ParsePosition(0)).getTime();  
     93      String n = document.substring(index + 6, 
     94        document.indexOf(" ", index + 6)).trim(); 
     95      idx[i] = Integer.parseInt(n); 
     96 
     97      String date = document.substring(document.indexOf(" ", index + 6), 
     98        document.indexOf("FORMAT")).trim(); 
     99      stamp[i] = fmt.parse(date, new ParsePosition(0)).getTime(); 
    100100    } 
    101101 
     
    103103    core.currentOrder[0] = core.rgb[0] ? "XYC" : "XY"; 
    104104 
    105     // determine the axis sizes and ordering  
     105    // determine the axis sizes and ordering 
    106106    boolean unique = true; 
    107107    for (int i=0; i<stamp.length; i++) { 
     
    114114      if (unique) { 
    115115        core.sizeT[0]++; 
    116         if (core.currentOrder[0].indexOf("T") < 0) core.currentOrder[0] += "T";  
     116        if (core.currentOrder[0].indexOf("T") < 0) core.currentOrder[0] += "T"; 
    117117      } 
    118118      else if (i > 0) { 
     
    121121        } 
    122122        else if (core.currentOrder[0].indexOf("Z") < 0) { 
    123           core.currentOrder[0] += "Z";  
     123          core.currentOrder[0] += "Z"; 
    124124        } 
    125125      } 
    126       unique = true;  
     126      unique = true; 
    127127    } 
    128128 
     
    132132 
    133133    if (core.sizeT[0] == 0) core.sizeT[0] = 1; 
    134     if (channelCount == 0) channelCount = 1;  
     134    if (channelCount == 0) channelCount = 1; 
    135135    core.sizeZ[0] = ifds.length / (core.sizeT[0] * channelCount); 
    136136    core.sizeC[0] *= channelCount; 
    137     core.imageCount[0] = core.sizeZ[0] * core.sizeT[0] * channelCount;  
    138    
    139     // cut up comment  
    140   
     137    core.imageCount[0] = core.sizeZ[0] * core.sizeT[0] * channelCount; 
     138 
     139    // cut up comment 
     140 
    141141    String comment = (String) getMeta("Comment"); 
    142142    if (comment != null && comment.startsWith("[")) { 
     
    153153      metadata.remove("Comment"); 
    154154    } 
    155   }  
     155  } 
    156156 
    157157} 
  • trunk/loci/formats/in/VisitechReader.java

    r2970 r2976  
    4040  // -- Constructor -- 
    4141 
    42   public VisitechReader() {  
     42  public VisitechReader() { 
    4343    super("Visitech XYS", new String[] {"xys", "html"}); 
    4444  } 
     
    5555    byte[] buf = new byte[core.sizeX[0] * core.sizeY[0] * 
    5656      FormatTools.getBytesPerPixel(core.pixelType[0])]; 
    57     return openBytes(no, buf);  
     57    return openBytes(no, buf); 
    5858  } 
    5959 
     
    6262    throws FormatException, IOException 
    6363  { 
    64     FormatTools.assertId(currentId, true, 1);  
     64    FormatTools.assertId(currentId, true, 1); 
    6565    if (no < 0 || no >= core.imageCount[0]) { 
    6666      throw new FormatException("Invalid image number: " + no); 
    6767    } 
    68     int plane = core.sizeX[0] * core.sizeY[0] *  
     68    int plane = core.sizeX[0] * core.sizeY[0] * 
    6969      FormatTools.getBytesPerPixel(core.pixelType[0]); 
    70     if (buf.length < plane) {  
     70    if (buf.length < plane) { 
    7171      throw new FormatException("Buffer too small."); 
    7272    } 
     
    7979    s.skipBytes(382 + (plane + 164)*planeIndex); 
    8080    s.read(buf); 
    81     s.close();  
     81    s.close(); 
    8282    return buf; 
    8383  } 
     
    9292  /* @see loci.formats.IFormatReader#getUsedFiles() */ 
    9393  public String[] getUsedFiles() { 
    94     if (files == null) return new String[0];  
    95     return (String[]) files.toArray(new String[0]);  
     94    if (files == null) return new String[0]; 
     95    return (String[]) files.toArray(new String[0]); 
    9696  } 
    9797 
     
    101101  protected void initFile(String id) throws FormatException, IOException { 
    102102    super.initFile(id); 
    103    
    104     // first, make sure we have the HTML file  
    105   
     103 
     104    // first, make sure we have the HTML file 
     105 
    106106    if (!id.toLowerCase().endsWith("html")) { 
    107107      Location file = new Location(id).getAbsoluteFile(); 
    108108      String path = file.getPath(); 
    109       int ndx = path.lastIndexOf(File.separator);  
    110       String base = path.substring(ndx + 1, path.indexOf(" ", ndx));  
    111     
     109      int ndx = path.lastIndexOf(File.separator); 
     110      String base = path.substring(ndx + 1, path.indexOf(" ", ndx)); 
     111 
    112112      currentId = null; 
    113       initFile(new Location(file.getParent(),  
     113      initFile(new Location(file.getParent(), 
    114114        base + " Report.html").getAbsolutePath()); 
    115       return;  
    116     }  
    117   
     115      return; 
     116    } 
     117 
    118118    // parse the HTML file 
    119119 
     
    123123 
    124124    // strip out "style", "a", and "script" tags 
    125   
     125 
    126126    s = s.replaceAll("<[bB][rR]>", "\n"); 
    127127    s = s.replaceAll("<[sS][tT][yY][lL][eE]\\p{ASCII}*?" + 
     
    135135 
    136136      if ((token.startsWith("<") && !token.startsWith("</")) || 
    137         token.indexOf("pixels") != -1)  
     137        token.indexOf("pixels") != -1) 
    138138      { 
    139139        token = token.replaceAll("<.*?>", ""); 
    140         int ndx = token.indexOf(":");  
    141          
     140        int ndx = token.indexOf(":"); 
     141 
    142142        if (ndx != -1) { 
    143           addMeta(token.substring(0, ndx).trim(),  
     143          addMeta(token.substring(0, ndx).trim(), 
    144144            token.substring(ndx + 1).trim()); 
    145145        } 
    146       
     146 
    147147        if (token.indexOf("pixels") != -1) { 
    148148          core.sizeC[0]++; 
    149           core.imageCount[0] +=  
    150             Integer.parseInt(token.substring(0, token.indexOf(" ")));  
    151         }  
     149          core.imageCount[0] += 
     150            Integer.parseInt(token.substring(0, token.indexOf(" "))); 
     151        } 
    152152      } 
    153153    } 
     
    172172    String xy = (String) metadata.get("Image dimensions"); 
    173173    core.sizeX[0] = Integer.parseInt(xy.substring(1, xy.indexOf(",")).trim()); 
    174     core.sizeY[0] = Integer.parseInt(xy.substring(xy.indexOf(",") + 1,  
     174    core.sizeY[0] = Integer.parseInt(xy.substring(xy.indexOf(",") + 1, 
    175175      xy.length() - 1).trim()); 
    176176    core.rgb[0] = false; 
     
    179179    core.littleEndian[0] = true; 
    180180 
    181     // find pixels files - we think there is one channel per file  
    182      
     181    // find pixels files - we think there is one channel per file 
     182 
    183183    files = new Vector(); 
    184184 
    185185    Location file = new Location(id).getAbsoluteFile(); 
    186186    String path = file.getPath(); 
    187     int ndx = path.lastIndexOf(File.separator);  
    188     String base = path.substring(ndx + 1, path.indexOf(" ", ndx));  
     187    int ndx = path.lastIndexOf(File.separator); 
     188    String base = path.substring(ndx + 1, path.indexOf(" ", ndx)); 
    189189 
    190190    for (int i=0; i<core.sizeC[0]; i++) { 
    191       files.add(new Location(file.getParent(),  
    192         base + " " + (i + 1) + ".xys").getAbsolutePath());   
    193     } 
    194    
    195     files.add(currentId);  
    196    
     191      files.add(new Location(file.getParent(), 
     192        base + " " + (i + 1) + ".xys").getAbsolutePath()); 
     193    } 
     194 
     195    files.add(currentId); 
     196 
    197197    MetadataStore store = getMetadataStore(); 
    198198    store.setPixels(new Integer(core.sizeX[0]), new Integer(core.sizeY[0]), 
     
    205205        core.sizeC[0] == 1 ? "monochrome" : "RGB", null, null); 
    206206    } 
    207    
     207 
    208208  } 
    209209 
  • trunk/loci/formats/in/ZeissZVIReader.java

    r2964 r2976  
    448448        { 
    449449          if (entryName.equals("Tags")) { 
    450             parseTags(s);  
     450            parseTags(s); 
    451451          } 
    452452        } 
    453453        else if (dirName.equals("Tags") && isContents) { 
    454           parseTags(s);  
     454          parseTags(s); 
    455455        } 
    456456        else if (isContents && (dirName.equals("Image") || 
     
    458458          (data.length > core.sizeX[0]*core.sizeY[0])) 
    459459        { 
    460           s.skipBytes(6);  
     460          s.skipBytes(6); 
    461461 
    462462          int vt = s.readShort(); 
    463463          if (vt == 3) { 
    464             s.skipBytes(6);  
     464            s.skipBytes(6); 
    465465          } 
    466466          else if (vt == 8) { 
    467             int l = s.readShort();  
    468             s.skipBytes(l + 2);  
     467            int l = s.readShort(); 
     468            s.skipBytes(l + 2); 
    469469          } 
    470           int len = s.readShort();  
    471           if (s.readShort() != 0) s.seek(s.getFilePointer() - 2);  
     470          int len = s.readShort(); 
     471          if (s.readShort() != 0) s.seek(s.getFilePointer() - 2); 
    472472 
    473473          String typeDescription = ""; 
     
    479479          vt = s.readShort(); 
    480480          if (vt == 8) { 
    481             len = s.readInt();  
    482             s.skipBytes(len + 2);  
     481            len = s.readInt(); 
     482            s.skipBytes(len + 2); 
    483483          } 
    484484 
     
    487487            core.sizeX[0] = tw; 
    488488          } 
    489           s.skipBytes(2);  
    490           int th = s.readInt();  
     489          s.skipBytes(2); 
     490          int th = s.readInt(); 
    491491          if (core.sizeY[0] == 0 || (th < core.sizeY[0] && th > 0)) { 
    492492            core.sizeY[0] = th; 
     
    506506 
    507507          // VT_BLOB - Others 
    508           len = s.readInt();  
    509           s.skipBytes(len);  
     508          len = s.readInt(); 
     509          s.skipBytes(len); 
    510510 
    511511          // VT_STORED_OBJECT - Layers 
    512512          s.skipBytes(2); 
    513513          long old = s.getFilePointer(); 
    514           len = s.readInt();  
     514          len = s.readInt(); 
    515515 
    516516          s.skipBytes(8); 
    517517 
    518518          int tidx = s.readInt(); 
    519           int cidx = s.readInt();  
    520           int zidx = s.readInt();  
     519          int cidx = s.readInt(); 
     520          int zidx = s.readInt(); 
    521521 
    522522          Integer zndx = new Integer(zidx); 
     
    531531 
    532532          boolean foundWidth = s.readInt() == core.sizeX[0]; 
    533           boolean foundHeight = s.readInt() == core.sizeY[0];  
     533          boolean foundHeight = s.readInt() == core.sizeY[0]; 
    534534          boolean findFailed = false; 
    535           while ((!foundWidth || !foundHeight) &&  
    536             s.getFilePointer() + 1 < s.length())  
     535          while ((!foundWidth || !foundHeight) && 
     536            s.getFilePointer() + 1 < s.length()) 
    537537          { 
    538             s.seek(s.getFilePointer() - 7);  
    539             foundWidth = s.readInt() == core.sizeX[0];  
    540             foundHeight = s.readInt() == core.sizeY[0];  
     538            s.seek(s.getFilePointer() - 7); 
     539            foundWidth = s.readInt() == core.sizeX[0]; 
     540            foundHeight = s.readInt() == core.sizeY[0]; 
    541541          } 
    542           s.seek(s.getFilePointer() - 16);  
     542          s.seek(s.getFilePointer() - 16); 
    543543          findFailed = !foundWidth && !foundHeight; 
    544544 
     
    581581  /** Parse a plane of data. */ 
    582582  private void parsePlane(byte[] data, int num, Object directory, String entry) 
    583     throws IOException  
     583    throws IOException 
    584584  { 
    585585    RandomAccessStream s = new RandomAccessStream(data); 
    586586    s.order(true); 
    587587    s.skipBytes(8); 
    588      
    589     core.sizeX[0] = s.readInt();  
    590     core.sizeY[0] = s.readInt();  
    591     int depth = s.readInt();  
    592     bpp = s.readInt();  
    593     int pixelFormat = s.readInt();  
    594     int validBitsPerPixel = s.readInt();  
     588 
     589    core.sizeX[0] = s.readInt(); 
     590    core.sizeY[0] = s.readInt(); 
     591    int depth = s.readInt(); 
     592    bpp = s.readInt(); 
     593    int pixelFormat = s.readInt(); 
     594    int validBitsPerPixel = s.readInt(); 
    595595 
    596596    pixels.put(new Integer(num), directory); 
     
    603603  /** Parse all of the tags in a stream. */ 
    604604  private void parseTags(RandomAccessStream s) throws IOException { 
    605     s.skipBytes(24);  
    606  
    607     int count = s.readInt();  
     605    s.skipBytes(24); 
     606 
     607    int count = s.readInt(); 
    608608 
    609609    // limit count to 4096 
     
    611611 
    612612    for (int i=0; i<count; i++) { 
    613       if (s.getFilePointer() + 2 >= s.length()) break;  
    614       int type = s.readShort();  
     613      if (s.getFilePointer() + 2 >= s.length()) break; 
     614      int type = s.readShort(); 
    615615 
    616616      String value = ""; 
     
    621621          break; 
    622622        case 2: 
    623           value = "" + s.readShort();  
     623          value = "" + s.readShort(); 
    624624          break; 
    625625        case 3: 
    626626        case 22: 
    627627        case 23: 
    628           value = "" + s.readInt();  
     628          value = "" + s.readInt(); 
    629629          break; 
    630630        case 4: 
    631           value = "" + s.readFloat();  
     631          value = "" + s.readFloat(); 
    632632          break; 
    633633        case 5: 
    634           value = "" + s.readDouble();  
     634          value = "" + s.readDouble(); 
    635635          break; 
    636636        case 7: 
    637637        case 20: 
    638638        case 21: 
    639           value = "" + s.readLong();  
     639          value = "" + s.readLong(); 
    640640          break; 
    641641        case 69: 
     
    645645            value = s.readString(len); 
    646646          } 
    647           else return;  
     647          else return; 
    648648          break; 
    649649        case 66: 
    650           int l = s.readShort();  
     650          int l = s.readShort(); 
    651651          s.seek(s.getFilePointer() - 2); 
    652652          value = s.readString(l + 2); 
    653653          break; 
    654654        default: 
    655           long old = s.getFilePointer();  
    656           while (s.readShort() != 3 &&  
     655          long old = s.getFilePointer(); 
     656          while (s.readShort() != 3 && 
    657657            s.getFilePointer() + 2 < s.length()); 
    658           long fp = s.getFilePointer() - 2;  
     658          long fp = s.getFilePointer() - 2; 
    659659          s.seek(old - 2); 
    660660          value = s.readString((int) (fp - old + 2)); 
    661661      } 
    662    
    663       s.skipBytes(2);  
     662 
     663      s.skipBytes(2); 
    664664      int tagID = 0; 
    665       int attribute = 0;  
    666      
     665      int attribute = 0; 
     666 
    667667      try { tagID = s.readInt(); } 
    668668      catch (IOException e) { } 
    669     
    670       s.skipBytes(2);  
    671     
     669 
     670      s.skipBytes(2); 
     671 
    672672      try { attribute = s.readInt(); } 
    673673      catch (IOException e) { } 
    674       
     674 
    675675      parseTag(value, tagID, attribute); 
    676676      if (metadata.get("ImageWidth") != null) { 
    677         try {  
    678           if (core.sizeX[0] == 0) core.sizeX[0] = Integer.parseInt(value);  
     677        try { 
     678          if (core.sizeX[0] == 0) core.sizeX[0] = Integer.parseInt(value); 
    679679        } 
    680680        catch (NumberFormatException e) { } 
    681       }  
     681      } 
    682682      if (metadata.get("ImageHeight") != null) { 
    683         try {  
    684           if (core.sizeY[0] == 0) core.sizeY[0] = Integer.parseInt(value);  
     683        try { 
     684          if (core.sizeY[0] == 0) core.sizeY[0] = Integer.parseInt(value); 
    685685        } 
    686686        catch (NumberFormatException e) { } 
    687       }  
     687      } 
    688688    } 
    689689  } 
  • trunk/loci/formats/ome/OMEReader.java

    r2957 r2976  
    109109 
    110110    currentId = server + ":" + imageId; 
    111      
     111 
    112112    String omeis = "http://" + server + "/cgi-bin/omeis"; 
    113113    server = "http://" + server + "/shoola/"; 
  • trunk/loci/formats/ome/OMEXMLMetadataStore.java

    r2957 r2976  
    9595  } 
    9696 
    97   /** Add the key/value pair as a new OriginalMetadata node. */  
     97  /** Add the key/value pair as a new OriginalMetadata node. */ 
    9898  public void populateOriginalMetadata(String key, String value) { 
    99     if (firstImageCA == null) {  
     99    if (firstImageCA == null) { 
    100100      ImageNode image = (ImageNode) getChild(root, "Image", 0); 
    101       CustomAttributesNode ca =  
     101      CustomAttributesNode ca = 
    102102        (CustomAttributesNode) getChild(image, "CustomAttributes", 0); 
    103103      firstImageCA = ca.getDOMElement(); 
  • trunk/loci/formats/test/ConfigurationFiles.java

    r2922 r2976  
    141141              s.substring(ndx, s.indexOf(" ", ndx))); 
    142142            ndx = s.indexOf("little") + 7; 
    143             entry.littleEndian[i] =  
     143            entry.littleEndian[i] = 
    144144              s.substring(ndx, s.indexOf(" ", ndx)).equals("true"); 
    145145            ndx = s.indexOf("md5") + 4; 
     
    262262    private int[] type; 
    263263    private boolean[] littleEndian; 
    264     private String[] md5;  
     264    private String[] md5; 
    265265    private float access; 
    266266    private int mem; 
  • trunk/loci/formats/test/ReaderTest.java

    r2919 r2976  
    3232import loci.formats.ome.OMEXMLMetadataStore; 
    3333 
    34 /**  
     34/** 
    3535 * TestNG tester for Bio-Formats file format readers. 
    3636 * Details on failed tests are written to a log file, for easier processing. 
     
    3838 * To run tests: 
    3939 * java -ea -mx512m -Dtestng.directory="/path/" -Dtestng.multiplier="1.0" \ 
    40  *   org.testng.TestNG -sourcedir . testng.xml  
     40 *   org.testng.TestNG -sourcedir . testng.xml 
    4141 */ 
    4242public class ReaderTest { 
     
    4848 
    4949  /** List of files to test. */ 
    50   private static Vector toTest;  
     50  private static Vector toTest; 
    5151 
    5252  /** List of configuration files. */ 
     
    6666  public Object[][] createData() { 
    6767    if (isFirstTime) { 
    68       toTest = new Vector();  
     68      toTest = new Vector(); 
    6969      getFiles(System.getProperty("testng.directory"), toTest); 
    70       isFirstTime = false;  
     70      isFirstTime = false; 
    7171    } 
    7272    String[] o = (String[]) toTest.toArray(new String[0]); 
     
    9595        int c = reader.getRGBChannelCount(); 
    9696        int type = reader.getPixelType(); 
    97        
     97 
    9898        for (int j=0; j<reader.getImageCount(); j++) { 
    9999          BufferedImage b = reader.openImage(j); 
     
    102102          boolean failC = b.getRaster().getNumBands() <= c; 
    103103          boolean failType = ImageTools.getPixelType(b) != type; 
    104          
     104 
    105105          success = failX || failY || failC || failType; 
    106106          if (!success) { 
    107107            writeLog(file + " failed BufferedImage test"); 
    108             break;  
     108            break; 
    109109          } 
    110110        } 
    111111      } 
    112       assert success;  
     112      assert success; 
    113113    } 
    114114    catch (Exception exc) { 
    115115      writeLog(file + " failed BufferedImage test"); 
    116116      writeLog(exc); 
    117       assert false;  
     117      assert false; 
    118118    } 
    119119  } 
     
    151151      writeLog(file + " failed byte array test"); 
    152152      writeLog(exc); 
    153       assert false;  
     153      assert false; 
    154154    } 
    155155  } 
     
    172172        int c = reader.getRGBChannelCount(); 
    173173        int type = reader.getPixelType(); 
    174        
     174 
    175175        for (int j=0; j<reader.getImageCount(); j++) { 
    176176          BufferedImage b = reader.openThumbImage(j); 
     
    179179          boolean failC = b.getRaster().getNumBands() <= c; 
    180180          boolean failType = ImageTools.getPixelType(b) != type; 
    181          
     181 
    182182          success = failX || failY || failC || failType; 
    183183          if (!success) { 
    184184            writeLog(file + " failed thumbnail BufferedImage test"); 
    185             break;  
     185            break; 
    186186          } 
    187187        } 
    188188      } 
    189       assert success;  
     189      assert success; 
    190190    } 
    191191    catch (Exception exc) { 
    192192      writeLog(file + " failed thumbnail BufferedImage test"); 
    193193      writeLog(exc); 
    194       assert false;  
     194      assert false; 
    195195    } 
    196196  } 
     
    228228      writeLog(file + " failed thumbnail byte array test"); 
    229229      writeLog(exc); 
    230       assert false;  
    231     } 
    232   } 
    233    
    234   /** 
    235    * @testng.test dataProvider = "provider" 
    236     *             groups = "all fast"  
     230      assert false; 
     231    } 
     232  } 
     233 
     234  /** 
     235   * @testng.test dataProvider = "provider" 
     236    *             groups = "all fast" 
    237237   */ 
    238238  public void testImageCount(String file) { 
     
    240240      FileStitcher reader = new FileStitcher(); 
    241241      reader.setId(file); 
    242       boolean success = true;  
     242      boolean success = true; 
    243243      for (int i=0; i<reader.getSeriesCount(); i++) { 
    244244        reader.setSeries(i); 
     
    249249        if (imageCount != z * c * t) { 
    250250          success = false; 
    251           break;  
    252         }  
    253       }  
    254       reader.close();  
    255       if (!success) writeLog(file + " failed image count test");  
    256       assert success;  
     251          break; 
     252        } 
     253      } 
     254      reader.close(); 
     255      if (!success) writeLog(file + " failed image count test"); 
     256      assert success; 
    257257    } 
    258258    catch (Exception exc) { 
    259259      writeLog(file + " failed image count test"); 
    260260      writeLog(exc); 
    261       assert false;  
    262     } 
    263   }  
    264  
    265   /** 
    266    * @testng.test dataProvider = "provider" 
    267    *              groups = "all xml fast"  
     261      assert false; 
     262    } 
     263  } 
     264 
     265  /** 
     266   * @testng.test dataProvider = "provider" 
     267   *              groups = "all xml fast" 
    268268   */ 
    269269  public void testOMEXML(String file) { 
     
    280280      for (int i=0; i<reader.getSeriesCount(); i++) { 
    281281        reader.setSeries(i); 
    282          
     282 
    283283        Integer ii = new Integer(i); 
    284284 
    285285        String type = FormatTools.getPixelTypeString(reader.getPixelType()); 
    286286 
    287         boolean failX = reader.getSizeX() != store.getSizeX(ii).intValue();  
    288         boolean failY = reader.getSizeY() != store.getSizeY(ii).intValue();  
    289         boolean failZ = reader.getSizeZ() != store.getSizeZ(ii).intValue();  
    290         boolean failC = reader.getSizeC() != store.getSizeC(ii).intValue();  
    291         boolean failT = reader.getSizeT() != store.getSizeT(ii).intValue();  
    292         boolean failBE =  
    293           reader.isLittleEndian() == store.getBigEndian(ii).booleanValue();  
    294         boolean failDE =  
    295           !reader.getDimensionOrder().equals(store.getDimensionOrder(ii));  
    296         boolean failType = !type.equalsIgnoreCase(store.getPixelType(ii));  
     287        boolean failX = reader.getSizeX() != store.getSizeX(ii).intValue(); 
     288        boolean failY = reader.getSizeY() != store.getSizeY(ii).intValue(); 
     289        boolean failZ = reader.getSizeZ() != store.getSizeZ(ii).intValue(); 
     290        boolean failC = reader.getSizeC() != store.getSizeC(ii).intValue(); 
     291        boolean failT = reader.getSizeT() != store.getSizeT(ii).intValue(); 
     292        boolean failBE = 
     293          reader.isLittleEndian() == store.getBigEndian(ii).booleanValue(); 
     294        boolean failDE = 
     295          !reader.getDimensionOrder().equals(store.getDimensionOrder(ii)); 
     296        boolean failType = !type.equalsIgnoreCase(store.getPixelType(ii)); 
    297297 
    298298        if (success) { 
     
    300300            failDE || failType); 
    301301        } 
    302         if (!success) break;  
    303       }  
    304       if (!success) writeLog(file + " failed OME-XML sanity test");  
    305       assert success;  
     302        if (!success) break; 
     303      } 
     304      if (!success) writeLog(file + " failed OME-XML sanity test"); 
     305      assert success; 
    306306    } 
    307307    catch (Exception exc) { 
    308308      writeLog(file + " failed OME-XML sanity test"); 
    309309      writeLog(exc); 
    310       assert false;  
    311     } 
    312   } 
    313  
    314   /** 
    315    * @testng.test dataProvider = "provider" 
    316    *              groups = "all fast"  
     310      assert false; 
     311    } 
     312  } 
     313 
     314  /** 
     315   * @testng.test dataProvider = "provider" 
     316   *              groups = "all fast" 
    317317   */ 
    318318  public void testConsistent(String file) { 
     
    323323      boolean success = true; 
    324324      boolean failSeries = r.getSeriesCount() != config.getNumSeries(file); 
    325         
     325 
    326326      if (failSeries) { 
    327         writeLog(file + " failed consistent metadata (wrong series count)");  
     327        writeLog(file + " failed consistent metadata (wrong series count)"); 
    328328        assert false; 
    329         return;  
    330       }  
     329        return; 
     330      } 
    331331 
    332332      for (int i=0; i<r.getSeriesCount(); i++) { 
    333333        r.setSeries(i); 
    334334        config.setSeries(file, i); 
    335        
     335 
    336336        boolean failX = config.getWidth(file) != r.getSizeX(); 
    337337        boolean failY = config.getHeight(file) != r.getSizeY(); 
     
    339339        boolean failC = config.getC(file) != r.getSizeC(); 
    340340        boolean failT = config.getT(file) != r.getSizeT(); 
    341         boolean failDim =  
    342           !config.getDimOrder(file).equals(r.getDimensionOrder());  
    343         boolean failInt = config.isInterleaved(file) != r.isInterleaved();  
     341        boolean failDim = 
     342          !config.getDimOrder(file).equals(r.getDimensionOrder()); 
     343        boolean failInt = config.isInterleaved(file) != r.isInterleaved(); 
    344344        boolean failRGB = config.isRGB(file) != r.isRGB(); 
    345         // TODO : uncomment this once the config files have been updated  
     345        // TODO : uncomment this once the config files have been updated 
    346346        //boolean failTX = config.getThumbX(file) != r.getThumbSizeX(); 
    347347        //boolean failTY = config.getThumbY(file) != r.getThumbSizeY(); 
    348348        boolean failType = config.getPixelType(file) != r.getPixelType(); 
    349349        boolean failEndian = config.isLittleEndian(file) != r.isLittleEndian(); 
    350        
     350 
    351351        success = !(failX || failY || failZ || failC || failT || failDim || 
    352352          failInt || failRGB || /*failTX || failTY || */failType || failEndian); 
    353       
     353 
    354354        if (!success) { 
    355355          writeLog(file + " failed consistent metadata test"); 
    356           assert false;  
    357           return;  
     356          assert false; 
     357          return; 
    358358        } 
    359359      } 
     
    363363      writeLog(file + " failed consistent metadata test"); 
    364364      writeLog(exc); 
    365       assert false;  
    366     } 
    367   } 
    368  
    369   /** 
    370    * @testng.test dataProvider = "provider" 
    371    *              groups = "all"  
     365      assert false; 
     366    } 
     367  } 
     368 
     369  /** 
     370   * @testng.test dataProvider = "provider" 
     371   *              groups = "all" 
    372372   */ 
    373373  public void testMemoryUsage(String file) { 
     
    386386        mem = (int) ((r.totalMemory() - r.freeMemory()) >> 20); 
    387387        if (mem > maxMemory) maxMemory = mem; 
    388       }  
    389       int finalMemory = (int) ((r.totalMemory() - r.freeMemory()) >> 20);  
     388      } 
     389      int finalMemory = (int) ((r.totalMemory() - r.freeMemory()) >> 20); 
    390390 
    391391      boolean success = true; 
    392392 
    393       // max memory usage should be no more than twice the file size  
     393      // max memory usage should be no more than twice the file size 
    394394      if (maxMemory - initialMemory > 2*(config.getFileSize(file) + 1)) { 
    395395        success = false; 
    396         writeLog(file + " failed memory test (used " +  
    397           (maxMemory - initialMemory) + "MB; expected <= " +  
     396        writeLog(file + " failed memory test (used " + 
     397          (maxMemory - initialMemory) + "MB; expected <= " + 
    398398          (2*config.getFileSize(file) + 1) + "MB)"); 
    399399      } 
    400     
    401       // check that the reader doesn't have any significant memory leaks  
     400 
     401      // check that the reader doesn't have any significant memory leaks 
    402402      if (finalMemory - initialMemory > 10) { 
    403403        success = false; 
     
    405405          (finalMemory - initialMemory) + "MB leaked)"); 
    406406      } 
    407       assert success;  
     407      assert success; 
    408408    } 
    409409    catch (Exception e) { 
    410410      writeLog(file + " failed memory test"); 
    411411      writeLog(e); 
    412       assert false;  
    413     } 
    414   } 
    415  
    416   /** 
    417    * @testng.test dataProvider = "provider" 
    418    *              groups = "all"  
     412      assert false; 
     413    } 
     414  } 
     415 
     416  /** 
     417   * @testng.test dataProvider = "provider" 
     418   *              groups = "all" 
    419419   */ 
    420420  public void testAccessTime(String file) { 
    421421    try { 
    422       float timeMultiplier =  
    423         Float.parseFloat(System.getProperty("testng.multiplier"));  
    424        
     422      float timeMultiplier = 
     423        Float.parseFloat(System.getProperty("testng.multiplier")); 
     424 
    425425      FileStitcher reader = new FileStitcher(); 
    426426      reader.setId(file); 
     
    431431      } 
    432432      long l2 = System.currentTimeMillis(); 
    433       if (((l2 - l1) / reader.getImageCount()) -  
     433      if (((l2 - l1) / reader.getImageCount()) - 
    434434        timeMultiplier*config.getTimePerPlane(file) > 20.0) 
    435435      { 
     
    437437          ((l2 - l1) / reader.getImageCount()) + " ms, expected " + 
    438438          config.getTimePerPlane(file) + " ms)"); 
    439         assert false;  
    440         return;  
    441       } 
    442       assert true;  
     439        assert false; 
     440        return; 
     441      } 
     442      assert true; 
    443443    } 
    444444    catch (Exception e) { 
    445445      writeLog(file + " failed consistent access time test"); 
    446446      writeLog(e); 
    447       assert false;  
    448     } 
    449   } 
    450  
    451   /** 
    452    * @testng.test dataProvider = "provider" 
    453    *              groups = "all"  
     447      assert false; 
     448    } 
     449  } 
     450 
     451  /** 
     452   * @testng.test dataProvider = "provider" 
     453   *              groups = "all" 
    454454   */ 
    455455  public void testSaneUsedFiles(String file) { 
     
    457457      FileStitcher reader = new FileStitcher(); 
    458458      reader.setId(file); 
    459        
     459 
    460460      String[] base = reader.getUsedFiles(); 
    461461      Arrays.sort(base); 
     
    469469            writeLog(file + " failed sane used files test (" + base[i] + ")"); 
    470470            assert false; 
    471             return;  
     471            return; 
    472472          } 
    473473        } 
    474474      } 
    475       reader.close();  
    476       assert true;  
     475      reader.close(); 
     476      assert true; 
    477477    } 
    478478    catch (Exception e) { 
    479479      writeLog(file + " failed sane used files test"); 
    480480      writeLog(e); 
    481       assert false;  
    482     } 
    483   } 
    484  
    485   /** 
    486    * @testng.test dataProvider = "provider" 
    487    *              groups = "all xml fast"  
     481      assert false; 
     482    } 
     483  } 
     484 
     485  /** 
     486   * @testng.test dataProvider = "provider" 
     487   *              groups = "all xml fast" 
    488488   */ 
    489489  public void testValidXML(String file) { 
     
    497497      String xml = ((OMEXMLMetadataStore) reader.getMetadataStore()).dumpXML(); 
    498498      if (xml == null) writeLog(file + " failed OME-XML validation"); 
    499       reader.close();  
    500       assert xml != null;  
     499      reader.close(); 
     500      assert xml != null; 
    501501    } 
    502502    catch (Exception e) { 
    503503      writeLog(file + " failed OME-XML validation"); 
    504504      writeLog(e); 
    505       assert false;  
    506     } 
    507   } 
    508  
    509   /** 
    510    * @testng.test dataProvider = "provider" 
    511    *              groups = "all pixels"  
     505      assert false; 
     506    } 
     507  } 
     508 
     509  /** 
     510   * @testng.test dataProvider = "provider" 
     511   *              groups = "all pixels" 
    512512   */ 
    513513  public void testPixelsHashes(String file) { 
    514514    boolean success = true; 
    515     try {  
    516       // check the MD5 of the first plane in each series  
    517   
     515    try { 
     516      // check the MD5 of the first plane in each series 
     517 
    518518      FileStitcher reader = new FileStitcher(); 
    519519      reader.setId(file); 
     
    534534      writeLog(file + " failed pixels consistency"); 
    535535      writeLog(exc); 
    536       assert false;  
    537     } 
    538     assert success;  
    539   } 
    540  
    541   /** 
    542    * @testng.test dataProvider = "provider" 
    543    *              groups = "config"  
     536      assert false; 
     537    } 
     538    assert success; 
     539  } 
     540 
     541  /** 
     542   * @testng.test dataProvider = "provider" 
     543   *              groups = "config" 
    544544   */ 
    545545  public void writeConfigFiles(String file) { 
    546     try {  
     546    try { 
    547547      FileStitcher reader = new FileStitcher(); 
    548548      reader.setId(file); 
     
    569569        line.append(" thumbx=" + reader.getThumbSizeX()); 
    570570        line.append(" thumby=" + reader.getThumbSizeY()); 
    571         line.append(" type=" +  
     571        line.append(" type=" + 
    572572          FormatTools.getPixelTypeString(reader.getPixelType())); 
    573573        line.append(" little=" + reader.isLittleEndian()); 
    574574        line.append(" md5=" + md5(reader.openBytes(0))); 
    575575        line.append("]"); 
    576      
     576 
    577577        total += reader.getImageCount(); 
    578         for (int j=1; j<reader.getImageCount(); j++) reader.openImage(j);  
    579       } 
    580       long end = System.currentTimeMillis();  
    581    
     578        for (int j=1; j<reader.getImageCount(); j++) reader.openImage(j); 
     579      } 
     580      long end = System.currentTimeMillis(); 
     581 
    582582      line.append(" access="); 
    583583      line.append((end - start) / total); 
     
    590590      w.write(line.toString()); 
    591591      w.close(); 
    592       assert true;  
     592      assert true; 
    593593    } 
    594594    catch (Exception e) { 
     
    598598        w.write("\"" + file + "\" test=false\n"); 
    599599        w.close(); 
    600         assert true;  
     600        assert true; 
    601601      } 
    602602      catch (IOException exc) { } 
     
    608608  /** Calculate the MD5 of a byte array. */ 
    609609  private static String md5(byte[] b) { 
    610     try {  
     610    try { 
    611611      MessageDigest md = MessageDigest.getInstance("MD5"); 
    612612      md.reset(); 
    613613      md.update(b); 
    614614      byte[] digest = md.digest(); 
    615       StringBuffer sb = new StringBuffer();  
     615      StringBuffer sb = new StringBuffer(); 
    616616      for (int i=0; i<digest.length; i++) { 
    617617        String a = Integer.toHexString(0xff & digest[i]); 
     
    619619        sb.append(a); 
    620620      } 
    621       return sb.toString();  
     621      return sb.toString(); 
    622622    } 
    623623    catch (Exception e) { 
    624       writeLog(e);  
    625     } 
    626     return null;  
     624      writeLog(e); 
     625    } 
     626    return null; 
    627627  } 
    628628 
     
    645645  /** Creates a new log file. */ 
    646646  private static void createLogFile() { 
    647     try {  
     647    try { 
    648648      String date = new Date().toString().replaceAll(":", "-"); 
    649649      logFile = new FileWriter("bio-formats-test-" + date + ".log"); 
     
    661661    Location f = new Location(root); 
    662662    String[] subs = f.list(); 
    663     if (subs == null) subs = new String[0];  
     663    if (subs == null) subs = new String[0]; 
    664664    Arrays.sort(subs); 
    665665 
     
    671671        subs[i] = tmp; 
    672672        break; 
    673       }  
    674     }  
    675    
     673      } 
     674    } 
     675 
    676676    if (subs == null) { 
    677677      LogTools.println("Invalid directory: " + root); 
    678678      return; 
    679679    } 
    680   
     680 
    681681    ImageReader ir = new ImageReader(); 
    682682    Vector similarFiles = new Vector(); 
     
    691691          similarFiles.add(new Location(root, matching[j]).getAbsolutePath()); 
    692692        } 
    693         continue;  
     693        continue; 
    694694      } 
    695695      Location file = new Location(subs[i]); 
     
    705705          files.add(file.getAbsolutePath()); 
    706706        } 
    707         else LogTools.println(subs[i] + " has invalid type");  
    708       } 
    709       file = null;  
    710     }   
    711   }  
     707        else LogTools.println(subs[i] + " has invalid type"); 
     708      } 
     709      file = null; 
     710    } 
     711  } 
    712712 
    713713  /** Determines if the given file is "bad" (bad files are not tested). */ 
    714714  private static boolean isBadFile(String file) { 
    715715    for (int i=0; i<configFiles.size(); i++) { 
    716       try {  
     716      try { 
    717717        String s = (String) configFiles.get(i); 
    718718        if (!config.isParsed(s)) { 
    719719          config.addFile(s); 
    720         }  
    721       }  
     720        } 
     721      } 
    722722      catch (IOException exc) { 
    723723        LogTools.trace(exc); 
    724724      } 
    725725    } 
    726     return !config.testFile(file) && !file.endsWith(".bioformats");  
     726    return !config.testFile(file) && !file.endsWith(".bioformats"); 
    727727  } 
    728728 
    729729  // -- Helper class -- 
    730   
     730 
    731731  public static class TestLogger extends Log { 
    732     private FileWriter writer;  
     732    private FileWriter writer; 
    733733 
    734734    public TestLogger(FileWriter writer) { 
    735735      this.writer = writer; 
    736736    } 
    737    
     737 
    738738    public void print(String x) { 
    739       try {  
     739      try { 
    740740        if (writer != null) writer.write(x); 
    741741      } 
Note: See TracChangeset for help on using the changeset viewer.