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.25) + 0.5;\r
  27                     map_y.at<float>(j,i) = 2 * (j - map_x.rows * 0.25) + 0.5;\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) = i;\r
  37                 map_y.at<float>(j,i) = map_x.rows - j;\r
  38                 break;\r
  39             case REFLECTION_X:\r
  40                 map_x.at<float>(j,i) = map_x.cols - i;\r
  41                 map_y.at<float>(j,i) = j;\r
  42                 break;\r
  43             case REFLECTION_BOTH:\r
  44                 map_x.at<float>(j,i) = map_x.cols - i;\r
  45                 map_y.at<float>(j,i) = 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(3.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     cv::gpu::GpuMat d_src(src);\r
  82     cv::gpu::GpuMat d_xmap(xmap);\r
  83     cv::gpu::GpuMat d_ymap(ymap);\r
  84     cv::gpu::GpuMat d_dst;\r
  85 \r
  86     cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);\r
  87 \r
  88     TEST_CYCLE()\r
  89     {\r
  90         cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);\r
  91     }\r
  92 }\r
  93 \r
  94 //////////////////////////////////////////////////////////////////////\r
  95 // Resize\r
  96 \r
  97 DEF_PARAM_TEST(Sz_Depth_Cn_Inter_Scale, cv::Size, MatDepth, int, Interpolation, double);\r
  98 \r
  99 PERF_TEST_P(Sz_Depth_Cn_Inter_Scale, ImgProc_Resize, Combine(\r
 100     GPU_TYPICAL_MAT_SIZES,\r
 101     Values(CV_8U, CV_16U, CV_32F),\r
 102     Values(1, 3, 4),\r
 103     ALL_INTERPOLATIONS,\r
 104     Values(0.5, 0.3, 2.0)))\r
 105 {\r
 106     declare.time(1.0);\r
 107 \r
 108     cv::Size size = GET_PARAM(0);\r
 109     int depth = GET_PARAM(1);\r
 110     int channels = GET_PARAM(2);\r
 111     int interpolation = GET_PARAM(3);\r
 112     double f = GET_PARAM(4);\r
 113 \r
 114     int type = CV_MAKE_TYPE(depth, channels);\r
 115 \r
 116     cv::Mat src(size, type);\r
 117     fillRandom(src);\r
 118 \r
 119     cv::gpu::GpuMat d_src(src);\r
 120     cv::gpu::GpuMat d_dst;\r
 121 \r
 122     cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);\r
 123 \r
 124     TEST_CYCLE()\r
 125     {\r
 126         cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);\r
 127     }\r
 128 }\r
 129 \r
 130 //////////////////////////////////////////////////////////////////////\r
 131 // ResizeArea\r
 132 \r
 133 DEF_PARAM_TEST(Sz_Depth_Cn_Scale, cv::Size, MatDepth, int, double);\r
 134 \r
 135 PERF_TEST_P(Sz_Depth_Cn_Scale, ImgProc_ResizeArea, Combine(\r
 136     GPU_TYPICAL_MAT_SIZES,\r
 137     Values(CV_8U, CV_16U, CV_32F),\r
 138     Values(1, 3, 4),\r
 139     Values(0.2, 0.1, 0.05)))\r
 140 {\r
 141     declare.time(1.0);\r
 142 \r
 143     cv::Size size = GET_PARAM(0);\r
 144     int depth = GET_PARAM(1);\r
 145     int channels = GET_PARAM(2);\r
 146     int interpolation = cv::INTER_AREA;\r
 147     double f = GET_PARAM(3);\r
 148 \r
 149     int type = CV_MAKE_TYPE(depth, channels);\r
 150 \r
 151     cv::Mat src(size, type);\r
 152     fillRandom(src);\r
 153 \r
 154     cv::gpu::GpuMat d_src(src);\r
 155     cv::gpu::GpuMat d_dst;\r
 156 \r
 157     cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);\r
 158 \r
 159     TEST_CYCLE()\r
 160     {\r
 161         cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);\r
 162     }\r
 163 }\r
 164 \r
 165 //////////////////////////////////////////////////////////////////////\r
 166 // WarpAffine\r
 167 \r
 168 DEF_PARAM_TEST(Sz_Depth_Cn_Inter_Border, cv::Size, MatDepth, int, Interpolation, BorderMode);\r
 169 \r
 170 PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpAffine, Combine(\r
 171     GPU_TYPICAL_MAT_SIZES,\r
 172     Values(CV_8U, CV_16U, CV_32F),\r
 173     Values(1, 3, 4),\r
 174     Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),\r
 175     ALL_BORDER_MODES))\r
 176 {\r
 177     cv::Size size = GET_PARAM(0);\r
 178     int depth = GET_PARAM(1);\r
 179     int channels = GET_PARAM(2);\r
 180     int interpolation = GET_PARAM(3);\r
 181     int borderMode = GET_PARAM(4);\r
 182 \r
 183     int type = CV_MAKE_TYPE(depth, channels);\r
 184 \r
 185     cv::Mat src(size, type);\r
 186     fillRandom(src);\r
 187 \r
 188     const double aplha = CV_PI / 4;\r
 189     double mat[2][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},\r
 190                          {std::sin(aplha),  std::cos(aplha), 0}};\r
 191     cv::Mat M(2, 3, CV_64F, (void*) mat);\r
 192 \r
 193     cv::gpu::GpuMat d_src(src);\r
 194     cv::gpu::GpuMat d_dst;\r
 195 \r
 196     cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode);\r
 197 \r
 198     TEST_CYCLE()\r
 199     {\r
 200         cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode);\r
 201     }\r
 202 }\r
 203 \r
 204 //////////////////////////////////////////////////////////////////////\r
 205 // WarpPerspective\r
 206 \r
 207 PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpPerspective, Combine(\r
 208     GPU_TYPICAL_MAT_SIZES,\r
 209     Values(CV_8U, CV_16U, CV_32F),\r
 210     Values(1, 3, 4),\r
 211     Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),\r
 212     ALL_BORDER_MODES))\r
 213 {\r
 214     cv::Size size = GET_PARAM(0);\r
 215     int depth = GET_PARAM(1);\r
 216     int channels = GET_PARAM(2);\r
 217     int interpolation = GET_PARAM(3);\r
 218     int borderMode = GET_PARAM(4);\r
 219 \r
 220     int type = CV_MAKE_TYPE(depth, channels);\r
 221 \r
 222     cv::Mat src(size, type);\r
 223     fillRandom(src);\r
 224 \r
 225     const double aplha = CV_PI / 4;\r
 226     double mat[3][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},\r
 227                          {std::sin(aplha),  std::cos(aplha), 0},\r
 228                          {0.0,              0.0,             1.0}};\r
 229     cv::Mat M(3, 3, CV_64F, (void*) mat);\r
 230 \r
 231     cv::gpu::GpuMat d_src(src);\r
 232     cv::gpu::GpuMat d_dst;\r
 233 \r
 234     cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode);\r
 235 \r
 236     TEST_CYCLE()\r
 237     {\r
 238         cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode);\r
 239     }\r
 240 }\r
 241 \r
 242 //////////////////////////////////////////////////////////////////////\r
 243 // CopyMakeBorder\r
 244 \r
 245 DEF_PARAM_TEST(Sz_Depth_Cn_Border, cv::Size, MatDepth, int, BorderMode);\r
 246 \r
 247 PERF_TEST_P(Sz_Depth_Cn_Border, ImgProc_CopyMakeBorder, Combine(\r
 248     GPU_TYPICAL_MAT_SIZES,\r
 249     Values(CV_8U, CV_16U, CV_32F),\r
 250     Values(1, 3, 4),\r
 251     ALL_BORDER_MODES))\r
 252 {\r
 253     cv::Size size = GET_PARAM(0);\r
 254     int depth = GET_PARAM(1);\r
 255     int channels = GET_PARAM(2);\r
 256     int borderMode = GET_PARAM(3);\r
 257 \r
 258     int type = CV_MAKE_TYPE(depth, channels);\r
 259 \r
 260     cv::Mat src(size, type);\r
 261     fillRandom(src);\r
 262 \r
 263     cv::gpu::GpuMat d_src(src);\r
 264     cv::gpu::GpuMat d_dst;\r
 265 \r
 266     cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);\r
 267 \r
 268     TEST_CYCLE()\r
 269     {\r
 270         cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);\r
 271     }\r
 272 }\r
 273 \r
 274 //////////////////////////////////////////////////////////////////////\r
 275 // Threshold\r
 276 \r
 277 CV_ENUM(ThreshOp, cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV)\r
 278 #define ALL_THRESH_OPS ValuesIn(ThreshOp::all())\r
 279 \r
 280 DEF_PARAM_TEST(Sz_Depth_Op, cv::Size, MatDepth, ThreshOp);\r
 281 \r
 282 PERF_TEST_P(Sz_Depth_Op, ImgProc_Threshold, Combine(\r
 283     GPU_TYPICAL_MAT_SIZES,\r
 284     Values(CV_8U, CV_16U, CV_32F, CV_64F),\r
 285     ALL_THRESH_OPS))\r
 286 {\r
 287     cv::Size size = GET_PARAM(0);\r
 288     int depth = GET_PARAM(1);\r
 289     int threshOp = GET_PARAM(2);\r
 290 \r
 291     cv::Mat src(size, depth);\r
 292     fillRandom(src);\r
 293 \r
 294     cv::gpu::GpuMat d_src(src);\r
 295     cv::gpu::GpuMat d_dst;\r
 296 \r
 297     cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);\r
 298 \r
 299     TEST_CYCLE()\r
 300     {\r
 301         cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);\r
 302     }\r
 303 }\r
 304 \r
 305 //////////////////////////////////////////////////////////////////////\r
 306 // Integral\r
 307 \r
 308 PERF_TEST_P(Sz, ImgProc_Integral, GPU_TYPICAL_MAT_SIZES)\r
 309 {\r
 310     cv::Size size = GetParam();\r
 311 \r
 312     cv::Mat src(size, CV_8UC1);\r
 313     fillRandom(src);\r
 314 \r
 315     cv::gpu::GpuMat d_src(src);\r
 316     cv::gpu::GpuMat d_dst;\r
 317     cv::gpu::GpuMat d_buf;\r
 318 \r
 319     cv::gpu::integralBuffered(d_src, d_dst, d_buf);\r
 320 \r
 321     TEST_CYCLE()\r
 322     {\r
 323         cv::gpu::integralBuffered(d_src, d_dst, d_buf);\r
 324     }\r
 325 }\r
 326 \r
 327 //////////////////////////////////////////////////////////////////////\r
 328 // IntegralSqr\r
 329 \r
 330 PERF_TEST_P(Sz, ImgProc_IntegralSqr, GPU_TYPICAL_MAT_SIZES)\r
 331 {\r
 332     cv::Size size = GetParam();\r
 333 \r
 334     cv::Mat src(size, CV_8UC1);\r
 335     fillRandom(src);\r
 336 \r
 337     cv::gpu::GpuMat d_src(src);\r
 338     cv::gpu::GpuMat d_dst;\r
 339 \r
 340     cv::gpu::sqrIntegral(d_src, d_dst);\r
 341 \r
 342     TEST_CYCLE()\r
 343     {\r
 344         cv::gpu::sqrIntegral(d_src, d_dst);\r
 345     }\r
 346 }\r
 347 \r
 348 //////////////////////////////////////////////////////////////////////\r
 349 // HistEvenC1\r
 350 \r
 351 PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC1, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_16S)))\r
 352 {\r
 353     cv::Size size = GET_PARAM(0);\r
 354     int depth = GET_PARAM(1);\r
 355 \r
 356     cv::Mat src(size, depth);\r
 357     fillRandom(src);\r
 358 \r
 359     cv::gpu::GpuMat d_src(src);\r
 360     cv::gpu::GpuMat d_hist;\r
 361     cv::gpu::GpuMat d_buf;\r
 362 \r
 363     cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);\r
 364 \r
 365     TEST_CYCLE()\r
 366     {\r
 367         cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);\r
 368     }\r
 369 }\r
 370 \r
 371 //////////////////////////////////////////////////////////////////////\r
 372 // HistEvenC4\r
 373 \r
 374 PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC4, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_16S)))\r
 375 {\r
 376     cv::Size size = GET_PARAM(0);\r
 377     int depth = GET_PARAM(1);\r
 378 \r
 379     cv::Mat src(size, CV_MAKE_TYPE(depth, 4));\r
 380     fillRandom(src);\r
 381 \r
 382     int histSize[] = {30, 30, 30, 30};\r
 383     int lowerLevel[] = {0, 0, 0, 0};\r
 384     int upperLevel[] = {180, 180, 180, 180};\r
 385 \r
 386     cv::gpu::GpuMat d_src(src);\r
 387     cv::gpu::GpuMat d_hist[4];\r
 388     cv::gpu::GpuMat d_buf;\r
 389 \r
 390     cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);\r
 391 \r
 392     TEST_CYCLE()\r
 393     {\r
 394         cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);\r
 395     }\r
 396 }\r
 397 \r
 398 //////////////////////////////////////////////////////////////////////\r
 399 // CalcHist\r
 400 \r
 401 PERF_TEST_P(Sz, ImgProc_CalcHist, GPU_TYPICAL_MAT_SIZES)\r
 402 {\r
 403     cv::Size size = GetParam();\r
 404 \r
 405     cv::Mat src(size, CV_8UC1);\r
 406     fillRandom(src);\r
 407 \r
 408     cv::gpu::GpuMat d_src(src);\r
 409     cv::gpu::GpuMat d_hist;\r
 410     cv::gpu::GpuMat d_buf;\r
 411 \r
 412     cv::gpu::calcHist(d_src, d_hist, d_buf);\r
 413 \r
 414     TEST_CYCLE()\r
 415     {\r
 416         cv::gpu::calcHist(d_src, d_hist, d_buf);\r
 417     }\r
 418 }\r
 419 \r
 420 //////////////////////////////////////////////////////////////////////\r
 421 // EqualizeHist\r
 422 \r
 423 PERF_TEST_P(Sz, ImgProc_EqualizeHist, GPU_TYPICAL_MAT_SIZES)\r
 424 {\r
 425     cv::Size size = GetParam();\r
 426 \r
 427     cv::Mat src(size, CV_8UC1);\r
 428     fillRandom(src);\r
 429 \r
 430     cv::gpu::GpuMat d_src(src);\r
 431     cv::gpu::GpuMat d_dst;\r
 432     cv::gpu::GpuMat d_hist;\r
 433     cv::gpu::GpuMat d_buf;\r
 434 \r
 435     cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);\r
 436 \r
 437     TEST_CYCLE()\r
 438     {\r
 439         cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);\r
 440     }\r
 441 }\r
 442 \r
 443 //////////////////////////////////////////////////////////////////////\r
 444 // ColumnSum\r
 445 \r
 446 PERF_TEST_P(Sz, ImgProc_ColumnSum, GPU_TYPICAL_MAT_SIZES)\r
 447 {\r
 448     cv::Size size = GetParam();\r
 449 \r
 450     cv::Mat src(size, CV_32FC1);\r
 451     fillRandom(src);\r
 452 \r
 453     cv::gpu::GpuMat d_src(src);\r
 454     cv::gpu::GpuMat d_dst;\r
 455 \r
 456     cv::gpu::columnSum(d_src, d_dst);\r
 457 \r
 458     TEST_CYCLE()\r
 459     {\r
 460         cv::gpu::columnSum(d_src, d_dst);\r
 461     }\r
 462 }\r
 463 \r
 464 //////////////////////////////////////////////////////////////////////\r
 465 // Canny\r
 466 \r
 467 DEF_PARAM_TEST(Image_AppertureSz_L2gradient, string, int, bool);\r
 468 \r
 469 PERF_TEST_P(Image_AppertureSz_L2gradient, ImgProc_Canny, Combine(\r
 470     Values("perf/800x600.jpg", "perf/1280x1024.jpg", "perf/1680x1050.jpg"),\r
 471     Values(3, 5),\r
 472     Bool()))\r
 473 {\r
 474     string fileName = GET_PARAM(0);\r
 475     int apperture_size = GET_PARAM(1);\r
 476     bool useL2gradient = GET_PARAM(2);\r
 477 \r
 478     cv::Mat image = readImage(fileName, cv::IMREAD_GRAYSCALE);\r
 479     ASSERT_FALSE(image.empty());\r
 480 \r
 481     cv::gpu::GpuMat d_image(image);\r
 482     cv::gpu::GpuMat d_dst;\r
 483     cv::gpu::CannyBuf d_buf;\r
 484 \r
 485     cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient);\r
 486 \r
 487     TEST_CYCLE()\r
 488     {\r
 489         cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient);\r
 490     }\r
 491 }\r
 492 \r
 493 //////////////////////////////////////////////////////////////////////\r
 494 // MeanShiftFiltering\r
 495 \r
 496 DEF_PARAM_TEST_1(Image, string);\r
 497 \r
 498 PERF_TEST_P(Image, ImgProc_MeanShiftFiltering, Values<string>("gpu/meanshift/cones.png"))\r
 499 {\r
 500     declare.time(5.0);\r
 501 \r
 502     cv::Mat img = readImage(GetParam());\r
 503     ASSERT_FALSE(img.empty());\r
 504 \r
 505     cv::Mat rgba;\r
 506     cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);\r
 507 \r
 508     cv::gpu::GpuMat d_src(rgba);\r
 509     cv::gpu::GpuMat d_dst;\r
 510 \r
 511     cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);\r
 512 \r
 513     TEST_CYCLE()\r
 514     {\r
 515         cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);\r
 516     }\r
 517 }\r
 518 \r
 519 //////////////////////////////////////////////////////////////////////\r
 520 // MeanShiftProc\r
 521 \r
 522 PERF_TEST_P(Image, ImgProc_MeanShiftProc, Values<string>("gpu/meanshift/cones.png"))\r
 523 {\r
 524     declare.time(5.0);\r
 525 \r
 526     cv::Mat img = readImage(GetParam());\r
 527     ASSERT_FALSE(img.empty());\r
 528 \r
 529     cv::Mat rgba;\r
 530     cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);\r
 531 \r
 532     cv::gpu::GpuMat d_src(rgba);\r
 533     cv::gpu::GpuMat d_dstr;\r
 534     cv::gpu::GpuMat d_dstsp;\r
 535 \r
 536     cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);\r
 537 \r
 538     TEST_CYCLE()\r
 539     {\r
 540         cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);\r
 541     }\r
 542 }\r
 543 \r
 544 //////////////////////////////////////////////////////////////////////\r
 545 // MeanShiftSegmentation\r
 546 \r
 547 PERF_TEST_P(Image, ImgProc_MeanShiftSegmentation, Values<string>("gpu/meanshift/cones.png"))\r
 548 {\r
 549     declare.time(5.0);\r
 550 \r
 551     cv::Mat img = readImage(GetParam());\r
 552     ASSERT_FALSE(img.empty());\r
 553 \r
 554     cv::Mat rgba;\r
 555     cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);\r
 556 \r
 557     cv::Mat dst;\r
 558 \r
 559     cv::gpu::GpuMat d_src(rgba);\r
 560 \r
 561     cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);\r
 562 \r
 563     TEST_CYCLE()\r
 564     {\r
 565         cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);\r
 566     }\r
 567 }\r
 568 \r
 569 //////////////////////////////////////////////////////////////////////\r
 570 // BlendLinear\r
 571 \r
 572 PERF_TEST_P(Sz_Depth_Cn, ImgProc_BlendLinear, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_32F), Values(1, 3, 4)))\r
 573 {\r
 574     cv::Size size = GET_PARAM(0);\r
 575     int depth = GET_PARAM(1);\r
 576     int channels = GET_PARAM(2);\r
 577 \r
 578     int type = CV_MAKE_TYPE(depth, channels);\r
 579 \r
 580     cv::Mat img1(size, type);\r
 581     fillRandom(img1);\r
 582 \r
 583     cv::Mat img2(size, type);\r
 584     fillRandom(img2);\r
 585 \r
 586     cv::gpu::GpuMat d_img1(img1);\r
 587     cv::gpu::GpuMat d_img2(img2);\r
 588     cv::gpu::GpuMat d_weights1(size, CV_32FC1, cv::Scalar::all(0.5));\r
 589     cv::gpu::GpuMat d_weights2(size, CV_32FC1, cv::Scalar::all(0.5));\r
 590     cv::gpu::GpuMat d_dst;\r
 591 \r
 592     cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);\r
 593 \r
 594     TEST_CYCLE()\r
 595     {\r
 596         cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);\r
 597     }\r
 598 }\r
 599 \r
 600 //////////////////////////////////////////////////////////////////////\r
 601 // Convolve\r
 602 \r
 603 DEF_PARAM_TEST(Sz_KernelSz_Ccorr, cv::Size, int, bool);\r
 604 \r
 605 PERF_TEST_P(Sz_KernelSz_Ccorr, ImgProc_Convolve, Combine(GPU_TYPICAL_MAT_SIZES, Values(17, 27, 32, 64), Bool()))\r
 606 {\r
 607     declare.time(2.0);\r
 608 \r
 609     cv::Size size = GET_PARAM(0);\r
 610     int templ_size = GET_PARAM(1);\r
 611     bool ccorr = GET_PARAM(2);\r
 612 \r
 613     cv::gpu::GpuMat d_image = cv::gpu::createContinuous(size, CV_32FC1);\r
 614     d_image.setTo(cv::Scalar(1.0));\r
 615 \r
 616     cv::gpu::GpuMat d_templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);\r
 617     d_templ.setTo(cv::Scalar(1.0));\r
 618 \r
 619     cv::gpu::GpuMat d_dst;\r
 620     cv::gpu::ConvolveBuf d_buf;\r
 621 \r
 622     cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);\r
 623 \r
 624     TEST_CYCLE()\r
 625     {\r
 626         cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);\r
 627     }\r
 628 }\r
 629 \r
 630 ////////////////////////////////////////////////////////////////////////////////\r
 631 // MatchTemplate8U\r
 632 \r
 633 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
 634 #define ALL_TEMPLATE_METHODS ValuesIn(TemplateMethod::all())\r
 635 \r
 636 DEF_PARAM_TEST(Sz_TemplateSz_Cn_Method, cv::Size, cv::Size, int, TemplateMethod);\r
 637 \r
 638 PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate8U, Combine(\r
 639     GPU_TYPICAL_MAT_SIZES,\r
 640     Values(cv::Size(5, 5), cv::Size(16, 16), cv::Size(30, 30)),\r
 641     Values(1, 3, 4),\r
 642     ALL_TEMPLATE_METHODS))\r
 643 {\r
 644     cv::Size size = GET_PARAM(0);\r
 645     cv::Size templ_size = GET_PARAM(1);\r
 646     int cn = GET_PARAM(2);\r
 647     int method = GET_PARAM(3);\r
 648 \r
 649     cv::Mat image(size, CV_MAKE_TYPE(CV_8U, cn));\r
 650     fillRandom(image);\r
 651 \r
 652     cv::Mat templ(templ_size, CV_MAKE_TYPE(CV_8U, cn));\r
 653     fillRandom(templ);\r
 654 \r
 655     cv::gpu::GpuMat d_image(image);\r
 656     cv::gpu::GpuMat d_templ(templ);\r
 657     cv::gpu::GpuMat d_dst;\r
 658 \r
 659     cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);\r
 660 \r
 661     TEST_CYCLE()\r
 662     {\r
 663         cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);\r
 664     }\r
 665 };\r
 666 \r
 667 ////////////////////////////////////////////////////////////////////////////////\r
 668 // MatchTemplate32F\r
 669 \r
 670 PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate32F, Combine(\r
 671     GPU_TYPICAL_MAT_SIZES,\r
 672     Values(cv::Size(5, 5), cv::Size(16, 16), cv::Size(30, 30)),\r
 673     Values(1, 3, 4),\r
 674     Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_CCORR))))\r
 675 {\r
 676     cv::Size size = GET_PARAM(0);\r
 677     cv::Size templ_size = GET_PARAM(1);\r
 678     int cn = GET_PARAM(2);\r
 679     int method = GET_PARAM(3);\r
 680 \r
 681     cv::Mat image(size, CV_MAKE_TYPE(CV_32F, cn));\r
 682     fillRandom(image);\r
 683 \r
 684     cv::Mat templ(templ_size, CV_MAKE_TYPE(CV_32F, cn));\r
 685     fillRandom(templ);\r
 686 \r
 687     cv::gpu::GpuMat d_image(image);\r
 688     cv::gpu::GpuMat d_templ(templ);\r
 689     cv::gpu::GpuMat d_dst;\r
 690 \r
 691     cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);\r
 692 \r
 693     TEST_CYCLE()\r
 694     {\r
 695         cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);\r
 696     }\r
 697 };\r
 698 \r
 699 //////////////////////////////////////////////////////////////////////\r
 700 // MulSpectrums\r
 701 \r
 702 CV_FLAGS(DftFlags, 0, cv::DFT_INVERSE, cv::DFT_SCALE, cv::DFT_ROWS, cv::DFT_COMPLEX_OUTPUT, cv::DFT_REAL_OUTPUT)\r
 703 \r
 704 DEF_PARAM_TEST(Sz_Flags, cv::Size, DftFlags);\r
 705 \r
 706 PERF_TEST_P(Sz_Flags, ImgProc_MulSpectrums, Combine(\r
 707     GPU_TYPICAL_MAT_SIZES,\r
 708     Values(0, DftFlags(cv::DFT_ROWS))))\r
 709 {\r
 710     cv::Size size = GET_PARAM(0);\r
 711     int flag = GET_PARAM(1);\r
 712 \r
 713     cv::Mat a(size, CV_32FC2);\r
 714     fillRandom(a, 0, 100);\r
 715 \r
 716     cv::Mat b(size, CV_32FC2);\r
 717     fillRandom(b, 0, 100);\r
 718 \r
 719     cv::gpu::GpuMat d_a(a);\r
 720     cv::gpu::GpuMat d_b(b);\r
 721     cv::gpu::GpuMat d_dst;\r
 722 \r
 723     cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);\r
 724 \r
 725     TEST_CYCLE()\r
 726     {\r
 727         cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);\r
 728     }\r
 729 }\r
 730 \r
 731 //////////////////////////////////////////////////////////////////////\r
 732 // MulAndScaleSpectrums\r
 733 \r
 734 PERF_TEST_P(Sz, ImgProc_MulAndScaleSpectrums, GPU_TYPICAL_MAT_SIZES)\r
 735 {\r
 736     cv::Size size = GetParam();\r
 737 \r
 738     float scale = 1.f / size.area();\r
 739 \r
 740     cv::Mat src1(size, CV_32FC2);\r
 741     fillRandom(src1, 0, 100);\r
 742 \r
 743     cv::Mat src2(size, CV_32FC2);\r
 744     fillRandom(src2, 0, 100);\r
 745 \r
 746     cv::gpu::GpuMat d_src1(src1);\r
 747     cv::gpu::GpuMat d_src2(src2);\r
 748     cv::gpu::GpuMat d_dst;\r
 749 \r
 750     cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);\r
 751 \r
 752     TEST_CYCLE()\r
 753     {\r
 754         cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);\r
 755     }\r
 756 }\r
 757 \r
 758 //////////////////////////////////////////////////////////////////////\r
 759 // Dft\r
 760 \r
 761 PERF_TEST_P(Sz_Flags, ImgProc_Dft, Combine(\r
 762     GPU_TYPICAL_MAT_SIZES,\r
 763     Values(0, DftFlags(cv::DFT_ROWS), DftFlags(cv::DFT_INVERSE))))\r
 764 {\r
 765     declare.time(2.0);\r
 766 \r
 767     cv::Size size = GET_PARAM(0);\r
 768     int flag = GET_PARAM(1);\r
 769 \r
 770     cv::Mat src(size, CV_32FC2);\r
 771     fillRandom(src, 0, 100);\r
 772 \r
 773     cv::gpu::GpuMat d_src(src);\r
 774     cv::gpu::GpuMat d_dst;\r
 775 \r
 776     cv::gpu::dft(d_src, d_dst, size, flag);\r
 777 \r
 778     TEST_CYCLE()\r
 779     {\r
 780         cv::gpu::dft(d_src, d_dst, size, flag);\r
 781     }\r
 782 }\r
 783 \r
 784 //////////////////////////////////////////////////////////////////////\r
 785 // CornerHarris\r
 786 \r
 787 DEF_PARAM_TEST(Image_Type_Border_BlockSz_ApertureSz, string, MatType, BorderMode, int, int);\r
 788 \r
 789 PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerHarris, Combine(\r
 790     Values<string>("gpu/stereobm/aloe-L.png"),\r
 791     Values(CV_8UC1, CV_32FC1),\r
 792     Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_REFLECT)),\r
 793     Values(3, 5, 7),\r
 794     Values(0, 3, 5, 7)))\r
 795 {\r
 796     double k = 0.5;\r
 797 \r
 798     string fileName = GET_PARAM(0);\r
 799     int type = GET_PARAM(1);\r
 800     int borderMode = GET_PARAM(2);\r
 801     int blockSize = GET_PARAM(3);\r
 802     int apertureSize = GET_PARAM(4);\r
 803 \r
 804     cv::Mat img = readImage(fileName, cv::IMREAD_GRAYSCALE);\r
 805     ASSERT_FALSE(img.empty());\r
 806 \r
 807     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
 808 \r
 809     cv::gpu::GpuMat d_img(img);\r
 810     cv::gpu::GpuMat d_dst;\r
 811     cv::gpu::GpuMat d_Dx;\r
 812     cv::gpu::GpuMat d_Dy;\r
 813     cv::gpu::GpuMat d_buf;\r
 814 \r
 815     cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);\r
 816 \r
 817     TEST_CYCLE()\r
 818     {\r
 819         cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);\r
 820     }\r
 821 }\r
 822 \r
 823 //////////////////////////////////////////////////////////////////////\r
 824 // CornerMinEigenVal\r
 825 \r
 826 PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerMinEigenVal, Combine(\r
 827     Values<string>("gpu/stereobm/aloe-L.png"),\r
 828     Values(CV_8UC1, CV_32FC1),\r
 829     Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_REFLECT)),\r
 830     Values(3, 5, 7),\r
 831     Values(0, 3, 5, 7)))\r
 832 {\r
 833     string fileName = GET_PARAM(0);\r
 834     int type = GET_PARAM(1);\r
 835     int borderMode = GET_PARAM(2);\r
 836     int blockSize = GET_PARAM(3);\r
 837     int apertureSize = GET_PARAM(4);\r
 838 \r
 839     cv::Mat img = readImage(fileName, cv::IMREAD_GRAYSCALE);\r
 840     ASSERT_FALSE(img.empty());\r
 841 \r
 842     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
 843 \r
 844     cv::gpu::GpuMat d_img(img);\r
 845     cv::gpu::GpuMat d_dst;\r
 846     cv::gpu::GpuMat d_Dx;\r
 847     cv::gpu::GpuMat d_Dy;\r
 848     cv::gpu::GpuMat d_buf;\r
 849 \r
 850     cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);\r
 851 \r
 852     TEST_CYCLE()\r
 853     {\r
 854         cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);\r
 855     }\r
 856 }\r
 857 \r
 858 //////////////////////////////////////////////////////////////////////\r
 859 // BuildWarpPlaneMaps\r
 860 \r
 861 PERF_TEST_P(Sz, ImgProc_BuildWarpPlaneMaps, GPU_TYPICAL_MAT_SIZES)\r
 862 {\r
 863     cv::Size size = GetParam();\r
 864 \r
 865     cv::Mat K = cv::Mat::eye(3, 3, CV_32FC1);\r
 866     cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1);\r
 867     cv::Mat T = cv::Mat::zeros(1, 3, CV_32F);\r
 868 \r
 869     cv::gpu::GpuMat d_map_x;\r
 870     cv::gpu::GpuMat d_map_y;\r
 871 \r
 872     cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y);\r
 873 \r
 874     TEST_CYCLE()\r
 875     {\r
 876         cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y);\r
 877     }\r
 878 }\r
 879 \r
 880 //////////////////////////////////////////////////////////////////////\r
 881 // BuildWarpCylindricalMaps\r
 882 \r
 883 PERF_TEST_P(Sz, ImgProc_BuildWarpCylindricalMaps, GPU_TYPICAL_MAT_SIZES)\r
 884 {\r
 885     cv::Size size = GetParam();\r
 886 \r
 887     cv::Mat K = cv::Mat::eye(3, 3, CV_32FC1);\r
 888     cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1);\r
 889 \r
 890     cv::gpu::GpuMat d_map_x;\r
 891     cv::gpu::GpuMat d_map_y;\r
 892 \r
 893     cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);\r
 894 \r
 895     TEST_CYCLE()\r
 896     {\r
 897         cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);\r
 898     }\r
 899 }\r
 900 \r
 901 //////////////////////////////////////////////////////////////////////\r
 902 // BuildWarpSphericalMaps\r
 903 \r
 904 PERF_TEST_P(Sz, ImgProc_BuildWarpSphericalMaps, GPU_TYPICAL_MAT_SIZES)\r
 905 {\r
 906     cv::Size size = GetParam();\r
 907 \r
 908     cv::Mat K = cv::Mat::eye(3, 3, CV_32FC1);\r
 909     cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1);\r
 910 \r
 911     cv::gpu::GpuMat d_map_x;\r
 912     cv::gpu::GpuMat d_map_y;\r
 913 \r
 914     cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);\r
 915 \r
 916     TEST_CYCLE()\r
 917     {\r
 918         cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);\r
 919     }\r
 920 }\r
 921 \r
 922 //////////////////////////////////////////////////////////////////////\r
 923 // Rotate\r
 924 \r
 925 DEF_PARAM_TEST(Sz_Depth_Cn_Inter, cv::Size, MatDepth, int, Interpolation);\r
 926 \r
 927 PERF_TEST_P(Sz_Depth_Cn_Inter, ImgProc_Rotate, Combine(\r
 928     GPU_TYPICAL_MAT_SIZES,\r
 929     Values(CV_8U, CV_16U, CV_32F),\r
 930     Values(1, 3, 4),\r
 931     Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC))))\r
 932 {\r
 933     cv::Size size = GET_PARAM(0);\r
 934     int depth = GET_PARAM(1);\r
 935     int channels = GET_PARAM(2);\r
 936     int interpolation = GET_PARAM(3);\r
 937 \r
 938     int type = CV_MAKE_TYPE(depth, channels);\r
 939 \r
 940     cv::Mat src(size, type);\r
 941     fillRandom(src);\r
 942 \r
 943     cv::gpu::GpuMat d_src(src);\r
 944     cv::gpu::GpuMat d_dst;\r
 945 \r
 946     cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);\r
 947 \r
 948     TEST_CYCLE()\r
 949     {\r
 950         cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);\r
 951     }\r
 952 }\r
 953 \r
 954 //////////////////////////////////////////////////////////////////////\r
 955 // PyrDown\r
 956 \r
 957 PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrDown, Combine(\r
 958     GPU_TYPICAL_MAT_SIZES,\r
 959     Values(CV_8U, CV_16U, CV_32F),\r
 960     Values(1, 3, 4)))\r
 961 {\r
 962     cv::Size size = GET_PARAM(0);\r
 963     int depth = GET_PARAM(1);\r
 964     int channels = GET_PARAM(2);\r
 965 \r
 966     int type = CV_MAKE_TYPE(depth, channels);\r
 967 \r
 968     cv::Mat src(size, type);\r
 969     fillRandom(src);\r
 970 \r
 971     cv::gpu::GpuMat d_src(src);\r
 972     cv::gpu::GpuMat d_dst;\r
 973 \r
 974     cv::gpu::pyrDown(d_src, d_dst);\r
 975 \r
 976     TEST_CYCLE()\r
 977     {\r
 978         cv::gpu::pyrDown(d_src, d_dst);\r
 979     }\r
 980 }\r
 981 \r
 982 //////////////////////////////////////////////////////////////////////\r
 983 // PyrUp\r
 984 \r
 985 PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrUp, Combine(\r
 986     GPU_TYPICAL_MAT_SIZES,\r
 987     Values(CV_8U, CV_16U, CV_32F),\r
 988     Values(1, 3, 4)))\r
 989 {\r
 990     cv::Size size = GET_PARAM(0);\r
 991     int depth = GET_PARAM(1);\r
 992     int channels = GET_PARAM(2);\r
 993 \r
 994     int type = CV_MAKE_TYPE(depth, channels);\r
 995 \r
 996     cv::Mat src(size, type);\r
 997     fillRandom(src);\r
 998 \r
 999     cv::gpu::GpuMat d_src(src);\r
1000     cv::gpu::GpuMat d_dst;\r
1001 \r
1002     cv::gpu::pyrUp(d_src, d_dst);\r
1003 \r
1004     TEST_CYCLE()\r
1005     {\r
1006         cv::gpu::pyrUp(d_src, d_dst);\r
1007     }\r
1008 }\r
1009 \r
1010 //////////////////////////////////////////////////////////////////////\r
1011 // CvtColor\r
1012 \r
1013 DEF_PARAM_TEST(Sz_Depth_Code, cv::Size, MatDepth, CvtColorInfo);\r
1014 \r
1015 PERF_TEST_P(Sz_Depth_Code, ImgProc_CvtColor, Combine(\r
1016     GPU_TYPICAL_MAT_SIZES,\r
1017     Values(CV_8U, CV_16U, CV_32F),\r
1018     Values(CvtColorInfo(4, 4, cv::COLOR_RGBA2BGRA),\r
1019            CvtColorInfo(4, 1, cv::COLOR_BGRA2GRAY),\r
1020            CvtColorInfo(1, 4, cv::COLOR_GRAY2BGRA),\r
1021            CvtColorInfo(3, 3, cv::COLOR_BGR2XYZ),\r
1022            CvtColorInfo(3, 3, cv::COLOR_XYZ2BGR),\r
1023            CvtColorInfo(3, 3, cv::COLOR_BGR2YCrCb),\r
1024            CvtColorInfo(3, 3, cv::COLOR_YCrCb2BGR),\r
1025            CvtColorInfo(3, 3, cv::COLOR_BGR2YUV),\r
1026            CvtColorInfo(3, 3, cv::COLOR_YUV2BGR),\r
1027            CvtColorInfo(3, 3, cv::COLOR_BGR2HSV),\r
1028            CvtColorInfo(3, 3, cv::COLOR_HSV2BGR),\r
1029            CvtColorInfo(3, 3, cv::COLOR_BGR2HLS),\r
1030            CvtColorInfo(3, 3, cv::COLOR_HLS2BGR),\r
1031            CvtColorInfo(3, 3, cv::COLOR_BGR2Lab),\r
1032            CvtColorInfo(3, 3, cv::COLOR_RGB2Lab),\r
1033            CvtColorInfo(3, 3, cv::COLOR_BGR2Luv),\r
1034            CvtColorInfo(3, 3, cv::COLOR_RGB2Luv),\r
1035            CvtColorInfo(3, 3, cv::COLOR_Lab2BGR),\r
1036            CvtColorInfo(3, 3, cv::COLOR_Lab2RGB),\r
1037            CvtColorInfo(3, 3, cv::COLOR_Luv2BGR),\r
1038            CvtColorInfo(3, 3, cv::COLOR_Luv2RGB),\r
1039            CvtColorInfo(1, 3, cv::COLOR_BayerBG2BGR),\r
1040            CvtColorInfo(1, 3, cv::COLOR_BayerGB2BGR),\r
1041            CvtColorInfo(1, 3, cv::COLOR_BayerRG2BGR),\r
1042            CvtColorInfo(1, 3, cv::COLOR_BayerGR2BGR),\r
1043            CvtColorInfo(4, 4, cv::COLOR_RGBA2mRGBA))))\r
1044 {\r
1045     cv::Size size = GET_PARAM(0);\r
1046     int depth = GET_PARAM(1);\r
1047     CvtColorInfo info = GET_PARAM(2);\r
1048 \r
1049     cv::Mat src(size, CV_MAKETYPE(depth, info.scn));\r
1050     fillRandom(src);\r
1051 \r
1052     cv::gpu::GpuMat d_src(src);\r
1053     cv::gpu::GpuMat d_dst;\r
1054 \r
1055     cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);\r
1056 \r
1057     TEST_CYCLE()\r
1058     {\r
1059         cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);\r
1060     }\r
1061 }\r
1062 \r
1063 //////////////////////////////////////////////////////////////////////\r
1064 // SwapChannels\r
1065 \r
1066 PERF_TEST_P(Sz, ImgProc_SwapChannels, GPU_TYPICAL_MAT_SIZES)\r
1067 {\r
1068     cv::Size size = GetParam();\r
1069 \r
1070     cv::Mat src(size, CV_8UC4);\r
1071     fillRandom(src);\r
1072 \r
1073     const int dstOrder[] = {2, 1, 0, 3};\r
1074 \r
1075     cv::gpu::GpuMat d_src(src);\r
1076 \r
1077     cv::gpu::swapChannels(d_src, dstOrder);\r
1078 \r
1079     TEST_CYCLE()\r
1080     {\r
1081         cv::gpu::swapChannels(d_src, dstOrder);\r
1082     }\r
1083 }\r
1084 \r
1085 //////////////////////////////////////////////////////////////////////\r
1086 // AlphaComp\r
1087 \r
1088 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
1089 #define ALL_ALPHA_OPS ValuesIn(AlphaOp::all())\r
1090 \r
1091 DEF_PARAM_TEST(Sz_Type_Op, cv::Size, MatType, AlphaOp);\r
1092 \r
1093 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
1094 {\r
1095     cv::Size size = GET_PARAM(0);\r
1096     int type = GET_PARAM(1);\r
1097     int alpha_op = GET_PARAM(2);\r
1098 \r
1099     cv::Mat img1(size, type);\r
1100     fillRandom(img1);\r
1101 \r
1102     cv::Mat img2(size, type);\r
1103     fillRandom(img2);\r
1104 \r
1105     cv::gpu::GpuMat d_img1(img1);\r
1106     cv::gpu::GpuMat d_img2(img2);\r
1107     cv::gpu::GpuMat d_dst;\r
1108 \r
1109     cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);\r
1110 \r
1111     TEST_CYCLE()\r
1112     {\r
1113         cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);\r
1114     }\r
1115 }\r
1116 \r
1117 //////////////////////////////////////////////////////////////////////\r
1118 // ImagePyramidBuild\r
1119 \r
1120 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
1121 {\r
1122     cv::Size size = GET_PARAM(0);\r
1123     int depth = GET_PARAM(1);\r
1124     int channels = GET_PARAM(2);\r
1125 \r
1126     int type = CV_MAKE_TYPE(depth, channels);\r
1127 \r
1128     cv::Mat src(size, type);\r
1129     fillRandom(src);\r
1130 \r
1131     cv::gpu::GpuMat d_src(src);\r
1132 \r
1133     cv::gpu::ImagePyramid d_pyr;\r
1134 \r
1135     d_pyr.build(d_src, 5);\r
1136 \r
1137     TEST_CYCLE()\r
1138     {\r
1139         d_pyr.build(d_src, 5);\r
1140     }\r
1141 }\r
1142 \r
1143 //////////////////////////////////////////////////////////////////////\r
1144 // ImagePyramidGetLayer\r
1145 \r
1146 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
1147 {\r
1148     cv::Size size = GET_PARAM(0);\r
1149     int depth = GET_PARAM(1);\r
1150     int channels = GET_PARAM(2);\r
1151 \r
1152     int type = CV_MAKE_TYPE(depth, channels);\r
1153 \r
1154     cv::Mat src(size, type);\r
1155     fillRandom(src);\r
1156 \r
1157     cv::Size dstSize(size.width / 2 + 10, size.height / 2 + 10);\r
1158 \r
1159     cv::gpu::GpuMat d_src(src);\r
1160     cv::gpu::GpuMat d_dst;\r
1161 \r
1162     cv::gpu::ImagePyramid d_pyr(d_src, 3);\r
1163 \r
1164     d_pyr.getLayer(d_dst, dstSize);\r
1165 \r
1166     TEST_CYCLE()\r
1167     {\r
1168         d_pyr.getLayer(d_dst, dstSize);\r
1169     }\r
1170 }\r
1171 \r
1172 //////////////////////////////////////////////////////////////////////\r
1173 // HoughLines\r
1174 \r
1175 DEF_PARAM_TEST(Sz_DoSort, cv::Size, bool);\r
1176 \r
1177 PERF_TEST_P(Sz_DoSort, ImgProc_HoughLines, Combine(GPU_TYPICAL_MAT_SIZES, Bool()))\r
1178 {\r
1179     declare.time(30.0);\r
1180 \r
1181     const cv::Size size = GET_PARAM(0);\r
1182     const bool doSort = GET_PARAM(1);\r
1183 \r
1184     const float rho = 1.0f;\r
1185     const float theta = CV_PI / 180.0f;\r
1186     const int threshold = 300;\r
1187 \r
1188     cv::RNG rng(123456789);\r
1189 \r
1190     cv::Mat src(size, CV_8UC1, cv::Scalar::all(0));\r
1191 \r
1192     const int numLines = rng.uniform(500, 2000);\r
1193     for (int i = 0; i < numLines; ++i)\r
1194     {\r
1195         cv::Point p1(rng.uniform(0, src.cols), rng.uniform(0, src.rows));\r
1196         cv::Point p2(rng.uniform(0, src.cols), rng.uniform(0, src.rows));\r
1197         cv::line(src, p1, p2, cv::Scalar::all(255), 2);\r
1198     }\r
1199 \r
1200     cv::gpu::GpuMat d_src(src);\r
1201     cv::gpu::GpuMat d_lines;\r
1202     cv::gpu::GpuMat d_accum;\r
1203     cv::gpu::GpuMat d_buf;\r
1204 \r
1205     cv::gpu::HoughLines(d_src, d_lines, d_accum, d_buf, rho, theta, threshold, doSort);\r
1206 \r
1207     TEST_CYCLE()\r
1208     {\r
1209         cv::gpu::HoughLines(d_src, d_lines, d_accum, d_buf, rho, theta, threshold, doSort);\r
1210     }\r
1211 }\r
1212 \r
1213 } // namespace\r