opencv環境下有自帶的filter2D()函式可以實現影象的卷積，自己寫一個卷積函式函式貌似是沒事找事。。。。好吧，事實是這是我們計算機視覺課程上的一項作業。我們很多演算法過程僅僅只呼叫別人寫好的介面，即使原理我們已經清楚，但是真正編寫程式碼的時候很多細節我們可能還是沒有意識到，也許自己再實現一遍是一種深入學習的途徑吧。

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運算元