Huffman图像压缩

1、实现基于Huffman编码的图像压缩

实现大体思路遵循上述的原理，关于比特位的处理，如果直接用位运算的话，编写起来较复杂。于是我改用0和1的字符串来逐位表示一个个比特。也就是说，编码过程中经过像素值转成，再由字符串转成比特位，解码过程中经过比特位转成字符串，再由字符串转成像素值。通过字符串作为桥梁，可以避免复杂的位运算，而运行效率也不会下降多少。而至于像素值和字符串怎样转换，还要用到现成的bitset<32>类型。

c++代码如下：

HuffmanEncode.cpp:

HuffmanEncode函数对外使用。调用函数HuffmanEncode，输入图像的二维矩阵，图像的宽高，以及另存的压缩后的文件名，执行后得到压缩后的文件以及头部信息文件。

在HuffmanEncode函数内，findMinNode函数用于找到当前最少出现的节点；buildTree函数用于构建哈夫曼树；每个节点的下标为像素值，存有出现次数，指向左右子节点的下标，以及用来判断是否已删除的位；buildTable函数用于建立像素值和编码值的映射关系。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <bitset>using namespace std;struct Node {int count;int left;int right;int removed;
};int findMinNode(Node* nodes, int length) {int index = -1;for (int i = 0; i < length; i++) {if ((index == -1 || nodes[i].count < nodes[index].count) && !nodes[i].removed && nodes[i].count > 0) {index = i;}}if (index != -1) {nodes[index].removed = 1;}return index;
}int buildTree(Node* nodes, int* counts) {for (int i = 0; i < 256; i++) {nodes[i].left = -1;nodes[i].right = -1;nodes[i].count = counts[i];nodes[i].removed = 0;}int length = 256;while (1) {int l = findMinNode(nodes, length);if (l == -1) {break;}int r = findMinNode(nodes, length);if (r == -1) {break;}nodes[length].left = l;nodes[length].right = r;nodes[length].count = nodes[l].count + nodes[r].count;nodes[length].removed = 0;length++;}return length;
}void buildTable(Node* nodes, int pos, string bits, string * table) {int l = nodes[pos].left;int r = nodes[pos].right;if (nodes[pos].left == -1 && nodes[pos].right == -1) {table[pos] = bits;return;}buildTable(nodes, r, bits + "1", table);buildTable(nodes, l, bits + "0", table);
}void HuffmanEncode(unsigned char ** data, int height, int width, const char *writepath) {FILE* fp;int counts[256];memset(counts, 0, sizeof(int) * 256);for (int i = 0; i < height; i++) {for (int j = 0; j < width; j++) {counts[data[i][j]]++;}}Node nodes[256 * 2];int length = buildTree(nodes, counts);string table[256];buildTable(nodes, length - 1, "", table);string table_path = "";table_path = table_path + writepath + "_table";fp = fopen(table_path.c_str(), "w");for (int i = 0; i < 256; i++) {if (table[i].size() == 0) {fprintf(fp, "2\n");} else  {fprintf(fp, "%s\n", table[i].c_str());}}fclose(fp);int total_bit_length = 0;for (int i = 0; i < 256; i++) {total_bit_length += counts[i] * table[i].size();}char * str = new char[total_bit_length];int cur = 0;for (int i = 0; i < height; i++) {for (int j = 0; j < width; j++) {for (int k = 0; k < table[data[i][j]].size(); k++) {str[cur] = table[data[i][j]][k];cur++;}}}fp = fopen(writepath, "wb");int times = total_bit_length / 32 + 1;string total = "";total = total + str;for (int i = 0; i < 32 * times - total_bit_length; i++) {total = total + "0";}fwrite(&total_bit_length, sizeof(int), 1, fp);for (int i = 0; i < times; i++) {bitset<32> byte(total.substr(32 * i, 32));unsigned long tmp = byte.to_ulong();fwrite(&tmp, sizeof(int), 1, fp);}fclose(fp);
}

函数HuffmanDecode直接调用，传入字符类型的数组指针作为解码后数据用于返回到主函数，图像的宽高以及编码文件的路径名。

decodeString函数用于解析由比特位转成的字符串，并将之解析为最终用于返回的解码图像矩阵。其中，传入的map类型参数是读取编码映射表后建立的编码值和像素值的解码映射表，map类型可以极大地减少查表的时间，降低时间复杂度。由于编码值的前缀唯一不会是其它的编码值，所以不会出现错误识别编码字符串的情况。

HuffmanDecode.cpp:

#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <bitset>
#include <map>using namespace std;void decodeString(string & total, map<string, int> & table_map, int total_bit_length, unsigned char * data) {int index = 0;int cur = 1;int head = 0;while (head < total_bit_length) {if (total[head] != '1' && total[head] != '0') {head++;cur = head + 1;continue;}if (table_map.count(total.substr(head, cur - head))) {data[index++] = table_map[total.substr(head, cur - head)];head = cur;cur = head + 1;} else {cur++;}}
}void HuffmanDecode(unsigned char * decoded_data, int height, int width, const char *readpath) {FILE* fp;string table[256];string path = "";path = path + readpath + "_table";fp = fopen(path.c_str(), "rb");for (int i = 0; i < 256; i++) {char tmp[30];fscanf(fp, "%s", tmp);table[i] = table[i] + tmp;}fclose(fp);map<string, int> table_map;for (int i = 0; i < 256; i++) {table_map[table[i]] = i;}fp = fopen(readpath, "rb");int total_bit_length;fread(&total_bit_length, sizeof(int), 1, fp);int times = total_bit_length / 32 + 1;string total = "";char * str = new char[total_bit_length];int *words = new int[times];fread(words, sizeof(int), times, fp);int cur = 0;for (int i = 0; i < times; i++) {bitset<32> bits(words[i]);string tmp = bits.to_string();for (int j = 0; j < 32; j++) {str[cur] = tmp[j];cur++;}}fclose(fp);total = total + str;decodeString(total, table_map, total_bit_length, decoded_data);
}

这个文件装的是主函数，以及主函数调用的关于压缩文件文件、头部信息文件和映射表文件等的读写处理的函数。

HuffmanMain.cpp

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include "HuffmanEncode.cpp"
#include "HuffmanDecode.cpp"using namespace std;struct ImageHeader {BITMAPFILEHEADER bf;    BITMAPINFOHEADER bi;int rgb[256];
};int ReadImage(string path, ImageHeader & ih, unsigned char ** & data) {FILE * fp;fp = fopen(path.c_str(), "rb");if (fp == NULL) {return 0;} fread(&ih.bf, sizeof(BITMAPFILEHEADER), 1, fp);fread(&ih.bi, sizeof(BITMAPINFOHEADER), 1, fp);fread(&ih.rgb, sizeof(int), 256, fp);if (ih.bi.biBitCount != 8) {printf("Gray image only!\n");return 0;}data = new unsigned char*[ih.bi.biHeight];int row_width = ih.bi.biWidth + (4 - ih.bi.biWidth % 4);for (int i = 0; i < ih.bi.biHeight; i++) {data[i] = new unsigned char[ih.bi.biWidth];}for (int i = ih.bi.biHeight - 1; i >= 0; i--) {for (int j = 0; j < ih.bi.biWidth; j++) {fread(&data[i][j], 1, 1, fp);}if (ih.bi.biWidth % 4 > 0) {fseek(fp, 4 - ih.bi.biWidth % 4, SEEK_CUR);}}fclose(fp);return 1;
}int CopyHeader(string path, ImageHeader & ih) {FILE * fp;fp = fopen(path.c_str(), "wb");if (fp == NULL) {return 0;}fwrite(&ih.bf, sizeof(BITMAPFILEHEADER), 1, fp);fwrite(&ih.bi, sizeof(BITMAPINFOHEADER), 1, fp);fwrite(&ih.rgb, sizeof(int), 256, fp);fclose(fp);return 1;
}int ReaderHeader(string path, ImageHeader & ih2) {FILE * fp;fp = fopen(path.c_str(), "rb");if (fp == NULL) {return 0;}fread(&ih2.bf, sizeof(BITMAPFILEHEADER), 1, fp);fread(&ih2.bi, sizeof(BITMAPINFOHEADER), 1, fp);fread(&ih2.rgb, sizeof(int), 256, fp);fclose(fp);return 1;
}int WriteImage(string path, ImageHeader & ih2, unsigned char * & decoded_data) {FILE * fp;fp = fopen(path.c_str(), "wb");if (fp == NULL) {return 0;}fwrite(&ih2.bf, sizeof(BITMAPFILEHEADER), 1, fp);fwrite(&ih2.bi, sizeof(BITMAPINFOHEADER), 1, fp);fwrite(&ih2.rgb, sizeof(int), 256, fp);for (int i = ih2.bi.biHeight - 1; i >= 0; i--) {fwrite(&decoded_data[i * ih2.bi.biWidth], ih2.bi.biWidth, 1, fp);char tmp = 0;if (ih2.bi.biWidth % 4 > 0) {fwrite(&tmp, 1, 4 - ih2.bi.biWidth % 4, fp);}}fclose(fp);return 1;
}int main() {char readpath[50];printf("BMP format image name:");scanf("%s", readpath);ImageHeader ih;unsigned char ** data;string path = "";path = path + readpath + ".bmp";if (ReadImage(path, ih, data)) {printf("Image %s read successful.\n", readpath);} else {printf("Image %s reading failed.\n", readpath);return 0;}path = "";path = path + readpath + "_head";if (CopyHeader(path, ih)) {printf("Header file copied.\n");} else {printf("Header file copying failed.\n");return 0;}path = "";path = path + readpath;HuffmanEncode(data, ih.bi.biHeight, ih.bi.biWidth, path.c_str());printf("Image encoded.\n");path = "";path = path + readpath + "_head";ImageHeader ih2;if (ReaderHeader(path, ih2)) {printf("Header file read successful.\n");} else {printf("Header file reading failed.\n");return 0;}path = "";path = path + readpath;unsigned char * decoded_data = new unsigned char[ih2.bi.biHeight * ih2.bi.biWidth];HuffmanDecode(decoded_data, ih2.bi.biHeight, ih2.bi.biWidth, path.c_str());printf("Image decoded.\n");path = "";path = path + readpath + "_decode.bmp";if (WriteImage(path, ih2, decoded_data)) {printf("Decoded image saved successful.\n");} else {printf("Decoded image saving failed.\n");return 0;}
}

2、实验结果

原图像test.bmp：

处理过程：

原图像文件test.bmp与压缩后文件test的大小对比：

压缩率约为15.27%。

解码后的图像test_decode.bmp:

原图像文件test.bmp与解码后图像test_decode.bmp的大小对比：

可以看到，解码后图像能一个字节都不差地被恢复出来。因为是无损压缩，失真率为0。

另再测试原图像test1.bmp：

处理过程：

原图像文件test1.bmp与压缩后文件test1的大小对比：

压缩率约为6.19%。

解码后的图像test1_decode.bmp:

原图像文件test1.bmp与解码后图像test1_decode.bmp的大小对比：

可以看到，解码后图像还是能一个字节都不差地被恢复出来。因为是无损压缩，失真率为0。

3、总结

这次作业，一开始我并没打算纯用C/C++来实现Huffman压缩图像，因为原先不清楚bmp格式的文件怎么读取。但Matlab可以调用函数直接获得图像矩阵，这样不不用去处理文件头部信息了。但是对于Matlab很高级的编程工具，要做到Huffman建树、建表，以及按位来写文件的话却并不知道如何着手，反而是用惯了的C/C++更适合这种工作。于是我开始寻求两种优势兼具的解决方法：先用Matlab读取出图像矩阵，再将图像矩阵通过面向C语言的接口传给C代码压缩处理，最后返回解码后的图像矩阵到Matlab，让Matlab封装图像矩阵成bmp格式文件。这样一来，我既能不去考虑图像文件头部处理，又能用C/C++来从底层实现编码压缩和解码。

通过网上查阅资料，我学到了Matlab的C语言接口mex的基本使用，包括如何在Matlab传递参数，如何在C代码内解析参数。解析的过程有点绕，不过熟练掌握指针的知识的话也能正确处理好参数。

这份代码能正确进行Huffman编码和解码，不过最后我还是改用C++重新实现了一次，因为绕了这么久好像也就差个bmp格式文件的读写罢了，干脆再差点关于bmp的资料，把这个问题也用C语言解决了罢。

以上的代码我花了两天时间来编写，测试起来很痛苦，因为用对着图像矩阵检查像素值是否算对，甚至还要用BinaryViewer来检查二进制位是否正确，如果不正确又会是哪里出错了。每晚都要debug知道三四点，那几天感觉严重缺乏睡眠。

但总体来说，这次大作业，我能应用学到的多媒体技术知识来解决问题并温习了学过的知识，虽然过程不轻松，但最终能正确丝毫无误地解码出图像时，成就感还是满满的，结果还是很让自己满意，并且编程也算是能练练手了。

以下是我一开始用这种方法实现的代码：

Matlab脚本Huffman.m:

img = imread('test.bmp');
%img = rgb2gray(img);
[height, width] = size(img);mex HuffmanEncode.cpp
HuffmanEncode(int32(img), 'test.txt');mex HuffmanDecode.cpp
mat = uint8(HuffmanDecode('test.txt', height, width));
imwrite(mat, 'test_decoded.bmp', 'bmp');

HuffmanEncode.cpp:

#include "mex.h"
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <string>
#include <bitset>using namespace std;struct Node {int count;int left;int right;int removed;
};int findMinNode(Node* nodes, int length) {int index = -1;for (int i = 0; i < length; i++) {if ((index == -1 || nodes[i].count < nodes[index].count) && !nodes[i].removed && nodes[i].count > 0) {index = i;}}if (index != -1) {nodes[index].removed = 1;}return index;
}int buildTree(Node* nodes, int* counts) {for (int i = 0; i < 256; i++) {nodes[i].left = -1;nodes[i].right = -1;nodes[i].count = counts[i];nodes[i].removed = 0;}int length = 256;while (1) {int l = findMinNode(nodes, length);if (l == -1) {break;}int r = findMinNode(nodes, length);if (r == -1) {break;}nodes[length].left = l;nodes[length].right = r;nodes[length].count = nodes[l].count + nodes[r].count;nodes[length].removed = 0;length++;}return length;
}void buildTable(Node* nodes, int pos, string bits, string * table) {int l = nodes[pos].left;int r = nodes[pos].right;if (nodes[pos].left == -1 && nodes[pos].right == -1) {table[pos] = bits;return;}buildTable(nodes, r, bits + "1", table);buildTable(nodes, l, bits + "0", table);
}void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {double* dataCursor = mxGetPr(prhs[0]);int height = mxGetM(prhs[0]);int width = mxGetN(prhs[0]);char *writepath = mxArrayToString(prhs[1]);FILE* fp;int * data = (int *)dataCursor;int counts[256];memset(counts, 0, sizeof(int) * 256);for (int i = 0; i < height; i++) {for (int j = 0; j < width; j++) {counts[data[i + height * j]]++;}}Node nodes[256 * 2];int length = buildTree(nodes, counts);string table[256];buildTable(nodes, length - 1, "", table);string table_path = "table_of_";table_path = table_path + writepath;fp = fopen(table_path.c_str(), "w");for (int i = 0; i < 256; i++) {if (table[i].size() == 0) {fprintf(fp, "2\n");} else  {fprintf(fp, "%s\n", table[i].c_str());}}fclose(fp);int total_bit_length = 0;for (int i = 0; i < 256; i++) {total_bit_length += counts[i] * table[i].size();}char * str = new char[total_bit_length];int cur = 0;for (int i = 0; i < width; i++) {for (int j = 0; j < height; j++) {for (int k = 0; k < table[data[height * i + j]].size(); k++) {str[cur] = table[data[height * i + j]][k];cur++;}}}fp = fopen(writepath, "wb");int times = total_bit_length / 32 + 1;string total = "";total = total + str;for (int i = 0; i < 32 * times - total_bit_length; i++) {total = total + "0";}fwrite(&total_bit_length, sizeof(int), 1, fp);for (int i = 0; i < times; i++) {bitset<32> byte(total.substr(32 * i, 32));unsigned long tmp = byte.to_ulong();fwrite(&tmp, sizeof(int), 1, fp);}fclose(fp);
}

HuffmanDecode.cpp:

#include "mex.h"
#include <stdlib.h>
#include <stdio.h>
#include <string>
#include <bitset>
#include <map>using namespace std;void decodeString(string & total, map<string, int> & table_map, int total_bit_length, double* res) {int index = 0;int cur = 1;int head = 0;while (head < total_bit_length) {if (total[head] != '1' && total[head] != '0') {head++;cur = head + 1;continue;}if (table_map.count(total.substr(head, cur - head))) {res[index++] = table_map[total.substr(head, cur - head)];head = cur;cur = head + 1;} else {cur++;}}
}void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {const char *readpath = mxArrayToString(prhs[0]);int height = mxGetScalar(prhs[1]);int width = mxGetScalar(prhs[2]);FILE* fp;string table[256];string table_path = "table_of_";table_path = table_path + readpath;fp = fopen(table_path.c_str(), "rb");for (int i = 0; i < 256; i++) {char tmp[30];fscanf(fp, "%s", tmp);table[i] = table[i] + tmp;}fclose(fp);map<string, int> table_map;for (int i = 0; i < 256; i++) {table_map[table[i]] = i;}fp = fopen(readpath, "rb");int buffer;int total_bit_length;fread(&total_bit_length, sizeof(int), 1, fp);int times = total_bit_length / 32 + 1;string total = "";char * str = new char[total_bit_length];int *words = new int[times];fread(words, sizeof(int), times, fp);int cur = 0;for (int i = 0; i < times; i++) {bitset<32> bits(words[i]);string tmp = bits.to_string();for (int j = 0; j < 32; j++) {str[cur] = tmp[j];cur++;}}fclose(fp);total = total + str;double *res;plhs[0] = mxCreateDoubleMatrix(height, width, mxREAL);res = mxGetPr(plhs[0]);decodeString(total, table_map, total_bit_length, res);
}