基于c语言的图像卷积计算

以下是基于C语言的图像卷积计算程序，主要利用了二维数组和嵌套循环实现：

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

void convolution(int **input, int **kernel, int **output, int rows, int cols, int kRows, int kCols) {
    int i, j, m, n;
    int kCenterRow = kRows / 2;
    int kCenterCol = kCols / 2;

    // 对每个像素进行卷积计算
    for(i = 0; i < rows; ++i) {
        for(j = 0; j < cols; ++j) {
            output[i][j] = 0;
            for(m = 0; m < kRows; ++m) {
                for(n = 0; n < kCols; ++n) {
                    // 计算卷积结果
                    int ii = i + (m - kCenterRow);
                    int jj = j + (n - kCenterCol);
                    if(ii >= 0 && ii < rows && jj >= 0 && jj < cols) {
                        output[i][j] += input[ii][jj] * kernel[m][n];
                    }
                }
            }
        }
    }
}

int main() {
    int rows, cols, kRows, kCols;
    int **input, **kernel, **output;
    int i, j;

    // 读取输入图像和卷积核
    scanf("%d%d", &rows, &cols);
    input = (int **)malloc(rows * sizeof(int *));
    for(i = 0; i < rows; ++i) {
        input[i] = (int *)malloc(cols * sizeof(int));
        for(j = 0; j < cols; ++j) {
            scanf("%d", &input[i][j]);
        }
    }

    scanf("%d%d", &kRows, &kCols);
    kernel = (int **)malloc(kRows * sizeof(int *));
    for(i = 0; i < kRows; ++i) {
        kernel[i] = (int *)malloc(kCols * sizeof(int));
        for(j = 0; j < kCols; ++j) {
            scanf("%d", &kernel[i][j]);
        }
    }

    // 初始化输出图像
    output = (int **)malloc(rows * sizeof(int *));
    for(i = 0; i < rows; ++i) {
        output[i] = (int *)malloc(cols * sizeof(int));
    }

    // 进行卷积计算
    convolution(input, kernel, output, rows, cols, kRows, kCols);

    // 输出卷积结果
    printf("%d %d\n", rows, cols);
    for(i = 0; i < rows; ++i) {
        for(j = 0; j < cols; ++j) {
            printf("%d ", output[i][j]);
        }
        printf("\n");
    }

    // 释放内存
    for(i = 0; i < rows; ++i) {
        free(input[i]);
        free(output[i]);
    }
    free(input);
    free(output);

    for(i = 0; i < kRows; ++i) {
        free(kernel[i]);
    }
    free(kernel);

    return 0;
}

上述程序中，我们使用了二维数组来存储输入图像、卷积核和输出图像，并通过嵌套循环遍历每个像素进行卷积计算。需要注意的是，卷积核的中心位置需要根据其大小进行计算，以确保卷积计算的正确性。

在程序中，我们采用了动态内存分配来分配二维数组的内存空间，需要在程序结束时进行相应的内存释放操作，以避免内存泄漏。