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