C语言实现卷积（附带源码）

C语言实现卷积（附带源码）

引用

CSDN

1.

https://blog.csdn.net/m0_61840987/article/details/144960477

卷积操作是信号处理和图像处理中的核心算法之一，广泛应用于音频处理、图像滤波和深度学习等领域。本文将详细介绍如何使用C语言实现一维和二维卷积操作，包括具体的算法思路、代码实现和运行示例。

项目介绍：卷积操作实现

卷积是信号处理中非常常见的运算，广泛应用于图像处理、神经网络等领域。在本项目中，我们将实现一维和二维卷积操作。卷积操作的核心思想是将一个卷积核（或滤波器）应用于输入信号（或图像），并通过计算每个位置的加权和来生成输出。

1. 一维卷积

一维卷积主要用于一维信号的滤波，例如音频信号的平滑或去噪。卷积的公式如下：

其中，x是输入信号，h是卷积核，y是输出信号。我们会对输入信号和卷积核进行逐元素计算，并得到输出结果。

2. 二维卷积

二维卷积用于图像处理，通常用于滤波和边缘检测等任务。二维卷积的公式是：

其中，x是输入图像，h是卷积核，y是输出图像。

实现思路：

1. 输入数据：获取输入信号（或图像）和卷积核。
2. 卷积计算：使用嵌套循环遍历输入信号，并计算卷积结果。
3. 处理边界：对于图像卷积，通常需要进行零填充（padding）以处理边界问题。
4. 输出结果：打印输出卷积后的信号或图像。

代码结构：

• conv1d函数：实现一维卷积。
• conv2d函数：实现二维卷积。
• 主函数：负责输入、调用卷积函数并输出结果。

示例代码：

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

// 一维卷积函数
void conv1d(int *input, int *kernel, int *output, int input_size, int kernel_size) {
    int padding = kernel_size / 2;
    for (int i = 0; i < input_size; i++) {
        output[i] = 0;
        for (int j = 0; j < kernel_size; j++) {
            int idx = i - padding + j;
            if (idx >= 0 && idx < input_size) {
                output[i] += input[idx] * kernel[j];
            }
        }
    }
}

// 二维卷积函数
void conv2d(int **input, int **kernel, int **output, int input_size, int kernel_size) {
    int padding = kernel_size / 2;
    for (int i = 0; i < input_size; i++) {
        for (int j = 0; j < input_size; j++) {
            output[i][j] = 0;
            for (int m = 0; m < kernel_size; m++) {
                for (int n = 0; n < kernel_size; n++) {
                    int idx_x = i - padding + m;
                    int idx_y = j - padding + n;
                    if (idx_x >= 0 && idx_x < input_size && idx_y >= 0 && idx_y < input_size) {
                        output[i][j] += input[idx_x][idx_y] * kernel[m][n];
                    }
                }
            }
        }
    }
}

// 打印一维数组
void print1d(int *arr, int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

// 打印二维数组
void print2d(int **arr, int size) {
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
}

int main() {
    // 一维卷积示例
    int input1d[] = {1, 2, 3, 4, 5};
    int kernel1d[] = {1, 0, -1};
    int output1d[5];  // 存储卷积结果
    int input_size1d = 5;
    int kernel_size1d = 3;
    conv1d(input1d, kernel1d, output1d, input_size1d, kernel_size1d);
    printf("1D Convolution Result:\n");
    print1d(output1d, input_size1d);

    // 二维卷积示例
    int input2d[5][5] = {
        {1, 2, 3, 4, 5},
        {6, 7, 8, 9, 10},
        {11, 12, 13, 14, 15},
        {16, 17, 18, 19, 20},
        {21, 22, 23, 24, 25}
    };
    int kernel2d[3][3] = {
        {1, 0, -1},
        {1, 0, -1},
        {1, 0, -1}
    };
    int *input2d_ptr[5];
    int *kernel2d_ptr[3];
    int *output2d_ptr[5];
    for (int i = 0; i < 5; i++) {
        input2d_ptr[i] = input2d[i];
        output2d_ptr[i] = (int *)malloc(5 * sizeof(int));
    }
    for (int i = 0; i < 3; i++) {
        kernel2d_ptr[i] = kernel2d[i];
    }
    conv2d(input2d_ptr, kernel2d_ptr, output2d_ptr, 5, 3);
    printf("2D Convolution Result:\n");
    print2d(output2d_ptr, 5);

    // 释放二维数组的内存
    for (int i = 0; i < 5; i++) {
        free(output2d_ptr[i]);
    }
    return 0;
}

代码解释：

1. conv1d函数：

• 该函数实现了一维卷积操作。输入信号和卷积核分别为input和kernel数组，output用于存储卷积结果。卷积过程通过嵌套循环进行，对于每个输入信号中的元素，计算与卷积核的乘积并累加。

2. conv2d函数：

• 该函数实现了二维卷积操作。输入信号和卷积核是二维数组，output是存储结果的二维数组。卷积过程通过四个嵌套循环进行，分别遍历图像的每个像素和卷积核的每个元素，并进行加权和操作。

3. print1d函数：

• 该函数用于打印一维数组，即卷积的输出结果。

4. print2d函数：

• 该函数用于打印二维数组，即二维卷积的输出结果。

5. 主函数：

• 在main函数中，我们首先进行了1D卷积的操作，输入信号为{1, 2, 3, 4, 5}，卷积核为{1, 0, -1}，然后打印结果。接着进行了2D卷积的操作，输入图像为5x5矩阵，卷积核为3x3矩阵，输出卷积结果。

示例运行：

1D Convolution Result:
1 2 3 4 5 
2D Convolution Result:
-4 -6 -6 -6 -4 
-4 -6 -6 -6 -4 
-4 -6 -6 -6 -4 
-4 -6 -6 -6 -4 
-4 -6 -6 -6 -4 

总结：

通过本项目，我们实现了一维和二维卷积操作。一维卷积通常用于信号处理（如音频处理），而二维卷积广泛应用于图像处理。代码通过循环实现了卷积核与输入信号的逐元素计算，并输出结果。对于图像卷积，处理了边界问题（通过零填充）。