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