CUDA/GPU как сделать максимально быстро свертку по ядру 3x3 , 4x4 , 5x5 ... (2 стр)

#include <iostream>

#include <opencv2/highgui.hpp>
#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>

using namespace std;
using namespace cv;



void convolutionCPU(  unsigned char *h_Dst,
                      unsigned char *h_Src,
                      float *h_Kernel,
                      int    imageW,
                      int    imageH,
                      int    kernelW,
                      int    kernelH)
{

    for (int x=0; x < imageW; ++x)
    {
        for (int y=0; y < imageH; ++y)
        {
          //------------- convolution --------------//

            float kSum = 0;
            for (int i = 0; i < kernelW; i++)
            {
                for (int j = 0; j < kernelH; j++)
                {
                    int pixelPosX = x + (i - (kernelW / 2));
                    int pixelPosY = y + (j - (kernelH / 2));

                    if ((pixelPosX < 0       ) ||
                        (pixelPosX >= imageW ) ||
                        (pixelPosY < 0       ) ||
                        (pixelPosY >= imageH )) continue;


                        int index = (imageW * pixelPosY + pixelPosX) * 1;


                   // std::cout << "[" << i << "," << j << "]"  << "  "<< int(ImageOriginal.at<uchar>(pixelPosY,pixelPosX)) << " * ";
                   // std::cout << kernel_matrix.at<float>(i,j) << "   ";

                        kSum += h_Src[index] * h_Kernel[i * kernelW + j];

                   // kSum += kernel_matrix.at<float>(i,j) * int(image.at<uchar>(index));
                }

                //std::cout << endl;
            }

            h_Dst[ imageW * y + x ] = (uchar)kSum;

             //cout<< " \n\n\n";
             //dst.at<uchar>( ImageOriginal.rows * y + x ) = (uchar)kSum;
            //result.at<uchar>(y,x) = (uchar)kSum;

          //----------------------------------------//

        }
    }

}


////////////////////////////////////////////////////////////////////////////////
// Reference row convolution filter
////////////////////////////////////////////////////////////////////////////////
void convolutionRowCPU(  unsigned char *h_Dst,
                         unsigned char *h_Src,
                         float *h_Kernel,
                         int imageW,
                         int imageH,
                         int kernelR )
{
    for (int y = 0; y < imageH; y++)
    {
        for (int x = 0; x < imageW; x++)
        {
            float sum = 0;

            for (int k = -kernelR; k <= kernelR; k++)
            {
                int d = x + k;

                if (d >= 0 && d < imageW)
                {
                    sum += h_Src[y * imageW + d] * h_Kernel[kernelR - k];
                }
            }

            h_Dst[y * imageW + x] = sum;
        }
    }
}



////////////////////////////////////////////////////////////////////////////////
// Reference column convolution filter
////////////////////////////////////////////////////////////////////////////////
void convolutionColumnCPU( unsigned char *h_Dst,
                           unsigned char *h_Src,
                           float *h_Kernel,
                           int imageW,
                           int imageH,
                           int kernelR )
{
    for (int y = 0; y < imageH; y++)
    {
        for (int x = 0; x < imageW; x++)
        {
            float sum = 0;

            for (int k = -kernelR; k <= kernelR; k++)
            {
                int d = y + k;

                if (d >= 0 && d < imageH)
                {
                    sum += h_Src[d * imageW + x] * h_Kernel[kernelR - k];
                }
            }

            h_Dst[y * imageW + x] = sum;
        }
    }
}

int main()
{

    Mat image = imread("data/lena.jpg" ,CV_LOAD_IMAGE_GRAYSCALE);


    //----------------------------------------------------------//

    // ядро свертки
//     float kernel[9]
//     {
//         static_cast<float>(0.11102) ,  static_cast<float>(0.11116), static_cast<float>(0.11102),
//         static_cast<float>(0.11116) ,  static_cast<float>(0.1113) , static_cast<float>(0.11116),
//         static_cast<float>(0.11102) ,  static_cast<float>(0.11116), static_cast<float>(0.11102)
//     };

    float kernel[9]
    {
        static_cast<float>(0.1) ,  static_cast<float>(0.1), static_cast<float>(0.1),
        static_cast<float>(0.1) ,  static_cast<float>(0.1), static_cast<float>(0.1),
        static_cast<float>(0.1) ,  static_cast<float>(0.1), static_cast<float>(0.1)
    };

     // матрица ядра
     Mat kernel_matrix=Mat(3,3,CV_32FC1,kernel);

    //----------------------------------------------------------//


    Mat result_0 = Mat::zeros( image.rows , image.cols , CV_8UC1 );
    Mat result_1 = Mat::zeros( image.rows , image.cols , CV_8UC1 );
    Mat result_2 = Mat::zeros( image.rows , image.cols , CV_8UC1 );


    //----------------------------------------------------------//

    cv::filter2D(image, result_0, -1, kernel_matrix);

    //----------------------------------------------------------//

    convolutionCPU( result_1.data , image.data , (float*)kernel_matrix.data , image.cols ,  image.rows , 3 , 3);

    //----------------------------------------------------------//

    convolutionRowCPU( result_2.data , image.data , (float*)kernel_matrix.data , image.cols ,  image.rows , 3);
    convolutionColumnCPU( result_2.data , image.data , (float*)kernel_matrix.data , image.cols ,  image.rows , 3);

    //----------------------------------------------------------//

    imshow( " Original " , image );

    imshow( " Result Filter2D " , result_0 );
    imshow( " Result Convolution " , result_1 );
    imshow( " Result Convolution-Separable" , result_0 );

    waitKey();
}