Changeset 6545


Ignore:
Timestamp:
06/21/10 16:47:55 (9 years ago)
Author:
curtis
Message:

For indexed color fake data, return a different LUT for each channel.

File:
1 edited

Legend:

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

    r6437 r6545  
    6767  private double scaleFactor = 1; 
    6868 
    69   /** 8-bit lookup table, if indexed color. */ 
    70   private byte[][] lut8 = null; 
    71  
    72   /** 16-bit lookup table, if indexed color. */ 
    73   private short[][] lut16 = null; 
    74  
    75   private int[] indexToValue = null, valueToIndex = null; 
     69  /** 8-bit lookup table, if indexed color, one per channel. */ 
     70  private byte[][][] lut8 = null; 
     71 
     72  /** 16-bit lookup table, if indexed color, one per channel. */ 
     73  private short[][][] lut16 = null; 
     74 
     75  /** For indexed color, mapping from indices to values and vice versa. */ 
     76  private int[][] indexToValue = null, valueToIndex = null; 
     77 
     78  /** Channel of last opened image plane. */ 
     79  private int ac = -1; 
    7680 
    7781  // -- Constructor -- 
     
    8589  @Override 
    8690  public byte[][] get8BitLookupTable() throws FormatException, IOException { 
    87     return lut8; 
     91    return ac < 0 || lut8 == null ? null : lut8[ac]; 
    8892  } 
    8993 
     
    9195  @Override 
    9296  public short[][] get16BitLookupTable() throws FormatException, IOException { 
    93     return lut16; 
     97    return ac < 0 || lut16 == null ? null : lut16[ac]; 
    9498  } 
    9599 
     
    115119    final int[] zct = getZCTCoords(no); 
    116120    final int zIndex = zct[0], cIndex = zct[1], tIndex = zct[2]; 
     121    ac = cIndex; 
    117122 
    118123    // integer types start gradient at the smallest value 
     
    157162          // if indexed color with non-null LUT, convert value to index 
    158163          if (indexed) { 
    159             if (lut8 != null) pixel = valueToIndex[(int) (pixel % 256)]; 
    160             if (lut16 != null) pixel = valueToIndex[(int) (pixel % 65536)]; 
     164            if (lut8 != null) pixel = valueToIndex[ac][(int) (pixel % 256)]; 
     165            if (lut16 != null) pixel = valueToIndex[ac][(int) (pixel % 65536)]; 
    161166          } 
    162167 
     
    337342    if (indexed) { 
    338343      if (pixelType == FormatTools.UINT8) { 
    339         // create 8-bit LUT 
     344        // create 8-bit LUTs 
    340345        final int num = 256; 
    341346        createIndexMap(num); 
    342         lut8 = new byte[lutLength][num]; 
     347        lut8 = new byte[sizeC][lutLength][num]; 
    343348        // linear ramp 
    344         for (int c=0; c<lutLength; c++) { 
    345           for (int index = 0; index < num; index++) { 
    346             lut8[c][index] = (byte) indexToValue[index]; 
     349        for (int c=0; c<sizeC; c++) { 
     350          for (int i=0; i<lutLength; i++) { 
     351            for (int index=0; index<num; index++) { 
     352              lut8[c][i][index] = (byte) indexToValue[c][index]; 
     353            } 
    347354          } 
    348355        } 
    349356      } 
    350357      else if (pixelType == FormatTools.UINT16) { 
    351         // create 16-bit LUT 
     358        // create 16-bit LUTs 
    352359        final int num = 65536; 
    353360        createIndexMap(num); 
    354         lut16 = new short[lutLength][num]; 
     361        lut16 = new short[sizeC][lutLength][num]; 
    355362        // linear ramp 
    356         for (int c=0; c<lutLength; c++) { 
    357           for (int index = 0; index < num; index++) { 
    358             lut16[c][index] = (short) indexToValue[index]; 
     363        for (int c=0; c<sizeC; c++) { 
     364          for (int i=0; i<lutLength; i++) { 
     365            for (int index=0; index<num; index++) { 
     366              lut16[c][i][index] = (short) indexToValue[c][index]; 
     367            } 
    359368          } 
    360369        } 
     
    368377  /** Creates a mapping between indices and color values. */ 
    369378  private void createIndexMap(int num) { 
     379    int sizeC = core[0].sizeC; 
     380 
    370381    // create random mapping from indices to values 
    371     indexToValue = new int[num]; 
    372     for (int index = 0; index < num; index++) indexToValue[index] = index; 
    373     shuffle(indexToValue); 
     382    indexToValue = new int[sizeC][num]; 
     383    for (int c=0; c<sizeC; c++) { 
     384      for (int index=0; index<num; index++) indexToValue[c][index] = index; 
     385      shuffle(c, indexToValue[c]); 
     386    } 
    374387 
    375388    // create inverse mapping: values to indices 
    376     valueToIndex = new int[num]; 
    377     for (int index = 0; index < num; index++) { 
    378       int value = indexToValue[index]; 
    379       valueToIndex[value] = index; 
    380     } 
    381   } 
    382  
    383   /** Fisher-Yates shuffle with constant seed to ensure reproducibility. */ 
    384   private static void shuffle(int[] array) { 
    385     Random r = new Random(SEED); 
     389    valueToIndex = new int[sizeC][num]; 
     390    for (int c=0; c<sizeC; c++) { 
     391      for (int index=0; index<num; index++) { 
     392        int value = indexToValue[c][index]; 
     393        valueToIndex[c][value] = index; 
     394      } 
     395    } 
     396  } 
     397 
     398  /** Fisher-Yates shuffle with constant seeds to ensure reproducibility. */ 
     399  private static void shuffle(int c, int[] array) { 
     400    Random r = new Random(SEED + c); 
    386401    for (int i = array.length; i > 1; i--) { 
    387402      int j = r.nextInt(i); 
Note: See TracChangeset for help on using the changeset viewer.