c语言中如何处理图片

在C语言中处理图片的核心观点是：使用库函数、操作文件、理解图像格式、进行像素操作。这些方法是处理图片的基础。使用库函数，如libjpeg或libpng，可以简化图片处理过程。下面详细描述使用库函数的步骤。

C语言本身不直接支持图像处理功能，因此我们需要借助一些第三方库来处理图像文件。例如，libjpeg库可以处理JPEG格式的图片，libpng库可以处理PNG格式的图片。使用这些库，可以方便地读取、修改和保存图像数据。首先需要安装并链接这些库，然后通过库提供的API进行图像处理。具体步骤包括：加载图片、处理像素数据、保存修改后的图片。使用库函数不仅可以提高开发效率，还能减少复杂性和错误率。

一、使用库函数

1.1、libjpeg库

libjpeg是处理JPEG格式图片的一个常用库。首先需要安装libjpeg库，然后通过其API进行图片处理。

安装libjpeg

在Linux系统上，可以通过包管理器安装libjpeg。例如，在Ubuntu上可以使用以下命令：

sudo apt-get install libjpeg-dev

使用libjpeg加载和保存图片

下面是一个使用libjpeg库读取和保存JPEG图片的简单示例：

#include <stdio.h>
#include <stdlib.h>
#include <jpeglib.h>
void read_jpeg_file(const char *filename) {
    struct jpeg_decompress_struct cinfo;
    struct jpeg_error_mgr jerr;
    FILE *infile;
    if ((infile = fopen(filename, "rb")) == NULL) {
        fprintf(stderr, "can't open %sn", filename);
        return;
    }
    cinfo.err = jpeg_std_error(&jerr);
    jpeg_create_decompress(&cinfo);
    jpeg_stdio_src(&cinfo, infile);
    jpeg_read_header(&cinfo, TRUE);
    jpeg_start_decompress(&cinfo);
    int row_stride = cinfo.output_width * cinfo.output_components;
    JSAMPARRAY buffer = (*cinfo.mem->alloc_sarray)
            ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
    while (cinfo.output_scanline < cinfo.output_height) {
        jpeg_read_scanlines(&cinfo, buffer, 1);
        // Here you can process the buffer, which contains one row of pixel data
    }
    jpeg_finish_decompress(&cinfo);
    jpeg_destroy_decompress(&cinfo);
    fclose(infile);
}
void write_jpeg_file(const char *filename, JSAMPARRAY image_buffer, int width, int height) {
    struct jpeg_compress_struct cinfo;
    struct jpeg_error_mgr jerr;
    FILE *outfile;
    if ((outfile = fopen(filename, "wb")) == NULL) {
        fprintf(stderr, "can't open %sn", filename);
        return;
    }
    cinfo.err = jpeg_std_error(&jerr);
    jpeg_create_compress(&cinfo);
    jpeg_stdio_dest(&cinfo, outfile);
    cinfo.image_width = width;
    cinfo.image_height = height;
    cinfo.input_components = 3;
    cinfo.in_color_space = JCS_RGB;
    jpeg_set_defaults(&cinfo);
    jpeg_start_compress(&cinfo, TRUE);
    while (cinfo.next_scanline < cinfo.image_height) {
        jpeg_write_scanlines(&cinfo, &image_buffer[cinfo.next_scanline], 1);
    }
    jpeg_finish_compress(&cinfo);
    jpeg_destroy_compress(&cinfo);
    fclose(outfile);
}
int main() {
    const char *input_file = "input.jpg";
    const char *output_file = "output.jpg";
    read_jpeg_file(input_file);
    // Process image data here
    // write_jpeg_file(output_file, image_buffer, width, height);
    return 0;
}

1.2、libpng库

libpng是处理PNG格式图片的一个常用库。与libjpeg类似，首先需要安装libpng库，然后通过其API进行图片处理。

安装libpng

在Linux系统上，可以通过包管理器安装libpng。例如，在Ubuntu上可以使用以下命令：

sudo apt-get install libpng-dev

使用libpng加载和保存图片

下面是一个使用libpng库读取和保存PNG图片的简单示例：

#include <stdio.h>
#include <stdlib.h>
#include <png.h>
void read_png_file(const char *filename) {
    FILE *fp = fopen(filename, "rb");
    if (!fp) {
        fprintf(stderr, "can't open %sn", filename);
        return;
    }
    png_structp png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
    if (!png) {
        fclose(fp);
        return;
    }
    png_infop info = png_create_info_struct(png);
    if (!info) {
        png_destroy_read_struct(&png, NULL, NULL);
        fclose(fp);
        return;
    }
    if (setjmp(png_jmpbuf(png))) {
        png_destroy_read_struct(&png, &info, NULL);
        fclose(fp);
        return;
    }
    png_init_io(png, fp);
    png_read_info(png, info);
    int width = png_get_image_width(png, info);
    int height = png_get_image_height(png, info);
    png_byte color_type = png_get_color_type(png, info);
    png_byte bit_depth = png_get_bit_depth(png, info);
    if (bit_depth == 16) {
        png_set_strip_16(png);
    }
    if (color_type == PNG_COLOR_TYPE_PALETTE) {
        png_set_palette_to_rgb(png);
    }
    if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
        png_set_expand_gray_1_2_4_to_8(png);
    }
    if (png_get_valid(png, info, PNG_INFO_tRNS)) {
        png_set_tRNS_to_alpha(png);
    }
    if (color_type == PNG_COLOR_TYPE_RGB || color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_PALETTE) {
        png_set_filler(png, 0xFF, PNG_FILLER_AFTER);
    }
    if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
        png_set_gray_to_rgb(png);
    }
    png_read_update_info(png, info);
    png_bytep *row_pointers = (png_bytep *) malloc(sizeof(png_bytep) * height);
    for (int y = 0; y < height; y++) {
        row_pointers[y] = (png_byte *) malloc(png_get_rowbytes(png, info));
    }
    png_read_image(png, row_pointers);
    fclose(fp);
    png_destroy_read_struct(&png, &info, NULL);
    // Process image data here
    for (int y = 0; y < height; y++) {
        free(row_pointers[y]);
    }
    free(row_pointers);
}
void write_png_file(const char *filename, png_bytep *row_pointers, int width, int height) {
    FILE *fp = fopen(filename, "wb");
    if (!fp) {
        fprintf(stderr, "can't open %sn", filename);
        return;
    }
    png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
    if (!png) {
        fclose(fp);
        return;
    }
    png_infop info = png_create_info_struct(png);
    if (!info) {
        png_destroy_write_struct(&png, NULL);
        fclose(fp);
        return;
    }
    if (setjmp(png_jmpbuf(png))) {
        png_destroy_write_struct(&png, &info);
        fclose(fp);
        return;
    }
    png_init_io(png, fp);
    png_set_IHDR(
            png,
            info,
            width, height,
            8,
            PNG_COLOR_TYPE_RGBA,
            PNG_INTERLACE_NONE,
            PNG_COMPRESSION_TYPE_DEFAULT,
            PNG_FILTER_TYPE_DEFAULT
    );
    png_write_info(png, info);
    png_write_image(png, row_pointers);
    png_write_end(png, NULL);
    fclose(fp);
    png_destroy_write_struct(&png, &info);
}
int main() {
    const char *input_file = "input.png";
    const char *output_file = "output.png";
    read_png_file(input_file);
    // Process image data here
    // write_png_file(output_file, row_pointers, width, height);
    return 0;
}

二、操作文件

2.1、读取文件

在C语言中，读取图像文件的第一步是打开文件并读取其内容。通常使用标准的文件I/O函数，如fopen、fread和fclose。对于图像文件，需要读取特定的文件头信息，以了解图像的格式、宽度、高度和颜色深度等。

FILE *fp = fopen("image.bmp", "rb");
if (!fp) {
    fprintf(stderr, "Cannot open filen");
    return -1;
}
// Read file header
unsigned char header[54];
fread(header, sizeof(unsigned char), 54, fp);
// Extract image information
int width = *(int*)&header[18];
int height = *(int*)&header[22];
int bitDepth = *(int*)&header[28];
fclose(fp);

2.2、写入文件

写入图像文件时，需要按照特定的文件格式写入文件头和图像数据。以BMP格式为例，首先写入文件头，然后写入像素数据。

FILE *fp = fopen("output.bmp", "wb");
if (!fp) {
    fprintf(stderr, "Cannot open filen");
    return -1;
}
// Write file header
unsigned char header[54] = { /* ... initialize header ... */ };
fwrite(header, sizeof(unsigned char), 54, fp);
// Write pixel data
for (int i = 0; i < height; i++) {
    for (int j = 0; j < width; j++) {
        unsigned char pixel[3] = { /* ... initialize pixel data ... */ };
        fwrite(pixel, sizeof(unsigned char), 3, fp);
    }
}
fclose(fp);

三、理解图像格式

3.1、BMP格式

BMP是最简单的图像格式之一，适合初学者理解和处理。BMP文件包含文件头、信息头和像素数据。文件头包含文件大小和像素数据的起始位置；信息头包含图像宽度、高度和颜色深度等信息；像素数据存储每个像素的颜色值。

typedef struct {
    unsigned char bfType[2];      // "BM"
    unsigned int bfSize;          // File size
    unsigned short bfReserved1;
    unsigned short bfReserved2;
    unsigned int bfOffBits;       // Offset to pixel data
} BMPFileHeader;
typedef struct {
    unsigned int biSize;          // Size of this header
    int biWidth;                  // Width of the image
    int biHeight;                 // Height of the image
    unsigned short biPlanes;
    unsigned short biBitCount;    // Bits per pixel
    unsigned int biCompression;
    unsigned int biSizeImage;
    int biXPelsPerMeter;
    int biYPelsPerMeter;
    unsigned int biClrUsed;
    unsigned int biClrImportant;
} BMPInfoHeader;

3.2、JPEG格式

JPEG是一种有损压缩图像格式，适用于存储照片。JPEG文件由多个段组成，每个段都有特定的标识符和长度。常见的段包括SOI（开始），APP0（应用数据），DQT（量化表），SOF（帧头），DHT（霍夫曼表），SOS（扫描头）和EOI（结束）。

typedef struct {
    unsigned short marker;        // Marker identifier
    unsigned short length;        // Length of the segment
    unsigned char data[];         // Segment data
} JPEGSegment;

四、进行像素操作

4.1、遍历像素

遍历图像中的每个像素是进行图像处理的基本步骤。例如，可以通过双重循环遍历BMP图像中的每个像素。

for (int y = 0; y < height; y++) {
    for (int x = 0; x < width; x++) {
        unsigned char r = pixel_data[y * width + x].r;
        unsigned char g = pixel_data[y * width + x].g;
        unsigned char b = pixel_data[y * width + x].b;
        // Process pixel data
    }
}

4.2、修改像素

修改像素值是图像处理的核心。例如，可以将图像转换为灰度图，通过计算每个像素的灰度值并修改其颜色。

for (int y = 0; y < height; y++) {
    for (int x = 0; x < width; x++) {
        unsigned char r = pixel_data[y * width + x].r;
        unsigned char g = pixel_data[y * width + x].g;
        unsigned char b = pixel_data[y * width + x].b;
        unsigned char gray = 0.3 * r + 0.59 * g + 0.11 * b;
        pixel_data[y * width + x].r = gray;
        pixel_data[y * width + x].g = gray;
        pixel_data[y * width + x].b = gray;
    }
}

五、图像处理算法

5.1、图像缩放

图像缩放是改变图像尺寸的常见操作。可以使用双线性插值算法进行图像缩放。该算法通过计算目标像素周围四个像素的加权平均值来确定目标像素的颜色。

void bilinear_interpolation(unsigned char *src, unsigned char *dst, int src_width, int src_height, int dst_width, int dst_height) {
    float x_ratio = (float)src_width / dst_width;
    float y_ratio = (float)src_height / dst_height;
    for (int y = 0; y < dst_height; y++) {
        for (int x = 0; x < dst_width; x++) {
            int x_l = (int)(x * x_ratio);
            int y_l = (int)(y * y_ratio);
            int x_h = x_l + 1;
            int y_h = y_l + 1;
            if (x_h >= src_width) x_h = src_width - 1;
            if (y_h >= src_height) y_h = src_height - 1;
            float x_diff = (x * x_ratio) - x_l;
            float y_diff = (y * y_ratio) - y_l;
            unsigned char a = src[y_l * src_width + x_l];
            unsigned char b = src[y_l * src_width + x_h];
            unsigned char c = src[y_h * src_width + x_l];
            unsigned char d = src[y_h * src_width + x_h];
            unsigned char pixel = (unsigned char)(
                    a * (1 - x_diff) * (1 - y_diff) +
                    b * x_diff * (1 - y_diff) +
                    c * y_diff * (1 - x_diff) +
                    d * x_diff * y_diff
            );
            dst[y * dst_width + x] = pixel;
        }
    }
}

5.2、图像旋转

图像旋转是将图像按指定角度旋转的操作。可以使用最近邻插值算法进行图像旋转。该算法通过查找最近的像素并将其值赋给目标像素来确定目标像素的颜色。

void nearest_neighbor_rotation(unsigned char *src, unsigned char *dst, int width, int height, float angle) {
    float rad = angle * M_PI / 180;
    float cos_a = cos(rad);
    float sin_a = sin(rad);
    int cx = width / 2;
    int cy = height / 2;
    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            int nx = cos_a * (x - cx) - sin_a * (y - cy) + cx;
            int ny = sin_a * (x - cx) + cos_a * (y - cy) + cy;
            if (nx >= 0 && nx < width && ny >= 0 && ny < height) {
                dst[y * width + x] = src[ny * width + nx];
            } else {
                dst[y * width + x] = 0; // Background color
            }
        }
    }
}

六、图像滤波

6.1、均值滤波

均值滤波是一种简单的图像平滑算法，通过计算像素邻域内像素值的平均值来平滑图像。

void mean_filter(unsigned char *src, unsigned char *dst, int width, int height) {
    int kernel_size = 3;
    int offset = kernel_size / 2;
    for (int y = offset; y < height - offset; y++) {
        for (int x = offset; x < width - offset; x++) {
            int sum = 0;
            for (int ky = -offset; ky <= offset; ky++) {
                for (int kx = -offset; kx <= offset; kx++) {
                    sum += src[(y + ky) * width + (x + kx)];
                }
            }
            dst[y * width + x] = sum / (kernel_size * kernel_size);
        }
    }
}

6.2、高斯滤波

高斯滤波是一种常用的图像平滑算法，通过计算像素邻域内像素值的加权平均值来平滑图像。权重由高斯函数确定。

void gaussian_filter(unsigned char *src, unsigned char *dst, int width, int height) {