Huffman code for image compression - Java - encoding

Question

Since I started my Codification Theory course, I've started to feel curious about practical implementations of information theory algorithms. I've researched about Huffman code and how this is used for data compress. I am specially curious about building an image (JPG, JPEG) compressor using Huffman codes but I'm struggling in the implementation.
My idea for this program goes like this:
1. Implement a HuffmanCode class, which is used to encode and decode a string input (Find the char frequency for all characters in string, build Huffman tree, generate Huffman code, etc.). I found this implementation "here".
2. Having the Huffman code implementation, I read an image input and convert it to a byte array. Then, I use this byte array to build a string having all of these bytes. Now, I apply the Huffman code for the previous string.
3. The result of the previous step is a binary string, then I convert this binary string to a byte array.
4. Finally, write the corresponding image to the previous byte array and output.
Following this reasoning, I got a RasterFormatException : Data array too small (should be > 749999 ). I've tried others implementations for writing the image but I am still getting some other Exceptions such as image == null exception.
I was wondering if someone has a better approach for building this program, or if I am missing something related to writing/reading images in Java (I'm new with this tools), or if I am misunderstanding something related to Huffman codes.
The HuffmanCode class is the following (I made some changes):
public class HuffmanCode {
public static void main(String[] args){
String test = "AndersonAndresLlanosQuintero";
System.out.println(countFrequency(test));
}
// Clase nodo para las construcción del árbol.
class HuffmanNode{
public int frecuencia;
public char caracter;
public HuffmanNode leftNode;
public HuffmanNode rightNode;
public HuffmanNode(){}
public int getFrecuencia() {
return frecuencia;
}
public void setFrecuencia(int frecuencia) {
this.frecuencia = frecuencia;
}
public char getCaracter() {
return caracter;
}
public void setCaracter(char caracter) {
this.caracter = caracter;
}
public HuffmanNode getLeftNode() {
return leftNode;
}
public void setLeftNode(HuffmanNode leftNode) {
this.leftNode = leftNode;
}
public HuffmanNode getRightNode() {
return rightNode;
}
public void setRightNode(HuffmanNode rightNode) {
this.rightNode = rightNode;
}
}
// Clase comparadora para saber cuando un nodo está por encima de otro.
class HuffmanComparator implements Comparator<HuffmanNode> {
public int compare(HuffmanNode x, HuffmanNode y) {
return x.frecuencia - y.frecuencia;
}
}
/* Procedemos a implementar el algoritmo : */
/* Necesitaremos la raíz del árbol de Huffman y un Map para
hacer match entre un símbol y su frecuencia de aparición.
*/
private Map<Character,String> charToBinaryMap;
private HuffmanNode root;
private String nuevaSalida;
public HuffmanNode getRoot(){
return this.root;
}
public String getNuevaSalida(){
return this.nuevaSalida;
}
public HuffmanCode(){
this.root = null;
this.charToBinaryMap = new HashMap<Character, String>();
}
public HuffmanNode getTree(){
return this.root;
}
/* Teniendo el código de Huffman, decodificar simplemente asigna a cada arista
* del árbol el símbolo de 0 o 1. Para esta implementación, las aristas a la izq.
* tendrán el símbolo "0" y para la derecha el símbolo "1". */
public String Decodificar(String binaryString, HuffmanNode root){
HuffmanNode current = root;
StringBuilder build = new StringBuilder();
for(int i = 0; i < binaryString.length(); i++){
if(current != null){
if((current.rightNode == null && binaryString.charAt(i) == '1') || (current.leftNode == null && binaryString.charAt(i) == '0')){
i--;
build.append(current.caracter);
current = root;
continue;
}
if(binaryString.charAt(i) == '1'){
current = current.rightNode;
}else {
current = current.leftNode;
}
}
}
if(current != null){
build.append(current.caracter);
}
return build.toString();
}
/*Codificar : Crear el árbol más óptimo para nuestra cadena de bits. */
public String Codificar(String strToCode){
Map<Character, Integer> charOcurrence = countFrequency(strToCode);
int n = charOcurrence.size();
/* Creamos una cola de prioridad con el mapeo de la ocurrencia de símbolos
que organice los símbolos de acuerdo al comparador de Huffman. */
PriorityQueue<HuffmanNode> huffmanHeap = new PriorityQueue<>(n, new HuffmanComparator());
// Recorremos el HashMap y creamos la cola de prioridad de acuerdo a la frecuencia del símbolo:
charOcurrence.forEach((key, value) -> {
HuffmanNode node = new HuffmanNode();
node.caracter = key;
node.frecuencia = value;
node.leftNode = null;
node.rightNode = null;
huffmanHeap.add(node);
});
/* Transformamos la cola prioritaria (minHeap) en un árbol de Huffman mediante
el algoritmo visto en clase. */
while(huffmanHeap.size() > 1){
HuffmanNode leaf1 = huffmanHeap.peek();
huffmanHeap.poll();
HuffmanNode leaf2 = huffmanHeap.peek();
huffmanHeap.poll();
HuffmanNode ptr = new HuffmanNode();
ptr.frecuencia = leaf1.frecuencia + leaf2.frecuencia;
ptr.caracter = '-';
ptr.leftNode = leaf1;
ptr.rightNode = leaf2;
huffmanHeap.add(ptr);
}
this.root = huffmanHeap.peek();
/* Teniendo el árbol de Huffman, buscamos las palabras código
y mostramos al usuario como se han codificado los símbolos : */
System.out.println(" Caracter | Palabra Código | Frecuencia");
System.out.println("----------------------------------");
codeWords(root, "");
/* Codificamos el input con las nuevas palabras código obtenidas : */
StringBuilder build = new StringBuilder();
for(Character ch : strToCode.toCharArray()){
build.append(this.charToBinaryMap.get(ch));
}
this.nuevaSalida = build.toString();
int pesoOriginal = strToCode.getBytes().length*8;
int pesoComprimido = nuevaSalida.length();
System.out.println("Peso original (bits) :" + pesoOriginal);
/*System.out.println("Codificación de Huffman: " + nuevaSalida);
*/
System.out.println("Longitud de la codificación de Huffman: " + nuevaSalida.length());
System.out.println("Peso post-codificación: " + pesoComprimido);
return nuevaSalida;
}
/* countFrequency : Cuenta número de ocurrencias de un caracter. */
public static Map<Character, Integer> countFrequency(String input){
HashMap<Character, Integer> mapFrequency = new HashMap<>();
for(int i = 0; i < input.length(); i++){
if(!mapFrequency.containsKey(input.toCharArray()[i])){
mapFrequency.put(input.toCharArray()[i], 1);
}else{
mapFrequency.put(input.toCharArray()[i], mapFrequency.get(input.toCharArray()[i])+1);
}
}
return mapFrequency;
}
/* Como queremos las hojas del árbol de Huffman, hacemos un simple
* recorrido in-order sobre el árbol, imprimiendo únicamente las hojas. */
public void codeWords(HuffmanNode root, String str){
if(root.leftNode != null){
codeWords(root.leftNode, str + 0);
}
if(root.leftNode == null && root.rightNode == null){
this.charToBinaryMap.put(root.caracter, str);
System.out.println(root.caracter + " | " + str + " | " + root.frecuencia);
return;
}
if(root.rightNode != null){
codeWords(root.rightNode, str + 1);
}
}
public String charList(HuffmanNode root, String str){
if(root.leftNode != null){
charList(root.leftNode, str);
}
if(root.leftNode == null && root.rightNode == null){
str = str + root.caracter;
}
if(root.rightNode != null){
charList(root.rightNode, str);
}
return str;
}
}
The ImageProcessing class, where the whole reasoning is developed, is the following:
import java.awt.*;
import java.awt.color.ColorSpace;
import java.awt.image.*;
import java.io.*;
import java.math.BigInteger;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import javax.imageio.ImageIO;
public class ImageProcessing {
public static void main(String args[]) throws Exception{
/* Convert image to byte array and then, to a string */
StringBuilder build = new StringBuilder();
BufferedImage bImage = ImageIO.read(new File("/WorkSpace/HuffmanCompression/src/draken.jpg"));
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ImageIO.write(bImage, "jpg", bos );
byte [] data = bos.toByteArray();
for(int i = 0; i < data.length; i++){
build.append(data[i]);
}
/* Use Huffman code to the previous string.*/
HuffmanCode huffman = new HuffmanCode();
String prueba = huffman.Codificar(build.toString());
String pruebaDecodificada = huffman.Decodificar(prueba, huffman.getTree());
String strToByte = huffman.getNuevaSalida();
/*
String inputString = strToByte;
Charset dictionaryMap = StandardCharsets.UTF_16;
byte[] newImage = inputString.getBytes(dictionaryMap);
*/
/*Convert the binary string to a byte array and then, output the corresponding image. I copied and paste this part of the code from this blog. */
byte[] bval = new BigInteger(strToByte, 2).toByteArray();
OutputStream stream = new FileOutputStream("output.jpg");
BufferedImage image = createRGBImage(bval, bImage.getWidth(), bImage.getHeight());
try {
ImageIO.write(image, "jpg", stream);
}
finally {
stream.close();
}
}
public static BufferedImage createRGBImage(byte[] bytes, int width, int height) {
DataBufferByte buffer = new DataBufferByte(bytes, bytes.length);
ColorModel cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), new int[]{8, 8, 8}, false, false, Transparency.OPAQUE, DataBuffer.TYPE_BYTE);
return new BufferedImage(cm, Raster.createInterleavedRaster(buffer, width, height, width * 3, 3, new int[]{0, 1, 2}, null), false, null);
}
}
I will be grateful if someone can help me, Thanks in advance!