Extended set of OpenVX HAL calls disabled for small images

modules/imgproc/src/accum.cpp

@@ -1945,6 +1945,8 @@ enum
 static bool openvx_accumulate(InputArray _src, InputOutputArray _dst, InputArray _mask, double _weight, int opType)
 {
     Mat srcMat = _src.getMat(), dstMat = _dst.getMat();
+    if (ovx::skipSmallImages<VX_KERNEL_ACCUMULATE>(srcMat.cols, srcMat.rows))
+        return false;
     if(!_mask.empty() ||
        (opType == VX_ACCUMULATE_WEIGHTED_OP && dstMat.type() != CV_8UC1  ) ||
        (opType != VX_ACCUMULATE_WEIGHTED_OP && dstMat.type() != CV_16SC1 ) ||

modules/imgproc/src/canny.cpp

@@ -868,7 +868,8 @@ void Canny( InputArray _src, OutputArray _dst,
             src.type() == CV_8UC1 &&
             !src.isSubmatrix() &&
             src.cols >= aperture_size &&
-            src.rows >= aperture_size,
+            src.rows >= aperture_size &&
+            !ovx::skipSmallImages<VX_KERNEL_CANNY_EDGE_DETECTOR>(src.cols, src.rows),
         openvx_canny(
             src,
             dst,

modules/imgproc/src/deriv.cpp

@@ -191,7 +191,7 @@ namespace cv
         int stype = _src.type();
         int dtype = _dst.type();
         if (stype != CV_8UC1 || (dtype != CV_16SC1 && dtype != CV_8UC1) ||
-            ksize < 3 || ksize % 2 != 1 || delta != 0.0)
+            ksize != 3 || delta != 0.0)//Restrict to 3x3 kernels since otherwise convolution would be slower than separable filter
             return false;
 
         Mat src = _src.getMat();
@@ -200,6 +200,12 @@ namespace cv
         if (src.cols < ksize || src.rows < ksize)
             return false;
 
+        if (dtype == CV_16SC1 && ksize == 3 && ((dx | dy) == 1) && (dx + dy) == 1 ?
+            ovx::skipSmallImages<VX_KERNEL_SOBEL_3x3>(src.cols, src.rows) :
+            ovx::skipSmallImages<VX_KERNEL_CUSTOM_CONVOLUTION>(src.cols, src.rows)
+            )
+            return false;
+
         int iscale = 1;
         vx_uint32 cscale = 1;
         if(scale != 1.0)
@@ -237,8 +243,8 @@ namespace cv
         try
         {
             ivx::Context ctx = ovx::getOpenVXContext();
-            if ((vx_size)ksize > ctx.convolutionMaxDimension())
-                return false;
+            //if ((vx_size)ksize > ctx.convolutionMaxDimension())
+            //    return false;
 
             Mat a;
             if (dst.data != src.data)

modules/imgproc/src/featureselect.cpp

@@ -377,7 +377,8 @@ void cv::goodFeaturesToTrack( InputArray _image, OutputArray _corners,
     }
 
     // Disabled due to bad accuracy
-    CV_OVX_RUN(false && useHarrisDetector && _mask.empty(),
+    CV_OVX_RUN(false && useHarrisDetector && _mask.empty() &&
+               !ovx::skipSmallImages<VX_KERNEL_HARRIS_CORNERS>(image.cols, image.rows),
                openvx_harris(image, _corners, maxCorners, qualityLevel, minDistance, blockSize, harrisK))
 
     if( useHarrisDetector )

modules/imgproc/src/histogram.cpp

@@ -1376,7 +1376,8 @@ void cv::calcHist( const Mat* images, int nimages, const int* channels,
         images && histSize &&
         nimages == 1 && images[0].type() == CV_8UC1 && dims == 1 && _mask.getMat().empty() &&
         (!channels || channels[0] == 0) && !accumulate && uniform &&
-        ranges && ranges[0],
+        ranges && ranges[0] &&
+        !ovx::skipSmallImages<VX_KERNEL_HISTOGRAM>(images[0].cols, images[0].rows),
         openvx_calchist(images[0], _hist, histSize[0], ranges[0]))
 
     CV_IPP_RUN(nimages == 1 && images[0].type() == CV_8UC1 && dims == 1 && channels &&
@@ -3817,7 +3818,7 @@ void cv::equalizeHist( InputArray _src, OutputArray _dst )
     _dst.create( src.size(), src.type() );
     Mat dst = _dst.getMat();
 
-    CV_OVX_RUN(true,
+    CV_OVX_RUN(!ovx::skipSmallImages<VX_KERNEL_EQUALIZE_HISTOGRAM>(src.cols, src.rows),
                openvx_equalize_hist(src, dst))
 
     Mutex histogramLockInstance;

modules/imgproc/src/imgwarp.cpp

@@ -4935,6 +4935,7 @@ void cv::remap( InputArray _src, OutputArray _dst,
 
     CV_OVX_RUN(
         src.type() == CV_8UC1 && dst.type() == CV_8UC1 &&
+        !ovx::skipSmallImages<VX_KERNEL_REMAP>(src.cols, src.rows) &&
         (borderType& ~BORDER_ISOLATED) == BORDER_CONSTANT &&
         ((map1.type() == CV_32FC2 && map2.empty() && map1.size == dst.size) ||
          (map1.type() == CV_32FC1 && map2.type() == CV_32FC1 && map1.size == dst.size && map2.size == dst.size) ||

modules/imgproc/src/pyramids.cpp

@@ -1265,6 +1265,9 @@ static bool openvx_pyrDown( InputArray _src, OutputArray _dst, const Size& _dsz,
 
     Mat srcMat = _src.getMat();
 
+    if (ovx::skipSmallImages<VX_KERNEL_HALFSCALE_GAUSSIAN>(srcMat.cols, srcMat.rows))
+        return false;
+
     CV_Assert(!srcMat.empty());
 
     Size ssize = _src.size();

modules/imgproc/src/smooth.cpp

@@ -1649,11 +1649,17 @@ namespace cv
         if (stype != CV_8UC1 || (ddepth != CV_8U && ddepth != CV_16S) ||
             (anchor.x >= 0 && anchor.x != ksize.width / 2) ||
             (anchor.y >= 0 && anchor.y != ksize.height / 2) ||
-            ksize.width % 2 != 1 || ksize.height % 2 != 1 ||
-            ksize.width < 3 || ksize.height < 3)
+            ksize.width != 3 || ksize.height != 3)
             return false;
 
         Mat src = _src.getMat();
+
+        if (ddepth == CV_8U && ksize.width == 3 && ksize.height == 3 && normalize ?
+            ovx::skipSmallImages<VX_KERNEL_BOX_3x3>(src.cols, src.rows) :
+            ovx::skipSmallImages<VX_KERNEL_CUSTOM_CONVOLUTION>(src.cols, src.rows)
+            )
+            return false;
+
         _dst.create(src.size(), CV_MAKETYPE(ddepth, 1));
         Mat dst = _dst.getMat();
 
@@ -1678,8 +1684,8 @@ namespace cv
         try
         {
             ivx::Context ctx = ovx::getOpenVXContext();
-            if ((vx_size)(ksize.width) > ctx.convolutionMaxDimension() || (vx_size)(ksize.height) > ctx.convolutionMaxDimension())
-                return false;
+            //if ((vx_size)(ksize.width) > ctx.convolutionMaxDimension() || (vx_size)(ksize.height) > ctx.convolutionMaxDimension())
+            //    return false;
 
             Mat a;
             if (dst.data != src.data)
@@ -2210,6 +2216,7 @@ static bool openvx_gaussianBlur(InputArray _src, OutputArray _dst, Size ksize,
 
     if (stype != CV_8UC1 ||
         ksize.width < 3 || ksize.height < 3 ||
+        ksize.width > 5 || ksize.height > 5 ||
         ksize.width % 2 != 1 || ksize.height % 2 != 1)
         return false;
 
@@ -2219,6 +2226,12 @@ static bool openvx_gaussianBlur(InputArray _src, OutputArray _dst, Size ksize,
     Mat src = _src.getMat();
     Mat dst = _dst.getMat();
 
+    if (ksize.width == 3 && ksize.height == 3 && (sigma1 == 0.0 || (sigma1 - 0.8) < DBL_EPSILON) && (sigma2 == 0.0 || (sigma2 - 0.8) < DBL_EPSILON) ?
+        ovx::skipSmallImages<VX_KERNEL_GAUSSIAN_3x3>(src.cols, src.rows) :
+        ovx::skipSmallImages<VX_KERNEL_CUSTOM_CONVOLUTION>(src.cols, src.rows)
+        )
+        return false;
+
     if (src.cols < ksize.width || src.rows < ksize.height)
         return false;
 
@@ -3359,6 +3372,14 @@ namespace cv
         Mat src = _src.getMat();
         Mat dst = _dst.getMat();
 
+        if (
+#ifdef VX_VERSION_1_1
+             ksize != 3 ? ovx::skipSmallImages<VX_KERNEL_NON_LINEAR_FILTER>(src.cols, src.rows) :
+#endif
+             ovx::skipSmallImages<VX_KERNEL_MEDIAN_3x3>(src.cols, src.rows)
+           )
+            return false;
+
         try
         {
             ivx::Context ctx = ovx::getOpenVXContext();

modules/imgproc/src/thresh.cpp

@@ -1390,7 +1390,7 @@ double cv::threshold( InputArray _src, OutputArray _dst, double thresh, double m
             return thresh;
         }
 
-       CV_OVX_RUN(true,
+       CV_OVX_RUN(!ovx::skipSmallImages<VX_KERNEL_THRESHOLD>(src.cols, src.rows),
                   openvx_threshold(src, dst, ithresh, imaxval, type), (double)ithresh)
 
         thresh = ithresh;