package de.desy.acop.video.displayer;
   
   import java.util.Arrays;
   
   /**
    * <code>ColorLookup</code> creates, prepares and maintains a false color table
    * necessary to decode pure grayscale image data to true color display. Three
    * false color tables (mappings) are supported at the moment:
    * <ul>
   * <li>PITZ false color (was invented at PITZ Video System v2, Velizar Miltchev)
   * <li>MATLAB jet false color (taken from Matlab)
   * <li>GRAYSCALE simple grayscale conversion
   * </ul>
   * 
   * An important criteria to mention is that these mappings support scaling to
   * physical and effective bits per pixel settings. For example if source
   * grayscale data is 16bpp physically encoded (for performance reason) but only
   * 12 of these bits are effectively used, the false color table is designed to
   * support 0 as darkest and 4195 (12 bit max) as brightest value. All other
   * value (for 16 bit: 4096 to 65535) are encoded in magenta to easily detect
   * them as being illegal. In comparison to that, the output format is always
   * java TYPE_INT_ARGB for sake of simplicity.<br>
   * The main use is to generate a 1-dimensional false-color-mapping table that
   * accepts as index any physically valid grayscale number and returns the
   * matched pixel ready for being placed to the output drawing buffer.
   * 
   * @author sweisse, mdavid
   * @deprecated replaced by LookUpTable
   */
  
  public final class ColorLookupTable {
  
  	/**
  	 * current color map
  	 */
  	private ColorMap colorMap;
  
  	/**
  	 * physical bytes per pixel inside
  	 */
  	private int bytesPerPixel;
  
  	/**
  	 * effective bits per pixel inside
  	 */
  	private int effBitsPerPixel;
  
  	/**
  	 * array for false color mapping table
  	 */
  	private int[] rgbs;
  
  	/**
  	 * Constructs a false color lookup table
  	 * 
  	 * @param colorMap
  	 *            color map (allowed values are ColorMap.GRAYSCALE,
  	 *            ColorMap.PITZ, ColorMap.JET)
  	 * @param bytesPerPixel
  	 *            physical bytes per pixel (allowed values are 1, 2, 3)
  	 * @param effBitsPerPixel
  	 *            effective bits per pixel (effective bits must fit inside
  	 *            physical bits per pixel)
  	 * 
  	 * @see ColorMap
  	 */
  	public ColorLookupTable(ColorMap colorMap, int bytesPerPixel, int effBitsPerPixel) {
  		if (colorMap == null)
  			throw new NullPointerException("colorMap == null!");
  
  		if (bytesPerPixel < 1 || bytesPerPixel > 3)
  			throw new IllegalArgumentException("bytesPerPixel = " + bytesPerPixel);
  
  		if (effBitsPerPixel < 1 || effBitsPerPixel > (bytesPerPixel * 8))
  			throw new IllegalArgumentException("effBitsPerPixel = " + effBitsPerPixel);
  
  		this.colorMap = colorMap;
  		this.bytesPerPixel = bytesPerPixel;
  		this.effBitsPerPixel = effBitsPerPixel;
  
  		createLUT();
  	}
  
  	/**
  	 * Returns the lookup table data by reference.
  	 * 
  	 * @return the data array of this <code>ColorLookup</code>.
  	 */
  	public int[] getRGB() {
  		return rgbs;
  	}
  
  	/**
  	 * @return physical bytes per pixel
  	 */
  	public int getBytesPerPixel() {
  		return bytesPerPixel;
  	}
  
 	/**
 	 * @return effective bits per Pixel
 	 */
 	public int getEffBitsPerPixel() {
 		return effBitsPerPixel;
 	}
 
 	/**
 	 * Fills false color table (Alpha:24 Red:16 Green:8 Blue:0).
 	 */
 	private void createLUT() {
 		rgbs = new int[1 << (bytesPerPixel * 8)];
 
 		switch (colorMap) {
 		case PITZ:
 			fillPITZ();
 			break;
 
 		case JET:
 			fillJET();
 			break;
 
 		case GRAYSCALE:
 			fillGrayscale();
 			break;
 
 		default:
 			throw new AssertionError("Unsupportted color map: " + colorMap);
 		}
 
 		/*
 		 * Fills left colors (if effective bpp < physical bpp) with Magenta
 		 * (0xffff00ff) for spotting of illegal values
 		 */
 		Arrays.fill(rgbs, 1 << effBitsPerPixel, rgbs.length, 0xffff00ff);
 	}
 
 	/**
 	 * Fills the lookup table using PITZ false colors based on current private
 	 * class variables
 	 */
 	private void fillPITZ() {
 		int dec = 1 << effBitsPerPixel;
 
 		// black 0-0-0
 		rgbs[0] = 0xff000000;
 
 		// white 255-255-255
 		rgbs[dec - 1] = 0xffffffff;
 
 		int step1 = (dec / 3) + 1;
 		int step2 = (dec * 293 / 500) + 1;
 		int step3 = (dec * 2 / 3) + 1;
 		int step4 = dec - 1;
 
 		int i = 1;
 		for (; i < step1; i++)
 			rgbs[i] = 0xff000000 | ((int) ((-0.5608 / (dec / 3 - 1.0) * (i - 1) + 1.0) * 255.0) & 0xff);
 
 		for (; i < step2; i++) {
 			double m1 = 0.561 / ((dec * 293 / 500) - (dec / 3));
 			double n1 = 0.263 - (m1 * (dec / 3));
 			double m2 = -0.4314 / ((dec * 293 / 500) - (dec / 3));
 			double n2 = 0 - (m2 * (dec * 293 / 500));
 			rgbs[i] = 0xff000000 | (((int) ((m1 * i + n1) * 255d) & 0xff) << 8) | ((int) ((m2 * i + n2) * 255d) & 0xff);
 		}
 
 		for (; i < step3; i++) {
 			double m1 = 0.176 / ((dec * 2 / 3) - (dec * 293 / 500));
 			double n1 = 1 - (m1 * (dec * 2 / 3));
 			rgbs[i] = 0xff000000 | (((int) ((m1 * i + n1) * 255.0) & 0xff) << 8);
 		}
 
 		for (; i < step4; i++) {
 			double m1 = 0.737 / (dec - (dec * 2 / 3));
 			double n1 = 1 - (m1 * dec);
 			rgbs[i] = 0xff000000 | (((int) ((m1 * i + n1) * 255.0) & 0xff) << 16);
 		}
 	}
 
 	/**
 	 * Fills the lookup table using MATLAB Jet false colors based on current
 	 * private class variables
 	 */
 	private void fillJET() {
 		int dec = 1 << effBitsPerPixel;
 
 		int step1 = dec / 8;
 		int step2 = dec * 3 / 8;
 		int step3 = dec * 5 / 8;
 		int step4 = dec * 7 / 8 + 1;
 		int step5 = dec - 1;
 
 		// white 255-255-255
 		rgbs[dec - 1] = 0xffffffff;
 
 		int i = 0;
 
 		// blue
 		for (; i < step1; i++) {
 			rgbs[i] = 0xff000000 | ((int) ((i / (step1 * 2.0) + 0.5) * 255.0) & 0xff);
 		}
 
 		// green
 		for (; i < step2; i++) {
 			rgbs[i] = 0xff000000 | (((int) ((i / (step1 * 2.0) - 0.5) * 255.0) & 0xff) << 8) | 0xff;
 		}
 
 		for (; i < step3; i++) {
 			double red = (i / (step1 * 2.0) - 1.5) * 255.0;
 			double blue = (1.0 - (i / (step1 * 2.0) - 1.5)) * 255.0;
 			rgbs[i] = 0xff000000 | (((int) red & 0xff) << 16) | 0xff00 | ((int) blue & 0xff);
 		}
 
 		// green
 		for (; i < step4; i++) {
 			rgbs[i] = 0xff000000 | 0xff0000 | (((int) ((i / (-step1 * 2.0) + 3.5) * 255.0) & 0xff) << 8);
 		}
 
 		// red
 		for (; i < step5; i++) {
 			rgbs[i] = 0xff000000 | (((int) ((i / (-step1 * 2.0) + 4.5) * 255.0) & 0xff) << 16);
 		}
 	}
 
 	/**
 	 * Fills the lookup table using grayscale based on current private class
 	 * variables
 	 */
 	private void fillGrayscale() {
 		int dec = 1 << effBitsPerPixel;
 		int gray;
 		for (int i = 0; i < dec; i++) {
 			gray = 255 * i / (dec - 1);
 			rgbs[i] = 0xff000000 | ((gray & 0xff) << 16) | ((gray & 0xff) << 8) | (gray & 0xff); // argb
 		}
 	}
 
 	@Override
 	public String toString() {
 		StringBuilder sb = new StringBuilder();
 		sb.append("colorMap = ").append(colorMap);
 		sb.append(", bytesPerPixel = ").append(bytesPerPixel);
 		sb.append(", effBitsPerPixel = ").append(effBitsPerPixel);
 		sb.append(", rgbs.length = ").append(rgbs.length);
 		return sb.toString();
 	}
 }