samples/gpu/performance/tests.cpp

   1 #include <stdexcept>
   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"
  14
  15 #include "performance.h"
  16
  17 #include "opencv2/opencv_modules.hpp"
  18
  19 #ifdef HAVE_OPENCV_XFEATURES2D
  20 #include "opencv2/xfeatures2d/cuda.hpp"
  21 #include "opencv2/xfeatures2d/nonfree.hpp"
  22 #endif
  23
  24 using namespace std;
  25 using namespace cv;
  26
  27
  28 TEST(matchTemplate)
  29 {
  30     Mat src, templ, dst;
  31     gen(src, 3000, 3000, CV_32F, 0, 1);
  32
  33     cuda::GpuMat d_src(src), d_templ, d_dst;
  34
  35     Ptr<cuda::TemplateMatching> alg = cuda::createTemplateMatching(src.type(), TM_CCORR);
  36
  37     for (int templ_size = 5; templ_size < 200; templ_size *= 5)
  38     {
  39         SUBTEST << src.cols << 'x' << src.rows << ", 32FC1" << ", templ " << templ_size << 'x' << templ_size << ", CCORR";
  40
  41         gen(templ, templ_size, templ_size, CV_32F, 0, 1);
  42         matchTemplate(src, templ, dst, TM_CCORR);
  43
  44         CPU_ON;
  45         matchTemplate(src, templ, dst, TM_CCORR);
  46         CPU_OFF;
  47
  48         d_templ.upload(templ);
  49         alg->match(d_src, d_templ, d_dst);
  50
  51         CUDA_ON;
  52         alg->match(d_src, d_templ, d_dst);
  53         CUDA_OFF;
  54     }
  55 }
  56
  57
  58 TEST(minMaxLoc)
  59 {
  60     Mat src;
  61     cuda::GpuMat d_src;
  62
  63     double min_val, max_val;
  64     Point min_loc, max_loc;
  65
  66     for (int size = 2000; size <= 8000; size *= 2)
  67     {
  68         SUBTEST << size << 'x' << size << ", 32F";
  69
  70         gen(src, size, size, CV_32F, 0, 1);
  71
  72         CPU_ON;
  73         minMaxLoc(src, &min_val, &max_val, &min_loc, &max_loc);
  74         CPU_OFF;
  75
  76         d_src.upload(src);
  77
  78         CUDA_ON;
  79         cuda::minMaxLoc(d_src, &min_val, &max_val, &min_loc, &max_loc);
  80         CUDA_OFF;
  81     }
  82 }
  83
  84
  85 TEST(remap)
  86 {
  87     Mat src, dst, xmap, ymap;
  88     cuda::GpuMat d_src, d_dst, d_xmap, d_ymap;
  89
  90     int interpolation = INTER_LINEAR;
  91     int borderMode = BORDER_REPLICATE;
  92
  93     for (int size = 1000; size <= 4000; size *= 2)
  94     {
  95         SUBTEST << size << 'x' << size << ", 8UC4, INTER_LINEAR, BORDER_REPLICATE";
  96
  97         gen(src, size, size, CV_8UC4, 0, 256);
  98
  99         xmap.create(size, size, CV_32F);
 100         ymap.create(size, size, CV_32F);
 101         for (int i = 0; i < size; ++i)
 102         {
 103             float* xmap_row = xmap.ptr<float>(i);
 104             float* ymap_row = ymap.ptr<float>(i);
 105             for (int j = 0; j < size; ++j)
 106             {
 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;
 109             }
 110         }
 111
 112         remap(src, dst, xmap, ymap, interpolation, borderMode);
 113
 114         CPU_ON;
 115         remap(src, dst, xmap, ymap, interpolation, borderMode);
 116         CPU_OFF;
 117
 118         d_src.upload(src);
 119         d_xmap.upload(xmap);
 120         d_ymap.upload(ymap);
 121
 122         cuda::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
 123
 124         CUDA_ON;
 125         cuda::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
 126         CUDA_OFF;
 127     }
 128 }
 129
 130
 131 TEST(dft)
 132 {
 133     Mat src, dst;
 134     cuda::GpuMat d_src, d_dst;
 135
 136     for (int size = 1000; size <= 4000; size *= 2)
 137     {
 138         SUBTEST << size << 'x' << size << ", 32FC2, complex-to-complex";
 139
 140         gen(src, size, size, CV_32FC2, Scalar::all(0), Scalar::all(1));
 141
 142         dft(src, dst);
 143
 144         CPU_ON;
 145         dft(src, dst);
 146         CPU_OFF;
 147
 148         d_src.upload(src);
 149
 150         cuda::dft(d_src, d_dst, Size(size, size));
 151
 152         CUDA_ON;
 153         cuda::dft(d_src, d_dst, Size(size, size));
 154         CUDA_OFF;
 155     }
 156 }
 157
 158
 159 TEST(cornerHarris)
 160 {
 161     Mat src, dst;
 162     cuda::GpuMat d_src, d_dst;
 163
 164     for (int size = 1000; size <= 4000; size *= 2)
 165     {
 166         SUBTEST << size << 'x' << size << ", 32FC1, BORDER_REFLECT101";
 167
 168         gen(src, size, size, CV_32F, 0, 1);
 169
 170         cornerHarris(src, dst, 5, 7, 0.1, BORDER_REFLECT101);
 171
 172         CPU_ON;
 173         cornerHarris(src, dst, 5, 7, 0.1, BORDER_REFLECT101);
 174         CPU_OFF;
 175
 176         d_src.upload(src);
 177
 178         Ptr<cuda::CornernessCriteria> harris = cuda::createHarrisCorner(src.type(), 5, 7, 0.1, BORDER_REFLECT101);
 179
 180         harris->compute(d_src, d_dst);
 181
 182         CUDA_ON;
 183         harris->compute(d_src, d_dst);
 184         CUDA_OFF;
 185     }
 186 }
 187
 188
 189 TEST(integral)
 190 {
 191     Mat src, sum;
 192     cuda::GpuMat d_src, d_sum, d_buf;
 193
 194     for (int size = 1000; size <= 4000; size *= 2)
 195     {
 196         SUBTEST << size << 'x' << size << ", 8UC1";
 197
 198         gen(src, size, size, CV_8U, 0, 256);
 199
 200         integral(src, sum);
 201
 202         CPU_ON;
 203         integral(src, sum);
 204         CPU_OFF;
 205
 206         d_src.upload(src);
 207
 208         cuda::integralBuffered(d_src, d_sum, d_buf);
 209
 210         CUDA_ON;
 211         cuda::integralBuffered(d_src, d_sum, d_buf);
 212         CUDA_OFF;
 213     }
 214 }
 215
 216
 217 TEST(norm)
 218 {
 219     Mat src;
 220     cuda::GpuMat d_src, d_buf;
 221
 222     for (int size = 2000; size <= 4000; size += 1000)
 223     {
 224         SUBTEST << size << 'x' << size << ", 32FC4, NORM_INF";
 225
 226         gen(src, size, size, CV_32FC4, Scalar::all(0), Scalar::all(1));
 227
 228         norm(src, NORM_INF);
 229
 230         CPU_ON;
 231         norm(src, NORM_INF);
 232         CPU_OFF;
 233
 234         d_src.upload(src);
 235
 236         cuda::norm(d_src, NORM_INF, d_buf);
 237
 238         CUDA_ON;
 239         cuda::norm(d_src, NORM_INF, d_buf);
 240         CUDA_OFF;
 241     }
 242 }
 243
 244
 245 TEST(meanShift)
 246 {
 247     int sp = 10, sr = 10;
 248
 249     Mat src, dst;
 250     cuda::GpuMat d_src, d_dst;
 251
 252     for (int size = 400; size <= 800; size *= 2)
 253     {
 254         SUBTEST << size << 'x' << size << ", 8UC3 vs 8UC4";
 255
 256         gen(src, size, size, CV_8UC3, Scalar::all(0), Scalar::all(256));
 257
 258         pyrMeanShiftFiltering(src, dst, sp, sr);
 259
 260         CPU_ON;
 261         pyrMeanShiftFiltering(src, dst, sp, sr);
 262         CPU_OFF;
 263
 264         gen(src, size, size, CV_8UC4, Scalar::all(0), Scalar::all(256));
 265
 266         d_src.upload(src);
 267
 268         cuda::meanShiftFiltering(d_src, d_dst, sp, sr);
 269
 270         CUDA_ON;
 271         cuda::meanShiftFiltering(d_src, d_dst, sp, sr);
 272         CUDA_OFF;
 273     }
 274 }
 275
 276 #ifdef HAVE_OPENCV_XFEATURES2D
 277
 278 TEST(SURF)
 279 {
 280     Mat src = imread(abspath("aloeL.jpg"), IMREAD_GRAYSCALE);
 281     if (src.empty()) throw runtime_error("can't open aloeL.jpg");
 282
 283     SURF surf;
 284     vector<KeyPoint> keypoints;
 285     Mat descriptors;
 286
 287     surf(src, Mat(), keypoints, descriptors);
 288
 289     CPU_ON;
 290     surf(src, Mat(), keypoints, descriptors);
 291     CPU_OFF;
 292
 293     cuda::SURF_CUDA d_surf;
 294     cuda::GpuMat d_src(src);
 295     cuda::GpuMat d_keypoints;
 296     cuda::GpuMat d_descriptors;
 297
 298     d_surf(d_src, cuda::GpuMat(), d_keypoints, d_descriptors);
 299
 300     CUDA_ON;
 301     d_surf(d_src, cuda::GpuMat(), d_keypoints, d_descriptors);
 302     CUDA_OFF;
 303 }
 304
 305 #endif
 306
 307
 308 TEST(FAST)
 309 {
 310     Mat src = imread(abspath("aloeL.jpg"), IMREAD_GRAYSCALE);
 311     if (src.empty()) throw runtime_error("can't open aloeL.jpg");
 312
 313     vector<KeyPoint> keypoints;
 314
 315     FAST(src, keypoints, 20);
 316
 317     CPU_ON;
 318     FAST(src, keypoints, 20);
 319     CPU_OFF;
 320
 321     cuda::FAST_CUDA d_FAST(20);
 322     cuda::GpuMat d_src(src);
 323     cuda::GpuMat d_keypoints;
 324
 325     d_FAST(d_src, cuda::GpuMat(), d_keypoints);
 326
 327     CUDA_ON;
 328     d_FAST(d_src, cuda::GpuMat(), d_keypoints);
 329     CUDA_OFF;
 330 }
 331
 332
 333 TEST(ORB)
 334 {
 335     Mat src = imread(abspath("aloeL.jpg"), IMREAD_GRAYSCALE);
 336     if (src.empty()) throw runtime_error("can't open aloeL.jpg");
 337
 338     ORB orb(4000);
 339     vector<KeyPoint> keypoints;
 340     Mat descriptors;
 341
 342     orb(src, Mat(), keypoints, descriptors);
 343
 344     CPU_ON;
 345     orb(src, Mat(), keypoints, descriptors);
 346     CPU_OFF;
 347
 348     cuda::ORB_CUDA d_orb;
 349     cuda::GpuMat d_src(src);
 350     cuda::GpuMat d_keypoints;
 351     cuda::GpuMat d_descriptors;
 352
 353     d_orb(d_src, cuda::GpuMat(), d_keypoints, d_descriptors);
 354
 355     CUDA_ON;
 356     d_orb(d_src, cuda::GpuMat(), d_keypoints, d_descriptors);
 357     CUDA_OFF;
 358 }
 359
 360
 361 TEST(BruteForceMatcher)
 362 {
 363     // Init CPU matcher
 364
 365     int desc_len = 64;
 366
 367     BFMatcher matcher(NORM_L2);
 368
 369     Mat query;
 370     gen(query, 3000, desc_len, CV_32F, 0, 1);
 371
 372     Mat train;
 373     gen(train, 3000, desc_len, CV_32F, 0, 1);
 374
 375     // Init CUDA matcher
 376
 377     cuda::BFMatcher_CUDA d_matcher(NORM_L2);
 378
 379     cuda::GpuMat d_query(query);
 380     cuda::GpuMat d_train(train);
 381
 382     // Output
 383     vector< vector<DMatch> > matches(2);
 384     cuda::GpuMat d_trainIdx, d_distance, d_allDist, d_nMatches;
 385
 386     SUBTEST << "match";
 387
 388     matcher.match(query, train, matches[0]);
 389
 390     CPU_ON;
 391     matcher.match(query, train, matches[0]);
 392     CPU_OFF;
 393
 394     d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
 395
 396     CUDA_ON;
 397     d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
 398     CUDA_OFF;
 399
 400     SUBTEST << "knnMatch";
 401
 402     matcher.knnMatch(query, train, matches, 2);
 403
 404     CPU_ON;
 405     matcher.knnMatch(query, train, matches, 2);
 406     CPU_OFF;
 407
 408     d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, 2);
 409
 410     CUDA_ON;
 411     d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, 2);
 412     CUDA_OFF;
 413
 414     SUBTEST << "radiusMatch";
 415
 416     float max_distance = 2.0f;
 417
 418     matcher.radiusMatch(query, train, matches, max_distance);
 419
 420     CPU_ON;
 421     matcher.radiusMatch(query, train, matches, max_distance);
 422     CPU_OFF;
 423
 424     d_trainIdx.release();
 425
 426     d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, max_distance);
 427
 428     CUDA_ON;
 429     d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, max_distance);
 430     CUDA_OFF;
 431 }
 432
 433
 434 TEST(magnitude)
 435 {
 436     Mat x, y, mag;
 437     cuda::GpuMat d_x, d_y, d_mag;
 438
 439     for (int size = 2000; size <= 4000; size += 1000)
 440     {
 441         SUBTEST << size << 'x' << size << ", 32FC1";
 442
 443         gen(x, size, size, CV_32F, 0, 1);
 444         gen(y, size, size, CV_32F, 0, 1);
 445
 446         magnitude(x, y, mag);
 447
 448         CPU_ON;
 449         magnitude(x, y, mag);
 450         CPU_OFF;
 451
 452         d_x.upload(x);
 453         d_y.upload(y);
 454
 455         cuda::magnitude(d_x, d_y, d_mag);
 456
 457         CUDA_ON;
 458         cuda::magnitude(d_x, d_y, d_mag);
 459         CUDA_OFF;
 460     }
 461 }
 462
 463
 464 TEST(add)
 465 {
 466     Mat src1, src2, dst;
 467     cuda::GpuMat d_src1, d_src2, d_dst;
 468
 469     for (int size = 2000; size <= 4000; size += 1000)
 470     {
 471         SUBTEST << size << 'x' << size << ", 32FC1";
 472
 473         gen(src1, size, size, CV_32F, 0, 1);
 474         gen(src2, size, size, CV_32F, 0, 1);
 475
 476         add(src1, src2, dst);
 477
 478         CPU_ON;
 479         add(src1, src2, dst);
 480         CPU_OFF;
 481
 482         d_src1.upload(src1);
 483         d_src2.upload(src2);
 484
 485         cuda::add(d_src1, d_src2, d_dst);
 486
 487         CUDA_ON;
 488         cuda::add(d_src1, d_src2, d_dst);
 489         CUDA_OFF;
 490     }
 491 }
 492
 493
 494 TEST(log)
 495 {
 496     Mat src, dst;
 497     cuda::GpuMat d_src, d_dst;
 498
 499     for (int size = 2000; size <= 4000; size += 1000)
 500     {
 501         SUBTEST << size << 'x' << size << ", 32F";
 502
 503         gen(src, size, size, CV_32F, 1, 10);
 504
 505         log(src, dst);
 506
 507         CPU_ON;
 508         log(src, dst);
 509         CPU_OFF;
 510
 511         d_src.upload(src);
 512
 513         cuda::log(d_src, d_dst);
 514
 515         CUDA_ON;
 516         cuda::log(d_src, d_dst);
 517         CUDA_OFF;
 518     }
 519 }
 520
 521
 522 TEST(mulSpectrums)
 523 {
 524     Mat src1, src2, dst;
 525     cuda::GpuMat d_src1, d_src2, d_dst;
 526
 527     for (int size = 2000; size <= 4000; size += 1000)
 528     {
 529         SUBTEST << size << 'x' << size;
 530
 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));
 533
 534         mulSpectrums(src1, src2, dst, 0, true);
 535
 536         CPU_ON;
 537         mulSpectrums(src1, src2, dst, 0, true);
 538         CPU_OFF;
 539
 540         d_src1.upload(src1);
 541         d_src2.upload(src2);
 542
 543         cuda::mulSpectrums(d_src1, d_src2, d_dst, 0, true);
 544
 545         CUDA_ON;
 546         cuda::mulSpectrums(d_src1, d_src2, d_dst, 0, true);
 547         CUDA_OFF;
 548     }
 549 }
 550
 551
 552 TEST(resize)
 553 {
 554     Mat src, dst;
 555     cuda::GpuMat d_src, d_dst;
 556
 557     for (int size = 1000; size <= 3000; size += 1000)
 558     {
 559         SUBTEST << size << 'x' << size << ", 8UC4, up";
 560
 561         gen(src, size, size, CV_8UC4, 0, 256);
 562
 563         resize(src, dst, Size(), 2.0, 2.0);
 564
 565         CPU_ON;
 566         resize(src, dst, Size(), 2.0, 2.0);
 567         CPU_OFF;
 568
 569         d_src.upload(src);
 570
 571         cuda::resize(d_src, d_dst, Size(), 2.0, 2.0);
 572
 573         CUDA_ON;
 574         cuda::resize(d_src, d_dst, Size(), 2.0, 2.0);
 575         CUDA_OFF;
 576     }
 577
 578     for (int size = 1000; size <= 3000; size += 1000)
 579     {
 580         SUBTEST << size << 'x' << size << ", 8UC4, down";
 581
 582         gen(src, size, size, CV_8UC4, 0, 256);
 583
 584         resize(src, dst, Size(), 0.5, 0.5);
 585
 586         CPU_ON;
 587         resize(src, dst, Size(), 0.5, 0.5);
 588         CPU_OFF;
 589
 590         d_src.upload(src);
 591
 592         cuda::resize(d_src, d_dst, Size(), 0.5, 0.5);
 593
 594         CUDA_ON;
 595         cuda::resize(d_src, d_dst, Size(), 0.5, 0.5);
 596         CUDA_OFF;
 597     }
 598 }
 599
 600
 601 TEST(cvtColor)
 602 {
 603     Mat src, dst;
 604     cuda::GpuMat d_src, d_dst;
 605
 606     gen(src, 4000, 4000, CV_8UC1, 0, 255);
 607     d_src.upload(src);
 608
 609     SUBTEST << "4000x4000, 8UC1, COLOR_GRAY2BGRA";
 610
 611     cvtColor(src, dst, COLOR_GRAY2BGRA, 4);
 612
 613     CPU_ON;
 614     cvtColor(src, dst, COLOR_GRAY2BGRA, 4);
 615     CPU_OFF;
 616
 617     cuda::cvtColor(d_src, d_dst, COLOR_GRAY2BGRA, 4);
 618
 619     CUDA_ON;
 620     cuda::cvtColor(d_src, d_dst, COLOR_GRAY2BGRA, 4);
 621     CUDA_OFF;
 622
 623     cv::swap(src, dst);
 624     d_src.swap(d_dst);
 625
 626     SUBTEST << "4000x4000, 8UC3 vs 8UC4, COLOR_BGR2YCrCb";
 627
 628     cvtColor(src, dst, COLOR_BGR2YCrCb);
 629
 630     CPU_ON;
 631     cvtColor(src, dst, COLOR_BGR2YCrCb);
 632     CPU_OFF;
 633
 634     cuda::cvtColor(d_src, d_dst, COLOR_BGR2YCrCb, 4);
 635
 636     CUDA_ON;
 637     cuda::cvtColor(d_src, d_dst, COLOR_BGR2YCrCb, 4);
 638     CUDA_OFF;
 639
 640     cv::swap(src, dst);
 641     d_src.swap(d_dst);
 642
 643     SUBTEST << "4000x4000, 8UC4, COLOR_YCrCb2BGR";
 644
 645     cvtColor(src, dst, COLOR_YCrCb2BGR, 4);
 646
 647     CPU_ON;
 648     cvtColor(src, dst, COLOR_YCrCb2BGR, 4);
 649     CPU_OFF;
 650
 651     cuda::cvtColor(d_src, d_dst, COLOR_YCrCb2BGR, 4);
 652
 653     CUDA_ON;
 654     cuda::cvtColor(d_src, d_dst, COLOR_YCrCb2BGR, 4);
 655     CUDA_OFF;
 656
 657     cv::swap(src, dst);
 658     d_src.swap(d_dst);
 659
 660     SUBTEST << "4000x4000, 8UC3 vs 8UC4, COLOR_BGR2XYZ";
 661
 662     cvtColor(src, dst, COLOR_BGR2XYZ);
 663
 664     CPU_ON;
 665     cvtColor(src, dst, COLOR_BGR2XYZ);
 666     CPU_OFF;
 667
 668     cuda::cvtColor(d_src, d_dst, COLOR_BGR2XYZ, 4);
 669
 670     CUDA_ON;
 671     cuda::cvtColor(d_src, d_dst, COLOR_BGR2XYZ, 4);
 672     CUDA_OFF;
 673
 674     cv::swap(src, dst);
 675     d_src.swap(d_dst);
 676
 677     SUBTEST << "4000x4000, 8UC4, COLOR_XYZ2BGR";
 678
 679     cvtColor(src, dst, COLOR_XYZ2BGR, 4);
 680
 681     CPU_ON;
 682     cvtColor(src, dst, COLOR_XYZ2BGR, 4);
 683     CPU_OFF;
 684
 685     cuda::cvtColor(d_src, d_dst, COLOR_XYZ2BGR, 4);
 686
 687     CUDA_ON;
 688     cuda::cvtColor(d_src, d_dst, COLOR_XYZ2BGR, 4);
 689     CUDA_OFF;
 690
 691     cv::swap(src, dst);
 692     d_src.swap(d_dst);
 693
 694     SUBTEST << "4000x4000, 8UC3 vs 8UC4, COLOR_BGR2HSV";
 695
 696     cvtColor(src, dst, COLOR_BGR2HSV);
 697
 698     CPU_ON;
 699     cvtColor(src, dst, COLOR_BGR2HSV);
 700     CPU_OFF;
 701
 702     cuda::cvtColor(d_src, d_dst, COLOR_BGR2HSV, 4);
 703
 704     CUDA_ON;
 705     cuda::cvtColor(d_src, d_dst, COLOR_BGR2HSV, 4);
 706     CUDA_OFF;
 707
 708     cv::swap(src, dst);
 709     d_src.swap(d_dst);
 710
 711     SUBTEST << "4000x4000, 8UC4, COLOR_HSV2BGR";
 712
 713     cvtColor(src, dst, COLOR_HSV2BGR, 4);
 714
 715     CPU_ON;
 716     cvtColor(src, dst, COLOR_HSV2BGR, 4);
 717     CPU_OFF;
 718
 719     cuda::cvtColor(d_src, d_dst, COLOR_HSV2BGR, 4);
 720
 721     CUDA_ON;
 722     cuda::cvtColor(d_src, d_dst, COLOR_HSV2BGR, 4);
 723     CUDA_OFF;
 724
 725     cv::swap(src, dst);
 726     d_src.swap(d_dst);
 727 }
 728
 729
 730 TEST(erode)
 731 {
 732     Mat src, dst, ker;
 733     cuda::GpuMat d_src, d_buf, d_dst;
 734
 735     for (int size = 2000; size <= 4000; size += 1000)
 736     {
 737         SUBTEST << size << 'x' << size;
 738
 739         gen(src, size, size, CV_8UC4, Scalar::all(0), Scalar::all(256));
 740         ker = getStructuringElement(MORPH_RECT, Size(3, 3));
 741
 742         erode(src, dst, ker);
 743
 744         CPU_ON;
 745         erode(src, dst, ker);
 746         CPU_OFF;
 747
 748         d_src.upload(src);
 749
 750         Ptr<cuda::Filter> erode = cuda::createMorphologyFilter(MORPH_ERODE, d_src.type(), ker);
 751
 752         erode->apply(d_src, d_dst);
 753
 754         CUDA_ON;
 755         erode->apply(d_src, d_dst);
 756         CUDA_OFF;
 757     }
 758 }
 759
 760 TEST(threshold)
 761 {
 762     Mat src, dst;
 763     cuda::GpuMat d_src, d_dst;
 764
 765     for (int size = 2000; size <= 4000; size += 1000)
 766     {
 767         SUBTEST << size << 'x' << size << ", 8UC1, THRESH_BINARY";
 768
 769         gen(src, size, size, CV_8U, 0, 100);
 770
 771         threshold(src, dst, 50.0, 0.0, THRESH_BINARY);
 772
 773         CPU_ON;
 774         threshold(src, dst, 50.0, 0.0, THRESH_BINARY);
 775         CPU_OFF;
 776
 777         d_src.upload(src);
 778
 779         cuda::threshold(d_src, d_dst, 50.0, 0.0, THRESH_BINARY);
 780
 781         CUDA_ON;
 782         cuda::threshold(d_src, d_dst, 50.0, 0.0, THRESH_BINARY);
 783         CUDA_OFF;
 784     }
 785
 786     for (int size = 2000; size <= 4000; size += 1000)
 787     {
 788         SUBTEST << size << 'x' << size << ", 32FC1, THRESH_TRUNC [NPP]";
 789
 790         gen(src, size, size, CV_32FC1, 0, 100);
 791
 792         threshold(src, dst, 50.0, 0.0, THRESH_TRUNC);
 793
 794         CPU_ON;
 795         threshold(src, dst, 50.0, 0.0, THRESH_TRUNC);
 796         CPU_OFF;
 797
 798         d_src.upload(src);
 799
 800         cuda::threshold(d_src, d_dst, 50.0, 0.0, THRESH_TRUNC);
 801
 802         CUDA_ON;
 803         cuda::threshold(d_src, d_dst, 50.0, 0.0, THRESH_TRUNC);
 804         CUDA_OFF;
 805     }
 806 }
 807
 808 TEST(pow)
 809 {
 810     Mat src, dst;
 811     cuda::GpuMat d_src, d_dst;
 812
 813     for (int size = 1000; size <= 4000; size += 1000)
 814     {
 815         SUBTEST << size << 'x' << size << ", 32F";
 816
 817         gen(src, size, size, CV_32F, 0, 100);
 818
 819         pow(src, -2.0, dst);
 820
 821         CPU_ON;
 822         pow(src, -2.0, dst);
 823         CPU_OFF;
 824
 825         d_src.upload(src);
 826
 827         cuda::pow(d_src, -2.0, d_dst);
 828
 829         CUDA_ON;
 830         cuda::pow(d_src, -2.0, d_dst);
 831         CUDA_OFF;
 832     }
 833 }
 834
 835
 836 TEST(projectPoints)
 837 {
 838     Mat src;
 839     vector<Point2f> dst;
 840     cuda::GpuMat d_src, d_dst;
 841
 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;
 849
 850     for (int size = (int)1e6, count = 0; size >= 1e5 && count < 5; size = int(size / 1.4), count++)
 851     {
 852         SUBTEST << size;
 853
 854         gen(src, 1, size, CV_32FC3, Scalar::all(0), Scalar::all(10));
 855
 856         projectPoints(src, rvec, tvec, camera_mat, Mat::zeros(1, 8, CV_32F), dst);
 857
 858         CPU_ON;
 859         projectPoints(src, rvec, tvec, camera_mat, Mat::zeros(1, 8, CV_32F), dst);
 860         CPU_OFF;
 861
 862         d_src.upload(src);
 863
 864         cuda::projectPoints(d_src, rvec, tvec, camera_mat, Mat(), d_dst);
 865
 866         CUDA_ON;
 867         cuda::projectPoints(d_src, rvec, tvec, camera_mat, Mat(), d_dst);
 868         CUDA_OFF;
 869     }
 870 }
 871
 872
 873 static void InitSolvePnpRansac()
 874 {
 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));
 877     Mat rvec, tvec;
 878     cuda::solvePnPRansac(object, image, Mat::eye(3, 3, CV_32F), Mat(), rvec, tvec);
 879 }
 880
 881
 882 TEST(solvePnPRansac)
 883 {
 884     InitSolvePnpRansac();
 885
 886     for (int num_points = 5000; num_points <= 300000; num_points = int(num_points * 3.76))
 887     {
 888         SUBTEST << num_points;
 889
 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;
 897
 898         Mat rvec, tvec;
 899         const int num_iters = 200;
 900         const float max_dist = 2.0f;
 901         vector<int> inliers_cpu, inliers_gpu;
 902
 903         CPU_ON;
 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);
 906         CPU_OFF;
 907
 908         CUDA_ON;
 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);
 911         CUDA_OFF;
 912     }
 913 }
 914
 915 TEST(GaussianBlur)
 916 {
 917     for (int size = 1000; size <= 4000; size += 1000)
 918     {
 919         SUBTEST << size << 'x' << size << ", 8UC4";
 920
 921         Mat src, dst;
 922
 923         gen(src, size, size, CV_8UC4, 0, 256);
 924
 925         GaussianBlur(src, dst, Size(3, 3), 1);
 926
 927         CPU_ON;
 928         GaussianBlur(src, dst, Size(3, 3), 1);
 929         CPU_OFF;
 930
 931         cuda::GpuMat d_src(src);
 932         cuda::GpuMat d_dst(src.size(), src.type());
 933         cuda::GpuMat d_buf;
 934
 935         cv::Ptr<cv::cuda::Filter> gauss = cv::cuda::createGaussianFilter(d_src.type(), -1, cv::Size(3, 3), 1);
 936
 937         gauss->apply(d_src, d_dst);
 938
 939         CUDA_ON;
 940         gauss->apply(d_src, d_dst);
 941         CUDA_OFF;
 942     }
 943 }
 944
 945 TEST(filter2D)
 946 {
 947     for (int size = 512; size <= 2048; size *= 2)
 948     {
 949         Mat src;
 950         gen(src, size, size, CV_8UC4, 0, 256);
 951
 952         for (int ksize = 3; ksize <= 16; ksize += 2)
 953         {
 954             SUBTEST << "ksize = " << ksize << ", " << size << 'x' << size << ", 8UC4";
 955
 956             Mat kernel;
 957             gen(kernel, ksize, ksize, CV_32FC1, 0.0, 1.0);
 958
 959             Mat dst;
 960             cv::filter2D(src, dst, -1, kernel);
 961
 962             CPU_ON;
 963             cv::filter2D(src, dst, -1, kernel);
 964             CPU_OFF;
 965
 966             cuda::GpuMat d_src(src);
 967             cuda::GpuMat d_dst;
 968
 969             Ptr<cuda::Filter> filter2D = cuda::createLinearFilter(d_src.type(), -1, kernel);
 970             filter2D->apply(d_src, d_dst);
 971
 972             CUDA_ON;
 973             filter2D->apply(d_src, d_dst);
 974             CUDA_OFF;
 975         }
 976     }
 977 }
 978
 979 TEST(pyrDown)
 980 {
 981     for (int size = 4000; size >= 1000; size -= 1000)
 982     {
 983         SUBTEST << size << 'x' << size << ", 8UC4";
 984
 985         Mat src, dst;
 986         gen(src, size, size, CV_8UC4, 0, 256);
 987
 988         pyrDown(src, dst);
 989
 990         CPU_ON;
 991         pyrDown(src, dst);
 992         CPU_OFF;
 993
 994         cuda::GpuMat d_src(src);
 995         cuda::GpuMat d_dst;
 996
 997         cuda::pyrDown(d_src, d_dst);
 998
 999         CUDA_ON;
1000         cuda::pyrDown(d_src, d_dst);
1001         CUDA_OFF;
1002     }
1003 }
1004
1005 TEST(pyrUp)
1006 {
1007     for (int size = 2000; size >= 1000; size -= 1000)
1008     {
1009         SUBTEST << size << 'x' << size << ", 8UC4";
1010
1011         Mat src, dst;
1012
1013         gen(src, size, size, CV_8UC4, 0, 256);
1014
1015         pyrUp(src, dst);
1016
1017         CPU_ON;
1018         pyrUp(src, dst);
1019         CPU_OFF;
1020
1021         cuda::GpuMat d_src(src);
1022         cuda::GpuMat d_dst;
1023
1024         cuda::pyrUp(d_src, d_dst);
1025
1026         CUDA_ON;
1027         cuda::pyrUp(d_src, d_dst);
1028         CUDA_OFF;
1029     }
1030 }
1031
1032
1033 TEST(equalizeHist)
1034 {
1035     for (int size = 1000; size < 4000; size += 1000)
1036     {
1037         SUBTEST << size << 'x' << size;
1038
1039         Mat src, dst;
1040
1041         gen(src, size, size, CV_8UC1, 0, 256);
1042
1043         equalizeHist(src, dst);
1044
1045         CPU_ON;
1046         equalizeHist(src, dst);
1047         CPU_OFF;
1048
1049         cuda::GpuMat d_src(src);
1050         cuda::GpuMat d_dst;
1051         cuda::GpuMat d_buf;
1052
1053         cuda::equalizeHist(d_src, d_dst, d_buf);
1054
1055         CUDA_ON;
1056         cuda::equalizeHist(d_src, d_dst, d_buf);
1057         CUDA_OFF;
1058     }
1059 }
1060
1061
1062 TEST(Canny)
1063 {
1064     Mat img = imread(abspath("aloeL.jpg"), IMREAD_GRAYSCALE);
1065
1066     if (img.empty()) throw runtime_error("can't open aloeL.jpg");
1067
1068     Mat edges(img.size(), CV_8UC1);
1069
1070     CPU_ON;
1071     Canny(img, edges, 50.0, 100.0);
1072     CPU_OFF;
1073
1074     cuda::GpuMat d_img(img);
1075     cuda::GpuMat d_edges;
1076
1077     Ptr<cuda::CannyEdgeDetector> canny = cuda::createCannyEdgeDetector(50.0, 100.0);
1078
1079     canny->detect(d_img, d_edges);
1080
1081     CUDA_ON;
1082     canny->detect(d_img, d_edges);
1083     CUDA_OFF;
1084 }
1085
1086
1087 TEST(reduce)
1088 {
1089     for (int size = 1000; size < 4000; size += 1000)
1090     {
1091         Mat src;
1092         gen(src, size, size, CV_32F, 0, 255);
1093
1094         Mat dst0;
1095         Mat dst1;
1096
1097         cuda::GpuMat d_src(src);
1098         cuda::GpuMat d_dst0;
1099         cuda::GpuMat d_dst1;
1100
1101         SUBTEST << size << 'x' << size << ", dim = 0";
1102
1103         reduce(src, dst0, 0, REDUCE_MIN);
1104
1105         CPU_ON;
1106         reduce(src, dst0, 0, REDUCE_MIN);
1107         CPU_OFF;
1108
1109         cuda::reduce(d_src, d_dst0, 0, REDUCE_MIN);
1110
1111         CUDA_ON;
1112         cuda::reduce(d_src, d_dst0, 0, REDUCE_MIN);
1113         CUDA_OFF;
1114
1115         SUBTEST << size << 'x' << size << ", dim = 1";
1116
1117         reduce(src, dst1, 1, REDUCE_MIN);
1118
1119         CPU_ON;
1120         reduce(src, dst1, 1, REDUCE_MIN);
1121         CPU_OFF;
1122
1123         cuda::reduce(d_src, d_dst1, 1, REDUCE_MIN);
1124
1125         CUDA_ON;
1126         cuda::reduce(d_src, d_dst1, 1, REDUCE_MIN);
1127         CUDA_OFF;
1128     }
1129 }
1130
1131
1132 TEST(gemm)
1133 {
1134     Mat src1, src2, src3, dst;
1135     cuda::GpuMat d_src1, d_src2, d_src3, d_dst;
1136
1137     for (int size = 512; size <= 1024; size *= 2)
1138     {
1139         SUBTEST << size << 'x' << size;
1140
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));
1144
1145         gemm(src1, src2, 1.0, src3, 1.0, dst);
1146
1147         CPU_ON;
1148         gemm(src1, src2, 1.0, src3, 1.0, dst);
1149         CPU_OFF;
1150
1151         d_src1.upload(src1);
1152         d_src2.upload(src2);
1153         d_src3.upload(src3);
1154
1155         cuda::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
1156
1157         CUDA_ON;
1158         cuda::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
1159         CUDA_OFF;
1160     }
1161 }
1162
1163 TEST(GoodFeaturesToTrack)
1164 {
1165     Mat src = imread(abspath("aloeL.jpg"), IMREAD_GRAYSCALE);
1166     if (src.empty()) throw runtime_error("can't open aloeL.jpg");
1167
1168     vector<Point2f> pts;
1169
1170     goodFeaturesToTrack(src, pts, 8000, 0.01, 0.0);
1171
1172     CPU_ON;
1173     goodFeaturesToTrack(src, pts, 8000, 0.01, 0.0);
1174     CPU_OFF;
1175
1176     Ptr<cuda::CornersDetector> detector = cuda::createGoodFeaturesToTrackDetector(src.type(), 8000, 0.01, 0.0);
1177
1178     cuda::GpuMat d_src(src);
1179     cuda::GpuMat d_pts;
1180
1181     detector->detect(d_src, d_pts);
1182
1183     CUDA_ON;
1184     detector->detect(d_src, d_pts);
1185     CUDA_OFF;
1186 }
1187
1188 TEST(PyrLKOpticalFlow)
1189 {
1190     Mat frame0 = imread(abspath("rubberwhale1.png"));
1191     if (frame0.empty()) throw runtime_error("can't open rubberwhale1.png");
1192
1193     Mat frame1 = imread(abspath("rubberwhale2.png"));
1194     if (frame1.empty()) throw runtime_error("can't open rubberwhale2.png");
1195
1196     Mat gray_frame;
1197     cvtColor(frame0, gray_frame, COLOR_BGR2GRAY);
1198
1199     for (int points = 1000; points <= 8000; points *= 2)
1200     {
1201         SUBTEST << points;
1202
1203         vector<Point2f> pts;
1204         goodFeaturesToTrack(gray_frame, pts, points, 0.01, 0.0);
1205
1206         vector<Point2f> nextPts;
1207         vector<unsigned char> status;
1208
1209         vector<float> err;
1210
1211         calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, err);
1212
1213         CPU_ON;
1214         calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, err);
1215         CPU_OFF;
1216
1217         cuda::PyrLKOpticalFlow d_pyrLK;
1218
1219         cuda::GpuMat d_frame0(frame0);
1220         cuda::GpuMat d_frame1(frame1);
1221
1222         cuda::GpuMat d_pts;
1223         Mat pts_mat(1, (int)pts.size(), CV_32FC2, (void*)&pts[0]);
1224         d_pts.upload(pts_mat);
1225
1226         cuda::GpuMat d_nextPts;
1227         cuda::GpuMat d_status;
1228         cuda::GpuMat d_err;
1229
1230         d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err);
1231
1232         CUDA_ON;
1233         d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err);
1234         CUDA_OFF;
1235     }
1236 }
1237
1238
1239 TEST(FarnebackOpticalFlow)
1240 {
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) {
1245
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");
1251
1252     cuda::FarnebackOpticalFlow calc;
1253     calc.fastPyramids = fastPyramids != 0;
1254     calc.flags |= useGaussianBlur ? OPTFLOW_FARNEBACK_GAUSSIAN : 0;
1255
1256     cuda::GpuMat d_frame0(frame0), d_frame1(frame1), d_flowx, d_flowy;
1257     CUDA_ON;
1258     calc(d_frame0, d_frame1, d_flowx, d_flowy);
1259     CUDA_OFF;
1260
1261     Mat flow;
1262     CPU_ON;
1263     calcOpticalFlowFarneback(frame0, frame1, flow, calc.pyrScale, calc.numLevels, calc.winSize, calc.numIters, calc.polyN, calc.polySigma, calc.flags);
1264     CPU_OFF;
1265
1266     }}}
1267 }
1268
1269 TEST(MOG)
1270 {
1271     const std::string inputFile = abspath("768x576.avi");
1272
1273     cv::VideoCapture cap(inputFile);
1274     if (!cap.isOpened()) throw runtime_error("can't open 768x576.avi");
1275
1276     cv::Mat frame;
1277     cap >> frame;
1278
1279     cv::Ptr<cv::BackgroundSubtractor> mog = cv::createBackgroundSubtractorMOG();
1280     cv::Mat foreground;
1281
1282     mog->apply(frame, foreground, 0.01);
1283
1284     while (!TestSystem::instance().stop())
1285     {
1286         cap >> frame;
1287
1288         TestSystem::instance().cpuOn();
1289
1290         mog->apply(frame, foreground, 0.01);
1291
1292         TestSystem::instance().cpuOff();
1293     }
1294     TestSystem::instance().cpuComplete();
1295
1296     cap.open(inputFile);
1297
1298     cap >> frame;
1299
1300     cv::cuda::GpuMat d_frame(frame);
1301     cv::Ptr<cv::BackgroundSubtractor> d_mog = cv::cuda::createBackgroundSubtractorMOG();
1302     cv::cuda::GpuMat d_foreground;
1303
1304     d_mog->apply(d_frame, d_foreground, 0.01);
1305
1306     while (!TestSystem::instance().stop())
1307     {
1308         cap >> frame;
1309         d_frame.upload(frame);
1310
1311         TestSystem::instance().gpuOn();
1312
1313         d_mog->apply(d_frame, d_foreground, 0.01);
1314
1315         TestSystem::instance().gpuOff();
1316     }
1317     TestSystem::instance().gpuComplete();
1318 }
1319
1320 TEST(MOG2)
1321 {
1322     const std::string inputFile = abspath("768x576.avi");
1323
1324     cv::VideoCapture cap(inputFile);
1325     if (!cap.isOpened()) throw runtime_error("can't open 768x576.avi");
1326
1327     cv::Mat frame;
1328     cap >> frame;
1329
1330     cv::Ptr<cv::BackgroundSubtractor> mog2 = cv::createBackgroundSubtractorMOG2();
1331     cv::Mat foreground;
1332     cv::Mat background;
1333
1334     mog2->apply(frame, foreground);
1335     mog2->getBackgroundImage(background);
1336
1337     while (!TestSystem::instance().stop())
1338     {
1339         cap >> frame;
1340
1341         TestSystem::instance().cpuOn();
1342
1343         mog2->apply(frame, foreground);
1344         mog2->getBackgroundImage(background);
1345
1346         TestSystem::instance().cpuOff();
1347     }
1348     TestSystem::instance().cpuComplete();
1349
1350     cap.open(inputFile);
1351
1352     cap >> frame;
1353
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;
1358
1359     d_mog2->apply(d_frame, d_foreground);
1360     d_mog2->getBackgroundImage(d_background);
1361
1362     while (!TestSystem::instance().stop())
1363     {
1364         cap >> frame;
1365         d_frame.upload(frame);
1366
1367         TestSystem::instance().gpuOn();
1368
1369         d_mog2->apply(d_frame, d_foreground);
1370         d_mog2->getBackgroundImage(d_background);
1371
1372         TestSystem::instance().gpuOff();
1373     }
1374     TestSystem::instance().gpuComplete();
1375 }