计算机图像处理实验二（C语言）

已于 2023-05-22 12:52:15 修改
阅读量307 收藏 1
点赞数
分类专栏： 图像处理 文章标签： c语言 图像处理 c++
于 2023-05-17 14:42:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62549323/article/details/130724372
版权

实验任务：Huffman编解码

已知：

  1. 原灰度图像Is：b8gray.bmp
    图片在实验一中已经给出。
    求：
  2. 代码
  3. 编码后的bpp值
  4. 原灰度图像的熵
    验证:
  5. 编码程序，输入为Is，输出为压缩文件C.dat
  6. 解码程序，输入为C.dat，输出为解码图像Id
  7. Is与Id是否相同
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define MAX_TREE_NODES 256

// Huffman树节点
typedef struct Node
{
    unsigned char symbol;
    int frequency;
    struct Node *left;
    struct Node *right;
} Node;

// 优先队列
typedef struct PriorityQueue
{
    int size;
    int capacity;
    Node **nodes;
} PriorityQueue;

// 创建Huffman树节点
Node *createNode(unsigned char symbol, int frequency)
{
    Node *node = (Node *)malloc(sizeof(Node));
    node->symbol = symbol;
    node->frequency = frequency;
    node->left = NULL;
    node->right = NULL;
    return node;
}

// 创建优先队列
PriorityQueue *createPriorityQueue(int capacity)
{
    PriorityQueue *queue = (PriorityQueue *)malloc(sizeof(PriorityQueue));
    queue->size = 0;
    queue->capacity = capacity;
    queue->nodes = (Node **)malloc(capacity * sizeof(Node *));
    return queue;
}

// 交换两个节点
void swapNodes(Node **a, Node **b)
{
    Node *temp = *a;
    *a = *b;
    *b = temp;
}

// 从优先队列中获取最小频率的节点
Node *extractMin(PriorityQueue *queue)
{
    int minIndex = 0;
    for (int i = 1; i < queue->size; i++)
    {
        if (queue->nodes[i]->frequency < queue->nodes[minIndex]->frequency)
        {
            minIndex = i;
        }
    }

    Node *minNode = queue->nodes[minIndex];
    queue->size--;
    swapNodes(&queue->nodes[minIndex], &queue->nodes[queue->size]);
    return minNode;
}

// 插入节点到优先队列
void insertNode(PriorityQueue *queue, Node *node)
{
    int i = queue->size;
    while (i > 0 && node->frequency < queue->nodes[i - 1]->frequency)
    {
        queue->nodes[i] = queue->nodes[i - 1];
        i--;
    }
    queue->nodes[i] = node;
    queue->size++;
}

// 构建Huffman树
Node *buildHuffmanTree(int *frequencies)
{
    PriorityQueue *queue = createPriorityQueue(MAX_TREE_NODES);

    for (int i = 0; i < MAX_TREE_NODES; i++)
    {
        if (frequencies[i] > 0)
        {
            Node *node = createNode(i, frequencies[i]);
            insertNode(queue, node);
        }
    }

    while (queue->size > 1)
    {
        Node *left = extractMin(queue);
        Node *right = extractMin(queue);

        Node *parent = createNode('$', left->frequency + right->frequency);
        parent->left = left;
        parent->right = right;

        insertNode(queue, parent);
    }

    Node *root = extractMin(queue);
    free(queue->nodes);
    free(queue);
    return root;
}

// 递归地构建Huffman编码
void buildHuffmanCodes(Node *node, unsigned long code, int length, unsigned long *codes, int *lengths)
{
    if (node->left == NULL && node->right == NULL)
    {
        codes[node->symbol] = code;
        lengths[node->symbol] = length;
    }
    else
    {
        buildHuffmanCodes(node->left, (code << 1) | 0, length + 1, codes, lengths);
        buildHuffmanCodes(node->right, (code << 1) | 1, length + 1, codes, lengths);
    }
}

// 将Huffman编码保存到文件
void saveHuffmanCodes(FILE *file, unsigned long *codes, int *lengths)
{
    for (int i = 0; i < MAX_TREE_NODES; i++)
    {
        if (lengths[i] > 0)
        {
            unsigned char symbol = (unsigned char)i;
            fwrite(&symbol, sizeof(unsigned char), 1, file);
            fwrite(&lengths[i], sizeof(int), 1, file);
            fwrite(&codes[i], sizeof(unsigned long), 1, file);
        }
    }
}
// 从文件中加载Huffman编码
void loadHuffmanCodes(FILE *file, unsigned long *codes, int *lengths)
{
    unsigned char symbol;
    int length;
    unsigned long code;
    while (fread(&symbol, sizeof(unsigned char), 1, file) == 1)
    {
        fread(&length, sizeof(int), 1, file);
        fread(&code, sizeof(unsigned long), 1, file);
        codes[symbol] = code;
        lengths[symbol] = length;
    }
}
// 获取文件大小
long getFileSize(FILE *file)
{
    fseek(file, 0, SEEK_END);
    long size = ftell(file);
    rewind(file);
    return size;
}

// 对图像进行Huffman编码
void encodeImage(FILE *inputFile, FILE *outputFile, unsigned long *codes, int *lengths, int *bpp)
{
    unsigned char buffer = 0;
    int bufferLength = 0;
    unsigned char pixel;
    long inputSize = getFileSize(inputFile);
    while (fread(&pixel, sizeof(unsigned char), 1, inputFile) == 1)
    {
        unsigned long code = codes[pixel];
        int length = lengths[pixel];

        for (int i = 0; i < length; i++)
        {
            buffer = (buffer << 1) | ((code >> (length - 1 - i)) & 1);
            bufferLength++;

            if (bufferLength == 8)
            {
                fwrite(&buffer, sizeof(unsigned char), 1, outputFile);
                buffer = 0;
                bufferLength = 0;
            }
        }
    }

    if (bufferLength > 0)
    {
        buffer = buffer << (8 - bufferLength);
        fwrite(&buffer, sizeof(unsigned char), 1, outputFile);
    }

    // 计算压缩后的bpp值
    long outputSize = getFileSize(outputFile);
    *bpp = (int)(outputSize * 8 / (float)inputSize);
}
// 对Huffman编码进行解码
void decodeImage(FILE *inputFile, FILE *outputFile, Node *root, long inputSize)
{
    Node *currentNode = root;
    unsigned char byte;
    unsigned char bit;
    long bytesRead = 0;
    while (fread(&byte, sizeof(unsigned char), 1, inputFile) == 1 && bytesRead < inputSize)
    {
        for (int i = 7; i >= 0; i--)
        {
            bit = (byte >> i) & 1;

            if (bit == 0)
            {
                currentNode = currentNode->left;
            }
            else
            {
                currentNode = currentNode->right;
            }

            if (currentNode->left == NULL && currentNode->right == NULL)
            {
                fwrite(&(currentNode->symbol), sizeof(unsigned char), 1, outputFile);
                currentNode = root;
            }

            bytesRead++;

            if (bytesRead >= inputSize)
            {
                break;
            }
        }
    }
}
double computeEntropy(int *frequencies, int totalPixels)
{
    double entropy = 0.0;

    for (int i = 0; i < MAX_TREE_NODES; i++)
    {
        if (frequencies[i] > 0)
        {
            double probability = (double)frequencies[i] / totalPixels;
            entropy -= probability * log2(probability);
        }
    }

    return entropy;
}
int main()
{
    // 读取图像文件和创建输出文件
    FILE *input = fopen("b8gray.bmp", "rb");
    FILE *output = fopen("C.dat", "wb");
    // 计算图像中每个像素的频率
    int frequencies[MAX_TREE_NODES] = {0};
    unsigned char pixel;
    int totalPixels = 0;
    while (fread(&pixel, sizeof(unsigned char), 1, input) == 1)
    {
        frequencies[pixel]++;
        totalPixels++;
    }
    rewind(input);
    // 计算灰度图像的熵
    double entropy = computeEntropy(frequencies, totalPixels);
    printf("原灰度图像的熵：%f\n", entropy);

    // 构建Huffman树
    Node *root = buildHuffmanTree(frequencies);

    // 构建Huffman编码
    unsigned long codes[MAX_TREE_NODES] = {0};
    int lengths[MAX_TREE_NODES] = {0};
    buildHuffmanCodes(root, 0, 0, codes, lengths);

    // 将Huffman编码保存到文件
    saveHuffmanCodes(output, codes, lengths);

    // 对图像进行编码
    int bpp;
    encodeImage(input, output, codes, lengths, &bpp);
    printf("压缩后的bpp值：%d\n", bpp);

    fclose(input);
    fclose(output);

    // 解码
    FILE *compressed = fopen("C.dat", "rb");
    FILE *decoded = fopen("Id.bmp", "wb");

    // 加载Huffman编码
    unsigned long loadedCodes[MAX_TREE_NODES] = {0};
    int loadedLengths[MAX_TREE_NODES] = {0};
    loadHuffmanCodes(compressed, loadedCodes, loadedLengths);

    // 重新构建Huffman树
    Node *decodedRoot = buildHuffmanTree(loadedLengths);

    // 解码图像
    long inputSize = getFileSize(compressed);
    decodeImage(compressed, decoded, decodedRoot, inputSize);

    fclose(compressed);
    fclose(decoded);

    return 0;
}

上述代码运行后，对b8gray.bmp文件进行编码再解码后，生成的Id.bmp大小与源文件不同，（可能代码有误，之后解决问题后再更改文章）

主要步骤：

  1. 定义了Huffman树节点结构体（Node）和优先队列结构体（PriorityQueue），用于构建Huffman树和管理节点。

  2. 创建Huffman树节点的函数（createNode）用于创建一个新的节点。

  3. 创建优先队列的函数（createPriorityQueue）用于创建一个空的优先队列。

  4. 交换节点的函数（swapNodes）用于交换两个节点的位置。

  5. 从优先队列中获取最小频率的节点的函数（extractMin）用于从优先队列中取出频率最小的节点。

  6. 插入节点到优先队列的函数（insertNode）用于将一个节点插入到优先队列中的适当位置。

  7. 构建Huffman树的函数（buildHuffmanTree）根据给定的字符频率数组构建Huffman树。

  8. 递归地构建Huffman编码的函数（buildHuffmanCodes）根据Huffman树节点，计算每个字符的Huffman编码和编码长度。

  9. 将Huffman编码保存到文件的函数（saveHuffmanCodes）将每个字符的编码和长度保存到输出文件中。

  10. 从文件中加载Huffman编码的函数（loadHuffmanCodes）从输入文件中加载每个字符的编码和长度。

  11. 获取文件大小的函数（getFileSize）用于计算给定文件的大小。

  12. 对图像进行Huffman编码的函数（encodeImage）将输入图像文件中的像素值根据Huffman编码转换为压缩后的二进制数据，并保存到输出文件中。同时计算压缩后的bpp值。

  13. 对Huffman编码进行解码的函数（decodeImage）将压缩后的二进制数据根据Huffman编码进行解码，并将解码后的像素值写入到输出文件中。

  14. 主函数中执行以下操作：

  • 打开输入图像文件和输出文件。
  • 计算图像中每个像素的频率。
  • 构建Huffman树。
  • 构建Huffman编码。
  • 将Huffman编码保存到文件。
  • 对图像进行编码并计算压缩后的bpp值。
  • 关闭输入和输出文件。
  • 打开压缩后的文件和解码后的输出文件。
  • 加载Huffman编码。
  • 重新构建Huffman树。
  • 解码图像。
  • 关闭压缩文件和解码文件。

解决遗留问题：上述代码的压缩和解压缩过程是基于像素值进行的，并使用Huffman编码来表示每个像素值。因此，如果输入图像（C.dat）是非像素图像，则无法正确执行解码过程。

努力学习的小天
关注
专栏目录
计算机图形图像处理 实验二
BRAVE
05-03 1424
计算机图形图像处理 一 图像平滑 均值滤波 中值滤波 高斯滤波 实验结果 二 图像锐化 Sobel算子 Robert算子 Prewitt算子 Laplacian算子 LOG算子 实验结果 三 图像去噪 高斯噪声 椒盐噪声 均匀噪声
计算机图形图像处理 实验一
BRAVE
04-11 3205
opencv对图像的处理 图像加减乘除运算 图像灰度级变换 图像求反 图像变换 直方图均衡化处理
C语言图像处理
05-24
介绍如何使用C语言实现数字图像处理的过程及数字图像处理的理论
C语言图像处理方法
Y·F·C
11-06 2247
　　1．图像平移　　图像平移只是改变图像在屏幕上的位置，图像本身并不发生变化。　　假设原图像区域左上角坐标为(x0, y0)，右下角坐标为(x1, y1)，将图像分别沿x和y轴平移dx和dy，则新图像的左上角坐标为(x0 ＋ dx, y0 ＋ dy)，右下角坐标为(x1 ＋ dx, y1 ＋ dy)。坐标平移变换公式为：　　x′ = x ＋ dx　　y′ = y ＋ dy　　在屏幕上实现图像的移动
C语言图像处理代码
11-11
各种c语言处理图像的代码，中值滤波、直方图处理、旋转平移等等
C语言图像处理教程
02-03
经典的C语言图像处理教材，内容详细，深入浅出，入门必备
图像处理基本算法 C语言实现
06-28
图像平滑、图像增强、图像分割、图像二值化、图像画图工具如圆、直线、像素值趋势线等
数字图像处理实验二直方图均衡C语言.zip
05-14
在数字图像处理领域，直方图均衡化是一种重要的图像增强...总之，通过这个实验，你可以了解到数字图像处理中直方图均衡化的基本原理和C语言编程技巧，这对于进一步学习图像处理算法和计算机视觉领域都是很有帮助的。
基于opencv和c语言的图像处理程序
03-04
本项目是“基于OpenCV和C语言的图像处理程序”，旨在实现图像的美白和磨皮效果，并提供了可视化界面。下面将详细讨论相关知识点。 首先，OpenCV库提供了丰富的图像处理函数，涵盖了从基本的图像读取、显示到复杂的...
一个C语言写的小型图像处理库
02-23
这是一个基于C语言的小型图像处理库（VC++6.0工程），可以用来读取BMP，JPG格式的文件，第一次运行过程中间会报错出现断言，是正常现象，点击重试即可运行完成
C语言实用数字图像处理（日本人写的，容易懂挺不错）
06-26
C语言实用数字图像处理（日本人写的，容易懂挺不错），里面包含了相应的代码。
用C语言进行数字图像处理
03-05
单纯用C语言，而不是C++实现的数字图像处理。这里只是抛砖引玉，所以，只做了用C语言读入位图、保存位图等。当然包括获得位图的各种信息。 在VC6.0下，无误通过编译。
c语言图像处理
05-07
利用c语言进行图像处理，关于这方面的中文资料非常少，这个一本很不错的英文书籍，利用作者编写的c语言图像处理库对图像处理函数进行细致的讲解
C语言图像处理程序设计
11-05
C语言图像处理程序设计 非常好的图片处理资料
C语言数字图像处理（四）：图像边缘检测和灰度变换：拉普拉斯，Sobel，伽玛校正，和直方图增强
最新发布
Wilson_Lin_01的博客
11-17 1102
拉普拉斯算子通过增强图像的灰度对比来实现锐化效果。作为一个二阶微分算子，它增强了图像中灰度突变的区域，并减弱了灰度变化缓慢的区域。但处理后的图像失去了边缘的方向信息，并增强了噪声。 Sobel算子属于一阶微分边缘检测算子，它引入了类似于局部平均的运算，因此在强化图像对象边缘的同时对噪声具有平滑作用。 经过微分后，平坦处的值几乎为0，而边缘处的绝对值很大。 但Sobel算子并没有严格区分图像主体和背景，因此提取的图像轮廓有时并不令人满意。 首先使用归一化（normalization）处理像素：将像素值转换为
自编图像处理实验.zip
01-30
在本压缩包“自编图像处理实验.zip”中，我们主要关注的是图像处理技术的实践应用，特别是通过C语言编程实现。图像处理是一门涵盖广泛的技术领域，它涉及到计算机视觉、数字信号处理以及图形学等多个学科。在这个...
c语言可以处理图像吗,C语言图像处理方法
weixin_35033275的博客
05-23 2416
最近在学习C语言图像处理，真的很郁闷，感觉摸不到门道，而且老师要求尽快掌握，还要处理一些图像数据，只能在网上找找现成的消化下，希望能有助有学习和理解。C语言图像处理方法1．图像平移图像平移只是改变图像在屏幕上的位置，图像本身并不发生变化。1．图像平移图像平移只是改变图像在屏幕上的位置，图像本身并不发生变化。假设原图像区域左上角坐标为(x0, y0)，右下角坐标为(x1, y1)，将图像分别沿x和y...
c语言数字图像处理
hshqing的博客
05-28 9707
转载：https://www.cnblogs.com/GoldBeetle/p/9614287.html
BMP图像处理：输入输出实现与实验报告
总结来说，这个实验旨在通过实践加深对BMP图像格式的理解，提升C语言编程能力，同时熟悉Windows环境下图像处理程序的开发过程。通过完成这个项目，学生能够具备基本的图像文件操作技能，这对于进一步学习图像处理和...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值