Changeset 6420


Ignore:
Timestamp:
05/28/10 15:24:07 (9 years ago)
Author:
curtis
Message:

Merge ChannelFiller and FakeReader bugfixes to 4.2.

Location:
branches/4.2/components/bio-formats/src/loci/formats
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/4.2/components/bio-formats/src/loci/formats/ChannelFiller.java

    r6155 r6420  
    2929 
    3030/** 
    31  * Expands indexed color images to RGB. 
     31 * For indexed color data representing true color, factors out 
     32 * the indices, replacing them with the color table values directly. 
     33 *  
     34 * For all other data (either non-indexed, or indexed with 
     35 * "false color" tables), does nothing. 
    3236 * 
    3337 * <dl><dt><b>Source code:</b></dt> 
     
    3640 */ 
    3741public class ChannelFiller extends ReaderWrapper { 
    38  
     42   
    3943  // -- Utility methods -- 
    4044 
     
    5559  // -- IFormatReader API methods -- 
    5660 
     61  @Override 
     62  public int getSizeC() { 
     63    if (passthrough()) return reader.getSizeC(); 
     64    return reader.getSizeC() * getLookupTableComponentCount(); 
     65  } 
     66 
     67  /* @see IFormatReader#isRGB() */ 
     68  @Override 
     69  public boolean isRGB() { 
     70    if (passthrough()) return reader.isRGB(); 
     71    return false; 
     72  } 
     73 
    5774  /* @see IFormatReader#isIndexed() */ 
     75  @Override 
    5876  public boolean isIndexed() { 
     77    if (passthrough()) return reader.isIndexed(); 
    5978    return false; 
    6079  } 
    6180 
    62   /* @see IFormatReader#getSizeC() */ 
    63   public int getSizeC() { 
    64     return reader.getSizeC() * 
    65       ((reader.isIndexed() && !reader.isFalseColor()) ? 3 : 1); 
    66   } 
    67  
    6881  /* @see IFormatReader#getRGBChannelCount() */ 
     82  @Override 
    6983  public int getRGBChannelCount() { 
    70     return (reader.isIndexed() && !reader.isFalseColor()) ? 3 : 
    71       reader.getRGBChannelCount(); 
    72   } 
    73  
    74   /* @see IFormatReader#isRGB() */ 
    75   public boolean isRGB() { 
    76     return (reader.isIndexed() && !reader.isFalseColor()) || reader.isRGB(); 
     84    if (passthrough()) return reader.getRGBChannelCount(); 
     85    return reader.getRGBChannelCount() * getLookupTableComponentCount(); 
    7786  } 
    7887 
    7988  /* @see IFormatReader#get8BitLookupTable() */ 
    80   public byte[][] get8BitLookupTable() { 
    81     try { 
    82       return reader.isFalseColor() ? reader.get8BitLookupTable() : null; 
    83     } 
    84     catch (FormatException e) { } 
    85     catch (IOException e) { } 
     89  @Override 
     90  public byte[][] get8BitLookupTable() throws FormatException, IOException { 
     91    if (passthrough()) return reader.get8BitLookupTable(); 
    8692    return null; 
    8793  } 
    8894 
    8995  /* @see IFormatReader#get16BitLookupTable() */ 
    90   public short[][] get16BitLookupTable() { 
    91     try { 
    92       return reader.isFalseColor() ? reader.get16BitLookupTable() : null; 
    93     } 
    94     catch (FormatException e) { } 
    95     catch (IOException e) { } 
     96  @Override 
     97  public short[][] get16BitLookupTable() throws FormatException, IOException { 
     98    if (passthrough()) return reader.get16BitLookupTable(); 
    9699    return null; 
    97100  } 
    98101 
    99102  /* @see IFormatReader#openBytes(int) */ 
     103  @Override 
    100104  public byte[] openBytes(int no) throws FormatException, IOException { 
    101105    return openBytes(no, 0, 0, getSizeX(), getSizeY()); 
     
    103107 
    104108  /* @see IFormatReader#openBytes(int, byte[]) */ 
     109  @Override 
    105110  public byte[] openBytes(int no, byte[] buf) 
    106111    throws FormatException, IOException 
     
    110115 
    111116  /* @see IFormatReader#openBytes(int, int, int, int, int) */ 
     117  @Override 
    112118  public byte[] openBytes(int no, int x, int y, int w, int h) 
    113119    throws FormatException, IOException 
     
    119125 
    120126  /* @see IFormatReader#openBytes(int, byte[], int, int, int, int) */ 
     127  @Override 
    121128  public byte[] openBytes(int no, byte[] buf, int x, int y, int w, int h) 
    122129    throws FormatException, IOException 
    123130  { 
    124     if (reader.isIndexed() && !reader.isFalseColor()) { 
    125       byte[] pix = reader.openBytes(no, x, y, w, h); 
    126       if (getPixelType() == FormatTools.UINT8) { 
    127         byte[][] b = ImageTools.indexedToRGB(reader.get8BitLookupTable(), pix); 
    128         if (isInterleaved()) { 
    129           int pt = 0; 
    130           for (int i=0; i<b[0].length; i++) { 
    131             for (int j=0; j<b.length; j++) { 
    132               buf[pt++] = b[j][i]; 
    133             } 
    134           } 
    135         } 
    136         else { 
    137           for (int i=0; i<b.length; i++) { 
    138             System.arraycopy(b[i], 0, buf, i*b[i].length, b[i].length); 
    139           } 
    140         } 
    141         return buf; 
    142       } 
    143       short[][] s = ImageTools.indexedToRGB(reader.get16BitLookupTable(), 
    144         pix, isLittleEndian()); 
    145  
     131    if (passthrough()) return reader.openBytes(no, buf, x, y, w, h); 
     132 
     133    byte[] pix = reader.openBytes(no, x, y, w, h); 
     134    if (getPixelType() == FormatTools.UINT8) { 
     135      byte[][] b = ImageTools.indexedToRGB(reader.get8BitLookupTable(), pix); 
    146136      if (isInterleaved()) { 
    147137        int pt = 0; 
    148         for (int i=0; i<s[0].length; i++) { 
    149           for (int j=0; j<s.length; j++) { 
    150             buf[pt++] = (byte) (isLittleEndian() ? 
    151               (s[j][i] & 0xff) : (s[j][i] >> 8)); 
    152             buf[pt++] = (byte) (isLittleEndian() ? 
    153               (s[j][i] >> 8) : (s[j][i] & 0xff)); 
     138        for (int i=0; i<b[0].length; i++) { 
     139          for (int j=0; j<b.length; j++) { 
     140            buf[pt++] = b[j][i]; 
    154141          } 
    155142        } 
    156143      } 
    157144      else { 
    158         int pt = 0; 
    159         for (int i=0; i<s.length; i++) { 
    160           for (int j=0; j<s[i].length; j++) { 
    161             buf[pt++] = (byte) (isLittleEndian() ? 
    162               (s[i][j] & 0xff) : (s[i][j] >> 8)); 
    163             buf[pt++] = (byte) (isLittleEndian() ? 
    164               (s[i][j] >> 8) : (s[i][j] & 0xff)); 
    165           } 
     145        for (int i=0; i<b.length; i++) { 
     146          System.arraycopy(b[i], 0, buf, i*b[i].length, b[i].length); 
    166147        } 
    167148      } 
    168149      return buf; 
    169150    } 
    170     return reader.openBytes(no, buf, x, y, w, h); 
     151    short[][] s = ImageTools.indexedToRGB(reader.get16BitLookupTable(), 
     152      pix, isLittleEndian()); 
     153 
     154    if (isInterleaved()) { 
     155      int pt = 0; 
     156      for (int i=0; i<s[0].length; i++) { 
     157        for (int j=0; j<s.length; j++) { 
     158          buf[pt++] = (byte) (isLittleEndian() ? 
     159            (s[j][i] & 0xff) : (s[j][i] >> 8)); 
     160          buf[pt++] = (byte) (isLittleEndian() ? 
     161            (s[j][i] >> 8) : (s[j][i] & 0xff)); 
     162        } 
     163      } 
     164    } 
     165    else { 
     166      int pt = 0; 
     167      for (int i=0; i<s.length; i++) { 
     168        for (int j=0; j<s[i].length; j++) { 
     169          buf[pt++] = (byte) (isLittleEndian() ? 
     170            (s[i][j] & 0xff) : (s[i][j] >> 8)); 
     171          buf[pt++] = (byte) (isLittleEndian() ? 
     172            (s[i][j] >> 8) : (s[i][j] & 0xff)); 
     173        } 
     174      } 
     175    } 
     176    return buf; 
    171177  } 
    172178 
     
    174180 
    175181  /* @see IFormatHandler#setId(String) */ 
     182  @Override 
    176183  public void setId(String id) throws FormatException, IOException { 
    177184    super.setId(id); 
     
    179186    MetadataTools.populatePixels(store, this, false, false); 
    180187  } 
     188   
     189  // -- Helper methods -- 
     190 
     191  /** Whether to hand off all method calls directly to the wrapped reader. */ 
     192  private boolean passthrough() { 
     193    return !reader.isIndexed() || reader.isFalseColor(); 
     194  } 
     195   
     196  /** Gets the number of color components in the lookup table. */ 
     197  private int getLookupTableComponentCount() { 
     198    try { 
     199      byte[][] lut8 = reader.get8BitLookupTable(); 
     200      if (lut8 != null) return lut8.length; 
     201      short[][] lut16 = reader.get16BitLookupTable(); 
     202      if (lut16 != null) return lut16.length; 
     203    } 
     204    catch (FormatException exc) { } 
     205    catch (IOException exc) { } 
     206    return 3; 
     207  } 
    181208 
    182209} 
  • branches/4.2/components/bio-formats/src/loci/formats/in/FakeReader.java

    r6376 r6420  
    100100    FormatTools.checkPlaneParameters(this, no, buf.length, x, y, w, h); 
    101101 
    102     int series = getSeries(); 
    103     int pixelType = getPixelType(); 
    104     int bpp = FormatTools.getBytesPerPixel(pixelType); 
    105     boolean signed = FormatTools.isSigned(pixelType); 
    106     boolean floating = FormatTools.isFloatingPoint(pixelType); 
    107     boolean little = isLittleEndian(); 
    108     boolean indexed = isIndexed(); 
    109  
    110     int[] zct = getZCTCoords(no); 
    111     int zIndex = zct[0], cIndex = zct[1], tIndex = zct[2]; 
     102    final int series = getSeries(); 
     103    final int pixelType = getPixelType(); 
     104    final int bpp = FormatTools.getBytesPerPixel(pixelType); 
     105    final boolean signed = FormatTools.isSigned(pixelType); 
     106    final boolean floating = FormatTools.isFloatingPoint(pixelType); 
     107    final int rgb = getRGBChannelCount(); 
     108    final boolean indexed = isIndexed(); 
     109    final boolean little = isLittleEndian(); 
     110    final boolean interleaved = isInterleaved(); 
     111 
     112    final int[] zct = getZCTCoords(no); 
     113    final int zIndex = zct[0], cIndex = zct[1], tIndex = zct[2]; 
    112114 
    113115    // integer types start gradient at the smallest value 
     
    115117    if (floating) min = 0; // floating point types always start at 0 
    116118 
    117     for (int row=0; row<h; row++) { 
    118       int yy = y + row; 
    119       for (int col=0; col<w; col++) { 
    120         int index = bpp * (w * row + col); 
    121         int xx = x + col; 
    122  
    123         // encode various information into the image plane 
    124         long pixel = min + xx; 
    125         if (yy < BOX_SIZE) { 
    126           int grid = xx / BOX_SIZE; 
    127           switch (grid) { 
    128             case 0: 
    129               pixel = series; 
     119    for (int cOffset=0; cOffset<rgb; cOffset++) { 
     120      int channel = cIndex + cOffset; 
     121      for (int row=0; row<h; row++) { 
     122        int yy = y + row; 
     123        for (int col=0; col<w; col++) { 
     124          int xx = x + col; 
     125   
     126          // encode various information into the image plane 
     127          long pixel = min + xx; 
     128          if (yy < BOX_SIZE) { 
     129            int grid = xx / BOX_SIZE; 
     130            switch (grid) { 
     131              case 0: 
     132                pixel = series; 
     133                break; 
     134              case 1: 
     135                pixel = no; 
     136                break; 
     137              case 2: 
     138                pixel = zIndex; 
     139                break; 
     140              case 3: 
     141                pixel = channel; 
     142                break; 
     143              case 4: 
     144                pixel = tIndex; 
     145                break; 
     146            } 
     147          } 
     148   
     149          // if indexed color with non-null LUT, convert value to index 
     150          if (indexed) { 
     151            if (lut8 != null) pixel = valueToIndex[(int) (pixel % 256)]; 
     152            if (lut16 != null) pixel = valueToIndex[(int) (pixel % 65536)]; 
     153          } 
     154   
     155          // if floating point, convert value to raw IEEE floating point bits 
     156          switch (pixelType) { 
     157            case FormatTools.FLOAT: 
     158              pixel = Float.floatToIntBits(pixel); 
    130159              break; 
    131             case 1: 
    132               pixel = no; 
     160            case FormatTools.DOUBLE: 
     161              pixel = Double.doubleToLongBits(pixel); 
    133162              break; 
    134             case 2: 
    135               pixel = zIndex; 
    136               break; 
    137             case 3: 
    138               pixel = cIndex; 
    139               break; 
    140             case 4: 
    141               pixel = tIndex; 
    142               break; 
    143           } 
     163          } 
     164 
     165          // unpack pixel into byte buffer 
     166          int index; 
     167          if (interleaved) index = w * rgb * row + rgb * col + cOffset; // CXY 
     168          else index = h * w * cOffset + w * row + col; // XYC 
     169          index *= bpp; 
     170          DataTools.unpackBytes(pixel, buf, index, bpp, little); 
    144171        } 
    145  
    146         // if indexed color with non-null LUT, convert value to index 
    147         if (indexed) { 
    148           if (lut8 != null) pixel = valueToIndex[(int) (pixel % 256)]; 
    149           if (lut16 != null) pixel = valueToIndex[(int) (pixel % 65536)]; 
    150         } 
    151  
    152         // if floating point, convert value to raw IEEE floating point bits 
    153         switch (pixelType) { 
    154           case FormatTools.FLOAT: 
    155             pixel = Float.floatToIntBits(pixel); 
    156             break; 
    157           case FormatTools.DOUBLE: 
    158             pixel = Double.doubleToLongBits(pixel); 
    159             break; 
    160         } 
    161         DataTools.unpackBytes(pixel, buf, index, bpp, little); 
    162172      } 
    163173    } 
     
    196206 
    197207    int seriesCount = 1; 
     208    int lutLength = 3; 
    198209 
    199210    // parse tokens from filename 
     
    237248      else if (key.equals("thumbnail")) thumbnail = bool; 
    238249      else if (key.equals("series")) seriesCount = num; 
     250      else if (key.equals("lutLength")) lutLength = num; 
    239251    } 
    240252 
     
    255267        sizeC + "/" + rgb); 
    256268    } 
    257  
    258269    getDimensionOrder(dimOrder); 
    259270    if (falseColor && !indexed) { 
     
    262273    if (seriesCount < 1) { 
    263274      throw new FormatException("Invalid seriesCount: " + seriesCount); 
     275    } 
     276    if (lutLength < 1) { 
     277      throw new FormatException("Invalid lutLength: " + lutLength); 
    264278    } 
    265279 
     
    305319        final int num = 256; 
    306320        createIndexMap(num); 
    307         lut8 = new byte[rgb][num]; 
     321        lut8 = new byte[lutLength][num]; 
    308322        // linear ramp 
    309         for (int c=0; c<rgb; c++) { 
     323        for (int c=0; c<lutLength; c++) { 
    310324          for (int index = 0; index < num; index++) { 
    311325            lut8[c][index] = (byte) indexToValue[index]; 
     
    317331        final int num = 65536; 
    318332        createIndexMap(num); 
    319         lut16 = new short[rgb][num]; 
     333        lut16 = new short[lutLength][num]; 
    320334        // linear ramp 
    321         for (int c=0; c<rgb; c++) { 
     335        for (int c=0; c<lutLength; c++) { 
    322336          for (int index = 0; index < num; index++) { 
    323337            lut16[c][index] = (short) indexToValue[index]; 
     
    331345  // -- Helper methods -- 
    332346 
    333   /** Creates an index map from 0 */ 
     347  /** Creates a mapping between indices and color values. */ 
    334348  private void createIndexMap(int num) { 
    335349    // create random mapping from indices to values 
Note: See TracChangeset for help on using the changeset viewer.