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