add sanity checks into the denoising gpu performance tests

modules/gpu/perf/perf_denoising.cpp

@@ -11,7 +11,7 @@ using namespace testing;
 
 DEF_PARAM_TEST(Sz_Depth_Cn_KernelSz, cv::Size, MatDepth, MatCn, int);
 
-PERF_TEST_P(Sz_Depth_Cn_KernelSz, Denoising_BilateralFilter, 
+PERF_TEST_P(Sz_Depth_Cn_KernelSz, Denoising_BilateralFilter,
             Combine(GPU_DENOISING_IMAGE_SIZES, Values(CV_8U, CV_32F), GPU_CHANNELS_1_3, Values(3, 5, 9)))
 {
     declare.time(60.0);
@@ -30,7 +30,7 @@ PERF_TEST_P(Sz_Depth_Cn_KernelSz, Denoising_BilateralFilter,
     cv::Mat src(size, type);
     fillRandom(src);
 
-     if (runOnGpu)
+     if (PERF_RUN_GPU())
     {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
@@ -41,6 +41,8 @@ PERF_TEST_P(Sz_Depth_Cn_KernelSz, Denoising_BilateralFilter,
         {
             cv::gpu::bilateralFilter(d_src, d_dst, kernel_size, sigma_color, sigma_spatial, borderMode);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -52,6 +54,8 @@ PERF_TEST_P(Sz_Depth_Cn_KernelSz, Denoising_BilateralFilter,
         {
             cv::bilateralFilter(src, dst, kernel_size, sigma_color, sigma_spatial, borderMode);
         }
+
+        CPU_SANITY_CHECK(dst);
     }
 }
 
@@ -61,27 +65,27 @@ PERF_TEST_P(Sz_Depth_Cn_KernelSz, Denoising_BilateralFilter,
 
 DEF_PARAM_TEST(Sz_Depth_Cn_WinSz_BlockSz, cv::Size, MatDepth, MatCn, int, int);
 
-PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, Denoising_NonLocalMeans, 
+PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, Denoising_NonLocalMeans,
             Combine(GPU_DENOISING_IMAGE_SIZES, Values<MatDepth>(CV_8U), GPU_CHANNELS_1_3, Values(21), Values(5, 7)))
 {
     declare.time(60.0);
 
     cv::Size size = GET_PARAM(0);
-    int depth = GET_PARAM(1);    
-    int channels = GET_PARAM(2);    
-    
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
+
     int search_widow_size = GET_PARAM(3);
     int block_size = GET_PARAM(4);
 
     float h = 10;
     int borderMode = cv::BORDER_REFLECT101;
-    
+
     int type = CV_MAKE_TYPE(depth, channels);
 
     cv::Mat src(size, type);
     fillRandom(src);
 
-    if (runOnGpu)
+    if (PERF_RUN_GPU())
     {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
@@ -92,10 +96,12 @@ PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, Denoising_NonLocalMeans,
         {
             cv::gpu::nonLocalMeans(d_src, d_dst, h, search_widow_size, block_size, borderMode);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
-        FAIL();
+        FAIL() << "No such CPU implementation analogy";
     }
 }
 
@@ -105,35 +111,37 @@ PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, Denoising_NonLocalMeans,
 
 DEF_PARAM_TEST(Sz_Depth_Cn_WinSz_BlockSz, cv::Size, MatDepth, MatCn, int, int);
 
-PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, Denoising_FastNonLocalMeans, 
+PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, Denoising_FastNonLocalMeans,
             Combine(GPU_DENOISING_IMAGE_SIZES, Values<MatDepth>(CV_8U), GPU_CHANNELS_1_3, Values(21), Values(7)))
 {
     declare.time(150.0);
-    
+
     cv::Size size = GET_PARAM(0);
-    int depth = GET_PARAM(1);    
-    
+    int depth = GET_PARAM(1);
+
     int search_widow_size = GET_PARAM(2);
     int block_size = GET_PARAM(3);
-    
-    float h = 10;           
-    int type = CV_MAKE_TYPE(depth, 1);    
+
+    float h = 10;
+    int type = CV_MAKE_TYPE(depth, 1);
 
     cv::Mat src(size, type);
     fillRandom(src);
 
-    if (runOnGpu)
+    if (PERF_RUN_GPU())
     {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
         cv::gpu::FastNonLocalMeansDenoising fnlmd;
 
-        fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size); 
+        fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size);
 
         TEST_CYCLE()
         {
-            fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size); 
+            fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -144,6 +152,8 @@ PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, Denoising_FastNonLocalMeans,
         {
             cv::fastNlMeansDenoising(src, dst, h, block_size, search_widow_size);
         }
+
+        CPU_SANITY_CHECK(dst);
     }
 }
 
@@ -152,35 +162,37 @@ PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, Denoising_FastNonLocalMeans,
 
 DEF_PARAM_TEST(Sz_Depth_WinSz_BlockSz, cv::Size, MatDepth, int, int);
 
-PERF_TEST_P(Sz_Depth_WinSz_BlockSz, Denoising_FastNonLocalMeansColored, 
+PERF_TEST_P(Sz_Depth_WinSz_BlockSz, Denoising_FastNonLocalMeansColored,
             Combine(GPU_DENOISING_IMAGE_SIZES, Values<MatDepth>(CV_8U), Values(21), Values(7)))
 {
     declare.time(350.0);
-    
+
     cv::Size size = GET_PARAM(0);
     int depth = GET_PARAM(1);
-    
+
     int search_widow_size = GET_PARAM(2);
     int block_size = GET_PARAM(3);
 
-    float h = 10;       
+    float h = 10;
     int type = CV_MAKE_TYPE(depth, 3);
 
     cv::Mat src(size, type);
     fillRandom(src);
 
-    if (runOnGpu)
+    if (PERF_RUN_GPU())
     {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
         cv::gpu::FastNonLocalMeansDenoising fnlmd;
 
-        fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size); 
+        fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size);
 
         TEST_CYCLE()
         {
-            fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size); 
+            fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -191,5 +203,7 @@ PERF_TEST_P(Sz_Depth_WinSz_BlockSz, Denoising_FastNonLocalMeansColored,
         {
             cv::fastNlMeansDenoisingColored(src, dst, h, h, block_size, search_widow_size);
         }
+
+        CPU_SANITY_CHECK(dst);
     }
 }
\ No newline at end of file