package de.desy.acop.video.timageio;
   
   import java.awt.Graphics2D;
   import java.awt.Transparency;
   import java.awt.color.ColorSpace;
   import java.awt.image.BufferedImage;
   import java.awt.image.ColorModel;
   import java.awt.image.ComponentColorModel;
   import java.awt.image.DataBuffer;
  import java.awt.image.DataBufferByte;
  import java.awt.image.DataBufferInt;
  import java.awt.image.DataBufferUShort;
  import java.awt.image.DirectColorModel;
  import java.awt.image.Raster;
  import java.awt.image.SampleModel;
  import java.awt.image.WritableRaster;
  import java.io.ByteArrayInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.Arrays;
  import java.util.Hashtable;
  
  import de.desy.acop.video.displayer.ColorMap;
  import de.desy.acop.video.displayer.HuffmanDecompression;
  import de.desy.acop.video.displayer.ImageFormat;
  import de.desy.tine.types.IMAGE;
  import de.desy.tine.types.IMAGE.FrameHeader;
  
  /**
   * The <code>TBufferedImage</code> comprised of a {@link TImageMetadata} of
   * image metadata and a {@link BufferedImage} of image data.
   * 
   * @author David Melkumyan, DESY Zeuthen
   */
  public class TBufferedImage {
  
  	/**
  	 * Java <code>BufferedImage</code> with an accessible buffer of image data.
  	 */
  	private BufferedImage bufferedImage;
  
  	/**
  	 * Image metadata (non-image data) associated with TINE images.
  	 */
  	private TImageMetadata tiMetadata;
  
  	/**
  	 * Constructs a <code>TBufferedImage</code> from <code>BufferedImage</code>
  	 * and <code>TImageMetadata</code>.
  	 * 
  	 * @note only for internal use
  	 * 
  	 * @param bufferedImage
  	 *            - Java <code>BufferedImage</code>
  	 * @param tiMetadata
  	 *            - <code>TImageMetadata</code>
  	 * 
  	 * @see TImageMetadata
  	 */
  	public TBufferedImage(BufferedImage bufferedImage, TImageMetadata tiMetadata) {
  		if (bufferedImage == null)
  			throw new NullPointerException("bufferedImage == null!");
  		this.bufferedImage = bufferedImage;
  		this.tiMetadata = tiMetadata;
  	}
  
  	/**
  	 * Creates <code>TBufferedImage</code> instance from Tine IMAGE (in
  	 * 'archival' mode).
  	 * 
  	 * @param ti
  	 *            - TINE Image
  	 */
  	public TBufferedImage(IMAGE ti) {
  		this(TBufferedImage.toBufferedImage(ti), new TImageMetadata(ti));
  	}
  
  	/**
  	 * Creates <code>TBufferedImage</code> instance from Tine IMAGE (in
  	 * 'archival' mode).
  	 * 
  	 * @param ti
  	 *            - TINE Image
  	 */
  	public TBufferedImage(IMAGE ti, ColorMap colorMap, boolean normalize, boolean aoiExpansion) {
  		this(TBufferedImage.toBufferedImage(ti, colorMap, normalize, aoiExpansion), new TImageMetadata(ti));
  	}
  
  	/**
  	 * Returns Java BufferedImage with an accessible buffer of image data
  	 * 
  	 * @return BufferedImage
  	 */
  	public BufferedImage getBufferedImage() {
  		return bufferedImage;
  	}
  
  	public void setBufferedImage(BufferedImage image) {
  		this.bufferedImage = image;
 	}
 
 	/**
 	 * Returns image metadata (non-image data) associated with TINE images.
 	 * 
 	 * @return TImageMetadata
 	 */
 	public TImageMetadata getMetadata() {
 		return tiMetadata;
 	}
 
 	/**
 	 * Sets the TINE image metadata
 	 * 
 	 * @param metadata
 	 *            - TINE image metadata
 	 */
 	public void setMetadata(TImageMetadata metadata) {
 		this.tiMetadata = metadata;
 	}
 
 	/**
 	 * Creates <code>BufferedImage</code> from Tine IMAGE in 'archival' mode.
 	 * 
 	 * @param ti
 	 *            - input Tine IMAGE
 	 * @return Java Buffered Image
 	 */
 	public static BufferedImage toBufferedImage(IMAGE ti) {
 		return toBufferedImage(ti, null, false, false);
 	}
 
 	/**
 	 * Creates <code>BufferedImage</code> from Tine IMAGE in 'archival'/'export'
 	 * mode.
 	 * 
 	 * @param ti
 	 *            - input Tine IMAGE
 	 * 
 	 * @param colorMap
 	 *            - apply color map
 	 * @param normalize
 	 *            - apply the histogram equalization will be applied
 	 * @param aoiExpansion
 	 *            - apply the AOI expansion
 	 * 
 	 * @return Java Buffered Image
 	 */
 	public static BufferedImage toBufferedImage(IMAGE ti, ColorMap colorMap, boolean normalize, boolean aoiExpansion) {
 		return toBufferedImage(ti, colorMap, normalize, -1, -1, aoiExpansion);
 	}
 
 	public static BufferedImage toBufferedImage(IMAGE ti, ColorMap colorMap, boolean normalize, int min, int max,
 			boolean aoiExpansion) {
 		if (ti == null)
 			throw new NullPointerException("ti == null!");
 
 		BufferedImage destImage = null;
 
 		final FrameHeader frmHdr = ti.getFrameHeader();
 		if ((frmHdr.aoiWidth == -1 && frmHdr.aoiHeight != -1) || (frmHdr.aoiWidth != -1 && frmHdr.aoiHeight == -1))
 			throw new IllegalArgumentException("aoiWidth=" + frmHdr.aoiWidth + ", aoiHeight=" + frmHdr.aoiHeight);
 
 		final boolean isAOI = (frmHdr.aoiWidth != -1);
 
 		final ImageFormat format = ImageFormat.valueOf(frmHdr.imageFormat);
 		final int w = (isAOI ? frmHdr.aoiWidth : frmHdr.sourceWidth);
 		final int h = (isAOI ? frmHdr.aoiHeight : frmHdr.sourceHeight);
 		final int bpp = frmHdr.bytesPerPixel;
 		final int bits = frmHdr.effectiveBitsPerPixel;
 		final int appendedSize = frmHdr.appendedFrameSize;
 		final int wh = w * h;
 		byte[] byteArray = ti.getImageFrameBuffer();
 
 		if (bits < 8)
 			throw new IllegalArgumentException("bits=" + bits);
 		if (byteArray.length < appendedSize)
 			throw new IllegalArgumentException("format=" + format + ", size=" + appendedSize //
 					+ ", w=" + w + ", h=" + h + ", bpp=" + bpp + ", data.size=" + byteArray.length);
 
 		final Hashtable<?, ?> props = TImageMetadata.createProperties(ti);
 
 		switch (format) {
 		case IMAGE_FORMAT_GRAY:
 			if (appendedSize != wh * bpp)
 				throw new IllegalArgumentException("format=" + format + ", size=" + appendedSize //
 						+ ", w=" + w + ", h=" + h + ", bpp=" + bpp);
 
 			switch (bpp) {
 			case 1: // 1 bytes per pixel
 				// created buffered image: TYPE_BYTE_INDEXED / TYPE_BYTE_GRAY
 				if (bits != 8)
 					throw new IllegalArgumentException("format=" + format + ", bits=" + bits);
 				if (normalize)
 					byteArray = normalizeGray(Arrays.copyOf(byteArray, wh), //
 							min == -1 ? 0x0 : min, max == -1 ? 0xff : max);
 				if (colorMap == null || colorMap.equals(ColorMap.NONE))
 					destImage = createImageGray(w, h, bits, new DataBufferByte(byteArray, wh), props);
 				else
 					destImage = createImageIndexed(colorMap.getLUT(bits), w, h, new DataBufferByte(byteArray, wh),
 							props);
 				break;
 
 			case 2: // 2 bytes per pixel
 				// created buffered image: TYPE_CUSTOM / TYPE_USHORT_GRAY
 				if (bits > 16)
 					throw new IllegalArgumentException("format=" + format + ", bits=" + bits);
 				short[] shortArray = createShortArray(byteArray, wh, bits);
 				if (normalize)
 					normalizeGray(shortArray, (1 << bits) - 1, min == -1 ? 0x0 : min, max == -1 ? 0xffff : max);
 
 				if (colorMap == null || ColorMap.NONE.equals(colorMap) || ColorMap.GRAYSCALE.equals(colorMap))
 					// #pixelBits = 16 numComponents = 1 maxBits = [1-16]
 					destImage = createImageGray(w, h, bits, new DataBufferUShort(shortArray, wh), props);
 				else
 					// #pixelBits = [1-16] numComponents = 3
 					destImage = createImageIndexed(colorMap.getLUT(bits), w, h, //
 							new DataBufferUShort(shortArray, wh), props);
 				break;
 
 			default:
 				throw new IllegalArgumentException("format=" + format + ", bpp=" + bpp);
 			}
 			break;
 
 		case IMAGE_FORMAT_RGB:
 			// created buffered image: TYPE_INT_RGB
 			if (bpp != 3 || bits != 24)
 				throw new IllegalArgumentException("format=" + format + ", bpp=" + bpp + ", bits=" + bits);
 			if (appendedSize != wh * bpp)
 				throw new IllegalArgumentException("format=" + format + ", size=" + appendedSize //
 						+ ", w=" + w + ", h=" + h + ", bpp=" + bpp);
 			int[] intArray = createIntArray(byteArray, wh, bpp);
 			if (normalize)
 				normalizeRGB(intArray, min == -1 ? 0x0 : min, max == -1 ? 0xff : max);
 
 			destImage = createImageRGB(w, h, new DataBufferInt(intArray, wh), props);
 			break;
 
 		case IMAGE_FORMAT_RGBA:
 			// created buffered image: TYPE_INT_RGB
 			if (bpp != 4 || bits != 32)
 				throw new IllegalArgumentException("format=" + format + ", bpp=" + bpp + ", bits=" + bits);
 			if (appendedSize != wh * bpp)
 				throw new IllegalArgumentException("format=" + format + ", size=" + appendedSize //
 						+ ", w=" + w + ", h=" + h + ", bpp=" + bpp);
 			intArray = createIntArray(byteArray, wh, bpp);
 			if (normalize)
 				normalizeRGB(intArray, min == -1 ? 0x0 : min, max == -1 ? 0xff : max);
 
 			destImage = createImageRGB(w, h, new DataBufferInt(intArray, wh), props);
 			break;
 
 		case IMAGE_FORMAT_HUFFYUV:
 			// created buffered image: TYPE_BYTE_INDEXED / TYPE_BYTE_GRAY
 			if (bpp != 1 || bits != 8)
 				throw new IllegalArgumentException("format=" + format + ", bpp=" + bpp + ", bits=" + bits);
 			if (frmHdr.sourceFormat != 0) // IMAGE_FORMAT_GRAY
 				throw new IllegalArgumentException("format=" + format + ", srcFormat="
 						+ ImageFormat.valueOf(frmHdr.sourceFormat));
 			byte[] compressed = Arrays.copyOf(byteArray, appendedSize);
 			byte[] uncompressed = new byte[wh * bpp];
 			HuffmanDecompression.decompressHuffYUV(compressed, 0, uncompressed, 0, uncompressed.length);
 			if (normalize)
 				normalizeGray(uncompressed, min == -1 ? 0x0 : min, max == -1 ? 0xff : max);
 			if (colorMap == null || colorMap.equals(ColorMap.NONE))
 				destImage = createImageGray(w, h, bits, new DataBufferByte(uncompressed, wh), props);
 			else
 				destImage = createImageIndexed(colorMap.getLUT(bits), w, h, new DataBufferByte(uncompressed, wh), props);
 			break;
 
 		case IMAGE_FORMAT_JPEG:
 			// created buffered image:
 			// TYPE_BYTE_INDEXED / TYPE_BYTE_GRAY / TYPE_3BYTE_BGR /
 			// TYPE_INT_RGB
 			if ((bpp != 1 && bpp != 3) || (bpp == 1 && bits != 8) || (bpp == 3 && bits != 24))
 				throw new IllegalArgumentException("format=" + format + ", bpp=" + bpp + ", bits=" + bits);
 
 			
 			BufferedImage bi = createImageJPEG(w, wh, Arrays.copyOf(byteArray, appendedSize), props);
 			switch (bi.getType()) {
 			case BufferedImage.TYPE_BYTE_GRAY:
 				byteArray = ((DataBufferByte) bi.getRaster().getDataBuffer()).getData();
 				if (normalize)
 					normalizeGray(byteArray, min == -1 ? 0x0 : min, max == -1 ? 0xff : max);
 				if (colorMap == null || colorMap.equals(ColorMap.NONE))
 					destImage = bi;
 				else
 					destImage = new BufferedImage(colorMap.getLUT(bits), bi.getRaster(), false, props);
 				break;
 
 			case BufferedImage.TYPE_3BYTE_BGR:
 				byteArray = ((DataBufferByte) bi.getRaster().getDataBuffer()).getData();
 				if (normalize)
 					normalizeBGR(byteArray, min == -1 ? 0x0 : min, max == -1 ? 0xff : max);
 
 				destImage = bi;
 				break;
 
 			case BufferedImage.TYPE_INT_RGB:
 				intArray = ((DataBufferInt) bi.getRaster().getDataBuffer()).getData();
 				if (normalize)
 					normalizeRGB(intArray, min == -1 ? 0x0 : min, max == -1 ? 0xff : max);
 
 				destImage = bi;
 				break;
 
 			default:
 				throw new IllegalArgumentException("Unsupported image format: " + bi.getType());
 			}
 			break;
 
 		default:
 			throw new IllegalArgumentException("tiFormat=" + format);
 		}
 		return (aoiExpansion && isAOI) ? expanseAOI(destImage, props) : destImage;
 	}
 
 	/**
 	 * Converts Java <code>BufferedImage</code> to TINE image
 	 * 
 	 * @param bi
 	 *            - Java BufferedImage with/without TINE image metadata
 	 * @return TINE image
 	 */
 	public static IMAGE toIMAGE(BufferedImage bi) {
 		return toIMAGE(bi, false);
 	}
 
 	/**
 	 * Converts Java <code>BufferedImage</code> to TINE image
 	 * 
 	 * @param bi
 	 *            - Java BufferedImage with/without TINE image metadata
 	 * 
 	 * @param rejectNonArchival
 	 *            - if <code>true</code> and <code>bi</code> does not contain
 	 *            TINE image metadata throws
 	 *            <code>IllegalArgumentException</code>
 	 * @return TINE image
 	 */
 	@SuppressWarnings("deprecation")
 	public static IMAGE toIMAGE(BufferedImage bi, boolean rejectNonArchival) {
 		TImageMetadata tiMetadata = new TImageMetadata(bi, rejectNonArchival);
 		if (tiMetadata == null)
 			throw new NullPointerException("tiMetadata == null!");
 
 		IMAGE ti = new IMAGE(0);
 		tiMetadata.write(ti);
 		ti.setImageFrameBuffer(getData(bi));
 
 		return ti;
 	}
 
 	/**
 	 * Represents <code>TBufferedImage</code> as TINE image
 	 * 
 	 * @return TINE image
 	 */
 	public IMAGE toIMAGE() {
 		return toIMAGE(bufferedImage);
 	}
 
 	/**
 	 * Represents <code>TBufferedImage</code> as TINE image
 	 * 
 	 * @param rejectNonArchival
 	 *            - if <code>true</code> and <code>TBufferedImage</code> does
 	 *            not contain TINE image metadata throws
 	 *            <code>IllegalArgumentException</code>
 	 * @return TINE image
 	 */
 	public IMAGE toIMAGE(boolean rejectNonArchival) {
 		return toIMAGE(bufferedImage, rejectNonArchival);
 	}
 
 	/**
 	 * Returns true if TINE image format is supported.
 	 * 
 	 * @param format
 	 *            - an Image Format
 	 * @return true if image format is supported, otherwise - false
 	 * @throws IllegalArgumentException
 	 *             if format is invalid
 	 */
 	public static boolean isSupported(int format) {
 		return ImageFormat.valueOf(format).isSupported();
 	}
 
 	/**
 	 * Returns true if TINE image contains AOI, otherwise false.
 	 * 
 	 * @param ti
 	 *            - TINE image
 	 * @return true if AOI is present in the image, otherwise false
 	 * @note TODO: have to be a part of the TINE Image interface
 	 */
 	public static boolean containsAOI(IMAGE ti) {
 		return (ti.getFrameHeader().aoiHeight != -1 || ti.getFrameHeader().aoiWidth != -1);
 	}
 
 	/**
 	 * @param bi
 	 *            - BufferedImage
 	 * @return always <code>null</code> (!!!) while
 	 *         <code>BufferedImage#getPropertyNames()</code> returns always
 	 *         <code>null</code>
 	 * @deprecated
 	 * @see <code>BufferedImage#getPropertyNames()</code>
 	 */
 	public static Hashtable<String, Object> getProperties(BufferedImage bi) {
 		String[] propertyNames = bi.getPropertyNames();
 		if (propertyNames == null)
 			return null;
 
 		Hashtable<String, Object> properties = new Hashtable<String, Object>(32);
 		for (int i = 0; i < propertyNames.length; i++) {
 			String name = propertyNames[i];
 			properties.put(name, bi.getProperty(name));
 		}
 		return properties;
 	}
 
 	private static BufferedImage createImageGray(int w, int h, int bits, DataBuffer db, Hashtable<?, ?> props) {
 		WritableRaster raster = Raster.createInterleavedRaster(db, w, h, w, 1, new int[] { 0 }, null);
 		ColorModel cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_GRAY), //
 				new int[] { bits }, false, true, Transparency.OPAQUE, db.getDataType());
 		return new BufferedImage(cm, raster, false, props);
 	}
 
 	private static BufferedImage createImageIndexed(ColorModel cm, int w, int h, DataBuffer db, Hashtable<?, ?> props) {
 		WritableRaster raster = Raster.createInterleavedRaster(db, w, h, w, 1, new int[] { 0 }, null);
 		return new BufferedImage(cm, raster, false, props);
 	}
 
 	private static BufferedImage createImageRGB(int w, int h, DataBuffer db, Hashtable<?, ?> props) {
 		ColorModel cm = new DirectColorModel(24, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x0);
 		SampleModel sm = cm.createCompatibleSampleModel(w, h);
 		WritableRaster raster = WritableRaster.createWritableRaster(sm, db, null);
 		return new BufferedImage(cm, raster, false, props);
 	}
 
 	private static BufferedImage expanseAOI(BufferedImage srcImage, Hashtable<?, ?> props) {
 		if (srcImage == null)
 			throw new NullPointerException("srcImage == null!");
 
 		int srcWidth = (Integer) props.get(TImageMetadata.KEY_SOURCE_WIDTH);
 		int srcHeight = (Integer) props.get(TImageMetadata.KEY_SOURCE_HEIGHT);
 		int xStart = (Integer) props.get(TImageMetadata.KEY_XSTART);
 		int yStart = (Integer) props.get(TImageMetadata.KEY_YSTART);
 
 		ColorModel cm = new DirectColorModel(24, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x0);
 		WritableRaster raster = cm.createCompatibleWritableRaster(srcWidth, srcHeight);
 		BufferedImage bi = new BufferedImage(cm, raster, false, props);
 
 		Graphics2D g2d = bi.createGraphics();
 		g2d.drawImage(srcImage, xStart, yStart, null);
 		srcImage.flush();
 		g2d.dispose();
 
 		return bi;
 	}
 
 	private static BufferedImage createImageJPEG(int w, int h, byte[] dataArray, Hashtable<?, ?> properties) {
 
 		javax.imageio.ImageIO.setUseCache(false); // don`t use cache file
 
 		InputStream bis = new ByteArrayInputStream(dataArray);
 		BufferedImage bi;
 		try {
 			bi = javax.imageio.ImageIO.read(bis);
 
 		} catch (IOException e) {
 			throw new IllegalArgumentException(e);
 		} finally {
 			try {
 				bis.close();
 			} catch (IOException ignored) {
 			}
 		}
 		ColorModel cm = bi.getColorModel();
 		return new BufferedImage(cm, bi.getRaster(), cm.isAlphaPremultiplied(), properties);
 	}
 
 	private static short[] createShortArray(byte[] byteArray, int wh, int bits) {
 		final int maxValue = (1 << bits) - 1;
 		short[] shortArray = new short[wh];
 		for (int i = 0, j = 0; i < wh;) {
 			int gray0 = byteArray[j++] & 0xff;
 			int gray1 = byteArray[j++] & 0xff;
 			int pixel = ((gray1 << 8) | gray0);
 			if (pixel > maxValue)
 				throw new IllegalArgumentException("Invalid pixel at " + i + ": " + pixel);
 			shortArray[i++] = (short) pixel;
 		}
 		return shortArray;
 	}
 
 	private static int[] createIntArray(byte[] byteArray, int wh, int bpp) {
 		int[] intArray = new int[wh];
 		for (int i = 0, j = 0; i < wh; j += bpp) {
 			int red = byteArray[j] & 0xff;
 			int green = byteArray[j + 1] & 0xff;
 			int blue = byteArray[j + 2] & 0xff;
 			intArray[i++] = 0xff000000 | (red << 16) | (green << 8) | blue;
 		}
 		return intArray;
 	}
 
 	private static int[] getExtrema(byte[] array) {
 		int max = Byte.MIN_VALUE;
 		int min = Byte.MAX_VALUE;
 		for (int i : array) {
 			max = (max >= i) ? max : i;
 			min = (min <= i) ? min : i;
 		}
 		return (new int[] { min, max });
 	}
 
 	private static int[] getExtrema(short[] array) {
 		int max = Short.MIN_VALUE;
 		int min = Short.MAX_VALUE;
 		for (int i : array) {
 			max = (max >= i) ? max : i;
 			min = (min <= i) ? min : i;
 		}
 		return (new int[] { min, max });
 	}
 
 	private static int[] getExtrema(int[] array) {
 		int max = Integer.MIN_VALUE;
 		int min = Integer.MAX_VALUE;
 		for (int pixel : array) {
 			pixel = (int) (0.299 * ((pixel >> 16) & 0xff) + 0.587 * ((pixel >> 8) & 0xff) + 0.114 * (pixel & 0xff));
 			max = (max >= pixel) ? max : pixel;
 			min = (min <= pixel) ? min : pixel;
 		}
 		return (new int[] { min, max });
 	}
 
 	// private static int[][] getExtrema(int[] array) {
 	// int maxR, maxG, maxB, minR, minG, minB;
 	// maxR = maxG = maxB = Integer.MIN_VALUE;
 	// minR = minG = minB = Integer.MAX_VALUE;
 	// for (int pixel : array) {
 	// int r = (pixel >> 16) & 0xff;
 	// int g = (pixel >> 8) & 0xff;
 	// int b = pixel & 0xff;
 	// maxR = (maxR >= r) ? maxR : r;
 	// minR = (minR <= r) ? minR : r;
 	// maxG = (maxG >= g) ? maxG : g;
 	// minG = (minG <= g) ? minG : g;
 	// maxB = (maxB >= b) ? maxB : b;
 	// minB = (minB <= b) ? minB : b;
 	// }
 	// return (new int[][] { { minR, maxR }, { minG, maxG }, { minG, maxG } });
 	// }
 
 	private static byte[] normalizeGray(byte[] dataArray, final int lowest, final int highest) {
 
 		if (highest <= lowest)
 			throw new IllegalArgumentException(highest + " <= " + lowest);
 
 		final int[] extrema = getExtrema(dataArray);
 
 		// no amplitude rescaling needed, return source image
 		if (extrema[0] == extrema[1])
 			return dataArray;
 
 		int min = Math.max(extrema[0], lowest);
 		int max = Math.min(extrema[1], highest);
 
 		// calculate factor and offset of the amplitude rescaling
 		double constant = 255D / (max - min);
 		double offset = constant * min;
 
 		// amplitude rescaling of the image data
 		int size = dataArray.length;
 		for (int i = 0, pixel; i < size; i++) {
 			pixel = (dataArray[i] & 0xff);
 			if (pixel < min)
 				pixel = min;
 			if (pixel > max)
 				pixel = max;
 			dataArray[i] = (byte) (constant * pixel - offset);
 		}
 		return dataArray;
 	}
 
 	private static short[] normalizeGray(short[] dataArray, int colors, int lowest, int highest) {
 		if (highest <= lowest)
 			throw new IllegalArgumentException(highest + " <= " + lowest);
 
 		final int[] extrema = getExtrema(dataArray);
 
 		// no amplitude rescaling needed, return source image
 		if (extrema[0] == extrema[1])
 			return dataArray;
 
 		int min = Math.max(extrema[0], lowest);
 		int max = Math.min(extrema[1], Math.min(colors, highest));
 
 		// calculate factor and offset for amplitude rescaling
 		double constant = 1D * colors / (max - min);
 		double offset = constant * min;
 
 		// amplitude rescaling of the image data
 		int size = dataArray.length;
 		for (int i = 0, pixel; i < size; i++) {
 			pixel = (dataArray[i] & colors);
 			if (pixel < min)
 				pixel = min;
 			if (pixel > max)
 				pixel = max;
 			dataArray[i] = (short) (constant * pixel - offset);
 		}
 		return dataArray;
 	}
 
 	private static int[] normalizeRGB(int[] dataArray, final int lowest, final int highest) {
 
 		// calculate min/max
 		final int[] extrema = getExtrema(dataArray);
 		int min = Math.max(extrema[0], lowest);
 		int max = Math.min(extrema[1], highest);
 
 		// create scaling factor and offset for stretching
 		final double constant = 255D / (max - min);
 		final double offset = constant * min;
 
 		// normalize image data
 		final int size = dataArray.length;
 		for (int i = 0, pixel; i < size; i++) {
 			pixel = dataArray[i];
 			int r = (pixel >> 16) & 0xff; // red component
 			int g = (pixel >> 8) & 0xff; // green component
 			int b = pixel & 0xff; // blue component
 
 			double dY = constant - (offset / (0.299 * r + 0.587 * g + 0.114 * b));
 			r *= dY;
 			g *= dY;
 			b *= dY;
 
 			if (r < 0)
 				r = 0;
 			if (g < 0)
 				g = 0;
 			if (b < 0)
 				b = 0;
 			if (r > 0xff)
 				r = 0xff;
 			if (g > 0xff)
 				g = 0xff;
 			if (b > 0xff)
 				b = 0xff;
 
 			dataArray[i] = 0xff000000 | (r << 16) | (g << 8) | (b);
 		}
 		return dataArray;
 	}
 
 	private static byte[] normalizeBGR(byte[] dataArray, int lowest, int highest) {
 		// calculate min/max
 		final int[] extrema = getExtrema(dataArray);
 		int min = Math.max(extrema[0], lowest);
 		int max = Math.min(extrema[1], highest);
 
 		// create scaling factor and offset for stretching
 		final double constant = 255D / (max - min);
 		final double offset = constant * min;
 
 		// normalize image data
 		final int size = dataArray.length;
 		for (int i = 0; i < size; i += 3) {
 			int r = (dataArray[i + 2] & 0xff);
 			int g = (dataArray[i + 1] & 0xff);
 			int b = (dataArray[i] & 0xff);
 
 			double dY = constant - (offset / (0.299 * r + 0.587 * g + 0.114 * b));
 			r *= dY;
 			g *= dY;
 			b *= dY;
 
 			if (r < 0)
 				r = 0;
 			if (g < 0)
 				g = 0;
 			if (b < 0)
 				b = 0;
 			if (r > 0xff)
 				r = 0xff;
 			if (g > 0xff)
 				g = 0xff;
 			if (b > 0xff)
 				b = 0xff;
 
 			dataArray[i + 2] = (byte) r; // R
 			dataArray[i + 1] = (byte) g; // G
 			dataArray[i] = (byte) b; // B
 		}
 		return dataArray;
 	}
 
 	/**
 	 * Returns TINE image buffer byte-array data
 	 * 
 	 * @return image data
 	 */
 	private static byte[] getData(BufferedImage bi) {
 
 		final int[] intArray;
 		final short[] shortArray;
 		final byte[] byteArray;
 
 		final byte[] data;
 
 		int length;
 
 		final int imageType = bi.getType();
 
 		switch (imageType) {
 		case BufferedImage.TYPE_BYTE_GRAY:
 			return ((DataBufferByte) bi.getRaster().getDataBuffer()).getData();
 
 		case BufferedImage.TYPE_USHORT_GRAY:
 			shortArray = ((DataBufferUShort) bi.getRaster().getDataBuffer()).getData();
 			length = shortArray.length;
 			data = new byte[2 * length];
 			for (int i = 0, pos = 0; i < length; i++) {
 				data[pos++] = (byte) (shortArray[i]);
 				data[pos++] = (byte) (shortArray[i] >>> 8);
 			}
 			return data;
 
 		case BufferedImage.TYPE_INT_RGB:
 		case BufferedImage.TYPE_INT_ARGB:
 			intArray = ((DataBufferInt) bi.getRaster().getDataBuffer()).getData();
 			length = intArray.length;
 			data = new byte[3 * length];
 			for (int i = 0, pos = 0; i < length; i++) {
 				data[pos++] = (byte) (intArray[i] >>> 16); // red
 				data[pos++] = (byte) (intArray[i] >>> 8); // green
 				data[pos++] = (byte) (intArray[i] & 0xff); // blue
 			}
 			return data;
 
 		case BufferedImage.TYPE_INT_BGR:
 			intArray = ((DataBufferInt) bi.getRaster().getDataBuffer()).getData();
 			length = intArray.length;
 			data = new byte[3 * length];
 			for (int i = 0, pos = 0; i < length; i++) {
 				data[pos++] = (byte) (intArray[i] & 0xff); // red
 				data[pos++] = (byte) (intArray[i] >>> 8); // green
 				data[pos++] = (byte) (intArray[i] >>> 16); // blue
 			}
 			return data;
 
 		case BufferedImage.TYPE_3BYTE_BGR:
 			byteArray = ((DataBufferByte) bi.getRaster().getDataBuffer()).getData();
 			length = byteArray.length;
 			data = new byte[length];
 			for (int i = 0, pos = 0; pos < length; i += 3) {
 				data[pos++] = byteArray[i + 2]; // red
 				data[pos++] = byteArray[i + 1]; // green
 				data[pos++] = byteArray[i]; // blue
 			}
 			return data;
 
 		case BufferedImage.TYPE_4BYTE_ABGR:
 			byteArray = ((DataBufferByte) bi.getRaster().getDataBuffer()).getData();
 			length = byteArray.length / 4 * 3;
 			data = new byte[length];
 			for (int i = 0, pos = 0; pos < length; i += 4) {
 				data[pos++] = byteArray[i + 3]; // red
 				data[pos++] = byteArray[i + 2]; // green
 				data[pos++] = byteArray[i + 1]; // blue
 			}
 			return data;
 
 		default:
 			intArray = bi.getRGB(0, 0, bi.getWidth(), bi.getHeight(), null, 0, bi.getWidth());
 			length = intArray.length;
 			data = new byte[3 * length];
 			for (int i = 0, pos = 0; i < length; i++) {
 				data[pos++] = (byte) (intArray[i] >>> 16); // red
 				data[pos++] = (byte) (intArray[i] >>> 8); // green
 				data[pos++] = (byte) (intArray[i] & 0xff); // blue
 			}
 			return data;
 		}
 	}
 
 	public static BufferedImage toImageRGB(BufferedImage src) {
 		final int type = src.getType();
 		if (type == BufferedImage.TYPE_INT_RGB)
 			return src;
 		BufferedImage dest = new BufferedImage(src.getWidth(), src.getHeight(), BufferedImage.TYPE_INT_RGB);
 		dest.getGraphics().drawImage(src, 0, 0, null);
 		src.flush();
 		return dest;
 	}
 
 }