Merge pull request #927 from bitwangyaoyao:2.4_perf

modules/ocl/perf/perf_blend.cpp

@@ -71,7 +71,7 @@ void blendLinearGold(const cv::Mat &img1, const cv::Mat &img2, const cv::Mat &we
 }
 PERFTEST(blend)
 {
-    Mat src1, src2, weights1, weights2, dst;
+    Mat src1, src2, weights1, weights2, dst, ocl_dst;
     ocl::oclMat d_src1, d_src2, d_weights1, d_weights2, d_dst;
 
     int all_type[] = {CV_8UC1, CV_8UC4};
@@ -103,10 +103,6 @@ PERFTEST(blend)
             ocl::blendLinear(d_src1, d_src2, d_weights1, d_weights2, d_dst);
             WARMUP_OFF;
 
-            cv::Mat ocl_mat;
-            d_dst.download(ocl_mat);
-            TestSystem::instance().setAccurate(ExpectedMatNear(dst, ocl_mat, 1.f));
-
             GPU_ON;
             ocl::blendLinear(d_src1, d_src2, d_weights1, d_weights2, d_dst);
             GPU_OFF;
@@ -117,8 +113,10 @@ PERFTEST(blend)
             d_weights1.upload(weights1);
             d_weights2.upload(weights2);
             ocl::blendLinear(d_src1, d_src2, d_weights1, d_weights2, d_dst);
-            d_dst.download(dst);
+            d_dst.download(ocl_dst);
             GPU_FULL_OFF;
+
+            TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.f);
         }
     }
 }
\ No newline at end of file

modules/ocl/perf/perf_brute_force_matcher.cpp

@@ -88,9 +88,6 @@ PERFTEST(BruteForceMatcher)
         d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
         WARMUP_OFF;
 
-        d_matcher.match(d_query, d_train, d_matches[0]);
-        TestSystem::instance().setAccurate(AssertEQ<size_t>(d_matches[0].size(), matches[0].size()));
-
         GPU_ON;
         d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
         GPU_OFF;
@@ -98,9 +95,15 @@ PERFTEST(BruteForceMatcher)
         GPU_FULL_ON;
         d_query.upload(query);
         d_train.upload(train);
-        d_matcher.match(d_query, d_train, matches[0]);
+        d_matcher.match(d_query, d_train, d_matches[0]);
         GPU_FULL_OFF;
 
+        int diff = abs((int)d_matches[0].size() - (int)matches[0].size());
+        if(diff == 0)
+            TestSystem::instance().setAccurate(1, 0);
+        else
+            TestSystem::instance().setAccurate(0, diff);
+
         SUBTEST << size << "; knnMatch";
 
         matcher.knnMatch(query, train, matches, 2);
@@ -123,7 +126,11 @@ PERFTEST(BruteForceMatcher)
         d_matcher.knnMatch(d_query, d_train, d_matches, 2);
         GPU_FULL_OFF;
 
-        TestSystem::instance().setAccurate(AssertEQ<size_t>(d_matches[0].size(), matches[0].size()));
+        diff = abs((int)d_matches[0].size() - (int)matches[0].size());
+        if(diff == 0)
+            TestSystem::instance().setAccurate(1, 0);
+        else
+            TestSystem::instance().setAccurate(0, diff);
 
         SUBTEST << size << "; radiusMatch";
 
@@ -151,6 +158,10 @@ PERFTEST(BruteForceMatcher)
         d_matcher.radiusMatch(d_query, d_train, d_matches, max_distance);
         GPU_FULL_OFF;
 
-        TestSystem::instance().setAccurate(AssertEQ<size_t>(d_matches[0].size(), matches[0].size()));
+        diff = abs((int)d_matches[0].size() - (int)matches[0].size());
+        if(diff == 0)
+            TestSystem::instance().setAccurate(1, 0);
+        else
+            TestSystem::instance().setAccurate(0, diff);
     }
 }
\ No newline at end of file

modules/ocl/perf/perf_canny.cpp

@@ -57,7 +57,7 @@ PERFTEST(Canny)
 
     SUBTEST << img.cols << 'x' << img.rows << "; aloeL.jpg" << "; edges" << "; CV_8UC1";
 
-    Mat edges(img.size(), CV_8UC1);
+    Mat edges(img.size(), CV_8UC1), ocl_edges;
 
     CPU_ON;
     Canny(img, edges, 50.0, 100.0);
@@ -71,8 +71,6 @@ PERFTEST(Canny)
     ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0);
     WARMUP_OFF;
 
-    TestSystem::instance().setAccurate(ExceptedMatSimilar(edges, d_edges, 2e-2));
-
     GPU_ON;
     ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0);
     GPU_OFF;
@@ -80,6 +78,8 @@ PERFTEST(Canny)
     GPU_FULL_ON;
     d_img.upload(img);
     ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0);
-    d_edges.download(edges);
+    d_edges.download(ocl_edges);
     GPU_FULL_OFF;
+
+    TestSystem::instance().ExceptedMatSimilar(edges, ocl_edges, 2e-2);
 }
\ No newline at end of file

modules/ocl/perf/perf_color.cpp

@@ -48,7 +48,7 @@
 ///////////// cvtColor////////////////////////
 PERFTEST(cvtColor)
 {
-    Mat src, dst;
+    Mat src, dst, ocl_dst;
     ocl::oclMat d_src, d_dst;
 
     int all_type[] = {CV_8UC4};
@@ -73,10 +73,6 @@ PERFTEST(cvtColor)
             ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4);
             WARMUP_OFF;
 
-            cv::Mat ocl_mat;
-            d_dst.download(ocl_mat);
-            TestSystem::instance().setAccurate(ExceptedMatSimilar(dst, ocl_mat, 1e-5));
-
             GPU_ON;
             ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4);
             GPU_OFF;
@@ -84,8 +80,10 @@ PERFTEST(cvtColor)
             GPU_FULL_ON;
             d_src.upload(src);
             ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4);
-            d_dst.download(dst);
+            d_dst.download(ocl_dst);
             GPU_FULL_OFF;
+
+            TestSystem::instance().ExceptedMatSimilar(dst, ocl_dst, 1e-5);
         }
 
 

modules/ocl/perf/perf_columnsum.cpp

@@ -48,7 +48,7 @@
 ///////////// columnSum////////////////////////
 PERFTEST(columnSum)
 {
-    Mat src, dst;
+    Mat src, dst, ocl_dst;
     ocl::oclMat d_src, d_dst;
 
     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
@@ -63,23 +63,16 @@ PERFTEST(columnSum)
             dst.at<float>(0, j) = src.at<float>(0, j);
 
         for (int i = 1; i < src.rows; ++i)
-        {for (int j = 0; j < src.cols; ++j)
-            {
+            for (int j = 0; j < src.cols; ++j)
                 dst.at<float>(i, j) = dst.at<float>(i - 1 , j) + src.at<float>(i , j);
-            }
-        }
-
         CPU_OFF;
 
         d_src.upload(src);
+
         WARMUP_ON;
         ocl::columnSum(d_src, d_dst);
         WARMUP_OFF;
 
-        cv::Mat ocl_mat;
-        d_dst.download(ocl_mat);
-        TestSystem::instance().setAccurate(ExpectedMatNear(dst, ocl_mat, 5e-1));
-
         GPU_ON;
         ocl::columnSum(d_src, d_dst);
         GPU_OFF;
@@ -87,7 +80,9 @@ PERFTEST(columnSum)
         GPU_FULL_ON;
         d_src.upload(src);
         ocl::columnSum(d_src, d_dst);
-        d_dst.download(dst);
+        d_dst.download(ocl_dst);
         GPU_FULL_OFF;
+
+        TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 5e-1);
     }
 }
\ No newline at end of file

modules/ocl/perf/perf_fft.cpp

@@ -48,7 +48,7 @@
 ///////////// dft ////////////////////////
 PERFTEST(dft)
 {
-    Mat src, dst;
+    Mat src, dst, ocl_dst;
     ocl::oclMat d_src, d_dst;
 
     int all_type[] = {CV_32FC2};
@@ -74,8 +74,6 @@ PERFTEST(dft)
             ocl::dft(d_src, d_dst, Size(size, size));
             WARMUP_OFF;
 
-            TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), src.size().area() * 1e-4));
-
             GPU_ON;
             ocl::dft(d_src, d_dst, Size(size, size));
             GPU_OFF;
@@ -83,8 +81,10 @@ PERFTEST(dft)
             GPU_FULL_ON;
             d_src.upload(src);
             ocl::dft(d_src, d_dst, Size(size, size));
-            d_dst.download(dst);
+            d_dst.download(ocl_dst);
             GPU_FULL_OFF;
+
+            TestSystem::instance().ExpectedMatNear(dst, ocl_dst, src.size().area() * 1e-4);
         }
 
     }

modules/ocl/perf/perf_filters.cpp

@@ -48,7 +48,7 @@
 ///////////// Blur////////////////////////
 PERFTEST(Blur)
 {
-    Mat src1, dst;
+    Mat src1, dst, ocl_dst;
     ocl::oclMat d_src1, d_dst;
 
     Size ksize = Size(3, 3);
@@ -65,7 +65,6 @@ PERFTEST(Blur)
             gen(src1, size, size, all_type[j], 0, 256);
             gen(dst, size, size, all_type[j], 0, 256);
 
-
             blur(src1, dst, ksize, Point(-1, -1), bordertype);
 
             CPU_ON;
@@ -78,8 +77,6 @@ PERFTEST(Blur)
             ocl::blur(d_src1, d_dst, ksize, Point(-1, -1), bordertype);
             WARMUP_OFF;
 
-            TestSystem::instance().setAccurate(ExpectedMatNear(cv::Mat(d_dst), dst, 1.0));
-
             GPU_ON;
             ocl::blur(d_src1, d_dst, ksize, Point(-1, -1), bordertype);
             GPU_OFF;
@@ -87,8 +84,10 @@ PERFTEST(Blur)
             GPU_FULL_ON;
             d_src1.upload(src1);
             ocl::blur(d_src1, d_dst, ksize, Point(-1, -1), bordertype);
-            d_dst.download(dst);
+            d_dst.download(ocl_dst);
             GPU_FULL_OFF;
+
+            TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1.0);
         }
 
     }
@@ -96,7 +95,7 @@ PERFTEST(Blur)
 ///////////// Laplacian////////////////////////
 PERFTEST(Laplacian)
 {
-    Mat src1, dst;
+    Mat src1, dst, ocl_dst;
     ocl::oclMat d_src1, d_dst;
 
     int ksize = 3;
@@ -112,7 +111,6 @@ PERFTEST(Laplacian)
             gen(src1, size, size, all_type[j], 0, 256);
             gen(dst, size, size, all_type[j], 0, 256);
 
-
             Laplacian(src1, dst, -1, ksize, 1);
 
             CPU_ON;
@@ -125,8 +123,6 @@ PERFTEST(Laplacian)
             ocl::Laplacian(d_src1, d_dst, -1, ksize, 1);
             WARMUP_OFF;
 
-            TestSystem::instance().setAccurate(ExpectedMatNear(cv::Mat(d_dst), dst, 1e-5));
-
             GPU_ON;
             ocl::Laplacian(d_src1, d_dst, -1, ksize, 1);
             GPU_OFF;
@@ -134,8 +130,10 @@ PERFTEST(Laplacian)
             GPU_FULL_ON;
             d_src1.upload(src1);
             ocl::Laplacian(d_src1, d_dst, -1, ksize, 1);
-            d_dst.download(dst);
+            d_dst.download(ocl_dst);
             GPU_FULL_OFF;
+
+            TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5);
         }
 
     }
@@ -144,7 +142,7 @@ PERFTEST(Laplacian)
 ///////////// Erode ////////////////////
 PERFTEST(Erode)
 {
-    Mat src, dst, ker;
+    Mat src, dst, ker, ocl_dst;
     ocl::oclMat d_src, d_dst;
 
     int all_type[] = {CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4};
@@ -171,8 +169,6 @@ PERFTEST(Erode)
             ocl::erode(d_src, d_dst, ker);
             WARMUP_OFF;
 
-            TestSystem::instance().setAccurate(ExpectedMatNear(cv::Mat(d_dst), dst, 1e-5));            
-
             GPU_ON;
             ocl::erode(d_src, d_dst, ker);
             GPU_OFF;
@@ -180,8 +176,10 @@ PERFTEST(Erode)
             GPU_FULL_ON;
             d_src.upload(src);
             ocl::erode(d_src, d_dst, ker);
-            d_dst.download(dst);
+            d_dst.download(ocl_dst);
             GPU_FULL_OFF;
+
+            TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5);
         }
 
     }
@@ -190,7 +188,7 @@ PERFTEST(Erode)
 ///////////// Sobel ////////////////////////
 PERFTEST(Sobel)
 {
-    Mat src, dst;
+    Mat src, dst, ocl_dst;
     ocl::oclMat d_src, d_dst;
 
     int dx = 1;
@@ -218,8 +216,6 @@ PERFTEST(Sobel)
             ocl::Sobel(d_src, d_dst, -1, dx, dy);
             WARMUP_OFF;
 
-            TestSystem::instance().setAccurate(ExpectedMatNear(cv::Mat(d_dst), dst, 1));
-
             GPU_ON;
             ocl::Sobel(d_src, d_dst, -1, dx, dy);
             GPU_OFF;
@@ -227,8 +223,10 @@ PERFTEST(Sobel)
             GPU_FULL_ON;
             d_src.upload(src);
             ocl::Sobel(d_src, d_dst, -1, dx, dy);
-            d_dst.download(dst);
+            d_dst.download(ocl_dst);
             GPU_FULL_OFF;
+
+            TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1);
         }
 
     }
@@ -236,7 +234,7 @@ PERFTEST(Sobel)
 ///////////// Scharr ////////////////////////
 PERFTEST(Scharr)
 {
-    Mat src, dst;
+    Mat src, dst, ocl_dst;
     ocl::oclMat d_src, d_dst;
 
     int dx = 1;
@@ -264,8 +262,6 @@ PERFTEST(Scharr)
             ocl::Scharr(d_src, d_dst, -1, dx, dy);
             WARMUP_OFF;
 
-            TestSystem::instance().setAccurate(ExpectedMatNear(cv::Mat(d_dst), dst, 1));
-
             GPU_ON;
             ocl::Scharr(d_src, d_dst, -1, dx, dy);
             GPU_OFF;
@@ -273,8 +269,10 @@ PERFTEST(Scharr)
             GPU_FULL_ON;
             d_src.upload(src);
             ocl::Scharr(d_src, d_dst, -1, dx, dy);
-            d_dst.download(dst);
+            d_dst.download(ocl_dst);
             GPU_FULL_OFF;
+
+            TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1);
         }
 
     }
@@ -283,7 +281,7 @@ PERFTEST(Scharr)
 ///////////// GaussianBlur ////////////////////////
 PERFTEST(GaussianBlur)
 {
-    Mat src, dst;
+    Mat src, dst, ocl_dst;
     int all_type[] = {CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4};
     std::string type_name[] = {"CV_8UC1", "CV_8UC4", "CV_32FC1", "CV_32FC4"};
 
@@ -311,9 +309,6 @@ PERFTEST(GaussianBlur)
             ocl::GaussianBlur(d_src, d_dst, Size(9, 9), 0);
             WARMUP_OFF;
 
-            TestSystem::instance().setAccurate(ExpectedMatNear(cv::Mat(d_dst), dst, 1.0));
-
-
             GPU_ON;
             ocl::GaussianBlur(d_src, d_dst, Size(9, 9), 0);
             GPU_OFF;
@@ -321,8 +316,10 @@ PERFTEST(GaussianBlur)
             GPU_FULL_ON;
             d_src.upload(src);
             ocl::GaussianBlur(d_src, d_dst, Size(9, 9), 0);
-            d_dst.download(dst);
+            d_dst.download(ocl_dst);
             GPU_FULL_OFF;
+
+            TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1.0);
         }
 
     }
@@ -349,7 +346,7 @@ PERFTEST(filter2D)
                 Mat kernel;
                 gen(kernel, ksize, ksize, CV_32FC1, 0.0, 1.0);
 
-				Mat dst(src);
+				Mat dst, ocl_dst;
 				dst.setTo(0);
                 cv::filter2D(src, dst, -1, kernel);
 
@@ -357,17 +354,12 @@ PERFTEST(filter2D)
                 cv::filter2D(src, dst, -1, kernel);
                 CPU_OFF;
 
-                ocl::oclMat d_src(src);
-                ocl::oclMat d_dst(d_src);
-				d_dst.setTo(0);
+                ocl::oclMat d_src(src), d_dst;
 
                 WARMUP_ON;
                 ocl::filter2D(d_src, d_dst, -1, kernel);
                 WARMUP_OFF;
 
-                TestSystem::instance().setAccurate(ExpectedMatNear(cv::Mat(d_dst), dst, 1e-5));
-
-
                 GPU_ON;
                 ocl::filter2D(d_src, d_dst, -1, kernel);
                 GPU_OFF;
@@ -375,8 +367,10 @@ PERFTEST(filter2D)
                 GPU_FULL_ON;
                 d_src.upload(src);
                 ocl::filter2D(d_src, d_dst, -1, kernel);
-                d_dst.download(dst);
+                d_dst.download(ocl_dst);
                 GPU_FULL_OFF;
+
+                TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5);
             }
 
         }

modules/ocl/perf/perf_gemm.cpp

@@ -48,7 +48,7 @@
 ///////////// gemm ////////////////////////
 PERFTEST(gemm)
 {
-    Mat src1, src2, src3, dst;
+    Mat src1, src2, src3, dst, ocl_dst;
     ocl::oclMat d_src1, d_src2, d_src3, d_dst;
 
     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
@@ -72,7 +72,6 @@ PERFTEST(gemm)
         WARMUP_ON;
         ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
         WARMUP_OFF;
-        TestSystem::instance().setAccurate(ExpectedMatNear(cv::Mat(d_dst), dst, src1.cols * src1.rows * 1e-4));
 
         GPU_ON;
         ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
@@ -83,7 +82,9 @@ PERFTEST(gemm)
         d_src2.upload(src2);
         d_src3.upload(src3);
         ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
-        d_dst.download(dst);
+        d_dst.download(ocl_dst);
         GPU_FULL_OFF;
+
+        TestSystem::instance().ExpectedMatNear(ocl_dst, dst, src1.cols * src1.rows * 1e-4);
     }
 }
\ No newline at end of file

modules/ocl/perf/perf_haar.cpp

@@ -123,8 +123,10 @@ PERFTEST(Haar)
                                  1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
     WARMUP_OFF;
 
-    //Testing whether the expected is equal to the actual.
-    TestSystem::instance().setAccurate(ExpectedEQ<vector<Rect>::size_type, vector<Rect>::size_type>(faces.size(), oclfaces.size()));
+    if(faces.size() == oclfaces.size())
+        TestSystem::instance().setAccurate(1, 0);
+    else
+        TestSystem::instance().setAccurate(0, abs((int)faces.size() - (int)oclfaces.size()));
 
     faces.clear();
 

modules/ocl/perf/perf_hog.cpp

@@ -146,10 +146,8 @@ PERFTEST(HOG)
         }
     }
 
-    cv::Mat ocl_mat;
-    ocl_mat = cv::Mat(d_comp);
-    ocl_mat.convertTo(ocl_mat, cv::Mat(comp).type());
-    TestSystem::instance().setAccurate(ExpectedMatNear(ocl_mat, cv::Mat(comp), 3));
+    cv::Mat gpu_rst(d_comp), cpu_rst(comp);
+    TestSystem::instance().ExpectedMatNear(gpu_rst, cpu_rst, 3);
 
     GPU_ON;
     ocl_hog.detectMultiScale(d_src, found_locations);

modules/ocl/perf/perf_match_template.cpp

@@ -56,11 +56,9 @@
 PERFTEST(matchTemplate)
 {
     //InitMatchTemplate();
-
-    Mat src, templ, dst;
+    Mat src, templ, dst, ocl_dst;
     int templ_size = 5;
 
-
     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
     {
         int all_type[] = {CV_32FC1, CV_32FC4};
@@ -82,16 +80,12 @@ PERFTEST(matchTemplate)
                 matchTemplate(src, templ, dst, CV_TM_CCORR);
                 CPU_OFF;
 
-                ocl::oclMat d_src(src), d_templ, d_dst;
-
-                d_templ.upload(templ);
+                ocl::oclMat d_src(src), d_templ(templ), d_dst;
 
                 WARMUP_ON;
                 ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR);
                 WARMUP_OFF;
 
-                TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), templ.rows * templ.cols * 1e-1));            
-
                 GPU_ON;
                 ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR);
                 GPU_OFF;
@@ -100,8 +94,10 @@ PERFTEST(matchTemplate)
                 d_src.upload(src);
                 d_templ.upload(templ);
                 ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR);
-                d_dst.download(dst);
+                d_dst.download(ocl_dst);
                 GPU_FULL_OFF;
+
+                TestSystem::instance().ExpectedMatNear(dst, ocl_dst, templ.rows * templ.cols * 1e-1);
             }
         }
 
@@ -131,8 +127,6 @@ PERFTEST(matchTemplate)
                 ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR_NORMED);
                 WARMUP_OFF;
 
-                TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), templ.rows * templ.cols * 1e-1));            
-
                 GPU_ON;
                 ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR_NORMED);
                 GPU_OFF;
@@ -141,8 +135,10 @@ PERFTEST(matchTemplate)
                 d_src.upload(src);
                 d_templ.upload(templ);
                 ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR_NORMED);
-                d_dst.download(dst);
+                d_dst.download(ocl_dst);
                 GPU_FULL_OFF;
+
+                TestSystem::instance().ExpectedMatNear(dst, ocl_dst, templ.rows * templ.cols * 1e-1);
             }
         }
     }

modules/ocl/perf/perf_matrix_operation.cpp

@@ -48,7 +48,7 @@
 ///////////// ConvertTo////////////////////////
 PERFTEST(ConvertTo)
 {
-    Mat src, dst;
+    Mat src, dst, ocl_dst;
     ocl::oclMat d_src, d_dst;
 
     int all_type[] = {CV_8UC1, CV_8UC4};
@@ -77,9 +77,6 @@ PERFTEST(ConvertTo)
             d_src.convertTo(d_dst, CV_32FC1);
             WARMUP_OFF;
 
-            TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), 0.0));            
-
-
             GPU_ON;
             d_src.convertTo(d_dst, CV_32FC1);
             GPU_OFF;
@@ -87,8 +84,10 @@ PERFTEST(ConvertTo)
             GPU_FULL_ON;
             d_src.upload(src);
             d_src.convertTo(d_dst, CV_32FC1);
-            d_dst.download(dst);
+            d_dst.download(ocl_dst);
             GPU_FULL_OFF;
+
+            TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0);
         }
 
     }
@@ -96,7 +95,7 @@ PERFTEST(ConvertTo)
 ///////////// copyTo////////////////////////
 PERFTEST(copyTo)
 {
-    Mat src, dst;
+    Mat src, dst, ocl_dst;
     ocl::oclMat d_src, d_dst;
 
     int all_type[] = {CV_8UC1, CV_8UC4};
@@ -125,9 +124,6 @@ PERFTEST(copyTo)
             d_src.copyTo(d_dst);
             WARMUP_OFF;
 
-            TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), 0.0));            
-
-
             GPU_ON;
             d_src.copyTo(d_dst);
             GPU_OFF;
@@ -135,8 +131,10 @@ PERFTEST(copyTo)
             GPU_FULL_ON;
             d_src.upload(src);
             d_src.copyTo(d_dst);
-            d_dst.download(dst);
+            d_dst.download(ocl_dst);
             GPU_FULL_OFF;
+
+            TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0);
         }
 
     }
@@ -144,9 +142,9 @@ PERFTEST(copyTo)
 ///////////// setTo////////////////////////
 PERFTEST(setTo)
 {
-    Mat src, dst;
+    Mat src, ocl_src;
     Scalar val(1, 2, 3, 4);
-    ocl::oclMat d_src, d_dst;
+    ocl::oclMat d_src;
 
     int all_type[] = {CV_8UC1, CV_8UC4};
     std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
@@ -171,10 +169,10 @@ PERFTEST(setTo)
             d_src.setTo(val);
             WARMUP_OFF;
 
-            TestSystem::instance().setAccurate(ExpectedMatNear(src, cv::Mat(d_src), 1.0));            
+            d_src.download(ocl_src);
+            TestSystem::instance().ExpectedMatNear(src, ocl_src, 1.0);
 
-
-            GPU_ON;
+            GPU_ON;;
             d_src.setTo(val);
             GPU_OFF;
 

modules/ocl/perf/perf_norm.cpp

@@ -48,39 +48,40 @@
 ///////////// norm////////////////////////
 PERFTEST(norm)
 {
-    Mat src, buf;
-    ocl::oclMat d_src, d_buf;
-
+    Mat src1, src2, ocl_src1;
+    ocl::oclMat d_src1, d_src2;
 
     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
     {
         SUBTEST << size << 'x' << size << "; CV_8UC1; NORM_INF";
 
-        gen(src, size, size, CV_8UC1, Scalar::all(0), Scalar::all(1));
-        gen(buf, size, size, CV_8UC1, Scalar::all(0), Scalar::all(1));
+        gen(src1, size, size, CV_8UC1, Scalar::all(0), Scalar::all(1));
+        gen(src2, size, size, CV_8UC1, Scalar::all(0), Scalar::all(1));
 
-        norm(src, NORM_INF);
+        norm(src1, src2, NORM_INF);
 
         CPU_ON;
-        norm(src, NORM_INF);
+        norm(src1, src2, NORM_INF);
         CPU_OFF;
 
-        d_src.upload(src);
-        d_buf.upload(buf);
+        d_src1.upload(src1);
+        d_src2.upload(src2);
 
         WARMUP_ON;
-        ocl::norm(d_src, d_buf, NORM_INF);
+        ocl::norm(d_src1, d_src2, NORM_INF);
         WARMUP_OFF;
 
-        TestSystem::instance().setAccurate(ExpectedMatNear(src, cv::Mat(d_buf), .5));                        
+        d_src1.download(ocl_src1);
+        TestSystem::instance().ExpectedMatNear(src1, ocl_src1, .5);                        
 
         GPU_ON;
-        ocl::norm(d_src, d_buf, NORM_INF);
+        ocl::norm(d_src1, d_src2, NORM_INF);
         GPU_OFF;
 
         GPU_FULL_ON;
-        d_src.upload(src);
-        ocl::norm(d_src, d_buf, NORM_INF);
+        d_src1.upload(src1);
+        d_src2.upload(src2);
+        ocl::norm(d_src1, d_src2, NORM_INF);
         GPU_FULL_OFF;
     }
 }
\ No newline at end of file

modules/ocl/perf/perf_pyrlk.cpp → modules/ocl/perf/perf_opticalflow.cpp

@@ -82,8 +82,8 @@ PERFTEST(PyrLKOpticalFlow)
                 SUBTEST << frame0.cols << "x" << frame0.rows << "; color; " << points << " points";
             else
                 SUBTEST << frame0.cols << "x" << frame0.rows << "; gray; " << points << " points";
-            Mat nextPts_cpu;
-            Mat status_cpu;
+            Mat ocl_nextPts;
+            Mat ocl_status;
 
             vector<Point2f> pts;
             goodFeaturesToTrack(i == 0 ? gray_frame : frame0, pts, points, 0.01, 0.0);
@@ -116,12 +116,6 @@ PERFTEST(PyrLKOpticalFlow)
             d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err);
             WARMUP_OFF;
 
-            std::vector<cv::Point2f> ocl_nextPts(d_nextPts.cols);
-            std::vector<unsigned char> ocl_status(d_status.cols);
-            TestSystem::instance().setAccurate(AssertEQ<size_t>(nextPts.size(), ocl_nextPts.size()));
-            TestSystem::instance().setAccurate(AssertEQ<size_t>(status.size(), ocl_status.size()));                        
-
-
             GPU_ON;
             d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err);
             GPU_OFF;
@@ -133,17 +127,102 @@ PERFTEST(PyrLKOpticalFlow)
             d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err);
 
             if (!d_nextPts.empty())
-            {
-                d_nextPts.download(nextPts_cpu);
-            }
+                d_nextPts.download(ocl_nextPts);
 
             if (!d_status.empty())
+                d_status.download(ocl_status);
+            GPU_FULL_OFF;
+
+            size_t mismatch = 0;
+            for (int i = 0; i < (int)nextPts.size(); ++i)
             {
-                d_status.download(status_cpu);
+                if(status[i] != ocl_status.at<unsigned char>(0, i)){
+                    mismatch++;
+                    continue;
+                }
+                if(status[i]){
+                    Point2f gpu_rst = ocl_nextPts.at<Point2f>(0, i);
+                    Point2f cpu_rst = nextPts[i];
+                    if(fabs(gpu_rst.x - cpu_rst.x) >= 1. || fabs(gpu_rst.y - cpu_rst.y) >= 1.)
+                        mismatch++;
+                }
             }
-
-            GPU_FULL_OFF;
+            double ratio = (double)mismatch / (double)nextPts.size();
+            if(ratio < .02)
+                TestSystem::instance().setAccurate(1, ratio);
+            else
+                TestSystem::instance().setAccurate(0, ratio);
         }
 
     }
 }
+
+
+PERFTEST(tvl1flow)
+{
+    cv::Mat frame0 = imread("rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+    assert(!frame0.empty());
+
+    cv::Mat frame1 = imread("rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+    assert(!frame1.empty());
+
+    cv::ocl::OpticalFlowDual_TVL1_OCL d_alg;
+    cv::ocl::oclMat d_flowx(frame0.size(), CV_32FC1);
+    cv::ocl::oclMat d_flowy(frame1.size(), CV_32FC1);
+
+    cv::Ptr<cv::DenseOpticalFlow> alg = cv::createOptFlow_DualTVL1();
+    cv::Mat flow;
+
+
+    SUBTEST << frame0.cols << 'x' << frame0.rows << "; rubberwhale1.png; "<<frame1.cols<<'x'<<frame1.rows<<"; rubberwhale2.png";
+
+    alg->calc(frame0, frame1, flow);
+
+    CPU_ON;
+    alg->calc(frame0, frame1, flow);
+    CPU_OFF;
+
+    cv::Mat gold[2];
+    cv::split(flow, gold);
+
+    cv::ocl::oclMat d0(frame0.size(), CV_32FC1);
+    d0.upload(frame0);
+    cv::ocl::oclMat d1(frame1.size(), CV_32FC1);
+    d1.upload(frame1);
+
+    WARMUP_ON;
+    d_alg(d0, d1, d_flowx, d_flowy);
+    WARMUP_OFF;
+/*
+    double diff1 = 0.0, diff2 = 0.0;
+    if(ExceptedMatSimilar(gold[0], cv::Mat(d_flowx), 3e-3, diff1) == 1
+        &&ExceptedMatSimilar(gold[1], cv::Mat(d_flowy), 3e-3, diff2) == 1)
+        TestSystem::instance().setAccurate(1);
+    else
+        TestSystem::instance().setAccurate(0);
+
+    TestSystem::instance().setDiff(diff1);
+    TestSystem::instance().setDiff(diff2);
+*/
+
+
+    GPU_ON;
+    d_alg(d0, d1, d_flowx, d_flowy);
+    d_alg.collectGarbage();
+    GPU_OFF;
+    
+
+    cv::Mat flowx, flowy;
+
+    GPU_FULL_ON;
+    d0.upload(frame0);
+    d1.upload(frame1);
+    d_alg(d0, d1, d_flowx, d_flowy);
+    d_alg.collectGarbage();
+    d_flowx.download(flowx);
+    d_flowy.download(flowy);
+    GPU_FULL_OFF;
+
+    TestSystem::instance().ExceptedMatSimilar(gold[0], flowx, 3e-3);
+    TestSystem::instance().ExceptedMatSimilar(gold[1], flowy, 3e-3);
+}
\ No newline at end of file

modules/ocl/perf/perf_pyrdown.cpp → modules/ocl/perf/perf_pyramid.cpp

@@ -48,7 +48,7 @@
 ///////////// pyrDown //////////////////////
 PERFTEST(pyrDown)
 {
-    Mat src, dst;
+    Mat src, dst, ocl_dst;
     int all_type[] = {CV_8UC1, CV_8UC4};
     std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
 
@@ -73,9 +73,6 @@ PERFTEST(pyrDown)
             ocl::pyrDown(d_src, d_dst);
             WARMUP_OFF;
 
-            TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), dst.depth() == CV_32F ? 1e-4f : 1.0f));                        
-
-
             GPU_ON;
             ocl::pyrDown(d_src, d_dst);
             GPU_OFF;
@@ -83,8 +80,53 @@ PERFTEST(pyrDown)
             GPU_FULL_ON;
             d_src.upload(src);
             ocl::pyrDown(d_src, d_dst);
-            d_dst.download(dst);
+            d_dst.download(ocl_dst);
+            GPU_FULL_OFF;
+
+            TestSystem::instance().ExpectedMatNear(dst, ocl_dst, dst.depth() == CV_32F ? 1e-4f : 1.0f);
+        }
+    }
+}
+
+///////////// pyrUp ////////////////////////
+PERFTEST(pyrUp)
+{
+    Mat src, dst, ocl_dst;
+    int all_type[] = {CV_8UC1, CV_8UC4};
+    std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
+
+    for (int size = 500; size <= 2000; size *= 2)
+    {
+        for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
+        {
+            SUBTEST << size << 'x' << size << "; " << type_name[j] ;
+
+            gen(src, size, size, all_type[j], 0, 256);
+
+            pyrUp(src, dst);
+
+            CPU_ON;
+            pyrUp(src, dst);
+            CPU_OFF;
+
+            ocl::oclMat d_src(src);
+            ocl::oclMat d_dst;
+
+            WARMUP_ON;
+            ocl::pyrUp(d_src, d_dst);
+            WARMUP_OFF;
+
+            GPU_ON;
+            ocl::pyrUp(d_src, d_dst);
+            GPU_OFF;
+
+            GPU_FULL_ON;
+            d_src.upload(src);
+            ocl::pyrUp(d_src, d_dst);
+            d_dst.download(ocl_dst);
             GPU_FULL_OFF;
+
+            TestSystem::instance().ExpectedMatNear(dst, ocl_dst, (src.depth() == CV_32F ? 1e-4f : 1.0));
         }
     }
 }
\ No newline at end of file

modules/ocl/perf/perf_pyrup.cpp

-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
-// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// @Authors
-//    Fangfang Bai, fangfang@multicorewareinc.com
-//    Jin Ma,       jin@multicorewareinc.com
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other oclMaterials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors as is and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-#include "precomp.hpp"
-
-///////////// pyrUp ////////////////////////
-PERFTEST(pyrUp)
-{
-    Mat src, dst;
-    int all_type[] = {CV_8UC1, CV_8UC4};
-    std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
-
-    for (int size = 500; size <= 2000; size *= 2)
-    {
-        for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
-        {
-            SUBTEST << size << 'x' << size << "; " << type_name[j] ;
-
-            gen(src, size, size, all_type[j], 0, 256);
-
-            pyrUp(src, dst);
-
-            CPU_ON;
-            pyrUp(src, dst);
-            CPU_OFF;
-
-            ocl::oclMat d_src(src);
-            ocl::oclMat d_dst;
-
-            WARMUP_ON;
-            ocl::pyrUp(d_src, d_dst);
-            WARMUP_OFF;
-
-            TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), (src.depth() == CV_32F ? 1e-4f : 1.0)));                     
-
-            GPU_ON;
-            ocl::pyrUp(d_src, d_dst);
-            GPU_OFF;
-
-            GPU_FULL_ON;
-            d_src.upload(src);
-            ocl::pyrUp(d_src, d_dst);
-            d_dst.download(dst);
-            GPU_FULL_OFF;
-        }
-    }
-}
\ No newline at end of file

modules/ocl/perf/perf_split_merge.cpp

@@ -48,7 +48,7 @@
 ///////////// Merge////////////////////////
 PERFTEST(Merge)
 {
-    Mat dst;
+    Mat dst, ocl_dst;
     ocl::oclMat d_dst;
 
     int channels = 4;
@@ -85,22 +85,20 @@ PERFTEST(Merge)
             ocl::merge(d_src, d_dst);
             WARMUP_OFF;
 
-            TestSystem::instance().setAccurate(ExpectedMatNear(cv::Mat(dst), cv::Mat(d_dst), 0.0));                     
-
             GPU_ON;
             ocl::merge(d_src, d_dst);
             GPU_OFF;
 
             GPU_FULL_ON;
-
             for (int i = 0; i < channels; ++i)
             {
-                d_src[i] = ocl::oclMat(size1, CV_8U, cv::Scalar::all(i));
+                d_src[i] = ocl::oclMat(size1, all_type[j], cv::Scalar::all(i));
             }
-
             ocl::merge(d_src, d_dst);
-            d_dst.download(dst);
+            d_dst.download(ocl_dst);
             GPU_FULL_OFF;
+
+            TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0);
         }
 
     }
@@ -122,7 +120,7 @@ PERFTEST(Split)
 
             Mat src(size1, CV_MAKE_TYPE(all_type[j], 4), cv::Scalar(1, 2, 3, 4));
 
-            std::vector<cv::Mat> dst;
+            std::vector<cv::Mat> dst, ocl_dst(4);
 
             split(src, dst);
 
@@ -135,22 +133,7 @@ PERFTEST(Split)
 
             WARMUP_ON;
             ocl::split(d_src, d_dst);
-            WARMUP_OFF;
-
-            if(d_dst.size() == dst.size())
-            {
-                TestSystem::instance().setAccurate(1);
-                for(size_t i = 0; i < dst.size(); i++)
-                {
-                    if(ExpectedMatNear(dst[i], cv::Mat(d_dst[i]), 0.0) == 0)
-                    {
-                        TestSystem::instance().setAccurate(0);
-                        break;
-                    }
-                }
-            }else
-                TestSystem::instance().setAccurate(0);
-                                
+            WARMUP_OFF;         
 
             GPU_ON;
             ocl::split(d_src, d_dst);
@@ -159,7 +142,12 @@ PERFTEST(Split)
             GPU_FULL_ON;
             d_src.upload(src);
             ocl::split(d_src, d_dst);
+            for(size_t i = 0; i < dst.size(); i++)
+                d_dst[i].download(ocl_dst[i]);
             GPU_FULL_OFF;
+
+            vector<double> eps(4, 0.);
+            TestSystem::instance().ExpectMatsNear(dst, ocl_dst, eps);
         }
 
     }

modules/ocl/perf/precomp.cpp

@@ -114,7 +114,6 @@ void TestSystem::finishCurrentSubtest()
         return;
     }
 
-    int is_accurate = is_accurate_;
     double cpu_time = cpu_elapsed_ / getTickFrequency() * 1000.0;
     double gpu_time = gpu_elapsed_ / getTickFrequency() * 1000.0;
     double gpu_full_time = gpu_full_elapsed_ / getTickFrequency() * 1000.0;
@@ -171,8 +170,8 @@ void TestSystem::finishCurrentSubtest()
         deviation = std::sqrt(sum / gpu_times_.size());
     }
 
-    printMetrics(is_accurate, cpu_time, gpu_time, gpu_full_time, speedup, fullspeedup);
-    writeMetrics(is_accurate, cpu_time, gpu_time, gpu_full_time, speedup, fullspeedup, gpu_min, gpu_max, deviation);
+    printMetrics(is_accurate_, cpu_time, gpu_time, gpu_full_time, speedup, fullspeedup);
+    writeMetrics(cpu_time, gpu_time, gpu_full_time, speedup, fullspeedup, gpu_min, gpu_max, deviation);
 
     num_subtests_called_++;
     resetCurrentSubtest();
@@ -219,7 +218,7 @@ void TestSystem::writeHeading()
         }
     }
 
-    fprintf(record_, "NAME,DESCRIPTION,ACCURACY,CPU (ms),GPU (ms),SPEEDUP,GPUTOTAL (ms),TOTALSPEEDUP,GPU Min (ms),GPU Max (ms), Standard deviation (ms)\n");
+    fprintf(record_, "NAME,DESCRIPTION,ACCURACY,DIFFERENCE,CPU (ms),GPU (ms),SPEEDUP,GPUTOTAL (ms),TOTALSPEEDUP,GPU Min (ms),GPU Max (ms), Standard deviation (ms)\n");
 
     fflush(record_);
 }
@@ -392,7 +391,7 @@ void TestSystem::printMetrics(int is_accurate, double cpu_time, double gpu_time,
 #endif
 }
 
-void TestSystem::writeMetrics(int is_accurate, double cpu_time, double gpu_time, double gpu_full_time, double speedup, double fullspeedup, double gpu_min, double gpu_max, double std_dev)
+void TestSystem::writeMetrics(double cpu_time, double gpu_time, double gpu_full_time, double speedup, double fullspeedup, double gpu_min, double gpu_max, double std_dev)
 {
     if (!record_)
     {
@@ -402,21 +401,24 @@ void TestSystem::writeMetrics(int is_accurate, double cpu_time, double gpu_time,
 
     string _is_accurate_;
 
-    if(is_accurate == 1)
+    if(is_accurate_ == 1)
         _is_accurate_ = "Pass";
-    else if(is_accurate == 0)
+    else if(is_accurate_ == 0)
         _is_accurate_ = "Fail";
-    else if(is_accurate == -1)
+    else if(is_accurate_ == -1)
         _is_accurate_ = " ";
     else
     {
-        std::cout<<"is_accurate errer: "<<is_accurate<<"\n";
+        std::cout<<"is_accurate errer: "<<is_accurate_<<"\n";
         exit(-1);
     }
 
-    fprintf(record_, "%s,%s,%s,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f\n", itname_changed_ ? itname_.c_str() : "",
+    fprintf(record_, "%s,%s,%s,%.2f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f\n", 
+        itname_changed_ ? itname_.c_str() : "",
         cur_subtest_description_.str().c_str(),
-        _is_accurate_.c_str(), cpu_time, gpu_time, speedup, gpu_full_time, fullspeedup,
+        _is_accurate_.c_str(), 
+        accurate_diff_,
+        cpu_time, gpu_time, speedup, gpu_full_time, fullspeedup,
         gpu_min, gpu_max, std_dev);
 
     if (itname_changed_)
@@ -469,134 +471,6 @@ void gen(Mat &mat, int rows, int cols, int type, Scalar low, Scalar high)
     RNG rng(0);
     rng.fill(mat, RNG::UNIFORM, low, high);
 }
-#if 0
-void gen(Mat &mat, int rows, int cols, int type, int low, int high, int n)
-{
-    assert(n > 0&&n <= cols * rows);
-    assert(type == CV_8UC1||type == CV_8UC3||type == CV_8UC4
-        ||type == CV_32FC1||type == CV_32FC3||type == CV_32FC4);
-
-    RNG rng;
-    //generate random position without duplication
-    std::vector<int> pos;
-    for(int i = 0; i < cols * rows; i++)
-    {
-        pos.push_back(i);
-    }
-
-    for(int i = 0; i < cols * rows; i++)
-    {
-        int temp = i + rng.uniform(0, cols * rows - 1 - i);
-        int temp1 = pos[temp];
-        pos[temp]= pos[i];
-        pos[i] = temp1;
-    }
-
-    std::vector<int> selected_pos;
-    for(int i = 0; i < n; i++)
-    {
-        selected_pos.push_back(pos[i]);
-    }
-
-    pos.clear();
-    //end of generating random y without duplication
-
-    if(type == CV_8UC1)
-    {
-        typedef struct coorStruct_
-        {
-            int x;
-            int y;
-            uchar xy;
-        }coorStruct;
-
-        coorStruct coor_struct;
-
-        std::vector<coorStruct> coor;
-
-        for(int i = 0; i < n; i++)
-        {
-            coor_struct.x = -1;
-            coor_struct.y = -1;
-            coor_struct.xy = (uchar)rng.uniform(low, high);
-            coor.push_back(coor_struct);
-        }
-
-        for(int i = 0; i < n; i++)
-        {
-            coor[i].y = selected_pos[i]/cols;
-            coor[i].x = selected_pos[i]%cols;
-        }
-        selected_pos.clear();
-
-        mat.create(rows, cols, type);
-        mat.setTo(0);
-
-        for(int i = 0; i < n; i++)
-        {
-            mat.at<unsigned char>(coor[i].y, coor[i].x) = coor[i].xy;
-        }
-    }
-
-    if(type == CV_8UC4 || type == CV_8UC3)
-    {
-        mat.create(rows, cols, type);
-        mat.setTo(0);
-
-        typedef struct Coor
-        {
-            int x;
-            int y;
-
-            uchar r;
-            uchar g;
-            uchar b;
-            uchar alpha;
-        }coor;
-
-        std::vector<coor> coor_vect;
-
-        coor xy_coor;
-
-        for(int i = 0; i < n; i++)
-        {
-            xy_coor.r = (uchar)rng.uniform(low, high);
-            xy_coor.g = (uchar)rng.uniform(low, high);
-            xy_coor.b = (uchar)rng.uniform(low, high);
-            if(type == CV_8UC4)
-                xy_coor.alpha = (uchar)rng.uniform(low, high);
-
-            coor_vect.push_back(xy_coor);
-        }
-
-        for(int i = 0; i < n; i++)
-        {
-            coor_vect[i].y = selected_pos[i]/((int)mat.step1()/mat.elemSize());
-            coor_vect[i].x = selected_pos[i]%((int)mat.step1()/mat.elemSize());
-            //printf("coor_vect[%d] = (%d, %d)\n", i, coor_vect[i].y, coor_vect[i].x);
-        }
-
-        if(type == CV_8UC4)
-        {
-            for(int i = 0; i < n; i++)
-            {
-                mat.at<unsigned char>(coor_vect[i].y, 4 * coor_vect[i].x) = coor_vect[i].r;
-                mat.at<unsigned char>(coor_vect[i].y, 4 * coor_vect[i].x + 1) = coor_vect[i].g;
-                mat.at<unsigned char>(coor_vect[i].y, 4 * coor_vect[i].x + 2) = coor_vect[i].b;
-                mat.at<unsigned char>(coor_vect[i].y, 4 * coor_vect[i].x + 3) = coor_vect[i].alpha;
-            }
-        }else if(type == CV_8UC3)
-        {
-            for(int i = 0; i < n; i++)
-            {
-                mat.at<unsigned char>(coor_vect[i].y, 3 * coor_vect[i].x) = coor_vect[i].r;
-                mat.at<unsigned char>(coor_vect[i].y, 3 * coor_vect[i].x + 1) = coor_vect[i].g;
-                mat.at<unsigned char>(coor_vect[i].y, 3 * coor_vect[i].x + 2) = coor_vect[i].b;
-            }
-        }
-    }
-}
-#endif
 
 string abspath(const string &relpath)
 {
@@ -630,32 +504,5 @@ double checkSimilarity(const Mat &m1, const Mat &m2)
 }
 
 
-int ExpectedMatNear(cv::Mat dst, cv::Mat cpu_dst, double eps)
-{
-    assert(dst.type() == cpu_dst.type());
-    assert(dst.size() == cpu_dst.size());
-    if(checkNorm(cv::Mat(dst), cv::Mat(cpu_dst)) < eps ||checkNorm(cv::Mat(dst), cv::Mat(cpu_dst)) == eps)
-        return 1;
-    return 0;
-}
-
-int ExceptDoubleNear(double val1, double val2, double abs_error)
-{
-    const double diff = fabs(val1 - val2);
-    if (diff <= abs_error)
-        return 1;
-
-    return 0;
-}
-
-int ExceptedMatSimilar(cv::Mat dst, cv::Mat cpu_dst, double eps)
-{
-    assert(dst.type() == cpu_dst.type());
-    assert(dst.size() == cpu_dst.size()); 
-    if(checkSimilarity(cv::Mat(cpu_dst), cv::Mat(dst)) <= eps)
-        return 1;
-    return 0;
-}
-
 
 

modules/ocl/perf/precomp.hpp

@@ -313,9 +313,46 @@ public:
         itname_changed_ = true;
     }
 
-    void setAccurate(int is_accurate = -1)
+    void setAccurate(int accurate, double diff)
     {
-        is_accurate_ = is_accurate;
+        is_accurate_ = accurate;
+        accurate_diff_ = diff;
+    }
+
+    void ExpectMatsNear(vector<Mat>& dst, vector<Mat>& cpu_dst, vector<double>& eps)
+    {
+        assert(dst.size() == cpu_dst.size());
+        assert(cpu_dst.size() == eps.size());
+        is_accurate_ = 1;
+        for(size_t i=0; i<dst.size(); i++)
+        {
+            double cur_diff = checkNorm(dst[i], cpu_dst[i]);
+            accurate_diff_ = max(accurate_diff_, cur_diff);
+            if(cur_diff > eps[i])
+                is_accurate_ = 0;
+        }
+    }
+
+    void ExpectedMatNear(cv::Mat& dst, cv::Mat& cpu_dst, double eps)
+    {
+        assert(dst.type() == cpu_dst.type());
+        assert(dst.size() == cpu_dst.size());
+        accurate_diff_ = checkNorm(dst, cpu_dst);
+        if(accurate_diff_ <= eps)
+            is_accurate_ = 1;
+        else
+            is_accurate_ = 0;
+    }
+
+    void ExceptedMatSimilar(cv::Mat& dst, cv::Mat& cpu_dst, double eps)
+    {
+        assert(dst.type() == cpu_dst.type());
+        assert(dst.size() == cpu_dst.size());
+        accurate_diff_ = checkSimilarity(cpu_dst, dst);
+        if(accurate_diff_ <= eps)
+            is_accurate_ = 1;
+        else
+            is_accurate_ = 0;    
     }
 
     std::stringstream &getCurSubtestDescription()
@@ -333,7 +370,7 @@ private:
         num_iters_(10), cpu_num_iters_(2),
         gpu_warmup_iters_(1), cur_iter_idx_(0), cur_warmup_idx_(0),
         record_(0), recordname_("performance"), itname_changed_(true), 
-        is_accurate_(-1)
+        is_accurate_(-1), accurate_diff_(0.)
     {
         cpu_times_.reserve(num_iters_);
         gpu_times_.reserve(num_iters_);
@@ -354,6 +391,7 @@ private:
         gpu_times_.clear();
         gpu_full_times_.clear();
         is_accurate_ = -1;
+        accurate_diff_ = 0.;
     }
 
     double meanTime(const std::vector<int64> &samples);
@@ -364,7 +402,7 @@ private:
 
     void writeHeading();
     void writeSummary();
-    void writeMetrics(int is_accurate, double cpu_time, double gpu_time = 0.0f, double gpu_full_time = 0.0f,
+    void writeMetrics(double cpu_time, double gpu_time = 0.0f, double gpu_full_time = 0.0f,
                       double speedup = 0.0f, double fullspeedup = 0.0f,
                       double gpu_min = 0.0f, double gpu_max = 0.0f, double std_dev = 0.0f);
 
@@ -416,6 +454,7 @@ private:
     bool itname_changed_;
 
     int is_accurate_;
+    double accurate_diff_;
 };