2 #include "opencv2/imgproc.hpp"
3 #include "opencv2/highgui.hpp"
4 #include "opencv2/calib3d.hpp"
5 #include "opencv2/video.hpp"
6 #include "opencv2/cuda.hpp"
7 #include "opencv2/cudaimgproc.hpp"
8 #include "opencv2/cudaarithm.hpp"
9 #include "opencv2/cudawarping.hpp"
10 #include "opencv2/cudafeatures2d.hpp"
11 #include "opencv2/cudafilters.hpp"
12 #include "opencv2/cudaoptflow.hpp"
13 #include "opencv2/cudabgsegm.hpp"
15 #include "opencv2/legacy.hpp"
16 #include "performance.h"
18 #include "opencv2/opencv_modules.hpp"
20 #ifdef HAVE_OPENCV_NONFREE
21 #include "opencv2/nonfree/cuda.hpp"
22 #include "opencv2/nonfree/nonfree.hpp"
32 gen(src, 3000, 3000, CV_32F, 0, 1);
34 cuda::GpuMat d_src(src), d_templ, d_dst;
36 Ptr<cuda::TemplateMatching> alg = cuda::createTemplateMatching(src.type(), TM_CCORR);
38 for (int templ_size = 5; templ_size < 200; templ_size *= 5)
40 SUBTEST << src.cols << 'x' << src.rows << ", 32FC1" << ", templ " << templ_size << 'x' << templ_size << ", CCORR";
42 gen(templ, templ_size, templ_size, CV_32F, 0, 1);
43 matchTemplate(src, templ, dst, TM_CCORR);
46 matchTemplate(src, templ, dst, TM_CCORR);
49 d_templ.upload(templ);
50 alg->match(d_src, d_templ, d_dst);
53 alg->match(d_src, d_templ, d_dst);
64 double min_val, max_val;
65 Point min_loc, max_loc;
67 for (int size = 2000; size <= 8000; size *= 2)
69 SUBTEST << size << 'x' << size << ", 32F";
71 gen(src, size, size, CV_32F, 0, 1);
74 minMaxLoc(src, &min_val, &max_val, &min_loc, &max_loc);
80 cuda::minMaxLoc(d_src, &min_val, &max_val, &min_loc, &max_loc);
88 Mat src, dst, xmap, ymap;
89 cuda::GpuMat d_src, d_dst, d_xmap, d_ymap;
91 int interpolation = INTER_LINEAR;
92 int borderMode = BORDER_REPLICATE;
94 for (int size = 1000; size <= 4000; size *= 2)
96 SUBTEST << size << 'x' << size << ", 8UC4, INTER_LINEAR, BORDER_REPLICATE";
98 gen(src, size, size, CV_8UC4, 0, 256);
100 xmap.create(size, size, CV_32F);
101 ymap.create(size, size, CV_32F);
102 for (int i = 0; i < size; ++i)
104 float* xmap_row = xmap.ptr<float>(i);
105 float* ymap_row = ymap.ptr<float>(i);
106 for (int j = 0; j < size; ++j)
108 xmap_row[j] = (j - size * 0.5f) * 0.75f + size * 0.5f;
109 ymap_row[j] = (i - size * 0.5f) * 0.75f + size * 0.5f;
113 remap(src, dst, xmap, ymap, interpolation, borderMode);
116 remap(src, dst, xmap, ymap, interpolation, borderMode);
123 cuda::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
126 cuda::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
135 cuda::GpuMat d_src, d_dst;
137 for (int size = 1000; size <= 4000; size *= 2)
139 SUBTEST << size << 'x' << size << ", 32FC2, complex-to-complex";
141 gen(src, size, size, CV_32FC2, Scalar::all(0), Scalar::all(1));
151 cuda::dft(d_src, d_dst, Size(size, size));
154 cuda::dft(d_src, d_dst, Size(size, size));
163 cuda::GpuMat d_src, d_dst;
165 for (int size = 1000; size <= 4000; size *= 2)
167 SUBTEST << size << 'x' << size << ", 32FC1, BORDER_REFLECT101";
169 gen(src, size, size, CV_32F, 0, 1);
171 cornerHarris(src, dst, 5, 7, 0.1, BORDER_REFLECT101);
174 cornerHarris(src, dst, 5, 7, 0.1, BORDER_REFLECT101);
179 Ptr<cuda::CornernessCriteria> harris = cuda::createHarrisCorner(src.type(), 5, 7, 0.1, BORDER_REFLECT101);
181 harris->compute(d_src, d_dst);
184 harris->compute(d_src, d_dst);
193 cuda::GpuMat d_src, d_sum, d_buf;
195 for (int size = 1000; size <= 4000; size *= 2)
197 SUBTEST << size << 'x' << size << ", 8UC1";
199 gen(src, size, size, CV_8U, 0, 256);
209 cuda::integralBuffered(d_src, d_sum, d_buf);
212 cuda::integralBuffered(d_src, d_sum, d_buf);
221 cuda::GpuMat d_src, d_buf;
223 for (int size = 2000; size <= 4000; size += 1000)
225 SUBTEST << size << 'x' << size << ", 32FC4, NORM_INF";
227 gen(src, size, size, CV_32FC4, Scalar::all(0), Scalar::all(1));
237 cuda::norm(d_src, NORM_INF, d_buf);
240 cuda::norm(d_src, NORM_INF, d_buf);
248 int sp = 10, sr = 10;
251 cuda::GpuMat d_src, d_dst;
253 for (int size = 400; size <= 800; size *= 2)
255 SUBTEST << size << 'x' << size << ", 8UC3 vs 8UC4";
257 gen(src, size, size, CV_8UC3, Scalar::all(0), Scalar::all(256));
259 pyrMeanShiftFiltering(src, dst, sp, sr);
262 pyrMeanShiftFiltering(src, dst, sp, sr);
265 gen(src, size, size, CV_8UC4, Scalar::all(0), Scalar::all(256));
269 cuda::meanShiftFiltering(d_src, d_dst, sp, sr);
272 cuda::meanShiftFiltering(d_src, d_dst, sp, sr);
277 #ifdef HAVE_OPENCV_NONFREE
281 Mat src = imread(abspath("aloeL.jpg"), IMREAD_GRAYSCALE);
282 if (src.empty()) throw runtime_error("can't open aloeL.jpg");
285 vector<KeyPoint> keypoints;
288 surf(src, Mat(), keypoints, descriptors);
291 surf(src, Mat(), keypoints, descriptors);
294 cuda::SURF_CUDA d_surf;
295 cuda::GpuMat d_src(src);
296 cuda::GpuMat d_keypoints;
297 cuda::GpuMat d_descriptors;
299 d_surf(d_src, cuda::GpuMat(), d_keypoints, d_descriptors);
302 d_surf(d_src, cuda::GpuMat(), d_keypoints, d_descriptors);
311 Mat src = imread(abspath("aloeL.jpg"), IMREAD_GRAYSCALE);
312 if (src.empty()) throw runtime_error("can't open aloeL.jpg");
314 vector<KeyPoint> keypoints;
316 FAST(src, keypoints, 20);
319 FAST(src, keypoints, 20);
322 cuda::FAST_CUDA d_FAST(20);
323 cuda::GpuMat d_src(src);
324 cuda::GpuMat d_keypoints;
326 d_FAST(d_src, cuda::GpuMat(), d_keypoints);
329 d_FAST(d_src, cuda::GpuMat(), d_keypoints);
336 Mat src = imread(abspath("aloeL.jpg"), IMREAD_GRAYSCALE);
337 if (src.empty()) throw runtime_error("can't open aloeL.jpg");
340 vector<KeyPoint> keypoints;
343 orb(src, Mat(), keypoints, descriptors);
346 orb(src, Mat(), keypoints, descriptors);
349 cuda::ORB_CUDA d_orb;
350 cuda::GpuMat d_src(src);
351 cuda::GpuMat d_keypoints;
352 cuda::GpuMat d_descriptors;
354 d_orb(d_src, cuda::GpuMat(), d_keypoints, d_descriptors);
357 d_orb(d_src, cuda::GpuMat(), d_keypoints, d_descriptors);
362 TEST(BruteForceMatcher)
368 BFMatcher matcher(NORM_L2);
371 gen(query, 3000, desc_len, CV_32F, 0, 1);
374 gen(train, 3000, desc_len, CV_32F, 0, 1);
378 cuda::BFMatcher_CUDA d_matcher(NORM_L2);
380 cuda::GpuMat d_query(query);
381 cuda::GpuMat d_train(train);
384 vector< vector<DMatch> > matches(2);
385 cuda::GpuMat d_trainIdx, d_distance, d_allDist, d_nMatches;
389 matcher.match(query, train, matches[0]);
392 matcher.match(query, train, matches[0]);
395 d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
398 d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
401 SUBTEST << "knnMatch";
403 matcher.knnMatch(query, train, matches, 2);
406 matcher.knnMatch(query, train, matches, 2);
409 d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, 2);
412 d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, 2);
415 SUBTEST << "radiusMatch";
417 float max_distance = 2.0f;
419 matcher.radiusMatch(query, train, matches, max_distance);
422 matcher.radiusMatch(query, train, matches, max_distance);
425 d_trainIdx.release();
427 d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, max_distance);
430 d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, max_distance);
438 cuda::GpuMat d_x, d_y, d_mag;
440 for (int size = 2000; size <= 4000; size += 1000)
442 SUBTEST << size << 'x' << size << ", 32FC1";
444 gen(x, size, size, CV_32F, 0, 1);
445 gen(y, size, size, CV_32F, 0, 1);
447 magnitude(x, y, mag);
450 magnitude(x, y, mag);
456 cuda::magnitude(d_x, d_y, d_mag);
459 cuda::magnitude(d_x, d_y, d_mag);
468 cuda::GpuMat d_src1, d_src2, d_dst;
470 for (int size = 2000; size <= 4000; size += 1000)
472 SUBTEST << size << 'x' << size << ", 32FC1";
474 gen(src1, size, size, CV_32F, 0, 1);
475 gen(src2, size, size, CV_32F, 0, 1);
477 add(src1, src2, dst);
480 add(src1, src2, dst);
486 cuda::add(d_src1, d_src2, d_dst);
489 cuda::add(d_src1, d_src2, d_dst);
498 cuda::GpuMat d_src, d_dst;
500 for (int size = 2000; size <= 4000; size += 1000)
502 SUBTEST << size << 'x' << size << ", 32F";
504 gen(src, size, size, CV_32F, 1, 10);
514 cuda::log(d_src, d_dst);
517 cuda::log(d_src, d_dst);
526 cuda::GpuMat d_src1, d_src2, d_dst;
528 for (int size = 2000; size <= 4000; size += 1000)
530 SUBTEST << size << 'x' << size;
532 gen(src1, size, size, CV_32FC2, Scalar::all(0), Scalar::all(1));
533 gen(src2, size, size, CV_32FC2, Scalar::all(0), Scalar::all(1));
535 mulSpectrums(src1, src2, dst, 0, true);
538 mulSpectrums(src1, src2, dst, 0, true);
544 cuda::mulSpectrums(d_src1, d_src2, d_dst, 0, true);
547 cuda::mulSpectrums(d_src1, d_src2, d_dst, 0, true);
556 cuda::GpuMat d_src, d_dst;
558 for (int size = 1000; size <= 3000; size += 1000)
560 SUBTEST << size << 'x' << size << ", 8UC4, up";
562 gen(src, size, size, CV_8UC4, 0, 256);
564 resize(src, dst, Size(), 2.0, 2.0);
567 resize(src, dst, Size(), 2.0, 2.0);
572 cuda::resize(d_src, d_dst, Size(), 2.0, 2.0);
575 cuda::resize(d_src, d_dst, Size(), 2.0, 2.0);
579 for (int size = 1000; size <= 3000; size += 1000)
581 SUBTEST << size << 'x' << size << ", 8UC4, down";
583 gen(src, size, size, CV_8UC4, 0, 256);
585 resize(src, dst, Size(), 0.5, 0.5);
588 resize(src, dst, Size(), 0.5, 0.5);
593 cuda::resize(d_src, d_dst, Size(), 0.5, 0.5);
596 cuda::resize(d_src, d_dst, Size(), 0.5, 0.5);
605 cuda::GpuMat d_src, d_dst;
607 gen(src, 4000, 4000, CV_8UC1, 0, 255);
610 SUBTEST << "4000x4000, 8UC1, COLOR_GRAY2BGRA";
612 cvtColor(src, dst, COLOR_GRAY2BGRA, 4);
615 cvtColor(src, dst, COLOR_GRAY2BGRA, 4);
618 cuda::cvtColor(d_src, d_dst, COLOR_GRAY2BGRA, 4);
621 cuda::cvtColor(d_src, d_dst, COLOR_GRAY2BGRA, 4);
627 SUBTEST << "4000x4000, 8UC3 vs 8UC4, COLOR_BGR2YCrCb";
629 cvtColor(src, dst, COLOR_BGR2YCrCb);
632 cvtColor(src, dst, COLOR_BGR2YCrCb);
635 cuda::cvtColor(d_src, d_dst, COLOR_BGR2YCrCb, 4);
638 cuda::cvtColor(d_src, d_dst, COLOR_BGR2YCrCb, 4);
644 SUBTEST << "4000x4000, 8UC4, COLOR_YCrCb2BGR";
646 cvtColor(src, dst, COLOR_YCrCb2BGR, 4);
649 cvtColor(src, dst, COLOR_YCrCb2BGR, 4);
652 cuda::cvtColor(d_src, d_dst, COLOR_YCrCb2BGR, 4);
655 cuda::cvtColor(d_src, d_dst, COLOR_YCrCb2BGR, 4);
661 SUBTEST << "4000x4000, 8UC3 vs 8UC4, COLOR_BGR2XYZ";
663 cvtColor(src, dst, COLOR_BGR2XYZ);
666 cvtColor(src, dst, COLOR_BGR2XYZ);
669 cuda::cvtColor(d_src, d_dst, COLOR_BGR2XYZ, 4);
672 cuda::cvtColor(d_src, d_dst, COLOR_BGR2XYZ, 4);
678 SUBTEST << "4000x4000, 8UC4, COLOR_XYZ2BGR";
680 cvtColor(src, dst, COLOR_XYZ2BGR, 4);
683 cvtColor(src, dst, COLOR_XYZ2BGR, 4);
686 cuda::cvtColor(d_src, d_dst, COLOR_XYZ2BGR, 4);
689 cuda::cvtColor(d_src, d_dst, COLOR_XYZ2BGR, 4);
695 SUBTEST << "4000x4000, 8UC3 vs 8UC4, COLOR_BGR2HSV";
697 cvtColor(src, dst, COLOR_BGR2HSV);
700 cvtColor(src, dst, COLOR_BGR2HSV);
703 cuda::cvtColor(d_src, d_dst, COLOR_BGR2HSV, 4);
706 cuda::cvtColor(d_src, d_dst, COLOR_BGR2HSV, 4);
712 SUBTEST << "4000x4000, 8UC4, COLOR_HSV2BGR";
714 cvtColor(src, dst, COLOR_HSV2BGR, 4);
717 cvtColor(src, dst, COLOR_HSV2BGR, 4);
720 cuda::cvtColor(d_src, d_dst, COLOR_HSV2BGR, 4);
723 cuda::cvtColor(d_src, d_dst, COLOR_HSV2BGR, 4);
734 cuda::GpuMat d_src, d_buf, d_dst;
736 for (int size = 2000; size <= 4000; size += 1000)
738 SUBTEST << size << 'x' << size;
740 gen(src, size, size, CV_8UC4, Scalar::all(0), Scalar::all(256));
741 ker = getStructuringElement(MORPH_RECT, Size(3, 3));
743 erode(src, dst, ker);
746 erode(src, dst, ker);
751 Ptr<cuda::Filter> erode = cuda::createMorphologyFilter(MORPH_ERODE, d_src.type(), ker);
753 erode->apply(d_src, d_dst);
756 erode->apply(d_src, d_dst);
764 cuda::GpuMat d_src, d_dst;
766 for (int size = 2000; size <= 4000; size += 1000)
768 SUBTEST << size << 'x' << size << ", 8UC1, THRESH_BINARY";
770 gen(src, size, size, CV_8U, 0, 100);
772 threshold(src, dst, 50.0, 0.0, THRESH_BINARY);
775 threshold(src, dst, 50.0, 0.0, THRESH_BINARY);
780 cuda::threshold(d_src, d_dst, 50.0, 0.0, THRESH_BINARY);
783 cuda::threshold(d_src, d_dst, 50.0, 0.0, THRESH_BINARY);
787 for (int size = 2000; size <= 4000; size += 1000)
789 SUBTEST << size << 'x' << size << ", 32FC1, THRESH_TRUNC [NPP]";
791 gen(src, size, size, CV_32FC1, 0, 100);
793 threshold(src, dst, 50.0, 0.0, THRESH_TRUNC);
796 threshold(src, dst, 50.0, 0.0, THRESH_TRUNC);
801 cuda::threshold(d_src, d_dst, 50.0, 0.0, THRESH_TRUNC);
804 cuda::threshold(d_src, d_dst, 50.0, 0.0, THRESH_TRUNC);
812 cuda::GpuMat d_src, d_dst;
814 for (int size = 1000; size <= 4000; size += 1000)
816 SUBTEST << size << 'x' << size << ", 32F";
818 gen(src, size, size, CV_32F, 0, 100);
828 cuda::pow(d_src, -2.0, d_dst);
831 cuda::pow(d_src, -2.0, d_dst);
841 cuda::GpuMat d_src, d_dst;
843 Mat rvec; gen(rvec, 1, 3, CV_32F, 0, 1);
844 Mat tvec; gen(tvec, 1, 3, CV_32F, 0, 1);
845 Mat camera_mat; gen(camera_mat, 3, 3, CV_32F, 0, 1);
846 camera_mat.at<float>(0, 1) = 0.f;
847 camera_mat.at<float>(1, 0) = 0.f;
848 camera_mat.at<float>(2, 0) = 0.f;
849 camera_mat.at<float>(2, 1) = 0.f;
851 for (int size = (int)1e6, count = 0; size >= 1e5 && count < 5; size = int(size / 1.4), count++)
855 gen(src, 1, size, CV_32FC3, Scalar::all(0), Scalar::all(10));
857 projectPoints(src, rvec, tvec, camera_mat, Mat::zeros(1, 8, CV_32F), dst);
860 projectPoints(src, rvec, tvec, camera_mat, Mat::zeros(1, 8, CV_32F), dst);
865 cuda::projectPoints(d_src, rvec, tvec, camera_mat, Mat(), d_dst);
868 cuda::projectPoints(d_src, rvec, tvec, camera_mat, Mat(), d_dst);
874 static void InitSolvePnpRansac()
876 Mat object; gen(object, 1, 4, CV_32FC3, Scalar::all(0), Scalar::all(100));
877 Mat image; gen(image, 1, 4, CV_32FC2, Scalar::all(0), Scalar::all(100));
879 cuda::solvePnPRansac(object, image, Mat::eye(3, 3, CV_32F), Mat(), rvec, tvec);
885 InitSolvePnpRansac();
887 for (int num_points = 5000; num_points <= 300000; num_points = int(num_points * 3.76))
889 SUBTEST << num_points;
891 Mat object; gen(object, 1, num_points, CV_32FC3, Scalar::all(10), Scalar::all(100));
892 Mat image; gen(image, 1, num_points, CV_32FC2, Scalar::all(10), Scalar::all(100));
893 Mat camera_mat; gen(camera_mat, 3, 3, CV_32F, 0.5, 1);
894 camera_mat.at<float>(0, 1) = 0.f;
895 camera_mat.at<float>(1, 0) = 0.f;
896 camera_mat.at<float>(2, 0) = 0.f;
897 camera_mat.at<float>(2, 1) = 0.f;
900 const int num_iters = 200;
901 const float max_dist = 2.0f;
902 vector<int> inliers_cpu, inliers_gpu;
905 solvePnPRansac(object, image, camera_mat, Mat::zeros(1, 8, CV_32F), rvec, tvec, false, num_iters,
906 max_dist, int(num_points * 0.05), inliers_cpu);
910 cuda::solvePnPRansac(object, image, camera_mat, Mat::zeros(1, 8, CV_32F), rvec, tvec, false, num_iters,
911 max_dist, int(num_points * 0.05), &inliers_gpu);
918 for (int size = 1000; size <= 4000; size += 1000)
920 SUBTEST << size << 'x' << size << ", 8UC4";
924 gen(src, size, size, CV_8UC4, 0, 256);
926 GaussianBlur(src, dst, Size(3, 3), 1);
929 GaussianBlur(src, dst, Size(3, 3), 1);
932 cuda::GpuMat d_src(src);
933 cuda::GpuMat d_dst(src.size(), src.type());
936 cv::Ptr<cv::cuda::Filter> gauss = cv::cuda::createGaussianFilter(d_src.type(), -1, cv::Size(3, 3), 1);
938 gauss->apply(d_src, d_dst);
941 gauss->apply(d_src, d_dst);
948 for (int size = 512; size <= 2048; size *= 2)
951 gen(src, size, size, CV_8UC4, 0, 256);
953 for (int ksize = 3; ksize <= 16; ksize += 2)
955 SUBTEST << "ksize = " << ksize << ", " << size << 'x' << size << ", 8UC4";
958 gen(kernel, ksize, ksize, CV_32FC1, 0.0, 1.0);
961 cv::filter2D(src, dst, -1, kernel);
964 cv::filter2D(src, dst, -1, kernel);
967 cuda::GpuMat d_src(src);
970 Ptr<cuda::Filter> filter2D = cuda::createLinearFilter(d_src.type(), -1, kernel);
971 filter2D->apply(d_src, d_dst);
974 filter2D->apply(d_src, d_dst);
982 for (int size = 4000; size >= 1000; size -= 1000)
984 SUBTEST << size << 'x' << size << ", 8UC4";
987 gen(src, size, size, CV_8UC4, 0, 256);
995 cuda::GpuMat d_src(src);
998 cuda::pyrDown(d_src, d_dst);
1001 cuda::pyrDown(d_src, d_dst);
1008 for (int size = 2000; size >= 1000; size -= 1000)
1010 SUBTEST << size << 'x' << size << ", 8UC4";
1014 gen(src, size, size, CV_8UC4, 0, 256);
1022 cuda::GpuMat d_src(src);
1025 cuda::pyrUp(d_src, d_dst);
1028 cuda::pyrUp(d_src, d_dst);
1036 for (int size = 1000; size < 4000; size += 1000)
1038 SUBTEST << size << 'x' << size;
1042 gen(src, size, size, CV_8UC1, 0, 256);
1044 equalizeHist(src, dst);
1047 equalizeHist(src, dst);
1050 cuda::GpuMat d_src(src);
1054 cuda::equalizeHist(d_src, d_dst, d_buf);
1057 cuda::equalizeHist(d_src, d_dst, d_buf);
1065 Mat img = imread(abspath("aloeL.jpg"), IMREAD_GRAYSCALE);
1067 if (img.empty()) throw runtime_error("can't open aloeL.jpg");
1069 Mat edges(img.size(), CV_8UC1);
1072 Canny(img, edges, 50.0, 100.0);
1075 cuda::GpuMat d_img(img);
1076 cuda::GpuMat d_edges;
1078 Ptr<cuda::CannyEdgeDetector> canny = cuda::createCannyEdgeDetector(50.0, 100.0);
1080 canny->detect(d_img, d_edges);
1083 canny->detect(d_img, d_edges);
1090 for (int size = 1000; size < 4000; size += 1000)
1093 gen(src, size, size, CV_32F, 0, 255);
1098 cuda::GpuMat d_src(src);
1099 cuda::GpuMat d_dst0;
1100 cuda::GpuMat d_dst1;
1102 SUBTEST << size << 'x' << size << ", dim = 0";
1104 reduce(src, dst0, 0, REDUCE_MIN);
1107 reduce(src, dst0, 0, REDUCE_MIN);
1110 cuda::reduce(d_src, d_dst0, 0, REDUCE_MIN);
1113 cuda::reduce(d_src, d_dst0, 0, REDUCE_MIN);
1116 SUBTEST << size << 'x' << size << ", dim = 1";
1118 reduce(src, dst1, 1, REDUCE_MIN);
1121 reduce(src, dst1, 1, REDUCE_MIN);
1124 cuda::reduce(d_src, d_dst1, 1, REDUCE_MIN);
1127 cuda::reduce(d_src, d_dst1, 1, REDUCE_MIN);
1135 Mat src1, src2, src3, dst;
1136 cuda::GpuMat d_src1, d_src2, d_src3, d_dst;
1138 for (int size = 512; size <= 1024; size *= 2)
1140 SUBTEST << size << 'x' << size;
1142 gen(src1, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10));
1143 gen(src2, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10));
1144 gen(src3, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10));
1146 gemm(src1, src2, 1.0, src3, 1.0, dst);
1149 gemm(src1, src2, 1.0, src3, 1.0, dst);
1152 d_src1.upload(src1);
1153 d_src2.upload(src2);
1154 d_src3.upload(src3);
1156 cuda::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
1159 cuda::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
1164 TEST(GoodFeaturesToTrack)
1166 Mat src = imread(abspath("aloeL.jpg"), IMREAD_GRAYSCALE);
1167 if (src.empty()) throw runtime_error("can't open aloeL.jpg");
1169 vector<Point2f> pts;
1171 goodFeaturesToTrack(src, pts, 8000, 0.01, 0.0);
1174 goodFeaturesToTrack(src, pts, 8000, 0.01, 0.0);
1177 Ptr<cuda::CornersDetector> detector = cuda::createGoodFeaturesToTrackDetector(src.type(), 8000, 0.01, 0.0);
1179 cuda::GpuMat d_src(src);
1182 detector->detect(d_src, d_pts);
1185 detector->detect(d_src, d_pts);
1189 TEST(PyrLKOpticalFlow)
1191 Mat frame0 = imread(abspath("rubberwhale1.png"));
1192 if (frame0.empty()) throw runtime_error("can't open rubberwhale1.png");
1194 Mat frame1 = imread(abspath("rubberwhale2.png"));
1195 if (frame1.empty()) throw runtime_error("can't open rubberwhale2.png");
1198 cvtColor(frame0, gray_frame, COLOR_BGR2GRAY);
1200 for (int points = 1000; points <= 8000; points *= 2)
1204 vector<Point2f> pts;
1205 goodFeaturesToTrack(gray_frame, pts, points, 0.01, 0.0);
1207 vector<Point2f> nextPts;
1208 vector<unsigned char> status;
1212 calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, err);
1215 calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, err);
1218 cuda::PyrLKOpticalFlow d_pyrLK;
1220 cuda::GpuMat d_frame0(frame0);
1221 cuda::GpuMat d_frame1(frame1);
1224 Mat pts_mat(1, (int)pts.size(), CV_32FC2, (void*)&pts[0]);
1225 d_pts.upload(pts_mat);
1227 cuda::GpuMat d_nextPts;
1228 cuda::GpuMat d_status;
1231 d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err);
1234 d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err);
1240 TEST(FarnebackOpticalFlow)
1242 const string datasets[] = {"rubberwhale", "basketball"};
1243 for (size_t i = 0; i < sizeof(datasets)/sizeof(*datasets); ++i) {
1244 for (int fastPyramids = 0; fastPyramids < 2; ++fastPyramids) {
1245 for (int useGaussianBlur = 0; useGaussianBlur < 2; ++useGaussianBlur) {
1247 SUBTEST << "dataset=" << datasets[i] << ", fastPyramids=" << fastPyramids << ", useGaussianBlur=" << useGaussianBlur;
1248 Mat frame0 = imread(abspath(datasets[i] + "1.png"), IMREAD_GRAYSCALE);
1249 Mat frame1 = imread(abspath(datasets[i] + "2.png"), IMREAD_GRAYSCALE);
1250 if (frame0.empty()) throw runtime_error("can't open " + datasets[i] + "1.png");
1251 if (frame1.empty()) throw runtime_error("can't open " + datasets[i] + "2.png");
1253 cuda::FarnebackOpticalFlow calc;
1254 calc.fastPyramids = fastPyramids != 0;
1255 calc.flags |= useGaussianBlur ? OPTFLOW_FARNEBACK_GAUSSIAN : 0;
1257 cuda::GpuMat d_frame0(frame0), d_frame1(frame1), d_flowx, d_flowy;
1259 calc(d_frame0, d_frame1, d_flowx, d_flowy);
1264 calcOpticalFlowFarneback(frame0, frame1, flow, calc.pyrScale, calc.numLevels, calc.winSize, calc.numIters, calc.polyN, calc.polySigma, calc.flags);
1272 template<> void DefaultDeleter<CvBGStatModel>::operator ()(CvBGStatModel* obj) const
1274 cvReleaseBGStatModel(&obj);
1280 const std::string inputFile = abspath("768x576.avi");
1282 VideoCapture cap(inputFile);
1283 if (!cap.isOpened()) throw runtime_error("can't open 768x576.avi");
1288 IplImage ipl_frame = frame;
1289 Ptr<CvBGStatModel> model(cvCreateFGDStatModel(&ipl_frame));
1291 while (!TestSystem::instance().stop())
1296 TestSystem::instance().cpuOn();
1298 cvUpdateBGStatModel(&ipl_frame, model);
1300 TestSystem::instance().cpuOff();
1302 TestSystem::instance().cpuComplete();
1304 cap.open(inputFile);
1308 cuda::GpuMat d_frame(frame), d_fgmask;
1309 Ptr<BackgroundSubtractor> d_fgd = cuda::createBackgroundSubtractorFGD();
1311 d_fgd->apply(d_frame, d_fgmask);
1313 while (!TestSystem::instance().stop())
1316 d_frame.upload(frame);
1318 TestSystem::instance().gpuOn();
1320 d_fgd->apply(d_frame, d_fgmask);
1322 TestSystem::instance().gpuOff();
1324 TestSystem::instance().gpuComplete();
1329 const std::string inputFile = abspath("768x576.avi");
1331 cv::VideoCapture cap(inputFile);
1332 if (!cap.isOpened()) throw runtime_error("can't open 768x576.avi");
1337 cv::Ptr<cv::BackgroundSubtractor> mog = cv::createBackgroundSubtractorMOG();
1340 mog->apply(frame, foreground, 0.01);
1342 while (!TestSystem::instance().stop())
1346 TestSystem::instance().cpuOn();
1348 mog->apply(frame, foreground, 0.01);
1350 TestSystem::instance().cpuOff();
1352 TestSystem::instance().cpuComplete();
1354 cap.open(inputFile);
1358 cv::cuda::GpuMat d_frame(frame);
1359 cv::Ptr<cv::BackgroundSubtractor> d_mog = cv::cuda::createBackgroundSubtractorMOG();
1360 cv::cuda::GpuMat d_foreground;
1362 d_mog->apply(d_frame, d_foreground, 0.01);
1364 while (!TestSystem::instance().stop())
1367 d_frame.upload(frame);
1369 TestSystem::instance().gpuOn();
1371 d_mog->apply(d_frame, d_foreground, 0.01);
1373 TestSystem::instance().gpuOff();
1375 TestSystem::instance().gpuComplete();
1380 const std::string inputFile = abspath("768x576.avi");
1382 cv::VideoCapture cap(inputFile);
1383 if (!cap.isOpened()) throw runtime_error("can't open 768x576.avi");
1388 cv::Ptr<cv::BackgroundSubtractor> mog2 = cv::createBackgroundSubtractorMOG2();
1392 mog2->apply(frame, foreground);
1393 mog2->getBackgroundImage(background);
1395 while (!TestSystem::instance().stop())
1399 TestSystem::instance().cpuOn();
1401 mog2->apply(frame, foreground);
1402 mog2->getBackgroundImage(background);
1404 TestSystem::instance().cpuOff();
1406 TestSystem::instance().cpuComplete();
1408 cap.open(inputFile);
1412 cv::Ptr<cv::BackgroundSubtractor> d_mog2 = cv::cuda::createBackgroundSubtractorMOG2();
1413 cv::cuda::GpuMat d_frame(frame);
1414 cv::cuda::GpuMat d_foreground;
1415 cv::cuda::GpuMat d_background;
1417 d_mog2->apply(d_frame, d_foreground);
1418 d_mog2->getBackgroundImage(d_background);
1420 while (!TestSystem::instance().stop())
1423 d_frame.upload(frame);
1425 TestSystem::instance().gpuOn();
1427 d_mog2->apply(d_frame, d_foreground);
1428 d_mog2->getBackgroundImage(d_background);
1430 TestSystem::instance().gpuOff();
1432 TestSystem::instance().gpuComplete();