gistfile1.txt

package CompressAnImageToA4kibPreview;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.RenderingHints;
import java.awt.RenderingHints.Key;
import java.awt.geom.Path2D;
import java.awt.image.BufferedImage;
import java.awt.image.BufferedImageOp;
import java.awt.image.ConvolveOp;
import java.awt.image.Kernel;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.zip.Deflater;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.InflaterInputStream;

import javax.imageio.ImageIO;

/**
 * Licensed under Revised BSD License:
 * 
 * Copyright (c) 2016, Nicholas Klaebe
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Nicholas Klaebe nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 *  @author Nicholas Klaebe 
 *
 */ 
public class CompressAnImageToA4kibPreview
{
	/**
	 * InputStream that allows 1-63 bitwise writes
	 * @author default
	 *
	 */
	static class BitInputStream
	{
		InputStream fis;
		int count;
		long totalCount;
		byte value;
		byte[] buffer;
		int buffCount;
		int buffSize;
		boolean returnVal;
		private static final int EOF_INT = -1;

		/**
		 * Constructor
		 * 
		 * @param fis1
		 *            The base inputStream
		 * @param size
		 *            size of the input buffer
		 */
		public BitInputStream(InputStream fis1, int size)
		{
			count = 0;
			buffer = new byte[size];
			buffCount = 0;
			totalCount = 0;
			fis = fis1;
		}

		/**
		 * read in a single bit
		 * 
		 * @return bit read
		 * @throws IOException
		 */
		public boolean read() throws IOException
		{
			if (count == 0)
			{
				if (buffCount == 0)
				{
					buffSize = 0;
					while (buffSize == 0)
					{
						buffSize = fis.read(buffer, 0, buffer.length);
					}
					if (buffSize == EOF_INT)
					{
						throw new EOFException("END OF FILE");
					}

				}
				value = buffer[buffCount];
				buffCount++;
				if (buffCount == buffSize)
					buffCount = 0;
			}

			if ((value >> (7 - count) & 0x01) > 0)
				returnVal = true;
			else
				returnVal = false;

			count++;
			totalCount++;
			if (count == 8)
				count = 0;

			return returnVal;
		}

		/**
		 * reads in the next char, if not on a 8bit boundary then the stream is aligned to the next byte
		 * 
		 * @return byte read
		 * @throws IOException
		 */
		public char readChar() throws IOException
		{
			byte[] b = new byte[1];
			alignToNextByte();
			fis.read(b);
			totalCount += 8;
			return (char) b[0];
		}

		/**
		 * aligns the bit stream to the next byte boundary
		 * 
		 * @throws IOException
		 */
		public void alignToNextByte() throws IOException
		{
			while (count != 0)
			{
				read();
			}
		}

		/**
		 * read in a specified number of bits
		 * 
		 * @param bits
		 *            the number of bits to be read (between 1 and 64)
		 * @return a long integer containg the bits read
		 * @throws IOException
		 */

		public long read(int bits) throws IOException
		{
			long val = 0;
			int mask = 0x01;
			boolean[] bitsRead = new boolean[bits];

			for (int i = 0; i < bits; i++)
			{
				bitsRead[i] = read();
			}
			for (int j = bits - 1; j > -1; j--)
			{

				val = val << 1;
				if (bitsRead[j])
				{
					val = val | mask;
				}
			}
			return val;
		}

		/**
		 * attempts to read bytes into the array given
		 * 
		 * @param temp
		 *            the array being populated
		 * @param start
		 *            the starting index
		 * @param end
		 *            the ending index
		 * @return the bytes read in
		 * @throws IOException
		 */
		public int read(byte[] temp, int start, int end) throws IOException
		{
			totalCount += (end - start) * 8;
			return fis.read(temp, start, end);
		}

		public int read(byte[] temp) throws IOException
		{
			totalCount += temp.length * 8;
			return fis.read(temp);
		}

		public int readByte() throws IOException
		{
			totalCount += 8;
			return fis.read();
		}

		public void close() throws IOException
		{
			fis.close();
		}
	}

	/**
	 * OutputStream that allows 1-63 bitwise reads
	 */
	static public class BitOutputStream
	{
		int value; // The byte in which the encoded bits are firstly stored.
		int count; // The number of bits written into value.
		byte[] buffer; // A byte buffer which is filled with 'value' each time value is full. Used for wirting to file.
		int buffCount; // The current number of 'values' written into the buffer.
		long masterCount; // The overall count of bits that have been written
		OutputStream fos;

		/**
		 * constructor
		 * 
		 * @param fos1
		 *            The outputstream which this bit stream writes to
		 */
		public BitOutputStream(OutputStream fos1)
		{
			fos = fos1;
			value = 0;
			count = 0;
			buffer = new byte[4096];
			buffCount = 0;
			masterCount = 0;
		}

		/**
		 * Writes the passed value (temp) to the file using the given number of bits
		 * 
		 * @param temp
		 *            the value to be written
		 * @param bits
		 *            the number if bits to write
		 * @throws IOException
		 */
		public void write(long temp, int bits) throws IOException
		{
			for (int j = 0, mask = 1; j < bits; j++, mask <<= 1)
			{
				value = value << 1;
				count++;
				if ((temp & mask) > 0)
				{
					value = value | 0x01;
				}
				addToBuffer();
			}
		}

		/**
		 * write a single bit to the stream
		 * 
		 * @param bit
		 *            The bit to write
		 * @throws IOException
		 */
		public void write(boolean bit) throws IOException
		{
			value = value << 1;
			count++;
			if (bit)
			{
				value = value | 0x01;
			}
			addToBuffer();

		}

		/**
		 * writes a single char (converted to a byte) to the output stream aligning with the next byte boundary
		 * 
		 * @param c
		 *            the char to write
		 * @throws IOException
		 */

		public void write(char c) throws IOException
		{
			flush();
			byte[] b = new byte[1];
			b[0] = (byte) c;
			fos.write(b);
			masterCount += 8;

		}

		/**
		 * adds bits stored in 'value' to a buffer which will be saved to a file if the current bit count since last storing into the buffer is less than 8 then return without adding it to the buffer
		 * 
		 * @throws IOException
		 */

		public void addToBuffer() throws IOException
		{
			masterCount++;

			if (count < 8)
				return;

			// byte temp=(byte) (value);
			buffer[buffCount] = (byte) (value);
			;
			buffCount++;

			if (buffCount == buffer.length)
			{
				fos.write(buffer, 0, buffCount);
				buffCount = 0;
			}
			value = 0;
			count = 0;
		}

		/**
		 * writes a single byte to the output stream aligning with the next byte boundary
		 * 
		 * @param b
		 *            the byte to write
		 * @throws IOException
		 */
		public void write(byte[] b) throws IOException
		{
			flush();
			fos.write(b);
		}

		/**
		 * writes a single byte to the output stream aligning with the next byte boundary
		 * 
		 * @param b
		 *            the byte to write
		 * @throws IOException
		 */
		public void write(byte b) throws IOException
		{
			flush();
			fos.write(b);
		}

		public void write(byte[] b, int start, int count) throws IOException
		{
			flush();

			fos.write(b, start, count);
		}

		/**
		 * align the output stream with the next byte boundary
		 * 
		 * @throws IOException
		 */

		public void flush() throws IOException
		{
			// pad out the last byte if necessary

			if (count > 0)
			{
				masterCount += (8 - count - 1);
				value = value << (8 - count);
				count = 8;
				addToBuffer();
			}
			if (buffCount > 0)
			{

				fos.write(buffer, 0, buffCount);
				buffCount = 0;
			}

		}

		/**
		 * close the output stream
		 * 
		 * @throws IOException
		 */

		public void close() throws IOException
		{
			flush();
			fos.close();
		}
	}

	static private final Random rand = new Random(0);

	static private final int IMAGE_DIMENSION_BITS = 16;
	static private final int LUMA_BLOCK_SIZE = 3; // 4 //4 //4 //4 //3
	static private final int LUMA_SAMPLED_DIMENSION_BLOCKS = 32 * 2;// 18 //30 //16 //16 //8
	static private final int LUMA_SAMPLED_DIMENSION = LUMA_BLOCK_SIZE * LUMA_SAMPLED_DIMENSION_BLOCKS;
	static private final int MIN_SAMPLED_DIMENSION = LUMA_SAMPLED_DIMENSION_BLOCKS / 4;
	static private final int MAX_SAMPLED_DIMENSION_SCALAR_BITS = 8;
	static private final int MAX_SAMPLED_DIMENSION_SCALAR = (int) Math.pow(2, MAX_SAMPLED_DIMENSION_SCALAR_BITS);

	static private final int LUMA_FILTER_BIT_DEPTH = 10;// 10;//16 //16 //12 //12
	static private final int LUMA_FILTER_COUNT = (int) Math.pow(2, LUMA_FILTER_BIT_DEPTH);
	static private final int LUMA_BLOCK_SAMPLE_SIZE = LUMA_FILTER_COUNT * 10; // 10000
	static private final int LUMA_FILTERS_IMAGE_DIMENSION = (int) (Math.ceil(Math.sqrt(LUMA_FILTER_COUNT)));

	static private final int CHROMA_BLOCK_SIZE = LUMA_BLOCK_SIZE * 2; // 8 //8 //8 //6
	static private final int CHROMA_SAMPLED_DIMENSION_BLOCKS = LUMA_SAMPLED_DIMENSION_BLOCKS / 2; // 15 //8 //8 //4
	static private final int CHROMA_SAMPLED_DIMENSION = CHROMA_BLOCK_SIZE * CHROMA_SAMPLED_DIMENSION_BLOCKS;
	static private final int CHROMA_FILTER_BIT_DEPTH = 10;// 12;//10 //10 //7 //7
	static private final int CHROMA_FILTER_COUNT = (int) Math.pow(2, CHROMA_FILTER_BIT_DEPTH);
	static private final int CHROMA_BLOCK_SAMPLE_SIZE = CHROMA_FILTER_COUNT * 10; // 10000
	static private final int CHROMA_FILTERS_IMAGE_DIMENSION = (int) (Math.ceil(Math.sqrt(CHROMA_FILTER_COUNT)));

	private static final int LUMA_SIMILARITY_BIT_DEPTH = LUMA_FILTER_BIT_DEPTH;// 0;//2;//5;
	private static final int LUMA_SIMILARITY_COUNT = (int) Math.pow(2, LUMA_SIMILARITY_BIT_DEPTH);

	private static final int CHROMA_SIMILARITY_BIT_DEPTH = CHROMA_FILTER_BIT_DEPTH;// 0;//2;//5;
	private static final int CHROMA_SIMILARITY_COUNT = (int) Math.pow(2, CHROMA_SIMILARITY_BIT_DEPTH);

	static private final int LUMA = 0;
	static private final int CHROMA_U = 1;
	static private final int CHROMA_V = 2;

	static private final float EIGHT_BIT_DIVISOR = 1.0F / 256;

	static private final int GENERATE_NONE_ENUM = 0;
	static private final int GENERATE_ONLY_IF_NEEDED_ENUM = 1;
	static private final int GENERATE_ALWAYS_ENUM = 2;
	private static int GENERATE = GENERATE_ONLY_IF_NEEDED_ENUM;
	private static final boolean CLUSTER_LUMA = true;
	private static final boolean CLUSTER_CHROMA = true;

	private static final int DESIRED_COMPRESSED_SIZE_BYTES = 4096;

	private static final boolean OUTPUT_SAMPLE_IMAGES = false;

	/**
	 * FilterManager manages the lumenosity and chromenosity filters including creation, writing and reading.
	 * @author default
	 *
	 */
	static final class FilterManager
	{
		private static final int MAX_SAMPLE_IMAGE_SHAPE_SELECTOR = 20;
		private static final int SAMPLE_IMAGE_SUBSHAPE_STROKE_DIVISOR = 20;
		private static final float MIN_SAMPLE_IMAGE_SUBSHAPE_STROKE = 0.5F;
		private static final int MIN_SAMPLE_IMAGE_SUBSHAPE_SIZE = 10;
		private static final int SAMPLE_IMAGE_COUNT = 25;
		Block[] lumaFilters;
		Block[] chromaFilters;
		int[][] lumaFilterSimilarityOrdering;
		int[][] chromaFilterSimilarityOrdering;

		private void loadFilters() throws IOException
		{
			lumaFilters = new Block[LUMA_FILTER_COUNT];
			chromaFilters = new Block[CHROMA_FILTER_COUNT];
			BufferedImage filtersImage = ImageIO.read(new File("data/images/working/lumaFilters_" + LUMA_BLOCK_SIZE + "_" + CHROMA_BLOCK_SIZE + "_" + LUMA_FILTER_BIT_DEPTH + "_" + CHROMA_FILTER_BIT_DEPTH + ".png"));
			for (int i = 0; i < LUMA_FILTER_COUNT; i++)
			{
				float[][][] pixels = convertToYUVImage(filtersImage.getSubimage((i % LUMA_FILTERS_IMAGE_DIMENSION) * (LUMA_BLOCK_SIZE + 2), (i / LUMA_FILTERS_IMAGE_DIMENSION) * (LUMA_BLOCK_SIZE + 2), LUMA_BLOCK_SIZE, LUMA_BLOCK_SIZE));
				lumaFilters[i] = new Block(pixels, 0, 0, LUMA_BLOCK_SIZE);
				lumaFilters[i].closestMatchingFilterId = i;
			}

			filtersImage = ImageIO.read(new File("data/images/working/chromaFilters_" + LUMA_BLOCK_SIZE + "_" + CHROMA_BLOCK_SIZE + "_" + LUMA_FILTER_BIT_DEPTH + "_" + CHROMA_FILTER_BIT_DEPTH + ".png"));
			for (int i = 0; i < CHROMA_FILTER_COUNT; i++)
			{
				float[][][] pixels = convertToYUVImage(filtersImage.getSubimage((i % CHROMA_FILTERS_IMAGE_DIMENSION) * (CHROMA_BLOCK_SIZE + 2), (i / CHROMA_FILTERS_IMAGE_DIMENSION) * (CHROMA_BLOCK_SIZE + 2), CHROMA_BLOCK_SIZE, CHROMA_BLOCK_SIZE));
				chromaFilters[i] = new Block(pixels, 0, 0, CHROMA_BLOCK_SIZE);
				chromaFilters[i].closestMatchingFilterId = i;
			}

		}

		private void loadSimilarityOrdering() throws IOException
		{
			DataInputStream dis = new DataInputStream(new BufferedInputStream(new FileInputStream(new File("data/images/working/ordering_" + LUMA_BLOCK_SIZE + "_" + CHROMA_BLOCK_SIZE + "_" + LUMA_FILTER_BIT_DEPTH + "_" + CHROMA_FILTER_BIT_DEPTH + ".dat"))));
			if (LUMA_SIMILARITY_BIT_DEPTH > 0)
			{
				lumaFilterSimilarityOrdering = new int[LUMA_FILTER_COUNT][];
				for (int i = 0; i < lumaFilterSimilarityOrdering.length; i++)
				{
					lumaFilterSimilarityOrdering[i] = new int[LUMA_SIMILARITY_COUNT];
					for (int j = 0; j < LUMA_SIMILARITY_COUNT; j++)
					{
						lumaFilterSimilarityOrdering[i][j] = dis.readInt();
					}
				}
			}

			if (CHROMA_SIMILARITY_BIT_DEPTH > 0)
			{
				chromaFilterSimilarityOrdering = new int[CHROMA_FILTER_COUNT][];
				for (int i = 0; i < chromaFilterSimilarityOrdering.length; i++)
				{
					chromaFilterSimilarityOrdering[i] = new int[CHROMA_SIMILARITY_COUNT];
					for (int j = 0; j < CHROMA_SIMILARITY_COUNT; j++)
					{
						chromaFilterSimilarityOrdering[i][j] = dis.readInt();
					}
				}
			}
			dis.close();

		}

		private void performSimilarityOrdering() throws IOException
		{

			System.out.println("Creating similarity ordered Lists...");

			DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(new File("data/images/working/ordering_" + LUMA_BLOCK_SIZE + "_" + CHROMA_BLOCK_SIZE + "_" + LUMA_FILTER_BIT_DEPTH + "_" + CHROMA_FILTER_BIT_DEPTH + ".dat"))));
			if (LUMA_SIMILARITY_BIT_DEPTH > 0)
			{
				lumaFilterSimilarityOrdering = new int[LUMA_FILTER_COUNT][];

				for (int i = 0; i < lumaFilterSimilarityOrdering.length; i++)
				{
					lumaFilterSimilarityOrdering[i] = order(lumaFilters, lumaFilters[i], LumaComparator.comparator, LUMA_SIMILARITY_COUNT);
				}

				for (int i = 0; i < lumaFilterSimilarityOrdering.length; i++)
				{
					for (int j = 0; j < LUMA_SIMILARITY_COUNT; j++)
					{
						dos.writeInt(lumaFilterSimilarityOrdering[i][j]);
					}
				}
			}

			if (CHROMA_SIMILARITY_BIT_DEPTH > 0)
			{

				chromaFilterSimilarityOrdering = new int[CHROMA_FILTER_COUNT][];

				for (int i = 0; i < chromaFilterSimilarityOrdering.length; i++)
				{
					chromaFilterSimilarityOrdering[i] = order(chromaFilters, chromaFilters[i], ChromaComparator.comparator, CHROMA_SIMILARITY_COUNT);
				}

				for (int i = 0; i < chromaFilterSimilarityOrdering.length; i++)
				{
					for (int j = 0; j < CHROMA_SIMILARITY_COUNT; j++)
					{
						dos.writeInt(chromaFilterSimilarityOrdering[i][j]);
					}
				}
			}
			dos.close();
			System.out.println("Creating similarity ordered Lists - Done");

		}

		/**
		 * Performs similarity ordering of the given filter type as compared with the given filter.
		 * 
		 * @return array of similarity ordered indices into the filter list.
		 */
		static private int[] order(Block[] filters, final Block comparisionFilter, final BlockComparator comparator, final int similarityCount)
		{
			final class Tuple implements Comparable<Tuple>
			{
				public Tuple(float difference, int id)
				{
					this.difference = difference;
					this.id = id;
				}

				float difference;
				int id;

				@Override
				public int compareTo(Tuple other)
				{
					float diff = difference - other.difference;
					return diff < 0 ? -1 : (diff > 0 ? 1 : 0);
				}

			}

			ArrayList<Tuple> tuples = new ArrayList<>();
			for (int i = 0; i < filters.length; i++)
			{
				tuples.add(new Tuple(comparator.calculateDifference(filters[i], comparisionFilter), i));
			}
			Collections.sort(tuples);

			int[] orderedIndecies = new int[similarityCount];

			for (int i = 0; i < similarityCount; i++)
			{
				orderedIndecies[i] = tuples.get(i).id;
			}

			return orderedIndecies;
		}

		private void generateFilters() throws IOException
		{
			System.out.println("First time running (no filters found). Generating Sample Images...");

			List<float[][][]> sampleImages = new ArrayList<float[][][]>();
			BufferedImage sampleImage = new BufferedImage(LUMA_SAMPLED_DIMENSION, LUMA_SAMPLED_DIMENSION, BufferedImage.TYPE_INT_RGB);
			BufferedImage image1 = new BufferedImage(1024, 1024, BufferedImage.TYPE_INT_RGB);

			// generate sample images and convert and down sample them into YUV images
			for (int j = 0; j < SAMPLE_IMAGE_COUNT; j++)
			{
				final int MAX_SHAPE_SIZE = MIN_SAMPLE_IMAGE_SUBSHAPE_SIZE + image1.getWidth() / 5;
				Graphics2D g = (Graphics2D) image1.getGraphics();

				Color colour1 = new Color(Color.HSBtoRGB(rand.nextFloat(), rand.nextFloat(), (float) Math.log(0.001 + rand.nextFloat() * 10)));
				Color colour2 = new Color(Color.HSBtoRGB(rand.nextFloat(), rand.nextFloat(), (float) Math.log(0.001 + rand.nextFloat() * 10)));

				GradientPaint gradientPaint = new GradientPaint(0, 0, colour1, 1024, 1024, colour2);
				g.setPaint(gradientPaint);

				g.fillRect(0, 0, image1.getWidth(), image1.getHeight());

				for (int i = 0; i < 200; i++)
				{
					colour1 = new Color(Color.HSBtoRGB(rand.nextFloat(), rand.nextFloat(), (float) Math.log(0.001 + rand.nextFloat() * 10)));
					colour2 = new Color(Color.HSBtoRGB(rand.nextFloat(), rand.nextFloat(), (float) Math.log(0.001 + rand.nextFloat() * 10)));

					g.setStroke(new BasicStroke(MIN_SAMPLE_IMAGE_SUBSHAPE_STROKE + rand.nextFloat() * image1.getWidth() / SAMPLE_IMAGE_SUBSHAPE_STROKE_DIVISOR));
					int x = rand.nextInt(image1.getWidth() + MAX_SHAPE_SIZE / 2) - MAX_SHAPE_SIZE / 2;
					int y = rand.nextInt(image1.getHeight() - MAX_SHAPE_SIZE) + MAX_SHAPE_SIZE / 2;
					int w = rand.nextInt(MAX_SHAPE_SIZE);
					int h = rand.nextInt(MAX_SHAPE_SIZE);

					gradientPaint = new GradientPaint(x, y, colour1, x + w, y + h, colour2);
					g.setPaint(gradientPaint);

					switch (rand.nextInt(MAX_SAMPLE_IMAGE_SHAPE_SELECTOR))
					{
					case 0:
						g.fillRect(x, y, w, h);
						break;
					case 1:
						g.drawRect(x, y, w, h);
						break;
					case 2:
						g.drawOval(x, y, w, h);
						break;
					case 3:
						g.fillOval(x, y, w, h);
						break;
					case 4:
						g.drawLine(x, y, x + w, y + h);
						break;
					default:
						Path2D prettyPoly = new Path2D.Double();
						boolean isFirst = true;
						for (int points = 0; points < 3 + rand.nextInt(MAX_SHAPE_SIZE); points++)
						{
							double xx = rand.nextDouble() * MAX_SHAPE_SIZE;
							double yy = rand.nextDouble() * MAX_SHAPE_SIZE;

							if (isFirst)
							{
								prettyPoly.moveTo(xx, yy);
								isFirst = false;
							}
							else
							{
								prettyPoly.lineTo(xx, yy);
							}
						}

						prettyPoly.closePath();
						g.translate(x, y);
						gradientPaint = new GradientPaint(0, 0, colour1, MAX_SHAPE_SIZE, MAX_SHAPE_SIZE, colour2);
						g.setPaint(gradientPaint);
						g.fill(prettyPoly);
						g.translate(-x, -y);
						break;
					}
				}

				if (OUTPUT_SAMPLE_IMAGES)
				{
					File sampleFile = new File("data/images/working/sample" + j + ".png");
					sampleFile.getParentFile().mkdirs();
					ImageIO.write(image1, "png", sampleFile);
				}

				sampleImage.getGraphics().drawImage(image1.getScaledInstance(LUMA_SAMPLED_DIMENSION, LUMA_SAMPLED_DIMENSION, BufferedImage.SCALE_AREA_AVERAGING), 0, 0, null);
				float[][][] pixels = convertToYUVImage(sampleImage);
				sampleImages.add(pixels);
			}

			System.out.println("Generating Sample Images Completed.");

			// perform k-clustering for lumenosity and 'chromanosity'
			lumaFilters = clusterLuma(sampleImages);
			chromaFilters = new Block[0];

			if (!(CHROMA_FILTER_COUNT == 0 || CHROMA_SAMPLED_DIMENSION == 0))
			{
				chromaFilters = clusterChroma(sampleImages);
			}

			// construct and save clustered lumenosity filters image
			BufferedImage lumaFiltersImage = new BufferedImage(LUMA_FILTERS_IMAGE_DIMENSION * (LUMA_BLOCK_SIZE + 2), LUMA_FILTERS_IMAGE_DIMENSION * (LUMA_BLOCK_SIZE + 2), BufferedImage.TYPE_INT_RGB);
			BufferedImage lumaFilterImage = new BufferedImage(LUMA_BLOCK_SIZE, LUMA_BLOCK_SIZE, BufferedImage.TYPE_INT_RGB);

			for (int i = 0; i < lumaFilters.length; i++)
			{
				renderYUV(lumaFilterImage, lumaFilters[i].pixels);
				lumaFiltersImage.getGraphics().drawImage(lumaFilterImage, (i % LUMA_FILTERS_IMAGE_DIMENSION) * (LUMA_BLOCK_SIZE + 2), (i / LUMA_FILTERS_IMAGE_DIMENSION) * (LUMA_BLOCK_SIZE + 2), null);
			}
			new File("data/images/working").mkdirs();
			ImageIO.write(lumaFiltersImage, "png", new File("data/images/working/lumaFilters_" + LUMA_BLOCK_SIZE + "_" + CHROMA_BLOCK_SIZE + "_" + LUMA_FILTER_BIT_DEPTH + "_" + CHROMA_FILTER_BIT_DEPTH + ".png"));

			// construct and save clustered 'chromanosity' filters image
			BufferedImage chromafiltersImage = new BufferedImage(CHROMA_FILTERS_IMAGE_DIMENSION * (CHROMA_BLOCK_SIZE + 2), CHROMA_FILTERS_IMAGE_DIMENSION * (CHROMA_BLOCK_SIZE + 2), BufferedImage.TYPE_INT_RGB);
			BufferedImage chromafilterImage = new BufferedImage(CHROMA_BLOCK_SIZE, CHROMA_BLOCK_SIZE, BufferedImage.TYPE_INT_RGB);

			for (int i = 0; i < chromaFilters.length; i++)
			{
				renderYUV(chromafilterImage, chromaFilters[i].pixels);
				chromafiltersImage.getGraphics().drawImage(chromafilterImage, (i % CHROMA_FILTERS_IMAGE_DIMENSION) * (CHROMA_BLOCK_SIZE + 2), (i / CHROMA_FILTERS_IMAGE_DIMENSION) * (CHROMA_BLOCK_SIZE + 2), null);
			}
			ImageIO.write(chromafiltersImage, "png", new File("data/images/working/chromaFilters_" + LUMA_BLOCK_SIZE + "_" + CHROMA_BLOCK_SIZE + "_" + LUMA_FILTER_BIT_DEPTH + "_" + CHROMA_FILTER_BIT_DEPTH + ".png"));

		}

		/**
		 * Performs K-clustering of samples blocks to produce an array of filter blocks.
		 * 
		 * @param sampleImages
		 *            the collection of YUV down sampled sample images to obtain random blocks from
		 * @param sampledDimension
		 *            the dimension of the down sampled image (width == height)
		 * @param blockSize
		 *            the dimension of the filter block (width == height)
		 * @param filterCount
		 *            the number of filters to cluster for
		 * @param blockSampleSize
		 *            the number of blocks to cluster
		 * @param comparator
		 *            the comparator to use when determining magnitude of difference between two blocks
		 * @return array of filters
		 */
		static private Block[] cluster(List<float[][][]> sampleImages, final int sampledDimension, final int blockSize, final int filterCount, final int blockSampleSize, BlockComparator comparator, boolean performCluster)
		{
			Block[] filters = new Block[filterCount];

			Block[] samples = new Block[blockSampleSize];
			for (int i = 0; i < blockSampleSize; i++)
			{
				samples[i] = new Block(sampleImages.get(rand.nextInt(sampleImages.size())), rand.nextInt(sampledDimension - blockSize), rand.nextInt(sampledDimension - blockSize), blockSize);
			}

			// select initial filters
			for (int i = 0; i < filterCount; i++)
			{
				filters[i] = new Block(samples[i]);
				filters[i].closestMatchingFilterId = i;
			}

			if (performCluster)
			{
				int iteration = 0;
				boolean converged = false;
				long stopTime = System.currentTimeMillis() + 1000 * 60 * 60;

				// iterate until all blocks have converged into clusters or timeout occurs
				while (!converged && System.currentTimeMillis() < stopTime)
				{
					iteration++;
					System.out.print("iteration: " + iteration);

					converged = true;
					int blockSwapClusterCount = 0;

					// identify closest cluster mid point for each sample block
					for (int i = 0; i < blockSampleSize; i++)
					{
						Block block = samples[i];
						float bestDifference = Float.MAX_VALUE;
						int bestFilterIndex = -1;

						for (int j = 0; j < filterCount; j++)
						{
							float difference = comparator.calculateDifference(block, filters[j]);

							if (difference < bestDifference)
							{
								bestDifference = difference;
								bestFilterIndex = j;
							}
						}

						// sample block has changed to a different cluster or the assigned cluster's collection has been updated
						if (bestDifference != block.closestDifference || bestFilterIndex != block.closestMatchingFilterId)
						{
							blockSwapClusterCount++;
							converged = false;
							block.closestMatchingFilterId = bestFilterIndex;
							block.closestDifference = bestDifference;
						}
					}

					if (!converged)
					{
						int orphanedClusterCount = 0;
						// determine new cluster centre (i.e. filter)
						for (int j = 0; j < filterCount; j++)
						{
							int clusterSize = 0;
							Block filter = filters[j];
							filter.zeroise();
							for (int i = 0; i < blockSampleSize; i++)
							{
								if (samples[i].closestMatchingFilterId == j)
								{
									clusterSize++;
									filter.add(samples[i]);
								}
							}

							// the cluster no longer has any members... lets choose another random sample to be our this cluster centre
							if (clusterSize == 0)
							{
								orphanedClusterCount++;
								filter = new Block(samples[rand.nextInt(blockSampleSize)]);
								filter.closestMatchingFilterId = j;
								filters[j] = filter;
							}
							else
							{
								filter.divide(clusterSize);
							}

						}

						if (orphanedClusterCount > 0)
						{
							System.out.print(" orphanedClusterCount: " + orphanedClusterCount);
						}
					}

					if (blockSwapClusterCount > 0)
					{
						System.out.print(" blockSwapClusterCount: " + blockSwapClusterCount);
					}
					System.out.println();
				}
				System.out.println("Clustering complete");
			}
			return filters;
		}

		/**
		 * Perform k-clustering based on pixel lumenosity to derive lumenosity filters
		 * 
		 * @param sampleImages
		 *            the collection of YUV down sampled sample images to obtain random blocks from
		 * @return array of filters
		 */
		static private Block[] clusterLuma(List<float[][][]> sampleImages)
		{
			if (CLUSTER_LUMA)
			{
				System.out.println("K-Cluster Luma filters...");
			}
			return cluster(sampleImages, LUMA_SAMPLED_DIMENSION, LUMA_BLOCK_SIZE, LUMA_FILTER_COUNT, LUMA_BLOCK_SAMPLE_SIZE, LumaComparator.comparator, CLUSTER_LUMA);
		}

		/**
		 * Perform k-clustering based on pixel 'chromanosity' to derive 'chromanosity' filters
		 * 
		 * @param sampleImages
		 *            the collection of YUV down sampled sample images to obtain random blocks from
		 * @return array of filters
		 */
		static private Block[] clusterChroma(List<float[][][]> sampleImages)
		{
			if (CLUSTER_CHROMA)
			{
				System.out.println("K-Cluster Chroma filters...");
			}

			return cluster(sampleImages, CHROMA_SAMPLED_DIMENSION, CHROMA_BLOCK_SIZE, CHROMA_FILTER_COUNT, CHROMA_BLOCK_SAMPLE_SIZE, ChromaComparator.comparator, CLUSTER_CHROMA);
		}

		public static FilterManager create() throws IOException
		{
			FilterManager filterManager = new FilterManager();
			filterManager.generateFilters();
			filterManager.performSimilarityOrdering();
			return filterManager;
		}

		public static FilterManager load() throws IOException
		{
			FilterManager filterManager = new FilterManager();
			filterManager.loadFilters();
			filterManager.loadSimilarityOrdering();
			return filterManager;
		}

	}

	/**
	 * A square block holding YUV pixels
	 */
	public static final class Block
	{
		float[][][] pixels;

		int closestMatchingFilterId = -1;
		float closestDifference = -1;
		final int blockSize;

		public Block(float[][][] sourceImage, int x, int y, final int blockSize)
		{
			this.blockSize = blockSize;
			pixels = new float[blockSize][blockSize][3];
			for (int i = 0; i < blockSize; i++)
			{
				for (int j = 0; j < blockSize; j++)
				{
					float[] pixel = sourceImage[x + j][y + i];
					pixels[j][i][LUMA] = pixel[LUMA];
					pixels[j][i][CHROMA_U] = pixel[CHROMA_U];
					pixels[j][i][CHROMA_V] = pixel[CHROMA_V];
				}
			}
		}

		/**
		 * Copy Constructor
		 * 
		 * @param other
		 */
		public Block(Block other)
		{
			this.blockSize = other.blockSize;
			pixels = new float[blockSize][blockSize][3];
			for (int i = 0; i < blockSize; i++)
			{
				for (int j = 0; j < blockSize; j++)
				{
					pixels[j][i][LUMA] = other.pixels[j][i][LUMA];
					pixels[j][i][CHROMA_U] = other.pixels[j][i][CHROMA_U];
					pixels[j][i][CHROMA_V] = other.pixels[j][i][CHROMA_V];
				}
			}
		}

		/**
		 * sets all pixel colour components to 0
		 */
		public void zeroise()
		{
			pixels = new float[blockSize][blockSize][3];
		}

		/**
		 * adds each pixel's colour components to this block's corresponding pixel colour components
		 * 
		 * @param other
		 *            the other block to add
		 */
		public void add(Block other)
		{
			for (int i = 0; i < blockSize; i++)
			{
				for (int j = 0; j < blockSize; j++)
				{
					pixels[j][i][LUMA] += other.pixels[j][i][LUMA];
					pixels[j][i][CHROMA_U] += other.pixels[j][i][CHROMA_U];
					pixels[j][i][CHROMA_V] += other.pixels[j][i][CHROMA_V];
				}
			}
		}

		/**
		 * divides all pixels colour components by the provided divisor
		 * 
		 * @param divisor
		 */
		public void divide(float divisor)
		{
			for (int i = 0; i < blockSize; i++)
			{
				for (int j = 0; j < blockSize; j++)
				{
					pixels[j][i][LUMA] /= divisor;
					pixels[j][i][CHROMA_U] /= divisor;
					pixels[j][i][CHROMA_V] /= divisor;
				}
			}
		}

	}

	/**
	 * Abstract Class providing the method signature to calculate the difference between blocks
	 */
	public static abstract class BlockComparator
	{
		/**
		 * Calculates and returns the magnitude of difference between the two provided blocks. The result has only has meaning when comparing against other results obtained by calling this method.
		 * 
		 * @param block1
		 * @param block2
		 * @return the magnitude of difference between the two provided blocks
		 */
		abstract public float calculateDifference(Block block1, Block block2);
	}

	/**
	 * Concrete implementation of BlockComparator with the difference calculated based on lumenosity
	 */
	public static abstract class LumaComparator extends BlockComparator
	{
		public static final LumaComparator comparator = new LumaComparator()
		{
			public float calculateDifference(Block block1, Block block2)
			{
				float diffMetric = 0;
				for (int i = 0; i < LUMA_BLOCK_SIZE; i++)
				{
					for (int j = 0; j < LUMA_BLOCK_SIZE; j++)
					{
						diffMetric += (block1.pixels[j][i][LUMA] - block2.pixels[j][i][LUMA]) * (block1.pixels[j][i][LUMA] - block2.pixels[j][i][LUMA]);
					}
				}
				return diffMetric;
			}
		};
	}

	/**
	 * Concrete implementation of BlockComparator with the difference calculated based on 'chromanosity'
	 */
	public static abstract class ChromaComparator extends BlockComparator
	{
		public static final ChromaComparator comparator = new ChromaComparator()
		{
			public float calculateDifference(Block block1, Block block2)
			{
				float diff;
				float diffMetric = 0;
				for (int i = 0; i < CHROMA_BLOCK_SIZE; i++)
				{
					for (int j = 0; j < CHROMA_BLOCK_SIZE; j++)
					{
						diff = (block1.pixels[j][i][CHROMA_U] - block2.pixels[j][i][CHROMA_U]);
						diffMetric += diff * diff * diff * diff;
						diff = (block1.pixels[j][i][CHROMA_V] - block2.pixels[j][i][CHROMA_V]);
						diffMetric += diff * diff * diff * diff;
					}
				}
				return diffMetric;
			}
		};
	}

	public static void printCommandLineOptions()
	{
		System.out.println("Usage: \n" + 
				"       For single image compression: java CompressAnImageToA4kibPreview -c <INPUT IMAGE> [<COMPRESSED IMAGE>]\n" + 
				"       For multiple image compression: java CompressAnImageToA4kibPreview -c <INPUT IMAGES DIR> [<COMPRESSED IMAGE DIR>]\n" + 
				"       For single image decompression: java CompressAnImageToA4kibPreview -d <COMPRESSED IMAGE> [<DECOMPRESSED IMAGE>\n" + 
				"       For multiple image decompression: java CompressAnImageToA4kibPreview -d <COMPRESSED IMAGE DIR> [<DECOMPRESSED IMAGES DIR>]\n" + 
				"\n" + 
				"If optional parameters are not set then defaults will be used:\n" + 
				"       For single image compression, compressed image will be created in same directory are input image and have '.compressed' file extension.\n"	+ 
				"       For multiple image compression, compressed images will be created in a new 'out' sub directory of <INPUT IMAGES DIR> and have '.compressed' file extensions.\n" + 
				"       For single image decompression, decompressed image will be created in same directory are input image and have '.out.png' file extension.\n"	+ 
				"       For multiple image decompression, decompressed images will be created a new 'out' sub directory of <COMPRESSED IMAGE DIR> and have '.png' file extensions.\n" + 
				"\n" + 
				"The first time this application is run, required files will be generated and saved in a directory relative to execution working dir. This may take a few minutes.");
	}

	public static void main(String[] args) throws Exception
	{
		if (args.length < 2 || args.length > 3)
		{
			printCommandLineOptions();
			return;
		}

		File filterFile = new File("data/images/working/lumaFilters_" + LUMA_BLOCK_SIZE + "_" + CHROMA_BLOCK_SIZE + "_" + LUMA_FILTER_BIT_DEPTH + "_" + CHROMA_FILTER_BIT_DEPTH + ".png");
		FilterManager filters = (GENERATE == GENERATE_ALWAYS_ENUM || (GENERATE == GENERATE_ONLY_IF_NEEDED_ENUM && !filterFile.exists())) ? FilterManager.create() : FilterManager.load();

		File outputFile;
		File inputFile = new File(args[1]);

		boolean compress = args[0].equals("-c");

		if (compress)
		{
			if (inputFile.exists())
			{
				if (inputFile.isDirectory())
				{
					if (args.length == 3)
					{
						outputFile = new File(args[2]);
						if (outputFile.exists() && outputFile.isFile())
						{
							System.out.println("ERROR: " + outputFile + " is not a directory.\n\n");
							printCommandLineOptions();
							return;
						}
					}
					else
					{
						outputFile = new File(args[1] + "/out");
						if (outputFile.exists() && outputFile.isFile())
						{
							System.out.println("ERROR: " + outputFile + " is not a directory.\n\n");
							printCommandLineOptions();
							return;
						}
					}

					outputFile.mkdirs();
				}
				else
				{
					if (args.length == 3)
					{
						outputFile = new File(args[2]);
						if (outputFile.exists() && outputFile.isDirectory())
						{
							System.out.println("ERROR: " + outputFile + " is a directory.\n\n");
							printCommandLineOptions();
							return;
						}
					}
					else
					{
						outputFile = new File(args[1] + ".out.compressed");
						if (outputFile.exists() && outputFile.isDirectory())
						{
							System.out.println("ERROR: " + outputFile + " is a directory.\n\n");
							printCommandLineOptions();
							return;
						}
					}
				}
			}
			else
			{
				System.out.println("ERROR: " + inputFile + " does not exist.\n\n");
				printCommandLineOptions();
				return;
			}

			compress(inputFile, outputFile, filters);
		}
		else
		{
			if (inputFile.exists())
			{
				if (inputFile.isDirectory())
				{
					if (args.length == 3)
					{
						outputFile = new File(args[2]);
						if (outputFile.exists() && outputFile.isFile())
						{
							System.out.println("ERROR: " + outputFile + " is not a directory.\n\n");
							printCommandLineOptions();
							return;
						}
					}
					else
					{
						outputFile = new File(args[1] + "/out");
						if (outputFile.exists() && outputFile.isFile())
						{
							System.out.println("ERROR: " + outputFile + " is not a directory.\n\n");
							printCommandLineOptions();
							return;
						}
					}
					outputFile.mkdirs();
				}
				else
				{
					if (args.length == 3)
					{
						outputFile = new File(args[2]);
						if (outputFile.exists() && outputFile.isDirectory())
						{
							System.out.println("ERROR: " + outputFile + " is a directory.\n\n");
							printCommandLineOptions();
							return;
						}
					}
					else
					{
						outputFile = new File(args[1] + ".out.png");
						if (outputFile.exists() && outputFile.isDirectory())
						{
							System.out.println("ERROR: " + outputFile + " is a directory.\n\n");
							printCommandLineOptions();
							return;
						}
					}
				}
			}
			else
			{
				System.out.println("ERROR: " + inputFile + " does not exist.\n\n");
				printCommandLineOptions();
				return;
			}

			decompress(inputFile, outputFile, filters);
		}
	}

	/**
	 * Compresses the input image(s) and writes to origOutputFile
	 * @param origInputFile
	 * @param origOutputFile
	 * @param filters
	 * @throws Exception
	 */
	private static void compress(File origInputFile, File origOutputFile, FilterManager filters) throws Exception
	{
		String[] files = new String[] { origInputFile.getAbsolutePath() };
		if (origInputFile.isDirectory())
		{
			List<String> list = new ArrayList<String>();
			for (File file : origInputFile.listFiles())
			{
				list.add(file.getAbsolutePath());
			}
			files = list.toArray(new String[0]);
		}

		String outputDir = origOutputFile.getAbsolutePath();

		for (String inputFileString : files)
		{
			ByteArrayOutputStream defBaos = new ByteArrayOutputStream();
			int compressedSize = 0;
			int sampledDimensionScalar = MIN_SAMPLED_DIMENSION;

			File inputFile = new File(inputFileString);
			
			String outputFileString = (origInputFile.isFile() ? origOutputFile : new File(outputDir + File.separator + inputFile.getName())).getAbsolutePath() + ".compressed";
			File outputFile = new File(outputFileString);
			if (inputFile.isFile())
			{
				System.out.println("Compressing "+inputFile.getAbsolutePath()+"...");
				BufferedImage inputImage = ImageIO.read(inputFile);

				outputFile.getParentFile().mkdirs();

				while (compressedSize < DESIRED_COMPRESSED_SIZE_BYTES && sampledDimensionScalar < MAX_SAMPLED_DIMENSION_SCALAR)
				{
					sampledDimensionScalar += 1;
					if (compressedSize > 0)
					{

						System.out.println("Compressed Size: " + compressedSize + " Scalar: " + (sampledDimensionScalar - 1));

						byte[] data = defBaos.toByteArray();
						defBaos.reset();
						FileOutputStream fos = new FileOutputStream(outputFile);
						fos.write(data);
						fos.close();
					}

					int previousFrameChromaFilter = 0;
					int previousFrameLumaFilter = 0;

					ByteArrayOutputStream baos = new ByteArrayOutputStream();
					BitOutputStream bos = new BitOutputStream(baos);

					// Down sample input image

					int sampledDimension = CHROMA_BLOCK_SIZE * sampledDimensionScalar;
					BufferedImage scaledImage = new BufferedImage(sampledDimension, sampledDimension, BufferedImage.TYPE_INT_RGB);
					scaledImage.getGraphics().drawImage(inputImage.getScaledInstance(sampledDimension, sampledDimension, BufferedImage.SCALE_AREA_AVERAGING), 0, 0, null);
					float[][][] pixels = convertToYUVImage(scaledImage);

					// save image dimensions
					bos.write(inputImage.getWidth(), IMAGE_DIMENSION_BITS);
					bos.write(inputImage.getHeight(), IMAGE_DIMENSION_BITS);
					bos.write(sampledDimensionScalar, MAX_SAMPLED_DIMENSION_SCALAR_BITS);

					// match sampled image blocks' lumenosity to filters...
					float[][][] categorisedPixels = new float[sampledDimension][sampledDimension][3];

					for (int i = 0; i < sampledDimension; i += LUMA_BLOCK_SIZE)
					{
						for (int j = 0; j < sampledDimension; j += LUMA_BLOCK_SIZE)
						{
							Block block = new Block(pixels, j, i, LUMA_BLOCK_SIZE);
							Block leastDifferenceLumaFilter = null;
							float leastDifference = Float.MAX_VALUE;
							float difference;
							for (Block filter : filters.lumaFilters)
							{
								difference = LumaComparator.comparator.calculateDifference(filter, block);

								if (difference < leastDifference)
								{
									leastDifference = difference;
									leastDifferenceLumaFilter = filter;
								}
							}

							// save luma block
							if (LUMA_SIMILARITY_BIT_DEPTH == 0)
							{
								bos.write(leastDifferenceLumaFilter.closestMatchingFilterId, LUMA_FILTER_BIT_DEPTH);
							}
							else
								out:
								{
									int[] lumaFilterSimilarityOrdering = filters.lumaFilterSimilarityOrdering[previousFrameLumaFilter];
									for (int k = 0; k < LUMA_SIMILARITY_COUNT; k++)
										if (lumaFilterSimilarityOrdering[k] == leastDifferenceLumaFilter.closestMatchingFilterId)
										{
											if (LUMA_FILTER_COUNT > LUMA_SIMILARITY_COUNT)
												bos.write(true);
											bos.write(k, LUMA_SIMILARITY_BIT_DEPTH);
											break out;
										}
									if (LUMA_FILTER_COUNT > LUMA_SIMILARITY_COUNT)
										bos.write(false);
									bos.write(leastDifferenceLumaFilter.closestMatchingFilterId, LUMA_FILTER_BIT_DEPTH);
								}
							previousFrameLumaFilter = leastDifferenceLumaFilter.closestMatchingFilterId;

							// copy matched filter's lumenosity into corresponding output image's block
							for (int y = 0; y < LUMA_BLOCK_SIZE; y++)
							{
								for (int x = 0; x < LUMA_BLOCK_SIZE; x++)
								{
									categorisedPixels[j + x][i + y][LUMA] = leastDifferenceLumaFilter.pixels[x][y][LUMA];

								}
							}
						}
					}

					// match sampled image blocks' 'chromanosity' to filters...
					for (int i = 0; i < sampledDimension; i += CHROMA_BLOCK_SIZE)
					{
						for (int j = 0; j < sampledDimension; j += CHROMA_BLOCK_SIZE)
						{
							Block block = new Block(pixels, j, i, CHROMA_BLOCK_SIZE);

							Block leastDifferenceChromaFilter = null;
							float leastDifference = Float.MAX_VALUE;
							float difference;
							for (Block filter : filters.chromaFilters)
							{
								difference = ChromaComparator.comparator.calculateDifference(filter, block);

								if (difference < leastDifference)
								{
									leastDifference = difference;
									leastDifferenceChromaFilter = filter;
								}
							}

							// save chroma block
							if (CHROMA_SIMILARITY_BIT_DEPTH == 0)
							{
								bos.write(leastDifferenceChromaFilter.closestMatchingFilterId, CHROMA_FILTER_BIT_DEPTH);
							}
							else
								out:
								{
									int[] chromaFilterSimilarityOrdering = filters.chromaFilterSimilarityOrdering[previousFrameChromaFilter];
									for (int k = 0; k < CHROMA_SIMILARITY_COUNT; k++)
										if (chromaFilterSimilarityOrdering[k] == leastDifferenceChromaFilter.closestMatchingFilterId)
										{
											if (CHROMA_FILTER_COUNT > CHROMA_SIMILARITY_COUNT)
												bos.write(true);
											bos.write(k, CHROMA_SIMILARITY_BIT_DEPTH);
											break out;
										}
									if (CHROMA_FILTER_COUNT > CHROMA_SIMILARITY_COUNT)
										bos.write(false);
									bos.write(leastDifferenceChromaFilter.closestMatchingFilterId, CHROMA_FILTER_BIT_DEPTH);
								}
							previousFrameChromaFilter = leastDifferenceChromaFilter.closestMatchingFilterId;

							// copy matched filter's 'chromanosity' into corresponding output image's block
							for (int y = 0; y < CHROMA_BLOCK_SIZE; y++)
							{
								for (int x = 0; x < CHROMA_BLOCK_SIZE; x++)
								{
									categorisedPixels[j + x][i + y][CHROMA_U] = leastDifferenceChromaFilter.pixels[x][y][CHROMA_U];
									categorisedPixels[j + x][i + y][CHROMA_V] = leastDifferenceChromaFilter.pixels[x][y][CHROMA_V];
								}
							}
						}
					}

					bos.close();

					DeflaterOutputStream deflater = new DeflaterOutputStream(defBaos, new Deflater(Deflater.BEST_COMPRESSION));
					deflater.write(baos.toByteArray());
					deflater.close();
					compressedSize = defBaos.size();

				}
				System.out.println("Compressed "+inputFile.getAbsolutePath()+".");
			}
		}
	}

	/**
	 * Decompresses the input image(s) and writes to origOutputFile
	 */
	private static void decompress(File origInputFile, File origOutputFile, FilterManager filters) throws Exception
	{
		String[] files = new String[] { origInputFile.getAbsolutePath() };
		if (origInputFile.isDirectory())
		{
			List<String> list = new ArrayList<String>();
			for (File file : origInputFile.listFiles())
			{
				list.add(file.getAbsolutePath());
			}
			files = list.toArray(new String[0]);
		}

		String outputDir = origOutputFile.getAbsolutePath();

		for (String inputFileString : files)
		{

			File inputFile = new File(inputFileString);
			if (inputFile.isFile())
			{
				File decompressedFile = origInputFile.isFile() ? origOutputFile : new File(outputDir + File.separator + inputFile.getName()+".png");
				filters = FilterManager.load();
				decodeFrame(decompressedFile, filters, new FileInputStream(inputFile));
			}
		}
	}

	static void decodeFrame(File outputFile, FilterManager filters, InputStream is) throws IOException
	{

		InflaterInputStream inflater = new InflaterInputStream(is);
		BitInputStream bis = new BitInputStream(inflater, 8);

		int previousFrameLumaFilter = 0;
		int previousFrameChromaFilter = 0;

		int width = (int) bis.read(IMAGE_DIMENSION_BITS);
		int height = (int) bis.read(IMAGE_DIMENSION_BITS);
		int sampledDimensionScalar = (int) bis.read(MAX_SAMPLED_DIMENSION_SCALAR_BITS);
		int sampledDimension = CHROMA_BLOCK_SIZE * sampledDimensionScalar;

		float[][][] pixels = new float[sampledDimension][sampledDimension][3];

		for (int i = 0; i < sampledDimension; i += LUMA_BLOCK_SIZE)
		{
			for (int j = 0; j < sampledDimension; j += LUMA_BLOCK_SIZE)
			{
				int filterId;
				if (LUMA_SIMILARITY_BIT_DEPTH == 0 || (LUMA_FILTER_COUNT > LUMA_SIMILARITY_COUNT && !bis.read()))
				{
					filterId = (int) bis.read(LUMA_FILTER_BIT_DEPTH);
				}
				else
				{
					filterId = filters.lumaFilterSimilarityOrdering[previousFrameLumaFilter][(int) bis.read(LUMA_SIMILARITY_BIT_DEPTH)];
				}
				previousFrameLumaFilter = filterId;
				Block filter = filters.lumaFilters[filterId];

				// copy matched filter's lumenosity into corresponding output image's block
				for (int y = 0; y < LUMA_BLOCK_SIZE; y++)
				{
					for (int x = 0; x < LUMA_BLOCK_SIZE; x++)
					{
						pixels[j + x][i + y][LUMA] = filter.pixels[x][y][LUMA];
					}
				}
			}
		}

		// match sampled image blocks' 'chromanosity' to filters...
		for (int i = 0; i < sampledDimension; i += CHROMA_BLOCK_SIZE)
		{
			for (int j = 0; j < sampledDimension; j += CHROMA_BLOCK_SIZE)
			{
				int filterId;
				if (CHROMA_SIMILARITY_BIT_DEPTH == 0 || (CHROMA_FILTER_COUNT > CHROMA_SIMILARITY_COUNT && !bis.read()))
				{
					filterId = (int) bis.read(CHROMA_FILTER_BIT_DEPTH);
				}
				else
				{
					filterId = filters.chromaFilterSimilarityOrdering[previousFrameChromaFilter][(int) bis.read(CHROMA_SIMILARITY_BIT_DEPTH)];
				}
				previousFrameChromaFilter = filterId;
				Block filter = filters.chromaFilters[filterId];

				// copy matched filter's 'chromanosity' into corresponding output image's block
				for (int y = 0; y < CHROMA_BLOCK_SIZE; y++)
				{
					for (int x = 0; x < CHROMA_BLOCK_SIZE; x++)
					{
						pixels[j + x][i + y][CHROMA_U] = filter.pixels[x][y][CHROMA_U];
						pixels[j + x][i + y][CHROMA_V] = filter.pixels[x][y][CHROMA_V];
					}
				}
			}
		}

		// render the scaled output image
		BufferedImage yuvImage = new BufferedImage(sampledDimension, sampledDimension, BufferedImage.TYPE_INT_RGB);
		renderYUV(yuvImage, pixels);

		// save the output image, resized to the input image's dimensons
		ImageIO.write(blurResize(yuvImage, width, height), "png", outputFile);
//		BufferedImage scaledImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
//		scaledImage.getGraphics().drawImage(yuvImage.getScaledInstance(width, height, Image.SCALE_FAST), 0, 0, null);
//		ImageIO.write(scaledImage, "png", new File(outputFile.getAbsolutePath() + ".nonBlurred.png"));
		System.out.println("Decompressed "+outputFile.getAbsolutePath());
	}

	/**
	 * Converts the given buffered image into a 3-dimensional array of YUV pixels
	 * 
	 * @param image
	 *            the buffered image to convert
	 * @return 3-dimensional array of YUV pixels
	 */
	static private float[][][] convertToYUVImage(BufferedImage image)
	{
		final int width = image.getWidth();
		final int height = image.getHeight();
		float[][][] yuv = new float[width][height][3];
		for (int y = 0; y < height; y++)
		{
			for (int x = 0; x < width; x++)
			{
				int rgb = image.getRGB(x, y);
				yuv[x][y] = rgb2yuv(rgb);
			}
		}
		return yuv;
	}

	/**
	 * Renders the given YUV image into the given buffered image.
	 * 
	 * @param image
	 *            the buffered image to render to
	 * @param pixels
	 *            the YUV image to render.
	 * @param dimension
	 *            the
	 */
	static private void renderYUV(BufferedImage image, float[][][] pixels)
	{
		final int height = pixels.length;
		final int width = pixels[0].length;
		int rgb;

		for (int y = 0; y < height; y++)
		{
			for (int x = 0; x < width; x++)
			{

				rgb = yuv2rgb(pixels[x][y]);
				image.setRGB(x, y, rgb);
			}
		}
	}

	/**
	 * Converts a RGB pixel into a YUV pixel
	 * 
	 * @param rgb
	 *            a pixel encoded as 24 bit RGB
	 * @return array representing a pixel. Consisting of Y,U and V components
	 */
	static float[] rgb2yuv(int rgb)
	{
		float red = EIGHT_BIT_DIVISOR * ((rgb >> 16) & 0xFF);
		float green = EIGHT_BIT_DIVISOR * ((rgb >> 8) & 0xFF);
		float blue = EIGHT_BIT_DIVISOR * (rgb & 0xFF);

		float Y = 0.299F * red + 0.587F * green + 0.114F * blue;
		float U = (blue - Y) * 0.565F;
		float V = (red - Y) * 0.713F;

		return new float[] { Y, U, V };
	}

	/**
	 * Converts a YUV pixel into a RGB pixel
	 * 
	 * @param yuv
	 *            array representing a pixel. Consisting of Y,U and V components
	 * @return a pixel encoded as 24 bit RGB
	 */
	static int yuv2rgb(float[] yuv)
	{
		int red = (int) ((yuv[0] + 1.403 * yuv[2]) * 256);
		int green = (int) ((yuv[0] - 0.344 * yuv[1] - 0.714 * yuv[2]) * 256);
		int blue = (int) ((yuv[0] + 1.77 * yuv[1]) * 256);

		// clamp to 0-255 range
		red = red < 0 ? 0 : red > 255 ? 255 : red;
		green = green < 0 ? 0 : green > 255 ? 255 : green;
		blue = blue < 0 ? 0 : blue > 255 ? 255 : blue;

		return (red << 16) | (green << 8) | blue;
	}

	/**
	 * Blurs an image using a 3x3 weighted kernel.
	 * 
	 * @param image
	 *            the image to blur from
	 * @return the blurred image
	 */
	public static BufferedImage blurImage(BufferedImage image)
	{
		float[] blurKernel = { 0.0375f, 0.0625f, 0.0375f, 0.0625f, 0.6f, 0.0625f, 0.0375f, 0.0625f, 0.0375f };

		Map<Key, Object> map = new HashMap<Key, Object>();

		map.put(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);

		map.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
		map.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

		RenderingHints hints = new RenderingHints(map);
		BufferedImageOp op = new ConvolveOp(new Kernel(3, 3, blurKernel), ConvolveOp.EDGE_NO_OP, hints);
		return op.filter(image, null);
	}

	/**
	 * Resizes the input image to the given width and height.
	 *
	 * Algorithm: 1. check to see if doubling image will exceed desired width or height, if so then goto 5 2. resize the image so that it is double the width and height it was before. 3. blur the image 4. goto 1 5. resize image to desired with and height
	 *
	 * @param image
	 *            the image to resize
	 * @param newWidth
	 *            the desired width of the resized image
	 * @param newHeight
	 *            the desired height of the resized image
	 * @return a new resized image
	 */
	public static BufferedImage blurResize(BufferedImage image, int newWidth, int newHeight)
	{

		int width = image.getWidth();
		int height = image.getHeight();

		while (width * 2 <= newWidth && height * 2 <= newHeight)
		{
			BufferedImage newImage = new BufferedImage(width * 2, height * 2, BufferedImage.TYPE_INT_RGB);
			newImage.getGraphics().drawImage(image.getScaledInstance(width * 2, height * 2, Image.SCALE_AREA_AVERAGING), 0, 0, null);

			image = blurImage(newImage);
			width = image.getWidth();
			height = image.getHeight();
		}

		BufferedImage newImage = new BufferedImage(newWidth, newHeight, BufferedImage.TYPE_INT_RGB);
		newImage.getGraphics().drawImage(image.getScaledInstance(newWidth, newHeight, Image.SCALE_AREA_AVERAGING), 0, 0, null);
		return newImage;
	}
}