modules/gpu/perf/perf_video.cpp

   1 #include "perf_precomp.hpp"\r
   2 \r
   3 using namespace std;\r
   4 using namespace testing;\r
   5 \r
   6 namespace cv\r
   7 {\r
   8     template<> void Ptr<CvBGStatModel>::delete_obj()\r
   9     {\r
  10         cvReleaseBGStatModel(&obj);\r
  11     }\r
  12 }\r
  13 \r
  14 namespace {\r
  15 \r
  16 //////////////////////////////////////////////////////\r
  17 // BroxOpticalFlow\r
  18 \r
  19 typedef pair<string, string> pair_string;\r
  20 \r
  21 DEF_PARAM_TEST_1(ImagePair, pair_string);\r
  22 \r
  23 PERF_TEST_P(ImagePair, Video_BroxOpticalFlow, Values<pair_string>(make_pair("gpu/opticalflow/frame0.png", "gpu/opticalflow/frame1.png")))\r
  24 {\r
  25     declare.time(10);\r
  26 \r
  27     cv::Mat frame0 = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);\r
  28     ASSERT_FALSE(frame0.empty());\r
  29 \r
  30     cv::Mat frame1 = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);\r
  31     ASSERT_FALSE(frame1.empty());\r
  32 \r
  33     frame0.convertTo(frame0, CV_32FC1, 1.0 / 255.0);\r
  34     frame1.convertTo(frame1, CV_32FC1, 1.0 / 255.0);\r
  35 \r
  36     if (runOnGpu)\r
  37     {\r
  38         cv::gpu::GpuMat d_frame0(frame0);\r
  39         cv::gpu::GpuMat d_frame1(frame1);\r
  40         cv::gpu::GpuMat d_u;\r
  41         cv::gpu::GpuMat d_v;\r
  42 \r
  43         cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,\r
  44                                         10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);\r
  45 \r
  46         d_flow(d_frame0, d_frame1, d_u, d_v);\r
  47 \r
  48         TEST_CYCLE()\r
  49         {\r
  50             d_flow(d_frame0, d_frame1, d_u, d_v);\r
  51         }\r
  52     }\r
  53     else\r
  54     {\r
  55         FAIL();\r
  56     }\r
  57 }\r
  58 \r
  59 //////////////////////////////////////////////////////\r
  60 // InterpolateFrames\r
  61 \r
  62 PERF_TEST_P(ImagePair, Video_InterpolateFrames, Values<pair_string>(make_pair("gpu/opticalflow/frame0.png", "gpu/opticalflow/frame1.png")))\r
  63 {\r
  64     cv::Mat frame0 = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);\r
  65     ASSERT_FALSE(frame0.empty());\r
  66 \r
  67     cv::Mat frame1 = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);\r
  68     ASSERT_FALSE(frame1.empty());\r
  69 \r
  70     frame0.convertTo(frame0, CV_32FC1, 1.0 / 255.0);\r
  71     frame1.convertTo(frame1, CV_32FC1, 1.0 / 255.0);\r
  72 \r
  73     if (runOnGpu)\r
  74     {\r
  75         cv::gpu::GpuMat d_frame0(frame0);\r
  76         cv::gpu::GpuMat d_frame1(frame1);\r
  77         cv::gpu::GpuMat d_fu, d_fv;\r
  78         cv::gpu::GpuMat d_bu, d_bv;\r
  79 \r
  80         cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,\r
  81                                         10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);\r
  82 \r
  83         d_flow(d_frame0, d_frame1, d_fu, d_fv);\r
  84         d_flow(d_frame1, d_frame0, d_bu, d_bv);\r
  85 \r
  86         cv::gpu::GpuMat d_newFrame;\r
  87         cv::gpu::GpuMat d_buf;\r
  88 \r
  89         cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);\r
  90 \r
  91         TEST_CYCLE()\r
  92         {\r
  93             cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);\r
  94         }\r
  95     }\r
  96     else\r
  97     {\r
  98         FAIL();\r
  99     }\r
 100 }\r
 101 \r
 102 //////////////////////////////////////////////////////\r
 103 // CreateOpticalFlowNeedleMap\r
 104 \r
 105 PERF_TEST_P(ImagePair, Video_CreateOpticalFlowNeedleMap, Values<pair_string>(make_pair("gpu/opticalflow/frame0.png", "gpu/opticalflow/frame1.png")))\r
 106 {\r
 107     cv::Mat frame0 = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);\r
 108     ASSERT_FALSE(frame0.empty());\r
 109 \r
 110     cv::Mat frame1 = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);\r
 111     ASSERT_FALSE(frame1.empty());\r
 112 \r
 113     frame0.convertTo(frame0, CV_32FC1, 1.0 / 255.0);\r
 114     frame1.convertTo(frame1, CV_32FC1, 1.0 / 255.0);\r
 115 \r
 116     if (runOnGpu)\r
 117     {\r
 118         cv::gpu::GpuMat d_frame0(frame0);\r
 119         cv::gpu::GpuMat d_frame1(frame1);\r
 120         cv::gpu::GpuMat d_u;\r
 121         cv::gpu::GpuMat d_v;\r
 122 \r
 123         cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,\r
 124                                         10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);\r
 125 \r
 126         d_flow(d_frame0, d_frame1, d_u, d_v);\r
 127 \r
 128         cv::gpu::GpuMat d_vertex, d_colors;\r
 129 \r
 130         cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors);\r
 131 \r
 132         TEST_CYCLE()\r
 133         {\r
 134             cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors);\r
 135         }\r
 136     }\r
 137     else\r
 138     {\r
 139         FAIL();\r
 140     }\r
 141 }\r
 142 \r
 143 //////////////////////////////////////////////////////\r
 144 // GoodFeaturesToTrack\r
 145 \r
 146 DEF_PARAM_TEST(Image_MinDistance, string, double);\r
 147 \r
 148 PERF_TEST_P(Image_MinDistance, Video_GoodFeaturesToTrack, Combine(Values<string>("gpu/perf/aloe.jpg"), Values(0.0, 3.0)))\r
 149 {\r
 150     string fileName = GET_PARAM(0);\r
 151     double minDistance = GET_PARAM(1);\r
 152 \r
 153     cv::Mat image = readImage(fileName, cv::IMREAD_GRAYSCALE);\r
 154     ASSERT_FALSE(image.empty());\r
 155 \r
 156     if (runOnGpu)\r
 157     {\r
 158         cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(8000, 0.01, minDistance);\r
 159 \r
 160         cv::gpu::GpuMat d_image(image);\r
 161         cv::gpu::GpuMat d_pts;\r
 162 \r
 163         d_detector(d_image, d_pts);\r
 164 \r
 165         TEST_CYCLE()\r
 166         {\r
 167             d_detector(d_image, d_pts);\r
 168         }\r
 169     }\r
 170     else\r
 171     {\r
 172         cv::Mat pts;\r
 173 \r
 174         cv::goodFeaturesToTrack(image, pts, 8000, 0.01, minDistance);\r
 175 \r
 176         TEST_CYCLE()\r
 177         {\r
 178             cv::goodFeaturesToTrack(image, pts, 8000, 0.01, minDistance);\r
 179         }\r
 180     }\r
 181 }\r
 182 \r
 183 //////////////////////////////////////////////////////\r
 184 // PyrLKOpticalFlowSparse\r
 185 \r
 186 DEF_PARAM_TEST(ImagePair_Gray_NPts_WinSz_Levels_Iters, pair_string, bool, int, int, int, int);\r
 187 \r
 188 PERF_TEST_P(ImagePair_Gray_NPts_WinSz_Levels_Iters, Video_PyrLKOpticalFlowSparse, Combine(\r
 189     Values<pair_string>(make_pair("gpu/opticalflow/frame0.png", "gpu/opticalflow/frame1.png")),\r
 190     Bool(),\r
 191     Values(1000, 2000, 4000, 8000),\r
 192     Values(9, 13, 17, 21),\r
 193     Values(1, 2, 3),\r
 194     Values(1, 10, 30)))\r
 195 {\r
 196     declare.time(20.0);\r
 197 \r
 198     pair_string imagePair = GET_PARAM(0);\r
 199     bool useGray = GET_PARAM(1);\r
 200     int points = GET_PARAM(2);\r
 201     int winSize = GET_PARAM(3);\r
 202     int levels = GET_PARAM(4);\r
 203     int iters = GET_PARAM(5);\r
 204 \r
 205     cv::Mat frame0 = readImage(imagePair.first, useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);\r
 206     ASSERT_FALSE(frame0.empty());\r
 207 \r
 208     cv::Mat frame1 = readImage(imagePair.second, useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);\r
 209     ASSERT_FALSE(frame1.empty());\r
 210 \r
 211     cv::Mat gray_frame;\r
 212     if (useGray)\r
 213         gray_frame = frame0;\r
 214     else\r
 215         cv::cvtColor(frame0, gray_frame, cv::COLOR_BGR2GRAY);\r
 216 \r
 217     cv::Mat pts;\r
 218     cv::goodFeaturesToTrack(gray_frame, pts, points, 0.01, 0.0);\r
 219 \r
 220     if (runOnGpu)\r
 221     {\r
 222         cv::gpu::GpuMat d_pts(pts);\r
 223 \r
 224         cv::gpu::PyrLKOpticalFlow d_pyrLK;\r
 225         d_pyrLK.winSize = cv::Size(winSize, winSize);\r
 226         d_pyrLK.maxLevel = levels - 1;\r
 227         d_pyrLK.iters = iters;\r
 228 \r
 229         cv::gpu::GpuMat d_frame0(frame0);\r
 230         cv::gpu::GpuMat d_frame1(frame1);\r
 231         cv::gpu::GpuMat d_nextPts;\r
 232         cv::gpu::GpuMat d_status;\r
 233 \r
 234         d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status);\r
 235 \r
 236         TEST_CYCLE()\r
 237         {\r
 238             d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status);\r
 239         }\r
 240     }\r
 241     else\r
 242     {\r
 243         cv::Mat nextPts;\r
 244         cv::Mat status;\r
 245 \r
 246         cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, cv::noArray(),\r
 247                                  cv::Size(winSize, winSize), levels - 1,\r
 248                                  cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, iters, 0.01));\r
 249 \r
 250         TEST_CYCLE()\r
 251         {\r
 252             cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, cv::noArray(),\r
 253                                      cv::Size(winSize, winSize), levels - 1,\r
 254                                      cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, iters, 0.01));\r
 255         }\r
 256     }\r
 257 }\r
 258 \r
 259 //////////////////////////////////////////////////////\r
 260 // PyrLKOpticalFlowDense\r
 261 \r
 262 DEF_PARAM_TEST(ImagePair_WinSz_Levels_Iters, pair_string, int, int, int);\r
 263 \r
 264 PERF_TEST_P(ImagePair_WinSz_Levels_Iters, Video_PyrLKOpticalFlowDense, Combine(\r
 265     Values<pair_string>(make_pair("gpu/opticalflow/frame0.png", "gpu/opticalflow/frame1.png")),\r
 266     Values(3, 5, 7, 9, 13, 17, 21),\r
 267     Values(1, 2, 3),\r
 268     Values(1, 10)))\r
 269 {\r
 270     declare.time(30);\r
 271 \r
 272     pair_string imagePair = GET_PARAM(0);\r
 273     int winSize = GET_PARAM(1);\r
 274     int levels = GET_PARAM(2);\r
 275     int iters = GET_PARAM(3);\r
 276 \r
 277     cv::Mat frame0 = readImage(imagePair.first, cv::IMREAD_GRAYSCALE);\r
 278     ASSERT_FALSE(frame0.empty());\r
 279 \r
 280     cv::Mat frame1 = readImage(imagePair.second, cv::IMREAD_GRAYSCALE);\r
 281     ASSERT_FALSE(frame1.empty());\r
 282 \r
 283     if (runOnGpu)\r
 284     {\r
 285         cv::gpu::GpuMat d_frame0(frame0);\r
 286         cv::gpu::GpuMat d_frame1(frame1);\r
 287         cv::gpu::GpuMat d_u;\r
 288         cv::gpu::GpuMat d_v;\r
 289 \r
 290         cv::gpu::PyrLKOpticalFlow d_pyrLK;\r
 291         d_pyrLK.winSize = cv::Size(winSize, winSize);\r
 292         d_pyrLK.maxLevel = levels - 1;\r
 293         d_pyrLK.iters = iters;\r
 294 \r
 295         d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v);\r
 296 \r
 297         TEST_CYCLE()\r
 298         {\r
 299             d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v);\r
 300         }\r
 301     }\r
 302     else\r
 303     {\r
 304         FAIL();\r
 305     }\r
 306 }\r
 307 \r
 308 //////////////////////////////////////////////////////\r
 309 // FarnebackOpticalFlow\r
 310 \r
 311 PERF_TEST_P(ImagePair, Video_FarnebackOpticalFlow, Values<pair_string>(make_pair("gpu/opticalflow/frame0.png", "gpu/opticalflow/frame1.png")))\r
 312 {\r
 313     declare.time(10);\r
 314 \r
 315     cv::Mat frame0 = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);\r
 316     ASSERT_FALSE(frame0.empty());\r
 317 \r
 318     cv::Mat frame1 = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);\r
 319     ASSERT_FALSE(frame1.empty());\r
 320 \r
 321     int numLevels = 5;\r
 322     double pyrScale = 0.5;\r
 323     int winSize = 13;\r
 324     int numIters = 10;\r
 325     int polyN = 5;\r
 326     double polySigma = 1.1;\r
 327     int flags = 0;\r
 328 \r
 329     if (runOnGpu)\r
 330     {\r
 331         cv::gpu::GpuMat d_frame0(frame0);\r
 332         cv::gpu::GpuMat d_frame1(frame1);\r
 333         cv::gpu::GpuMat d_u;\r
 334         cv::gpu::GpuMat d_v;\r
 335 \r
 336         cv::gpu::FarnebackOpticalFlow d_farneback;\r
 337         d_farneback.numLevels = numLevels;\r
 338         d_farneback.pyrScale = pyrScale;\r
 339         d_farneback.winSize = winSize;\r
 340         d_farneback.numIters = numIters;\r
 341         d_farneback.polyN = polyN;\r
 342         d_farneback.polySigma = polySigma;\r
 343         d_farneback.flags = flags;\r
 344 \r
 345         d_farneback(d_frame0, d_frame1, d_u, d_v);\r
 346 \r
 347         TEST_CYCLE()\r
 348         {\r
 349             d_farneback(d_frame0, d_frame1, d_u, d_v);\r
 350         }\r
 351     }\r
 352     else\r
 353     {\r
 354         cv::Mat flow;\r
 355 \r
 356         cv::calcOpticalFlowFarneback(frame0, frame1, flow, pyrScale, numLevels, winSize, numIters, polyN, polySigma, flags);\r
 357 \r
 358         TEST_CYCLE()\r
 359         {\r
 360             cv::calcOpticalFlowFarneback(frame0, frame1, flow, pyrScale, numLevels, winSize, numIters, polyN, polySigma, flags);\r
 361         }\r
 362     }\r
 363 }\r
 364 \r
 365 //////////////////////////////////////////////////////\r
 366 // FGDStatModel\r
 367 \r
 368 DEF_PARAM_TEST_1(Video, string);\r
 369 \r
 370 PERF_TEST_P(Video, Video_FGDStatModel, Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"))\r
 371 {\r
 372     declare.time(60);\r
 373 \r
 374     string inputFile = perf::TestBase::getDataPath(GetParam());\r
 375 \r
 376     cv::VideoCapture cap(inputFile);\r
 377     ASSERT_TRUE(cap.isOpened());\r
 378 \r
 379     cv::Mat frame;\r
 380     cap >> frame;\r
 381     ASSERT_FALSE(frame.empty());\r
 382 \r
 383     if (runOnGpu)\r
 384     {\r
 385         cv::gpu::GpuMat d_frame(frame);\r
 386 \r
 387         cv::gpu::FGDStatModel d_model(4);\r
 388         d_model.create(d_frame);\r
 389 \r
 390         for (int i = 0; i < 10; ++i)\r
 391         {\r
 392             cap >> frame;\r
 393             ASSERT_FALSE(frame.empty());\r
 394 \r
 395             d_frame.upload(frame);\r
 396 \r
 397             startTimer(); next();\r
 398             d_model.update(d_frame);\r
 399             stopTimer();\r
 400         }\r
 401     }\r
 402     else\r
 403     {\r
 404         IplImage ipl_frame = frame;\r
 405         cv::Ptr<CvBGStatModel> model(cvCreateFGDStatModel(&ipl_frame));\r
 406 \r
 407         for (int i = 0; i < 10; ++i)\r
 408         {\r
 409             cap >> frame;\r
 410             ASSERT_FALSE(frame.empty());\r
 411 \r
 412             ipl_frame = frame;\r
 413 \r
 414             startTimer(); next();\r
 415             cvUpdateBGStatModel(&ipl_frame, model);\r
 416             stopTimer();\r
 417         }\r
 418     }\r
 419 }\r
 420 \r
 421 //////////////////////////////////////////////////////\r
 422 // MOG\r
 423 \r
 424 DEF_PARAM_TEST(Video_Cn_LearningRate, string, int, double);\r
 425 \r
 426 PERF_TEST_P(Video_Cn_LearningRate, Video_MOG, Combine(Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"), Values(1, 3, 4), Values(0.0, 0.01)))\r
 427 {\r
 428     string inputFile = perf::TestBase::getDataPath(GET_PARAM(0));\r
 429     int cn = GET_PARAM(1);\r
 430     float learningRate = static_cast<float>(GET_PARAM(2));\r
 431 \r
 432     cv::VideoCapture cap(inputFile);\r
 433     ASSERT_TRUE(cap.isOpened());\r
 434 \r
 435     cv::Mat frame;\r
 436 \r
 437     cap >> frame;\r
 438     ASSERT_FALSE(frame.empty());\r
 439 \r
 440     if (cn != 3)\r
 441     {\r
 442         cv::Mat temp;\r
 443         if (cn == 1)\r
 444             cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);\r
 445         else\r
 446             cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);\r
 447         cv::swap(temp, frame);\r
 448     }\r
 449 \r
 450     if (runOnGpu)\r
 451     {\r
 452         cv::gpu::GpuMat d_frame(frame);\r
 453         cv::gpu::MOG_GPU d_mog;\r
 454         cv::gpu::GpuMat d_foreground;\r
 455 \r
 456         d_mog(d_frame, d_foreground, learningRate);\r
 457 \r
 458         for (int i = 0; i < 10; ++i)\r
 459         {\r
 460             cap >> frame;\r
 461             ASSERT_FALSE(frame.empty());\r
 462 \r
 463             if (cn != 3)\r
 464             {\r
 465                 cv::Mat temp;\r
 466                 if (cn == 1)\r
 467                     cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);\r
 468                 else\r
 469                     cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);\r
 470                 cv::swap(temp, frame);\r
 471             }\r
 472 \r
 473             d_frame.upload(frame);\r
 474 \r
 475             startTimer(); next();\r
 476             d_mog(d_frame, d_foreground, learningRate);\r
 477             stopTimer();\r
 478         }\r
 479     }\r
 480     else\r
 481     {\r
 482         cv::BackgroundSubtractorMOG mog;\r
 483         cv::Mat foreground;\r
 484 \r
 485         mog(frame, foreground, learningRate);\r
 486 \r
 487         for (int i = 0; i < 10; ++i)\r
 488         {\r
 489             cap >> frame;\r
 490             ASSERT_FALSE(frame.empty());\r
 491 \r
 492             if (cn != 3)\r
 493             {\r
 494                 cv::Mat temp;\r
 495                 if (cn == 1)\r
 496                     cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);\r
 497                 else\r
 498                     cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);\r
 499                 cv::swap(temp, frame);\r
 500             }\r
 501 \r
 502             startTimer(); next();\r
 503             mog(frame, foreground, learningRate);\r
 504             stopTimer();\r
 505         }\r
 506     }\r
 507 }\r
 508 \r
 509 //////////////////////////////////////////////////////\r
 510 // MOG2\r
 511 \r
 512 DEF_PARAM_TEST(Video_Cn, string, int);\r
 513 \r
 514 PERF_TEST_P(Video_Cn, Video_MOG2, Combine(Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"), Values(1, 3, 4)))\r
 515 {\r
 516     string inputFile = perf::TestBase::getDataPath(GET_PARAM(0));\r
 517     int cn = GET_PARAM(1);\r
 518 \r
 519     cv::VideoCapture cap(inputFile);\r
 520     ASSERT_TRUE(cap.isOpened());\r
 521 \r
 522     cv::Mat frame;\r
 523 \r
 524     cap >> frame;\r
 525     ASSERT_FALSE(frame.empty());\r
 526 \r
 527     if (cn != 3)\r
 528     {\r
 529         cv::Mat temp;\r
 530         if (cn == 1)\r
 531             cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);\r
 532         else\r
 533             cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);\r
 534         cv::swap(temp, frame);\r
 535     }\r
 536 \r
 537     if (runOnGpu)\r
 538     {\r
 539         cv::gpu::GpuMat d_frame(frame);\r
 540         cv::gpu::MOG2_GPU d_mog2;\r
 541         cv::gpu::GpuMat d_foreground;\r
 542 \r
 543         d_mog2(d_frame, d_foreground);\r
 544 \r
 545         for (int i = 0; i < 10; ++i)\r
 546         {\r
 547             cap >> frame;\r
 548             ASSERT_FALSE(frame.empty());\r
 549 \r
 550             if (cn != 3)\r
 551             {\r
 552                 cv::Mat temp;\r
 553                 if (cn == 1)\r
 554                     cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);\r
 555                 else\r
 556                     cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);\r
 557                 cv::swap(temp, frame);\r
 558             }\r
 559 \r
 560             d_frame.upload(frame);\r
 561 \r
 562             startTimer(); next();\r
 563             d_mog2(d_frame, d_foreground);\r
 564             stopTimer();\r
 565         }\r
 566     }\r
 567     else\r
 568     {\r
 569         cv::BackgroundSubtractorMOG2 mog2;\r
 570         cv::Mat foreground;\r
 571 \r
 572         mog2(frame, foreground);\r
 573 \r
 574         for (int i = 0; i < 10; ++i)\r
 575         {\r
 576             cap >> frame;\r
 577             ASSERT_FALSE(frame.empty());\r
 578 \r
 579             if (cn != 3)\r
 580             {\r
 581                 cv::Mat temp;\r
 582                 if (cn == 1)\r
 583                     cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);\r
 584                 else\r
 585                     cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);\r
 586                 cv::swap(temp, frame);\r
 587             }\r
 588 \r
 589             startTimer(); next();\r
 590             mog2(frame, foreground);\r
 591             stopTimer();\r
 592         }\r
 593     }\r
 594 }\r
 595 \r
 596 //////////////////////////////////////////////////////\r
 597 // MOG2GetBackgroundImage\r
 598 \r
 599 PERF_TEST_P(Video_Cn, Video_MOG2GetBackgroundImage, Combine(Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"), Values(1, 3, 4)))\r
 600 {\r
 601     string inputFile = perf::TestBase::getDataPath(GET_PARAM(0));\r
 602     int cn = GET_PARAM(1);\r
 603 \r
 604     cv::VideoCapture cap(inputFile);\r
 605     ASSERT_TRUE(cap.isOpened());\r
 606 \r
 607     cv::Mat frame;\r
 608 \r
 609     if (runOnGpu)\r
 610     {\r
 611         cv::gpu::GpuMat d_frame;\r
 612         cv::gpu::MOG2_GPU d_mog2;\r
 613         cv::gpu::GpuMat d_foreground;\r
 614 \r
 615         for (int i = 0; i < 10; ++i)\r
 616         {\r
 617             cap >> frame;\r
 618             ASSERT_FALSE(frame.empty());\r
 619 \r
 620             if (cn != 3)\r
 621             {\r
 622                 cv::Mat temp;\r
 623                 if (cn == 1)\r
 624                     cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);\r
 625                 else\r
 626                     cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);\r
 627                 cv::swap(temp, frame);\r
 628             }\r
 629 \r
 630             d_frame.upload(frame);\r
 631 \r
 632             d_mog2(d_frame, d_foreground);\r
 633         }\r
 634 \r
 635         cv::gpu::GpuMat d_background;\r
 636         d_mog2.getBackgroundImage(d_background);\r
 637 \r
 638         TEST_CYCLE()\r
 639         {\r
 640             d_mog2.getBackgroundImage(d_background);\r
 641         }\r
 642     }\r
 643     else\r
 644     {\r
 645         cv::BackgroundSubtractorMOG2 mog2;\r
 646         cv::Mat foreground;\r
 647 \r
 648         for (int i = 0; i < 10; ++i)\r
 649         {\r
 650             cap >> frame;\r
 651             ASSERT_FALSE(frame.empty());\r
 652 \r
 653             if (cn != 3)\r
 654             {\r
 655                 cv::Mat temp;\r
 656                 if (cn == 1)\r
 657                     cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);\r
 658                 else\r
 659                     cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);\r
 660                 cv::swap(temp, frame);\r
 661             }\r
 662 \r
 663             mog2(frame, foreground);\r
 664         }\r
 665 \r
 666         cv::Mat background;\r
 667         mog2.getBackgroundImage(background);\r
 668 \r
 669         TEST_CYCLE()\r
 670         {\r
 671             mog2.getBackgroundImage(background);\r
 672         }\r
 673     }\r
 674 }\r
 675 \r
 676 //////////////////////////////////////////////////////\r
 677 // VIBE\r
 678 \r
 679 PERF_TEST_P(Video_Cn, Video_VIBE, Combine(Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"), Values(1, 3, 4)))\r
 680 {\r
 681     string inputFile = perf::TestBase::getDataPath(GET_PARAM(0));\r
 682     int cn = GET_PARAM(1);\r
 683 \r
 684     cv::VideoCapture cap(inputFile);\r
 685     ASSERT_TRUE(cap.isOpened());\r
 686 \r
 687     cv::Mat frame;\r
 688     cap >> frame;\r
 689     ASSERT_FALSE(frame.empty());\r
 690 \r
 691     if (cn != 3)\r
 692     {\r
 693         cv::Mat temp;\r
 694         if (cn == 1)\r
 695             cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);\r
 696         else\r
 697             cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);\r
 698         cv::swap(temp, frame);\r
 699     }\r
 700 \r
 701     if (runOnGpu)\r
 702     {\r
 703         cv::gpu::GpuMat d_frame(frame);\r
 704         cv::gpu::VIBE_GPU d_vibe;\r
 705         cv::gpu::GpuMat d_foreground;\r
 706 \r
 707         d_vibe(d_frame, d_foreground);\r
 708 \r
 709         for (int i = 0; i < 10; ++i)\r
 710         {\r
 711             cap >> frame;\r
 712             ASSERT_FALSE(frame.empty());\r
 713 \r
 714             if (cn != 3)\r
 715             {\r
 716                 cv::Mat temp;\r
 717                 if (cn == 1)\r
 718                     cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);\r
 719                 else\r
 720                     cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);\r
 721                 cv::swap(temp, frame);\r
 722             }\r
 723 \r
 724             d_frame.upload(frame);\r
 725 \r
 726             startTimer(); next();\r
 727             d_vibe(d_frame, d_foreground);\r
 728             stopTimer();\r
 729         }\r
 730     }\r
 731     else\r
 732     {\r
 733         FAIL();\r
 734     }\r
 735 }\r
 736 \r
 737 //////////////////////////////////////////////////////\r
 738 // GMG\r
 739 \r
 740 DEF_PARAM_TEST(Video_Cn_MaxFeatures, string, int, int);\r
 741 \r
 742 PERF_TEST_P(Video_Cn_MaxFeatures, Video_GMG, Combine(Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"), Values(1, 3, 4), Values(20, 40, 60)))\r
 743 {\r
 744     std::string inputFile = perf::TestBase::getDataPath(GET_PARAM(0));\r
 745     int cn = GET_PARAM(1);\r
 746     int maxFeatures = GET_PARAM(2);\r
 747 \r
 748     cv::VideoCapture cap(inputFile);\r
 749     ASSERT_TRUE(cap.isOpened());\r
 750 \r
 751     cv::Mat frame;\r
 752     cap >> frame;\r
 753     ASSERT_FALSE(frame.empty());\r
 754 \r
 755     if (cn != 3)\r
 756     {\r
 757         cv::Mat temp;\r
 758         if (cn == 1)\r
 759             cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);\r
 760         else\r
 761             cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);\r
 762         cv::swap(temp, frame);\r
 763     }\r
 764 \r
 765     if (runOnGpu)\r
 766     {\r
 767         cv::gpu::GpuMat d_frame(frame);\r
 768         cv::gpu::GpuMat d_fgmask;\r
 769 \r
 770         cv::gpu::GMG_GPU d_gmg;\r
 771         d_gmg.maxFeatures = maxFeatures;\r
 772 \r
 773         d_gmg(d_frame, d_fgmask);\r
 774 \r
 775         for (int i = 0; i < 150; ++i)\r
 776         {\r
 777             cap >> frame;\r
 778             if (frame.empty())\r
 779             {\r
 780                 cap.open(inputFile);\r
 781                 cap >> frame;\r
 782             }\r
 783 \r
 784             if (cn != 3)\r
 785             {\r
 786                 cv::Mat temp;\r
 787                 if (cn == 1)\r
 788                     cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);\r
 789                 else\r
 790                     cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);\r
 791                 cv::swap(temp, frame);\r
 792             }\r
 793 \r
 794             d_frame.upload(frame);\r
 795 \r
 796             startTimer(); next();\r
 797             d_gmg(d_frame, d_fgmask);\r
 798             stopTimer();\r
 799         }\r
 800     }\r
 801     else\r
 802     {\r
 803         cv::Mat fgmask;\r
 804         cv::Mat zeros(frame.size(), CV_8UC1, cv::Scalar::all(0));\r
 805 \r
 806         cv::BackgroundSubtractorGMG gmg;\r
 807         gmg.set("maxFeatures", maxFeatures);\r
 808         gmg.initialize(frame.size(), 0.0, 255.0);\r
 809 \r
 810         gmg(frame, fgmask);\r
 811 \r
 812         for (int i = 0; i < 150; ++i)\r
 813         {\r
 814             cap >> frame;\r
 815             if (frame.empty())\r
 816             {\r
 817                 cap.open(inputFile);\r
 818                 cap >> frame;\r
 819             }\r
 820 \r
 821             if (cn != 3)\r
 822             {\r
 823                 cv::Mat temp;\r
 824                 if (cn == 1)\r
 825                     cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);\r
 826                 else\r
 827                     cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);\r
 828                 cv::swap(temp, frame);\r
 829             }\r
 830 \r
 831             startTimer(); next();\r
 832             gmg(frame, fgmask);\r
 833             stopTimer();\r
 834         }\r
 835     }\r
 836 }\r
 837 \r
 838 //////////////////////////////////////////////////////\r
 839 // VideoWriter\r
 840 \r
 841 PERF_TEST_P(Video, Video_VideoWriter, Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"))\r
 842 {\r
 843     declare.time(30);\r
 844 \r
 845     string inputFile = perf::TestBase::getDataPath(GetParam());\r
 846     string outputFile = cv::tempfile(".avi");\r
 847 \r
 848     const double FPS = 25.0;\r
 849 \r
 850     cv::VideoCapture reader(inputFile);\r
 851     ASSERT_TRUE( reader.isOpened() );\r
 852 \r
 853     cv::Mat frame;\r
 854 \r
 855     if (runOnGpu)\r
 856     {\r
 857         cv::gpu::VideoWriter_GPU d_writer;\r
 858 \r
 859         cv::gpu::GpuMat d_frame;\r
 860 \r
 861         for (int i = 0; i < 10; ++i)\r
 862         {\r
 863             reader >> frame;\r
 864             ASSERT_FALSE(frame.empty());\r
 865 \r
 866             d_frame.upload(frame);\r
 867 \r
 868             if (!d_writer.isOpened())\r
 869                 d_writer.open(outputFile, frame.size(), FPS);\r
 870 \r
 871             startTimer(); next();\r
 872             d_writer.write(d_frame);\r
 873             stopTimer();\r
 874         }\r
 875     }\r
 876     else\r
 877     {\r
 878         cv::VideoWriter writer;\r
 879 \r
 880         for (int i = 0; i < 10; ++i)\r
 881         {\r
 882             reader >> frame;\r
 883             ASSERT_FALSE(frame.empty());\r
 884 \r
 885             if (!writer.isOpened())\r
 886                 writer.open(outputFile, CV_FOURCC('X', 'V', 'I', 'D'), FPS, frame.size());\r
 887 \r
 888             startTimer(); next();\r
 889             writer.write(frame);\r
 890             stopTimer();\r
 891         }\r
 892     }\r
 893 }\r
 894 \r
 895 //////////////////////////////////////////////////////\r
 896 // VideoReader\r
 897 \r
 898 PERF_TEST_P(Video, Video_VideoReader, Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"))\r
 899 {\r
 900     declare.time(20);\r
 901 \r
 902     string inputFile = perf::TestBase::getDataPath(GetParam());\r
 903 \r
 904     if (runOnGpu)\r
 905     {\r
 906         cv::gpu::VideoReader_GPU d_reader(inputFile);\r
 907         ASSERT_TRUE( d_reader.isOpened() );\r
 908 \r
 909         cv::gpu::GpuMat d_frame;\r
 910 \r
 911         d_reader.read(d_frame);\r
 912 \r
 913         TEST_CYCLE_N(10)\r
 914         {\r
 915             d_reader.read(d_frame);\r
 916         }\r
 917     }\r
 918     else\r
 919     {\r
 920         cv::VideoCapture reader(inputFile);\r
 921         ASSERT_TRUE( reader.isOpened() );\r
 922 \r
 923         cv::Mat frame;\r
 924 \r
 925         reader >> frame;\r
 926 \r
 927         TEST_CYCLE_N(10)\r
 928         {\r
 929             reader >> frame;\r
 930         }\r
 931     }\r
 932 }\r
 933 \r
 934 } // namespace\r