基于离散余弦变换的数字图像压缩算法实现c语言实现

数字图像压缩算法中，基于离散余弦变换（DCT）的压缩算法是比较常用的一种。下面是一个简单的C语言实现：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define BLOCK_SIZE 8 // 定义块大小为8x8
#define IMAGE_SIZE 512 // 定义图像大小为512x512

// 定义DCT系数矩阵
double c[BLOCK_SIZE][BLOCK_SIZE] = {0};
double dct_matrix[BLOCK_SIZE][BLOCK_SIZE] = {0};
void init_DCT_matrix()
{
    for(int i=0;i<BLOCK_SIZE;i++){
        for(int j=0;j<BLOCK_SIZE;j++){
            if(i==0){
                c[i][j] = sqrt(1.0/BLOCK_SIZE);
            }else{
                c[i][j] = sqrt(2.0/BLOCK_SIZE) * cos((2*j+1)*i*M_PI/(2*BLOCK_SIZE));
            }
        }
    }
    for(int i=0;i<BLOCK_SIZE;i++){
        for(int j=0;j<BLOCK_SIZE;j++){
            for(int k=0;k<BLOCK_SIZE;k++){
                dct_matrix[i][j] += c[i][k] * c[j][k];
            }
        }
    }
}

// DCT变换函数
void DCT(double block[BLOCK_SIZE][BLOCK_SIZE])
{
    double tmp[BLOCK_SIZE][BLOCK_SIZE] = {0};
    for(int i=0;i<BLOCK_SIZE;i++){
        for(int j=0;j<BLOCK_SIZE;j++){
            for(int k=0;k<BLOCK_SIZE;k++){
                tmp[i][j] += c[k][i] * block[k][j];
            }
        }
    }
    for(int i=0;i<BLOCK_SIZE;i++){
        for(int j=0;j<BLOCK_SIZE;j++){
            block[i][j] = 0;
            for(int k=0;k<BLOCK_SIZE;k++){
                block[i][j] += tmp[i][k] * c[k][j];
            }
        }
    }
}

// 块处理函数
void process_block(double block[BLOCK_SIZE][BLOCK_SIZE])
{
    // 对块进行DCT变换
    DCT(block);
    
    // 对DCT系数进行量化
    int quantization_table[BLOCK_SIZE][BLOCK_SIZE] = {
        {16, 11, 10, 16, 24, 40, 51, 61},
        {12, 12, 14, 19, 26, 58, 60, 55},
        {14, 13, 16, 24, 40, 57, 69, 56},
        {14, 17, 22, 29, 51, 87, 80, 62},
        {18, 22, 37, 56, 68, 109, 103, 77},
        {24, 35, 55, 64, 81, 104, 113, 92},
        {49, 64, 78, 87, 103, 121, 120, 101},
        {72, 92, 95, 98, 112, 100, 103, 99}
    };
    for(int i=0;i<BLOCK_SIZE;i++){
        for(int j=0;j<BLOCK_SIZE;j++){
            block[i][j] = round(block[i][j] / quantization_table[i][j]);
        }
    }
}

// 块反向处理函数
void reverse_process_block(double block[BLOCK_SIZE][BLOCK_SIZE])
{
    // 对DCT系数进行反向量化
    int quantization_table[BLOCK_SIZE][BLOCK_SIZE] = {
        {16, 11, 10, 16, 24, 40, 51, 61},
        {12, 12, 14, 19, 26, 58, 60, 55},
        {14, 13, 16, 24, 40, 57, 69, 56},
        {14, 17, 22, 29, 51, 87, 80, 62},
        {18, 22, 37, 56, 68, 109, 103, 77},
        {24, 35, 55, 64, 81, 104, 113, 92},
        {49, 64, 78, 87, 103, 121, 120, 101},
        {72, 92, 95, 98, 112, 100, 103, 99}
    };
    for(int i=0;i<BLOCK_SIZE;i++){
        for(int j=0;j<BLOCK_SIZE;j++){
            block[i][j] *= quantization_table[i][j];
        }
    }
    
    // 对块进行IDCT变换
    double tmp[BLOCK_SIZE][BLOCK_SIZE] = {0};
    for(int i=0;i<BLOCK_SIZE;i++){
        for(int j=0;j<BLOCK_SIZE;j++){
            for(int k=0;k<BLOCK_SIZE;k++){
                tmp[i][j] += c[k][i] * block[k][j];
            }
        }
    }
    for(int i=0;i<BLOCK_SIZE;i++){
        for(int j=0;j<BLOCK_SIZE;j++){
            block[i][j] = 0;
            for(int k=0;k<BLOCK_SIZE;k++){
                block[i][j] += tmp[i][k] * c[k][j];
            }
            block[i][j] = round(block[i][j]);
        }
    }
}

// 主函数
int main()
{
    // 读取原始图像
    FILE* fp_in = fopen("lena512.bmp", "rb");
    if(fp_in == NULL){
        printf("can't open file\n");
        return -1;
    }
    unsigned char img_in[IMAGE_SIZE][IMAGE_SIZE] = {0};
    fread(img_in, sizeof(unsigned char), IMAGE_SIZE*IMAGE_SIZE, fp_in);
    fclose(fp_in);

    // 对图像进行块处理
    init_DCT_matrix();
    for(int i=0;i<IMAGE_SIZE/BLOCK_SIZE;i++){
        for(int j=0;j<IMAGE_SIZE/BLOCK_SIZE;j++){
            double block[BLOCK_SIZE][BLOCK_SIZE] = {0};
            for(int x=0;x<BLOCK_SIZE;x++){
                for(int y=0;y<BLOCK_SIZE;y++){
                    block[x][y] = img_in[i*BLOCK_SIZE+x][j*BLOCK_SIZE+y];
                }
            }
            process_block(block);
            for(int x=0;x<BLOCK_SIZE;x++){
                for(int y=0;y<BLOCK_SIZE;y++){
                    img_in[i*BLOCK_SIZE+x][j*BLOCK_SIZE+y] = block[x][y];
                }
            }
        }
    }

    // 对处理后的图像进行反向块处理
    for(int i=0;i<IMAGE_SIZE/BLOCK_SIZE;i++){
        for(int j=0;j<IMAGE_SIZE/BLOCK_SIZE;j++){
            double block[BLOCK_SIZE][BLOCK_SIZE] = {0};
            for(int x=0;x<BLOCK_SIZE;x++){
                for(int y=0;y<BLOCK_SIZE;y++){
                    block[x][y] = img_in[i*BLOCK_SIZE+x][j*BLOCK_SIZE+y];
                }
            }
            reverse_process_block(block);
            for(int x=0;x<BLOCK_SIZE;x++){
                for(int y=0;y<BLOCK_SIZE;y++){
                    img_in[i*BLOCK_SIZE+x][j*BLOCK_SIZE+y] = block[x][y];
                }
            }
        }
    }

    // 输出压缩后的图像
    FILE* fp_out = fopen("lena512_out.bmp", "wb");
    if(fp_out == NULL){
        printf("can't open file\n");
        return -1;
    }
    fwrite(img_in, sizeof(unsigned char), IMAGE_SIZE*IMAGE_SIZE, fp_out);
    fclose(fp_out);

    return 0;
}

上述代码中，我们定义了一个8x8的块大小，并使用DCT变换将每个块压缩，然后再使用反向DCT变换反向压缩，最终输出压缩后的图像。其中，量化表用于对DCT系数进行量化，可以根据具体需求设置不同的量化表。