package de.desy.acop.video.displayer.timage;
   
   import java.awt.Graphics;
   import java.awt.Graphics2D;
   import java.awt.GraphicsConfiguration;
   import java.awt.GraphicsDevice;
   import java.awt.GraphicsEnvironment;
   import java.awt.HeadlessException;
   import java.awt.Image;
  import java.awt.Toolkit;
  import java.awt.Transparency;
  import java.awt.color.ColorSpace;
  import java.awt.geom.AffineTransform;
  import java.awt.image.BufferedImage;
  import java.awt.image.BufferedImageOp;
  import java.awt.image.ColorConvertOp;
  import java.awt.image.ColorModel;
  import java.awt.image.DataBufferByte;
  import java.awt.image.DataBufferInt;
  import java.awt.image.DataBufferUShort;
  import java.awt.image.FilteredImageSource;
  import java.awt.image.ImageFilter;
  import java.awt.image.ImageProducer;
  import java.awt.image.RenderedImage;
  import java.awt.image.WritableRaster;
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.util.Arrays;
  
  import javax.imageio.IIOImage;
  import javax.imageio.ImageIO;
  import javax.imageio.ImageReader;
  import javax.imageio.ImageWriter;
  import javax.imageio.stream.ImageInputStream;
  import javax.imageio.stream.ImageOutputStream;
  import javax.swing.GrayFilter;
  import javax.swing.ImageIcon;
  
  import com.sun.imageio.plugins.png.PNGMetadata;
  
  import de.desy.acop.video.displayer.ColorMap;
  import de.desy.acop.video.displayer.HuffmanDecompression;
  import de.desy.acop.video.displayer.ImageFormat;
  import de.desy.acop.video.timageio.TImageMetadata;
  import de.desy.tine.types.IMAGE;
  import de.desy.tine.types.IMAGE.FrameHeader;
  import de.desy.tine.types.IMAGE.SourceHeader;
  
  public class TImageUtils {
  
  	/**
  	 * Convenient static method to convert Image instances to BufferedImage
  	 * instances.
  	 * <p>
  	 * If the specified image is already instance of BufferedImage then it's
  	 * returned without processing.
  	 * 
  	 * @param image
  	 *            - image to convert if it's necessary
  	 * @return instance of BufferedImage or null if Image loading process is
  	 *         failed
  	 * @throws java.lang.NullPointerException
  	 *             <code>image</code> is null
  	 */
  	public static final BufferedImage toBufferedImage(java.awt.Image image) {
  		if (image == null)
  			throw new NullPointerException("image == null!");
  
  		if (image instanceof BufferedImage)
  			return (BufferedImage) image;
  
  		// This code ensures that all the pixels in the image are loaded
  		image = new ImageIcon(image).getImage();
  
  		// Determine if the image has transparent pixels; for this method's
  		// implementation, see e661 Determining If an Image Has Transparent
  		// Pixels
  		boolean hasAlpha = false;
  
  		// Create a buffered image with a format that's compatible with the
  		// screen
  		BufferedImage bi = null;
  		GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
  
  		try {
  			// Determine the type of transparency of the new buffered image
  			int transparency = Transparency.OPAQUE;
  			if (hasAlpha)
  				transparency = Transparency.BITMASK;
  
  			// Create the buffered image
  			GraphicsDevice gs = ge.getDefaultScreenDevice();
  			GraphicsConfiguration gc = gs.getDefaultConfiguration();
  			bi = gc.createCompatibleImage(image.getWidth(null), image.getHeight(null), transparency);
  
  		} catch (HeadlessException ignored) {
  			// The system does not have a screen
  		}
 
 		if (bi == null) {
 			// Create a buffered image using the default color model
 			int type = BufferedImage.TYPE_INT_RGB;
 			if (hasAlpha)
 				type = BufferedImage.TYPE_INT_ARGB;
 
 			bi = new BufferedImage(image.getWidth(null), image.getHeight(null), type);
 		}
 
 		// Copy image to buffered image
 		Graphics g = bi.createGraphics();
 
 		// Paint the image onto the buffered image
 		g.drawImage(image, 0, 0, null);
 		g.dispose();
 
 		return bi;
 	}
 
 	/**
 	 * Add the insets to the image and fill span between image and new borders.
 	 * 
 	 * @param src
 	 *            - image to inset
 	 * @param insets
 	 *            - instance of Insets class
 	 * @param paint
 	 *            - to fill the span
 	 * @return BufferedImage instance with added insets.
 	 * @throws java.lang.NullPointerException
 	 *             <ol>
 	 *             <li>If <code>src</code> is null
 	 *             <li>If <code>insets</code> is null
 	 */
 	public static final BufferedImage addInsets(BufferedImage src, java.awt.Insets insets, java.awt.Paint paint) {
 		if (src == null)
 			throw new NullPointerException("src == null!");
 
 		if (insets == null)
 			throw new NullPointerException("insets == null!");
 
 		int w = src.getWidth();
 		int h = src.getHeight();
 
 		BufferedImage dst = new BufferedImage(w + insets.left + insets.right, h + insets.top + insets.bottom, src
 				.getType());
 		Graphics2D g = dst.createGraphics();
 		if (paint != null) {
 			g.setPaint(paint);
 			if (insets.left > 0)
 				g.fillRect(0, 0, insets.left, h);
 
 			if (insets.right > 0)
 				g.fillRect(w - insets.right, 0, insets.right, h);
 
 			if (insets.top > 0)
 				g.fillRect(insets.left, 0, w - insets.left - insets.right, insets.top);
 
 			if (insets.bottom > 0)
 				g.fillRect(insets.left, h - insets.bottom, w - insets.left - insets.right, insets.bottom);
 		}
 		g.drawRenderedImage(src, AffineTransform.getTranslateInstance(insets.left, insets.right));
 		g.dispose();
 		return dst;
 	}
 
 	/**
 	 * @param src
 	 *            - image to scale
 	 * @param dstWidth
 	 *            - width which source image should be minimized to (the result
 	 *            image can have less width if 'keepRatio' parameter set to
 	 *            true)
 	 * @param dstHeight
 	 *            - height which source image should be minimized to (the result
 	 *            image can have less height if 'keepRatio' parameter set to
 	 *            true)
 	 * @param keepRatio
 	 *            -resize image proportionally
 	 * @return new scaled instance of BufferedImage
 	 * 
 	 * @throws NullPointerException
 	 *             If <code>src</code> is null
 	 * 
 	 * @throws java.lang.IllegalArgumentException
 	 *             <ol>
 	 *             <li>If <code>dstWidth</code> < 1
 	 *             <li>If <code>dstHeight</code> < 1
 	 */
 	public static final java.awt.image.BufferedImage scale(java.awt.image.BufferedImage src, int dstWidth,
 			int dstHeight, boolean keepRatio) {
 		if (src == null)
 			throw new NullPointerException("src == null!");
 
 		if (dstWidth < 1 || dstHeight < 1)
 			throw new IllegalArgumentException((dstWidth < 1 ? "dstWidth" : "dstHeight") + " < 1!");
 
 		int srcWidth = src.getWidth();
 		int srcHeight = src.getHeight();
 
 		Image scaleImage;
 		if (keepRatio) {
 			float ratio = (float) srcWidth / (float) srcHeight;
 			if (ratio < (float) dstWidth / (float) dstHeight)
 				dstWidth = (int) (dstHeight * ratio);
 			else
 				dstHeight = (int) (dstWidth * (1.0 / ratio));
 
 			if (dstWidth < 1)
 				dstWidth = 1;
 
 			if (dstHeight < 1)
 				dstHeight = 1;
 		}
 		scaleImage = src.getScaledInstance(dstWidth, dstHeight, Image.SCALE_FAST);
 
 		ColorModel dstCM = src.getColorModel();
 		BufferedImage dst = new BufferedImage(dstCM, dstCM.createCompatibleWritableRaster(dstWidth, dstHeight), dstCM
 				.isAlphaPremultiplied(), null);
 		Graphics2D g = dst.createGraphics();
 		g.drawImage(scaleImage, 0, 0, dstWidth, dstHeight, null);
 		g.dispose();
 		return dst;
 	}
 
 	/**
 	 * Writes an image using an arbitrary ImageWriter that supports the given
 	 * format to a newly allocated byte array.
 	 * 
 	 * @param rimage
 	 *            - a RenderedImage to be written.
 	 * @param formatName
 	 *            - a String contain the informal name of the format.
 	 * 
 	 * @return a newly allocated byte array
 	 * @throws IOException
 	 *             if an error occurs during writing.
 	 */
 	public static byte[] toRawBytes(RenderedImage rimage, String formatName) throws IOException {
 		ByteArrayOutputStream baos = new ByteArrayOutputStream();
 		byte[] rawBytes = null;
 		try {
 			ImageIO.write(rimage, formatName, baos);
 			baos.flush();
 			rawBytes = baos.toByteArray();
 
 		} finally {
 			baos.close();
 		}
 		return rawBytes;
 	}
 
 	/**
 	 * Creates an Image from array using raster.
 	 * 
 	 * @param pixels
 	 *            - The input int pixel array.
 	 * @param width
 	 *            - Width of the pixel rectangle.
 	 * @param height
 	 *            - Height of the pixel rectangle.
 	 * @param type
 	 *            - type of the created image
 	 * @return Image
 	 */
 	public static Image getImageFromArray(int[] pixels, int width, int height, int type) {
 		BufferedImage image = new BufferedImage(width, height, type);
 		WritableRaster raster = (WritableRaster) image.getData();
 		raster.setPixels(0, 0, width, height, pixels);
 		return image;
 	}
 
 	/**
 	 * Get a byte array associated with input buffered image.
 	 * 
 	 * @param image
 	 *            - input buffered image
 	 * @return byte-array
 	 */
 	public static byte[] getImageByteArray(BufferedImage image) {
 		WritableRaster raster = image.getRaster();
 		DataBufferByte buffer = (DataBufferByte) raster.getDataBuffer();
 		return buffer.getData();
 	}
 
 	/**
 	 * Get a integer array associated with input buffered image.
 	 * 
 	 * @param image
 	 *            - input buffered image
 	 * @return int-array
 	 */
 	public static int[] getImageIntArray(BufferedImage image) {
 		WritableRaster raster = image.getRaster();
 		DataBufferInt buffer = (DataBufferInt) raster.getDataBuffer();
 		return buffer.getData();
 	}
 
 	/**
 	 * Create an PNG image bitmap.
 	 * 
 	 * @param image
 	 *            The image to render.
 	 * @param resolution
 	 *            The DPI of the image.
 	 * @param format
 	 *            The format to convert to.
 	 * @return A file image of the bitmap.
 	 */
 	public static byte[] imageToBitmap(BufferedImage image, float resolution, String format) throws IOException {
 
 		// define PNG resolution, etc.
 		PNGMetadata png = new PNGMetadata();
 		int res = (int) Math.ceil(resolution / 0.0254f);
 		png.pHYs_pixelsPerUnitXAxis = res;
 		png.pHYs_pixelsPerUnitYAxis = res;
 		png.pHYs_unitSpecifier = 1;
 		png.pHYs_present = true;
 
 		IIOImage iioImage = new IIOImage(image, null, png);
 
 		// Save as PNG
 		ImageWriter writer = ImageIO.getImageWritersByFormatName(format).next();
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
 		ImageOutputStream ios = ImageIO.createImageOutputStream(out);
 		writer.setOutput(ios);
 
 		writer.write(iioImage);
 		writer.dispose();
 		return out.toByteArray();
 	}
 
 	/**
 	 * Convert a bitmap to an Image object
 	 * 
 	 * @param data
 	 *            The bitmap file.
 	 * @param format
 	 *            The format the data is in.
 	 * @return The Image of this data.
 	 * @throws IOException
 	 *             thrown if a problem reading the data or the format is wrong.
 	 */
 	public static BufferedImage bitmapToImage(byte[] data, String format) throws IOException {
 		ByteArrayInputStream inb = new ByteArrayInputStream(data);
 		ImageReader rdr = ImageIO.getImageReadersByFormatName(format).next();
 		ImageInputStream imageInput = ImageIO.createImageInputStream(inb);
 		rdr.setInput(imageInput);
 		return rdr.read(0);
 	}
 
 	public static BufferedImage convertToGrayscale(BufferedImage source) {
 		BufferedImageOp op = new ColorConvertOp(ColorSpace.getInstance(ColorSpace.CS_GRAY), null);
 		return op.filter(source, null);
 	}
 
 	public static BufferedImage convertToGrayscale2(BufferedImage colorImage) {
 		BufferedImage bi = new BufferedImage(colorImage.getWidth(), colorImage.getHeight(),
 				BufferedImage.TYPE_BYTE_GRAY);
 		Graphics g = bi.getGraphics();
 		g.drawImage(colorImage, 0, 0, null);
 		g.dispose();
 		return bi;
 	}
 
 	public static Image convertToGrayscale3(BufferedImage colorImage) {
 		ImageFilter filter = new GrayFilter(true, 50);
 		ImageProducer producer = new FilteredImageSource(colorImage.getSource(), filter);
 		Image image = Toolkit.getDefaultToolkit().createImage(producer);
 		return image;
 	}
 
 	/**
 	 * Uncompresses the TINE image data.
 	 * 
 	 * @param timage
 	 *            - input TINE IMAGE
 	 * @return - uncompressed TINE IMAGE
 	 */
 	public static IMAGE uncompressImage(IMAGE timage) {
 		if (timage == null)
 			throw new NullPointerException("timage == null!");
 
 		final IMAGE ti = timage.clone();
 
 		FrameHeader fHdr = ti.getFrameHeader();
 		SourceHeader sHdr = ti.getSourceHeader();
 
 		int uncompressed_byte_length = fHdr.bytesPerPixel //
 				* ((fHdr.aoiWidth != -1) ? fHdr.aoiWidth : fHdr.sourceWidth) //
 				* ((fHdr.aoiHeight != -1) ? fHdr.aoiHeight : fHdr.sourceHeight);
 
 		byte[] compressedBuf = new byte[fHdr.appendedFrameSize];
 
 		System.arraycopy(ti.getImageFrameBuffer(), 0, compressedBuf, 0, fHdr.appendedFrameSize);
 
 		// VideoHeaderV3.HDRSIZE
 		HuffmanDecompression.decompressHuffYUV(compressedBuf, 0, timage.getImageFrameBuffer(), 0,
 				uncompressed_byte_length);
 
 		// adjust header after compression
 		fHdr.imageFormat = ImageFormat.IMAGE_FORMAT_GRAY.getId();
 		fHdr.appendedFrameSize = uncompressed_byte_length;
 		sHdr.totalLength = uncompressed_byte_length + IMAGE.HEADER_SIZE;
 
 		return ti;
 	}
 
 	/**
 	 * Creates and returns a copy of TINE image.
 	 * 
 	 * @deprecated mdavid: use {@link de.desy.tine.types.IMAGE#clone()} instead
 	 * @return a copy of a <code>timage</code> TINE image.
 	 */
 	public static final IMAGE clone(IMAGE timage) {
 		FrameHeader fHdr = timage.getFrameHeader();
 		SourceHeader sHdr = timage.getSourceHeader();
 		byte[] buffer = timage.getImageFrameBuffer();
 		IMAGE ti = new IMAGE(buffer.length);
 		setFrameHeader(ti, fHdr);
 		setSourceHeader(ti, sHdr);
 		byte[] clone = ti.getImageFrameBuffer();
 		System.arraycopy(buffer, 0, clone, 0, clone.length);
 		// ti.setImageFrameBuffer(timage.getImageFrameBuffer().clone());
 		return ti;
 	}
 
 	/**
 	 * TODO: should be replaced/changed into IMAGE.FrameHeader class
 	 * 
 	 */
 	public static final IMAGE setFrameHeader(IMAGE timage, FrameHeader fraHeader) {
 		FrameHeader frameHeader = timage.getFrameHeader();
 		frameHeader.aoiHeight = fraHeader.aoiHeight;
 		frameHeader.aoiWidth = fraHeader.aoiWidth;
 		frameHeader.appendedFrameSize = fraHeader.appendedFrameSize;
 		frameHeader.bytesPerPixel = fraHeader.bytesPerPixel;
 		frameHeader.effectiveBitsPerPixel = fraHeader.effectiveBitsPerPixel;
 		frameHeader.eventNumber = fraHeader.eventNumber;
 		frameHeader.frameNumber = fraHeader.frameNumber;
 		frameHeader.fspare1 = fraHeader.fspare1;
 		frameHeader.fspare2 = fraHeader.fspare2;
 		frameHeader.fspare3 = fraHeader.fspare3;
 		frameHeader.horizontalBinning = fraHeader.horizontalBinning;
 		frameHeader.imageFlags = fraHeader.imageFlags;
 		frameHeader.imageFormat = fraHeader.imageFormat;
 		frameHeader.imageRotation = fraHeader.imageRotation;
 		frameHeader.ispare1 = fraHeader.ispare1;
 		frameHeader.ispare2 = fraHeader.ispare2;
 		frameHeader.ispare3 = fraHeader.ispare3;
 		frameHeader.sourceFormat = fraHeader.sourceFormat;
 		frameHeader.sourceHeight = fraHeader.sourceHeight;
 		frameHeader.sourceWidth = fraHeader.sourceWidth;
 		frameHeader.verticalBinning = fraHeader.verticalBinning;
 		frameHeader.xScale = fraHeader.xScale;
 		frameHeader.xStart = fraHeader.xStart;
 		frameHeader.yScale = fraHeader.yScale;
 		frameHeader.yStart = fraHeader.yStart;
 		return timage;
 	}
 
 	/**
 	 * TODO: should be replaced/changed into IMAGE.FrameHeader class
 	 * 
 	 */
 	public static final IMAGE setSourceHeader(IMAGE timage, SourceHeader srcHeader) {
 		SourceHeader sourceHeader = timage.getSourceHeader();
 		sourceHeader.baseTag = srcHeader.baseTag;
 		sourceHeader.cameraPortId = srcHeader.cameraPortId;
 		sourceHeader.cameraPortName = srcHeader.cameraPortName;
 		sourceHeader.timestampMicroseconds = srcHeader.timestampMicroseconds;
 		sourceHeader.timestampSeconds = srcHeader.timestampSeconds;
 		sourceHeader.totalLength = srcHeader.totalLength;
 		sourceHeader.versionTag = srcHeader.versionTag;
 		return timage;
 	}
 
 	/**
 	 ** Pad a string S with a size of N with char C on the left(True) or on the
 	 * right(False)
 	 */
 	public static String padString(String s, int n, char c, boolean padLeft) {
 		StringBuffer sb = new StringBuffer(s);
 		int strLength = sb.length();
 		if (n > 0 && n > strLength) {
 			for (int i = 0; i <= n; i++) {
 				if (padLeft) {
 					if (i < n - strLength)
 						sb.insert(0, c);
 				} else {
 					if (i > strLength)
 						sb.append(c);
 				}
 			}
 		}
 		return sb.toString();
 	}
 
 	public static synchronized boolean compare(IMAGE cTImage, IMAGE jTImage) {
 		if (cTImage == null)
 			return jTImage == null;
 
 		boolean failed = false;
 
 		SourceHeader srcHeader = cTImage.getSourceHeader();
 		if (srcHeader.baseTag != jTImage.getSourceHeader().baseTag) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in baseTag (arg1/arg2): \"" + srcHeader.baseTag
 					+ "\" / \"" + jTImage.getSourceHeader().baseTag);
 			failed = true;
 		}
 
 		if (srcHeader.cameraPortId != jTImage.getSourceHeader().cameraPortId) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in cameraPortId (arg1/arg2): \""
 					+ srcHeader.cameraPortId + "\" / \"" + jTImage.getSourceHeader().cameraPortId);
 			failed = true;
 		}
 
 		if (srcHeader.cameraPortName == null) {
 			if (jTImage.getSourceHeader().cameraPortName != null) {
 				System.out.println("<<< mdavid >>> ERROR - Difference in cameraPortName (arg1/arg2): \""
 						+ srcHeader.cameraPortName + "\" / \"" + jTImage.getSourceHeader().cameraPortName);
 				failed = true;
 			}
 
 		} else if (!srcHeader.cameraPortName.equals(jTImage.getSourceHeader().cameraPortName)) {
 			System.out
 					.println("<<< mdavid >>> WARN - Difference in cameraPortName (arg1/arg2): \""
 							+ srcHeader.cameraPortName + "\" / \"" + jTImage.getSourceHeader().cameraPortName
 							+ "\" - IGNORED!");
 			// res = false;
 		}
 
 		if (srcHeader.versionTag != jTImage.getSourceHeader().versionTag) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in versionTag (arg1/arg2): \"" + srcHeader.versionTag
 					+ "\" / \"" + jTImage.getSourceHeader().versionTag);
 			failed = true;
 		}
 
 		if (srcHeader.totalLength != jTImage.getSourceHeader().totalLength) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in totalLength (arg1/arg2): \""
 					+ srcHeader.totalLength + "\" / \"" + jTImage.getSourceHeader().totalLength);
 			failed = true;
 		}
 
 		if (srcHeader.timestampSeconds != jTImage.getSourceHeader().timestampSeconds) {
 			System.out.println("<<< mdavid >>> WARN - Difference in timestampSeconds (arg1/arg2): \""
 					+ srcHeader.timestampSeconds + "\" / \"" + jTImage.getSourceHeader().timestampSeconds
 					+ "\" - IGNORED!");
 			// res = false;
 		}
 
 		if (srcHeader.timestampMicroseconds != jTImage.getSourceHeader().timestampMicroseconds) {
 			System.out.println("<<< mdavid >>> WARN - Difference in timestampMicroseconds (arg1/arg2): \""
 					+ srcHeader.timestampMicroseconds + "\" / \"" + jTImage.getSourceHeader().timestampMicroseconds
 					+ "\" - IGNORED!");
 			// res = false;
 		}
 
 		/* ********************************************************************** */
 
 		FrameHeader frameHeader = cTImage.getFrameHeader();
 		if (frameHeader.sourceWidth != jTImage.getFrameHeader().sourceWidth) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in sourceWidth (arg1/arg2): \""
 					+ frameHeader.sourceWidth + "\" / \"" + jTImage.getFrameHeader().sourceWidth);
 			failed = true;
 		}
 
 		if (frameHeader.sourceHeight != jTImage.getFrameHeader().sourceHeight) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in sourceHeight (arg1/arg2): \""
 					+ frameHeader.sourceHeight + "\" / \"" + jTImage.getFrameHeader().sourceHeight);
 			failed = true;
 		}
 
 		if (frameHeader.aoiWidth != jTImage.getFrameHeader().aoiWidth) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in aoiWidth (arg1/arg2): \"" + frameHeader.aoiWidth
 					+ "\" / \"" + jTImage.getFrameHeader().aoiWidth);
 			failed = true;
 		}
 
 		if (frameHeader.aoiHeight != jTImage.getFrameHeader().aoiHeight) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in aoiHeight (arg1/arg2): \"" + frameHeader.aoiHeight
 					+ "\" / \"" + jTImage.getFrameHeader().aoiHeight);
 			failed = true;
 		}
 
 		if (frameHeader.xStart != jTImage.getFrameHeader().xStart) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in xStart (arg1/arg2): \"" + frameHeader.xStart
 					+ "\" / \"" + jTImage.getFrameHeader().xStart);
 			failed = true;
 		}
 		if (frameHeader.yStart != jTImage.getFrameHeader().yStart) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in yStart (arg1/arg2): \"" + frameHeader.yStart
 					+ "\" / \"" + jTImage.getFrameHeader().yStart);
 			failed = true;
 		}
 		if (frameHeader.bytesPerPixel != jTImage.getFrameHeader().bytesPerPixel) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in bytesPerPixel (arg1/arg2): \""
 					+ frameHeader.bytesPerPixel + "\" / \"" + jTImage.getFrameHeader().bytesPerPixel);
 			failed = true;
 		}
 		if (frameHeader.effectiveBitsPerPixel != jTImage.getFrameHeader().effectiveBitsPerPixel) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in effectiveBitsPerPixel (arg1/arg2): \""
 					+ frameHeader.effectiveBitsPerPixel + "\" / \"" + jTImage.getFrameHeader().effectiveBitsPerPixel);
 			failed = true;
 		}
 		if (frameHeader.horizontalBinning != jTImage.getFrameHeader().horizontalBinning) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in horizontalBinning (arg1/arg2): \""
 					+ frameHeader.horizontalBinning + "\" / \"" + jTImage.getFrameHeader().horizontalBinning);
 			failed = true;
 		}
 		if (frameHeader.verticalBinning != jTImage.getFrameHeader().verticalBinning) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in verticalBinning (arg1/arg2): \""
 					+ frameHeader.verticalBinning + "\" / \"" + jTImage.getFrameHeader().verticalBinning);
 			failed = true;
 		}
 		if (frameHeader.sourceFormat != jTImage.getFrameHeader().sourceFormat) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in sourceFormat (arg1/arg2): \""
 					+ frameHeader.sourceFormat + "\" / \"" + jTImage.getFrameHeader().sourceFormat);
 			failed = true;
 		}
 		if (frameHeader.imageFormat != jTImage.getFrameHeader().imageFormat) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in imageFormat (arg1/arg2): \""
 					+ frameHeader.imageFormat + "\" / \"" + jTImage.getFrameHeader().imageFormat);
 			failed = true;
 		}
 		if (frameHeader.frameNumber != jTImage.getFrameHeader().frameNumber) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in frameNumber (arg1/arg2): \""
 					+ frameHeader.frameNumber + "\" / \"" + jTImage.getFrameHeader().frameNumber);
 			failed = true;
 		}
 		if (frameHeader.eventNumber != jTImage.getFrameHeader().eventNumber) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in eventNumber (arg1/arg2): \""
 					+ frameHeader.eventNumber + "\" / \"" + jTImage.getFrameHeader().eventNumber);
 			failed = true;
 		}
 		if (frameHeader.xScale != jTImage.getFrameHeader().xScale) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in xScale (arg1/arg2): \"" + frameHeader.xScale
 					+ "\" / \"" + jTImage.getFrameHeader().xScale);
 			failed = true;
 		}
 		if (frameHeader.yScale != jTImage.getFrameHeader().yScale) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in yScale (arg1/arg2): \"" + frameHeader.yScale
 					+ "\" / \"" + jTImage.getFrameHeader().yScale);
 			failed = true;
 		}
 		if (frameHeader.imageRotation != jTImage.getFrameHeader().imageRotation) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in imageRotation (arg1/arg2): \""
 					+ frameHeader.imageRotation + "\" / \"" + jTImage.getFrameHeader().imageRotation);
 			failed = true;
 		}
 		if (frameHeader.fspare1 != jTImage.getFrameHeader().fspare1) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in fspare1 (arg1/arg2): \"" + frameHeader.fspare1
 					+ "\" / \"" + jTImage.getFrameHeader().fspare1);
 			failed = true;
 		}
 		if (frameHeader.fspare2 != jTImage.getFrameHeader().fspare2) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in fspare2 (arg1/arg2): \"" + frameHeader.fspare2
 					+ "\" / \"" + jTImage.getFrameHeader().fspare2);
 			failed = true;
 		}
 		if (frameHeader.fspare3 != jTImage.getFrameHeader().fspare3) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in fspare3 (arg1/arg2): \"" + frameHeader.fspare3
 					+ "\" / \"" + jTImage.getFrameHeader().fspare3);
 			failed = true;
 		}
 		if (frameHeader.imageFlags != jTImage.getFrameHeader().imageFlags) {
 			System.out.println("<<< mdavid >>> WARN - Difference in imageFlags (arg1/arg2): \""
 					+ frameHeader.imageFlags + "\" / \"" + jTImage.getFrameHeader().imageFlags);
 			// failed = true;
 		}
 		if (frameHeader.ispare1 != jTImage.getFrameHeader().ispare1) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in ispare1 (arg1/arg2): \"" + frameHeader.ispare1
 					+ "\" / \"" + jTImage.getFrameHeader().ispare1);
 			failed = true;
 		}
 		if (frameHeader.ispare2 != jTImage.getFrameHeader().ispare2) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in ispare2 (arg1/arg2): \"" + frameHeader.ispare2
 					+ "\" / \"" + jTImage.getFrameHeader().ispare2);
 			failed = true;
 		}
 		if (frameHeader.ispare3 != jTImage.getFrameHeader().ispare3) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in ispare3 (arg1/arg2): \"" + frameHeader.ispare3
 					+ "\" / \"" + jTImage.getFrameHeader().ispare3);
 			failed = true;
 		}
 		if (frameHeader.appendedFrameSize != jTImage.getFrameHeader().appendedFrameSize) {
 			System.out.println("<<< mdavid >>> ERROR - Difference in fspare3 (arg1/arg2): \""
 					+ frameHeader.appendedFrameSize + "\" / \"" + jTImage.getFrameHeader().appendedFrameSize);
 			failed = true;
 		}
 
 		/* ********************************************************************** */
 		/* ********************************************************************** */
 		if (cTImage.getSizeInBytes() != jTImage.getSizeInBytes()) {
 			System.out.println("<<< mdavid >>> WARN - Difference in sizeInBytes (arg1/arg2): \""
 					+ cTImage.getSizeInBytes() + "\" / \"" + jTImage.getSizeInBytes() + "\" - IGNORED!");
 			// res = false;
 		}
 
 		String cMD5Hash = TImageMetadata.md5hash(cTImage.getImageFrameBuffer());
 		String jMD5Hash = TImageMetadata.md5hash(jTImage.getImageFrameBuffer());
 		if (!cMD5Hash.equals(jMD5Hash)) {
 			System.out.println("<<< mdavid >>> WARN - Difference in md5hash (arg1/arg2): \"" + cMD5Hash + "\" / \""
 					+ jMD5Hash);
 
 			// failed = true;
 		}
 
 		byte[] buf = Arrays.copyOfRange(cTImage.getImageFrameBuffer(), 0, frameHeader.appendedFrameSize);
 
 		boolean b = false;
 		for (int i = 0; i < buf.length; i++) {
 			if (buf[i] != jTImage.getImageFrameBuffer()[i] && !b) {
 				System.out.println("<<< mdavid >>> ERROR - Difference: index = " + i + ", value (arg1/arg2): \""
 						+ buf[i] + "\" / \"" + jTImage.getImageFrameBuffer()[i] + "\"");
 				b = true;
 				failed = true;
 			}
 		}
 
 		// if (!Arrays.equals(buf, ti2.getImageFrameBuffer())) { // TODO: mdavid
 		// : why diff ??
 		// System.out.println("<<< mdavid >>> WARN - Difference in imageFrame buffer");
 		// res = false;
 		// }
 
 		return !failed;
 	}
 
 	/**
 	 * Convert 8 bit gray <code>BufferedImage</code> to RGB
 	 * <code>BufferedImage</code>.
 	 * 
 	 * @param image
 	 *            - source 8 bit gray <code>BufferedImage</code>
 	 * @return RGB <code>BufferedImage</code>
 	 */
 	public static BufferedImage convertGrayByteToRGB(BufferedImage image) {
 		byte[] byteArray = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
 		BufferedImage bi = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_RGB);
 		int[] intArray = ((DataBufferInt) bi.getRaster().getDataBuffer()).getData();
 		int numPixels = intArray.length;
 		for (int i = 0; i < numPixels; i++) {
 			int gray = byteArray[i] & 0xff;
 			intArray[i] = 0xff000000 | (gray << 16) | (gray << 8) | (gray);
 		}
 		return bi;
 	}
 
 	/**
 	 * Convert 16 bit gray <code>BufferedImage</code> to RGB
 	 * <code>BufferedImage</code>.
 	 * 
 	 * @param srcImage
 	 *            - source 16 bit gray <code>BufferedImage</code>
 	 * @return RGB <code>BufferedImage</code>
 	 */
 	public static BufferedImage convertGrayShortToRGB(BufferedImage srcImage) {
 		int bitsUsed = srcImage.getColorModel().getComponentSize(0);
 		short[] grayPixels = ((DataBufferUShort) srcImage.getRaster().getDataBuffer()).getData();
 
 		BufferedImage bi = new BufferedImage(srcImage.getWidth(), srcImage.getHeight(), BufferedImage.TYPE_INT_RGB);
 		int[] rgbPixels = ((DataBufferInt) bi.getRaster().getDataBuffer()).getData();
 		int numPixels = rgbPixels.length;
 		int shift = bitsUsed - 8;
 		for (int i = 0; i < numPixels; i++) {
 			int gray = (grayPixels[i] & 0xffff) >> shift;
 			rgbPixels[i] = 0xff000000 | ((gray & 0xff) << 16) | ((gray & 0xff) << 8) | (gray);
 		}
 		return bi;
 	}
 
 	/**
 	 * Convert 16 bit gray <code>BufferedImage</code> to 8 bit gray
 	 * <code>BufferedImage</code>.
 	 * 
 	 * @param image
 	 *            - source 16 bit gray <code>BufferedImage</code>
 	 * @return RGB <code>BufferedImage</code>
 	 */
 	public static BufferedImage convertGrayShortToGrayByte(BufferedImage image) {
 		if (image == null)
 			throw new NullPointerException("image == null!");
 		return new BufferedImage(ColorMap.GRAYSCALE.getLUT(12), image.getRaster(), false, null);
 	}
 
 	/**
 	 * Converts grayscale image into paletted (indexed) buffered image.
 	 * 
 	 * @param srcImage
 	 *            - grayscale buffered image
 	 * @param icm
 	 *            - indexed color model
 	 * @return - paletted buffered image
 	 */
 	public static BufferedImage toIndexedBufferedImage(BufferedImage srcImage, ColorModel icm) {
 		if (srcImage == null)
 			throw new NullPointerException("srcImage == null!");
 		if (icm == null)
 			throw new NullPointerException("icm == null!");
 		return new BufferedImage(icm, srcImage.getRaster(), false, null);
 	}
 
 	/**
 	 * Converts image into colored buffered image.
 	 * 
 	 * @param srcImage
 	 *            - buffered image
 	 * @return - colored buffered image
 	 */
 	public static BufferedImage toColoredBufferedImage(BufferedImage srcImage) {
 		if (srcImage == null)
 			throw new NullPointerException("srcImage == null!");
 
 		/* create new buffered image with/without alpha */
 		BufferedImage bi = new BufferedImage(srcImage.getWidth(), srcImage.getHeight(), //
 				(srcImage.getColorModel().hasAlpha() ? BufferedImage.TYPE_INT_ARGB : BufferedImage.TYPE_INT_RGB));
 
 		/* draw image into colored graphics */
 		((Graphics2D) bi.getGraphics()).drawImage(srcImage, AffineTransform.getRotateInstance(0), null);
 
 		/* flushes all image resources */
 		srcImage.flush();
 
 		return bi;
 	}
 }