fixed gpu::filter2D border interpolation for CV_32FC1 type

added additional tests for gpu filters
fixed gpu features2D tests

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

@@ -1661,7 +1661,7 @@ public:
     };
 
     //! Constructor
-    explicit ORB_GPU(int nFeatures = 500, float scaleFactor = 1.2f, int nLevels = 3, int edgeThreshold = 31,
+    explicit ORB_GPU(int nFeatures = 500, float scaleFactor = 1.2f, int nLevels = 8, int edgeThreshold = 31,
                      int firstLevel = 0, int WTA_K = 2, int scoreType = 0, int patchSize = 31);
 
     //! Compute the ORB features on an image

modules/gpu/src/surf.cpp

@@ -63,7 +63,7 @@ void cv::gpu::SURF_GPU::releaseMemory() { throw_nogpu(); }
 
 #else /* !defined (HAVE_CUDA) */
 
-namespace cv { namespace gpu { namespace device 
+namespace cv { namespace gpu { namespace device
 {
     namespace surf
     {
@@ -79,13 +79,13 @@ namespace cv { namespace gpu { namespace device
         void icvFindMaximaInLayer_gpu(const PtrStepf& det, const PtrStepf& trace, int4* maxPosBuffer, unsigned int* maxCounter,
             int img_rows, int img_cols, int octave, bool use_mask, int nLayers);
 
-        void icvInterpolateKeypoint_gpu(const PtrStepf& det, const int4* maxPosBuffer, unsigned int maxCounter, 
-            float* featureX, float* featureY, int* featureLaplacian, float* featureSize, float* featureHessian, 
+        void icvInterpolateKeypoint_gpu(const PtrStepf& det, const int4* maxPosBuffer, unsigned int maxCounter,
+            float* featureX, float* featureY, int* featureLaplacian, float* featureSize, float* featureHessian,
             unsigned int* featureCounter);
 
         void icvCalcOrientation_gpu(const float* featureX, const float* featureY, const float* featureSize, float* featureDir, int nFeatures);
 
-        void compute_descriptors_gpu(const DevMem2Df& descriptors, 
+        void compute_descriptors_gpu(const DevMem2Df& descriptors,
             const float* featureX, const float* featureY, const float* featureSize, const float* featureDir, int nFeatures);
     }
 }}}
@@ -108,7 +108,7 @@ namespace
 
         return (HAAR_SIZE0 + HAAR_SIZE_INC * layer) << octave;
     }
-    
+
     class SURF_GPU_Invoker
     {
     public:
@@ -121,11 +121,11 @@ namespace
             CV_Assert(mask.empty() || (mask.size() == img.size() && mask.type() == CV_8UC1));
             CV_Assert(surf_.nOctaves > 0 && surf_.nOctaveLayers > 0);
             CV_Assert(TargetArchs::builtWith(GLOBAL_ATOMICS) && DeviceInfo().supports(GLOBAL_ATOMICS));
-                
+
             const int min_size = calcSize(surf_.nOctaves - 1, 0);
             CV_Assert(img_rows - min_size >= 0);
             CV_Assert(img_cols - min_size >= 0);
-            
+
             const int layer_rows = img_rows >> (surf_.nOctaves - 1);
             const int layer_cols = img_cols >> (surf_.nOctaves - 1);
             const int min_margin = ((calcSize((surf_.nOctaves - 1), 2) >> 1) >> (surf_.nOctaves - 1)) + 1;
@@ -159,7 +159,7 @@ namespace
         {
             ensureSizeIsEnough(img_rows * (surf_.nOctaveLayers + 2), img_cols, CV_32FC1, surf_.det);
             ensureSizeIsEnough(img_rows * (surf_.nOctaveLayers + 2), img_cols, CV_32FC1, surf_.trace);
-            
+
             ensureSizeIsEnough(1, maxCandidates, CV_32SC4, surf_.maxPosBuffer);
             ensureSizeIsEnough(SURF_GPU::SF_FEATURE_STRIDE, maxFeatures, CV_32FC1, keypoints);
             keypoints.setTo(Scalar::all(0));
@@ -182,7 +182,7 @@ namespace
 
                 if (maxCounter > 0)
                 {
-                    icvInterpolateKeypoint_gpu(surf_.det, surf_.maxPosBuffer.ptr<int4>(), maxCounter, 
+                    icvInterpolateKeypoint_gpu(surf_.det, surf_.maxPosBuffer.ptr<int4>(), maxCounter,
                         keypoints.ptr<float>(SURF_GPU::SF_X), keypoints.ptr<float>(SURF_GPU::SF_Y),
                         keypoints.ptr<int>(SURF_GPU::SF_LAPLACIAN), keypoints.ptr<float>(SURF_GPU::SF_SIZE),
                         keypoints.ptr<float>(SURF_GPU::SF_HESSIAN), counters.ptr<unsigned int>());
@@ -238,7 +238,7 @@ namespace
 cv::gpu::SURF_GPU::SURF_GPU()
 {
     hessianThreshold = 100;
-    extended = 1;
+    extended = true;
     nOctaves = 4;
     nOctaveLayers = 2;
     keypointsRatio = 0.01f;
@@ -323,9 +323,9 @@ void cv::gpu::SURF_GPU::downloadKeypoints(const GpuMat& keypointsGPU, vector<Key
     else
     {
         CV_Assert(keypointsGPU.type() == CV_32FC1 && keypointsGPU.rows == SF_FEATURE_STRIDE);
-        
+
         Mat keypointsCPU(keypointsGPU);
-        
+
         keypoints.resize(nFeatures);
 
         float* kp_x = keypointsCPU.ptr<float>(SF_X);
@@ -373,13 +373,13 @@ void cv::gpu::SURF_GPU::operator()(const GpuMat& img, const GpuMat& mask, GpuMat
     }
 }
 
-void cv::gpu::SURF_GPU::operator()(const GpuMat& img, const GpuMat& mask, GpuMat& keypoints, GpuMat& descriptors, 
+void cv::gpu::SURF_GPU::operator()(const GpuMat& img, const GpuMat& mask, GpuMat& keypoints, GpuMat& descriptors,
                                    bool useProvidedKeypoints)
 {
     if (!img.empty())
     {
         SURF_GPU_Invoker surf(*this, img, mask);
-    
+
         if (!useProvidedKeypoints)
             surf.detectKeypoints(keypoints);
         else if (!upright)
@@ -400,20 +400,20 @@ void cv::gpu::SURF_GPU::operator()(const GpuMat& img, const GpuMat& mask, vector
     downloadKeypoints(keypointsGPU, keypoints);
 }
 
-void cv::gpu::SURF_GPU::operator()(const GpuMat& img, const GpuMat& mask, vector<KeyPoint>& keypoints, 
+void cv::gpu::SURF_GPU::operator()(const GpuMat& img, const GpuMat& mask, vector<KeyPoint>& keypoints,
     GpuMat& descriptors, bool useProvidedKeypoints)
 {
     GpuMat keypointsGPU;
 
     if (useProvidedKeypoints)
-        uploadKeypoints(keypoints, keypointsGPU);    
+        uploadKeypoints(keypoints, keypointsGPU);
 
     (*this)(img, mask, keypointsGPU, descriptors, useProvidedKeypoints);
 
     downloadKeypoints(keypointsGPU, keypoints);
 }
 
-void cv::gpu::SURF_GPU::operator()(const GpuMat& img, const GpuMat& mask, vector<KeyPoint>& keypoints, 
+void cv::gpu::SURF_GPU::operator()(const GpuMat& img, const GpuMat& mask, vector<KeyPoint>& keypoints,
     vector<float>& descriptors, bool useProvidedKeypoints)
 {
     GpuMat descriptorsGPU;
@@ -423,9 +423,9 @@ void cv::gpu::SURF_GPU::operator()(const GpuMat& img, const GpuMat& mask, vector
     downloadDescriptors(descriptorsGPU, descriptors);
 }
 
-void cv::gpu::SURF_GPU::releaseMemory() 
+void cv::gpu::SURF_GPU::releaseMemory()
 {
-    sum.release(); 
+    sum.release();
     mask1.release();
     maskSum.release();
     intBuffer.release();

modules/gpu/test/test_copy_make_border.cpp

@@ -41,9 +41,11 @@
 
 #include "precomp.hpp"
 
-#ifdef HAVE_CUDA
+namespace {
 
-PARAM_TEST_CASE(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, MatType, int, Border, UseRoi)
+IMPLEMENT_PARAM_CLASS(Border, int)
+
+PARAM_TEST_CASE(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, MatType, Border, BorderType, UseRoi)
 {
     cv::gpu::DeviceInfo devInfo;
     cv::Size size;
@@ -80,11 +82,19 @@ TEST_P(CopyMakeBorder, Accuracy)
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CopyMakeBorder, testing::Combine(
-    ALL_DEVICES, 
+    ALL_DEVICES,
     DIFFERENT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
-    testing::Values(1, 10, 50),
-    testing::Values(Border(cv::BORDER_REFLECT101), Border(cv::BORDER_REPLICATE), Border(cv::BORDER_CONSTANT), Border(cv::BORDER_REFLECT), Border(cv::BORDER_WRAP)),
+    testing::Values(MatType(CV_8UC1),
+                    MatType(CV_8UC3),
+                    MatType(CV_8UC4),
+                    MatType(CV_16UC1),
+                    MatType(CV_16UC3),
+                    MatType(CV_16UC4),
+                    MatType(CV_32FC1),
+                    MatType(CV_32FC3),
+                    MatType(CV_32FC4)),
+    testing::Values(Border(1), Border(10), Border(50)),
+    ALL_BORDER_TYPES,
     WHOLE_SUBMAT));
 
-#endif // HAVE_CUDA
+} // namespace

modules/gpu/test/test_imgproc.cpp

@@ -2198,7 +2198,7 @@ INSTANTIATE_TEST_CASE_P(ImgProc, EqualizeHist, ALL_DEVICES);
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 // cornerHarris
 
-PARAM_TEST_CASE(CornerHarris, cv::gpu::DeviceInfo, MatType, Border, int, int)
+PARAM_TEST_CASE(CornerHarris, cv::gpu::DeviceInfo, MatType, BorderType, int, int)
 {
     cv::gpu::DeviceInfo devInfo;
     int type;
@@ -2257,7 +2257,7 @@ INSTANTIATE_TEST_CASE_P(ImgProc, CornerHarris, Combine(
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 // cornerMinEigen
 
-PARAM_TEST_CASE(CornerMinEigen, cv::gpu::DeviceInfo, MatType, Border, int, int)
+PARAM_TEST_CASE(CornerMinEigen, cv::gpu::DeviceInfo, MatType, BorderType, int, int)
 {
     cv::gpu::DeviceInfo devInfo;
     int type;
@@ -2572,6 +2572,8 @@ INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftSegmentation, Combine(
 ////////////////////////////////////////////////////////////////////////////////
 // matchTemplate
 
+CV_ENUM(TemplateMethod, cv::TM_SQDIFF, cv::TM_SQDIFF_NORMED, cv::TM_CCORR, cv::TM_CCORR_NORMED, cv::TM_CCOEFF, cv::TM_CCOEFF_NORMED)
+
 PARAM_TEST_CASE(MatchTemplate8U, cv::gpu::DeviceInfo, int, TemplateMethod)
 {
     cv::gpu::DeviceInfo devInfo;
@@ -2776,6 +2778,8 @@ INSTANTIATE_TEST_CASE_P(ImgProc, MatchTemplate_CCOEF_NORMED, Combine(
 ////////////////////////////////////////////////////////////////////////////
 // MulSpectrums
 
+CV_FLAGS(DftFlags, cv::DFT_INVERSE, cv::DFT_SCALE, cv::DFT_ROWS, cv::DFT_COMPLEX_OUTPUT, cv::DFT_REAL_OUTPUT)
+
 PARAM_TEST_CASE(MulSpectrums, cv::gpu::DeviceInfo, DftFlags)
 {
     cv::gpu::DeviceInfo devInfo;

modules/gpu/test/test_remap.cpp

@@ -70,7 +70,7 @@ namespace
     {
         typedef void (*func_t)(const cv::Mat& src, const cv::Mat& xmap, const cv::Mat& ymap, cv::Mat& dst, int borderType, cv::Scalar borderVal);
 
-        static const func_t nearest_funcs[] = 
+        static const func_t nearest_funcs[] =
         {
             remapImpl<unsigned char, NearestInterpolator>,
             remapImpl<signed char, NearestInterpolator>,
@@ -80,7 +80,7 @@ namespace
             remapImpl<float, NearestInterpolator>
         };
 
-        static const func_t linear_funcs[] = 
+        static const func_t linear_funcs[] =
         {
             remapImpl<unsigned char, LinearInterpolator>,
             remapImpl<signed char, LinearInterpolator>,
@@ -90,7 +90,7 @@ namespace
             remapImpl<float, LinearInterpolator>
         };
 
-        static const func_t cubic_funcs[] = 
+        static const func_t cubic_funcs[] =
         {
             remapImpl<unsigned char, CubicInterpolator>,
             remapImpl<signed char, CubicInterpolator>,
@@ -109,7 +109,7 @@ namespace
 ///////////////////////////////////////////////////////////////////
 // Test
 
-PARAM_TEST_CASE(Remap, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, Border, UseRoi)
+PARAM_TEST_CASE(Remap, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, BorderType, UseRoi)
 {
     cv::gpu::DeviceInfo devInfo;
     cv::Size size;
@@ -171,7 +171,7 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Remap, testing::Combine(
     DIFFERENT_SIZES,
     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
     testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
-    testing::Values(Border(cv::BORDER_REFLECT101), Border(cv::BORDER_REPLICATE), Border(cv::BORDER_CONSTANT), Border(cv::BORDER_REFLECT), Border(cv::BORDER_WRAP)),
+    testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT), BorderType(cv::BORDER_WRAP)),
     WHOLE_SUBMAT));
 
 #endif // HAVE_CUDA

modules/gpu/test/test_threshold.cpp

@@ -43,6 +43,9 @@
 
 #ifdef HAVE_CUDA
 
+CV_ENUM(ThreshOp, cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV)
+#define ALL_THRESH_OPS testing::Values(ThreshOp(cv::THRESH_BINARY), ThreshOp(cv::THRESH_BINARY_INV), ThreshOp(cv::THRESH_TRUNC), ThreshOp(cv::THRESH_TOZERO), ThreshOp(cv::THRESH_TOZERO_INV))
+
 PARAM_TEST_CASE(Threshold, cv::gpu::DeviceInfo, cv::Size, MatType, ThreshOp, UseRoi)
 {
     cv::gpu::DeviceInfo devInfo;

modules/gpu/test/test_warp_affine.cpp

@@ -175,7 +175,7 @@ namespace
 ///////////////////////////////////////////////////////////////////
 // Test
 
-PARAM_TEST_CASE(WarpAffine, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse, Interpolation, Border, UseRoi)
+PARAM_TEST_CASE(WarpAffine, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse, Interpolation, BorderType, UseRoi)
 {
     cv::gpu::DeviceInfo devInfo;
     cv::Size size;
@@ -225,7 +225,7 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpAffine, testing::Combine(
     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
     DIRECT_INVERSE,
     testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
-    testing::Values(Border(cv::BORDER_REFLECT101), Border(cv::BORDER_REPLICATE), Border(cv::BORDER_REFLECT), Border(cv::BORDER_WRAP)),
+    testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_REFLECT), BorderType(cv::BORDER_WRAP)),
     WHOLE_SUBMAT));
 
 ///////////////////////////////////////////////////////////////////

modules/gpu/test/test_warp_perspective.cpp

@@ -175,7 +175,7 @@ namespace
 ///////////////////////////////////////////////////////////////////
 // Test
 
-PARAM_TEST_CASE(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse, Interpolation, Border, UseRoi)
+PARAM_TEST_CASE(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse, Interpolation, BorderType, UseRoi)
 {
     cv::gpu::DeviceInfo devInfo;
     cv::Size size;
@@ -225,7 +225,7 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpPerspective, testing::Combine(
     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
     DIRECT_INVERSE,
     testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
-    testing::Values(Border(cv::BORDER_REFLECT101), Border(cv::BORDER_REPLICATE), Border(cv::BORDER_REFLECT), Border(cv::BORDER_WRAP)),
+    testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_REFLECT), BorderType(cv::BORDER_WRAP)),
     WHOLE_SUBMAT));
 
 ///////////////////////////////////////////////////////////////////

modules/gpu/test/utility.cpp

@@ -47,6 +47,9 @@ using namespace cv::gpu;
 using namespace cvtest;
 using namespace testing;
 
+//////////////////////////////////////////////////////////////////////
+// random generators
+
 int randomInt(int minVal, int maxVal)
 {
     RNG& rng = TS::ptr()->get_rng();
@@ -74,6 +77,9 @@ Mat randomMat(Size size, int type, double minVal, double maxVal)
     return randomMat(TS::ptr()->get_rng(), size, type, minVal, maxVal, false);
 }
 
+//////////////////////////////////////////////////////////////////////
+// GpuMat create
+
 cv::gpu::GpuMat createMat(cv::Size size, int type, bool useRoi)
 {
     Size size0 = size;
@@ -99,6 +105,30 @@ GpuMat loadMat(const Mat& m, bool useRoi)
     return d_m;
 }
 
+//////////////////////////////////////////////////////////////////////
+// Image load
+
+Mat readImage(const string& fileName, int flags)
+{
+    return imread(string(cvtest::TS::ptr()->get_data_path()) + fileName, flags);
+}
+
+Mat readImageType(const string& fname, int type)
+{
+    Mat src = readImage(fname, CV_MAT_CN(type) == 1 ? IMREAD_GRAYSCALE : IMREAD_COLOR);
+    if (CV_MAT_CN(type) == 4)
+    {
+        Mat temp;
+        cvtColor(src, temp, cv::COLOR_BGR2BGRA);
+        swap(src, temp);
+    }
+    src.convertTo(src, CV_MAT_DEPTH(type));
+    return src;
+}
+
+//////////////////////////////////////////////////////////////////////
+// Gpu devices
+
 bool supportFeature(const DeviceInfo& info, FeatureSet feature)
 {
     return TargetArchs::builtWith(feature) && info.supports(feature);
@@ -150,86 +180,146 @@ vector<DeviceInfo> devices(FeatureSet feature)
     return devs_filtered;
 }
 
-vector<MatType> types(int depth_start, int depth_end, int cn_start, int cn_end)
-{
-    vector<MatType> v;
-
-    v.reserve((depth_end - depth_start + 1) * (cn_end - cn_start + 1));
+//////////////////////////////////////////////////////////////////////
+// Additional assertion
 
-    for (int depth = depth_start; depth <= depth_end; ++depth)
+Mat getMat(InputArray arr)
+{
+    if (arr.kind() == _InputArray::GPU_MAT)
     {
-        for (int cn = cn_start; cn <= cn_end; ++cn)
-        {
-            v.push_back(CV_MAKETYPE(depth, cn));
-        }
+        Mat m;
+        arr.getGpuMat().download(m);
+        return m;
     }
 
-    return v;
+    return arr.getMat();
 }
 
-const vector<MatType>& all_types()
+double checkNorm(InputArray m1, const InputArray m2)
 {
-    static vector<MatType> v = types(CV_8U, CV_64F, 1, 4);
-
-    return v;
+    return norm(getMat(m1), getMat(m2), NORM_INF);
 }
 
-Mat readImage(const string& fileName, int flags)
+void minMaxLocGold(const Mat& src, double* minVal_, double* maxVal_, Point* minLoc_, Point* maxLoc_, const Mat& mask)
 {
-    return imread(string(cvtest::TS::ptr()->get_data_path()) + fileName, flags);
-}
+    if (src.depth() != CV_8S)
+    {
+        minMaxLoc(src, minVal_, maxVal_, minLoc_, maxLoc_, mask);
+        return;
+    }
 
-Mat readImageType(const string& fname, int type)
-{
-    Mat src = readImage(fname, CV_MAT_CN(type) == 1 ? IMREAD_GRAYSCALE : IMREAD_COLOR);
-    if (CV_MAT_CN(type) == 4)
+    // OpenCV's minMaxLoc doesn't support CV_8S type
+    double minVal = numeric_limits<double>::max();
+    Point minLoc(-1, -1);
+
+    double maxVal = -numeric_limits<double>::max();
+    Point maxLoc(-1, -1);
+
+    for (int y = 0; y < src.rows; ++y)
     {
-        Mat temp;
-        cvtColor(src, temp, cv::COLOR_BGR2BGRA);
-        swap(src, temp);
+        const schar* src_row = src.ptr<signed char>(y);
+        const uchar* mask_row = mask.empty() ? 0 : mask.ptr<unsigned char>(y);
+
+        for (int x = 0; x < src.cols; ++x)
+        {
+            if (!mask_row || mask_row[x])
+            {
+                schar val = src_row[x];
+
+                if (val < minVal)
+                {
+                    minVal = val;
+                    minLoc = cv::Point(x, y);
+                }
+
+                if (val > maxVal)
+                {
+                    maxVal = val;
+                    maxLoc = cv::Point(x, y);
+                }
+            }
+        }
     }
-    src.convertTo(src, CV_MAT_DEPTH(type));
-    return src;
+
+    if (minVal_) *minVal_ = minVal;
+    if (maxVal_) *maxVal_ = maxVal;
+
+    if (minLoc_) *minLoc_ = minLoc;
+    if (maxLoc_) *maxLoc_ = maxLoc;
 }
 
 namespace
 {
-    Mat getMat(InputArray arr)
+    template <typename T, typename OutT> string printMatValImpl(const Mat& m, Point p)
     {
-        if (arr.kind() == _InputArray::GPU_MAT)
+        const int cn = m.channels();
+
+        ostringstream ostr;
+        ostr << "(";
+
+        p.x /= cn;
+
+        ostr << static_cast<OutT>(m.at<T>(p.y, p.x * cn));
+        for (int c = 1; c < m.channels(); ++c)
         {
-            Mat m;
-            arr.getGpuMat().download(m);
-            return m;
+            ostr << ", " << static_cast<OutT>(m.at<T>(p.y, p.x * cn + c));
         }
+        ostr << ")";
+
+        return ostr.str();
+    }
+
+    string printMatVal(const Mat& m, Point p)
+    {
+        typedef string (*func_t)(const Mat& m, Point p);
+
+        static const func_t funcs[] =
+        {
+            printMatValImpl<uchar, int>, printMatValImpl<schar, int>, printMatValImpl<ushort, int>, printMatValImpl<short, int>,
+            printMatValImpl<int, int>, printMatValImpl<float, float>, printMatValImpl<double, double>
+        };
 
-        return arr.getMat();
+        return funcs[m.depth()](m, p);
     }
 }
 
-void showDiff(InputArray gold_, InputArray actual_, double eps)
+testing::AssertionResult assertMatNear(const char* expr1, const char* expr2, const char* eps_expr, cv::InputArray m1_, cv::InputArray m2_, double eps)
 {
-    Mat gold = getMat(gold_);
-    Mat actual = getMat(actual_);
+    Mat m1 = getMat(m1_);
+    Mat m2 = getMat(m2_);
 
-    Mat diff;
-    absdiff(gold, actual, diff);
-    threshold(diff, diff, eps, 255.0, cv::THRESH_BINARY);
+    if (m1.size() != m2.size())
+    {
+        return AssertionFailure() << "Matrices \"" << expr1 << "\" and \"" << expr2 << "\" have different sizes : \""
+                                  << expr1 << "\" [" << PrintToString(m1.size()) << "] vs \""
+                                  << expr2 << "\" [" << PrintToString(m2.size()) << "]";
+    }
 
-    namedWindow("gold", WINDOW_NORMAL);
-    namedWindow("actual", WINDOW_NORMAL);
-    namedWindow("diff", WINDOW_NORMAL);
+    if (m1.type() != m2.type())
+    {
+        return AssertionFailure() << "Matrices \"" << expr1 << "\" and \"" << expr2 << "\" have different types : \""
+                                  << expr1 << "\" [" << PrintToString(MatType(m1.type())) << "] vs \""
+                                  << expr2 << "\" [" << PrintToString(MatType(m2.type())) << "]";
+    }
 
-    imshow("gold", gold);
-    imshow("actual", actual);
-    imshow("diff", diff);
+    Mat diff;
+    absdiff(m1.reshape(1), m2.reshape(1), diff);
 
-    waitKey();
-}
+    double maxVal = 0.0;
+    Point maxLoc;
+    minMaxLocGold(diff, 0, &maxVal, 0, &maxLoc);
 
-double checkNorm(InputArray m1, const InputArray m2)
-{
-    return norm(getMat(m1), getMat(m2), NORM_INF);
+    if (maxVal > eps)
+    {
+        return AssertionFailure() << "The max difference between matrices \"" << expr1 << "\" and \"" << expr2
+                                  << "\" is " << maxVal << " at (" << maxLoc.y << ", " << maxLoc.x / m1.channels() << ")"
+                                  << ", which exceeds \"" << eps_expr << "\", where \""
+                                  << expr1 << "\" at (" << maxLoc.y << ", " << maxLoc.x / m1.channels() << ") evaluates to " << printMatVal(m1, maxLoc) << ", \""
+                                  << expr2 << "\" at (" << maxLoc.y << ", " << maxLoc.x / m1.channels() << ") evaluates to " << printMatVal(m2, maxLoc) << ", \""
+                                  << eps_expr << "\" evaluates to " << eps;
+    }
+
+    return AssertionSuccess();
 }
 
 double checkSimilarity(InputArray m1, InputArray m2)
@@ -239,6 +329,45 @@ double checkSimilarity(InputArray m1, InputArray m2)
     return std::abs(diff.at<float>(0, 0) - 1.f);
 }
 
+//////////////////////////////////////////////////////////////////////
+// Helper structs for value-parameterized tests
+
+vector<MatDepth> depths(int depth_start, int depth_end)
+{
+    vector<MatDepth> v;
+
+    v.reserve((depth_end - depth_start + 1));
+
+    for (int depth = depth_start; depth <= depth_end; ++depth)
+        v.push_back(depth);
+
+    return v;
+}
+
+vector<MatType> types(int depth_start, int depth_end, int cn_start, int cn_end)
+{
+    vector<MatType> v;
+
+    v.reserve((depth_end - depth_start + 1) * (cn_end - cn_start + 1));
+
+    for (int depth = depth_start; depth <= depth_end; ++depth)
+    {
+        for (int cn = cn_start; cn <= cn_end; ++cn)
+        {
+            v.push_back(CV_MAKETYPE(depth, cn));
+        }
+    }
+
+    return v;
+}
+
+const vector<MatType>& all_types()
+{
+    static vector<MatType> v = types(CV_8U, CV_64F, 1, 4);
+
+    return v;
+}
+
 void cv::gpu::PrintTo(const DeviceInfo& info, ostream* os)
 {
     (*os) << info.name();
@@ -259,3 +388,23 @@ void PrintTo(const Inverse& inverse, std::ostream* os)
     else
         (*os) << "direct";
 }
+
+void showDiff(InputArray gold_, InputArray actual_, double eps)
+{
+    Mat gold = getMat(gold_);
+    Mat actual = getMat(actual_);
+
+    Mat diff;
+    absdiff(gold, actual, diff);
+    threshold(diff, diff, eps, 255.0, cv::THRESH_BINARY);
+
+    namedWindow("gold", WINDOW_NORMAL);
+    namedWindow("actual", WINDOW_NORMAL);
+    namedWindow("diff", WINDOW_NORMAL);
+
+    imshow("gold", gold);
+    imshow("actual", actual);
+    imshow("diff", diff);
+
+    waitKey();
+}