merged gpu_perf_cpu into gpu_perf

modules/gpu/perf/perf_features2d.cpp

@@ -12,21 +12,39 @@ DEF_PARAM_TEST_1(Image, string);
 
 PERF_TEST_P(Image, Features2D_SURF, Values<string>("gpu/perf/aloe.jpg"))
 {
-    declare.time(2.0);
+    declare.time(50.0);
 
     cv::Mat img = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(img.empty());
 
-    cv::gpu::SURF_GPU d_surf;
+    if (runOnGpu)
+    {
+        cv::gpu::SURF_GPU d_surf;
 
-    cv::gpu::GpuMat d_img(img);
-    cv::gpu::GpuMat d_keypoints, d_descriptors;
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_keypoints, d_descriptors;
 
-    d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
+        d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
+        }
+    }
+    else
     {
-        d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
+        cv::SURF surf;
+
+        std::vector<cv::KeyPoint> keypoints;
+        cv::Mat descriptors;
+
+        surf(img, cv::noArray(), keypoints, descriptors);
+
+        TEST_CYCLE()
+        {
+            keypoints.clear();
+            surf(img, cv::noArray(), keypoints, descriptors);
+        }
     }
 }
 
@@ -38,16 +56,31 @@ PERF_TEST_P(Image, Features2D_FAST, Values<string>("gpu/perf/aloe.jpg"))
     cv::Mat img = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(img.empty());
 
-    cv::gpu::FAST_GPU d_fast(20);
+    if (runOnGpu)
+    {
+        cv::gpu::FAST_GPU d_fast(20);
 
-    cv::gpu::GpuMat d_img(img);
-    cv::gpu::GpuMat d_keypoints;
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_keypoints;
 
-    d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
+        d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
+        }
+    }
+    else
     {
-        d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
+        std::vector<cv::KeyPoint> keypoints;
+
+        cv::FAST(img, keypoints, 20);
+
+        TEST_CYCLE()
+        {
+            keypoints.clear();
+            cv::FAST(img, keypoints, 20);
+        }
     }
 }
 
@@ -59,16 +92,34 @@ PERF_TEST_P(Image, Features2D_ORB, Values<string>("gpu/perf/aloe.jpg"))
     cv::Mat img = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(img.empty());
 
-    cv::gpu::ORB_GPU d_orb(4000);
+    if (runOnGpu)
+    {
+        cv::gpu::ORB_GPU d_orb(4000);
 
-    cv::gpu::GpuMat d_img(img);
-    cv::gpu::GpuMat d_keypoints, d_descriptors;
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_keypoints, d_descriptors;
 
-    d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
+        d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
+        }
+    }
+    else
     {
-        d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
+        cv::ORB orb(4000);
+
+        std::vector<cv::KeyPoint> keypoints;
+        cv::Mat descriptors;
+
+        orb(img, cv::noArray(), keypoints, descriptors);
+
+        TEST_CYCLE()
+        {
+            keypoints.clear();
+            orb(img, cv::noArray(), keypoints, descriptors);
+        }
     }
 }
 
@@ -79,7 +130,7 @@ DEF_PARAM_TEST(DescSize_Norm, int, NormType);
 
 PERF_TEST_P(DescSize_Norm, Features2D_BFMatch, Combine(Values(64, 128, 256), Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))))
 {
-    declare.time(3.0);
+    declare.time(20.0);
 
     int desc_size = GET_PARAM(0);
     int normType = GET_PARAM(1);
@@ -92,17 +143,33 @@ PERF_TEST_P(DescSize_Norm, Features2D_BFMatch, Combine(Values(64, 128, 256), Val
     cv::Mat train(3000, desc_size, type);
     fillRandom(train);
 
-    cv::gpu::BFMatcher_GPU d_matcher(normType);
+    if (runOnGpu)
+    {
+        cv::gpu::BFMatcher_GPU d_matcher(normType);
 
-    cv::gpu::GpuMat d_query(query);
-    cv::gpu::GpuMat d_train(train);
-    cv::gpu::GpuMat d_trainIdx, d_distance;
+        cv::gpu::GpuMat d_query(query);
+        cv::gpu::GpuMat d_train(train);
+        cv::gpu::GpuMat d_trainIdx, d_distance;
 
-    d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
+        d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
+        }
+    }
+    else
     {
-        d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
+        cv::BFMatcher matcher(normType);
+
+        std::vector<cv::DMatch> matches;
+
+        matcher.match(query, train, matches);
+
+        TEST_CYCLE()
+        {
+            matcher.match(query, train, matches);
+        }
     }
 }
 
@@ -116,7 +183,7 @@ PERF_TEST_P(DescSize_K_Norm, Features2D_BFKnnMatch, Combine(
     Values(2, 3),
     Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))))
 {
-    declare.time(3.0);
+    declare.time(30.0);
 
     int desc_size = GET_PARAM(0);
     int k = GET_PARAM(1);
@@ -130,17 +197,33 @@ PERF_TEST_P(DescSize_K_Norm, Features2D_BFKnnMatch, Combine(
     cv::Mat train(3000, desc_size, type);
     fillRandom(train);
 
-    cv::gpu::BFMatcher_GPU d_matcher(normType);
+    if (runOnGpu)
+    {
+        cv::gpu::BFMatcher_GPU d_matcher(normType);
 
-    cv::gpu::GpuMat d_query(query);
-    cv::gpu::GpuMat d_train(train);
-    cv::gpu::GpuMat d_trainIdx, d_distance, d_allDist;
+        cv::gpu::GpuMat d_query(query);
+        cv::gpu::GpuMat d_train(train);
+        cv::gpu::GpuMat d_trainIdx, d_distance, d_allDist;
 
-    d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
+        d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
+        }
+    }
+    else
     {
-        d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
+        cv::BFMatcher matcher(normType);
+
+        std::vector< std::vector<cv::DMatch> > matches;
+
+        matcher.knnMatch(query, train, matches, k);
+
+        TEST_CYCLE()
+        {
+            matcher.knnMatch(query, train, matches, k);
+        }
     }
 }
 
@@ -149,7 +232,7 @@ PERF_TEST_P(DescSize_K_Norm, Features2D_BFKnnMatch, Combine(
 
 PERF_TEST_P(DescSize_Norm, Features2D_BFRadiusMatch, Combine(Values(64, 128, 256), Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))))
 {
-    declare.time(3.0);
+    declare.time(30.0);
 
     int desc_size = GET_PARAM(0);
     int normType = GET_PARAM(1);
@@ -162,17 +245,33 @@ PERF_TEST_P(DescSize_Norm, Features2D_BFRadiusMatch, Combine(Values(64, 128, 256
     cv::Mat train(3000, desc_size, type);
     fillRandom(train, 0.0, 1.0);
 
-    cv::gpu::BFMatcher_GPU d_matcher(normType);
+    if (runOnGpu)
+    {
+        cv::gpu::BFMatcher_GPU d_matcher(normType);
 
-    cv::gpu::GpuMat d_query(query);
-    cv::gpu::GpuMat d_train(train);
-    cv::gpu::GpuMat d_trainIdx, d_nMatches, d_distance;
+        cv::gpu::GpuMat d_query(query);
+        cv::gpu::GpuMat d_train(train);
+        cv::gpu::GpuMat d_trainIdx, d_nMatches, d_distance;
 
-    d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
+        d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
+        }
+    }
+    else
     {
-        d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
+        cv::BFMatcher matcher(normType);
+
+        std::vector< std::vector<cv::DMatch> > matches;
+
+        matcher.radiusMatch(query, train, matches, 2.0);
+
+        TEST_CYCLE()
+        {
+            matcher.radiusMatch(query, train, matches, 2.0);
+        }
     }
 }
 

modules/gpu/perf/perf_labeling.cpp

@@ -7,27 +7,129 @@ namespace {
 
 DEF_PARAM_TEST_1(Image, string);
 
-PERF_TEST_P(Image, Labeling_ConnectedComponents, Values<string>("gpu/labeling/aloe-disp.png"))
+struct GreedyLabeling
 {
-    cv::Mat image = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
+    struct dot
+    {
+        int x;
+        int y;
+
+        static dot make(int i, int j)
+        {
+            dot d; d.x = i; d.y = j;
+            return d;
+        }
+    };
+
+    struct InInterval
+    {
+        InInterval(const int& _lo, const int& _hi) : lo(-_lo), hi(_hi) {};
+        const int lo, hi;
+
+        bool operator() (const unsigned char a, const unsigned char b) const
+        {
+            int d = a - b;
+            return lo <= d && d <= hi;
+        }
+    };
+
+    GreedyLabeling(cv::Mat img)
+    : image(img), _labels(image.size(), CV_32SC1, cv::Scalar::all(-1)) {stack = new dot[image.cols * image.rows];}
+
+    ~GreedyLabeling(){delete[] stack;}
+
+    void operator() (cv::Mat labels) const
+    {
+        labels.setTo(cv::Scalar::all(-1));
+        InInterval inInt(0, 2);
+        int cc = -1;
+
+        int* dist_labels = (int*)labels.data;
+        int pitch = labels.step1();
+
+        unsigned char* source = (unsigned char*)image.data;
+        int width = image.cols;
+        int height = image.rows;
+
+        for (int j = 0; j < image.rows; ++j)
+            for (int i = 0; i < image.cols; ++i)
+            {
+                if (dist_labels[j * pitch + i] != -1) continue;
+
+                dot* top = stack;
+                dot p = dot::make(i, j);
+                cc++;
+
+                dist_labels[j * pitch + i] = cc;
+
+                while (top >= stack)
+                {
+                    int*  dl = &dist_labels[p.y * pitch + p.x];
+                    unsigned char* sp = &source[p.y * image.step1() + p.x];
 
-    // cv::threshold(image, image, 150, 255, CV_THRESH_BINARY);
+                    dl[0] = cc;
 
-    cv::gpu::GpuMat mask;
-    mask.create(image.rows, image.cols, CV_8UC1);
+                    //right
+                    if( p.x < (width - 1) && dl[ +1] == -1 && inInt(sp[0], sp[+1]))
+                        *top++ = dot::make(p.x + 1, p.y);
 
-    cv::gpu::GpuMat components;
-    components.create(image.rows, image.cols, CV_32SC1);
+                    //left
+                    if( p.x > 0 && dl[-1] == -1 && inInt(sp[0], sp[-1]))
+                        *top++ = dot::make(p.x - 1, p.y);
 
-    cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2));
+                    //bottom
+                    if( p.y < (height - 1) && dl[+pitch] == -1 && inInt(sp[0], sp[+image.step1()]))
+                        *top++ = dot::make(p.x, p.y + 1);
 
-    ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components));
+                    //top
+                    if( p.y > 0 && dl[-pitch] == -1 && inInt(sp[0], sp[-image.step1()]))
+                        *top++ = dot::make(p.x, p.y - 1);
 
+                    p = *--top;
+                }
+            }
+    }
+
+    cv::Mat image;
+    cv::Mat _labels;
+    dot* stack;
+};
+
+PERF_TEST_P(Image, Labeling_ConnectedComponents, Values<string>("gpu/labeling/aloe-disp.png"))
+{
     declare.time(1.0);
 
-    TEST_CYCLE()
+    cv::Mat image = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
+
+    if (runOnGpu)
+    {
+        cv::gpu::GpuMat mask;
+        mask.create(image.rows, image.cols, CV_8UC1);
+
+        cv::gpu::GpuMat components;
+        components.create(image.rows, image.cols, CV_32SC1);
+
+        cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2));
+
+        ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components));
+
+        TEST_CYCLE()
+        {
+            cv::gpu::labelComponents(mask, components);
+        }
+    }
+    else
     {
-        cv::gpu::labelComponents(mask, components);
+        GreedyLabeling host(image);
+
+        host(host._labels);
+
+        declare.time(1.0);
+
+        TEST_CYCLE()
+        {
+            host(host._labels);
+        }
     }
 }
 

modules/gpu/perf/perf_matop.cpp

@@ -18,13 +18,27 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetTo, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
 
     cv::Scalar val(1, 2, 3, 4);
 
-    cv::gpu::GpuMat d_src(size, type);
+    if (runOnGpu)
+    {
+        cv::gpu::GpuMat d_src(size, type);
 
-    d_src.setTo(val);
+        d_src.setTo(val);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_src.setTo(val);
+        }
+    }
+    else
     {
-        d_src.setTo(val);
+        cv::Mat src(size, type);
+
+        src.setTo(val);
+
+        TEST_CYCLE()
+        {
+            src.setTo(val);
+        }
     }
 }
 
@@ -47,14 +61,26 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetToMasked, Combine(GPU_TYPICAL_MAT_SIZES, Value
 
     cv::Scalar val(1, 2, 3, 4);
 
-    cv::gpu::GpuMat d_src(src);
-    cv::gpu::GpuMat d_mask(mask);
+    if (runOnGpu)
+    {
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_mask(mask);
 
-    d_src.setTo(val, d_mask);
+        d_src.setTo(val, d_mask);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_src.setTo(val, d_mask);
+        }
+    }
+    else
     {
-        d_src.setTo(val, d_mask);
+        src.setTo(val, mask);
+
+        TEST_CYCLE()
+        {
+            src.setTo(val, mask);
+        }
     }
 }
 
@@ -75,15 +101,29 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_CopyToMasked, Combine(GPU_TYPICAL_MAT_SIZES, Valu
     cv::Mat mask(size, CV_8UC1);
     fillRandom(mask, 0, 2);
 
-    cv::gpu::GpuMat d_src(src);
-    cv::gpu::GpuMat d_mask(mask);
-    cv::gpu::GpuMat d_dst;
+    if (runOnGpu)
+    {
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_mask(mask);
+        cv::gpu::GpuMat d_dst;
 
-    d_src.copyTo(d_dst, d_mask);
+        d_src.copyTo(d_dst, d_mask);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_src.copyTo(d_dst, d_mask);
+        }
+    }
+    else
     {
-        d_src.copyTo(d_dst, d_mask);
+        cv::Mat dst;
+
+        src.copyTo(dst, mask);
+
+        TEST_CYCLE()
+        {
+            src.copyTo(dst, mask);
+        }
     }
 }
 
@@ -101,14 +141,28 @@ PERF_TEST_P(Sz_2Depth, MatOp_ConvertTo, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV
     cv::Mat src(size, depth1);
     fillRandom(src);
 
-    cv::gpu::GpuMat d_src(src);
-    cv::gpu::GpuMat d_dst;
+    if (runOnGpu)
+    {
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-    d_src.convertTo(d_dst, depth2, 0.5, 1.0);
+        d_src.convertTo(d_dst, depth2, 0.5, 1.0);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_src.convertTo(d_dst, depth2, 0.5, 1.0);
+        }
+    }
+    else
     {
-        d_src.convertTo(d_dst, depth2, 0.5, 1.0);
+        cv::Mat dst;
+
+        src.convertTo(dst, depth2, 0.5, 1.0);
+
+        TEST_CYCLE()
+        {
+            src.convertTo(dst, depth2, 0.5, 1.0);
+        }
     }
 }
 

modules/gpu/perf/perf_objdetect.cpp

@@ -17,16 +17,31 @@ PERF_TEST_P(Image, ObjDetect_HOG, Values<string>("gpu/hog/road.png"))
 
     std::vector<cv::Rect> found_locations;
 
-    cv::gpu::GpuMat d_img(img);
+    if (runOnGpu)
+    {
+        cv::gpu::GpuMat d_img(img);
 
-    cv::gpu::HOGDescriptor d_hog;
-    d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
+        cv::gpu::HOGDescriptor d_hog;
+        d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
 
-    d_hog.detectMultiScale(d_img, found_locations);
+        d_hog.detectMultiScale(d_img, found_locations);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_hog.detectMultiScale(d_img, found_locations);
+        }
+    }
+    else
     {
-        d_hog.detectMultiScale(d_img, found_locations);
+        cv::HOGDescriptor hog;
+        hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
+
+        hog.detectMultiScale(img, found_locations);
+
+        TEST_CYCLE()
+        {
+            hog.detectMultiScale(img, found_locations);
+        }
     }
 }
 
@@ -42,18 +57,34 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_HaarClassifier,
     cv::Mat img = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(img.empty());
 
-    cv::gpu::CascadeClassifier_GPU d_cascade;
-
-    ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
+    if (runOnGpu)
+    {
+        cv::gpu::CascadeClassifier_GPU d_cascade;
+        ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
 
-    cv::gpu::GpuMat d_img(img);
-    cv::gpu::GpuMat d_objects_buffer;
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_objects_buffer;
 
-    d_cascade.detectMultiScale(d_img, d_objects_buffer);
+        d_cascade.detectMultiScale(d_img, d_objects_buffer);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_cascade.detectMultiScale(d_img, d_objects_buffer);
+        }
+    }
+    else
     {
-        d_cascade.detectMultiScale(d_img, d_objects_buffer);
+        cv::CascadeClassifier cascade;
+        ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath("gpu/perf/haarcascade_frontalface_alt.xml")));
+
+        std::vector<cv::Rect> rects;
+
+        cascade.detectMultiScale(img, rects);
+
+        TEST_CYCLE()
+        {
+            cascade.detectMultiScale(img, rects);
+        }
     }
 }
 
@@ -66,18 +97,34 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_LBPClassifier,
     cv::Mat img = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(img.empty());
 
-    cv::gpu::CascadeClassifier_GPU d_cascade;
-
-    ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
+    if (runOnGpu)
+    {
+        cv::gpu::CascadeClassifier_GPU d_cascade;
+        ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
 
-    cv::gpu::GpuMat d_img(img);
-    cv::gpu::GpuMat d_gpu_rects;
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_gpu_rects;
 
-    d_cascade.detectMultiScale(d_img, d_gpu_rects);
+        d_cascade.detectMultiScale(d_img, d_gpu_rects);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_cascade.detectMultiScale(d_img, d_gpu_rects);
+        }
+    }
+    else
     {
-        d_cascade.detectMultiScale(d_img, d_gpu_rects);
+        cv::CascadeClassifier cascade;
+        ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath("gpu/lbpcascade/lbpcascade_frontalface.xml")));
+
+        std::vector<cv::Rect> rects;
+
+        cascade.detectMultiScale(img, rects);
+
+        TEST_CYCLE()
+        {
+            cascade.detectMultiScale(img, rects);
+        }
     }
 }
 

modules/gpu/perf_cpu/perf_cpu_precomp.cpp

-#include "perf_cpu_precomp.hpp"