modules/gpu/perf/perf_imgproc.cpp

   1 #include "perf_precomp.hpp"\r
   2 \r
   3 using namespace std;\r
   4 using namespace testing;\r
   5 \r
   6 namespace {\r
   7 \r
   8 //////////////////////////////////////////////////////////////////////\r
   9 // Remap\r
  10 \r
  11 enum{HALF_SIZE=0, UPSIDE_DOWN, REFLECTION_X, REFLECTION_BOTH};\r
  12 CV_ENUM(RemapMode, HALF_SIZE, UPSIDE_DOWN, REFLECTION_X, REFLECTION_BOTH);\r
  13 #define ALL_REMAP_MODES ValuesIn(RemapMode::all())\r
  14 \r
  15 void generateMap(cv::Mat& map_x, cv::Mat& map_y, int remapMode)\r
  16 {\r
  17     for (int j = 0; j < map_x.rows; ++j)\r
  18     {\r
  19         for (int i = 0; i < map_x.cols; ++i)\r
  20         {\r
  21             switch (remapMode)\r
  22             {\r
  23             case HALF_SIZE:\r
  24                 if (i > map_x.cols*0.25 && i < map_x.cols*0.75 && j > map_x.rows*0.25 && j < map_x.rows*0.75)\r
  25                 {\r
  26                     map_x.at<float>(j,i) = 2 * (i - map_x.cols * 0.25f) + 0.5f;\r
  27                     map_y.at<float>(j,i) = 2 * (j - map_x.rows * 0.25f) + 0.5f;\r
  28                 }\r
  29                 else\r
  30                 {\r
  31                     map_x.at<float>(j,i) = 0;\r
  32                     map_y.at<float>(j,i) = 0;\r
  33                 }\r
  34                 break;\r
  35             case UPSIDE_DOWN:\r
  36                 map_x.at<float>(j,i) = static_cast<float>(i);\r
  37                 map_y.at<float>(j,i) = static_cast<float>(map_x.rows - j);\r
  38                 break;\r
  39             case REFLECTION_X:\r
  40                 map_x.at<float>(j,i) = static_cast<float>(map_x.cols - i);\r
  41                 map_y.at<float>(j,i) = static_cast<float>(j);\r
  42                 break;\r
  43             case REFLECTION_BOTH:\r
  44                 map_x.at<float>(j,i) = static_cast<float>(map_x.cols - i);\r
  45                 map_y.at<float>(j,i) = static_cast<float>(map_x.rows - j);\r
  46                 break;\r
  47             } // end of switch\r
  48         }\r
  49     }\r
  50 }\r
  51 \r
  52 DEF_PARAM_TEST(Sz_Depth_Cn_Inter_Border_Mode, cv::Size, MatDepth, int, Interpolation, BorderMode, RemapMode);\r
  53 \r
  54 PERF_TEST_P(Sz_Depth_Cn_Inter_Border_Mode, ImgProc_Remap, Combine(\r
  55     GPU_TYPICAL_MAT_SIZES,\r
  56     Values(CV_8U, CV_16U, CV_32F),\r
  57     Values(1, 3, 4),\r
  58     Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),\r
  59     ALL_BORDER_MODES,\r
  60     ALL_REMAP_MODES))\r
  61 {\r
  62     declare.time(20.0);\r
  63 \r
  64     cv::Size size = GET_PARAM(0);\r
  65     int depth = GET_PARAM(1);\r
  66     int channels = GET_PARAM(2);\r
  67     int interpolation = GET_PARAM(3);\r
  68     int borderMode = GET_PARAM(4);\r
  69     int remapMode = GET_PARAM(5);\r
  70 \r
  71     int type = CV_MAKE_TYPE(depth, channels);\r
  72 \r
  73     cv::Mat src(size, type);\r
  74     fillRandom(src);\r
  75 \r
  76     cv::Mat xmap(size, CV_32FC1);\r
  77     cv::Mat ymap(size, CV_32FC1);\r
  78 \r
  79     generateMap(xmap, ymap, remapMode);\r
  80 \r
  81     if (runOnGpu)\r
  82     {\r
  83         cv::gpu::GpuMat d_src(src);\r
  84         cv::gpu::GpuMat d_xmap(xmap);\r
  85         cv::gpu::GpuMat d_ymap(ymap);\r
  86         cv::gpu::GpuMat d_dst;\r
  87 \r
  88         cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);\r
  89 \r
  90         TEST_CYCLE()\r
  91         {\r
  92             cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);\r
  93         }\r
  94     }\r
  95     else\r
  96     {\r
  97         cv::Mat dst;\r
  98 \r
  99         cv::remap(src, dst, xmap, ymap, interpolation, borderMode);\r
 100 \r
 101         TEST_CYCLE()\r
 102         {\r
 103             cv::remap(src, dst, xmap, ymap, interpolation, borderMode);\r
 104         }\r
 105     }\r
 106 }\r
 107 \r
 108 //////////////////////////////////////////////////////////////////////\r
 109 // Resize\r
 110 \r
 111 DEF_PARAM_TEST(Sz_Depth_Cn_Inter_Scale, cv::Size, MatDepth, int, Interpolation, double);\r
 112 \r
 113 PERF_TEST_P(Sz_Depth_Cn_Inter_Scale, ImgProc_Resize, Combine(\r
 114     GPU_TYPICAL_MAT_SIZES,\r
 115     Values(CV_8U, CV_16U, CV_32F),\r
 116     Values(1, 3, 4),\r
 117     ALL_INTERPOLATIONS,\r
 118     Values(0.5, 0.3, 2.0)))\r
 119 {\r
 120     declare.time(20.0);\r
 121 \r
 122     cv::Size size = GET_PARAM(0);\r
 123     int depth = GET_PARAM(1);\r
 124     int channels = GET_PARAM(2);\r
 125     int interpolation = GET_PARAM(3);\r
 126     double f = GET_PARAM(4);\r
 127 \r
 128     int type = CV_MAKE_TYPE(depth, channels);\r
 129 \r
 130     cv::Mat src(size, type);\r
 131     fillRandom(src);\r
 132 \r
 133     if (runOnGpu)\r
 134     {\r
 135         cv::gpu::GpuMat d_src(src);\r
 136         cv::gpu::GpuMat d_dst;\r
 137 \r
 138         cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);\r
 139 \r
 140         TEST_CYCLE()\r
 141         {\r
 142             cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);\r
 143         }\r
 144     }\r
 145     else\r
 146     {\r
 147         cv::Mat dst;\r
 148 \r
 149         cv::resize(src, dst, cv::Size(), f, f, interpolation);\r
 150 \r
 151         TEST_CYCLE()\r
 152         {\r
 153             cv::resize(src, dst, cv::Size(), f, f, interpolation);\r
 154         }\r
 155     }\r
 156 }\r
 157 \r
 158 //////////////////////////////////////////////////////////////////////\r
 159 // ResizeArea\r
 160 \r
 161 DEF_PARAM_TEST(Sz_Depth_Cn_Scale, cv::Size, MatDepth, int, double);\r
 162 \r
 163 PERF_TEST_P(Sz_Depth_Cn_Scale, ImgProc_ResizeArea, Combine(\r
 164     GPU_TYPICAL_MAT_SIZES,\r
 165     Values(CV_8U, CV_16U, CV_32F),\r
 166     Values(1, 3, 4),\r
 167     Values(0.2, 0.1, 0.05)))\r
 168 {\r
 169     declare.time(1.0);\r
 170 \r
 171     cv::Size size = GET_PARAM(0);\r
 172     int depth = GET_PARAM(1);\r
 173     int channels = GET_PARAM(2);\r
 174     int interpolation = cv::INTER_AREA;\r
 175     double f = GET_PARAM(3);\r
 176 \r
 177     int type = CV_MAKE_TYPE(depth, channels);\r
 178 \r
 179     cv::Mat src(size, type);\r
 180     fillRandom(src);\r
 181 \r
 182     if (runOnGpu)\r
 183     {\r
 184         cv::gpu::GpuMat d_src(src);\r
 185         cv::gpu::GpuMat d_dst;\r
 186 \r
 187         cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);\r
 188 \r
 189         TEST_CYCLE()\r
 190         {\r
 191             cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);\r
 192         }\r
 193     }\r
 194     else\r
 195     {\r
 196         cv::Mat dst;\r
 197 \r
 198         cv::resize(src, dst, cv::Size(), f, f, interpolation);\r
 199 \r
 200         TEST_CYCLE()\r
 201         {\r
 202             cv::resize(src, dst, cv::Size(), f, f, interpolation);\r
 203         }\r
 204     }\r
 205 }\r
 206 \r
 207 //////////////////////////////////////////////////////////////////////\r
 208 // WarpAffine\r
 209 \r
 210 DEF_PARAM_TEST(Sz_Depth_Cn_Inter_Border, cv::Size, MatDepth, int, Interpolation, BorderMode);\r
 211 \r
 212 PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpAffine, Combine(\r
 213     GPU_TYPICAL_MAT_SIZES,\r
 214     Values(CV_8U, CV_16U, CV_32F),\r
 215     Values(1, 3, 4),\r
 216     Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),\r
 217     ALL_BORDER_MODES))\r
 218 {\r
 219     declare.time(20.0);\r
 220 \r
 221     cv::Size size = GET_PARAM(0);\r
 222     int depth = GET_PARAM(1);\r
 223     int channels = GET_PARAM(2);\r
 224     int interpolation = GET_PARAM(3);\r
 225     int borderMode = GET_PARAM(4);\r
 226 \r
 227     int type = CV_MAKE_TYPE(depth, channels);\r
 228 \r
 229     cv::Mat src(size, type);\r
 230     fillRandom(src);\r
 231 \r
 232     const double aplha = CV_PI / 4;\r
 233     double mat[2][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},\r
 234                          {std::sin(aplha),  std::cos(aplha), 0}};\r
 235     cv::Mat M(2, 3, CV_64F, (void*) mat);\r
 236 \r
 237     if (runOnGpu)\r
 238     {\r
 239         cv::gpu::GpuMat d_src(src);\r
 240         cv::gpu::GpuMat d_dst;\r
 241 \r
 242         cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode);\r
 243 \r
 244         TEST_CYCLE()\r
 245         {\r
 246             cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode);\r
 247         }\r
 248     }\r
 249     else\r
 250     {\r
 251         cv::Mat dst;\r
 252 \r
 253         cv::warpAffine(src, dst, M, size, interpolation, borderMode);\r
 254 \r
 255         TEST_CYCLE()\r
 256         {\r
 257             cv::warpAffine(src, dst, M, size, interpolation, borderMode);\r
 258         }\r
 259     }\r
 260 }\r
 261 \r
 262 //////////////////////////////////////////////////////////////////////\r
 263 // WarpPerspective\r
 264 \r
 265 PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpPerspective, Combine(\r
 266     GPU_TYPICAL_MAT_SIZES,\r
 267     Values(CV_8U, CV_16U, CV_32F),\r
 268     Values(1, 3, 4),\r
 269     Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),\r
 270     ALL_BORDER_MODES))\r
 271 {\r
 272     declare.time(20.0);\r
 273 \r
 274     cv::Size size = GET_PARAM(0);\r
 275     int depth = GET_PARAM(1);\r
 276     int channels = GET_PARAM(2);\r
 277     int interpolation = GET_PARAM(3);\r
 278     int borderMode = GET_PARAM(4);\r
 279 \r
 280     int type = CV_MAKE_TYPE(depth, channels);\r
 281 \r
 282     cv::Mat src(size, type);\r
 283     fillRandom(src);\r
 284 \r
 285     const double aplha = CV_PI / 4;\r
 286     double mat[3][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},\r
 287                          {std::sin(aplha),  std::cos(aplha), 0},\r
 288                          {0.0,              0.0,             1.0}};\r
 289     cv::Mat M(3, 3, CV_64F, (void*) mat);\r
 290 \r
 291     if (runOnGpu)\r
 292     {\r
 293         cv::gpu::GpuMat d_src(src);\r
 294         cv::gpu::GpuMat d_dst;\r
 295 \r
 296         cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode);\r
 297 \r
 298         TEST_CYCLE()\r
 299         {\r
 300             cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode);\r
 301         }\r
 302     }\r
 303     else\r
 304     {\r
 305         cv::Mat dst;\r
 306 \r
 307         cv::warpPerspective(src, dst, M, size, interpolation, borderMode);\r
 308 \r
 309         TEST_CYCLE()\r
 310         {\r
 311             cv::warpPerspective(src, dst, M, size, interpolation, borderMode);\r
 312         }\r
 313     }\r
 314 }\r
 315 \r
 316 //////////////////////////////////////////////////////////////////////\r
 317 // CopyMakeBorder\r
 318 \r
 319 DEF_PARAM_TEST(Sz_Depth_Cn_Border, cv::Size, MatDepth, int, BorderMode);\r
 320 \r
 321 PERF_TEST_P(Sz_Depth_Cn_Border, ImgProc_CopyMakeBorder, Combine(\r
 322     GPU_TYPICAL_MAT_SIZES,\r
 323     Values(CV_8U, CV_16U, CV_32F),\r
 324     Values(1, 3, 4),\r
 325     ALL_BORDER_MODES))\r
 326 {\r
 327     cv::Size size = GET_PARAM(0);\r
 328     int depth = GET_PARAM(1);\r
 329     int channels = GET_PARAM(2);\r
 330     int borderMode = GET_PARAM(3);\r
 331 \r
 332     int type = CV_MAKE_TYPE(depth, channels);\r
 333 \r
 334     cv::Mat src(size, type);\r
 335     fillRandom(src);\r
 336 \r
 337     if (runOnGpu)\r
 338     {\r
 339         cv::gpu::GpuMat d_src(src);\r
 340         cv::gpu::GpuMat d_dst;\r
 341 \r
 342         cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);\r
 343 \r
 344         TEST_CYCLE()\r
 345         {\r
 346             cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);\r
 347         }\r
 348     }\r
 349     else\r
 350     {\r
 351         cv::Mat dst;\r
 352 \r
 353         cv::copyMakeBorder(src, dst, 5, 5, 5, 5, borderMode);\r
 354 \r
 355         TEST_CYCLE()\r
 356         {\r
 357             cv::copyMakeBorder(src, dst, 5, 5, 5, 5, borderMode);\r
 358         }\r
 359     }\r
 360 }\r
 361 \r
 362 //////////////////////////////////////////////////////////////////////\r
 363 // Threshold\r
 364 \r
 365 CV_ENUM(ThreshOp, cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV)\r
 366 #define ALL_THRESH_OPS ValuesIn(ThreshOp::all())\r
 367 \r
 368 DEF_PARAM_TEST(Sz_Depth_Op, cv::Size, MatDepth, ThreshOp);\r
 369 \r
 370 PERF_TEST_P(Sz_Depth_Op, ImgProc_Threshold, Combine(\r
 371     GPU_TYPICAL_MAT_SIZES,\r
 372     Values(CV_8U, CV_16U, CV_32F, CV_64F),\r
 373     ALL_THRESH_OPS))\r
 374 {\r
 375     cv::Size size = GET_PARAM(0);\r
 376     int depth = GET_PARAM(1);\r
 377     int threshOp = GET_PARAM(2);\r
 378 \r
 379     cv::Mat src(size, depth);\r
 380     fillRandom(src);\r
 381 \r
 382     if (runOnGpu)\r
 383     {\r
 384         cv::gpu::GpuMat d_src(src);\r
 385         cv::gpu::GpuMat d_dst;\r
 386 \r
 387         cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);\r
 388 \r
 389         TEST_CYCLE()\r
 390         {\r
 391             cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);\r
 392         }\r
 393     }\r
 394     else\r
 395     {\r
 396         cv::Mat dst;\r
 397 \r
 398         cv::threshold(src, dst, 100.0, 255.0, threshOp);\r
 399 \r
 400         TEST_CYCLE()\r
 401         {\r
 402             cv::threshold(src, dst, 100.0, 255.0, threshOp);\r
 403         }\r
 404     }\r
 405 }\r
 406 \r
 407 //////////////////////////////////////////////////////////////////////\r
 408 // Integral\r
 409 \r
 410 PERF_TEST_P(Sz, ImgProc_Integral, GPU_TYPICAL_MAT_SIZES)\r
 411 {\r
 412     cv::Size size = GetParam();\r
 413 \r
 414     cv::Mat src(size, CV_8UC1);\r
 415     fillRandom(src);\r
 416 \r
 417     if (runOnGpu)\r
 418     {\r
 419         cv::gpu::GpuMat d_src(src);\r
 420         cv::gpu::GpuMat d_dst;\r
 421         cv::gpu::GpuMat d_buf;\r
 422 \r
 423         cv::gpu::integralBuffered(d_src, d_dst, d_buf);\r
 424 \r
 425         TEST_CYCLE()\r
 426         {\r
 427             cv::gpu::integralBuffered(d_src, d_dst, d_buf);\r
 428         }\r
 429     }\r
 430     else\r
 431     {\r
 432         cv::Mat dst;\r
 433 \r
 434         cv::integral(src, dst);\r
 435 \r
 436         TEST_CYCLE()\r
 437         {\r
 438             cv::integral(src, dst);\r
 439         }\r
 440     }\r
 441 }\r
 442 \r
 443 //////////////////////////////////////////////////////////////////////\r
 444 // IntegralSqr\r
 445 \r
 446 PERF_TEST_P(Sz, ImgProc_IntegralSqr, GPU_TYPICAL_MAT_SIZES)\r
 447 {\r
 448     cv::Size size = GetParam();\r
 449 \r
 450     cv::Mat src(size, CV_8UC1);\r
 451     fillRandom(src);\r
 452 \r
 453     if (runOnGpu)\r
 454     {\r
 455         cv::gpu::GpuMat d_src(src);\r
 456         cv::gpu::GpuMat d_dst;\r
 457 \r
 458         cv::gpu::sqrIntegral(d_src, d_dst);\r
 459 \r
 460         TEST_CYCLE()\r
 461         {\r
 462             cv::gpu::sqrIntegral(d_src, d_dst);\r
 463         }\r
 464     }\r
 465     else\r
 466     {\r
 467         FAIL();\r
 468     }\r
 469 }\r
 470 \r
 471 //////////////////////////////////////////////////////////////////////\r
 472 // HistEvenC1\r
 473 \r
 474 PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC1, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_16S)))\r
 475 {\r
 476     cv::Size size = GET_PARAM(0);\r
 477     int depth = GET_PARAM(1);\r
 478 \r
 479     cv::Mat src(size, depth);\r
 480     fillRandom(src);\r
 481 \r
 482     if (runOnGpu)\r
 483     {\r
 484         cv::gpu::GpuMat d_src(src);\r
 485         cv::gpu::GpuMat d_hist;\r
 486         cv::gpu::GpuMat d_buf;\r
 487 \r
 488         cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);\r
 489 \r
 490         TEST_CYCLE()\r
 491         {\r
 492             cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);\r
 493         }\r
 494     }\r
 495     else\r
 496     {\r
 497         int hbins = 30;\r
 498         float hranges[] = {0.0f, 180.0f};\r
 499         int histSize[] = {hbins};\r
 500         const float* ranges[] = {hranges};\r
 501         int channels[] = {0};\r
 502 \r
 503         cv::Mat hist;\r
 504 \r
 505         cv::calcHist(&src, 1, channels, cv::Mat(), hist, 1, histSize, ranges);\r
 506 \r
 507         TEST_CYCLE()\r
 508         {\r
 509             cv::calcHist(&src, 1, channels, cv::Mat(), hist, 1, histSize, ranges);\r
 510         }\r
 511     }\r
 512 }\r
 513 \r
 514 //////////////////////////////////////////////////////////////////////\r
 515 // HistEvenC4\r
 516 \r
 517 PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC4, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_16S)))\r
 518 {\r
 519     cv::Size size = GET_PARAM(0);\r
 520     int depth = GET_PARAM(1);\r
 521 \r
 522     cv::Mat src(size, CV_MAKE_TYPE(depth, 4));\r
 523     fillRandom(src);\r
 524 \r
 525     int histSize[] = {30, 30, 30, 30};\r
 526     int lowerLevel[] = {0, 0, 0, 0};\r
 527     int upperLevel[] = {180, 180, 180, 180};\r
 528 \r
 529     if (runOnGpu)\r
 530     {\r
 531         cv::gpu::GpuMat d_src(src);\r
 532         cv::gpu::GpuMat d_hist[4];\r
 533         cv::gpu::GpuMat d_buf;\r
 534 \r
 535         cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);\r
 536 \r
 537         TEST_CYCLE()\r
 538         {\r
 539             cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);\r
 540         }\r
 541     }\r
 542     else\r
 543     {\r
 544         FAIL();\r
 545     }\r
 546 }\r
 547 \r
 548 //////////////////////////////////////////////////////////////////////\r
 549 // CalcHist\r
 550 \r
 551 PERF_TEST_P(Sz, ImgProc_CalcHist, GPU_TYPICAL_MAT_SIZES)\r
 552 {\r
 553     cv::Size size = GetParam();\r
 554 \r
 555     cv::Mat src(size, CV_8UC1);\r
 556     fillRandom(src);\r
 557 \r
 558     if (runOnGpu)\r
 559     {\r
 560         cv::gpu::GpuMat d_src(src);\r
 561         cv::gpu::GpuMat d_hist;\r
 562         cv::gpu::GpuMat d_buf;\r
 563 \r
 564         cv::gpu::calcHist(d_src, d_hist, d_buf);\r
 565 \r
 566         TEST_CYCLE()\r
 567         {\r
 568             cv::gpu::calcHist(d_src, d_hist, d_buf);\r
 569         }\r
 570     }\r
 571     else\r
 572     {\r
 573         FAIL();\r
 574     }\r
 575 }\r
 576 \r
 577 //////////////////////////////////////////////////////////////////////\r
 578 // EqualizeHist\r
 579 \r
 580 PERF_TEST_P(Sz, ImgProc_EqualizeHist, GPU_TYPICAL_MAT_SIZES)\r
 581 {\r
 582     cv::Size size = GetParam();\r
 583 \r
 584     cv::Mat src(size, CV_8UC1);\r
 585     fillRandom(src);\r
 586 \r
 587     if (runOnGpu)\r
 588     {\r
 589         cv::gpu::GpuMat d_src(src);\r
 590         cv::gpu::GpuMat d_dst;\r
 591         cv::gpu::GpuMat d_hist;\r
 592         cv::gpu::GpuMat d_buf;\r
 593 \r
 594         cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);\r
 595 \r
 596         TEST_CYCLE()\r
 597         {\r
 598             cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);\r
 599         }\r
 600     }\r
 601     else\r
 602     {\r
 603         cv::Mat dst;\r
 604 \r
 605         cv::equalizeHist(src, dst);\r
 606 \r
 607         TEST_CYCLE()\r
 608         {\r
 609             cv::equalizeHist(src, dst);\r
 610         }\r
 611     }\r
 612 }\r
 613 \r
 614 //////////////////////////////////////////////////////////////////////\r
 615 // ColumnSum\r
 616 \r
 617 PERF_TEST_P(Sz, ImgProc_ColumnSum, GPU_TYPICAL_MAT_SIZES)\r
 618 {\r
 619     cv::Size size = GetParam();\r
 620 \r
 621     cv::Mat src(size, CV_32FC1);\r
 622     fillRandom(src);\r
 623 \r
 624     if (runOnGpu)\r
 625     {\r
 626         cv::gpu::GpuMat d_src(src);\r
 627         cv::gpu::GpuMat d_dst;\r
 628 \r
 629         cv::gpu::columnSum(d_src, d_dst);\r
 630 \r
 631         TEST_CYCLE()\r
 632         {\r
 633             cv::gpu::columnSum(d_src, d_dst);\r
 634         }\r
 635     }\r
 636     else\r
 637     {\r
 638         FAIL();\r
 639     }\r
 640 }\r
 641 \r
 642 //////////////////////////////////////////////////////////////////////\r
 643 // Canny\r
 644 \r
 645 DEF_PARAM_TEST(Image_AppertureSz_L2gradient, string, int, bool);\r
 646 \r
 647 PERF_TEST_P(Image_AppertureSz_L2gradient, ImgProc_Canny, Combine(\r
 648     Values("perf/800x600.jpg", "perf/1280x1024.jpg", "perf/1680x1050.jpg"),\r
 649     Values(3, 5),\r
 650     Bool()))\r
 651 {\r
 652     string fileName = GET_PARAM(0);\r
 653     int apperture_size = GET_PARAM(1);\r
 654     bool useL2gradient = GET_PARAM(2);\r
 655 \r
 656     cv::Mat image = readImage(fileName, cv::IMREAD_GRAYSCALE);\r
 657     ASSERT_FALSE(image.empty());\r
 658 \r
 659     if (runOnGpu)\r
 660     {\r
 661         cv::gpu::GpuMat d_image(image);\r
 662         cv::gpu::GpuMat d_dst;\r
 663         cv::gpu::CannyBuf d_buf;\r
 664 \r
 665         cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient);\r
 666 \r
 667         TEST_CYCLE()\r
 668         {\r
 669             cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient);\r
 670         }\r
 671     }\r
 672     else\r
 673     {\r
 674         cv::Mat dst;\r
 675 \r
 676         cv::Canny(image, dst, 50.0, 100.0, apperture_size, useL2gradient);\r
 677 \r
 678         TEST_CYCLE()\r
 679         {\r
 680             cv::Canny(image, dst, 50.0, 100.0, apperture_size, useL2gradient);\r
 681         }\r
 682     }\r
 683 }\r
 684 \r
 685 //////////////////////////////////////////////////////////////////////\r
 686 // MeanShiftFiltering\r
 687 \r
 688 DEF_PARAM_TEST_1(Image, string);\r
 689 \r
 690 PERF_TEST_P(Image, ImgProc_MeanShiftFiltering, Values<string>("gpu/meanshift/cones.png"))\r
 691 {\r
 692     declare.time(15.0);\r
 693 \r
 694     cv::Mat img = readImage(GetParam());\r
 695     ASSERT_FALSE(img.empty());\r
 696 \r
 697     cv::Mat rgba;\r
 698     cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);\r
 699 \r
 700     if (runOnGpu)\r
 701     {\r
 702         cv::gpu::GpuMat d_src(rgba);\r
 703         cv::gpu::GpuMat d_dst;\r
 704 \r
 705         cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);\r
 706 \r
 707         TEST_CYCLE()\r
 708         {\r
 709             cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);\r
 710         }\r
 711     }\r
 712     else\r
 713     {\r
 714         cv::Mat dst;\r
 715 \r
 716         cv::pyrMeanShiftFiltering(img, dst, 50, 50);\r
 717 \r
 718         TEST_CYCLE()\r
 719         {\r
 720             cv::pyrMeanShiftFiltering(img, dst, 50, 50);\r
 721         }\r
 722     }\r
 723 }\r
 724 \r
 725 //////////////////////////////////////////////////////////////////////\r
 726 // MeanShiftProc\r
 727 \r
 728 PERF_TEST_P(Image, ImgProc_MeanShiftProc, Values<string>("gpu/meanshift/cones.png"))\r
 729 {\r
 730     declare.time(5.0);\r
 731 \r
 732     cv::Mat img = readImage(GetParam());\r
 733     ASSERT_FALSE(img.empty());\r
 734 \r
 735     cv::Mat rgba;\r
 736     cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);\r
 737 \r
 738     if (runOnGpu)\r
 739     {\r
 740         cv::gpu::GpuMat d_src(rgba);\r
 741         cv::gpu::GpuMat d_dstr;\r
 742         cv::gpu::GpuMat d_dstsp;\r
 743 \r
 744         cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);\r
 745 \r
 746         TEST_CYCLE()\r
 747         {\r
 748             cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);\r
 749         }\r
 750     }\r
 751     else\r
 752     {\r
 753         FAIL();\r
 754     }\r
 755 }\r
 756 \r
 757 //////////////////////////////////////////////////////////////////////\r
 758 // MeanShiftSegmentation\r
 759 \r
 760 PERF_TEST_P(Image, ImgProc_MeanShiftSegmentation, Values<string>("gpu/meanshift/cones.png"))\r
 761 {\r
 762     declare.time(5.0);\r
 763 \r
 764     cv::Mat img = readImage(GetParam());\r
 765     ASSERT_FALSE(img.empty());\r
 766 \r
 767     cv::Mat rgba;\r
 768     cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);\r
 769 \r
 770     cv::Mat dst;\r
 771 \r
 772     if (runOnGpu)\r
 773     {\r
 774         cv::gpu::GpuMat d_src(rgba);\r
 775 \r
 776         cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);\r
 777 \r
 778         TEST_CYCLE()\r
 779         {\r
 780             cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);\r
 781         }\r
 782     }\r
 783     else\r
 784     {\r
 785         FAIL();\r
 786     }\r
 787 }\r
 788 \r
 789 //////////////////////////////////////////////////////////////////////\r
 790 // BlendLinear\r
 791 \r
 792 PERF_TEST_P(Sz_Depth_Cn, ImgProc_BlendLinear, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_32F), Values(1, 3, 4)))\r
 793 {\r
 794     cv::Size size = GET_PARAM(0);\r
 795     int depth = GET_PARAM(1);\r
 796     int channels = GET_PARAM(2);\r
 797 \r
 798     int type = CV_MAKE_TYPE(depth, channels);\r
 799 \r
 800     cv::Mat img1(size, type);\r
 801     fillRandom(img1);\r
 802 \r
 803     cv::Mat img2(size, type);\r
 804     fillRandom(img2);\r
 805 \r
 806     if (runOnGpu)\r
 807     {\r
 808         cv::gpu::GpuMat d_img1(img1);\r
 809         cv::gpu::GpuMat d_img2(img2);\r
 810         cv::gpu::GpuMat d_weights1(size, CV_32FC1, cv::Scalar::all(0.5));\r
 811         cv::gpu::GpuMat d_weights2(size, CV_32FC1, cv::Scalar::all(0.5));\r
 812         cv::gpu::GpuMat d_dst;\r
 813 \r
 814         cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);\r
 815 \r
 816         TEST_CYCLE()\r
 817         {\r
 818             cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);\r
 819         }\r
 820     }\r
 821     else\r
 822     {\r
 823         FAIL();\r
 824     }\r
 825 }\r
 826 \r
 827 //////////////////////////////////////////////////////////////////////\r
 828 // Convolve\r
 829 \r
 830 DEF_PARAM_TEST(Sz_KernelSz_Ccorr, cv::Size, int, bool);\r
 831 \r
 832 PERF_TEST_P(Sz_KernelSz_Ccorr, ImgProc_Convolve, Combine(GPU_TYPICAL_MAT_SIZES, Values(17, 27, 32, 64), Bool()))\r
 833 {\r
 834     declare.time(10.0);\r
 835 \r
 836     cv::Size size = GET_PARAM(0);\r
 837     int templ_size = GET_PARAM(1);\r
 838     bool ccorr = GET_PARAM(2);\r
 839 \r
 840     cv::Mat image(size, CV_32FC1);\r
 841     image.setTo(1.0);\r
 842 \r
 843     cv::Mat templ(templ_size, templ_size, CV_32FC1);\r
 844     templ.setTo(1.0);\r
 845 \r
 846     if (runOnGpu)\r
 847     {\r
 848         cv::gpu::GpuMat d_image = cv::gpu::createContinuous(size, CV_32FC1);\r
 849         d_image.upload(image);\r
 850 \r
 851         cv::gpu::GpuMat d_templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);\r
 852         d_templ.upload(templ);\r
 853 \r
 854         cv::gpu::GpuMat d_dst;\r
 855         cv::gpu::ConvolveBuf d_buf;\r
 856 \r
 857         cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);\r
 858 \r
 859         TEST_CYCLE()\r
 860         {\r
 861             cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);\r
 862         }\r
 863     }\r
 864     else\r
 865     {\r
 866         ASSERT_FALSE(ccorr);\r
 867 \r
 868         cv::Mat dst;\r
 869 \r
 870         cv::filter2D(image, dst, image.depth(), templ);\r
 871 \r
 872         TEST_CYCLE()\r
 873         {\r
 874             cv::filter2D(image, dst, image.depth(), templ);\r
 875         }\r
 876     }\r
 877 }\r
 878 \r
 879 ////////////////////////////////////////////////////////////////////////////////\r
 880 // MatchTemplate8U\r
 881 \r
 882 CV_ENUM(TemplateMethod, cv::TM_SQDIFF, cv::TM_SQDIFF_NORMED, cv::TM_CCORR, cv::TM_CCORR_NORMED, cv::TM_CCOEFF, cv::TM_CCOEFF_NORMED)\r
 883 #define ALL_TEMPLATE_METHODS ValuesIn(TemplateMethod::all())\r
 884 \r
 885 DEF_PARAM_TEST(Sz_TemplateSz_Cn_Method, cv::Size, cv::Size, int, TemplateMethod);\r
 886 \r
 887 PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate8U, Combine(\r
 888     GPU_TYPICAL_MAT_SIZES,\r
 889     Values(cv::Size(5, 5), cv::Size(16, 16), cv::Size(30, 30)),\r
 890     Values(1, 3, 4),\r
 891     ALL_TEMPLATE_METHODS))\r
 892 {\r
 893     cv::Size size = GET_PARAM(0);\r
 894     cv::Size templ_size = GET_PARAM(1);\r
 895     int cn = GET_PARAM(2);\r
 896     int method = GET_PARAM(3);\r
 897 \r
 898     cv::Mat image(size, CV_MAKE_TYPE(CV_8U, cn));\r
 899     fillRandom(image);\r
 900 \r
 901     cv::Mat templ(templ_size, CV_MAKE_TYPE(CV_8U, cn));\r
 902     fillRandom(templ);\r
 903 \r
 904     if (runOnGpu)\r
 905     {\r
 906         cv::gpu::GpuMat d_image(image);\r
 907         cv::gpu::GpuMat d_templ(templ);\r
 908         cv::gpu::GpuMat d_dst;\r
 909 \r
 910         cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);\r
 911 \r
 912         TEST_CYCLE()\r
 913         {\r
 914             cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);\r
 915         }\r
 916     }\r
 917     else\r
 918     {\r
 919         cv::Mat dst;\r
 920 \r
 921         cv::matchTemplate(image, templ, dst, method);\r
 922 \r
 923         TEST_CYCLE()\r
 924         {\r
 925             cv::matchTemplate(image, templ, dst, method);\r
 926         }\r
 927     }\r
 928 };\r
 929 \r
 930 ////////////////////////////////////////////////////////////////////////////////\r
 931 // MatchTemplate32F\r
 932 \r
 933 PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate32F, Combine(\r
 934     GPU_TYPICAL_MAT_SIZES,\r
 935     Values(cv::Size(5, 5), cv::Size(16, 16), cv::Size(30, 30)),\r
 936     Values(1, 3, 4),\r
 937     Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_CCORR))))\r
 938 {\r
 939     cv::Size size = GET_PARAM(0);\r
 940     cv::Size templ_size = GET_PARAM(1);\r
 941     int cn = GET_PARAM(2);\r
 942     int method = GET_PARAM(3);\r
 943 \r
 944     cv::Mat image(size, CV_MAKE_TYPE(CV_32F, cn));\r
 945     fillRandom(image);\r
 946 \r
 947     cv::Mat templ(templ_size, CV_MAKE_TYPE(CV_32F, cn));\r
 948     fillRandom(templ);\r
 949 \r
 950     if (runOnGpu)\r
 951     {\r
 952         cv::gpu::GpuMat d_image(image);\r
 953         cv::gpu::GpuMat d_templ(templ);\r
 954         cv::gpu::GpuMat d_dst;\r
 955 \r
 956         cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);\r
 957 \r
 958         TEST_CYCLE()\r
 959         {\r
 960             cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);\r
 961         }\r
 962     }\r
 963     else\r
 964     {\r
 965         cv::Mat dst;\r
 966 \r
 967         cv::matchTemplate(image, templ, dst, method);\r
 968 \r
 969         TEST_CYCLE()\r
 970         {\r
 971             cv::matchTemplate(image, templ, dst, method);\r
 972         }\r
 973     }\r
 974 };\r
 975 \r
 976 //////////////////////////////////////////////////////////////////////\r
 977 // MulSpectrums\r
 978 \r
 979 CV_FLAGS(DftFlags, 0, cv::DFT_INVERSE, cv::DFT_SCALE, cv::DFT_ROWS, cv::DFT_COMPLEX_OUTPUT, cv::DFT_REAL_OUTPUT)\r
 980 \r
 981 DEF_PARAM_TEST(Sz_Flags, cv::Size, DftFlags);\r
 982 \r
 983 PERF_TEST_P(Sz_Flags, ImgProc_MulSpectrums, Combine(\r
 984     GPU_TYPICAL_MAT_SIZES,\r
 985     Values(0, DftFlags(cv::DFT_ROWS))))\r
 986 {\r
 987     cv::Size size = GET_PARAM(0);\r
 988     int flag = GET_PARAM(1);\r
 989 \r
 990     cv::Mat a(size, CV_32FC2);\r
 991     fillRandom(a, 0, 100);\r
 992 \r
 993     cv::Mat b(size, CV_32FC2);\r
 994     fillRandom(b, 0, 100);\r
 995 \r
 996     if (runOnGpu)\r
 997     {\r
 998         cv::gpu::GpuMat d_a(a);\r
 999         cv::gpu::GpuMat d_b(b);\r
1000         cv::gpu::GpuMat d_dst;\r
1001 \r
1002         cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);\r
1003 \r
1004         TEST_CYCLE()\r
1005         {\r
1006             cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);\r
1007         }\r
1008     }\r
1009     else\r
1010     {\r
1011         cv::Mat dst;\r
1012 \r
1013         cv::mulSpectrums(a, b, dst, flag);\r
1014 \r
1015         TEST_CYCLE()\r
1016         {\r
1017             cv::mulSpectrums(a, b, dst, flag);\r
1018         }\r
1019     }\r
1020 }\r
1021 \r
1022 //////////////////////////////////////////////////////////////////////\r
1023 // MulAndScaleSpectrums\r
1024 \r
1025 PERF_TEST_P(Sz, ImgProc_MulAndScaleSpectrums, GPU_TYPICAL_MAT_SIZES)\r
1026 {\r
1027     cv::Size size = GetParam();\r
1028 \r
1029     float scale = 1.f / size.area();\r
1030 \r
1031     cv::Mat src1(size, CV_32FC2);\r
1032     fillRandom(src1, 0, 100);\r
1033 \r
1034     cv::Mat src2(size, CV_32FC2);\r
1035     fillRandom(src2, 0, 100);\r
1036 \r
1037     if (runOnGpu)\r
1038     {\r
1039         cv::gpu::GpuMat d_src1(src1);\r
1040         cv::gpu::GpuMat d_src2(src2);\r
1041         cv::gpu::GpuMat d_dst;\r
1042 \r
1043         cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);\r
1044 \r
1045         TEST_CYCLE()\r
1046         {\r
1047             cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);\r
1048         }\r
1049     }\r
1050     else\r
1051     {\r
1052         FAIL();\r
1053     }\r
1054 }\r
1055 \r
1056 //////////////////////////////////////////////////////////////////////\r
1057 // Dft\r
1058 \r
1059 PERF_TEST_P(Sz_Flags, ImgProc_Dft, Combine(\r
1060     GPU_TYPICAL_MAT_SIZES,\r
1061     Values(0, DftFlags(cv::DFT_ROWS), DftFlags(cv::DFT_INVERSE))))\r
1062 {\r
1063     declare.time(10.0);\r
1064 \r
1065     cv::Size size = GET_PARAM(0);\r
1066     int flag = GET_PARAM(1);\r
1067 \r
1068     cv::Mat src(size, CV_32FC2);\r
1069     fillRandom(src, 0, 100);\r
1070 \r
1071     if (runOnGpu)\r
1072     {\r
1073         cv::gpu::GpuMat d_src(src);\r
1074         cv::gpu::GpuMat d_dst;\r
1075 \r
1076         cv::gpu::dft(d_src, d_dst, size, flag);\r
1077 \r
1078         TEST_CYCLE()\r
1079         {\r
1080             cv::gpu::dft(d_src, d_dst, size, flag);\r
1081         }\r
1082     }\r
1083     else\r
1084     {\r
1085         cv::Mat dst;\r
1086 \r
1087         cv::dft(src, dst, flag);\r
1088 \r
1089         TEST_CYCLE()\r
1090         {\r
1091             cv::dft(src, dst, flag);\r
1092         }\r
1093     }\r
1094 }\r
1095 \r
1096 //////////////////////////////////////////////////////////////////////\r
1097 // CornerHarris\r
1098 \r
1099 DEF_PARAM_TEST(Image_Type_Border_BlockSz_ApertureSz, string, MatType, BorderMode, int, int);\r
1100 \r
1101 PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerHarris, Combine(\r
1102     Values<string>("gpu/stereobm/aloe-L.png"),\r
1103     Values(CV_8UC1, CV_32FC1),\r
1104     Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_REFLECT)),\r
1105     Values(3, 5, 7),\r
1106     Values(0, 3, 5, 7)))\r
1107 {\r
1108     string fileName = GET_PARAM(0);\r
1109     int type = GET_PARAM(1);\r
1110     int borderMode = GET_PARAM(2);\r
1111     int blockSize = GET_PARAM(3);\r
1112     int apertureSize = GET_PARAM(4);\r
1113 \r
1114     cv::Mat img = readImage(fileName, cv::IMREAD_GRAYSCALE);\r
1115     ASSERT_FALSE(img.empty());\r
1116     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
1117 \r
1118     double k = 0.5;\r
1119 \r
1120     if (runOnGpu)\r
1121     {\r
1122         cv::gpu::GpuMat d_img(img);\r
1123         cv::gpu::GpuMat d_dst;\r
1124         cv::gpu::GpuMat d_Dx;\r
1125         cv::gpu::GpuMat d_Dy;\r
1126         cv::gpu::GpuMat d_buf;\r
1127 \r
1128         cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);\r
1129 \r
1130         TEST_CYCLE()\r
1131         {\r
1132             cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);\r
1133         }\r
1134     }\r
1135     else\r
1136     {\r
1137         cv::Mat dst;\r
1138 \r
1139         cv::cornerHarris(img, dst, blockSize, apertureSize, k, borderMode);\r
1140 \r
1141         TEST_CYCLE()\r
1142         {\r
1143             cv::cornerHarris(img, dst, blockSize, apertureSize, k, borderMode);\r
1144         }\r
1145     }\r
1146 }\r
1147 \r
1148 //////////////////////////////////////////////////////////////////////\r
1149 // CornerMinEigenVal\r
1150 \r
1151 PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerMinEigenVal, Combine(\r
1152     Values<string>("gpu/stereobm/aloe-L.png"),\r
1153     Values(CV_8UC1, CV_32FC1),\r
1154     Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_REFLECT)),\r
1155     Values(3, 5, 7),\r
1156     Values(0, 3, 5, 7)))\r
1157 {\r
1158     string fileName = GET_PARAM(0);\r
1159     int type = GET_PARAM(1);\r
1160     int borderMode = GET_PARAM(2);\r
1161     int blockSize = GET_PARAM(3);\r
1162     int apertureSize = GET_PARAM(4);\r
1163 \r
1164     cv::Mat img = readImage(fileName, cv::IMREAD_GRAYSCALE);\r
1165     ASSERT_FALSE(img.empty());\r
1166 \r
1167     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
1168 \r
1169     if (runOnGpu)\r
1170     {\r
1171         cv::gpu::GpuMat d_img(img);\r
1172         cv::gpu::GpuMat d_dst;\r
1173         cv::gpu::GpuMat d_Dx;\r
1174         cv::gpu::GpuMat d_Dy;\r
1175         cv::gpu::GpuMat d_buf;\r
1176 \r
1177         cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);\r
1178 \r
1179         TEST_CYCLE()\r
1180         {\r
1181             cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);\r
1182         }\r
1183     }\r
1184     else\r
1185     {\r
1186         cv::Mat dst;\r
1187 \r
1188         cv::cornerMinEigenVal(img, dst, blockSize, apertureSize, borderMode);\r
1189 \r
1190         TEST_CYCLE()\r
1191         {\r
1192             cv::cornerMinEigenVal(img, dst, blockSize, apertureSize, borderMode);\r
1193         }\r
1194     }\r
1195 }\r
1196 \r
1197 //////////////////////////////////////////////////////////////////////\r
1198 // BuildWarpPlaneMaps\r
1199 \r
1200 PERF_TEST_P(Sz, ImgProc_BuildWarpPlaneMaps, GPU_TYPICAL_MAT_SIZES)\r
1201 {\r
1202     cv::Size size = GetParam();\r
1203 \r
1204     cv::Mat K = cv::Mat::eye(3, 3, CV_32FC1);\r
1205     cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1);\r
1206     cv::Mat T = cv::Mat::zeros(1, 3, CV_32F);\r
1207 \r
1208     if (runOnGpu)\r
1209     {\r
1210         cv::gpu::GpuMat d_map_x;\r
1211         cv::gpu::GpuMat d_map_y;\r
1212 \r
1213         cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y);\r
1214 \r
1215         TEST_CYCLE()\r
1216         {\r
1217             cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y);\r
1218         }\r
1219     }\r
1220     else\r
1221     {\r
1222         FAIL();\r
1223     }\r
1224 }\r
1225 \r
1226 //////////////////////////////////////////////////////////////////////\r
1227 // BuildWarpCylindricalMaps\r
1228 \r
1229 PERF_TEST_P(Sz, ImgProc_BuildWarpCylindricalMaps, GPU_TYPICAL_MAT_SIZES)\r
1230 {\r
1231     cv::Size size = GetParam();\r
1232 \r
1233     cv::Mat K = cv::Mat::eye(3, 3, CV_32FC1);\r
1234     cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1);\r
1235 \r
1236     if (runOnGpu)\r
1237     {\r
1238         cv::gpu::GpuMat d_map_x;\r
1239         cv::gpu::GpuMat d_map_y;\r
1240 \r
1241         cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);\r
1242 \r
1243         TEST_CYCLE()\r
1244         {\r
1245             cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);\r
1246         }\r
1247     }\r
1248     else\r
1249     {\r
1250         FAIL();\r
1251     }\r
1252 }\r
1253 \r
1254 //////////////////////////////////////////////////////////////////////\r
1255 // BuildWarpSphericalMaps\r
1256 \r
1257 PERF_TEST_P(Sz, ImgProc_BuildWarpSphericalMaps, GPU_TYPICAL_MAT_SIZES)\r
1258 {\r
1259     cv::Size size = GetParam();\r
1260 \r
1261     cv::Mat K = cv::Mat::eye(3, 3, CV_32FC1);\r
1262     cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1);\r
1263 \r
1264     if (runOnGpu)\r
1265     {\r
1266         cv::gpu::GpuMat d_map_x;\r
1267         cv::gpu::GpuMat d_map_y;\r
1268 \r
1269         cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);\r
1270 \r
1271         TEST_CYCLE()\r
1272         {\r
1273             cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);\r
1274         }\r
1275     }\r
1276     else\r
1277     {\r
1278         FAIL();\r
1279     }\r
1280 }\r
1281 \r
1282 //////////////////////////////////////////////////////////////////////\r
1283 // Rotate\r
1284 \r
1285 DEF_PARAM_TEST(Sz_Depth_Cn_Inter, cv::Size, MatDepth, int, Interpolation);\r
1286 \r
1287 PERF_TEST_P(Sz_Depth_Cn_Inter, ImgProc_Rotate, Combine(\r
1288     GPU_TYPICAL_MAT_SIZES,\r
1289     Values(CV_8U, CV_16U, CV_32F),\r
1290     Values(1, 3, 4),\r
1291     Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC))))\r
1292 {\r
1293     cv::Size size = GET_PARAM(0);\r
1294     int depth = GET_PARAM(1);\r
1295     int channels = GET_PARAM(2);\r
1296     int interpolation = GET_PARAM(3);\r
1297 \r
1298     int type = CV_MAKE_TYPE(depth, channels);\r
1299 \r
1300     cv::Mat src(size, type);\r
1301     fillRandom(src);\r
1302 \r
1303     if (runOnGpu)\r
1304     {\r
1305         cv::gpu::GpuMat d_src(src);\r
1306         cv::gpu::GpuMat d_dst;\r
1307 \r
1308         cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);\r
1309 \r
1310         TEST_CYCLE()\r
1311         {\r
1312             cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);\r
1313         }\r
1314     }\r
1315     else\r
1316     {\r
1317         FAIL();\r
1318     }\r
1319 }\r
1320 \r
1321 //////////////////////////////////////////////////////////////////////\r
1322 // PyrDown\r
1323 \r
1324 PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrDown, Combine(\r
1325     GPU_TYPICAL_MAT_SIZES,\r
1326     Values(CV_8U, CV_16U, CV_32F),\r
1327     Values(1, 3, 4)))\r
1328 {\r
1329     cv::Size size = GET_PARAM(0);\r
1330     int depth = GET_PARAM(1);\r
1331     int channels = GET_PARAM(2);\r
1332 \r
1333     int type = CV_MAKE_TYPE(depth, channels);\r
1334 \r
1335     cv::Mat src(size, type);\r
1336     fillRandom(src);\r
1337 \r
1338     if (runOnGpu)\r
1339     {\r
1340         cv::gpu::GpuMat d_src(src);\r
1341         cv::gpu::GpuMat d_dst;\r
1342 \r
1343         cv::gpu::pyrDown(d_src, d_dst);\r
1344 \r
1345         TEST_CYCLE()\r
1346         {\r
1347             cv::gpu::pyrDown(d_src, d_dst);\r
1348         }\r
1349     }\r
1350     else\r
1351     {\r
1352         cv::Mat dst;\r
1353 \r
1354         cv::pyrDown(src, dst);\r
1355 \r
1356         TEST_CYCLE()\r
1357         {\r
1358             cv::pyrDown(src, dst);\r
1359         }\r
1360     }\r
1361 }\r
1362 \r
1363 //////////////////////////////////////////////////////////////////////\r
1364 // PyrUp\r
1365 \r
1366 PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrUp, Combine(\r
1367     GPU_TYPICAL_MAT_SIZES,\r
1368     Values(CV_8U, CV_16U, CV_32F),\r
1369     Values(1, 3, 4)))\r
1370 {\r
1371     cv::Size size = GET_PARAM(0);\r
1372     int depth = GET_PARAM(1);\r
1373     int channels = GET_PARAM(2);\r
1374 \r
1375     int type = CV_MAKE_TYPE(depth, channels);\r
1376 \r
1377     cv::Mat src(size, type);\r
1378     fillRandom(src);\r
1379 \r
1380     if (runOnGpu)\r
1381     {\r
1382         cv::gpu::GpuMat d_src(src);\r
1383         cv::gpu::GpuMat d_dst;\r
1384 \r
1385         cv::gpu::pyrUp(d_src, d_dst);\r
1386 \r
1387         TEST_CYCLE()\r
1388         {\r
1389             cv::gpu::pyrUp(d_src, d_dst);\r
1390         }\r
1391     }\r
1392     else\r
1393     {\r
1394         cv::Mat dst;\r
1395 \r
1396         cv::pyrUp(src, dst);\r
1397 \r
1398         TEST_CYCLE()\r
1399         {\r
1400             cv::pyrUp(src, dst);\r
1401         }\r
1402     }\r
1403 }\r
1404 \r
1405 //////////////////////////////////////////////////////////////////////\r
1406 // CvtColor\r
1407 \r
1408 DEF_PARAM_TEST(Sz_Depth_Code, cv::Size, MatDepth, CvtColorInfo);\r
1409 \r
1410 PERF_TEST_P(Sz_Depth_Code, ImgProc_CvtColor, Combine(\r
1411     GPU_TYPICAL_MAT_SIZES,\r
1412     Values(CV_8U, CV_16U, CV_32F),\r
1413     Values(CvtColorInfo(4, 4, cv::COLOR_RGBA2BGRA),\r
1414            CvtColorInfo(4, 1, cv::COLOR_BGRA2GRAY),\r
1415            CvtColorInfo(1, 4, cv::COLOR_GRAY2BGRA),\r
1416            CvtColorInfo(3, 3, cv::COLOR_BGR2XYZ),\r
1417            CvtColorInfo(3, 3, cv::COLOR_XYZ2BGR),\r
1418            CvtColorInfo(3, 3, cv::COLOR_BGR2YCrCb),\r
1419            CvtColorInfo(3, 3, cv::COLOR_YCrCb2BGR),\r
1420            CvtColorInfo(3, 3, cv::COLOR_BGR2YUV),\r
1421            CvtColorInfo(3, 3, cv::COLOR_YUV2BGR),\r
1422            CvtColorInfo(3, 3, cv::COLOR_BGR2HSV),\r
1423            CvtColorInfo(3, 3, cv::COLOR_HSV2BGR),\r
1424            CvtColorInfo(3, 3, cv::COLOR_BGR2HLS),\r
1425            CvtColorInfo(3, 3, cv::COLOR_HLS2BGR),\r
1426            CvtColorInfo(3, 3, cv::COLOR_BGR2Lab),\r
1427            CvtColorInfo(3, 3, cv::COLOR_RGB2Lab),\r
1428            CvtColorInfo(3, 3, cv::COLOR_BGR2Luv),\r
1429            CvtColorInfo(3, 3, cv::COLOR_RGB2Luv),\r
1430            CvtColorInfo(3, 3, cv::COLOR_Lab2BGR),\r
1431            CvtColorInfo(3, 3, cv::COLOR_Lab2RGB),\r
1432            CvtColorInfo(3, 3, cv::COLOR_Luv2BGR),\r
1433            CvtColorInfo(3, 3, cv::COLOR_Luv2RGB),\r
1434            CvtColorInfo(1, 3, cv::COLOR_BayerBG2BGR),\r
1435            CvtColorInfo(1, 3, cv::COLOR_BayerGB2BGR),\r
1436            CvtColorInfo(1, 3, cv::COLOR_BayerRG2BGR),\r
1437            CvtColorInfo(1, 3, cv::COLOR_BayerGR2BGR),\r
1438            CvtColorInfo(4, 4, cv::COLOR_RGBA2mRGBA))))\r
1439 {\r
1440     cv::Size size = GET_PARAM(0);\r
1441     int depth = GET_PARAM(1);\r
1442     CvtColorInfo info = GET_PARAM(2);\r
1443 \r
1444     cv::Mat src(size, CV_MAKETYPE(depth, info.scn));\r
1445     fillRandom(src);\r
1446 \r
1447     if (runOnGpu)\r
1448     {\r
1449         cv::gpu::GpuMat d_src(src);\r
1450         cv::gpu::GpuMat d_dst;\r
1451 \r
1452         cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);\r
1453 \r
1454         TEST_CYCLE()\r
1455         {\r
1456             cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);\r
1457         }\r
1458     }\r
1459     else\r
1460     {\r
1461         cv::Mat dst;\r
1462 \r
1463         cv::cvtColor(src, dst, info.code, info.dcn);\r
1464 \r
1465         TEST_CYCLE()\r
1466         {\r
1467             cv::cvtColor(src, dst, info.code, info.dcn);\r
1468         }\r
1469     }\r
1470 }\r
1471 \r
1472 //////////////////////////////////////////////////////////////////////\r
1473 // SwapChannels\r
1474 \r
1475 PERF_TEST_P(Sz, ImgProc_SwapChannels, GPU_TYPICAL_MAT_SIZES)\r
1476 {\r
1477     cv::Size size = GetParam();\r
1478 \r
1479     cv::Mat src(size, CV_8UC4);\r
1480     fillRandom(src);\r
1481 \r
1482     const int dstOrder[] = {2, 1, 0, 3};\r
1483 \r
1484     if (runOnGpu)\r
1485     {\r
1486         cv::gpu::GpuMat d_src(src);\r
1487 \r
1488         cv::gpu::swapChannels(d_src, dstOrder);\r
1489 \r
1490         TEST_CYCLE()\r
1491         {\r
1492             cv::gpu::swapChannels(d_src, dstOrder);\r
1493         }\r
1494     }\r
1495     else\r
1496     {\r
1497         FAIL();\r
1498     }\r
1499 }\r
1500 \r
1501 //////////////////////////////////////////////////////////////////////\r
1502 // AlphaComp\r
1503 \r
1504 CV_ENUM(AlphaOp, cv::gpu::ALPHA_OVER, cv::gpu::ALPHA_IN, cv::gpu::ALPHA_OUT, cv::gpu::ALPHA_ATOP, cv::gpu::ALPHA_XOR, cv::gpu::ALPHA_PLUS, cv::gpu::ALPHA_OVER_PREMUL, cv::gpu::ALPHA_IN_PREMUL, cv::gpu::ALPHA_OUT_PREMUL, cv::gpu::ALPHA_ATOP_PREMUL, cv::gpu::ALPHA_XOR_PREMUL, cv::gpu::ALPHA_PLUS_PREMUL, cv::gpu::ALPHA_PREMUL)\r
1505 #define ALL_ALPHA_OPS ValuesIn(AlphaOp::all())\r
1506 \r
1507 DEF_PARAM_TEST(Sz_Type_Op, cv::Size, MatType, AlphaOp);\r
1508 \r
1509 PERF_TEST_P(Sz_Type_Op, ImgProc_AlphaComp, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC4, CV_16UC4, CV_32SC4, CV_32FC4), ALL_ALPHA_OPS))\r
1510 {\r
1511     cv::Size size = GET_PARAM(0);\r
1512     int type = GET_PARAM(1);\r
1513     int alpha_op = GET_PARAM(2);\r
1514 \r
1515     cv::Mat img1(size, type);\r
1516     fillRandom(img1);\r
1517 \r
1518     cv::Mat img2(size, type);\r
1519     fillRandom(img2);\r
1520 \r
1521     if (runOnGpu)\r
1522     {\r
1523         cv::gpu::GpuMat d_img1(img1);\r
1524         cv::gpu::GpuMat d_img2(img2);\r
1525         cv::gpu::GpuMat d_dst;\r
1526 \r
1527         cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);\r
1528 \r
1529         TEST_CYCLE()\r
1530         {\r
1531             cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);\r
1532         }\r
1533     }\r
1534     else\r
1535     {\r
1536         FAIL();\r
1537     }\r
1538 }\r
1539 \r
1540 //////////////////////////////////////////////////////////////////////\r
1541 // ImagePyramidBuild\r
1542 \r
1543 PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidBuild, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_32F), Values(1, 3, 4)))\r
1544 {\r
1545     cv::Size size = GET_PARAM(0);\r
1546     int depth = GET_PARAM(1);\r
1547     int channels = GET_PARAM(2);\r
1548 \r
1549     int type = CV_MAKE_TYPE(depth, channels);\r
1550 \r
1551     cv::Mat src(size, type);\r
1552     fillRandom(src);\r
1553 \r
1554     if (runOnGpu)\r
1555     {\r
1556         cv::gpu::GpuMat d_src(src);\r
1557 \r
1558         cv::gpu::ImagePyramid d_pyr;\r
1559 \r
1560         d_pyr.build(d_src, 5);\r
1561 \r
1562         TEST_CYCLE()\r
1563         {\r
1564             d_pyr.build(d_src, 5);\r
1565         }\r
1566     }\r
1567     else\r
1568     {\r
1569         FAIL();\r
1570     }\r
1571 }\r
1572 \r
1573 //////////////////////////////////////////////////////////////////////\r
1574 // ImagePyramidGetLayer\r
1575 \r
1576 PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidGetLayer, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_32F), Values(1, 3, 4)))\r
1577 {\r
1578     cv::Size size = GET_PARAM(0);\r
1579     int depth = GET_PARAM(1);\r
1580     int channels = GET_PARAM(2);\r
1581 \r
1582     int type = CV_MAKE_TYPE(depth, channels);\r
1583 \r
1584     cv::Mat src(size, type);\r
1585     fillRandom(src);\r
1586 \r
1587     cv::Size dstSize(size.width / 2 + 10, size.height / 2 + 10);\r
1588 \r
1589     if (runOnGpu)\r
1590     {\r
1591         cv::gpu::GpuMat d_src(src);\r
1592         cv::gpu::GpuMat d_dst;\r
1593 \r
1594         cv::gpu::ImagePyramid d_pyr(d_src, 3);\r
1595 \r
1596         d_pyr.getLayer(d_dst, dstSize);\r
1597 \r
1598         TEST_CYCLE()\r
1599         {\r
1600             d_pyr.getLayer(d_dst, dstSize);\r
1601         }\r
1602     }\r
1603     else\r
1604     {\r
1605         FAIL();\r
1606     }\r
1607 }\r
1608 \r
1609 //////////////////////////////////////////////////////////////////////\r
1610 // HoughLines\r
1611 \r
1612 PERF_TEST_P(Sz, ImgProc_HoughLines, GPU_TYPICAL_MAT_SIZES)\r
1613 {\r
1614     declare.time(30.0);\r
1615 \r
1616     const cv::Size size = GetParam();\r
1617 \r
1618     const float rho = 1.0f;\r
1619     const float theta = static_cast<float>(CV_PI / 180.0);\r
1620     const int threshold = 300;\r
1621 \r
1622     cv::RNG rng(123456789);\r
1623 \r
1624     cv::Mat src(size, CV_8UC1, cv::Scalar::all(0));\r
1625 \r
1626     const int numLines = rng.uniform(100, 300);\r
1627     for (int i = 0; i < numLines; ++i)\r
1628     {\r
1629         cv::Point p1(rng.uniform(0, src.cols), rng.uniform(0, src.rows));\r
1630         cv::Point p2(rng.uniform(0, src.cols), rng.uniform(0, src.rows));\r
1631         cv::line(src, p1, p2, cv::Scalar::all(255), 2);\r
1632     }\r
1633 \r
1634     if (runOnGpu)\r
1635     {\r
1636         cv::gpu::GpuMat d_src(src);\r
1637         cv::gpu::GpuMat d_lines;\r
1638         cv::gpu::HoughLinesBuf d_buf;\r
1639 \r
1640         cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold);\r
1641 \r
1642         TEST_CYCLE()\r
1643         {\r
1644             cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold);\r
1645         }\r
1646     }\r
1647     else\r
1648     {\r
1649         std::vector<cv::Vec2f> lines;\r
1650         cv::HoughLines(src, lines, rho, theta, threshold);\r
1651 \r
1652         TEST_CYCLE()\r
1653         {\r
1654             cv::HoughLines(src, lines, rho, theta, threshold);\r
1655         }\r
1656     }\r
1657 }\r
1658 \r
1659 //////////////////////////////////////////////////////////////////////\r
1660 // HoughCircles\r
1661 \r
1662 DEF_PARAM_TEST(Sz_Dp_MinDist, cv::Size, float, float);\r
1663 \r
1664 PERF_TEST_P(Sz_Dp_MinDist, ImgProc_HoughCircles, Combine(GPU_TYPICAL_MAT_SIZES, Values(1.0f, 2.0f, 4.0f), Values(1.0f, 10.0f)))\r
1665 {\r
1666     declare.time(30.0);\r
1667 \r
1668     const cv::Size size = GET_PARAM(0);\r
1669     const float dp = GET_PARAM(1);\r
1670     const float minDist = GET_PARAM(2);\r
1671 \r
1672     const int minRadius = 10;\r
1673     const int maxRadius = 30;\r
1674     const int cannyThreshold = 100;\r
1675     const int votesThreshold = 15;\r
1676 \r
1677     cv::RNG rng(123456789);\r
1678 \r
1679     cv::Mat src(size, CV_8UC1, cv::Scalar::all(0));\r
1680 \r
1681     const int numCircles = rng.uniform(50, 100);\r
1682     for (int i = 0; i < numCircles; ++i)\r
1683     {\r
1684         cv::Point center(rng.uniform(0, src.cols), rng.uniform(0, src.rows));\r
1685         const int radius = rng.uniform(minRadius, maxRadius + 1);\r
1686 \r
1687         cv::circle(src, center, radius, cv::Scalar::all(255), -1);\r
1688     }\r
1689 \r
1690     if (runOnGpu)\r
1691     {\r
1692         cv::gpu::GpuMat d_src(src);\r
1693         cv::gpu::GpuMat d_circles;\r
1694         cv::gpu::HoughCirclesBuf d_buf;\r
1695 \r
1696         cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);\r
1697 \r
1698         TEST_CYCLE()\r
1699         {\r
1700             cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);\r
1701         }\r
1702     }\r
1703     else\r
1704     {\r
1705         std::vector<cv::Vec3f> circles;\r
1706 \r
1707         cv::HoughCircles(src, circles, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);\r
1708 \r
1709         TEST_CYCLE()\r
1710         {\r
1711             cv::HoughCircles(src, circles, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);\r
1712         }\r
1713     }\r
1714 }\r
1715 \r
1716 } // namespace\r