图像卷积操作的手动实现（基于opencv的C++编译环境）

        opencv环境下有自带的filter2D()函数可以实现图像的卷积，自己写一个卷积函数函数貌似是没事找事。。。。好吧，事实是这是我们计算机视觉课程上的一项作业。我们很多算法过程仅仅只调用别人写好的接口，即使原理我们已经清楚，但是真正编写代码的时候很多细节我们可能还是没有意识到，也许自己再实现一遍是一种深入学习的途径吧。

本文对图像卷积操作的原理不作详细讨论，博客https://blog.csdn.net/chaipp0607/article/details/72236892?locationNum=9&fps=1已经写得非常详细，所以这里只对opencv环境下的C++实现进行讨论。

OK，先上代码为敬

这里定义了一个My_Convolution的类，以下是头文件和源文件

#ifndef MY_CONVOLUTION
#define MY_CONVOLUTION

#include <opencv2/opencv.hpp>

class My_Convolution{
public:
    My_Convolution();
    ~My_Convolution();
    bool load_kernal(cv::Mat kernal);//加载卷积核
    void convolute(const cv::Mat &image,cv::Mat &dst);//卷积操作

private:
    bool kernal_loaded;//是否已经加载卷积核
    cv::Mat curr_kernal;//当前卷积核
    int bios_x,bios_y;//记录偏移量

    void compute_sum_of_product(int i,int j,int chan,cv::Mat &complete_image,cv::Mat & dst);//计算每一个像素的掩模乘积之和
    void complete_image_transform(const cv::Mat &image,cv::Mat &dst);//将原图像转换成边框补全的图像
};

#endif // MY_CONVOLUTION

#include "my_convolution.h"

using namespace std;
using namespace cv;

My_Convolution::My_Convolution(){
    kernal_loaded=false;
}
My_Convolution::~My_Convolution(){}

//加载卷积核
bool My_Convolution::load_kernal(Mat kernal){
    if(kernal.cols%2==1&&kernal.rows%2==1){
        curr_kernal=kernal.clone();
        bios_x=(kernal.cols-1)/2;
        bios_y=(kernal.rows-1)/2;
        kernal_loaded=true;
        return true;
    }
    else{
        cout<<"The size of kernal is not suitable!"<<endl;
        return false;
    }
}

//卷积操作
void My_Convolution::convolute(const Mat &image, Mat &dst){
    if(!kernal_loaded){
        cout<<"kernal is empty!Please load the kernal first!"<<endl;return;
    }
    Mat complete_image;
    complete_image_transform(image,complete_image);
    dst=Mat::zeros(image.rows,image.cols,image.type());
    int channels=image.channels();//获取图像的通道数
    if(channels==3){
        for(int chan=0;chan<channels;chan++){
            for(int i=0;i<dst.rows;i++){
                for(int j=0;j<dst.cols;j++){
                    compute_sum_of_product(i,j,chan,complete_image,dst);
                }
            }
        }
        return ;
    }
    if(channels==1){
        for(int i=0;i<dst.rows;i++){
            for(int j=0;j<dst.cols;j++){
                compute_sum_of_product(i,j,0,complete_image,dst);
            }
        }
    }

}

//计算掩模乘积之和
void My_Convolution::compute_sum_of_product(int i, int j,int chan,Mat &complete_image, Mat &dst){
    if(complete_image.channels()==3){
        float sum=0;
        int bios_rows=i;
        int bios_cols=j;
        for(int curr_rows=0;curr_rows<curr_kernal.rows;curr_rows++){
            for(int curr_cols=0;curr_cols<curr_kernal.cols;curr_cols++){
                float a=curr_kernal.at<float>(curr_rows,curr_cols)*complete_image.at<Vec3b>(curr_rows+bios_rows,curr_cols+bios_cols)[chan];
                sum+=a;
            }
        }
        dst.at<Vec3b>(i,j)[chan]=(int)sum;
    }
    else{
        if(complete_image.channels()==1){
            float sum=0;
            int bios_rows=i;
            int bios_cols=j;
            for(int curr_rows=0;curr_rows<curr_kernal.rows;curr_rows++){
                for(int curr_cols=0;curr_cols<curr_kernal.cols;curr_cols++){
                    float a=curr_kernal.at<float>(curr_rows,curr_cols)*complete_image.at<uchar>(curr_rows+bios_rows,curr_cols+bios_cols);
                    sum+=a;
                }
            }
            dst.at<uchar>(i,j)=(int)sum;
        }
        else{
            cout<<"the type of image is not suitable!"<<endl;return ;
        }
    }


}

//边框像素补全
void My_Convolution::complete_image_transform(const Mat &image,Mat &dst){
    if(!kernal_loaded){
        cout<<"kernal is empty!"<<endl;
        return ;
    }
    dst=Mat::zeros(2*bios_y+image.rows,2*bios_x+image.cols,image.type());//初始化一个补全图像的大小。
    Rect real_roi_of_image=Rect(bios_x,bios_y,image.cols,image.rows);
    Mat real_mat_of_image=dst(real_roi_of_image);
    image.copyTo(dst(real_roi_of_image));
}

        My_Convolution类对外提供了load_kernal()和convolute()两个函数接口，分别用来加载卷积核和进行卷机操作。若在convolute操作之前没有加载卷积核，则会给出提醒。    

        当卷积核以边缘像素为基准点进行卷积操作的时候，会出现卷积核内部分的值无法在原图像上找到相互对应的像素点，因为原图必然有边界。这里采取的办法是，在加载卷积核之后，获取卷积核的尺寸，根据卷积核的尺寸适当地在原图像的边缘增加bios_x列和bios_y行的像素，因此补全之后带有原图信息的新的图像的尺寸为(2*bios_x+image.cols)*(2*bios_y+image.rows)。

        得到补全的图像之后，使用一个2层的for循环来对原图像进行卷积操作，新产生的图像的尺寸要和原图像保持一致。

main函数里的测试代码：

#include <iostream>
#include <opencv2/opencv.hpp>
#include "my_convolution.h"

using namespace std;
using namespace cv;

//高斯核构造函数
Mat Gaussian_kernal(int kernal_size, int sigma)
{
    const double PI = 3.14159265358979323846;
    int m = kernal_size / 2;
    Mat kernal(kernal_size, kernal_size, CV_32FC1);
    float s = 2 * sigma*sigma;
    for (int i = 0; i < kernal_size; i++)
    {
        for (int j = 0; j < kernal_size; j++)
        {
            int x = i - m, y=j - m;
            kernal.ptr<float>(i)[j] = exp(-(x*x + y*y) / s) / (PI*s);
        }
    }
    return kernal;
}

//3*3均值卷积核
cv::Mat average_kernal_3 = (Mat_<float>(3,3) << 0.111, 0.111 ,0.111,
                                                0.111, 0.111, 0.111,
                                                0.111, 0.111, 0.111);

//5*5均值卷积核
cv::Mat average_kernal_5 = (Mat_<float>(3,3) << 0.04, 0.04 ,0.04, 0.04, 0.04,
                                                0.04, 0.04 ,0.04, 0.04, 0.04,
                                                0.04, 0.04 ,0.04, 0.04, 0.04,
                                                0.04, 0.04 ,0.04, 0.04, 0.04,
                                                0.04, 0.04 ,0.04, 0.04, 0.04);
//sobel边缘检测算子
cv::Mat sobel_y_kernal= (Mat_<float>(3,3) << -1, -2 ,-1,
                                              0,  0 , 0,
                                              1,  2 , 1);
cv::Mat sobel_x_kernal= (Mat_<float>(3,3) << -1,  0 , 1,
                                             -2,  0 , 2,
                                             -1,  0 , 1);

//prewitt边缘检测算子
cv::Mat prewitt_y_kernal= (Mat_<float>(3,3) << -1, -1 ,-1,
                                                0,  0 , 0,
                                                1,  1 , 1);
cv::Mat prewitt_x_kernal= (Mat_<float>(3,3) << -1,  0 , 1,
                                               -1,  0 , 1,
                                               -1,  0 , 1);

int main(){
    My_Convolution myconvolution;   
    Mat image=imread("lena.jpg");
    imshow("src",image);

    Mat dst_prewitt;
    //高斯卷积
    Mat dst_gaussian;
    myconvolution.load_kernal(Gaussian_kernal(7,2));
    myconvolution.convolute(image,dst_gaussian);

    imshow("dst_gaussian",dst_gaussian);
    //均值3*3
    Mat dst_aver_3;
    myconvolution.load_kernal(average_kernal_3);
    myconvolution.convolute(image,dst_aver_3);
    imshow("dst_aver_3",dst_aver_3);
    //均值5*5
    Mat dst_aver_5;
    myconvolution.load_kernal(average_kernal_5);
    myconvolution.convolute(image,dst_aver_5);
    imshow("dst_aver_5",dst_aver_5);
    //sobel操作
    Mat dst_sobel_x;
    Mat dst_sobel_y;

    myconvolution.load_kernal(sobel_x_kernal);
    myconvolution.convolute(image,dst_sobel_x);
    imshow("dst_sobel_x",dst_sobel_x);

    myconvolution.load_kernal(sobel_y_kernal);
    myconvolution.convolute(image,dst_sobel_y);
    imshow("dst_sobel_y",dst_sobel_y);

    //prewitt操作
    Mat dst_prewitt_x;
    Mat dst_prewitt_y;

    myconvolution.load_kernal(prewitt_x_kernal);
    myconvolution.convolute(image,dst_prewitt_x);
    imshow("dst_prewitt_x",dst_prewitt_x);

    myconvolution.load_kernal(prewitt_y_kernal);
    myconvolution.convolute(image,dst_prewitt_y);
    imshow("dst_prewitt_y",dst_prewitt_y);
    waitKey(0);
    return 0;
}

        main函数里分别对两个尺寸的均值卷积和高斯卷积进行了测试，高斯卷积的尺寸和其中的参数可以使用Guassian_kernal()函数生成。这里因为程序中只给出了sobel和prewitt两个方向上的卷积核并只分别单纯地做了卷积运算，并没有根据sobel和prewitt算子的完整计算过程算出其卷积图像，如果想知道sobel边缘检测和prewitt边缘检测是什么效果的朋友可以自己试一试。

最后给出效果图：

src原图

dst_guassian——高斯

dst_aver_3——3*3均值

dst_aver_5——5*5均值

dst_prewitt_x——x方向prewitt算子

dst_prewitt_y——y方向prewitt算子

dst_sobel_x——x方向sobel算子

dst_sobel_y——y方向sobel算子