Changeset 6419


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

Fix bugs in FakeReader with indexed color.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/components/bio-formats/src/loci/formats/in/FakeReader.java

    r6377 r6419  
    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 
     
    261273    if (seriesCount < 1) { 
    262274      throw new FormatException("Invalid seriesCount: " + seriesCount); 
     275    } 
     276    if (lutLength < 1) { 
     277      throw new FormatException("Invalid lutLength: " + lutLength); 
    263278    } 
    264279 
     
    304319        final int num = 256; 
    305320        createIndexMap(num); 
    306         lut8 = new byte[rgb][num]; 
     321        lut8 = new byte[lutLength][num]; 
    307322        // linear ramp 
    308         for (int c=0; c<rgb; c++) { 
     323        for (int c=0; c<lutLength; c++) { 
    309324          for (int index = 0; index < num; index++) { 
    310325            lut8[c][index] = (byte) indexToValue[index]; 
     
    316331        final int num = 65536; 
    317332        createIndexMap(num); 
    318         lut16 = new short[rgb][num]; 
     333        lut16 = new short[lutLength][num]; 
    319334        // linear ramp 
    320         for (int c=0; c<rgb; c++) { 
     335        for (int c=0; c<lutLength; c++) { 
    321336          for (int index = 0; index < num; index++) { 
    322337            lut16[c][index] = (short) indexToValue[index]; 
     
    330345  // -- Helper methods -- 
    331346 
    332   /** Creates an index map from 0 */ 
     347  /** Creates a mapping between indices and color values. */ 
    333348  private void createIndexMap(int num) { 
    334349    // create random mapping from indices to values 
Note: See TracChangeset for help on using the changeset viewer.