Merge pull request #2786 from ElenaGvozdeva:ocl_matchTemplate

modules/imgproc/src/templmatch.cpp

@@ -56,6 +56,26 @@ enum
     SUM_1 = 0, SUM_2 = 1
 };
 
+static bool extractFirstChannel_32F(InputArray _image, OutputArray _result, int cn)
+{
+    int depth = _image.depth();
+
+    ocl::Device dev = ocl::Device::getDefault();
+    int pxPerWIy = (dev.isIntel() && (dev.type() & ocl::Device::TYPE_GPU)) ? 4 : 1;
+
+    ocl::Kernel k("extractFirstChannel", ocl::imgproc::match_template_oclsrc, format("-D FIRST_CHANNEL -D T1=%s -D cn=%d -D PIX_PER_WI_Y=%d",
+                                                                            ocl::typeToStr(depth), cn, pxPerWIy));
+    if (k.empty())
+        return false;
+
+    UMat image  = _image.getUMat();
+    UMat result = _result.getUMat();
+
+
+    size_t globalsize[2] = {result.cols, (result.rows+pxPerWIy-1)/pxPerWIy};
+    return k.args(ocl::KernelArg::ReadOnlyNoSize(image), ocl::KernelArg::WriteOnly(result)).run( 2, globalsize, NULL, false);
+}
+
 static bool sumTemplate(InputArray _src, UMat & result)
 {
     int type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
@@ -88,15 +108,181 @@ static bool sumTemplate(InputArray _src, UMat & result)
     return k.run(1, &globalsize, &wgs, false);
 }
 
+static bool useNaive(Size size)
+{
+    if (!ocl::Device::getDefault().isIntel())
+        return true;
+
+    int dft_size = 18;
+    return size.height < dft_size && size.width < dft_size;
+
+}
+
+struct ConvolveBuf
+{
+    Size result_size;
+    Size block_size;
+    Size user_block_size;
+    Size dft_size;
+
+    UMat image_spect, templ_spect, result_spect;
+    UMat image_block, templ_block, result_data;
+
+    void create(Size image_size, Size templ_size);
+    static Size estimateBlockSize(Size result_size);
+};
+
+void 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);
+
+    block_size = user_block_size;
+    if (user_block_size.width == 0 || user_block_size.height == 0)
+        block_size = estimateBlockSize(result_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.)));
+
+    dft_size.width = getOptimalDFTSize(block_size.width + templ_size.width - 1);
+    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);
+
+    image_block.create(dft_size, CV_32F);
+    templ_block.create(dft_size, CV_32F);
+    result_data.create(dft_size, CV_32F);
+
+    image_spect.create(dft_size.height, dft_size.width / 2 + 1, CV_32FC2);
+    templ_spect.create(dft_size.height, dft_size.width / 2 + 1, CV_32FC2);
+    result_spect.create(dft_size.height, dft_size.width / 2 + 1, CV_32FC2);
+
+    // 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 ConvolveBuf::estimateBlockSize(Size result_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);
+    return Size(width, height);
+}
+
+static bool convolve_dft(InputArray _image, InputArray _templ, OutputArray _result)
+{
+    ConvolveBuf buf;
+    CV_Assert(_image.type() == CV_32F);
+    CV_Assert(_templ.type() == CV_32F);
+
+    buf.create(_image.size(), _templ.size());
+    _result.create(buf.result_size, CV_32F);
+
+    UMat image  = _image.getUMat();
+    UMat templ  = _templ.getUMat();
+
+    UMat result = _result.getUMat();
+
+    Size& block_size = buf.block_size;
+    Size& dft_size = buf.dft_size;
+
+    UMat& image_block = buf.image_block;
+    UMat& templ_block = buf.templ_block;
+    UMat& result_data = buf.result_data;
+
+    UMat& image_spect = buf.image_spect;
+    UMat& templ_spect = buf.templ_spect;
+    UMat& result_spect = buf.result_spect;
+
+    UMat templ_roi = templ;
+    copyMakeBorder(templ_roi, templ_block, 0, templ_block.rows - templ_roi.rows, 0,
+                   templ_block.cols - templ_roi.cols, BORDER_ISOLATED);
+
+    dft(templ_block, templ_spect, 0);
+
+    // Process all blocks of the result matrix
+    for (int y = 0; y < result.rows; y += block_size.height)
+    {
+        for (int x = 0; x < result.cols; x += block_size.width)
+        {
+            Size image_roi_size(std::min(x + dft_size.width, image.cols) - x,
+                                std::min(y + dft_size.height, image.rows) - y);
+            Rect roi0(x, y, image_roi_size.width, image_roi_size.height);
+
+            UMat image_roi(image, roi0);
+
+            copyMakeBorder(image_roi, image_block, 0, image_block.rows - image_roi.rows,
+                           0, image_block.cols - image_roi.cols, BORDER_ISOLATED);
+
+            dft(image_block, image_spect, 0);
+
+            mulSpectrums(image_spect, templ_spect, result_spect, 0, true);
+
+            dft(result_spect, result_data, cv::DFT_INVERSE | cv::DFT_REAL_OUTPUT | cv::DFT_SCALE);
+
+            Size result_roi_size(std::min(x + block_size.width, result.cols) - x,
+                                 std::min(y + block_size.height, result.rows) - y);
+
+            Rect roi1(x, y, result_roi_size.width, result_roi_size.height);
+            Rect roi2(0, 0, result_roi_size.width, result_roi_size.height);
+
+            UMat result_roi(result, roi1);
+            UMat result_block(result_data, roi2);
+
+            result_block.copyTo(result_roi);
+        }
+    }
+    return true;
+}
+
+static bool convolve_32F(InputArray _image, InputArray _templ, OutputArray _result)
+{
+    _result.create(_image.rows() - _templ.rows() + 1, _image.cols() - _templ.cols() + 1, CV_32F);
+
+    if (_image.channels() == 1)
+        return(convolve_dft(_image, _templ, _result));
+    else
+    {
+        UMat image = _image.getUMat();
+        UMat templ = _templ.getUMat();
+        UMat result_(image.rows-templ.rows+1,(image.cols-templ.cols+1)*image.channels(), CV_32F);
+        bool ok = convolve_dft(image.reshape(1), templ.reshape(1), result_);
+        if (ok==false)
+            return false;
+        UMat result = _result.getUMat();
+        return (extractFirstChannel_32F(result_, _result, _image.channels()));
+    }
+}
+
 static bool matchTemplateNaive_CCORR(InputArray _image, InputArray _templ, OutputArray _result)
 {
     int type = _image.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
-    int wdepth = std::max(depth, CV_32S), wtype = CV_MAKE_TYPE(wdepth, cn);
+    int wdepth = CV_32F, wtype = CV_MAKE_TYPE(wdepth, cn);
+
+    ocl::Device dev = ocl::Device::getDefault();
+    int pxPerWIx = (cn==1 && dev.isIntel() && (dev.type() & ocl::Device::TYPE_GPU)) ? 4 : 1;
+    int rated_cn = cn;
+    int wtype1 = wtype;
+
+    if (pxPerWIx!=1)
+    {
+        rated_cn = pxPerWIx;
+        type = CV_MAKE_TYPE(depth, rated_cn);
+        wtype1 = CV_MAKE_TYPE(wdepth, rated_cn);
+    }
 
     char cvt[40];
+    char cvt1[40];
+    const char* convertToWT1 = ocl::convertTypeStr(depth, wdepth, cn, cvt);
+    const char* convertToWT = ocl::convertTypeStr(depth, wdepth, rated_cn, cvt1);
+
     ocl::Kernel k("matchTemplate_Naive_CCORR", ocl::imgproc::match_template_oclsrc,
-                  format("-D CCORR -D T=%s -D T1=%s -D WT=%s -D convertToWT=%s -D cn=%d -D wdepth=%d", ocl::typeToStr(type), ocl::typeToStr(depth), ocl::typeToStr(wtype),
-                         ocl::convertTypeStr(depth, wdepth, cn, cvt), cn, wdepth));
+                  format("-D CCORR -D T=%s -D T1=%s -D WT=%s -D WT1=%s -D convertToWT=%s -D convertToWT1=%s -D cn=%d -D wdepth=%d -D PIX_PER_WI_X=%d", ocl::typeToStr(type), ocl::typeToStr(depth), ocl::typeToStr(wtype1), ocl::typeToStr(wtype),
+                         convertToWT, convertToWT1, cn, wdepth, pxPerWIx));
     if (k.empty())
         return false;
 
@@ -107,10 +293,33 @@ static bool matchTemplateNaive_CCORR(InputArray _image, InputArray _templ, Outpu
     k.args(ocl::KernelArg::ReadOnlyNoSize(image), ocl::KernelArg::ReadOnly(templ),
            ocl::KernelArg::WriteOnly(result));
 
-    size_t globalsize[2] = { result.cols, result.rows };
+    size_t globalsize[2] = { (result.cols+pxPerWIx-1)/pxPerWIx, result.rows};
     return k.run(2, globalsize, NULL, false);
 }
 
+
+static bool matchTemplate_CCORR(InputArray _image, InputArray _templ, OutputArray _result)
+{
+    if (useNaive(_templ.size()))
+        return( matchTemplateNaive_CCORR(_image, _templ, _result));
+    else
+    {
+        if(_image.depth() == CV_8U)
+        {
+            UMat imagef, templf;
+            UMat image = _image.getUMat();
+            UMat templ = _templ.getUMat();
+            image.convertTo(imagef, CV_32F);
+            templ.convertTo(templf, CV_32F);
+            return(convolve_32F(imagef, templf, _result));
+        }
+        else
+        {
+            return(convolve_32F(_image, _templ, _result));
+        }
+    }
+}
+
 static bool matchTemplate_CCORR_NORMED(InputArray _image, InputArray _templ, OutputArray _result)
 {
     matchTemplate(_image, _templ, _result, CV_TM_CCORR);
@@ -145,7 +354,7 @@ static bool matchTemplate_CCORR_NORMED(InputArray _image, InputArray _templ, Out
 static bool matchTemplateNaive_SQDIFF(InputArray _image, InputArray _templ, OutputArray _result)
 {
     int type = _image.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
-    int wdepth = std::max(depth, CV_32S), wtype = CV_MAKE_TYPE(wdepth, cn);
+    int wdepth = CV_32F, wtype = CV_MAKE_TYPE(wdepth, cn);
 
     char cvt[40];
     ocl::Kernel k("matchTemplate_Naive_SQDIFF", ocl::imgproc::match_template_oclsrc,
@@ -165,6 +374,41 @@ static bool matchTemplateNaive_SQDIFF(InputArray _image, InputArray _templ, Outp
     return k.run(2, globalsize, NULL, false);
 }
 
+static bool matchTemplate_SQDIFF(InputArray _image, InputArray _templ, OutputArray _result)
+{
+    if (useNaive(_templ.size()))
+        return( matchTemplateNaive_SQDIFF(_image, _templ, _result));
+    else
+    {
+        matchTemplate(_image, _templ, _result, CV_TM_CCORR);
+
+        int type = _image.type(), cn = CV_MAT_CN(type);
+
+        ocl::Kernel k("matchTemplate_Prepared_SQDIFF", ocl::imgproc::match_template_oclsrc,
+                  format("-D SQDIFF_PREPARED -D T=%s -D cn=%d", ocl::typeToStr(type),  cn));
+        if (k.empty())
+            return false;
+
+        UMat image = _image.getUMat(), templ = _templ.getUMat();
+        _result.create(image.rows - templ.rows + 1, image.cols - templ.cols + 1, CV_32F);
+        UMat result = _result.getUMat();
+
+        UMat image_sums, image_sqsums;
+        integral(image.reshape(1), image_sums, image_sqsums, CV_32F, CV_32F);
+
+        UMat templ_sqsum;
+        if (!sumTemplate(_templ, templ_sqsum))
+            return false;
+
+        k.args(ocl::KernelArg::ReadOnlyNoSize(image_sqsums), ocl::KernelArg::ReadWrite(result),
+           templ.rows, templ.cols, ocl::KernelArg::PtrReadOnly(templ_sqsum));
+
+        size_t globalsize[2] = { result.cols, result.rows };
+
+        return k.run(2, globalsize, NULL, false);
+    }
+}
+
 static bool matchTemplate_SQDIFF_NORMED(InputArray _image, InputArray _templ, OutputArray _result)
 {
     matchTemplate(_image, _templ, _result, CV_TM_CCORR);
@@ -202,47 +446,31 @@ static bool matchTemplate_CCOEFF(InputArray _image, InputArray _templ, OutputArr
     matchTemplate(_image, _templ, _result, CV_TM_CCORR);
 
     UMat image_sums, temp;
-    integral(_image, temp);
-
-    if (temp.depth() == CV_64F)
-        temp.convertTo(image_sums, CV_32F);
-    else
-        image_sums = temp;
+    integral(_image, image_sums, CV_32F);
 
     int type = image_sums.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
 
     ocl::Kernel k("matchTemplate_Prepared_CCOEFF", ocl::imgproc::match_template_oclsrc,
-                  format("-D CCOEFF -D T=%s -D elem_type=%s -D cn=%d", ocl::typeToStr(type), ocl::typeToStr(depth), cn));
+                  format("-D CCOEFF -D T=%s -D T1=%s -D cn=%d", ocl::typeToStr(type), ocl::typeToStr(depth), cn));
     if (k.empty())
         return false;
 
-    UMat templ = _templ.getUMat();
-    Size size = _image.size(), tsize = templ.size();
-    _result.create(size.height - templ.rows + 1, size.width - templ.cols + 1, CV_32F);
+    UMat templ  = _templ.getUMat();
     UMat result = _result.getUMat();
+    Size tsize = templ.size();
 
-    if (cn == 1)
+    if (cn==1)
     {
         float templ_sum = static_cast<float>(sum(_templ)[0]) / tsize.area();
 
-        k.args(ocl::KernelArg::ReadOnlyNoSize(image_sums), ocl::KernelArg::ReadWrite(result),
-                templ.rows, templ.cols, templ_sum);
+        k.args(ocl::KernelArg::ReadOnlyNoSize(image_sums), ocl::KernelArg::ReadWrite(result), templ.rows, templ.cols, templ_sum);
     }
     else
     {
         Vec4f templ_sum = Vec4f::all(0);
         templ_sum = sum(templ) / tsize.area();
 
-        if (cn == 2)
-            k.args(ocl::KernelArg::ReadOnlyNoSize(image_sums), ocl::KernelArg::ReadWrite(result), templ.rows, templ.cols,
-                   templ_sum[0], templ_sum[1]);
-        else if (cn==3)
-            k.args(ocl::KernelArg::ReadOnlyNoSize(image_sums), ocl::KernelArg::ReadWrite(result), templ.rows, templ.cols,
-                   templ_sum[0], templ_sum[1], templ_sum[2]);
-        else
-            k.args(ocl::KernelArg::ReadOnlyNoSize(image_sums), ocl::KernelArg::ReadWrite(result), templ.rows, templ.cols,
-                   templ_sum[0], templ_sum[1], templ_sum[2], templ_sum[3]);
-    }
+       k.args(ocl::KernelArg::ReadOnlyNoSize(image_sums), ocl::KernelArg::ReadWrite(result), templ.rows, templ.cols, templ_sum);    }
 
     size_t globalsize[2] = { result.cols, result.rows };
     return k.run(2, globalsize, NULL, false);
@@ -258,7 +486,7 @@ static bool matchTemplate_CCOEFF_NORMED(InputArray _image, InputArray _templ, Ou
     int type = image_sums.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
 
     ocl::Kernel k("matchTemplate_CCOEFF_NORMED", ocl::imgproc::match_template_oclsrc,
-        format("-D CCOEFF_NORMED -D type=%s -D elem_type=%s -D cn=%d", ocl::typeToStr(type), ocl::typeToStr(depth), cn));
+        format("-D CCOEFF_NORMED -D T=%s -D T1=%s -D cn=%d", ocl::typeToStr(type), ocl::typeToStr(depth), cn));
     if (k.empty())
         return false;
 
@@ -308,19 +536,9 @@ static bool matchTemplate_CCOEFF_NORMED(InputArray _image, InputArray _templ, Ou
             return true;
         }
 
-        if (cn == 2)
-            k.args(ocl::KernelArg::ReadOnlyNoSize(image_sums), ocl::KernelArg::ReadOnlyNoSize(image_sqsums),
-                   ocl::KernelArg::ReadWrite(result), templ.rows, templ.cols, scale,
-                   templ_sum[0], templ_sum[1], templ_sqsum_sum);
-        else if (cn == 3)
-            k.args(ocl::KernelArg::ReadOnlyNoSize(image_sums), ocl::KernelArg::ReadOnlyNoSize(image_sqsums),
-                   ocl::KernelArg::ReadWrite(result), templ.rows, templ.cols, scale,
-                   templ_sum[0], templ_sum[1], templ_sum[2], templ_sqsum_sum);
-        else
-            k.args(ocl::KernelArg::ReadOnlyNoSize(image_sums), ocl::KernelArg::ReadOnlyNoSize(image_sqsums),
+        k.args(ocl::KernelArg::ReadOnlyNoSize(image_sums), ocl::KernelArg::ReadOnlyNoSize(image_sqsums),
                    ocl::KernelArg::ReadWrite(result), templ.rows, templ.cols, scale,
-                   templ_sum[0], templ_sum[1], templ_sum[2], templ_sum[3], templ_sqsum_sum);
-    }
+                   templ_sum, templ_sqsum_sum);    }
 
     size_t globalsize[2] = { result.cols, result.rows };
     return k.run(2, globalsize, NULL, false);
@@ -339,7 +557,7 @@ static bool ocl_matchTemplate( InputArray _img, InputArray _templ, OutputArray _
 
     static const Caller callers[] =
     {
-        matchTemplateNaive_SQDIFF, matchTemplate_SQDIFF_NORMED, matchTemplateNaive_CCORR,
+        matchTemplate_SQDIFF, matchTemplate_SQDIFF_NORMED, matchTemplate_CCORR,
         matchTemplate_CCORR_NORMED, matchTemplate_CCOEFF, matchTemplate_CCOEFF_NORMED
     };
     const Caller caller = callers[method];