Merge pull request #2236 from ilya-lavrenov:tapi_boxfilter

modules/imgproc/src/smooth.cpp

@@ -611,155 +611,114 @@ template<> struct ColumnSum<int, ushort> : public BaseColumnFilter
     std::vector<int> sum;
 };
 
+#ifdef HAVE_OPENCL
+
 #define DIVUP(total, grain) ((total + grain - 1) / (grain))
 
 static bool ocl_boxFilter( InputArray _src, OutputArray _dst, int ddepth,
-                           Size ksize, Point anchor, int borderType )
+                           Size ksize, Point anchor, int borderType, bool normalize )
 {
-    int type = _src.type();
-    int cn = CV_MAT_CN(type);
-    if ((1 != cn) && (2 != cn) && (4 != cn))
-        return false;//TODO
+    int type = _src.type(), sdepth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type), esz = CV_ELEM_SIZE(type);
+    bool doubleSupport = ocl::Device::getDefault().doubleFPConfig() > 0;
 
-    int sdepth = CV_MAT_DEPTH(type);
-    if( ddepth < 0 )
+    if (ddepth < 0)
         ddepth = sdepth;
-    else if (ddepth != sdepth)
+
+    if (!(cn == 1 || cn == 2 || cn == 4) || (!doubleSupport && (sdepth == CV_64F || ddepth == CV_64F)) ||
+        _src.offset() % esz != 0 || _src.step() % esz != 0)
         return false;
-    if( anchor.x < 0 )
+
+    if (anchor.x < 0)
         anchor.x = ksize.width / 2;
-    if( anchor.y < 0 )
+    if (anchor.y < 0)
         anchor.y = ksize.height / 2;
 
-    ocl::Kernel kernel;
-
-    //Normalize the result by default
+    int computeUnits = ocl::Device::getDefault().maxComputeUnits();
     float alpha = 1.0f / (ksize.height * ksize.width);
-    bool isIsolatedBorder = (borderType & BORDER_ISOLATED) != 0;
-    bool useDouble = (CV_64F == sdepth);
-    const cv::ocl::Device &device = cv::ocl::Device::getDefault();
-    int doubleFPConfig = device.doubleFPConfig();
-    if (useDouble && (0 == doubleFPConfig))
-        return false;// may be we have to check is  (0 != (CL_FP_SOFT_FLOAT & doubleFPConfig)) ?
-
-    const char* btype = NULL;
-    switch (borderType & ~BORDER_ISOLATED)
-    {
-    case BORDER_CONSTANT:
-        btype = "BORDER_CONSTANT";
-        break;
-    case BORDER_REPLICATE:
-        btype = "BORDER_REPLICATE";
-        break;
-    case BORDER_REFLECT:
-        btype = "BORDER_REFLECT";
-        break;
-    case BORDER_WRAP:
-        //CV_Error(CV_StsUnsupportedFormat, "BORDER_WRAP is not supported!");
-        return false;
-    case BORDER_REFLECT101:
-        btype = "BORDER_REFLECT_101";
-        break;
-    }
-
-    cv::Size sz = _src.size();
+    Size size = _src.size(), wholeSize;
+    bool isolated = (borderType & BORDER_ISOLATED) != 0;
+    borderType &= ~BORDER_ISOLATED;
+    int wdepth = std::max(CV_32F, std::max(ddepth, sdepth));
 
-    size_t globalsize[2] = {sz.width, sz.height};
-    size_t localsize[2] = {0, 1};
+    const char * const borderMap[] = { "BORDER_CONSTANT", "BORDER_REPLICATE", "BORDER_REFLECT", 0, "BORDER_REFLECT_101" };
+    size_t globalsize[2] = { size.width, size.height };
+    size_t localsize[2] = { 0, 1 };
 
-    UMat src; Size wholeSize;
-    if (!isIsolatedBorder)
+    UMat src = _src.getUMat();
+    if (!isolated)
     {
-        src = _src.getUMat();
         Point ofs;
         src.locateROI(wholeSize, ofs);
     }
 
-    size_t maxWorkItemSizes[32]; device.maxWorkItemSizes(maxWorkItemSizes);
-    size_t tryWorkItems = maxWorkItemSizes[0];
-    for (;;)
-    {
-        size_t BLOCK_SIZE = tryWorkItems;
-        while (BLOCK_SIZE > 32 && BLOCK_SIZE >= (size_t)ksize.width * 2 && BLOCK_SIZE > (size_t)sz.width * 2)
-            BLOCK_SIZE /= 2;
-        size_t BLOCK_SIZE_Y = 8; // TODO Check heuristic value on devices
-        while (BLOCK_SIZE_Y < BLOCK_SIZE / 8 && BLOCK_SIZE_Y * device.maxComputeUnits() * 32 < (size_t)sz.height)
-            BLOCK_SIZE_Y *= 2;
+    int h = isolated ? size.height : wholeSize.height;
+    int w = isolated ? size.width : wholeSize.width;
 
-        if ((size_t)ksize.width > BLOCK_SIZE)
-            return false;
+    size_t maxWorkItemSizes[32];
+    ocl::Device::getDefault().maxWorkItemSizes(maxWorkItemSizes);
+    int tryWorkItems = (int)maxWorkItemSizes[0];
 
-        int requiredTop = anchor.y;
-        int requiredLeft = (int)BLOCK_SIZE; // not this: anchor.x;
-        int requiredBottom = ksize.height - 1 - anchor.y;
-        int requiredRight = (int)BLOCK_SIZE; // not this: ksize.width - 1 - anchor.x;
-        int h = isIsolatedBorder ? sz.height : wholeSize.height;
-        int w = isIsolatedBorder ? sz.width : wholeSize.width;
+    ocl::Kernel kernel;
+    for ( ; ; )
+    {
+        int BLOCK_SIZE_X = tryWorkItems, BLOCK_SIZE_Y = 8;
 
-        bool extra_extrapolation = h < requiredTop || h < requiredBottom || w < requiredLeft || w < requiredRight;
+        while (BLOCK_SIZE_X > 32 && BLOCK_SIZE_X >= ksize.width * 2 && BLOCK_SIZE_X > size.width * 2)
+            BLOCK_SIZE_X /= 2;
+        while (BLOCK_SIZE_Y < BLOCK_SIZE_X / 8 && BLOCK_SIZE_Y * computeUnits * 32 < size.height)
+            BLOCK_SIZE_Y *= 2;
 
-        if ((w < ksize.width) || (h < ksize.height))
+        if (ksize.width > BLOCK_SIZE_X || w < ksize.width || h < ksize.height)
             return false;
 
-        char build_options[1024];
-        sprintf(build_options, "-D LOCAL_SIZE=%d -D BLOCK_SIZE_Y=%d -D DATA_DEPTH=%d -D DATA_CHAN=%d -D USE_DOUBLE=%d -D ANCHOR_X=%d -D ANCHOR_Y=%d -D KERNEL_SIZE_X=%d -D KERNEL_SIZE_Y=%d -D %s -D %s -D %s",
-                (int)BLOCK_SIZE, (int)BLOCK_SIZE_Y,
-                sdepth, cn, useDouble ? 1 : 0,
-                anchor.x, anchor.y, ksize.width, ksize.height,
-                btype,
-                extra_extrapolation ? "EXTRA_EXTRAPOLATION" : "NO_EXTRA_EXTRAPOLATION",
-                isIsolatedBorder ? "BORDER_ISOLATED" : "NO_BORDER_ISOLATED");
+        char cvt[2][50];
+        String opts = format("-D LOCAL_SIZE_X=%d -D BLOCK_SIZE_Y=%d -D ST=%s -D DT=%s -D WT=%s -D convertToDT=%s -D convertToWT=%s "
+                             "-D ANCHOR_X=%d -D ANCHOR_Y=%d -D KERNEL_SIZE_X=%d -D KERNEL_SIZE_Y=%d -D %s%s%s%s",
+                             BLOCK_SIZE_X, BLOCK_SIZE_Y, ocl::typeToStr(type), ocl::typeToStr(CV_MAKE_TYPE(ddepth, cn)),
+                             ocl::typeToStr(CV_MAKE_TYPE(wdepth, cn)),
+                             ocl::convertTypeStr(wdepth, ddepth, cn, cvt[0]),
+                             ocl::convertTypeStr(sdepth, wdepth, cn, cvt[1]),
+                             anchor.x, anchor.y, ksize.width, ksize.height, borderMap[borderType],
+                             isolated ? " -D BORDER_ISOLATED" : "", doubleSupport ? " -D DOUBLE_SUPPORT" : "",
+                             normalize ? " -D NORMALIZE" : "");
 
-        localsize[0] = BLOCK_SIZE;
-        globalsize[0] = DIVUP(sz.width, BLOCK_SIZE - (ksize.width - 1)) * BLOCK_SIZE;
-        globalsize[1] = DIVUP(sz.height, BLOCK_SIZE_Y);
+        localsize[0] = BLOCK_SIZE_X;
+        globalsize[0] = DIVUP(size.width, BLOCK_SIZE_X - (ksize.width - 1)) * BLOCK_SIZE_X;
+        globalsize[1] = DIVUP(size.height, BLOCK_SIZE_Y);
 
-        cv::String errmsg;
-        kernel.create("boxFilter", cv::ocl::imgproc::boxFilter_oclsrc, build_options);
+        kernel.create("boxFilter", cv::ocl::imgproc::boxFilter_oclsrc, opts);
 
         size_t kernelWorkGroupSize = kernel.workGroupSize();
         if (localsize[0] <= kernelWorkGroupSize)
             break;
-
-        if (BLOCK_SIZE < kernelWorkGroupSize)
+        if (BLOCK_SIZE_X < (int)kernelWorkGroupSize)
             return false;
-        tryWorkItems = kernelWorkGroupSize;
+
+        tryWorkItems = (int)kernelWorkGroupSize;
     }
 
-    _dst.create(sz, CV_MAKETYPE(ddepth, cn));
+    _dst.create(size, CV_MAKETYPE(ddepth, cn));
     UMat dst = _dst.getUMat();
-    if (src.empty())
-        src = _src.getUMat();
-    int idxArg = 0;
-    idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(src));
+
+    int idxArg = kernel.set(0, ocl::KernelArg::PtrReadOnly(src));
     idxArg = kernel.set(idxArg, (int)src.step);
     int srcOffsetX = (int)((src.offset % src.step) / src.elemSize());
     int srcOffsetY = (int)(src.offset / src.step);
-    int srcEndX = (isIsolatedBorder ? (srcOffsetX + sz.width) : wholeSize.width);
-    int srcEndY = (isIsolatedBorder ? (srcOffsetY + sz.height) : wholeSize.height);
+    int srcEndX = isolated ? srcOffsetX + size.width : wholeSize.width;
+    int srcEndY = isolated ? srcOffsetY + size.height : wholeSize.height;
     idxArg = kernel.set(idxArg, srcOffsetX);
     idxArg = kernel.set(idxArg, srcOffsetY);
     idxArg = kernel.set(idxArg, srcEndX);
     idxArg = kernel.set(idxArg, srcEndY);
     idxArg = kernel.set(idxArg, ocl::KernelArg::WriteOnly(dst));
-    float borderValue[4] = {0, 0, 0, 0};
-    double borderValueDouble[4] = {0, 0, 0, 0};
-    if ((borderType & ~BORDER_ISOLATED) == BORDER_CONSTANT)
-    {
-        int cnocl = (3 == cn) ? 4 : cn;
-        if (useDouble)
-            idxArg = kernel.set(idxArg, (void *)&borderValueDouble[0], sizeof(double) * cnocl);
-        else
-            idxArg = kernel.set(idxArg, (void *)&borderValue[0], sizeof(float) * cnocl);
-    }
-    if (useDouble)
-        idxArg = kernel.set(idxArg, (double)alpha);
-    else
+    if (normalize)
         idxArg = kernel.set(idxArg, (float)alpha);
 
-    return kernel.run(2, globalsize, localsize, true);
+    return kernel.run(2, globalsize, localsize, false);
 }
 
+#endif
+
 }
 
 
@@ -862,9 +821,7 @@ void cv::boxFilter( InputArray _src, OutputArray _dst, int ddepth,
                 Size ksize, Point anchor,
                 bool normalize, int borderType )
 {
-    bool use_opencl = ocl::useOpenCL() && _dst.isUMat() && normalize;
-    if( use_opencl && ocl_boxFilter(_src, _dst, ddepth, ksize, anchor, borderType) )
-        return;
+    CV_OCL_RUN(_dst.isUMat(), ocl_boxFilter(_src, _dst, ddepth, ksize, anchor, borderType, normalize))
 
     Mat src = _src.getMat();
     int sdepth = src.depth(), cn = src.channels();

modules/imgproc/test/ocl/test_boxfilter.cpp

@@ -56,32 +56,34 @@ enum
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 // boxFilter
-PARAM_TEST_CASE(BoxFilter, MatDepth, Channels, BorderType, bool)
+PARAM_TEST_CASE(BoxFilter, MatDepth, Channels, BorderType, bool, bool)
 {
     static const int kernelMinSize = 2;
     static const int kernelMaxSize = 10;
 
-    int type;
+    int depth, cn;
     Size ksize;
     Size dsize;
     Point anchor;
     int borderType;
-    bool useRoi;
+    bool normalize, useRoi;
 
     TEST_DECLARE_INPUT_PARAMETER(src)
     TEST_DECLARE_OUTPUT_PARAMETER(dst)
 
     virtual void SetUp()
     {
-        type = CV_MAKE_TYPE(GET_PARAM(0), GET_PARAM(1));
+        depth = GET_PARAM(0);
+        cn = GET_PARAM(1);
         borderType = GET_PARAM(2); // only not isolated border tested, because CPU module doesn't support isolated border case.
-        useRoi = GET_PARAM(3);
+        normalize = GET_PARAM(3);
+        useRoi = GET_PARAM(4);
     }
 
     void random_roi()
     {
+        int type = CV_MAKE_TYPE(depth, cn);
         dsize = randomSize(1, MAX_VALUE);
-
         ksize = randomSize(kernelMinSize, kernelMaxSize);
 
         Size roiSize = randomSize(ksize.width, MAX_VALUE, ksize.height, MAX_VALUE);
@@ -100,8 +102,7 @@ PARAM_TEST_CASE(BoxFilter, MatDepth, Channels, BorderType, bool)
 
     void Near(double threshold = 0.0)
     {
-        EXPECT_MAT_NEAR(dst, udst, threshold);
-        EXPECT_MAT_NEAR(dst_roi, udst_roi, threshold);
+        OCL_EXPECT_MATS_NEAR(dst, threshold)
     }
 };
 
@@ -111,10 +112,10 @@ OCL_TEST_P(BoxFilter, Mat)
     {
         random_roi();
 
-        OCL_OFF(cv::boxFilter(src_roi, dst_roi, -1, ksize, anchor, true, borderType));
-        OCL_ON(cv::boxFilter(usrc_roi, udst_roi, -1, ksize, anchor, true, borderType));
+        OCL_OFF(cv::boxFilter(src_roi, dst_roi, -1, ksize, anchor, normalize, borderType));
+        OCL_ON(cv::boxFilter(usrc_roi, udst_roi, -1, ksize, anchor, normalize, borderType));
 
-        Near(1.0);
+        Near(depth <= CV_32S ? 1 : 1e-3);
     }
 }
 
@@ -127,6 +128,7 @@ OCL_INSTANTIATE_TEST_CASE_P(ImageProc, BoxFilter,
                                        (BorderType)BORDER_REPLICATE,
                                        (BorderType)BORDER_REFLECT,
                                        (BorderType)BORDER_REFLECT_101),
+                                Bool(),
                                 Bool()  // ROI
                                 )
                            );