【数据压缩】第五次作业——LZW编码
LAW编码
文章目录
- LAW编码
-
- 编码原理
- 解码原理
- 代码分析
-
- 词典树
- 初始化词典树
- 当前字符是否在词典中
- 添加新字符
- 编码
- 解码
-
- `DecodeString`
- 实验结果
-
- 编解码测试
-
- 词典输出
- 编码
- 解码
- 不同类型的文件
-
- 原文件
- 编码后的文件
- 各个文件的编码词典总数
- 解码恢复后的文件
- 统计分析
- LZW编码的特点和应用
- 程序代码
- 实验总结
LZW的编码思想是不断从字符流中提取新的“词条”，然后用码字来表示这个“词条”，LZW编码是围绕“词典”转换表完成的。LZW编码器通过管理这个词典完成输入和输出之间的转换，输入是字符流，输出是n位表示的码字流。解码端输入码字流，边解码边建立词典，得到输出字符流。
编码原理
- Step 1：将词典初始化为包含所有可能的单字符，当前前缀P初始化为空
- Step 2：当前字符C=字符流中的下一个字符
- Step 3：判断P+C是否在词典中
- 如果“是”，则用C扩展P，即让P=P+C，返回Step 2
- 如果“否”，则输出与当前前缀P相对应的码字W，将P+C添加到词典中，令P=C，返回Step 2
LZW编码算法首先初始化词典，然后顺序从待压缩文件中读入字符并按照上述算法执行编码，最后将编得的码字流输出至文件中。
解码原理
- Step 1：在开始译码时词典包含所有可能的前缀根
- Step 2：令CW：=码字流中的第一个码字。
- Step 3：输出当前缀-字符串string.CW到码字流。
- Step 4：先前码字PW：=当前码字CW。
- Step 5：当前码字CW：=码字流的下一个码字。
- Step 6：判断当前缀-字符串string.CW 是否在词典中。
- 如果”是”，则把当前缀-字符串string.CW输出到字符流。当前前缀P：=先前缀-字符串string.PW，当前字符C：=当前前缀-字符串string.CW的第一个字符。把缀-符串P+C添加到词典。
- 如果”否”，则当前前缀P：=先前缀-字符串string.PW。 当前字符C：=当前缀-字符串string.CW的第一个字符。 输出缀-符串P+C到字符流,然后把它添加到词典中。
- Step 7：判断码字流中是否还有码字要译。
- 如果”是”，就返回步骤4。
- 如果”否”，结束。
LZW解码算法首先初始化词典，然后顺序从压缩文件中读入码字，并按照上述算法执行解码，最后将解得的字符串输出至文件中
代码分析
词典树
#define MAX_CODE 65535 //词典中最多的词典数目
struct { //词典树
int suffix; //当前字符的尾缀字符
int parent, firstchild, nextsibling; //分别表示当前节点对应的母节点、第一个孩子节点、下一个兄弟节点
} dictionary[MAX_CODE+1];
int next_code;
int d_stack[MAX_CODE]; // stack for decoding a phrase，用来存储解码后的短语
这部分代码用来定义词典树
suffix：当前字符的尾缀字符
parent：当前节点的母节点
firstchild：当前节点的第一个孩子节点
nextsibling：当前节点的下一个兄弟（右边）节点
next_code：记录下一个词条的位置
初始化词典树
void InitDictionary( void){ //初始化词典
int i;
for( i=0; i<256; i++){ //单个字符写入词典，也就是词典树的第一层
dictionary[i].suffix = i; //尾缀字符
dictionary[i].parent = -1; //母节点
dictionary[i].firstchild = -1; //第一个孩子节点
dictionary[i].nextsibling = i+1; //下一个（右边的）兄弟节点
}
dictionary[255].nextsibling = -1; //第一层最后一个词的兄弟节点
next_code = 256; //下一个词条的编码
}
这一部分代码用来初始化词典，词典中默认包含ascii码对应的256个字符，如果想要写入新的词条，则需要从第256个位置开始
当前字符是否在词典中
int InDictionary( int character, int string_code){ //判断词典中是否有当前字符character（尾缀），string_code是旧词条（前缀）
int sibling; //表示字符在词典中的位置
if( 0>string_code) return character; //如果string_code=-1，说明当前字符是单个字符，已经存在词典中了，因此直接返回当前字符即可
sibling = dictionary[string_code].firstchild; //找string_code的第一个孩子，如果此时string_code没有第一个孩子则sibling=-1
while( -1<sibling){ //sibling>-1，表示string_code已经有孩子了，也就是已经有尾缀了
if( character == dictionary[sibling].suffix) return sibling; //如果当前字符与string_code的某一个尾缀相同，那么返回这个尾缀
sibling = dictionary[sibling].nextsibling; //每次循环后都让sibling的值等于它的下一个兄弟节点
}
return -1; //如果没有找到就返回-1
}
如果输入的是单个字符，那么直接返回这个字符
如果不是，就找到它的第一个孩子节点，也就是第一个尾缀，判断是否与当前新字符相同，如果不同就找这个孩子节点的兄弟节点，直到所有孩子节点都找完。在这个过程中，如果有某一个孩子节点与当前的新字符相同，那么函数返回此时的sibling，如果找不到就返回-1
添加新字符
在词典树中的添加新字符
首先添加新字符的上下和右向关系，新字符的前缀是string_code，孩子节点和右边的兄弟节点都是-1。
再补充新字符的左向关系，通过找新字符前缀的第一个孩子节点，并不断向右，找到这个前缀的最后一个孩子节点后，将最后一个孩子节点的右边兄弟节点更新为当前新字符。
void AddToDictionary( int character, int string_code){ //读入的新字符character（尾缀）和旧词条string_code（前缀）
int firstsibling, nextsibling;
if( 0>string_code) return; //如果string_code<0说明是一个单字符，返回即可
//描述上下和右向的关系
dictionary[next_code].suffix = character; //下一个词条的尾缀为当前新字符
dictionary[next_code].parent = string_code; //这个尾缀character的母节点就是它的前缀是string_code
dictionary[next_code].nextsibling = -1; //这个尾缀的兄弟节点是-1
dictionary[next_code].firstchild = -1; //这个尾缀的第一个孩子节点是-1
//描述左向的关系
firstsibling = dictionary[string_code].firstchild; //找前缀的第一个孩子，也是当前字符的第一个兄弟（最左边的）
if( -1<firstsibling){ // the parent has child 前缀有孩子
nextsibling = firstsibling; //先让下一个兄弟节点为第一个孩子
while( -1<dictionary[nextsibling].nextsibling ) //循环找兄弟节点的下一个兄弟节点，如果>-1说明还有兄弟节点
nextsibling = dictionary[nextsibling].nextsibling; //更新兄弟节点为右边的兄弟节点
dictionary[nextsibling].nextsibling = next_code; //直到兄弟节点的右边没有兄弟节点的时候，将新字符作为这个兄弟节点的兄弟节点
//此时新字符成为了当前前缀为string_code的最后一个孩子（在最右边）
}else{// no child before, modify it to be the first 前缀没有孩子的时候，当前新字符就是这个前缀的第一个孩子
dictionary[string_code].firstchild = next_code; //设置当前字符为前缀的第一个孩子
}
next_code ++; //每添加一个字符，next_code++
}
编码
- 先利用fseek函数确定读入的需要编码的文件长度
- 利用
InitDictionary函数为词典初始化 - 循环运行，每次从文件中读取一个字符，直到读不出字符为止，每次读入的字符就是之前说过的C
- 利用
InDictionary函数判断读入的字符是否在词典树中 - 将
InDictionary函数的返回值赋给index变量 - 如果
index>=0说明词典树中有当前字符和旧词条组成的字符串，就将index的值赋给string_code，也就是P<-P+C - 如果
index<0，就说明词典树中没有当前字符和旧词条组成的字符串，因此利用AddToDictionary函数在词典树中添加新字符
void LZWEncode( FILE *fp, BITFILE *bf){
int character; //新字符
int string_code; //已编码字符，旧词条
int index; //索引
unsigned long file_length; //文件长度
fseek( fp, 0, SEEK_END); //文件指针置文件尾
file_length = ftell( fp); //获取文件长度
fseek( fp, 0, SEEK_SET); //文件指针置文件头
BitsOutput( bf, file_length, 4*8); //调用BitsOutput函数
InitDictionary(); //初始化词典
string_code = -1; //初始值赋值为-1，方便在第一次判断的时候判断读取是否为单个字符
while( EOF!=(character=fgetc( fp))){ //fgetc是从文件中读取一个字符，EOF是文件结束的标志，从文件中读取字符，直到读到结束标志
//fgetc是从文件指针stream指向的文件中读取一个字符，读取一个字节后，光标位置后移一个字节。格式：int fgetc(FILE *stream);。
index = InDictionary( character, string_code); //判断当前字符是否在词典中，返回字符在词典中的index，如果不在则返回-1
if( 0<=index){ // string+character in dictionary index>=0说明旧字符+当前新字已经在词典中了
string_code = index; //更新当前的旧词条为先前的旧词条+当前的新字符 P<-P+C
}else{ // string+character not in dictionary 如果index返回-1，说明当前字符不在词典中
output( bf, string_code); //定义的输出，向编码后的文件中输出旧词条
if( MAX_CODE > next_code){ // free space in dictionary 如果词典中还有空间
// add string+character to dictionary
AddToDictionary( character, string_code); //将新字符串添加到词典中
}
string_code = character; //当前字符变为了旧字符，P<-C
}
}
output( bf, string_code); //循环读完文件后输出最后一个旧字符
}
解码
- 解码端也需要先初始化词典，并读取出解码文件的长度
- 之后进入while循环，每一次循环都是一次解码的过程
- 如果
CW>=next_code，那么就说明当前码字已经不在词典中了。这是因为编码和解码过程实际上是有时差的，编码的时候当输入第二个字符且第一个字符与第二个字符的组合未出现在词典中时，才会把第一个字符对应的码字输出，新的字符写入词典，但是对于解码端来说，只要收到码字就会开始解码。因此，如果在编码端词条刚写入词典就被使用了，这个时候解码端就会因为时差而无法在词典中找到新输入的码字对应的字符。又因为只有在编码端出现形似ababa的字符流时才会产生这样的情况，因此解码端只要收到不在词典中的码字的时候，只需要把上一个码字对应的字符的第一位放到当前码字对应的字符的最后一位即可得到码字的解码字符。所以这个时候令d_stack[0] = character即可，这里character=上一个码字的第一位，而d_stack[0]=当前码字的最后一位，并将上一个码字last_code对应的字符串也写入d_stack。 - 如果
CWnew_code对应的字符串写入d_stack即可
- 如果
- 利用
DecodeString函数计算每次解码字符串的长度，返回后令character = d_stack[phrase_length - 1]，也就是当前解码字符串的第一个字符 - 之后的
while循环中就是将倒序存入d_stack的字符串输出到文件中 - 如果词典中还有空间，就将上一个字符串与当前解码字符串的第一个字符写入词典，同时将当前码字赋值给上一个码字，并进入下一次循环，直到整个文件都解码完为止
void LZWDecode( BITFILE *bf, FILE *fp){
int character; //字符
int new_code, last_code; //new_code就是CW，表示码流中的下一个码字，last_code就是PW，表示上次解码的码字
int phrase_length; //每一个短语的长度，其实是每一次解码字符串的长度
unsigned long file_length; //文件长度
file_length = BitsInput(bf, 4 * 8); //编码后压缩文件的大小
if (-1 == file_length) file_length = 0;
InitDictionary(); //解码端也需要初始化词典
last_code = -1; //先设置前一个码字为-1，因为在第一个码字之前是空值
while (0 < file_length) { //当文件长度>0的时候进入循环，也就是仍有未解码的码字时进入循环
new_code = input(bf); //定义的输入，从压缩后的文件中读入码字
if (new_code >= next_code) { //this is the case CSCSC( not in dict)，除了第一次以外，每次都要判断新的字符是否在词典中
//如果新的码字比当前词典中最后一个码字要大，就说明新的码字已经不在词典中了
d_stack[0] = character; //先将character给d_stack[0]，如果新的码字不在词典中，那么新的码字对应的最后一个字符就是上一个码字的第一个字符
phrase_length = DecodeString(1, last_code); //此时d_stack要从1开始向后存储上一个码字的字符及其向上对应的母节点，得到解码字符串存入d_stack并返回字符串长度
}
else { //如果新的码字小于等于当前的最后一个码字，说明新码字在词典中
phrase_length = DecodeString(0, new_code); //此时d_stack从0开始向后存储新码字的字符及其向上对应的母节点，得到解码字符串存入d_stack并返回字符串长度
}
character = d_stack[phrase_length - 1]; //解码后的最后一个字符，其实是当前码字对应的字符流中的第一个字符
while (0 < phrase_length) { //解码存储符号时d_stack是从最后一个子节点倒序存储到最开始的母节点
phrase_length--; //因此d_stack是倒序存储的，通过phrase_length来决定此次将多少字符解压缩到文件中
fputc(d_stack[phrase_length], fp); //将d_stack中存储的字符写入文件
//函数功能： 将字符c写到文件指针fp所指向的文件的当前写指针的位置。函数格式：int fputc (int c, FILE *fp)。
file_length--; //压缩文件剩余的未解压缩的量
}
if (MAX_CODE > next_code) { //如果此时词典还不满的话
AddToDictionary(character, last_code); //将上一个字符（last_code）和当前码字对应字符流中的第一个字符（character）写入词典
}
last_code = new_code; //CW->PW
}
}
DecodeString
该函数返回每次解码时解码字符串的长度
count用来记录当前码字的解码字符流的长度，d_stack存储解码字符流，每次解压缩的字符串都会倒序存入d_stack，因此向文件中写入的时候需要倒序将里面的内容取出。
start代表从d_stack[0]开始存储还是d_stack[1]开始存储，code表示最后一个子节点对应的码字，通过它来找到子节点的字符并且找到它的母节点对应的码字，循环直到找到最开始的码字。
int DecodeString( int start, int code){
int count; //记录当前解码字符流的长度
count = start; //从0/1开始
while (code >= 0) { //如果还没有找到最开始的母节点
d_stack[count] = dictionary[code].suffix; //d_stack中存储解码时对应的字符
code = dictionary[code].parent; //是倒序存储的，0存储最后一个子节点，之后不断往上找它的母节点依次向后存入d_stack
count++; //每存储一个字符，字符流长度+1
}
return count; //返回字符流长度
}
实验结果
编解码测试
调试LZW的编码程序，以一个文本文件作为输入，得到输出的LZW编码文件。
词典输出
可以输出根据LZW规则建立的词典
void PrintDictionary( void){ //输出256之后的词典
int n;
int count; //字符串长度
for( n=256; n<next_code; n++){
count = DecodeString( 0, n); //从0开始记录到n的长度
printf( "%4d->", n); //输出这是第n个词条
while( 0<count--) printf("%c", (char)(d_stack[count])); //输出每一个词条对应的字符串
printf( "\n"); //换行
}
}
编码
- 设置工作目录和命令参数
- 查看test.txt文件中的内容
-
main函数中运行编码部分的指令if( 'E' == argv[1][0]){ // do encoding argv[1][0]如果是E的话就进行编码 fp = fopen( argv[2], "rb"); //打开输入文件，编码前的文件 bf = OpenBitFileOutput( argv[3]); //打开输出文件，编码后的文件 if( NULL!=fp && NULL!=bf){ //如果两个文件均不为空 LZWEncode( fp, bf); //对输入文件fp编码生成输出文件bf，bf也就是压缩后的文件 fclose( fp); //关闭输入文件 CloseBitFileOutput( bf); //关闭输出文件 fprintf( stdout, "encoding done\n"); //输出编码成功 } -
查看压缩后的test_dat.dat文件
-
输出词典
printf("encode dictionary:\n"); PrintDictionary();
.dat并不是一种标准文件。许多文件都使用这个扩展名，但文件含义不同。许多数据分析软件也用这个扩展名保存数据。所以这要看具体的软件情况来定。DAT文件，可以按照扩展名来看就是DATA的意思，即数据文件，这类文件并没有进行绝对化的定义，文件格式其实是不确定的
解码
- 设置解码命令行参数
-
main函数中运行解码部分的指令else if( 'D' == argv[1][0]){ // do decoding argv[1][0]如果是D的话就进行解码 bf = OpenBitFileInput( argv[2]); //打开输入文件，是压缩后的文件 fp = fopen( argv[3], "wb"); //以写的方式打开输出文件，是解压缩后的文件 if( NULL!=fp && NULL!=bf){ //如果两个文件不为空 LZWDecode( bf, fp); //对输入文件bf解码生成输出文件fp，fp就是解码后的文件 fclose( fp); //关闭输出文件 CloseBitFileInput( bf); //关闭输入文件 fprintf( stdout, "decoding done\n"); //输出解码成功 } } -
查看解码后的文件
解码成功！
-
输出解码词典
printf("decode dictionary:\n"); PrintDictionary();
- 对比编解码文件大小
发现压缩后的文件大小比原文件还要大，这可能是因为原文件字符重复率比较低而导致
- 更换一个字符重复率较高的文件
- 查看编码后的文件
- 对比编码后和解码后文件大小
观察到这个文件的压缩效果就很好
不同类型的文件
选择至少十种不同格式类型的文件，使用LZW编码器进行压缩得到输出的压缩比特流文件。对各种不同格式的文件进行压缩效率的分析。
原文件
编码后的文件
各个文件的编码词典总数
-
1.py：2418
-
2.jpeg：36735
-
3.pdf：65534
-
4.mp4：65534
-
5.docx：9990
-
6.yuv：65534
-
7.xlsx：7329
-
8.md：4582
-
9.wav：65534
-
10.pptx：43944
解码恢复后的文件
经检查，解码恢复后的文件内容与压缩前的文件内容相同
统计分析
观察到不同文件的压缩率差别非常的大，并且有很多文件在利用词典编码之后反而比原文件大了，猜测可能是因为文件中重复字符的概率较低而导致
LZW编码的特点和应用
- 优点：LZW只需要一遍扫描，具有自适应的特点；算法简单，便于快速实现（利用数字查找树/建树）
- 缺点：字符串重复概率低时，影响压缩效率，这是由输入字符流的统计特性决定的，很难解决；词典中的字符串不再出现的时候，会影响压缩效率；从词典中查找词条是算法中最费时的工作
- LZW编码的应用
- 通用文件压缩：WinZip
- 动画图像压缩：GIF，TIFF
- 电子邮件压缩
- PDF文档压缩
- 雷达数据压缩
- 等等
程序代码
bitio.h
/*
* Declaration for bitwise IO
*
* vim: ts=4 sw=4 cindent
*/
#ifndef __BITIO__
#define __BITIO__
#include bitio.cpp
/*
* Definitions for bitwise IO
*
* vim: ts=4 sw=4 cindent
*/
#include lzw.cpp
/*
* Definition for LZW coding
*
* vim: ts=4 sw=4 cindent nowrap
*/
#include \n" , argv[0]);
fprintf( stdout, "\t: E or D reffers encode or decode\n" );
fprintf( stdout, "\t: input file name\n" );
fprintf( stdout, "\t: output file name\n" );
return -1;
}
if( 'E' == argv[1][0]){ // do encoding argv[1][0]如果是E的话就进行编码
fp = fopen( argv[2], "rb"); //打开输入文件，编码前的文件
bf = OpenBitFileOutput( argv[3]); //打开输出文件，编码后的文件
if( NULL!=fp && NULL!=bf){ //如果两个文件均不为空
LZWEncode( fp, bf); //对输入文件fp编码生成输出文件bf，bf也就是压缩后的文件
fclose( fp); //关闭输入文件
CloseBitFileOutput( bf); //关闭输出文件
fprintf( stdout, "encoding done\n"); //输出编码成功
printf("encode dictionary:\n");
PrintDictionary();
}
}else if( 'D' == argv[1][0]){ // do decoding argv[1][0]如果是D的话就进行解码
bf = OpenBitFileInput( argv[2]); //打开输入文件，是压缩后的文件
fp = fopen( argv[3], "wb"); //以写的方式打开输出文件，是解压缩后的文件
if( NULL!=fp && NULL!=bf){ //如果两个文件不为空
LZWDecode( bf, fp); //对输入文件bf解码生成输出文件fp，fp就是解码后的文件
fclose( fp); //关闭输出文件
CloseBitFileInput( bf); //关闭输入文件
fprintf( stdout, "decoding done\n"); //输出解码成功
}
printf("decode dictionary:\n");
PrintDictionary();
}else{ // otherwise
fprintf( stderr, "not supported operation\n");
}
return 0;
}
实验总结
通过本次实验可以看到LZW编码方式虽然简单，但是很多时候编码效率并不是很好，这可能是因为对于数据流中连续重复出现的字节和字串，LZW压缩技术具有很高的压缩比，但事实上很多文件中并没有足够多的重复字符，因此无法体现出LZW编码的优势。