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, perf::MatType, Interpolation, BorderMode)\r
   9 {\r
  10     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
  11     cv::Size size = GET_PARAM(1);\r
  12     int type = GET_PARAM(2);\r
  13     int interpolation = GET_PARAM(3);\r
  14     int borderMode = GET_PARAM(4);\r
  15 \r
  16     cv::gpu::setDevice(devInfo.deviceID());\r
  17 \r
  18     cv::Mat src_host(size, type);\r
  19     cv::Mat xmap_host(size, CV_32FC1);\r
  20     cv::Mat ymap_host(size, CV_32FC1);\r
  21 \r
  22     declare.in(src_host, xmap_host, ymap_host, WARMUP_RNG);\r
  23 \r
  24     cv::gpu::GpuMat src(src_host);\r
  25     cv::gpu::GpuMat xmap(xmap_host);\r
  26     cv::gpu::GpuMat ymap(ymap_host);\r
  27     cv::gpu::GpuMat dst;\r
  28 \r
  29     declare.time(3.0);\r
  30 \r
  31     TEST_CYCLE()\r
  32     {\r
  33         cv::gpu::remap(src, dst, xmap, ymap, interpolation, borderMode);\r
  34     }\r
  35 }\r
  36 \r
  37 INSTANTIATE_TEST_CASE_P(ImgProc, Remap, testing::Combine(\r
  38                         ALL_DEVICES, \r
  39                         GPU_TYPICAL_MAT_SIZES, \r
  40                         testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_32FC1), \r
  41                         testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC),\r
  42                         testing::Values((int) cv::BORDER_REFLECT101, (int) cv::BORDER_REPLICATE, (int) cv::BORDER_CONSTANT)));\r
  43 \r
  44 //////////////////////////////////////////////////////////////////////\r
  45 // MeanShiftFiltering\r
  46 \r
  47 GPU_PERF_TEST_1(MeanShiftFiltering, cv::gpu::DeviceInfo)\r
  48 {\r
  49     cv::gpu::DeviceInfo devInfo = GetParam();\r
  50 \r
  51     cv::gpu::setDevice(devInfo.deviceID());\r
  52 \r
  53     cv::Mat img = readImage("gpu/meanshift/cones.png");\r
  54     ASSERT_FALSE(img.empty());\r
  55     \r
  56     cv::Mat rgba;\r
  57     cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);\r
  58 \r
  59     cv::gpu::GpuMat src(rgba);\r
  60     cv::gpu::GpuMat dst;\r
  61 \r
  62     declare.time(5.0);\r
  63 \r
  64     TEST_CYCLE()\r
  65     {\r
  66         cv::gpu::meanShiftFiltering(src, dst, 50, 50);\r
  67     }\r
  68 }\r
  69 \r
  70 INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftFiltering, ALL_DEVICES);\r
  71 \r
  72 //////////////////////////////////////////////////////////////////////\r
  73 // MeanShiftProc\r
  74 \r
  75 GPU_PERF_TEST_1(MeanShiftProc, cv::gpu::DeviceInfo)\r
  76 {\r
  77     cv::gpu::DeviceInfo devInfo = GetParam();\r
  78 \r
  79     cv::gpu::setDevice(devInfo.deviceID());\r
  80 \r
  81     cv::Mat img = readImage("gpu/meanshift/cones.png");\r
  82     ASSERT_FALSE(img.empty());\r
  83     \r
  84     cv::Mat rgba;\r
  85     cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);\r
  86 \r
  87     cv::gpu::GpuMat src(rgba);\r
  88     cv::gpu::GpuMat dstr;\r
  89     cv::gpu::GpuMat dstsp;\r
  90 \r
  91     declare.time(5.0);\r
  92 \r
  93     TEST_CYCLE()\r
  94     {\r
  95         cv::gpu::meanShiftProc(src, dstr, dstsp, 50, 50);\r
  96     }\r
  97 }\r
  98 \r
  99 INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftProc, ALL_DEVICES);\r
 100 \r
 101 //////////////////////////////////////////////////////////////////////\r
 102 // MeanShiftSegmentation\r
 103 \r
 104 GPU_PERF_TEST_1(MeanShiftSegmentation, cv::gpu::DeviceInfo)\r
 105 {\r
 106     cv::gpu::DeviceInfo devInfo = GetParam();\r
 107 \r
 108     cv::gpu::setDevice(devInfo.deviceID());\r
 109 \r
 110     cv::Mat img = readImage("gpu/meanshift/cones.png");\r
 111     ASSERT_FALSE(img.empty());\r
 112     \r
 113     cv::Mat rgba;\r
 114     cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);\r
 115 \r
 116     cv::gpu::GpuMat src(rgba);\r
 117     cv::Mat dst;\r
 118 \r
 119     declare.time(5.0);\r
 120 \r
 121     TEST_CYCLE()\r
 122     {\r
 123         meanShiftSegmentation(src, dst, 10, 10, 20);\r
 124     }\r
 125 }\r
 126 \r
 127 INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftSegmentation, ALL_DEVICES);\r
 128 \r
 129 //////////////////////////////////////////////////////////////////////\r
 130 // DrawColorDisp\r
 131 \r
 132 GPU_PERF_TEST(DrawColorDisp, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
 133 {\r
 134     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 135     cv::Size size = GET_PARAM(1);\r
 136     int type = GET_PARAM(2);\r
 137 \r
 138     cv::gpu::setDevice(devInfo.deviceID());\r
 139 \r
 140     cv::Mat src_host(size, type);\r
 141 \r
 142     fill(src_host, 0, 255);\r
 143 \r
 144     cv::gpu::GpuMat src(src_host);\r
 145     cv::gpu::GpuMat dst;\r
 146 \r
 147     TEST_CYCLE()\r
 148     {\r
 149         cv::gpu::drawColorDisp(src, dst, 255);\r
 150     }\r
 151 }\r
 152 \r
 153 INSTANTIATE_TEST_CASE_P(ImgProc, DrawColorDisp, testing::Combine(\r
 154                         ALL_DEVICES, \r
 155                         GPU_TYPICAL_MAT_SIZES, \r
 156                         testing::Values(CV_8UC1, CV_16SC1)));\r
 157 \r
 158 //////////////////////////////////////////////////////////////////////\r
 159 // ReprojectImageTo3D\r
 160 \r
 161 GPU_PERF_TEST(ReprojectImageTo3D, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
 162 {\r
 163     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 164     cv::Size size = GET_PARAM(1);\r
 165     int type = GET_PARAM(2);\r
 166 \r
 167     cv::gpu::setDevice(devInfo.deviceID());\r
 168 \r
 169     cv::Mat src_host(size, type);\r
 170 \r
 171     declare.in(src_host, WARMUP_RNG);\r
 172 \r
 173     cv::gpu::GpuMat src(src_host);\r
 174     cv::gpu::GpuMat dst;\r
 175 \r
 176     TEST_CYCLE()\r
 177     {\r
 178         cv::gpu::reprojectImageTo3D(src, dst, cv::Mat::ones(4, 4, CV_32FC1));\r
 179     }\r
 180 }\r
 181 \r
 182 INSTANTIATE_TEST_CASE_P(ImgProc, ReprojectImageTo3D, testing::Combine(\r
 183                         ALL_DEVICES, \r
 184                         GPU_TYPICAL_MAT_SIZES, \r
 185                         testing::Values(CV_8UC1, CV_16SC1)));\r
 186 \r
 187 //////////////////////////////////////////////////////////////////////\r
 188 // CvtColor\r
 189 \r
 190 GPU_PERF_TEST(CvtColor, cv::gpu::DeviceInfo, cv::Size, perf::MatType, CvtColorInfo)\r
 191 {\r
 192     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 193     cv::Size size = GET_PARAM(1);\r
 194     int type = GET_PARAM(2);\r
 195     CvtColorInfo info = GET_PARAM(3);\r
 196 \r
 197     cv::gpu::setDevice(devInfo.deviceID());\r
 198 \r
 199     cv::Mat src_host(size, CV_MAKETYPE(type, info.scn));\r
 200 \r
 201     declare.in(src_host, WARMUP_RNG);\r
 202 \r
 203     cv::gpu::GpuMat src(src_host);\r
 204     cv::gpu::GpuMat dst(size, CV_MAKETYPE(type, info.dcn));\r
 205 \r
 206     TEST_CYCLE()\r
 207     {\r
 208         cv::gpu::cvtColor(src, dst, info.code, info.dcn);\r
 209     }\r
 210 }\r
 211 \r
 212 INSTANTIATE_TEST_CASE_P(ImgProc, CvtColor, testing::Combine(\r
 213                         ALL_DEVICES, \r
 214                         GPU_TYPICAL_MAT_SIZES, \r
 215                         testing::Values(CV_8UC1, CV_16UC1, CV_32FC1),\r
 216                         testing::Values(\r
 217                             CvtColorInfo(4, 4, cv::COLOR_RGBA2BGRA), CvtColorInfo(4, 1, cv::COLOR_BGRA2GRAY), CvtColorInfo(1, 4, cv::COLOR_GRAY2BGRA), \r
 218                             CvtColorInfo(4, 4, cv::COLOR_BGR2XYZ), CvtColorInfo(4, 4, cv::COLOR_BGR2YCrCb), CvtColorInfo(4, 4, cv::COLOR_YCrCb2BGR), \r
 219                             CvtColorInfo(4, 4, cv::COLOR_BGR2HSV), CvtColorInfo(4, 4, cv::COLOR_HSV2BGR))));\r
 220 \r
 221 //////////////////////////////////////////////////////////////////////\r
 222 // Threshold\r
 223 \r
 224 GPU_PERF_TEST(Threshold, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
 225 {\r
 226     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 227     cv::Size size = GET_PARAM(1);\r
 228     int type = GET_PARAM(2);\r
 229 \r
 230     cv::gpu::setDevice(devInfo.deviceID());\r
 231 \r
 232     cv::Mat src_host(size, type);\r
 233 \r
 234     declare.in(src_host, WARMUP_RNG);\r
 235 \r
 236     cv::gpu::GpuMat src(src_host);\r
 237     cv::gpu::GpuMat dst(size, type);\r
 238 \r
 239     TEST_CYCLE()\r
 240     {\r
 241         cv::gpu::threshold(src, dst, 100.0, 255.0, cv::THRESH_BINARY);\r
 242     }\r
 243 }\r
 244 \r
 245 INSTANTIATE_TEST_CASE_P(ImgProc, Threshold, testing::Combine(\r
 246                         ALL_DEVICES, \r
 247                         GPU_TYPICAL_MAT_SIZES, \r
 248                         testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
 249 \r
 250 //////////////////////////////////////////////////////////////////////\r
 251 // Resize\r
 252 \r
 253 GPU_PERF_TEST(Resize, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation, double)\r
 254 {\r
 255     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 256     cv::Size size = GET_PARAM(1);\r
 257     int type = GET_PARAM(2);\r
 258     int interpolation = GET_PARAM(3);\r
 259     double f = GET_PARAM(4);\r
 260 \r
 261     cv::gpu::setDevice(devInfo.deviceID());\r
 262 \r
 263     cv::Mat src_host(size, type);\r
 264 \r
 265     declare.in(src_host, WARMUP_RNG);\r
 266 \r
 267     cv::gpu::GpuMat src(src_host);\r
 268     cv::gpu::GpuMat dst;\r
 269 \r
 270     declare.time(1.0);\r
 271 \r
 272     TEST_CYCLE()\r
 273     {\r
 274         cv::gpu::resize(src, dst, cv::Size(), f, f, interpolation);\r
 275     }\r
 276 }\r
 277 \r
 278 INSTANTIATE_TEST_CASE_P(ImgProc, Resize, testing::Combine(\r
 279                         ALL_DEVICES, \r
 280                         testing::Values(perf::szSXGA, perf::sz1080p), \r
 281                         testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_32FC1),\r
 282                         testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC),\r
 283                         testing::Values(0.5, 2.0)));\r
 284 \r
 285 //////////////////////////////////////////////////////////////////////\r
 286 // WarpAffine\r
 287 \r
 288 GPU_PERF_TEST(WarpAffine, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation)\r
 289 {\r
 290     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 291     cv::Size size = GET_PARAM(1);\r
 292     int type = GET_PARAM(2);\r
 293     int interpolation = GET_PARAM(3);\r
 294 \r
 295     cv::gpu::setDevice(devInfo.deviceID());\r
 296 \r
 297     cv::Mat src_host(size, type);\r
 298 \r
 299     declare.in(src_host, WARMUP_RNG);\r
 300 \r
 301     cv::gpu::GpuMat src(src_host);\r
 302     cv::gpu::GpuMat dst;\r
 303 \r
 304     double reflect[2][3] = { {-1,  0, 0},\r
 305                              { 0, -1, 0}};\r
 306     reflect[0][2] = size.width;\r
 307     reflect[1][2] = size.height;\r
 308     cv::Mat M(2, 3, CV_64F, (void*) reflect); \r
 309 \r
 310     TEST_CYCLE()\r
 311     {\r
 312         cv::gpu::warpAffine(src, dst, M, size, interpolation);\r
 313     }\r
 314 }\r
 315 \r
 316 INSTANTIATE_TEST_CASE_P(ImgProc, WarpAffine, testing::Combine(\r
 317                         ALL_DEVICES, \r
 318                         GPU_TYPICAL_MAT_SIZES, \r
 319                         testing::Values(CV_8UC1, CV_8UC4, CV_32FC1),\r
 320                         testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC)));\r
 321 \r
 322 //////////////////////////////////////////////////////////////////////\r
 323 // WarpPerspective\r
 324 \r
 325 GPU_PERF_TEST(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation)\r
 326 {\r
 327     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 328     cv::Size size = GET_PARAM(1);\r
 329     int type = GET_PARAM(2);\r
 330     int interpolation = GET_PARAM(3);\r
 331 \r
 332     cv::gpu::setDevice(devInfo.deviceID());\r
 333 \r
 334     cv::Mat src_host(size, type);\r
 335 \r
 336     declare.in(src_host, WARMUP_RNG);\r
 337 \r
 338     cv::gpu::GpuMat src(src_host);\r
 339     cv::gpu::GpuMat dst;\r
 340 \r
 341     double reflect[3][3] = { {-1,  0, 0},\r
 342                              { 0, -1, 0},\r
 343                              { 0, 0, 1}};\r
 344     reflect[0][2] = size.width;\r
 345     reflect[1][2] = size.height;\r
 346     cv::Mat M(3, 3, CV_64F, (void*)reflect); \r
 347 \r
 348     TEST_CYCLE()\r
 349     {\r
 350         cv::gpu::warpPerspective(src, dst, M, size, interpolation);\r
 351     }\r
 352 }\r
 353 \r
 354 INSTANTIATE_TEST_CASE_P(ImgProc, WarpPerspective, testing::Combine(\r
 355                         ALL_DEVICES, \r
 356                         GPU_TYPICAL_MAT_SIZES, \r
 357                         testing::Values(CV_8UC1, CV_8UC4, CV_32FC1),\r
 358                         testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC)));\r
 359 \r
 360 //////////////////////////////////////////////////////////////////////\r
 361 // BuildWarpPlaneMaps\r
 362 \r
 363 GPU_PERF_TEST(BuildWarpPlaneMaps, cv::gpu::DeviceInfo, cv::Size)\r
 364 {\r
 365     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 366     cv::Size size = GET_PARAM(1);\r
 367 \r
 368     cv::gpu::setDevice(devInfo.deviceID());\r
 369 \r
 370     cv::gpu::GpuMat map_x;\r
 371     cv::gpu::GpuMat map_y;\r
 372 \r
 373     TEST_CYCLE()\r
 374     {\r
 375         cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), cv::Mat::eye(3, 3, CV_32FC1), \r
 376                                     cv::Mat::ones(3, 3, CV_32FC1), cv::Mat::zeros(1, 3, CV_32F), 1.0, map_x, map_y);\r
 377     }\r
 378 }\r
 379 \r
 380 INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpPlaneMaps, testing::Combine(\r
 381                         ALL_DEVICES, \r
 382                         GPU_TYPICAL_MAT_SIZES));\r
 383 \r
 384 //////////////////////////////////////////////////////////////////////\r
 385 // BuildWarpCylindricalMaps\r
 386 \r
 387 GPU_PERF_TEST(BuildWarpCylindricalMaps, cv::gpu::DeviceInfo, cv::Size)\r
 388 {\r
 389     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 390     cv::Size size = GET_PARAM(1);\r
 391 \r
 392     cv::gpu::setDevice(devInfo.deviceID());\r
 393 \r
 394     cv::gpu::GpuMat map_x;\r
 395     cv::gpu::GpuMat map_y;\r
 396 \r
 397     TEST_CYCLE()\r
 398     {\r
 399         cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), cv::Mat::eye(3, 3, CV_32FC1),\r
 400                                           cv::Mat::ones(3, 3, CV_32FC1), 1.0, map_x, map_y);\r
 401     }\r
 402 }\r
 403 \r
 404 INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpCylindricalMaps, testing::Combine(\r
 405                         ALL_DEVICES, \r
 406                         GPU_TYPICAL_MAT_SIZES));\r
 407 \r
 408 //////////////////////////////////////////////////////////////////////\r
 409 // BuildWarpSphericalMaps\r
 410 \r
 411 GPU_PERF_TEST(BuildWarpSphericalMaps, cv::gpu::DeviceInfo, cv::Size)\r
 412 {\r
 413     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 414     cv::Size size = GET_PARAM(1);\r
 415 \r
 416     cv::gpu::setDevice(devInfo.deviceID());\r
 417 \r
 418     cv::gpu::GpuMat map_x;\r
 419     cv::gpu::GpuMat map_y;\r
 420 \r
 421     TEST_CYCLE()\r
 422     {\r
 423         cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), cv::Mat::eye(3, 3, CV_32FC1),\r
 424                                         cv::Mat::ones(3, 3, CV_32FC1), 1.0, map_x, map_y);\r
 425     }\r
 426 }\r
 427 \r
 428 INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpSphericalMaps, testing::Combine(\r
 429                         ALL_DEVICES, \r
 430                         GPU_TYPICAL_MAT_SIZES));\r
 431 \r
 432 //////////////////////////////////////////////////////////////////////\r
 433 // Rotate\r
 434 \r
 435 GPU_PERF_TEST(Rotate, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation)\r
 436 {\r
 437     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 438     cv::Size size = GET_PARAM(1);\r
 439     int type = GET_PARAM(2);\r
 440     int interpolation = GET_PARAM(3);\r
 441 \r
 442     cv::gpu::setDevice(devInfo.deviceID());\r
 443 \r
 444     cv::Mat src_host(size, type);\r
 445 \r
 446     declare.in(src_host, WARMUP_RNG);\r
 447 \r
 448     cv::gpu::GpuMat src(src_host);\r
 449     cv::gpu::GpuMat dst;\r
 450 \r
 451     TEST_CYCLE()\r
 452     {\r
 453         cv::gpu::rotate(src, dst, size, 30.0, 0, 0, interpolation);\r
 454     }\r
 455 }\r
 456 \r
 457 INSTANTIATE_TEST_CASE_P(ImgProc, Rotate, testing::Combine(\r
 458                         ALL_DEVICES, \r
 459                         GPU_TYPICAL_MAT_SIZES, \r
 460                         testing::Values(CV_8UC1, CV_8UC4),\r
 461                         testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC)));\r
 462 \r
 463 //////////////////////////////////////////////////////////////////////\r
 464 // CopyMakeBorder\r
 465 \r
 466 GPU_PERF_TEST(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, perf::MatType, BorderMode)\r
 467 {\r
 468     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 469     cv::Size size = GET_PARAM(1);\r
 470     int type = GET_PARAM(2);\r
 471     int borderType = GET_PARAM(3);\r
 472 \r
 473     cv::gpu::setDevice(devInfo.deviceID());\r
 474 \r
 475     cv::Mat src_host(size, type);\r
 476 \r
 477     declare.in(src_host, WARMUP_RNG);\r
 478 \r
 479     cv::gpu::GpuMat src(src_host);\r
 480     cv::gpu::GpuMat dst;\r
 481 \r
 482     TEST_CYCLE()\r
 483     {\r
 484         cv::gpu::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType);\r
 485     }\r
 486 }\r
 487 \r
 488 INSTANTIATE_TEST_CASE_P(ImgProc, CopyMakeBorder, testing::Combine(\r
 489                         ALL_DEVICES, \r
 490                         GPU_TYPICAL_MAT_SIZES, \r
 491                         testing::Values(CV_8UC1, CV_8UC4, CV_32FC1),\r
 492                         testing::Values((int) cv::BORDER_REPLICATE, (int) cv::BORDER_REFLECT, (int) cv::BORDER_WRAP, (int) cv::BORDER_CONSTANT)));\r
 493 \r
 494 //////////////////////////////////////////////////////////////////////\r
 495 // Integral\r
 496 \r
 497 GPU_PERF_TEST(Integral, cv::gpu::DeviceInfo, cv::Size)\r
 498 {\r
 499     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 500     cv::Size size = GET_PARAM(1);\r
 501 \r
 502     cv::gpu::setDevice(devInfo.deviceID());\r
 503 \r
 504     cv::Mat src_host(size, CV_8UC1);\r
 505 \r
 506     declare.in(src_host, WARMUP_RNG);\r
 507 \r
 508     cv::gpu::GpuMat src(src_host);\r
 509     cv::gpu::GpuMat dst;\r
 510     cv::gpu::GpuMat buf;\r
 511 \r
 512     TEST_CYCLE()\r
 513     {\r
 514         cv::gpu::integralBuffered(src, dst, buf);\r
 515     }\r
 516 }\r
 517 \r
 518 INSTANTIATE_TEST_CASE_P(ImgProc, Integral, testing::Combine(\r
 519                         ALL_DEVICES, \r
 520                         GPU_TYPICAL_MAT_SIZES));\r
 521 \r
 522 //////////////////////////////////////////////////////////////////////\r
 523 // IntegralBoth\r
 524 \r
 525 GPU_PERF_TEST(IntegralBoth, cv::gpu::DeviceInfo, cv::Size)\r
 526 {\r
 527     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 528     cv::Size size = GET_PARAM(1);\r
 529 \r
 530     cv::gpu::setDevice(devInfo.deviceID());\r
 531 \r
 532     cv::Mat src_host(size, CV_8UC1);\r
 533 \r
 534     declare.in(src_host, WARMUP_RNG);\r
 535 \r
 536     cv::gpu::GpuMat src(src_host);\r
 537     cv::gpu::GpuMat sum, sqsum;\r
 538 \r
 539     TEST_CYCLE()\r
 540     {\r
 541         cv::gpu::integral(src, sum, sqsum);\r
 542     }\r
 543 }\r
 544 \r
 545 INSTANTIATE_TEST_CASE_P(ImgProc, IntegralBoth, testing::Combine(\r
 546                         ALL_DEVICES, \r
 547                         GPU_TYPICAL_MAT_SIZES));\r
 548 \r
 549 //////////////////////////////////////////////////////////////////////\r
 550 // IntegralSqr\r
 551 \r
 552 GPU_PERF_TEST(IntegralSqr, cv::gpu::DeviceInfo, cv::Size)\r
 553 {\r
 554     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 555     cv::Size size = GET_PARAM(1);\r
 556 \r
 557     cv::gpu::setDevice(devInfo.deviceID());\r
 558 \r
 559     cv::Mat src_host(size, CV_8UC1);\r
 560 \r
 561     declare.in(src_host, WARMUP_RNG);\r
 562 \r
 563     cv::gpu::GpuMat src(src_host);\r
 564     cv::gpu::GpuMat dst;\r
 565 \r
 566     TEST_CYCLE()\r
 567     {\r
 568         cv::gpu::sqrIntegral(src, dst);\r
 569     }\r
 570 }\r
 571 \r
 572 INSTANTIATE_TEST_CASE_P(ImgProc, IntegralSqr, testing::Combine(\r
 573                         ALL_DEVICES, \r
 574                         GPU_TYPICAL_MAT_SIZES));\r
 575 \r
 576 //////////////////////////////////////////////////////////////////////\r
 577 // ColumnSum\r
 578 \r
 579 GPU_PERF_TEST(ColumnSum, cv::gpu::DeviceInfo, cv::Size)\r
 580 {\r
 581     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 582     cv::Size size = GET_PARAM(1);\r
 583 \r
 584     cv::gpu::setDevice(devInfo.deviceID());\r
 585 \r
 586     cv::Mat src_host(size, CV_32FC1);\r
 587 \r
 588     declare.in(src_host, WARMUP_RNG);\r
 589 \r
 590     cv::gpu::GpuMat src(src_host);\r
 591     cv::gpu::GpuMat dst;\r
 592 \r
 593     TEST_CYCLE()\r
 594     {\r
 595         cv::gpu::columnSum(src, dst);\r
 596     }\r
 597 }\r
 598 \r
 599 INSTANTIATE_TEST_CASE_P(ImgProc, ColumnSum, testing::Combine(\r
 600                         ALL_DEVICES, \r
 601                         GPU_TYPICAL_MAT_SIZES));\r
 602 \r
 603 //////////////////////////////////////////////////////////////////////\r
 604 // CornerHarris\r
 605 \r
 606 GPU_PERF_TEST(CornerHarris, cv::gpu::DeviceInfo, perf::MatType)\r
 607 {\r
 608     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 609     int type = GET_PARAM(1);\r
 610 \r
 611     cv::gpu::setDevice(devInfo.deviceID());\r
 612     \r
 613     cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);\r
 614     ASSERT_FALSE(img.empty());\r
 615 \r
 616     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
 617 \r
 618     cv::gpu::GpuMat src(img);\r
 619     cv::gpu::GpuMat dst;\r
 620     cv::gpu::GpuMat Dx;\r
 621     cv::gpu::GpuMat Dy;\r
 622 \r
 623     int blockSize = 3;\r
 624     int ksize = 7;        \r
 625     double k = 0.5;\r
 626 \r
 627     TEST_CYCLE()\r
 628     {\r
 629         cv::gpu::cornerHarris(src, dst, Dx, Dy, blockSize, ksize, k);\r
 630     }\r
 631 }\r
 632 \r
 633 INSTANTIATE_TEST_CASE_P(ImgProc, CornerHarris, testing::Combine(\r
 634                         ALL_DEVICES, \r
 635                         testing::Values(CV_8UC1, CV_32FC1)));\r
 636 \r
 637 //////////////////////////////////////////////////////////////////////\r
 638 // CornerMinEigenVal\r
 639 \r
 640 GPU_PERF_TEST(CornerMinEigenVal, cv::gpu::DeviceInfo, perf::MatType)\r
 641 {\r
 642     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 643     int type = GET_PARAM(1);\r
 644 \r
 645     cv::gpu::setDevice(devInfo.deviceID());\r
 646     \r
 647     cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);\r
 648     ASSERT_FALSE(img.empty());\r
 649 \r
 650     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
 651 \r
 652     cv::gpu::GpuMat src(img);\r
 653     cv::gpu::GpuMat dst;\r
 654     cv::gpu::GpuMat Dx;\r
 655     cv::gpu::GpuMat Dy;\r
 656 \r
 657     int blockSize = 3;\r
 658     int ksize = 7; \r
 659 \r
 660     TEST_CYCLE()\r
 661     {\r
 662         cv::gpu::cornerMinEigenVal(src, dst, Dx, Dy, blockSize, ksize);\r
 663     }\r
 664 }\r
 665 \r
 666 INSTANTIATE_TEST_CASE_P(ImgProc, CornerMinEigenVal, testing::Combine(\r
 667                         ALL_DEVICES, \r
 668                         testing::Values(CV_8UC1, CV_32FC1)));\r
 669 \r
 670 //////////////////////////////////////////////////////////////////////\r
 671 // MulSpectrums\r
 672 \r
 673 GPU_PERF_TEST(MulSpectrums, cv::gpu::DeviceInfo, cv::Size)\r
 674 {\r
 675     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 676     cv::Size size = GET_PARAM(1);\r
 677 \r
 678     cv::gpu::setDevice(devInfo.deviceID());\r
 679 \r
 680     cv::Mat a_host(size, CV_32FC2);\r
 681     cv::Mat b_host(size, CV_32FC2);\r
 682 \r
 683     declare.in(a_host, b_host, WARMUP_RNG);\r
 684 \r
 685     cv::gpu::GpuMat a(a_host);\r
 686     cv::gpu::GpuMat b(b_host);\r
 687     cv::gpu::GpuMat dst;\r
 688 \r
 689     TEST_CYCLE()\r
 690     {\r
 691         cv::gpu::mulSpectrums(a, b, dst, 0);\r
 692     }\r
 693 }\r
 694 \r
 695 INSTANTIATE_TEST_CASE_P(ImgProc, MulSpectrums, testing::Combine(\r
 696                         ALL_DEVICES, \r
 697                         GPU_TYPICAL_MAT_SIZES));\r
 698 \r
 699 //////////////////////////////////////////////////////////////////////\r
 700 // Dft\r
 701 \r
 702 GPU_PERF_TEST(Dft, cv::gpu::DeviceInfo, cv::Size)\r
 703 {\r
 704     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 705     cv::Size size = GET_PARAM(1);\r
 706 \r
 707     cv::gpu::setDevice(devInfo.deviceID());\r
 708 \r
 709     cv::Mat src_host(size, CV_32FC2);\r
 710 \r
 711     declare.in(src_host, WARMUP_RNG);\r
 712 \r
 713     cv::gpu::GpuMat src(src_host);\r
 714     cv::gpu::GpuMat dst;\r
 715 \r
 716     declare.time(2.0);\r
 717 \r
 718     TEST_CYCLE()\r
 719     {\r
 720         cv::gpu::dft(src, dst, size);\r
 721     }\r
 722 }\r
 723 \r
 724 INSTANTIATE_TEST_CASE_P(ImgProc, Dft, testing::Combine(\r
 725                         ALL_DEVICES, \r
 726                         GPU_TYPICAL_MAT_SIZES));\r
 727 \r
 728 //////////////////////////////////////////////////////////////////////\r
 729 // Convolve\r
 730 \r
 731 GPU_PERF_TEST(Convolve, cv::gpu::DeviceInfo, cv::Size, int)\r
 732 {\r
 733     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 734     cv::Size size = GET_PARAM(1);\r
 735     int templ_size = GET_PARAM(2);\r
 736 \r
 737     cv::gpu::setDevice(devInfo.deviceID());\r
 738 \r
 739     cv::gpu::GpuMat image = cv::gpu::createContinuous(size, CV_32FC1);\r
 740     cv::gpu::GpuMat templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);\r
 741 \r
 742     image.setTo(cv::Scalar(1.0));\r
 743     templ.setTo(cv::Scalar(1.0));\r
 744 \r
 745     cv::gpu::GpuMat dst;\r
 746     cv::gpu::ConvolveBuf buf;\r
 747 \r
 748     declare.time(2.0);\r
 749 \r
 750     TEST_CYCLE()\r
 751     {\r
 752         cv::gpu::convolve(image, templ, dst, false, buf);\r
 753     }\r
 754 }\r
 755 \r
 756 INSTANTIATE_TEST_CASE_P(ImgProc, Convolve, testing::Combine(\r
 757                         ALL_DEVICES, \r
 758                         GPU_TYPICAL_MAT_SIZES,\r
 759                         testing::Values(3, 9, 27, 32, 64)));\r
 760 \r
 761 //////////////////////////////////////////////////////////////////////\r
 762 // PyrDown\r
 763 \r
 764 GPU_PERF_TEST(PyrDown, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
 765 {\r
 766     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 767     cv::Size size = GET_PARAM(1);\r
 768     int type = GET_PARAM(2);\r
 769 \r
 770     cv::gpu::setDevice(devInfo.deviceID());\r
 771 \r
 772     cv::Mat src_host(size, type);\r
 773 \r
 774     declare.in(src_host, WARMUP_RNG);\r
 775 \r
 776     cv::gpu::GpuMat src(src_host);\r
 777     cv::gpu::GpuMat dst;\r
 778 \r
 779     TEST_CYCLE()\r
 780     {\r
 781         cv::gpu::pyrDown(src, dst);\r
 782     }\r
 783 }\r
 784 \r
 785 INSTANTIATE_TEST_CASE_P(ImgProc, PyrDown, testing::Combine(\r
 786                         ALL_DEVICES, \r
 787                         GPU_TYPICAL_MAT_SIZES,\r
 788                         testing::Values(CV_8UC1, CV_8UC4, CV_16SC3, CV_32FC1)));\r
 789 \r
 790 //////////////////////////////////////////////////////////////////////\r
 791 // PyrUp\r
 792 \r
 793 GPU_PERF_TEST(PyrUp, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
 794 {\r
 795     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 796     cv::Size size = GET_PARAM(1);\r
 797     int type = GET_PARAM(2);\r
 798 \r
 799     cv::gpu::setDevice(devInfo.deviceID());\r
 800 \r
 801     cv::Mat src_host(size, type);\r
 802 \r
 803     declare.in(src_host, WARMUP_RNG);\r
 804 \r
 805     cv::gpu::GpuMat src(src_host);\r
 806     cv::gpu::GpuMat dst;\r
 807 \r
 808     TEST_CYCLE()\r
 809     {\r
 810         cv::gpu::pyrUp(src, dst);\r
 811     }\r
 812 }\r
 813 \r
 814 INSTANTIATE_TEST_CASE_P(ImgProc, PyrUp, testing::Combine(\r
 815                         ALL_DEVICES, \r
 816                         GPU_TYPICAL_MAT_SIZES,\r
 817                         testing::Values(CV_8UC1, CV_8UC4, CV_16SC3, CV_32FC1)));\r
 818 \r
 819 //////////////////////////////////////////////////////////////////////\r
 820 // BlendLinear\r
 821 \r
 822 GPU_PERF_TEST(BlendLinear, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
 823 {\r
 824     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 825     cv::Size size = GET_PARAM(1);\r
 826     int type = GET_PARAM(2);\r
 827 \r
 828     cv::gpu::setDevice(devInfo.deviceID());\r
 829 \r
 830     cv::Mat img1_host(size, type);\r
 831     cv::Mat img2_host(size, type);\r
 832 \r
 833     declare.in(img1_host, img2_host, WARMUP_RNG);\r
 834 \r
 835     cv::gpu::GpuMat img1(img1_host);\r
 836     cv::gpu::GpuMat img2(img2_host);\r
 837     cv::gpu::GpuMat weights1(size, CV_32FC1, cv::Scalar::all(0.5));\r
 838     cv::gpu::GpuMat weights2(size, CV_32FC1, cv::Scalar::all(0.5));\r
 839     cv::gpu::GpuMat dst;\r
 840 \r
 841     TEST_CYCLE()\r
 842     {\r
 843         cv::gpu::blendLinear(img1, img2, weights1, weights2, dst);\r
 844     }\r
 845 }\r
 846 \r
 847 INSTANTIATE_TEST_CASE_P(ImgProc, BlendLinear, testing::Combine(\r
 848                         ALL_DEVICES, \r
 849                         GPU_TYPICAL_MAT_SIZES,\r
 850                         testing::Values(CV_8UC1, CV_32FC1)));\r
 851 \r
 852 //////////////////////////////////////////////////////////////////////\r
 853 // Canny\r
 854 \r
 855 GPU_PERF_TEST_1(Canny, cv::gpu::DeviceInfo)\r
 856 {\r
 857     cv::gpu::DeviceInfo devInfo = GetParam();\r
 858 \r
 859     cv::gpu::setDevice(devInfo.deviceID());\r
 860 \r
 861     cv::Mat image_host = readImage("perf/1280x1024.jpg", cv::IMREAD_GRAYSCALE);\r
 862     ASSERT_FALSE(image_host.empty());\r
 863 \r
 864     cv::gpu::GpuMat image(image_host);\r
 865     cv::gpu::GpuMat dst;\r
 866     cv::gpu::CannyBuf buf;\r
 867 \r
 868     TEST_CYCLE()\r
 869     {\r
 870         cv::gpu::Canny(image, buf, dst, 50.0, 100.0);\r
 871     }\r
 872 }\r
 873 \r
 874 INSTANTIATE_TEST_CASE_P(ImgProc, Canny, ALL_DEVICES);\r
 875 \r
 876 //////////////////////////////////////////////////////////////////////\r
 877 // CalcHist\r
 878 \r
 879 GPU_PERF_TEST(CalcHist, cv::gpu::DeviceInfo, cv::Size)\r
 880 {\r
 881     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 882     cv::Size size = GET_PARAM(1);\r
 883 \r
 884     cv::gpu::setDevice(devInfo.deviceID());\r
 885 \r
 886     cv::Mat src_host(size, CV_8UC1);\r
 887 \r
 888     declare.in(src_host, WARMUP_RNG);\r
 889 \r
 890     cv::gpu::GpuMat src(src_host);\r
 891     cv::gpu::GpuMat hist;\r
 892     cv::gpu::GpuMat buf;\r
 893 \r
 894     TEST_CYCLE()\r
 895     {\r
 896         cv::gpu::calcHist(src, hist, buf);\r
 897     }\r
 898 }\r
 899 \r
 900 INSTANTIATE_TEST_CASE_P(ImgProc, CalcHist, testing::Combine(\r
 901                         ALL_DEVICES, \r
 902                         GPU_TYPICAL_MAT_SIZES));\r
 903 \r
 904 //////////////////////////////////////////////////////////////////////\r
 905 // EqualizeHist\r
 906 \r
 907 GPU_PERF_TEST(EqualizeHist, cv::gpu::DeviceInfo, cv::Size)\r
 908 {\r
 909     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 910     cv::Size size = GET_PARAM(1);\r
 911 \r
 912     cv::gpu::setDevice(devInfo.deviceID());\r
 913 \r
 914     cv::Mat src_host(size, CV_8UC1);\r
 915 \r
 916     declare.in(src_host, WARMUP_RNG);\r
 917 \r
 918     cv::gpu::GpuMat src(src_host);\r
 919     cv::gpu::GpuMat dst;\r
 920     cv::gpu::GpuMat hist;\r
 921     cv::gpu::GpuMat buf;\r
 922 \r
 923     TEST_CYCLE()\r
 924     {\r
 925         cv::gpu::equalizeHist(src, dst, hist, buf);\r
 926     }\r
 927 }\r
 928 \r
 929 INSTANTIATE_TEST_CASE_P(ImgProc, EqualizeHist, testing::Combine(\r
 930                         ALL_DEVICES, \r
 931                         GPU_TYPICAL_MAT_SIZES));\r
 932 \r
 933 //////////////////////////////////////////////////////////////////////\r
 934 // ImagePyramid\r
 935 \r
 936 GPU_PERF_TEST(ImagePyramid_build, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
 937 {\r
 938     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 939     cv::Size size = GET_PARAM(1);\r
 940     int type = GET_PARAM(2);\r
 941 \r
 942     cv::gpu::setDevice(devInfo.deviceID());\r
 943 \r
 944     cv::Mat src_host(size, type);\r
 945 \r
 946     declare.in(src_host, WARMUP_RNG);\r
 947 \r
 948     cv::gpu::GpuMat src(src_host);\r
 949 \r
 950     cv::gpu::ImagePyramid pyr;\r
 951     \r
 952     TEST_CYCLE()\r
 953     {\r
 954         pyr.build(src, 5);\r
 955     }\r
 956 }\r
 957 \r
 958 INSTANTIATE_TEST_CASE_P(ImgProc, ImagePyramid_build, testing::Combine(\r
 959                         ALL_DEVICES, \r
 960                         GPU_TYPICAL_MAT_SIZES,\r
 961                         testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));\r
 962 \r
 963 GPU_PERF_TEST(ImagePyramid_getLayer, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
 964 {\r
 965     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 966     cv::Size size = GET_PARAM(1);\r
 967     int type = GET_PARAM(2);\r
 968 \r
 969     cv::gpu::setDevice(devInfo.deviceID());\r
 970 \r
 971     cv::Mat src_host(size, type);\r
 972 \r
 973     declare.in(src_host, WARMUP_RNG);\r
 974 \r
 975     cv::gpu::GpuMat src(src_host);\r
 976     cv::gpu::GpuMat dst;\r
 977 \r
 978     cv::gpu::ImagePyramid pyr(src, 3);\r
 979     \r
 980     TEST_CYCLE()\r
 981     {\r
 982         pyr.getLayer(dst, cv::Size(size.width / 2 + 10, size.height / 2 + 10));\r
 983     }\r
 984 }\r
 985 \r
 986 INSTANTIATE_TEST_CASE_P(ImgProc, ImagePyramid_getLayer, testing::Combine(\r
 987                         ALL_DEVICES, \r
 988                         GPU_TYPICAL_MAT_SIZES,\r
 989                         testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));\r
 990 \r
 991 #endif\r