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 "performance.h"
17 #include "opencv2/opencv_modules.hpp"
19 #ifdef HAVE_OPENCV_XFEATURES2D
20 #include "opencv2/xfeatures2d/cuda.hpp"
21 #include "opencv2/xfeatures2d/nonfree.hpp"
31 gen(src, 3000, 3000, CV_32F, 0, 1);
33 cuda::GpuMat d_src(src), d_templ, d_dst;
35 Ptr<cuda::TemplateMatching> alg = cuda::createTemplateMatching(src.type(), TM_CCORR);
37 for (int templ_size = 5; templ_size < 200; templ_size *= 5)
39 SUBTEST << src.cols << 'x' << src.rows << ", 32FC1" << ", templ " << templ_size << 'x' << templ_size << ", CCORR";
41 gen(templ, templ_size, templ_size, CV_32F, 0, 1);
42 matchTemplate(src, templ, dst, TM_CCORR);
45 matchTemplate(src, templ, dst, TM_CCORR);
48 d_templ.upload(templ);
49 alg->match(d_src, d_templ, d_dst);
52 alg->match(d_src, d_templ, d_dst);
63 double min_val, max_val;
64 Point min_loc, max_loc;
66 for (int size = 2000; size <= 8000; size *= 2)
68 SUBTEST << size << 'x' << size << ", 32F";
70 gen(src, size, size, CV_32F, 0, 1);
73 minMaxLoc(src, &min_val, &max_val, &min_loc, &max_loc);
79 cuda::minMaxLoc(d_src, &min_val, &max_val, &min_loc, &max_loc);
87 Mat src, dst, xmap, ymap;
88 cuda::GpuMat d_src, d_dst, d_xmap, d_ymap;
90 int interpolation = INTER_LINEAR;
91 int borderMode = BORDER_REPLICATE;
93 for (int size = 1000; size <= 4000; size *= 2)
95 SUBTEST << size << 'x' << size << ", 8UC4, INTER_LINEAR, BORDER_REPLICATE";
97 gen(src, size, size, CV_8UC4, 0, 256);
99 xmap.create(size, size, CV_32F);
100 ymap.create(size, size, CV_32F);
101 for (int i = 0; i < size; ++i)
103 float* xmap_row = xmap.ptr<float>(i);
104 float* ymap_row = ymap.ptr<float>(i);
105 for (int j = 0; j < size; ++j)
107 xmap_row[j] = (j - size * 0.5f) * 0.75f + size * 0.5f;
108 ymap_row[j] = (i - size * 0.5f) * 0.75f + size * 0.5f;
112 remap(src, dst, xmap, ymap, interpolation, borderMode);
115 remap(src, dst, xmap, ymap, interpolation, borderMode);
122 cuda::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
125 cuda::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
134 cuda::GpuMat d_src, d_dst;
136 for (int size = 1000; size <= 4000; size *= 2)
138 SUBTEST << size << 'x' << size << ", 32FC2, complex-to-complex";
140 gen(src, size, size, CV_32FC2, Scalar::all(0), Scalar::all(1));
150 cuda::dft(d_src, d_dst, Size(size, size));
153 cuda::dft(d_src, d_dst, Size(size, size));
162 cuda::GpuMat d_src, d_dst;
164 for (int size = 1000; size <= 4000; size *= 2)
166 SUBTEST << size << 'x' << size << ", 32FC1, BORDER_REFLECT101";
168 gen(src, size, size, CV_32F, 0, 1);
170 cornerHarris(src, dst, 5, 7, 0.1, BORDER_REFLECT101);
173 cornerHarris(src, dst, 5, 7, 0.1, BORDER_REFLECT101);
178 Ptr<cuda::CornernessCriteria> harris = cuda::createHarrisCorner(src.type(), 5, 7, 0.1, BORDER_REFLECT101);
180 harris->compute(d_src, d_dst);
183 harris->compute(d_src, d_dst);
192 cuda::GpuMat d_src, d_sum, d_buf;
194 for (int size = 1000; size <= 4000; size *= 2)
196 SUBTEST << size << 'x' << size << ", 8UC1";
198 gen(src, size, size, CV_8U, 0, 256);
208 cuda::integralBuffered(d_src, d_sum, d_buf);
211 cuda::integralBuffered(d_src, d_sum, d_buf);
220 cuda::GpuMat d_src, d_buf;
222 for (int size = 2000; size <= 4000; size += 1000)
224 SUBTEST << size << 'x' << size << ", 32FC4, NORM_INF";
226 gen(src, size, size, CV_32FC4, Scalar::all(0), Scalar::all(1));
236 cuda::norm(d_src, NORM_INF, d_buf);
239 cuda::norm(d_src, NORM_INF, d_buf);
247 int sp = 10, sr = 10;
250 cuda::GpuMat d_src, d_dst;
252 for (int size = 400; size <= 800; size *= 2)
254 SUBTEST << size << 'x' << size << ", 8UC3 vs 8UC4";
256 gen(src, size, size, CV_8UC3, Scalar::all(0), Scalar::all(256));
258 pyrMeanShiftFiltering(src, dst, sp, sr);
261 pyrMeanShiftFiltering(src, dst, sp, sr);
264 gen(src, size, size, CV_8UC4, Scalar::all(0), Scalar::all(256));
268 cuda::meanShiftFiltering(d_src, d_dst, sp, sr);
271 cuda::meanShiftFiltering(d_src, d_dst, sp, sr);
276 #ifdef HAVE_OPENCV_XFEATURES2D
280 Mat src = imread(abspath("aloeL.jpg"), IMREAD_GRAYSCALE);
281 if (src.empty()) throw runtime_error("can't open aloeL.jpg");
284 vector<KeyPoint> keypoints;
287 surf(src, Mat(), keypoints, descriptors);
290 surf(src, Mat(), keypoints, descriptors);
293 cuda::SURF_CUDA d_surf;
294 cuda::GpuMat d_src(src);
295 cuda::GpuMat d_keypoints;
296 cuda::GpuMat d_descriptors;
298 d_surf(d_src, cuda::GpuMat(), d_keypoints, d_descriptors);
301 d_surf(d_src, cuda::GpuMat(), d_keypoints, d_descriptors);
310 Mat src = imread(abspath("aloeL.jpg"), IMREAD_GRAYSCALE);
311 if (src.empty()) throw runtime_error("can't open aloeL.jpg");
313 vector<KeyPoint> keypoints;
315 FAST(src, keypoints, 20);
318 FAST(src, keypoints, 20);
321 cuda::FAST_CUDA d_FAST(20);
322 cuda::GpuMat d_src(src);
323 cuda::GpuMat d_keypoints;
325 d_FAST(d_src, cuda::GpuMat(), d_keypoints);
328 d_FAST(d_src, cuda::GpuMat(), d_keypoints);
335 Mat src = imread(abspath("aloeL.jpg"), IMREAD_GRAYSCALE);
336 if (src.empty()) throw runtime_error("can't open aloeL.jpg");
339 vector<KeyPoint> keypoints;
342 orb(src, Mat(), keypoints, descriptors);
345 orb(src, Mat(), keypoints, descriptors);
348 cuda::ORB_CUDA d_orb;
349 cuda::GpuMat d_src(src);
350 cuda::GpuMat d_keypoints;
351 cuda::GpuMat d_descriptors;
353 d_orb(d_src, cuda::GpuMat(), d_keypoints, d_descriptors);
356 d_orb(d_src, cuda::GpuMat(), d_keypoints, d_descriptors);
361 TEST(BruteForceMatcher)
367 BFMatcher matcher(NORM_L2);
370 gen(query, 3000, desc_len, CV_32F, 0, 1);
373 gen(train, 3000, desc_len, CV_32F, 0, 1);
377 cuda::BFMatcher_CUDA d_matcher(NORM_L2);
379 cuda::GpuMat d_query(query);
380 cuda::GpuMat d_train(train);
383 vector< vector<DMatch> > matches(2);
384 cuda::GpuMat d_trainIdx, d_distance, d_allDist, d_nMatches;
388 matcher.match(query, train, matches[0]);
391 matcher.match(query, train, matches[0]);
394 d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
397 d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
400 SUBTEST << "knnMatch";
402 matcher.knnMatch(query, train, matches, 2);
405 matcher.knnMatch(query, train, matches, 2);
408 d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, 2);
411 d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, 2);
414 SUBTEST << "radiusMatch";
416 float max_distance = 2.0f;
418 matcher.radiusMatch(query, train, matches, max_distance);
421 matcher.radiusMatch(query, train, matches, max_distance);
424 d_trainIdx.release();
426 d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, max_distance);
429 d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, max_distance);
437 cuda::GpuMat d_x, d_y, d_mag;
439 for (int size = 2000; size <= 4000; size += 1000)
441 SUBTEST << size << 'x' << size << ", 32FC1";
443 gen(x, size, size, CV_32F, 0, 1);
444 gen(y, size, size, CV_32F, 0, 1);
446 magnitude(x, y, mag);
449 magnitude(x, y, mag);
455 cuda::magnitude(d_x, d_y, d_mag);
458 cuda::magnitude(d_x, d_y, d_mag);
467 cuda::GpuMat d_src1, d_src2, d_dst;
469 for (int size = 2000; size <= 4000; size += 1000)
471 SUBTEST << size << 'x' << size << ", 32FC1";
473 gen(src1, size, size, CV_32F, 0, 1);
474 gen(src2, size, size, CV_32F, 0, 1);
476 add(src1, src2, dst);
479 add(src1, src2, dst);
485 cuda::add(d_src1, d_src2, d_dst);
488 cuda::add(d_src1, d_src2, d_dst);
497 cuda::GpuMat d_src, d_dst;
499 for (int size = 2000; size <= 4000; size += 1000)
501 SUBTEST << size << 'x' << size << ", 32F";
503 gen(src, size, size, CV_32F, 1, 10);
513 cuda::log(d_src, d_dst);
516 cuda::log(d_src, d_dst);
525 cuda::GpuMat d_src1, d_src2, d_dst;
527 for (int size = 2000; size <= 4000; size += 1000)
529 SUBTEST << size << 'x' << size;
531 gen(src1, size, size, CV_32FC2, Scalar::all(0), Scalar::all(1));
532 gen(src2, size, size, CV_32FC2, Scalar::all(0), Scalar::all(1));
534 mulSpectrums(src1, src2, dst, 0, true);
537 mulSpectrums(src1, src2, dst, 0, true);
543 cuda::mulSpectrums(d_src1, d_src2, d_dst, 0, true);
546 cuda::mulSpectrums(d_src1, d_src2, d_dst, 0, true);
555 cuda::GpuMat d_src, d_dst;
557 for (int size = 1000; size <= 3000; size += 1000)
559 SUBTEST << size << 'x' << size << ", 8UC4, up";
561 gen(src, size, size, CV_8UC4, 0, 256);
563 resize(src, dst, Size(), 2.0, 2.0);
566 resize(src, dst, Size(), 2.0, 2.0);
571 cuda::resize(d_src, d_dst, Size(), 2.0, 2.0);
574 cuda::resize(d_src, d_dst, Size(), 2.0, 2.0);
578 for (int size = 1000; size <= 3000; size += 1000)
580 SUBTEST << size << 'x' << size << ", 8UC4, down";
582 gen(src, size, size, CV_8UC4, 0, 256);
584 resize(src, dst, Size(), 0.5, 0.5);
587 resize(src, dst, Size(), 0.5, 0.5);
592 cuda::resize(d_src, d_dst, Size(), 0.5, 0.5);
595 cuda::resize(d_src, d_dst, Size(), 0.5, 0.5);
604 cuda::GpuMat d_src, d_dst;
606 gen(src, 4000, 4000, CV_8UC1, 0, 255);
609 SUBTEST << "4000x4000, 8UC1, COLOR_GRAY2BGRA";
611 cvtColor(src, dst, COLOR_GRAY2BGRA, 4);
614 cvtColor(src, dst, COLOR_GRAY2BGRA, 4);
617 cuda::cvtColor(d_src, d_dst, COLOR_GRAY2BGRA, 4);
620 cuda::cvtColor(d_src, d_dst, COLOR_GRAY2BGRA, 4);
626 SUBTEST << "4000x4000, 8UC3 vs 8UC4, COLOR_BGR2YCrCb";
628 cvtColor(src, dst, COLOR_BGR2YCrCb);
631 cvtColor(src, dst, COLOR_BGR2YCrCb);
634 cuda::cvtColor(d_src, d_dst, COLOR_BGR2YCrCb, 4);
637 cuda::cvtColor(d_src, d_dst, COLOR_BGR2YCrCb, 4);
643 SUBTEST << "4000x4000, 8UC4, COLOR_YCrCb2BGR";
645 cvtColor(src, dst, COLOR_YCrCb2BGR, 4);
648 cvtColor(src, dst, COLOR_YCrCb2BGR, 4);
651 cuda::cvtColor(d_src, d_dst, COLOR_YCrCb2BGR, 4);
654 cuda::cvtColor(d_src, d_dst, COLOR_YCrCb2BGR, 4);
660 SUBTEST << "4000x4000, 8UC3 vs 8UC4, COLOR_BGR2XYZ";
662 cvtColor(src, dst, COLOR_BGR2XYZ);
665 cvtColor(src, dst, COLOR_BGR2XYZ);
668 cuda::cvtColor(d_src, d_dst, COLOR_BGR2XYZ, 4);
671 cuda::cvtColor(d_src, d_dst, COLOR_BGR2XYZ, 4);
677 SUBTEST << "4000x4000, 8UC4, COLOR_XYZ2BGR";
679 cvtColor(src, dst, COLOR_XYZ2BGR, 4);
682 cvtColor(src, dst, COLOR_XYZ2BGR, 4);
685 cuda::cvtColor(d_src, d_dst, COLOR_XYZ2BGR, 4);
688 cuda::cvtColor(d_src, d_dst, COLOR_XYZ2BGR, 4);
694 SUBTEST << "4000x4000, 8UC3 vs 8UC4, COLOR_BGR2HSV";
696 cvtColor(src, dst, COLOR_BGR2HSV);
699 cvtColor(src, dst, COLOR_BGR2HSV);
702 cuda::cvtColor(d_src, d_dst, COLOR_BGR2HSV, 4);
705 cuda::cvtColor(d_src, d_dst, COLOR_BGR2HSV, 4);
711 SUBTEST << "4000x4000, 8UC4, COLOR_HSV2BGR";
713 cvtColor(src, dst, COLOR_HSV2BGR, 4);
716 cvtColor(src, dst, COLOR_HSV2BGR, 4);
719 cuda::cvtColor(d_src, d_dst, COLOR_HSV2BGR, 4);
722 cuda::cvtColor(d_src, d_dst, COLOR_HSV2BGR, 4);
733 cuda::GpuMat d_src, d_buf, d_dst;
735 for (int size = 2000; size <= 4000; size += 1000)
737 SUBTEST << size << 'x' << size;
739 gen(src, size, size, CV_8UC4, Scalar::all(0), Scalar::all(256));
740 ker = getStructuringElement(MORPH_RECT, Size(3, 3));
742 erode(src, dst, ker);
745 erode(src, dst, ker);
750 Ptr<cuda::Filter> erode = cuda::createMorphologyFilter(MORPH_ERODE, d_src.type(), ker);
752 erode->apply(d_src, d_dst);
755 erode->apply(d_src, d_dst);
763 cuda::GpuMat d_src, d_dst;
765 for (int size = 2000; size <= 4000; size += 1000)
767 SUBTEST << size << 'x' << size << ", 8UC1, THRESH_BINARY";
769 gen(src, size, size, CV_8U, 0, 100);
771 threshold(src, dst, 50.0, 0.0, THRESH_BINARY);
774 threshold(src, dst, 50.0, 0.0, THRESH_BINARY);
779 cuda::threshold(d_src, d_dst, 50.0, 0.0, THRESH_BINARY);
782 cuda::threshold(d_src, d_dst, 50.0, 0.0, THRESH_BINARY);
786 for (int size = 2000; size <= 4000; size += 1000)
788 SUBTEST << size << 'x' << size << ", 32FC1, THRESH_TRUNC [NPP]";
790 gen(src, size, size, CV_32FC1, 0, 100);
792 threshold(src, dst, 50.0, 0.0, THRESH_TRUNC);
795 threshold(src, dst, 50.0, 0.0, THRESH_TRUNC);
800 cuda::threshold(d_src, d_dst, 50.0, 0.0, THRESH_TRUNC);
803 cuda::threshold(d_src, d_dst, 50.0, 0.0, THRESH_TRUNC);
811 cuda::GpuMat d_src, d_dst;
813 for (int size = 1000; size <= 4000; size += 1000)
815 SUBTEST << size << 'x' << size << ", 32F";
817 gen(src, size, size, CV_32F, 0, 100);
827 cuda::pow(d_src, -2.0, d_dst);
830 cuda::pow(d_src, -2.0, d_dst);
840 cuda::GpuMat d_src, d_dst;
842 Mat rvec; gen(rvec, 1, 3, CV_32F, 0, 1);
843 Mat tvec; gen(tvec, 1, 3, CV_32F, 0, 1);
844 Mat camera_mat; gen(camera_mat, 3, 3, CV_32F, 0, 1);
845 camera_mat.at<float>(0, 1) = 0.f;
846 camera_mat.at<float>(1, 0) = 0.f;
847 camera_mat.at<float>(2, 0) = 0.f;
848 camera_mat.at<float>(2, 1) = 0.f;
850 for (int size = (int)1e6, count = 0; size >= 1e5 && count < 5; size = int(size / 1.4), count++)
854 gen(src, 1, size, CV_32FC3, Scalar::all(0), Scalar::all(10));
856 projectPoints(src, rvec, tvec, camera_mat, Mat::zeros(1, 8, CV_32F), dst);
859 projectPoints(src, rvec, tvec, camera_mat, Mat::zeros(1, 8, CV_32F), dst);
864 cuda::projectPoints(d_src, rvec, tvec, camera_mat, Mat(), d_dst);
867 cuda::projectPoints(d_src, rvec, tvec, camera_mat, Mat(), d_dst);
873 static void InitSolvePnpRansac()
875 Mat object; gen(object, 1, 4, CV_32FC3, Scalar::all(0), Scalar::all(100));
876 Mat image; gen(image, 1, 4, CV_32FC2, Scalar::all(0), Scalar::all(100));
878 cuda::solvePnPRansac(object, image, Mat::eye(3, 3, CV_32F), Mat(), rvec, tvec);
884 InitSolvePnpRansac();
886 for (int num_points = 5000; num_points <= 300000; num_points = int(num_points * 3.76))
888 SUBTEST << num_points;
890 Mat object; gen(object, 1, num_points, CV_32FC3, Scalar::all(10), Scalar::all(100));
891 Mat image; gen(image, 1, num_points, CV_32FC2, Scalar::all(10), Scalar::all(100));
892 Mat camera_mat; gen(camera_mat, 3, 3, CV_32F, 0.5, 1);
893 camera_mat.at<float>(0, 1) = 0.f;
894 camera_mat.at<float>(1, 0) = 0.f;
895 camera_mat.at<float>(2, 0) = 0.f;
896 camera_mat.at<float>(2, 1) = 0.f;
899 const int num_iters = 200;
900 const float max_dist = 2.0f;
901 vector<int> inliers_cpu, inliers_gpu;
904 solvePnPRansac(object, image, camera_mat, Mat::zeros(1, 8, CV_32F), rvec, tvec, false, num_iters,
905 max_dist, int(num_points * 0.05), inliers_cpu);
909 cuda::solvePnPRansac(object, image, camera_mat, Mat::zeros(1, 8, CV_32F), rvec, tvec, false, num_iters,
910 max_dist, int(num_points * 0.05), &inliers_gpu);
917 for (int size = 1000; size <= 4000; size += 1000)
919 SUBTEST << size << 'x' << size << ", 8UC4";
923 gen(src, size, size, CV_8UC4, 0, 256);
925 GaussianBlur(src, dst, Size(3, 3), 1);
928 GaussianBlur(src, dst, Size(3, 3), 1);
931 cuda::GpuMat d_src(src);
932 cuda::GpuMat d_dst(src.size(), src.type());
935 cv::Ptr<cv::cuda::Filter> gauss = cv::cuda::createGaussianFilter(d_src.type(), -1, cv::Size(3, 3), 1);
937 gauss->apply(d_src, d_dst);
940 gauss->apply(d_src, d_dst);
947 for (int size = 512; size <= 2048; size *= 2)
950 gen(src, size, size, CV_8UC4, 0, 256);
952 for (int ksize = 3; ksize <= 16; ksize += 2)
954 SUBTEST << "ksize = " << ksize << ", " << size << 'x' << size << ", 8UC4";
957 gen(kernel, ksize, ksize, CV_32FC1, 0.0, 1.0);
960 cv::filter2D(src, dst, -1, kernel);
963 cv::filter2D(src, dst, -1, kernel);
966 cuda::GpuMat d_src(src);
969 Ptr<cuda::Filter> filter2D = cuda::createLinearFilter(d_src.type(), -1, kernel);
970 filter2D->apply(d_src, d_dst);
973 filter2D->apply(d_src, d_dst);
981 for (int size = 4000; size >= 1000; size -= 1000)
983 SUBTEST << size << 'x' << size << ", 8UC4";
986 gen(src, size, size, CV_8UC4, 0, 256);
994 cuda::GpuMat d_src(src);
997 cuda::pyrDown(d_src, d_dst);
1000 cuda::pyrDown(d_src, d_dst);
1007 for (int size = 2000; size >= 1000; size -= 1000)
1009 SUBTEST << size << 'x' << size << ", 8UC4";
1013 gen(src, size, size, CV_8UC4, 0, 256);
1021 cuda::GpuMat d_src(src);
1024 cuda::pyrUp(d_src, d_dst);
1027 cuda::pyrUp(d_src, d_dst);
1035 for (int size = 1000; size < 4000; size += 1000)
1037 SUBTEST << size << 'x' << size;
1041 gen(src, size, size, CV_8UC1, 0, 256);
1043 equalizeHist(src, dst);
1046 equalizeHist(src, dst);
1049 cuda::GpuMat d_src(src);
1053 cuda::equalizeHist(d_src, d_dst, d_buf);
1056 cuda::equalizeHist(d_src, d_dst, d_buf);
1064 Mat img = imread(abspath("aloeL.jpg"), IMREAD_GRAYSCALE);
1066 if (img.empty()) throw runtime_error("can't open aloeL.jpg");
1068 Mat edges(img.size(), CV_8UC1);
1071 Canny(img, edges, 50.0, 100.0);
1074 cuda::GpuMat d_img(img);
1075 cuda::GpuMat d_edges;
1077 Ptr<cuda::CannyEdgeDetector> canny = cuda::createCannyEdgeDetector(50.0, 100.0);
1079 canny->detect(d_img, d_edges);
1082 canny->detect(d_img, d_edges);
1089 for (int size = 1000; size < 4000; size += 1000)
1092 gen(src, size, size, CV_32F, 0, 255);
1097 cuda::GpuMat d_src(src);
1098 cuda::GpuMat d_dst0;
1099 cuda::GpuMat d_dst1;
1101 SUBTEST << size << 'x' << size << ", dim = 0";
1103 reduce(src, dst0, 0, REDUCE_MIN);
1106 reduce(src, dst0, 0, REDUCE_MIN);
1109 cuda::reduce(d_src, d_dst0, 0, REDUCE_MIN);
1112 cuda::reduce(d_src, d_dst0, 0, REDUCE_MIN);
1115 SUBTEST << size << 'x' << size << ", dim = 1";
1117 reduce(src, dst1, 1, REDUCE_MIN);
1120 reduce(src, dst1, 1, REDUCE_MIN);
1123 cuda::reduce(d_src, d_dst1, 1, REDUCE_MIN);
1126 cuda::reduce(d_src, d_dst1, 1, REDUCE_MIN);
1134 Mat src1, src2, src3, dst;
1135 cuda::GpuMat d_src1, d_src2, d_src3, d_dst;
1137 for (int size = 512; size <= 1024; size *= 2)
1139 SUBTEST << size << 'x' << size;
1141 gen(src1, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10));
1142 gen(src2, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10));
1143 gen(src3, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10));
1145 gemm(src1, src2, 1.0, src3, 1.0, dst);
1148 gemm(src1, src2, 1.0, src3, 1.0, dst);
1151 d_src1.upload(src1);
1152 d_src2.upload(src2);
1153 d_src3.upload(src3);
1155 cuda::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
1158 cuda::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
1163 TEST(GoodFeaturesToTrack)
1165 Mat src = imread(abspath("aloeL.jpg"), IMREAD_GRAYSCALE);
1166 if (src.empty()) throw runtime_error("can't open aloeL.jpg");
1168 vector<Point2f> pts;
1170 goodFeaturesToTrack(src, pts, 8000, 0.01, 0.0);
1173 goodFeaturesToTrack(src, pts, 8000, 0.01, 0.0);
1176 Ptr<cuda::CornersDetector> detector = cuda::createGoodFeaturesToTrackDetector(src.type(), 8000, 0.01, 0.0);
1178 cuda::GpuMat d_src(src);
1181 detector->detect(d_src, d_pts);
1184 detector->detect(d_src, d_pts);
1188 TEST(PyrLKOpticalFlow)
1190 Mat frame0 = imread(abspath("rubberwhale1.png"));
1191 if (frame0.empty()) throw runtime_error("can't open rubberwhale1.png");
1193 Mat frame1 = imread(abspath("rubberwhale2.png"));
1194 if (frame1.empty()) throw runtime_error("can't open rubberwhale2.png");
1197 cvtColor(frame0, gray_frame, COLOR_BGR2GRAY);
1199 for (int points = 1000; points <= 8000; points *= 2)
1203 vector<Point2f> pts;
1204 goodFeaturesToTrack(gray_frame, pts, points, 0.01, 0.0);
1206 vector<Point2f> nextPts;
1207 vector<unsigned char> status;
1211 calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, err);
1214 calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, err);
1217 cuda::PyrLKOpticalFlow d_pyrLK;
1219 cuda::GpuMat d_frame0(frame0);
1220 cuda::GpuMat d_frame1(frame1);
1223 Mat pts_mat(1, (int)pts.size(), CV_32FC2, (void*)&pts[0]);
1224 d_pts.upload(pts_mat);
1226 cuda::GpuMat d_nextPts;
1227 cuda::GpuMat d_status;
1230 d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err);
1233 d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err);
1239 TEST(FarnebackOpticalFlow)
1241 const string datasets[] = {"rubberwhale", "basketball"};
1242 for (size_t i = 0; i < sizeof(datasets)/sizeof(*datasets); ++i) {
1243 for (int fastPyramids = 0; fastPyramids < 2; ++fastPyramids) {
1244 for (int useGaussianBlur = 0; useGaussianBlur < 2; ++useGaussianBlur) {
1246 SUBTEST << "dataset=" << datasets[i] << ", fastPyramids=" << fastPyramids << ", useGaussianBlur=" << useGaussianBlur;
1247 Mat frame0 = imread(abspath(datasets[i] + "1.png"), IMREAD_GRAYSCALE);
1248 Mat frame1 = imread(abspath(datasets[i] + "2.png"), IMREAD_GRAYSCALE);
1249 if (frame0.empty()) throw runtime_error("can't open " + datasets[i] + "1.png");
1250 if (frame1.empty()) throw runtime_error("can't open " + datasets[i] + "2.png");
1252 cuda::FarnebackOpticalFlow calc;
1253 calc.fastPyramids = fastPyramids != 0;
1254 calc.flags |= useGaussianBlur ? OPTFLOW_FARNEBACK_GAUSSIAN : 0;
1256 cuda::GpuMat d_frame0(frame0), d_frame1(frame1), d_flowx, d_flowy;
1258 calc(d_frame0, d_frame1, d_flowx, d_flowy);
1263 calcOpticalFlowFarneback(frame0, frame1, flow, calc.pyrScale, calc.numLevels, calc.winSize, calc.numIters, calc.polyN, calc.polySigma, calc.flags);
1271 const std::string inputFile = abspath("768x576.avi");
1273 cv::VideoCapture cap(inputFile);
1274 if (!cap.isOpened()) throw runtime_error("can't open 768x576.avi");
1279 cv::Ptr<cv::BackgroundSubtractor> mog = cv::createBackgroundSubtractorMOG();
1282 mog->apply(frame, foreground, 0.01);
1284 while (!TestSystem::instance().stop())
1288 TestSystem::instance().cpuOn();
1290 mog->apply(frame, foreground, 0.01);
1292 TestSystem::instance().cpuOff();
1294 TestSystem::instance().cpuComplete();
1296 cap.open(inputFile);
1300 cv::cuda::GpuMat d_frame(frame);
1301 cv::Ptr<cv::BackgroundSubtractor> d_mog = cv::cuda::createBackgroundSubtractorMOG();
1302 cv::cuda::GpuMat d_foreground;
1304 d_mog->apply(d_frame, d_foreground, 0.01);
1306 while (!TestSystem::instance().stop())
1309 d_frame.upload(frame);
1311 TestSystem::instance().gpuOn();
1313 d_mog->apply(d_frame, d_foreground, 0.01);
1315 TestSystem::instance().gpuOff();
1317 TestSystem::instance().gpuComplete();
1322 const std::string inputFile = abspath("768x576.avi");
1324 cv::VideoCapture cap(inputFile);
1325 if (!cap.isOpened()) throw runtime_error("can't open 768x576.avi");
1330 cv::Ptr<cv::BackgroundSubtractor> mog2 = cv::createBackgroundSubtractorMOG2();
1334 mog2->apply(frame, foreground);
1335 mog2->getBackgroundImage(background);
1337 while (!TestSystem::instance().stop())
1341 TestSystem::instance().cpuOn();
1343 mog2->apply(frame, foreground);
1344 mog2->getBackgroundImage(background);
1346 TestSystem::instance().cpuOff();
1348 TestSystem::instance().cpuComplete();
1350 cap.open(inputFile);
1354 cv::Ptr<cv::BackgroundSubtractor> d_mog2 = cv::cuda::createBackgroundSubtractorMOG2();
1355 cv::cuda::GpuMat d_frame(frame);
1356 cv::cuda::GpuMat d_foreground;
1357 cv::cuda::GpuMat d_background;
1359 d_mog2->apply(d_frame, d_foreground);
1360 d_mog2->getBackgroundImage(d_background);
1362 while (!TestSystem::instance().stop())
1365 d_frame.upload(frame);
1367 TestSystem::instance().gpuOn();
1369 d_mog2->apply(d_frame, d_foreground);
1370 d_mog2->getBackgroundImage(d_background);
1372 TestSystem::instance().gpuOff();
1374 TestSystem::instance().gpuComplete();