package de.desy.acop.video.displayer;
   
   import java.awt.image.IndexColorModel;
   import java.util.HashMap;
   import java.util.Map;
   
   /**
    * Color map enumeration. Using a memorization "cache", which stores previously
    * computed lookup tables.
   * 
   * @author mdavid, sweisse
   */
  public enum ColorMap {
  
  	NONE {
  		@Override
  		public IndexColorModel createLUT(int bits) {
  			throw new AssertionError("Color lookup table can not be created, colorMap = " + this);
  		}
  
  		@Override
  		public IndexColorModel getLUT(int bits) {
  			throw new AssertionError("Color lookup table can not be obtained, colorMap = " + this);
  		}
  	},
  
  	/**
  	 * grayscale mode
  	 */
  	GRAYSCALE {
  		private Map<Integer, IndexColorModel> cache = new HashMap<Integer, IndexColorModel>();
  
  		@Override
  		public IndexColorModel createLUT(int bits) {
  			int size = 1 << bits;
  			byte cmap[] = new byte[size];
  			for (int i = 0; i < size; i++)
  				cmap[i] = (byte) (255 * i / (size - 1) & 0xff);
  			return new IndexColorModel(bits, size, cmap, cmap, cmap);
  		}
  
  		@Override
  		public IndexColorModel getLUT(int bits) {
  			IndexColorModel cm = cache.get(bits);
  			if (cm == null)
  				cache.put(bits, cm = createLUT(bits));
  			return cm;
  		}
  	},
  
  	/**
  	 * PITZ false color mode
  	 */
  	PITZ {
  		private Map<Integer, IndexColorModel> cache = new HashMap<Integer, IndexColorModel>();
  
  		@Override
  		public IndexColorModel createLUT(int bits) {
  			int size = 1 << bits;
  
  			byte[] reds = new byte[size];
  			byte[] greens = new byte[size];
  			byte[] blues = new byte[size];
  
  			int i = size - 1;
  
  			// white 255-255-255
  			reds[i] = greens[i] = blues[i] = (byte) 0xff;
  
  			int step1 = (size / 3) + 1;
  			int step2 = (size * 293 / 500) + 1;
  			int step3 = (size * 2 / 3) + 1;
  			int step4 = size - 1;
  
  			for (i = 1; i < step1; i++)
  				blues[i] = (byte) ((int) ((-0.5608 / (size / 3 - 1.0) * (i - 1) + 1.0) * 255.0) & 0xff);
  
  			for (; i < step2; i++) {
  				double m1 = 0.561 / ((size * 293 / 500) - (size / 3));
  				double n1 = 0.263 - (m1 * (size / 3));
  				double m2 = -0.4314 / ((size * 293 / 500) - (size / 3));
  				double n2 = 0 - (m2 * (size * 293 / 500));
  				greens[i] = (byte) ((int) ((m1 * i + n1) * 255d) & 0xff);
  				blues[i] = (byte) ((int) ((m2 * i + n2) * 255d) & 0xff);
  			}
  
  			// green
  			for (; i < step3; i++) {
  				double m1 = 0.176 / ((size * 2 / 3) - (size * 293 / 500));
  				double n1 = 1 - (m1 * (size * 2 / 3));
  				greens[i] = (byte) ((int) ((m1 * i + n1) * 255.0) & 0xff);
  			}
  
  			// red
  			for (; i < step4; i++) {
  				double m1 = 0.737 / (size - (size * 2 / 3));
  				reds[i] = (byte) ((int) ((m1 * (i - size) + 1) * 255.0) & 0xff);
  			}
  
 			return new IndexColorModel(bits, size, reds, greens, blues);
 		}
 
 		@Override
 		public IndexColorModel getLUT(int bits) {
 			IndexColorModel cm = cache.get(bits);
 			if (cm == null)
 				cache.put(bits, cm = createLUT(bits));
 			return cm;
 		}
 	},
 
 	/**
 	 * MATLAB JET false color mode
 	 */
 	JET {
 		private Map<Integer, IndexColorModel> cache = new HashMap<Integer, IndexColorModel>();
 
 		@Override
 		public IndexColorModel createLUT(int bits) {
 			int size = 1 << bits;
 
 			byte[] reds = new byte[size];
 			byte[] greens = new byte[size];
 			byte[] blues = new byte[size];
 
 			int step1 = size / 8;
 			int step2 = size * 3 / 8;
 			int step3 = size * 5 / 8;
 			int step4 = size * 7 / 8 + 1;
 			int step5 = size - 1;
 
 			int i = size - 1;
 
 			// white 255-255-255
 			reds[i] = greens[i] = blues[i] = (byte) 0xff;
 
 			// blue
 			for (i = 0; i < step1; i++)
 				blues[i] = (byte) ((int) ((i / (step1 * 2.0) + 0.5) * 255.0) & 0xff);
 
 			// green
 			for (; i < step2; i++) {
 				greens[i] = (byte) ((int) ((i / (step1 * 2.0) - 0.5) * 255.0) & 0xff);
 				blues[i] = (byte) 0xff;
 			}
 
 			for (; i < step3; i++) {
 				reds[i] = (byte) ((int) ((i / (step1 * 2.0) - 1.5) * 255.0) & 0xff);
 				greens[i] = (byte) 0xff;
 				blues[i] = (byte) ((int) ((1.0 - (i / (step1 * 2.0) - 1.5)) * 255.0) & 0xff);
 			}
 
 			// green
 			for (; i < step4; i++) {
 				reds[i] = (byte) 0xff;
 				greens[i] = (byte) ((int) ((i / (-step1 * 2.0) + 3.5) * 255.0) & 0xff);
 			}
 
 			// red
 			for (; i < step5; i++)
 				reds[i] = (byte) ((int) ((i / (-step1 * 2.0) + 4.5) * 255.0) & 0xff);
 
 			return new IndexColorModel(bits, size, reds, greens, blues);
 		}
 
 		@Override
 		public IndexColorModel getLUT(int bits) {
 			IndexColorModel cm = cache.get(bits);
 			if (cm == null)
 				cache.put(bits, cm = createLUT(bits));
 			return cm;
 		}
 	};
 
 	/**
 	 * Creates an indexed color model.<br>
 	 * Abstract method, have to be implemented for all enumerated values
 	 * 
 	 * @param bits
 	 *            - the number of bits each pixel occupies
 	 * @return indexed color model representation of the lookup table
 	 * @throws IllegalArgumentException
 	 *             - if bits is less than 1 or greater than 16
 	 */
 	public abstract IndexColorModel createLUT(int bits);
 
 	/**
 	 * Returns indexed color model using caching.<br>
 	 * Abstract method, have to be implemented for all enumerated values
 	 * 
 	 * @param bits
 	 *            - bits per pixel
 	 * @return indexed color model representation of the lookup table
 	 */
 	public abstract IndexColorModel getLUT(int bits);
 
 }