modules/gpu/perf/perf_imgproc.cpp

   1 #include "perf_precomp.hpp"\r
   2 \r
   3 #ifdef HAVE_CUDA\r
   4 \r
   5 //////////////////////////////////////////////////////////////////////\r
   6 // Remap\r
   7 \r
   8 GPU_PERF_TEST(Remap, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, BorderMode)\r
   9 {\r
  10     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
  11     cv::gpu::setDevice(devInfo.deviceID());\r
  12 \r
  13     cv::Size size = GET_PARAM(1);\r
  14     int type = GET_PARAM(2);\r
  15     int interpolation = GET_PARAM(3);\r
  16     int borderMode = GET_PARAM(4);\r
  17 \r
  18     cv::Mat src_host(size, type);\r
  19     fill(src_host, 0, 255);\r
  20 \r
  21     cv::Mat xmap_host(size, CV_32FC1);\r
  22     fill(xmap_host, 0, size.width);\r
  23 \r
  24     cv::Mat ymap_host(size, CV_32FC1);\r
  25     fill(ymap_host, 0, size.height);\r
  26 \r
  27     cv::gpu::GpuMat src(src_host);\r
  28     cv::gpu::GpuMat xmap(xmap_host);\r
  29     cv::gpu::GpuMat ymap(ymap_host);\r
  30     cv::gpu::GpuMat dst;\r
  31 \r
  32     cv::gpu::remap(src, dst, xmap, ymap, interpolation, borderMode);\r
  33 \r
  34     declare.time(3.0);\r
  35 \r
  36     TEST_CYCLE()\r
  37     {\r
  38         cv::gpu::remap(src, dst, xmap, ymap, interpolation, borderMode);\r
  39     }\r
  40 }\r
  41 \r
  42 INSTANTIATE_TEST_CASE_P(ImgProc, Remap, testing::Combine(\r
  43     ALL_DEVICES,\r
  44     GPU_TYPICAL_MAT_SIZES,\r
  45     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
  46                     MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
  47                     MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
  48     testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),\r
  49     testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));\r
  50 \r
  51 \r
  52 //////////////////////////////////////////////////////////////////////\r
  53 // Resize\r
  54 \r
  55 IMPLEMENT_PARAM_CLASS(Scale, double)\r
  56 \r
  57 GPU_PERF_TEST(Resize, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, Scale)\r
  58 {\r
  59     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
  60     cv::gpu::setDevice(devInfo.deviceID());\r
  61 \r
  62     cv::Size size = GET_PARAM(1);\r
  63     int type = GET_PARAM(2);\r
  64     int interpolation = GET_PARAM(3);\r
  65     double f = GET_PARAM(4);\r
  66 \r
  67     cv::Mat src_host(size, type);\r
  68     fill(src_host, 0, 255);\r
  69 \r
  70     cv::gpu::GpuMat src(src_host);\r
  71     cv::gpu::GpuMat dst;\r
  72 \r
  73     cv::gpu::resize(src, dst, cv::Size(), f, f, interpolation);\r
  74 \r
  75     declare.time(1.0);\r
  76 \r
  77     TEST_CYCLE()\r
  78     {\r
  79         cv::gpu::resize(src, dst, cv::Size(), f, f, interpolation);\r
  80     }\r
  81 }\r
  82 \r
  83 INSTANTIATE_TEST_CASE_P(ImgProc, Resize, testing::Combine(\r
  84     ALL_DEVICES,\r
  85     GPU_TYPICAL_MAT_SIZES,\r
  86     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
  87                     MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
  88                     MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
  89     testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR),\r
  90                     Interpolation(cv::INTER_CUBIC),   Interpolation(cv::INTER_AREA)),\r
  91     testing::Values(Scale(0.5), Scale(0.3), Scale(2.0))));\r
  92 \r
  93 GPU_PERF_TEST(ResizeArea, cv::gpu::DeviceInfo, cv::Size, MatType, Scale)\r
  94 {\r
  95     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
  96     cv::gpu::setDevice(devInfo.deviceID());\r
  97 \r
  98     cv::Size size = GET_PARAM(1);\r
  99     int type = GET_PARAM(2);\r
 100     int interpolation = cv::INTER_AREA;\r
 101     double f = GET_PARAM(3);\r
 102 \r
 103     cv::Mat src_host(size, type);\r
 104     fill(src_host, 0, 255);\r
 105 \r
 106     cv::gpu::GpuMat src(src_host);\r
 107     cv::gpu::GpuMat dst;\r
 108 \r
 109     cv::gpu::resize(src, dst, cv::Size(), f, f, interpolation);\r
 110 \r
 111     declare.time(1.0);\r
 112 \r
 113     TEST_CYCLE()\r
 114     {\r
 115         cv::gpu::resize(src, dst, cv::Size(), f, f, interpolation);\r
 116     }\r
 117 }\r
 118 \r
 119 INSTANTIATE_TEST_CASE_P(ImgProc, ResizeArea, testing::Combine(\r
 120     ALL_DEVICES,\r
 121     testing::Values(perf::sz1080p/*, cv::Size(4096, 2048)*/),\r
 122     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
 123                     MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
 124                     MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
 125     testing::Values(Scale(0.2),Scale(0.1),Scale(0.05))));\r
 126 \r
 127 //////////////////////////////////////////////////////////////////////\r
 128 // WarpAffine\r
 129 \r
 130 GPU_PERF_TEST(WarpAffine, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, BorderMode)\r
 131 {\r
 132     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 133     cv::gpu::setDevice(devInfo.deviceID());\r
 134 \r
 135     cv::Size size = GET_PARAM(1);\r
 136     int type = GET_PARAM(2);\r
 137     int interpolation = GET_PARAM(3);\r
 138     int borderMode = GET_PARAM(4);\r
 139 \r
 140     cv::Mat src_host(size, type);\r
 141     fill(src_host, 0, 255);\r
 142 \r
 143     cv::gpu::GpuMat src(src_host);\r
 144     cv::gpu::GpuMat dst;\r
 145 \r
 146     const double aplha = CV_PI / 4;\r
 147     double mat[2][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},\r
 148                          {std::sin(aplha),  std::cos(aplha), 0}};\r
 149     cv::Mat M(2, 3, CV_64F, (void*) mat);\r
 150 \r
 151     cv::gpu::warpAffine(src, dst, M, size, interpolation, borderMode);\r
 152 \r
 153     TEST_CYCLE()\r
 154     {\r
 155         cv::gpu::warpAffine(src, dst, M, size, interpolation, borderMode);\r
 156     }\r
 157 }\r
 158 \r
 159 INSTANTIATE_TEST_CASE_P(ImgProc, WarpAffine, testing::Combine(\r
 160     ALL_DEVICES,\r
 161     GPU_TYPICAL_MAT_SIZES,\r
 162     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
 163                     MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
 164                     MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
 165     testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),\r
 166     testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));\r
 167 \r
 168 //////////////////////////////////////////////////////////////////////\r
 169 // WarpPerspective\r
 170 \r
 171 GPU_PERF_TEST(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, BorderMode)\r
 172 {\r
 173     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 174     cv::gpu::setDevice(devInfo.deviceID());\r
 175 \r
 176     cv::Size size = GET_PARAM(1);\r
 177     int type = GET_PARAM(2);\r
 178     int interpolation = GET_PARAM(3);\r
 179     int borderMode = GET_PARAM(4);\r
 180 \r
 181     cv::Mat src_host(size, type);\r
 182     fill(src_host, 0, 255);\r
 183 \r
 184     cv::gpu::GpuMat src(src_host);\r
 185     cv::gpu::GpuMat dst;\r
 186 \r
 187     const double aplha = CV_PI / 4;\r
 188     double mat[3][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},\r
 189                          {std::sin(aplha),  std::cos(aplha), 0},\r
 190                          {0.0,              0.0,             1.0}};\r
 191     cv::Mat M(3, 3, CV_64F, (void*) mat);\r
 192 \r
 193     cv::gpu::warpPerspective(src, dst, M, size, interpolation, borderMode);\r
 194 \r
 195     TEST_CYCLE()\r
 196     {\r
 197         cv::gpu::warpPerspective(src, dst, M, size, interpolation, borderMode);\r
 198     }\r
 199 }\r
 200 \r
 201 INSTANTIATE_TEST_CASE_P(ImgProc, WarpPerspective, testing::Combine(\r
 202     ALL_DEVICES,\r
 203     GPU_TYPICAL_MAT_SIZES,\r
 204     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
 205                     MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
 206                     MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
 207     testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),\r
 208     testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));\r
 209 \r
 210 //////////////////////////////////////////////////////////////////////\r
 211 // CopyMakeBorder\r
 212 \r
 213 GPU_PERF_TEST(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, MatType, BorderMode)\r
 214 {\r
 215     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 216     cv::gpu::setDevice(devInfo.deviceID());\r
 217 \r
 218     cv::Size size = GET_PARAM(1);\r
 219     int type = GET_PARAM(2);\r
 220     int borderType = GET_PARAM(3);\r
 221 \r
 222     cv::Mat src_host(size, type);\r
 223     fill(src_host, 0, 255);\r
 224 \r
 225     cv::gpu::GpuMat src(src_host);\r
 226     cv::gpu::GpuMat dst;\r
 227 \r
 228     cv::gpu::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType);\r
 229 \r
 230     TEST_CYCLE()\r
 231     {\r
 232         cv::gpu::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType);\r
 233     }\r
 234 }\r
 235 \r
 236 INSTANTIATE_TEST_CASE_P(ImgProc, CopyMakeBorder, testing::Combine(\r
 237     ALL_DEVICES,\r
 238     GPU_TYPICAL_MAT_SIZES,\r
 239     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
 240                     MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
 241                     MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
 242     testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));\r
 243 \r
 244 //////////////////////////////////////////////////////////////////////\r
 245 // Threshold\r
 246 \r
 247 CV_ENUM(ThreshOp, cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV)\r
 248 #define ALL_THRESH_OPS testing::Values(ThreshOp(cv::THRESH_BINARY), ThreshOp(cv::THRESH_BINARY_INV), ThreshOp(cv::THRESH_TRUNC), ThreshOp(cv::THRESH_TOZERO), ThreshOp(cv::THRESH_TOZERO_INV))\r
 249 \r
 250 GPU_PERF_TEST(Threshold, cv::gpu::DeviceInfo, cv::Size, MatDepth, ThreshOp)\r
 251 {\r
 252     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 253     cv::gpu::setDevice(devInfo.deviceID());\r
 254 \r
 255     cv::Size size = GET_PARAM(1);\r
 256     int depth = GET_PARAM(2);\r
 257     int threshOp = GET_PARAM(3);\r
 258 \r
 259     cv::Mat src_host(size, depth);\r
 260     fill(src_host, 0, 255);\r
 261 \r
 262     cv::gpu::GpuMat src(src_host);\r
 263     cv::gpu::GpuMat dst;\r
 264 \r
 265     cv::gpu::threshold(src, dst, 100.0, 255.0, threshOp);\r
 266 \r
 267     TEST_CYCLE()\r
 268     {\r
 269         cv::gpu::threshold(src, dst, 100.0, 255.0, threshOp);\r
 270     }\r
 271 }\r
 272 \r
 273 INSTANTIATE_TEST_CASE_P(ImgProc, Threshold, testing::Combine(\r
 274     ALL_DEVICES,\r
 275     GPU_TYPICAL_MAT_SIZES,\r
 276     testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F), MatDepth(CV_64F)),\r
 277     ALL_THRESH_OPS));\r
 278 \r
 279 //////////////////////////////////////////////////////////////////////\r
 280 // Integral\r
 281 \r
 282 GPU_PERF_TEST(Integral, cv::gpu::DeviceInfo, cv::Size)\r
 283 {\r
 284     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 285     cv::gpu::setDevice(devInfo.deviceID());\r
 286 \r
 287     cv::Size size = GET_PARAM(1);\r
 288 \r
 289     cv::Mat src_host(size, CV_8UC1);\r
 290     fill(src_host, 0, 255);\r
 291 \r
 292     cv::gpu::GpuMat src(src_host);\r
 293     cv::gpu::GpuMat dst;\r
 294     cv::gpu::GpuMat buf;\r
 295 \r
 296     cv::gpu::integralBuffered(src, dst, buf);\r
 297 \r
 298     TEST_CYCLE()\r
 299     {\r
 300         cv::gpu::integralBuffered(src, dst, buf);\r
 301     }\r
 302 }\r
 303 \r
 304 INSTANTIATE_TEST_CASE_P(ImgProc, Integral, testing::Combine(\r
 305     ALL_DEVICES,\r
 306     GPU_TYPICAL_MAT_SIZES));\r
 307 \r
 308 //////////////////////////////////////////////////////////////////////\r
 309 // Integral_Sqr\r
 310 \r
 311 GPU_PERF_TEST(Integral_Sqr, cv::gpu::DeviceInfo, cv::Size)\r
 312 {\r
 313     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 314     cv::gpu::setDevice(devInfo.deviceID());\r
 315 \r
 316     cv::Size size = GET_PARAM(1);\r
 317 \r
 318     cv::Mat src_host(size, CV_8UC1);\r
 319     fill(src_host, 0, 255);\r
 320 \r
 321     cv::gpu::GpuMat src(src_host);\r
 322     cv::gpu::GpuMat dst;\r
 323 \r
 324     cv::gpu::sqrIntegral(src, dst);\r
 325 \r
 326     TEST_CYCLE()\r
 327     {\r
 328         cv::gpu::sqrIntegral(src, dst);\r
 329     }\r
 330 }\r
 331 \r
 332 INSTANTIATE_TEST_CASE_P(ImgProc, Integral_Sqr, testing::Combine(\r
 333     ALL_DEVICES,\r
 334     GPU_TYPICAL_MAT_SIZES));\r
 335 \r
 336 //////////////////////////////////////////////////////////////////////\r
 337 // HistEven_OneChannel\r
 338 \r
 339 GPU_PERF_TEST(HistEven_OneChannel, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
 340 {\r
 341     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 342     cv::gpu::setDevice(devInfo.deviceID());\r
 343 \r
 344     cv::Size size = GET_PARAM(1);\r
 345     int depth = GET_PARAM(2);\r
 346 \r
 347     cv::Mat src_host(size, depth);\r
 348     fill(src_host, 0, 255);\r
 349 \r
 350     cv::gpu::GpuMat src(src_host);\r
 351     cv::gpu::GpuMat hist;\r
 352     cv::gpu::GpuMat buf;\r
 353 \r
 354     cv::gpu::histEven(src, hist, buf, 30, 0, 180);\r
 355 \r
 356     TEST_CYCLE()\r
 357     {\r
 358         cv::gpu::histEven(src, hist, buf, 30, 0, 180);\r
 359     }\r
 360 }\r
 361 \r
 362 INSTANTIATE_TEST_CASE_P(ImgProc, HistEven_OneChannel, testing::Combine(\r
 363     ALL_DEVICES,\r
 364     GPU_TYPICAL_MAT_SIZES,\r
 365     testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S))));\r
 366 \r
 367 //////////////////////////////////////////////////////////////////////\r
 368 // HistEven_FourChannel\r
 369 \r
 370 GPU_PERF_TEST(HistEven_FourChannel, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
 371 {\r
 372     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 373     cv::gpu::setDevice(devInfo.deviceID());\r
 374 \r
 375     cv::Size size = GET_PARAM(1);\r
 376     int depth = GET_PARAM(2);\r
 377 \r
 378     cv::Mat src_host(size, CV_MAKE_TYPE(depth, 4));\r
 379     fill(src_host, 0, 255);\r
 380 \r
 381     cv::gpu::GpuMat src(src_host);\r
 382     cv::gpu::GpuMat hist[4];\r
 383     cv::gpu::GpuMat buf;\r
 384     int histSize[] = {30, 30, 30, 30};\r
 385     int lowerLevel[] = {0, 0, 0, 0};\r
 386     int upperLevel[] = {180, 180, 180, 180};\r
 387 \r
 388     cv::gpu::histEven(src, hist, buf, histSize, lowerLevel, upperLevel);\r
 389 \r
 390     TEST_CYCLE()\r
 391     {\r
 392         cv::gpu::histEven(src, hist, buf, histSize, lowerLevel, upperLevel);\r
 393     }\r
 394 }\r
 395 \r
 396 INSTANTIATE_TEST_CASE_P(ImgProc, HistEven_FourChannel, testing::Combine(\r
 397     ALL_DEVICES,\r
 398     GPU_TYPICAL_MAT_SIZES,\r
 399     testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S))));\r
 400 \r
 401 //////////////////////////////////////////////////////////////////////\r
 402 // CalcHist\r
 403 \r
 404 GPU_PERF_TEST(CalcHist, cv::gpu::DeviceInfo, cv::Size)\r
 405 {\r
 406     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 407     cv::gpu::setDevice(devInfo.deviceID());\r
 408 \r
 409     cv::Size size = GET_PARAM(1);\r
 410 \r
 411     cv::Mat src_host(size, CV_8UC1);\r
 412     fill(src_host, 0, 255);\r
 413 \r
 414     cv::gpu::GpuMat src(src_host);\r
 415     cv::gpu::GpuMat hist;\r
 416     cv::gpu::GpuMat buf;\r
 417 \r
 418     cv::gpu::calcHist(src, hist, buf);\r
 419 \r
 420     TEST_CYCLE()\r
 421     {\r
 422         cv::gpu::calcHist(src, hist, buf);\r
 423     }\r
 424 }\r
 425 \r
 426 INSTANTIATE_TEST_CASE_P(ImgProc, CalcHist, testing::Combine(\r
 427     ALL_DEVICES,\r
 428     GPU_TYPICAL_MAT_SIZES));\r
 429 \r
 430 //////////////////////////////////////////////////////////////////////\r
 431 // EqualizeHist\r
 432 \r
 433 GPU_PERF_TEST(EqualizeHist, cv::gpu::DeviceInfo, cv::Size)\r
 434 {\r
 435     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 436     cv::gpu::setDevice(devInfo.deviceID());\r
 437 \r
 438     cv::Size size = GET_PARAM(1);\r
 439 \r
 440     cv::Mat src_host(size, CV_8UC1);\r
 441     fill(src_host, 0, 255);\r
 442 \r
 443     cv::gpu::GpuMat src(src_host);\r
 444     cv::gpu::GpuMat dst;\r
 445     cv::gpu::GpuMat hist;\r
 446     cv::gpu::GpuMat buf;\r
 447 \r
 448     cv::gpu::equalizeHist(src, dst, hist, buf);\r
 449 \r
 450     TEST_CYCLE()\r
 451     {\r
 452         cv::gpu::equalizeHist(src, dst, hist, buf);\r
 453     }\r
 454 }\r
 455 \r
 456 INSTANTIATE_TEST_CASE_P(ImgProc, EqualizeHist, testing::Combine(\r
 457     ALL_DEVICES,\r
 458     GPU_TYPICAL_MAT_SIZES));\r
 459 \r
 460 //////////////////////////////////////////////////////////////////////\r
 461 // ColumnSum\r
 462 \r
 463 GPU_PERF_TEST(ColumnSum, cv::gpu::DeviceInfo, cv::Size)\r
 464 {\r
 465     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 466     cv::gpu::setDevice(devInfo.deviceID());\r
 467 \r
 468     cv::Size size = GET_PARAM(1);\r
 469 \r
 470     cv::Mat src_host(size, CV_32FC1);\r
 471     fill(src_host, 0, 255);\r
 472 \r
 473     cv::gpu::GpuMat src(src_host);\r
 474     cv::gpu::GpuMat dst;\r
 475 \r
 476     cv::gpu::columnSum(src, dst);\r
 477 \r
 478     TEST_CYCLE()\r
 479     {\r
 480         cv::gpu::columnSum(src, dst);\r
 481     }\r
 482 }\r
 483 \r
 484 INSTANTIATE_TEST_CASE_P(ImgProc, ColumnSum, testing::Combine(\r
 485     ALL_DEVICES,\r
 486     GPU_TYPICAL_MAT_SIZES));\r
 487 \r
 488 //////////////////////////////////////////////////////////////////////\r
 489 // Canny\r
 490 \r
 491 IMPLEMENT_PARAM_CLASS(AppertureSize, int)\r
 492 IMPLEMENT_PARAM_CLASS(L2gradient, bool)\r
 493 \r
 494 GPU_PERF_TEST(Canny, cv::gpu::DeviceInfo, AppertureSize, L2gradient)\r
 495 {\r
 496     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 497     cv::gpu::setDevice(devInfo.deviceID());\r
 498 \r
 499     int apperture_size = GET_PARAM(1);\r
 500     bool useL2gradient = GET_PARAM(2);\r
 501 \r
 502     cv::Mat image_host = readImage("perf/1280x1024.jpg", cv::IMREAD_GRAYSCALE);\r
 503     ASSERT_FALSE(image_host.empty());\r
 504 \r
 505     cv::gpu::GpuMat image(image_host);\r
 506     cv::gpu::GpuMat dst;\r
 507     cv::gpu::CannyBuf buf;\r
 508 \r
 509     cv::gpu::Canny(image, buf, dst, 50.0, 100.0, apperture_size, useL2gradient);\r
 510 \r
 511     TEST_CYCLE()\r
 512     {\r
 513         cv::gpu::Canny(image, buf, dst, 50.0, 100.0, apperture_size, useL2gradient);\r
 514     }\r
 515 }\r
 516 \r
 517 INSTANTIATE_TEST_CASE_P(ImgProc, Canny, testing::Combine(\r
 518     ALL_DEVICES,\r
 519     testing::Values(AppertureSize(3), AppertureSize(5)),\r
 520     testing::Values(L2gradient(false), L2gradient(true))));\r
 521 \r
 522 //////////////////////////////////////////////////////////////////////\r
 523 // MeanShiftFiltering\r
 524 \r
 525 GPU_PERF_TEST_1(MeanShiftFiltering, cv::gpu::DeviceInfo)\r
 526 {\r
 527     cv::gpu::DeviceInfo devInfo = GetParam();\r
 528     cv::gpu::setDevice(devInfo.deviceID());\r
 529 \r
 530     cv::Mat img = readImage("gpu/meanshift/cones.png");\r
 531     ASSERT_FALSE(img.empty());\r
 532 \r
 533     cv::Mat rgba;\r
 534     cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);\r
 535 \r
 536     cv::gpu::GpuMat src(rgba);\r
 537     cv::gpu::GpuMat dst;\r
 538 \r
 539     cv::gpu::meanShiftFiltering(src, dst, 50, 50);\r
 540 \r
 541     declare.time(5.0);\r
 542 \r
 543     TEST_CYCLE()\r
 544     {\r
 545         cv::gpu::meanShiftFiltering(src, dst, 50, 50);\r
 546     }\r
 547 }\r
 548 \r
 549 INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftFiltering, ALL_DEVICES);\r
 550 \r
 551 //////////////////////////////////////////////////////////////////////\r
 552 // MeanShiftProc\r
 553 \r
 554 GPU_PERF_TEST_1(MeanShiftProc, cv::gpu::DeviceInfo)\r
 555 {\r
 556     cv::gpu::DeviceInfo devInfo = GetParam();\r
 557     cv::gpu::setDevice(devInfo.deviceID());\r
 558 \r
 559     cv::Mat img = readImage("gpu/meanshift/cones.png");\r
 560     ASSERT_FALSE(img.empty());\r
 561 \r
 562     cv::Mat rgba;\r
 563     cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);\r
 564 \r
 565     cv::gpu::GpuMat src(rgba);\r
 566     cv::gpu::GpuMat dstr;\r
 567     cv::gpu::GpuMat dstsp;\r
 568 \r
 569     cv::gpu::meanShiftProc(src, dstr, dstsp, 50, 50);\r
 570 \r
 571     declare.time(5.0);\r
 572 \r
 573     TEST_CYCLE()\r
 574     {\r
 575         cv::gpu::meanShiftProc(src, dstr, dstsp, 50, 50);\r
 576     }\r
 577 }\r
 578 \r
 579 INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftProc, ALL_DEVICES);\r
 580 \r
 581 //////////////////////////////////////////////////////////////////////\r
 582 // MeanShiftSegmentation\r
 583 \r
 584 GPU_PERF_TEST_1(MeanShiftSegmentation, cv::gpu::DeviceInfo)\r
 585 {\r
 586     cv::gpu::DeviceInfo devInfo = GetParam();\r
 587     cv::gpu::setDevice(devInfo.deviceID());\r
 588 \r
 589     cv::Mat img = readImage("gpu/meanshift/cones.png");\r
 590     ASSERT_FALSE(img.empty());\r
 591 \r
 592     cv::Mat rgba;\r
 593     cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);\r
 594 \r
 595     cv::gpu::GpuMat src(rgba);\r
 596     cv::Mat dst;\r
 597 \r
 598     meanShiftSegmentation(src, dst, 10, 10, 20);\r
 599 \r
 600     declare.time(5.0);\r
 601 \r
 602     TEST_CYCLE()\r
 603     {\r
 604         meanShiftSegmentation(src, dst, 10, 10, 20);\r
 605     }\r
 606 }\r
 607 \r
 608 INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftSegmentation, ALL_DEVICES);\r
 609 \r
 610 //////////////////////////////////////////////////////////////////////\r
 611 // BlendLinear\r
 612 \r
 613 GPU_PERF_TEST(BlendLinear, cv::gpu::DeviceInfo, cv::Size, MatType)\r
 614 {\r
 615     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 616     cv::gpu::setDevice(devInfo.deviceID());\r
 617 \r
 618     cv::Size size = GET_PARAM(1);\r
 619     int type = GET_PARAM(2);\r
 620 \r
 621     cv::Mat img1_host(size, type);\r
 622     fill(img1_host, 0, 255);\r
 623 \r
 624     cv::Mat img2_host(size, type);\r
 625     fill(img2_host, 0, 255);\r
 626 \r
 627     cv::gpu::GpuMat img1(img1_host);\r
 628     cv::gpu::GpuMat img2(img2_host);\r
 629     cv::gpu::GpuMat weights1(size, CV_32FC1, cv::Scalar::all(0.5));\r
 630     cv::gpu::GpuMat weights2(size, CV_32FC1, cv::Scalar::all(0.5));\r
 631     cv::gpu::GpuMat dst;\r
 632 \r
 633     cv::gpu::blendLinear(img1, img2, weights1, weights2, dst);\r
 634 \r
 635     TEST_CYCLE()\r
 636     {\r
 637         cv::gpu::blendLinear(img1, img2, weights1, weights2, dst);\r
 638     }\r
 639 }\r
 640 \r
 641 INSTANTIATE_TEST_CASE_P(ImgProc, BlendLinear, testing::Combine(\r
 642     ALL_DEVICES,\r
 643     GPU_TYPICAL_MAT_SIZES,\r
 644     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
 645                     MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4))));\r
 646 \r
 647 //////////////////////////////////////////////////////////////////////\r
 648 // Convolve\r
 649 \r
 650 IMPLEMENT_PARAM_CLASS(KSize, int)\r
 651 IMPLEMENT_PARAM_CLASS(Ccorr, bool)\r
 652 \r
 653 GPU_PERF_TEST(Convolve, cv::gpu::DeviceInfo, cv::Size, KSize, Ccorr)\r
 654 {\r
 655     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 656     cv::gpu::setDevice(devInfo.deviceID());\r
 657 \r
 658     cv::Size size = GET_PARAM(1);\r
 659     int templ_size = GET_PARAM(2);\r
 660     bool ccorr = GET_PARAM(3);\r
 661 \r
 662     cv::gpu::GpuMat image = cv::gpu::createContinuous(size, CV_32FC1);\r
 663     image.setTo(cv::Scalar(1.0));\r
 664 \r
 665     cv::gpu::GpuMat templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);\r
 666     templ.setTo(cv::Scalar(1.0));\r
 667 \r
 668     cv::gpu::GpuMat dst;\r
 669     cv::gpu::ConvolveBuf buf;\r
 670 \r
 671     cv::gpu::convolve(image, templ, dst, ccorr, buf);\r
 672 \r
 673     declare.time(2.0);\r
 674 \r
 675     TEST_CYCLE()\r
 676     {\r
 677         cv::gpu::convolve(image, templ, dst, ccorr, buf);\r
 678     }\r
 679 }\r
 680 \r
 681 INSTANTIATE_TEST_CASE_P(ImgProc, Convolve, testing::Combine(\r
 682     ALL_DEVICES,\r
 683     GPU_TYPICAL_MAT_SIZES,\r
 684     testing::Values(KSize(3), KSize(9), KSize(17), KSize(27), KSize(32), KSize(64)),\r
 685     testing::Values(Ccorr(false), Ccorr(true))));\r
 686 \r
 687 ////////////////////////////////////////////////////////////////////////////////\r
 688 // MatchTemplate_8U\r
 689 \r
 690 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
 691 #define ALL_TEMPLATE_METHODS testing::Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_SQDIFF_NORMED), TemplateMethod(cv::TM_CCORR), TemplateMethod(cv::TM_CCORR_NORMED), TemplateMethod(cv::TM_CCOEFF), TemplateMethod(cv::TM_CCOEFF_NORMED))\r
 692 \r
 693 IMPLEMENT_PARAM_CLASS(TemplateSize, cv::Size)\r
 694 \r
 695 GPU_PERF_TEST(MatchTemplate_8U, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Channels, TemplateMethod)\r
 696 {\r
 697     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 698     cv::gpu::setDevice(devInfo.deviceID());\r
 699 \r
 700     cv::Size size = GET_PARAM(1);\r
 701     cv::Size templ_size = GET_PARAM(2);\r
 702     int cn = GET_PARAM(3);\r
 703     int method = GET_PARAM(4);\r
 704 \r
 705     cv::Mat image_host(size, CV_MAKE_TYPE(CV_8U, cn));\r
 706     fill(image_host, 0, 255);\r
 707 \r
 708     cv::Mat templ_host(templ_size, CV_MAKE_TYPE(CV_8U, cn));\r
 709     fill(templ_host, 0, 255);\r
 710 \r
 711     cv::gpu::GpuMat image(image_host);\r
 712     cv::gpu::GpuMat templ(templ_host);\r
 713     cv::gpu::GpuMat dst;\r
 714 \r
 715     cv::gpu::matchTemplate(image, templ, dst, method);\r
 716 \r
 717     TEST_CYCLE()\r
 718     {\r
 719         cv::gpu::matchTemplate(image, templ, dst, method);\r
 720     }\r
 721 };\r
 722 \r
 723 INSTANTIATE_TEST_CASE_P(ImgProc, MatchTemplate_8U, testing::Combine(\r
 724     ALL_DEVICES,\r
 725     GPU_TYPICAL_MAT_SIZES,\r
 726     testing::Values(TemplateSize(cv::Size(5, 5)), TemplateSize(cv::Size(16, 16)), TemplateSize(cv::Size(30, 30))),\r
 727     testing::Values(Channels(1), Channels(3), Channels(4)),\r
 728     ALL_TEMPLATE_METHODS));\r
 729 \r
 730 ////////////////////////////////////////////////////////////////////////////////\r
 731 // MatchTemplate_32F\r
 732 \r
 733 GPU_PERF_TEST(MatchTemplate_32F, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Channels, TemplateMethod)\r
 734 {\r
 735     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 736     cv::gpu::setDevice(devInfo.deviceID());\r
 737 \r
 738     cv::Size size = GET_PARAM(1);\r
 739     cv::Size templ_size = GET_PARAM(2);\r
 740     int cn = GET_PARAM(3);\r
 741     int method = GET_PARAM(4);\r
 742 \r
 743     cv::Mat image_host(size, CV_MAKE_TYPE(CV_32F, cn));\r
 744     fill(image_host, 0, 255);\r
 745 \r
 746     cv::Mat templ_host(templ_size, CV_MAKE_TYPE(CV_32F, cn));\r
 747     fill(templ_host, 0, 255);\r
 748 \r
 749     cv::gpu::GpuMat image(image_host);\r
 750     cv::gpu::GpuMat templ(templ_host);\r
 751     cv::gpu::GpuMat dst;\r
 752 \r
 753     cv::gpu::matchTemplate(image, templ, dst, method);\r
 754 \r
 755     TEST_CYCLE()\r
 756     {\r
 757         cv::gpu::matchTemplate(image, templ, dst, method);\r
 758     }\r
 759 };\r
 760 \r
 761 INSTANTIATE_TEST_CASE_P(ImgProc, MatchTemplate_32F, testing::Combine(\r
 762     ALL_DEVICES,\r
 763     GPU_TYPICAL_MAT_SIZES,\r
 764     testing::Values(TemplateSize(cv::Size(5, 5)), TemplateSize(cv::Size(16, 16)), TemplateSize(cv::Size(30, 30))),\r
 765     testing::Values(Channels(1), Channels(3), Channels(4)),\r
 766     testing::Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_CCORR))));\r
 767 \r
 768 //////////////////////////////////////////////////////////////////////\r
 769 // MulSpectrums\r
 770 \r
 771 CV_FLAGS(DftFlags, 0, cv::DFT_INVERSE, cv::DFT_SCALE, cv::DFT_ROWS, cv::DFT_COMPLEX_OUTPUT, cv::DFT_REAL_OUTPUT)\r
 772 \r
 773 GPU_PERF_TEST(MulSpectrums, cv::gpu::DeviceInfo, cv::Size, DftFlags)\r
 774 {\r
 775     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 776     cv::gpu::setDevice(devInfo.deviceID());\r
 777 \r
 778     cv::Size size = GET_PARAM(1);\r
 779     int flag = GET_PARAM(2);\r
 780 \r
 781     cv::Mat a_host(size, CV_32FC2);\r
 782     fill(a_host, 0, 100);\r
 783 \r
 784     cv::Mat b_host(size, CV_32FC2);\r
 785     fill(b_host, 0, 100);\r
 786 \r
 787     cv::gpu::GpuMat a(a_host);\r
 788     cv::gpu::GpuMat b(b_host);\r
 789     cv::gpu::GpuMat dst;\r
 790 \r
 791     cv::gpu::mulSpectrums(a, b, dst, flag);\r
 792 \r
 793     TEST_CYCLE()\r
 794     {\r
 795         cv::gpu::mulSpectrums(a, b, dst, flag);\r
 796     }\r
 797 }\r
 798 \r
 799 INSTANTIATE_TEST_CASE_P(ImgProc, MulSpectrums, testing::Combine(\r
 800     ALL_DEVICES,\r
 801     GPU_TYPICAL_MAT_SIZES,\r
 802     testing::Values(DftFlags(0), DftFlags(cv::DFT_ROWS))));\r
 803 \r
 804 //////////////////////////////////////////////////////////////////////\r
 805 // MulAndScaleSpectrums\r
 806 \r
 807 GPU_PERF_TEST(MulAndScaleSpectrums, cv::gpu::DeviceInfo, cv::Size)\r
 808 {\r
 809     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 810     cv::gpu::setDevice(devInfo.deviceID());\r
 811 \r
 812     cv::Size size = GET_PARAM(1);\r
 813 \r
 814     float scale = 1.f / size.area();\r
 815 \r
 816     cv::Mat src1_host(size, CV_32FC2);\r
 817     fill(src1_host, 0, 100);\r
 818 \r
 819     cv::Mat src2_host(size, CV_32FC2);\r
 820     fill(src2_host, 0, 100);\r
 821 \r
 822     cv::gpu::GpuMat src1(src1_host);\r
 823     cv::gpu::GpuMat src2(src2_host);\r
 824     cv::gpu::GpuMat dst;\r
 825 \r
 826     cv::gpu::mulAndScaleSpectrums(src1, src2, dst, cv::DFT_ROWS, scale, false);\r
 827 \r
 828     TEST_CYCLE()\r
 829     {\r
 830         cv::gpu::mulAndScaleSpectrums(src1, src2, dst, cv::DFT_ROWS, scale, false);\r
 831     }\r
 832 }\r
 833 \r
 834 INSTANTIATE_TEST_CASE_P(ImgProc, MulAndScaleSpectrums, testing::Combine(\r
 835     ALL_DEVICES,\r
 836     GPU_TYPICAL_MAT_SIZES));\r
 837 \r
 838 //////////////////////////////////////////////////////////////////////\r
 839 // Dft\r
 840 \r
 841 GPU_PERF_TEST(Dft, cv::gpu::DeviceInfo, cv::Size, DftFlags)\r
 842 {\r
 843     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 844     cv::gpu::setDevice(devInfo.deviceID());\r
 845 \r
 846     cv::Size size = GET_PARAM(1);\r
 847     int flag = GET_PARAM(2);\r
 848 \r
 849     cv::Mat src_host(size, CV_32FC2);\r
 850     fill(src_host, 0, 100);\r
 851 \r
 852     cv::gpu::GpuMat src(src_host);\r
 853     cv::gpu::GpuMat dst;\r
 854 \r
 855     cv::gpu::dft(src, dst, size, flag);\r
 856 \r
 857     declare.time(2.0);\r
 858 \r
 859     TEST_CYCLE()\r
 860     {\r
 861         cv::gpu::dft(src, dst, size, flag);\r
 862     }\r
 863 }\r
 864 \r
 865 INSTANTIATE_TEST_CASE_P(ImgProc, Dft, testing::Combine(\r
 866     ALL_DEVICES,\r
 867     GPU_TYPICAL_MAT_SIZES,\r
 868     testing::Values(DftFlags(0), DftFlags(cv::DFT_ROWS), DftFlags(cv::DFT_INVERSE))));\r
 869 \r
 870 //////////////////////////////////////////////////////////////////////\r
 871 // CornerHarris\r
 872 \r
 873 IMPLEMENT_PARAM_CLASS(BlockSize, int)\r
 874 IMPLEMENT_PARAM_CLASS(ApertureSize, int)\r
 875 \r
 876 GPU_PERF_TEST(CornerHarris, cv::gpu::DeviceInfo, MatType, BorderMode, BlockSize, ApertureSize)\r
 877 {\r
 878     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 879     cv::gpu::setDevice(devInfo.deviceID());\r
 880 \r
 881     int type = GET_PARAM(1);\r
 882     int borderType = GET_PARAM(2);\r
 883     int blockSize = GET_PARAM(3);\r
 884     int apertureSize = GET_PARAM(4);\r
 885 \r
 886     cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);\r
 887     ASSERT_FALSE(img.empty());\r
 888 \r
 889     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
 890 \r
 891     cv::gpu::GpuMat src(img);\r
 892     cv::gpu::GpuMat dst;\r
 893     cv::gpu::GpuMat Dx;\r
 894     cv::gpu::GpuMat Dy;\r
 895     cv::gpu::GpuMat buf;\r
 896 \r
 897     double k = 0.5;\r
 898 \r
 899     cv::gpu::cornerHarris(src, dst, Dx, Dy, buf, blockSize, apertureSize, k, borderType);\r
 900 \r
 901     TEST_CYCLE()\r
 902     {\r
 903         cv::gpu::cornerHarris(src, dst, Dx, Dy, buf, blockSize, apertureSize, k, borderType);\r
 904     }\r
 905 }\r
 906 \r
 907 INSTANTIATE_TEST_CASE_P(ImgProc, CornerHarris, testing::Combine(\r
 908     ALL_DEVICES,\r
 909     testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),\r
 910     testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_REFLECT)),\r
 911     testing::Values(BlockSize(3), BlockSize(5), BlockSize(7)),\r
 912     testing::Values(ApertureSize(0), ApertureSize(3), ApertureSize(5), ApertureSize(7))));\r
 913 \r
 914 //////////////////////////////////////////////////////////////////////\r
 915 // CornerMinEigenVal\r
 916 \r
 917 GPU_PERF_TEST(CornerMinEigenVal, cv::gpu::DeviceInfo, MatType, BorderMode, BlockSize, ApertureSize)\r
 918 {\r
 919     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 920     cv::gpu::setDevice(devInfo.deviceID());\r
 921 \r
 922     int type = GET_PARAM(1);\r
 923     int borderType = GET_PARAM(2);\r
 924     int blockSize = GET_PARAM(3);\r
 925     int apertureSize = GET_PARAM(4);\r
 926 \r
 927     cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);\r
 928     ASSERT_FALSE(img.empty());\r
 929 \r
 930     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
 931 \r
 932     cv::gpu::GpuMat src(img);\r
 933     cv::gpu::GpuMat dst;\r
 934     cv::gpu::GpuMat Dx;\r
 935     cv::gpu::GpuMat Dy;\r
 936     cv::gpu::GpuMat buf;\r
 937 \r
 938     cv::gpu::cornerMinEigenVal(src, dst, Dx, Dy, buf, blockSize, apertureSize, borderType);\r
 939 \r
 940     TEST_CYCLE()\r
 941     {\r
 942         cv::gpu::cornerMinEigenVal(src, dst, Dx, Dy, buf, blockSize, apertureSize, borderType);\r
 943     }\r
 944 }\r
 945 \r
 946 INSTANTIATE_TEST_CASE_P(ImgProc, CornerMinEigenVal, testing::Combine(\r
 947     ALL_DEVICES,\r
 948     testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),\r
 949     testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_REFLECT)),\r
 950     testing::Values(BlockSize(3), BlockSize(5), BlockSize(7)),\r
 951     testing::Values(ApertureSize(0), ApertureSize(3), ApertureSize(5), ApertureSize(7))));\r
 952 \r
 953 //////////////////////////////////////////////////////////////////////\r
 954 // BuildWarpPlaneMaps\r
 955 \r
 956 GPU_PERF_TEST(BuildWarpPlaneMaps, cv::gpu::DeviceInfo, cv::Size)\r
 957 {\r
 958     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 959     cv::gpu::setDevice(devInfo.deviceID());\r
 960 \r
 961     cv::Size size = GET_PARAM(1);\r
 962 \r
 963     cv::Mat K = cv::Mat::eye(3, 3, CV_32FC1);\r
 964     cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1);\r
 965     cv::Mat T = cv::Mat::zeros(1, 3, CV_32F);\r
 966     cv::gpu::GpuMat map_x;\r
 967     cv::gpu::GpuMat map_y;\r
 968 \r
 969     cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, map_x, map_y);\r
 970 \r
 971     TEST_CYCLE()\r
 972     {\r
 973         cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, map_x, map_y);\r
 974     }\r
 975 }\r
 976 \r
 977 INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpPlaneMaps, testing::Combine(\r
 978     ALL_DEVICES,\r
 979     GPU_TYPICAL_MAT_SIZES));\r
 980 \r
 981 //////////////////////////////////////////////////////////////////////\r
 982 // BuildWarpCylindricalMaps\r
 983 \r
 984 GPU_PERF_TEST(BuildWarpCylindricalMaps, cv::gpu::DeviceInfo, cv::Size)\r
 985 {\r
 986     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 987     cv::gpu::setDevice(devInfo.deviceID());\r
 988 \r
 989     cv::Size size = GET_PARAM(1);\r
 990 \r
 991     cv::Mat K = cv::Mat::eye(3, 3, CV_32FC1);\r
 992     cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1);\r
 993     cv::gpu::GpuMat map_x;\r
 994     cv::gpu::GpuMat map_y;\r
 995 \r
 996     cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, map_x, map_y);\r
 997 \r
 998     TEST_CYCLE()\r
 999     {\r
1000         cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, map_x, map_y);\r
1001     }\r
1002 }\r
1003 \r
1004 INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpCylindricalMaps, testing::Combine(\r
1005     ALL_DEVICES,\r
1006     GPU_TYPICAL_MAT_SIZES));\r
1007 \r
1008 //////////////////////////////////////////////////////////////////////\r
1009 // BuildWarpSphericalMaps\r
1010 \r
1011 GPU_PERF_TEST(BuildWarpSphericalMaps, cv::gpu::DeviceInfo, cv::Size)\r
1012 {\r
1013     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
1014     cv::gpu::setDevice(devInfo.deviceID());\r
1015 \r
1016     cv::Size size = GET_PARAM(1);\r
1017 \r
1018     cv::Mat K = cv::Mat::eye(3, 3, CV_32FC1);\r
1019     cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1);\r
1020     cv::gpu::GpuMat map_x;\r
1021     cv::gpu::GpuMat map_y;\r
1022 \r
1023     cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, map_x, map_y);\r
1024 \r
1025     TEST_CYCLE()\r
1026     {\r
1027         cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, map_x, map_y);\r
1028     }\r
1029 }\r
1030 \r
1031 INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpSphericalMaps, testing::Combine(\r
1032     ALL_DEVICES,\r
1033     GPU_TYPICAL_MAT_SIZES));\r
1034 \r
1035 //////////////////////////////////////////////////////////////////////\r
1036 // Rotate\r
1037 \r
1038 GPU_PERF_TEST(Rotate, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation)\r
1039 {\r
1040     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
1041     cv::gpu::setDevice(devInfo.deviceID());\r
1042 \r
1043     cv::Size size = GET_PARAM(1);\r
1044     int type = GET_PARAM(2);\r
1045     int interpolation = GET_PARAM(3);\r
1046 \r
1047     cv::Mat src_host(size, type);\r
1048     fill(src_host, 0, 255);\r
1049 \r
1050     cv::gpu::GpuMat src(src_host);\r
1051     cv::gpu::GpuMat dst;\r
1052 \r
1053     cv::gpu::rotate(src, dst, size, 30.0, 0, 0, interpolation);\r
1054 \r
1055     TEST_CYCLE()\r
1056     {\r
1057         cv::gpu::rotate(src, dst, size, 30.0, 0, 0, interpolation);\r
1058     }\r
1059 }\r
1060 \r
1061 INSTANTIATE_TEST_CASE_P(ImgProc, Rotate, testing::Combine(\r
1062     ALL_DEVICES,\r
1063     GPU_TYPICAL_MAT_SIZES,\r
1064     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
1065                     MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
1066                     MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
1067     testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC))));\r
1068 \r
1069 //////////////////////////////////////////////////////////////////////\r
1070 // PyrDown\r
1071 \r
1072 GPU_PERF_TEST(PyrDown, cv::gpu::DeviceInfo, cv::Size, MatType)\r
1073 {\r
1074     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
1075     cv::gpu::setDevice(devInfo.deviceID());\r
1076 \r
1077     cv::Size size = GET_PARAM(1);\r
1078     int type = GET_PARAM(2);\r
1079 \r
1080     cv::Mat src_host(size, type);\r
1081     fill(src_host, 0, 255);\r
1082 \r
1083     cv::gpu::GpuMat src(src_host);\r
1084     cv::gpu::GpuMat dst;\r
1085 \r
1086     cv::gpu::pyrDown(src, dst);\r
1087 \r
1088     TEST_CYCLE()\r
1089     {\r
1090         cv::gpu::pyrDown(src, dst);\r
1091     }\r
1092 }\r
1093 \r
1094 INSTANTIATE_TEST_CASE_P(ImgProc, PyrDown, testing::Combine(\r
1095     ALL_DEVICES,\r
1096     GPU_TYPICAL_MAT_SIZES,\r
1097     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
1098                     MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
1099                     MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4))));\r
1100 \r
1101 //////////////////////////////////////////////////////////////////////\r
1102 // PyrUp\r
1103 \r
1104 GPU_PERF_TEST(PyrUp, cv::gpu::DeviceInfo, cv::Size, MatType)\r
1105 {\r
1106     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
1107     cv::gpu::setDevice(devInfo.deviceID());\r
1108 \r
1109     cv::Size size = GET_PARAM(1);\r
1110     int type = GET_PARAM(2);\r
1111 \r
1112     cv::Mat src_host(size, type);\r
1113     fill(src_host, 0, 255);\r
1114 \r
1115     cv::gpu::GpuMat src(src_host);\r
1116     cv::gpu::GpuMat dst;\r
1117 \r
1118     cv::gpu::pyrUp(src, dst);\r
1119 \r
1120     TEST_CYCLE()\r
1121     {\r
1122         cv::gpu::pyrUp(src, dst);\r
1123     }\r
1124 }\r
1125 \r
1126 INSTANTIATE_TEST_CASE_P(ImgProc, PyrUp, testing::Combine(\r
1127     ALL_DEVICES,\r
1128     GPU_TYPICAL_MAT_SIZES,\r
1129     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
1130                     MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
1131                     MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4))));\r
1132 \r
1133 //////////////////////////////////////////////////////////////////////\r
1134 // CvtColor\r
1135 \r
1136 GPU_PERF_TEST(CvtColor, cv::gpu::DeviceInfo, cv::Size, MatDepth, CvtColorInfo)\r
1137 {\r
1138     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
1139     cv::gpu::setDevice(devInfo.deviceID());\r
1140 \r
1141     cv::Size size = GET_PARAM(1);\r
1142     int depth = GET_PARAM(2);\r
1143     CvtColorInfo info = GET_PARAM(3);\r
1144 \r
1145     cv::Mat src_host(size, CV_MAKETYPE(depth, info.scn));\r
1146     fill(src_host, 0, 255);\r
1147 \r
1148     cv::gpu::GpuMat src(src_host);\r
1149     cv::gpu::GpuMat dst;\r
1150 \r
1151     if (info.code >= cv::COLOR_BayerBG2BGR && info.code <= cv::COLOR_BayerGR2BGR)\r
1152         info.dcn = 4;\r
1153 \r
1154     cv::gpu::cvtColor(src, dst, info.code, info.dcn);\r
1155 \r
1156     TEST_CYCLE()\r
1157     {\r
1158         cv::gpu::cvtColor(src, dst, info.code, info.dcn);\r
1159     }\r
1160 }\r
1161 \r
1162 INSTANTIATE_TEST_CASE_P(ImgProc, CvtColor, testing::Combine(\r
1163     ALL_DEVICES,\r
1164     GPU_TYPICAL_MAT_SIZES,\r
1165     testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F)),\r
1166     testing::Values(CvtColorInfo(4, 4, cv::COLOR_RGBA2BGRA),\r
1167                     CvtColorInfo(4, 1, cv::COLOR_BGRA2GRAY),\r
1168                     CvtColorInfo(1, 4, cv::COLOR_GRAY2BGRA),\r
1169                     CvtColorInfo(3, 3, cv::COLOR_BGR2XYZ),\r
1170                     CvtColorInfo(3, 3, cv::COLOR_XYZ2BGR),\r
1171                     CvtColorInfo(3, 3, cv::COLOR_BGR2YCrCb),\r
1172                     CvtColorInfo(3, 3, cv::COLOR_YCrCb2BGR),\r
1173                     CvtColorInfo(3, 3, cv::COLOR_BGR2YUV),\r
1174                     CvtColorInfo(3, 3, cv::COLOR_YUV2BGR),\r
1175                     CvtColorInfo(3, 3, cv::COLOR_BGR2HSV),\r
1176                     CvtColorInfo(3, 3, cv::COLOR_HSV2BGR),\r
1177                     CvtColorInfo(3, 3, cv::COLOR_BGR2HLS),\r
1178                     CvtColorInfo(3, 3, cv::COLOR_HLS2BGR),\r
1179                     CvtColorInfo(3, 3, cv::COLOR_BGR2Lab),\r
1180                     CvtColorInfo(3, 3, cv::COLOR_RGB2Lab),\r
1181                     CvtColorInfo(3, 3, cv::COLOR_BGR2Luv),\r
1182                     CvtColorInfo(3, 3, cv::COLOR_RGB2Luv),\r
1183                     CvtColorInfo(3, 3, cv::COLOR_Lab2BGR),\r
1184                     CvtColorInfo(3, 3, cv::COLOR_Lab2RGB),\r
1185                     CvtColorInfo(3, 3, cv::COLOR_Luv2BGR),\r
1186                     CvtColorInfo(3, 3, cv::COLOR_Luv2RGB),\r
1187                     CvtColorInfo(1, 3, cv::COLOR_BayerBG2BGR),\r
1188                     CvtColorInfo(1, 3, cv::COLOR_BayerGB2BGR),\r
1189                     CvtColorInfo(1, 3, cv::COLOR_BayerRG2BGR),\r
1190                     CvtColorInfo(1, 3, cv::COLOR_BayerGR2BGR),\r
1191                     CvtColorInfo(4, 4, cv::COLOR_RGBA2mRGBA))));\r
1192 \r
1193 //////////////////////////////////////////////////////////////////////\r
1194 // SwapChannels\r
1195 \r
1196 GPU_PERF_TEST(SwapChannels, cv::gpu::DeviceInfo, cv::Size)\r
1197 {\r
1198     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
1199     cv::gpu::setDevice(devInfo.deviceID());\r
1200 \r
1201     cv::Size size = GET_PARAM(1);\r
1202 \r
1203     cv::Mat src_host(size, CV_8UC4);\r
1204     fill(src_host, 0, 255);\r
1205 \r
1206     cv::gpu::GpuMat src(src_host);\r
1207 \r
1208     const int dstOrder[] = {2, 1, 0, 3};\r
1209 \r
1210     cv::gpu::swapChannels(src, dstOrder);\r
1211 \r
1212     TEST_CYCLE()\r
1213     {\r
1214         cv::gpu::swapChannels(src, dstOrder);\r
1215     }\r
1216 }\r
1217 \r
1218 INSTANTIATE_TEST_CASE_P(ImgProc, SwapChannels, testing::Combine(ALL_DEVICES, GPU_TYPICAL_MAT_SIZES));\r
1219 \r
1220 //////////////////////////////////////////////////////////////////////\r
1221 // AlphaComp\r
1222 \r
1223 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
1224 \r
1225 GPU_PERF_TEST(AlphaComp, cv::gpu::DeviceInfo, cv::Size, MatType, AlphaOp)\r
1226 {\r
1227     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
1228     cv::gpu::setDevice(devInfo.deviceID());\r
1229 \r
1230     cv::Size size = GET_PARAM(1);\r
1231     int type = GET_PARAM(2);\r
1232     int alpha_op = GET_PARAM(3);\r
1233 \r
1234     cv::Mat img1_host(size, type);\r
1235     fill(img1_host, 0, 255);\r
1236 \r
1237     cv::Mat img2_host(size, type);\r
1238     fill(img2_host, 0, 255);\r
1239 \r
1240     cv::gpu::GpuMat img1(img1_host);\r
1241     cv::gpu::GpuMat img2(img2_host);\r
1242     cv::gpu::GpuMat dst;\r
1243 \r
1244     cv::gpu::alphaComp(img1, img2, dst, alpha_op);\r
1245 \r
1246     TEST_CYCLE()\r
1247     {\r
1248         cv::gpu::alphaComp(img1, img2, dst, alpha_op);\r
1249     }\r
1250 }\r
1251 \r
1252 INSTANTIATE_TEST_CASE_P(ImgProc, AlphaComp, testing::Combine(\r
1253     ALL_DEVICES,\r
1254     GPU_TYPICAL_MAT_SIZES,\r
1255     testing::Values(MatType(CV_8UC4), MatType(CV_16UC4), MatType(CV_32SC4), MatType(CV_32FC4)),\r
1256     testing::Values(AlphaOp(cv::gpu::ALPHA_OVER),\r
1257                     AlphaOp(cv::gpu::ALPHA_IN),\r
1258                     AlphaOp(cv::gpu::ALPHA_OUT),\r
1259                     AlphaOp(cv::gpu::ALPHA_ATOP),\r
1260                     AlphaOp(cv::gpu::ALPHA_XOR),\r
1261                     AlphaOp(cv::gpu::ALPHA_PLUS),\r
1262                     AlphaOp(cv::gpu::ALPHA_OVER_PREMUL),\r
1263                     AlphaOp(cv::gpu::ALPHA_IN_PREMUL),\r
1264                     AlphaOp(cv::gpu::ALPHA_OUT_PREMUL),\r
1265                     AlphaOp(cv::gpu::ALPHA_ATOP_PREMUL),\r
1266                     AlphaOp(cv::gpu::ALPHA_XOR_PREMUL),\r
1267                     AlphaOp(cv::gpu::ALPHA_PLUS_PREMUL),\r
1268                     AlphaOp(cv::gpu::ALPHA_PREMUL))));\r
1269 \r
1270 //////////////////////////////////////////////////////////////////////\r
1271 // ImagePyramid\r
1272 \r
1273 GPU_PERF_TEST(ImagePyramid_build, cv::gpu::DeviceInfo, cv::Size, MatType)\r
1274 {\r
1275     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
1276     cv::gpu::setDevice(devInfo.deviceID());\r
1277 \r
1278     cv::Size size = GET_PARAM(1);\r
1279     int type = GET_PARAM(2);\r
1280 \r
1281     cv::Mat src_host(size, type);\r
1282     fill(src_host, 0, 255);\r
1283 \r
1284     cv::gpu::GpuMat src(src_host);\r
1285 \r
1286     cv::gpu::ImagePyramid pyr;\r
1287 \r
1288     pyr.build(src, 5);\r
1289 \r
1290     TEST_CYCLE()\r
1291     {\r
1292         pyr.build(src, 5);\r
1293     }\r
1294 }\r
1295 \r
1296 INSTANTIATE_TEST_CASE_P(ImgProc, ImagePyramid_build, testing::Combine(\r
1297     ALL_DEVICES,\r
1298     GPU_TYPICAL_MAT_SIZES,\r
1299     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
1300                     MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
1301                     MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4))));\r
1302 \r
1303 GPU_PERF_TEST(ImagePyramid_getLayer, cv::gpu::DeviceInfo, cv::Size, MatType)\r
1304 {\r
1305     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
1306     cv::gpu::setDevice(devInfo.deviceID());\r
1307 \r
1308     cv::Size size = GET_PARAM(1);\r
1309     int type = GET_PARAM(2);\r
1310 \r
1311     cv::Mat src_host(size, type);\r
1312     fill(src_host, 0, 255);\r
1313 \r
1314     cv::gpu::GpuMat src(src_host);\r
1315     cv::gpu::GpuMat dst;\r
1316 \r
1317     cv::gpu::ImagePyramid pyr(src, 3);\r
1318 \r
1319     pyr.getLayer(dst, cv::Size(size.width / 2 + 10, size.height / 2 + 10));\r
1320 \r
1321     TEST_CYCLE()\r
1322     {\r
1323         pyr.getLayer(dst, cv::Size(size.width / 2 + 10, size.height / 2 + 10));\r
1324     }\r
1325 }\r
1326 \r
1327 INSTANTIATE_TEST_CASE_P(ImgProc, ImagePyramid_getLayer, testing::Combine(\r
1328     ALL_DEVICES,\r
1329     GPU_TYPICAL_MAT_SIZES,\r
1330     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
1331                     MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
1332                     MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4))));\r
1333 \r
1334 //////////////////////////////////////////////////////////////////////\r
1335 // HoughLines\r
1336 \r
1337 IMPLEMENT_PARAM_CLASS(DoSort, bool)\r
1338 \r
1339 GPU_PERF_TEST(HoughLines, cv::gpu::DeviceInfo, cv::Size, DoSort)\r
1340 {\r
1341     declare.time(30.0);\r
1342 \r
1343     const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
1344     cv::gpu::setDevice(devInfo.deviceID());\r
1345     const cv::Size size = GET_PARAM(1);\r
1346     const bool doSort = GET_PARAM(2);\r
1347 \r
1348     const float rho = 1.0f;\r
1349     const float theta = CV_PI / 180.0f;\r
1350     const int threshold = 300;\r
1351 \r
1352     cv::RNG rng(123456789);\r
1353 \r
1354     cv::Mat src(size, CV_8UC1, cv::Scalar::all(0));\r
1355 \r
1356     const int numLines = rng.uniform(500, 2000);\r
1357     for (int i = 0; i < numLines; ++i)\r
1358     {\r
1359         cv::Point p1(rng.uniform(0, src.cols), rng.uniform(0, src.rows));\r
1360         cv::Point p2(rng.uniform(0, src.cols), rng.uniform(0, src.rows));\r
1361         cv::line(src, p1, p2, cv::Scalar::all(255), 2);\r
1362     }\r
1363 \r
1364     cv::gpu::GpuMat d_src(src);\r
1365     cv::gpu::GpuMat d_lines;\r
1366     cv::gpu::GpuMat d_accum;\r
1367     cv::gpu::GpuMat d_buf;\r
1368     cv::gpu::HoughLines(d_src, d_lines, d_accum, d_buf, rho, theta, threshold, doSort);\r
1369 \r
1370     TEST_CYCLE()\r
1371     {\r
1372         cv::gpu::HoughLines(d_src, d_lines, d_accum, d_buf, rho, theta, threshold, doSort);\r
1373     }\r
1374 }\r
1375 \r
1376 INSTANTIATE_TEST_CASE_P(ImgProc, HoughLines, testing::Combine(\r
1377     ALL_DEVICES,\r
1378     GPU_TYPICAL_MAT_SIZES,\r
1379     testing::Values(DoSort(false), DoSort(true))));\r
1380 \r
1381 #endif\r