#1713 Added the possibility of setting user_block_size manually for…

#1713 Added the possibility of setting user_block_size manually for gpu::matchTemplate function (and gpu::convolve). Added a buffer param into these functions. Removed using of 2^n block sizes when it's not necessary.

modules/gpu/doc/image_processing.rst

@@ -234,6 +234,35 @@ The source matrix should be continuous, otherwise reallocation and data copying
 .. seealso:: :ocv:func:`dft`
 
 
+gpu::ConvolveBuf
+----------------
+.. ocv:class:: gpu::ConvolveBuf
+
+Class providing a memory buffer for :ocv:func:`gpu::convolve` function, plus it allows to adjust some specific parameters. ::
+
+    struct CV_EXPORTS ConvolveBuf
+    {
+        Size result_size;
+        Size block_size;
+        Size user_block_size;
+        Size dft_size;
+        int spect_len;
+
+        GpuMat image_spect, templ_spect, result_spect;
+        GpuMat image_block, templ_block, result_data;
+
+        void create(Size image_size, Size templ_size);
+        static Size estimateBlockSize(Size result_size, Size templ_size);
+    };
+    
+You can use field `user_block_size` to set specific block size for :ocv:func:`gpu::convolve` function. If you leave its default value `Size(0,0)` then automatic estimation of block size will be used (which is optimized for speed). By varying `user_block_size` you can reduce memory requirements at the cost of speed.
+
+gpu::ConvolveBuf::create
+------------------------
+.. ocv:function:: ConvolveBuf::create(Size image_size, Size templ_size)
+
+Constructs a buffer for :ocv:func:`gpu::convolve` function with respective arguments.
+
 
 gpu::convolve
 -----------------
@@ -241,7 +270,7 @@ Computes a convolution (or cross-correlation) of two images.
 
 .. ocv:function:: void gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr=false)
 
-.. ocv:function:: void gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr, ConvolveBuf& buf)
+.. ocv:function:: void gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr, ConvolveBuf& buf, Stream &stream = Stream::Null())
 
     :param image: Source image. Only  ``CV_32FC1`` images are supported for now.
 
@@ -251,50 +280,36 @@ Computes a convolution (or cross-correlation) of two images.
 
     :param ccorr: Flags to evaluate cross-correlation instead of convolution.
 
-    :param buf: Optional buffer to avoid extra memory allocations (for many calls with the same sizes).
+    :param buf: Optional buffer to avoid extra memory allocations and to adjust some specific parameters. See :ocv:class:`gpu::ConvolveBuf`.
+   
+    :param stream: Stream for the asynchronous version.
 
 .. seealso:: :ocv:func:`gpu::filter2D`
 
+gpu::MatchTemplateBuf
+---------------------
+.. ocv:class:: gpu::MatchTemplateBuf
 
+Class providing memory buffers for :ocv:func:`gpu::matchTemplate` function, plus it allows to adjust some specific parameters. ::
 
-gpu::ConvolveBuf
-----------------
-.. ocv:class:: gpu::ConvolveBuf
-
-Class providing a memory buffer for the :ocv:func:`gpu::convolve` function. ::
-
-    struct CV_EXPORTS ConvolveBuf
+    struct CV_EXPORTS MatchTemplateBuf
     {
-        ConvolveBuf() {}
-        ConvolveBuf(Size image_size, Size templ_size)
-            { create(image_size, templ_size); }
-        void create(Size image_size, Size templ_size);
-
-    private:
-        // Hidden
+        Size user_block_size;
+        GpuMat imagef, templf;
+        std::vector<GpuMat> images;
+        std::vector<GpuMat> image_sums;
+        std::vector<GpuMat> image_sqsums;
     };
 
-
-
-gpu::ConvolveBuf::ConvolveBuf
----------------------------------
-The constructors.
-
-.. ocv:function:: ConvolveBuf::ConvolveBuf()
-
-Constructs an empty buffer that is properly resized after the first call of the :ocv:func:`gpu::convolve` function.
-
-.. ocv:function:: ConvolveBuf::ConvolveBuf(Size image_size, Size templ_size)
-
-Constructs a buffer for the :ocv:func:`gpu::convolve` function with respective arguments.
-
-
+You can use field `user_block_size` to set specific block size for :ocv:func:`gpu::matchTemplate` function. If you leave its default value `Size(0,0)` then automatic estimation of block size will be used (which is optimized for speed). By varying `user_block_size` you can reduce memory requirements at the cost of speed.
 
 gpu::matchTemplate
 ----------------------
 Computes a proximity map for a raster template and an image where the template is searched for.
 
-.. ocv:function:: void gpu::matchTemplate(const GpuMat& image, const GpuMat& templ, GpuMat& result, int method)
+.. ocv:function:: void gpu::matchTemplate(const GpuMat& image, const GpuMat& templ, GpuMat& result, int method, Stream &stream = Stream::Null())
+
+.. ocv:function:: void gpu::matchTemplate(const GpuMat& image, const GpuMat& templ, GpuMat& result, int method, MatchTemplateBuf &buf, Stream& stream = Stream::Null())
 
     :param image: Source image.  ``CV_32F`` and  ``CV_8U`` depth images (1..4 channels) are supported for now.
 
@@ -303,6 +318,10 @@ Computes a proximity map for a raster template and an image where the template i
     :param result: Map containing comparison results ( ``CV_32FC1`` ). If  ``image`` is  *W x H*  and ``templ`` is  *w x h*, then  ``result`` must be *W-w+1 x H-h+1*.
 
     :param method: Specifies the way to compare the template with the image.
+    
+    :param buf: Optional buffer to avoid extra memory allocations and to adjust some specific parameters. See :ocv:class:`gpu::MatchTemplateBuf`.
+    
+    :param stream: Stream for the asynchronous version.
 
     The following methods are supported for the ``CV_8U`` depth images for now:
 
@@ -321,7 +340,6 @@ Computes a proximity map for a raster template and an image where the template i
 .. seealso:: :ocv:func:`matchTemplate`
 
 
-
 gpu::remap
 --------------
 Applies a generic geometrical transformation to an image.

modules/gpu/include/opencv2/gpu/gpu.hpp

@@ -716,36 +716,42 @@ CV_EXPORTS void mulAndScaleSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c
 //! For complex-to-real transform it is assumed that the source matrix is packed in CUFFT's format.
 CV_EXPORTS void dft(const GpuMat& src, GpuMat& dst, Size dft_size, int flags=0, Stream& stream = Stream::Null());
 
-//! computes convolution (or cross-correlation) of two images using discrete Fourier transform
-//! supports source images of 32FC1 type only
-//! result matrix will have 32FC1 type
-struct CV_EXPORTS ConvolveBuf;
-CV_EXPORTS void convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr = false);
-CV_EXPORTS void convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr, ConvolveBuf& buf, Stream& stream = Stream::Null());
-
 struct CV_EXPORTS ConvolveBuf
 {
-    ConvolveBuf() {}
-    ConvolveBuf(Size image_size, Size templ_size)
-        { create(image_size, templ_size); }
-    void create(Size image_size, Size templ_size);
-    void create(Size image_size, Size templ_size, Size block_size);
-
-private:
-    static Size estimateBlockSize(Size result_size, Size templ_size);
-    friend void convolve(const GpuMat&, const GpuMat&, GpuMat&, bool, ConvolveBuf&, Stream& stream);
-
     Size result_size;
     Size block_size;
+    Size user_block_size;
     Size dft_size;
     int spect_len;
 
     GpuMat image_spect, templ_spect, result_spect;
     GpuMat image_block, templ_block, result_data;
+
+    void create(Size image_size, Size templ_size);
+    static Size estimateBlockSize(Size result_size, Size templ_size);
 };
 
+
+//! computes convolution (or cross-correlation) of two images using discrete Fourier transform
+//! supports source images of 32FC1 type only
+//! result matrix will have 32FC1 type
+CV_EXPORTS void convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr = false);
+CV_EXPORTS void convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr, ConvolveBuf& buf, Stream& stream = Stream::Null());
+
+struct CV_EXPORTS MatchTemplateBuf
+{
+    Size user_block_size;
+    GpuMat imagef, templf;
+    std::vector<GpuMat> images;
+    std::vector<GpuMat> image_sums;
+    std::vector<GpuMat> image_sqsums;
+};
+
+//! computes the proximity map for the raster template and the image where the template is searched for
+CV_EXPORTS void matchTemplate(const GpuMat& image, const GpuMat& templ, GpuMat& result, int method, Stream &stream = Stream::Null());
+
 //! computes the proximity map for the raster template and the image where the template is searched for
-CV_EXPORTS void matchTemplate(const GpuMat& image, const GpuMat& templ, GpuMat& result, int method, Stream& stream = Stream::Null());
+CV_EXPORTS void matchTemplate(const GpuMat& image, const GpuMat& templ, GpuMat& result, int method, MatchTemplateBuf &buf, Stream& stream = Stream::Null());
 
 //! smoothes the source image and downsamples it
 CV_EXPORTS void pyrDown(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null());

modules/gpu/src/cuda/match_template.cu

@@ -559,7 +559,7 @@ namespace cv { namespace gpu { namespace device
         void matchTemplatePrepared_CCOFF_NORMED_8U(
                     int w, int h, const DevMem2D_<unsigned int> image_sum, 
                     const DevMem2D_<unsigned long long> image_sqsum,
-                    unsigned int templ_sum, unsigned int templ_sqsum,
+                    unsigned int templ_sum, unsigned long long templ_sqsum,
                     DevMem2Df result, cudaStream_t stream)
         {
             dim3 threads(32, 8);
@@ -618,8 +618,8 @@ namespace cv { namespace gpu { namespace device
                     int w, int h, 
                     const DevMem2D_<unsigned int> image_sum_r, const DevMem2D_<unsigned long long> image_sqsum_r,
                     const DevMem2D_<unsigned int> image_sum_g, const DevMem2D_<unsigned long long> image_sqsum_g,
-                    unsigned int templ_sum_r, unsigned int templ_sqsum_r,
-                    unsigned int templ_sum_g, unsigned int templ_sqsum_g,
+                    unsigned int templ_sum_r, unsigned long long templ_sqsum_r,
+                    unsigned int templ_sum_g, unsigned long long templ_sqsum_g,
                     DevMem2Df result, cudaStream_t stream)
         {
             dim3 threads(32, 8);
@@ -694,9 +694,9 @@ namespace cv { namespace gpu { namespace device
                     const DevMem2D_<unsigned int> image_sum_r, const DevMem2D_<unsigned long long> image_sqsum_r,
                     const DevMem2D_<unsigned int> image_sum_g, const DevMem2D_<unsigned long long> image_sqsum_g,
                     const DevMem2D_<unsigned int> image_sum_b, const DevMem2D_<unsigned long long> image_sqsum_b,
-                    unsigned int templ_sum_r, unsigned int templ_sqsum_r,
-                    unsigned int templ_sum_g, unsigned int templ_sqsum_g,
-                    unsigned int templ_sum_b, unsigned int templ_sqsum_b,
+                    unsigned int templ_sum_r, unsigned long long templ_sqsum_r,
+                    unsigned int templ_sum_g, unsigned long long templ_sqsum_g,
+                    unsigned int templ_sum_b, unsigned long long templ_sqsum_b,
                     DevMem2Df result, cudaStream_t stream)
         {
             dim3 threads(32, 8);
@@ -782,10 +782,10 @@ namespace cv { namespace gpu { namespace device
                     const DevMem2D_<unsigned int> image_sum_g, const DevMem2D_<unsigned long long> image_sqsum_g,
                     const DevMem2D_<unsigned int> image_sum_b, const DevMem2D_<unsigned long long> image_sqsum_b,
                     const DevMem2D_<unsigned int> image_sum_a, const DevMem2D_<unsigned long long> image_sqsum_a,
-                    unsigned int templ_sum_r, unsigned int templ_sqsum_r,
-                    unsigned int templ_sum_g, unsigned int templ_sqsum_g,
-                    unsigned int templ_sum_b, unsigned int templ_sqsum_b,
-                    unsigned int templ_sum_a, unsigned int templ_sqsum_a,
+                    unsigned int templ_sum_r, unsigned long long templ_sqsum_r,
+                    unsigned int templ_sum_g, unsigned long long templ_sqsum_g,
+                    unsigned int templ_sum_b, unsigned long long templ_sqsum_b,
+                    unsigned int templ_sum_a, unsigned long long templ_sqsum_a,
                     DevMem2Df result, cudaStream_t stream)
         {
             dim3 threads(32, 8);
@@ -822,7 +822,7 @@ namespace cv { namespace gpu { namespace device
         template <int cn>
         __global__ void normalizeKernel_8U(
                 int w, int h, const PtrStep<unsigned long long> image_sqsum, 
-                unsigned int templ_sqsum, DevMem2Df result)
+                unsigned long long templ_sqsum, DevMem2Df result)
         {
             const int x = blockIdx.x * blockDim.x + threadIdx.x;
             const int y = blockIdx.y * blockDim.y + threadIdx.y;
@@ -837,7 +837,7 @@ namespace cv { namespace gpu { namespace device
         }
 
         void normalize_8U(int w, int h, const DevMem2D_<unsigned long long> image_sqsum, 
-                          unsigned int templ_sqsum, DevMem2Df result, int cn, cudaStream_t stream)
+                          unsigned long long templ_sqsum, DevMem2Df result, int cn, cudaStream_t stream)
         {
             dim3 threads(32, 8);
             dim3 grid(divUp(result.cols, threads.x), divUp(result.rows, threads.y));

modules/gpu/src/imgproc.cpp

@@ -1293,21 +1293,25 @@ void cv::gpu::ConvolveBuf::create(Size image_size, Size templ_size)
 {
     result_size = Size(image_size.width - templ_size.width + 1,
                        image_size.height - templ_size.height + 1);
-    create(image_size, templ_size, estimateBlockSize(result_size, templ_size));
-}
-
 
-void cv::gpu::ConvolveBuf::create(Size image_size, Size templ_size, Size block_size)
-{
-    result_size = Size(image_size.width - templ_size.width + 1,
-                       image_size.height - templ_size.height + 1);
-
-    this->block_size = block_size;
+    block_size = user_block_size;
+    if (user_block_size.width == 0 || user_block_size.height == 0)
+        block_size = estimateBlockSize(result_size, templ_size);
 
     dft_size.width = 1 << int(ceil(std::log(block_size.width + templ_size.width - 1.) / std::log(2.)));
     dft_size.height = 1 << int(ceil(std::log(block_size.height + templ_size.height - 1.) / std::log(2.)));
-    if (dft_size.width < 512) dft_size.width = 512;
-    if (dft_size.height < 512) dft_size.height = 512;
+
+    // CUFFT has hard-coded kernels for power-of-2 sizes (up to 8192),
+    // see CUDA Toolkit 4.1 CUFFT Library Programming Guide
+    if (dft_size.width > 8192)
+        dft_size.width = getOptimalDFTSize(block_size.width + templ_size.width - 1.);
+    if (dft_size.height > 8192)
+        dft_size.height = getOptimalDFTSize(block_size.height + templ_size.height - 1.);
+
+    // To avoid wasting time doing small DFTs
+    dft_size.width = std::max(dft_size.width, 512);
+    dft_size.height = std::max(dft_size.height, 512);
+
     createContinuous(dft_size, CV_32F, image_block);
     createContinuous(dft_size, CV_32F, templ_block);
     createContinuous(dft_size, CV_32F, result_data);
@@ -1317,17 +1321,18 @@ void cv::gpu::ConvolveBuf::create(Size image_size, Size templ_size, Size block_s
     createContinuous(1, spect_len, CV_32FC2, templ_spect);
     createContinuous(1, spect_len, CV_32FC2, result_spect);
 
-    this->block_size.width = std::min(dft_size.width - templ_size.width + 1, result_size.width);
-    this->block_size.height = std::min(dft_size.height - templ_size.height + 1, result_size.height);
+    // Use maximum result matrix block size for the estimated DFT block size
+    block_size.width = std::min(dft_size.width - templ_size.width + 1, result_size.width);
+    block_size.height = std::min(dft_size.height - templ_size.height + 1, result_size.height);
 }
 
 
-Size cv::gpu::ConvolveBuf::estimateBlockSize(Size result_size, Size templ_size)
+Size cv::gpu::ConvolveBuf::estimateBlockSize(Size result_size, Size /*templ_size*/)
 {
     int width = (result_size.width + 2) / 3;
     int height = (result_size.height + 2) / 3;
     width = std::min(width, result_size.width);
-    height = std::min(height, result_size.height);
+    height = std::min(height, result_size.height);    
     return Size(width, height);
 }
 
@@ -1367,7 +1372,7 @@ void cv::gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result,
 
     cufftHandle planR2C, planC2R;
     cufftSafeCall(cufftPlan2d(&planC2R, dft_size.height, dft_size.width, CUFFT_C2R));
-    cufftSafeCall(cufftPlan2d(&planR2C, dft_size.height, dft_size.width, CUFFT_R2C));
+    cufftSafeCall(cufftPlan2d(&planR2C, dft_size.height, dft_size.width, CUFFT_R2C));   
 
     cufftSafeCall( cufftSetStream(planR2C, StreamAccessor::getStream(stream)) );
     cufftSafeCall( cufftSetStream(planC2R, StreamAccessor::getStream(stream)) );