256色灰度图哈夫曼编码压缩

哈夫曼编码原理：设256种颜色在图片中各出现了a1、a2、…、an次，于是可以得到一个对应的权重数组。将权重数组以以下范例形式建立哈夫曼树。
范例：假设一个含有6个数值的权重数组9、8、3、6、7、1：
1. 首先选出两个最小的权值1、3。建立一颗二叉树：(注意小数在左）


2. 将1、3合并为4，加入原权重数组，即此时权重数组为：9、8、6、7、4
3. 再选出两个最小权值4、6，此时二叉树为：



4.依照上述方法，直到最后建立一颗哈夫曼树：（即每次从权重集合找出两个最小的数值，合并后再加入权重数组。并且同时建立二叉树，直到权重数组只剩下所有数值之和。）



建立颜色数组的哈夫曼树之后，从根节点进行遍历，做字数编码加0，右子树编码加1。（例如范例中7的哈夫曼编码为000，1的哈夫曼编码为1100）此处为变长编码。遍历整棵哈夫曼树之后即可得到256种颜色的哈夫曼编码。读取256灰度的bmp图片对映即可进行压缩。
代码部分：
类中构造器的参数为bmp解码部分，因与本讲述无关故不上传

Compression.h


#pragma once
#include "BMPbase.h"
#include <iostream>
using namespace std;
struct HuffmanTree {
HuffmanTree* parent;//parent节点
HuffmanTree* LTree;//左节点，即为1节点 应为变短编码
HuffmanTree* RTree;//右节点，即为0节点 遵循左清右重原则
int TreeIndex;//树的下标
bool isSorted;//判断是否被选取
int weight;//本节点的权值
int index;//本节点的原编码数位
};
class Compression
{
public:
Compression(BMPbase* pic, int size);
~Compression();
void BuildHuffmanTree(int min1,int min2);
void showTree(HuffmanTree * root, string str);
string* getHuffmanCode();
void choseMin(int & min);
private:
int* weightArray;
int size;//图色数
HuffmanTree** TreeArray;
int SortPoint;//排序静态指针
//int unUsed;//未被用到的颜色数
string* huffmanCode;//生成的哈夫曼编码
HuffmanTree* root;//根节点
};



Compression.cpp


#include "stdafx.h"
#include "Compression.h"


Compression::Compression(BMPbase* pic, int size)
{
this->size = size;
weightArray = new int[size];
huffmanCode = new string[size];
for (int i = 0; i < size; i++)
{
weightArray[i] = 0;
}
for (int i = 0; i < pic->pixNum; i++)//计算权值数组
{
weightArray[pic->getPicPix()[i]] += 1;//将第i个像素的颜色的权值加一
}

TreeArray = new HuffmanTree*[12000];
SortPoint = 0;
for (int i = 0; i < size; i++)//初始化树指针数组
{
if (weightArray[i] == 0)
{
huffmanCode[i] = "-1";
}
else {
TreeArray[SortPoint] = new HuffmanTree();
TreeArray[SortPoint]->index = i;
TreeArray[SortPoint]->TreeIndex = SortPoint;
TreeArray[SortPoint]->weight = weightArray[i];
TreeArray[SortPoint]->isSorted = false;
SortPoint++;
}
}

int min1, min2;
int sort = SortPoint - 1;
for (int i = 0; i < sort; i++)
{
choseMin(min1);//min1为小数 min2为大数
choseMin(min2);//min1为小数 min2为大数
BuildHuffmanTree(min1, min2);
}
int AllTreeNum = SortPoint;
string tmp1;
showTree(root, tmp1);

ofstream haffmanOut("huffman.code");
haffmanOut << AllTreeNum << endl;
for (int i = 0; i < SortPoint; i++) {
if (TreeArray[i]->LTree && TreeArray[i]->RTree){
haffmanOut <<TreeArray[i]->index << " " << TreeArray[i]->LTree->TreeIndex << " " << TreeArray[i]->RTree->TreeIndex << endl;
}
else {
haffmanOut << TreeArray[i]->index << -1 << " " << -1 << endl;
}
}

}

Compression::~Compression()
{
delete[] TreeArray;
}


void Compression::BuildHuffmanTree(int min1,int min2)//min1为小数 min2为大数
{
HuffmanTree* node = new HuffmanTree();
this->root = node;
node->index = -1;
node->LTree = TreeArray[min1];//权值小在左边
TreeArray[min1]->parent = node;
node->RTree = TreeArray[min2];//权值大在右边
TreeArray[min2]->parent = node;
node->weight = TreeArray[min1]->weight + TreeArray[min2]->weight;
node->isSorted = false;
node->TreeIndex = SortPoint;
TreeArray[SortPoint] = node;
SortPoint++;
}

void Compression::showTree(HuffmanTree* root, string str) {
//如果有左孩子就加个0，有右孩子就加个1，直到遍历完成为止
if (root->LTree != NULL)
{
showTree(root->LTree, str + '0');//如果左孩子不为空，就给编码加个0
}
if (root->RTree != NULL)
{
showTree(root->RTree, str + '1');//如果右孩子不为空，就给编码加个1
}
if(root->LTree == NULL && root->RTree == NULL) {
huffmanCode[root->index] = str;
return;
}
return;
}

string* Compression::getHuffmanCode()
{
return huffmanCode;
}

void Compression::choseMin(int &min)
{

int minA;
int i = 0;
bool flag = false;
while(i < SortPoint && !flag) {
if (!TreeArray[i]->isSorted) {
minA = i;
flag = true;
}
i++;
}
for (i = minA + 1; i < SortPoint; i++) {
if (!TreeArray[i]->isSorted) {
if (TreeArray[i]->weight < TreeArray[minA]->weight) {
minA = i;
}
}
}
TreeArray[minA]->isSorted = true;
min = minA;

}

嗯 想了想还是把bmp解码部分放出来好了，保持一下代码的完整性,代码中的注释部分是因为部分256色bmp图片不是太过严格
BMPbase.h


#pragma once
#include <fstream>
#include <iostream>
#include <iomanip>
using namespace std;
struct BitmapFileHeader {
WORD bmpHeader;//文件头“BM”
DWORD fileSize;//文件大小，字节为单位
WORD reservedWord1;//文件保留字1 必为0
WORD reservedWord2;//文件保留字2 必为0
DWORD offSet;//位图数据起始位置
};
struct BitmapFileInfo {
DWORD bmpInfoSize;//即本结构所占的大小 为28 即4字节
LONG bmpWidth;//位图的宽度
LONG bmpHeight;//位图的高度
WORD bmpPlanes;//目标设备的级别（必须为1）
WORD bmpBitCount;//每个像素的尾数，必须为1（双色）4（16色） 8（256色） 24（真彩）
DWORD bmpCompression;//必为0（BI_RGB未压缩） 1（BI_RLEB） 2（BI_RLE4)
DWORD bmpSizeImage;//位图的大小 单位为字节
LONG bmpXpelsPerMeter;//水平分辨率 每米像素数
LONG bmpYpelsPerMeter;//垂直分辨率
DWORD bmpColorUsed;//位图显示所需颜色数
DWORD bmpColorImportant;//重要的颜色数 若为0 则都重要
};
class BMPbase
{
public:

BMPbase(const char* fileName);
~BMPbase();
private:
bool fileSuccess;//判断文件是否打开成功的标志
bool fileCompression;//判断文件是否被压缩
bool bmpFileflag;//判断是否为BMP文件
bool bmpBitRight;//判断文件位数是否正确
BitmapFileHeader bmpHeader;//bmp文件头
BitmapFileInfo BmpPic;//bmp文件基本信息
BYTE* picPix;//图片数据数组

public:
bool isReadFileSuccess();
bool isBmpFile();
BitmapFileHeader getBmpHedader();//获取文件头
BitmapFileInfo getBmpInfo();//获取信息结构体
bool isBmpBitRight();//获取位图是否正确
bool isFileCompression();//获取文件是否被压缩
BYTE* getPicPix();//获取颜色数组
int pixNum;
};


BMPbase.cpp
#include "stdafx.h"
#include "BMPbase.h"


BMPbase::BMPbase(const char* fileName)
{
fileSuccess = true;//初始化文件为成功打开
bmpFileflag = true;//初始化文件为BMP文件
bmpBitRight = true;//初始化文件位数为正确
fileCompression = true;//初始化文件为未压缩
ifstream picReader(fileName, ios::binary);
if (!picReader)
{
fileSuccess = false;//文件读取失败
}
else
{
picReader.read((char*)&bmpHeader.bmpHeader, sizeof(WORD));
if (bmpHeader.bmpHeader != 0x4D42)
{
bmpFileflag = false;//文件读取失败，类型不一致
}
else//开始读取文件信息
{
picReader.read((char*)&bmpHeader.fileSize, sizeof(DWORD));//读文件大小
picReader.read((char*)&bmpHeader.reservedWord1, sizeof(WORD));//读取保留字
picReader.read((char*)&bmpHeader.reservedWord2, sizeof(WORD));//读取保留字
/*if (bmpHeader.reservedWord1 != 0x00 || bmpHeader.reservedWord2 != 0x00)//判断文件保留字是否正确
{
fileSuccess = false;//文件读取失败
}*/
picReader.read((char*)&bmpHeader.offSet, sizeof(DWORD));//读取偏移量
picReader.read((char*)&BmpPic.bmpInfoSize, sizeof(DWORD));
/*if (BmpPic.bmpInfoSize != 0x28)//判断文件信息长度是否正确
{
fileSuccess = false;//文件读取失败
}*/
picReader.read((char*)&BmpPic.bmpWidth, sizeof(DWORD));//获取宽度
picReader.read((char*)&BmpPic.bmpHeight, sizeof(DWORD));//获取高度
picReader.read((char*)&BmpPic.bmpPlanes, sizeof(WORD));//获取目标设备的级别 必须为1
/*if (BmpPic.bmpPlanes != 0x01)//判断设备级别是否正确
{
fileSuccess = false;//文件读取失败
}*/
picReader.read((char*)&BmpPic.bmpBitCount, sizeof(WORD));//获取每像素所需位数 8位图
if (BmpPic.bmpBitCount != 8)//判断是否为8位图
{
bmpBitRight = false;//文件读取失败,非8位图
}
picReader.read((char*)&BmpPic.bmpCompression, sizeof(DWORD));//获取文件压缩
if (BmpPic.bmpCompression != 0x00)//判断是否压缩
{
fileCompression = false;//文件读取失败,已被压缩
}
picReader.read((char*)&BmpPic.bmpSizeImage, sizeof(DWORD));//获取sizeImage
picReader.read((char*)&BmpPic.bmpXpelsPerMeter, sizeof(DWORD));//获取文件水平分辨率
picReader.read((char*)&BmpPic.bmpYpelsPerMeter, sizeof(DWORD));//获取文件水平分辨率
picReader.read((char*)&BmpPic.bmpColorUsed, sizeof(DWORD));//获取文件用到颜色
picReader.read((char*)&BmpPic.bmpColorImportant, sizeof(DWORD));//获取文件重要颜色
picReader.seekg(bmpHeader.offSet, ios::beg);//从文件开头开始偏移前面读出的偏移量
pixNum = BmpPic.bmpHeight*BmpPic.bmpWidth;
picPix = new BYTE[pixNum];
for (int x = 0; x < pixNum; x++)
{
picReader.read((char*)&picPix[x], sizeof(BYTE));//获取文件数据部分
}

}
}
}


BMPbase::~BMPbase()
{
for (int x = 0; x < BmpPic.bmpWidth; x++)
{
delete[] picPix;
}
}


bool BMPbase::isReadFileSuccess()
{
return fileSuccess;
}


bool BMPbase::isBmpFile()
{
return bmpFileflag;
}


BitmapFileHeader BMPbase::getBmpHedader()
{
return bmpHeader;
}


BitmapFileInfo BMPbase::getBmpInfo()
{
return BmpPic;
}


bool BMPbase::isBmpBitRight()
{
return bmpBitRight;
}


bool BMPbase::isFileCompression()
{
return fileCompression;
}


BYTE* BMPbase::getPicPix()
{
return picPix;
}