Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
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;
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.