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;\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 // SwapChannels\r
 223 \r
 224 GPU_PERF_TEST(SwapChannels, cv::gpu::DeviceInfo, cv::Size)\r
 225 {\r
 226     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 227     cv::Size size = GET_PARAM(1);\r
 228 \r
 229     cv::gpu::setDevice(devInfo.deviceID());\r
 230 \r
 231     cv::Mat src_host(size, CV_8UC4);\r
 232 \r
 233     declare.in(src_host, WARMUP_RNG);\r
 234 \r
 235     cv::gpu::GpuMat src(src_host);\r
 236 \r
 237     const int dstOrder[] = {2, 1, 0, 3};\r
 238 \r
 239     TEST_CYCLE()\r
 240     {\r
 241         cv::gpu::swapChannels(src, dstOrder);\r
 242     }\r
 243 }\r
 244 \r
 245 INSTANTIATE_TEST_CASE_P(ImgProc, SwapChannels, testing::Combine(ALL_DEVICES, GPU_TYPICAL_MAT_SIZES));\r
 246 \r
 247 //////////////////////////////////////////////////////////////////////\r
 248 // Threshold\r
 249 \r
 250 GPU_PERF_TEST(Threshold, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
 251 {\r
 252     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 253     cv::Size size = GET_PARAM(1);\r
 254     int type = GET_PARAM(2);\r
 255 \r
 256     cv::gpu::setDevice(devInfo.deviceID());\r
 257 \r
 258     cv::Mat src_host(size, type);\r
 259 \r
 260     declare.in(src_host, WARMUP_RNG);\r
 261 \r
 262     cv::gpu::GpuMat src(src_host);\r
 263     cv::gpu::GpuMat dst(size, type);\r
 264 \r
 265     TEST_CYCLE()\r
 266     {\r
 267         cv::gpu::threshold(src, dst, 100.0, 255.0, cv::THRESH_BINARY);\r
 268     }\r
 269 }\r
 270 \r
 271 INSTANTIATE_TEST_CASE_P(ImgProc, Threshold, testing::Combine(\r
 272                         ALL_DEVICES, \r
 273                         GPU_TYPICAL_MAT_SIZES, \r
 274                         testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
 275 \r
 276 //////////////////////////////////////////////////////////////////////\r
 277 // Resize\r
 278 \r
 279 GPU_PERF_TEST(Resize, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation, double)\r
 280 {\r
 281     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 282     cv::Size size = GET_PARAM(1);\r
 283     int type = GET_PARAM(2);\r
 284     int interpolation = GET_PARAM(3);\r
 285     double f = GET_PARAM(4);\r
 286 \r
 287     cv::gpu::setDevice(devInfo.deviceID());\r
 288 \r
 289     cv::Mat src_host(size, type);\r
 290 \r
 291     declare.in(src_host, WARMUP_RNG);\r
 292 \r
 293     cv::gpu::GpuMat src(src_host);\r
 294     cv::gpu::GpuMat dst;\r
 295 \r
 296     declare.time(1.0);\r
 297 \r
 298     TEST_CYCLE()\r
 299     {\r
 300         cv::gpu::resize(src, dst, cv::Size(), f, f, interpolation);\r
 301     }\r
 302 }\r
 303 \r
 304 INSTANTIATE_TEST_CASE_P(ImgProc, Resize, testing::Combine(\r
 305                         ALL_DEVICES, \r
 306                         testing::Values(perf::szSXGA, perf::sz1080p), \r
 307                         testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_32FC1),\r
 308                         testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC),\r
 309                         testing::Values(0.5, 2.0)));\r
 310 \r
 311 //////////////////////////////////////////////////////////////////////\r
 312 // WarpAffine\r
 313 \r
 314 GPU_PERF_TEST(WarpAffine, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation)\r
 315 {\r
 316     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 317     cv::Size size = GET_PARAM(1);\r
 318     int type = GET_PARAM(2);\r
 319     int interpolation = GET_PARAM(3);\r
 320 \r
 321     cv::gpu::setDevice(devInfo.deviceID());\r
 322 \r
 323     cv::Mat src_host(size, type);\r
 324 \r
 325     declare.in(src_host, WARMUP_RNG);\r
 326 \r
 327     cv::gpu::GpuMat src(src_host);\r
 328     cv::gpu::GpuMat dst;\r
 329 \r
 330     double reflect[2][3] = { {-1,  0, 0},\r
 331                              { 0, -1, 0}};\r
 332     reflect[0][2] = size.width;\r
 333     reflect[1][2] = size.height;\r
 334     cv::Mat M(2, 3, CV_64F, (void*) reflect); \r
 335 \r
 336     TEST_CYCLE()\r
 337     {\r
 338         cv::gpu::warpAffine(src, dst, M, size, interpolation);\r
 339     }\r
 340 }\r
 341 \r
 342 INSTANTIATE_TEST_CASE_P(ImgProc, WarpAffine, testing::Combine(\r
 343                         ALL_DEVICES, \r
 344                         GPU_TYPICAL_MAT_SIZES, \r
 345                         testing::Values(CV_8UC1, CV_8UC4, CV_32FC1),\r
 346                         testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC)));\r
 347 \r
 348 //////////////////////////////////////////////////////////////////////\r
 349 // WarpPerspective\r
 350 \r
 351 GPU_PERF_TEST(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation)\r
 352 {\r
 353     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 354     cv::Size size = GET_PARAM(1);\r
 355     int type = GET_PARAM(2);\r
 356     int interpolation = GET_PARAM(3);\r
 357 \r
 358     cv::gpu::setDevice(devInfo.deviceID());\r
 359 \r
 360     cv::Mat src_host(size, type);\r
 361 \r
 362     declare.in(src_host, WARMUP_RNG);\r
 363 \r
 364     cv::gpu::GpuMat src(src_host);\r
 365     cv::gpu::GpuMat dst;\r
 366 \r
 367     double reflect[3][3] = { {-1,  0, 0},\r
 368                              { 0, -1, 0},\r
 369                              { 0, 0, 1}};\r
 370     reflect[0][2] = size.width;\r
 371     reflect[1][2] = size.height;\r
 372     cv::Mat M(3, 3, CV_64F, (void*)reflect); \r
 373 \r
 374     TEST_CYCLE()\r
 375     {\r
 376         cv::gpu::warpPerspective(src, dst, M, size, interpolation);\r
 377     }\r
 378 }\r
 379 \r
 380 INSTANTIATE_TEST_CASE_P(ImgProc, WarpPerspective, testing::Combine(\r
 381                         ALL_DEVICES, \r
 382                         GPU_TYPICAL_MAT_SIZES, \r
 383                         testing::Values(CV_8UC1, CV_8UC4, CV_32FC1),\r
 384                         testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC)));\r
 385 \r
 386 //////////////////////////////////////////////////////////////////////\r
 387 // BuildWarpPlaneMaps\r
 388 \r
 389 GPU_PERF_TEST(BuildWarpPlaneMaps, cv::gpu::DeviceInfo, cv::Size)\r
 390 {\r
 391     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 392     cv::Size size = GET_PARAM(1);\r
 393 \r
 394     cv::gpu::setDevice(devInfo.deviceID());\r
 395 \r
 396     cv::gpu::GpuMat map_x;\r
 397     cv::gpu::GpuMat map_y;\r
 398 \r
 399     TEST_CYCLE()\r
 400     {\r
 401         cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), cv::Mat::eye(3, 3, CV_32FC1), \r
 402                                     cv::Mat::ones(3, 3, CV_32FC1), cv::Mat::zeros(1, 3, CV_32F), 1.0, map_x, map_y);\r
 403     }\r
 404 }\r
 405 \r
 406 INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpPlaneMaps, testing::Combine(\r
 407                         ALL_DEVICES, \r
 408                         GPU_TYPICAL_MAT_SIZES));\r
 409 \r
 410 //////////////////////////////////////////////////////////////////////\r
 411 // BuildWarpCylindricalMaps\r
 412 \r
 413 GPU_PERF_TEST(BuildWarpCylindricalMaps, cv::gpu::DeviceInfo, cv::Size)\r
 414 {\r
 415     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 416     cv::Size size = GET_PARAM(1);\r
 417 \r
 418     cv::gpu::setDevice(devInfo.deviceID());\r
 419 \r
 420     cv::gpu::GpuMat map_x;\r
 421     cv::gpu::GpuMat map_y;\r
 422 \r
 423     TEST_CYCLE()\r
 424     {\r
 425         cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), cv::Mat::eye(3, 3, CV_32FC1),\r
 426                                           cv::Mat::ones(3, 3, CV_32FC1), 1.0, map_x, map_y);\r
 427     }\r
 428 }\r
 429 \r
 430 INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpCylindricalMaps, testing::Combine(\r
 431                         ALL_DEVICES, \r
 432                         GPU_TYPICAL_MAT_SIZES));\r
 433 \r
 434 //////////////////////////////////////////////////////////////////////\r
 435 // BuildWarpSphericalMaps\r
 436 \r
 437 GPU_PERF_TEST(BuildWarpSphericalMaps, cv::gpu::DeviceInfo, cv::Size)\r
 438 {\r
 439     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 440     cv::Size size = GET_PARAM(1);\r
 441 \r
 442     cv::gpu::setDevice(devInfo.deviceID());\r
 443 \r
 444     cv::gpu::GpuMat map_x;\r
 445     cv::gpu::GpuMat map_y;\r
 446 \r
 447     TEST_CYCLE()\r
 448     {\r
 449         cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), cv::Mat::eye(3, 3, CV_32FC1),\r
 450                                         cv::Mat::ones(3, 3, CV_32FC1), 1.0, map_x, map_y);\r
 451     }\r
 452 }\r
 453 \r
 454 INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpSphericalMaps, testing::Combine(\r
 455                         ALL_DEVICES, \r
 456                         GPU_TYPICAL_MAT_SIZES));\r
 457 \r
 458 //////////////////////////////////////////////////////////////////////\r
 459 // Rotate\r
 460 \r
 461 GPU_PERF_TEST(Rotate, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation)\r
 462 {\r
 463     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 464     cv::Size size = GET_PARAM(1);\r
 465     int type = GET_PARAM(2);\r
 466     int interpolation = GET_PARAM(3);\r
 467 \r
 468     cv::gpu::setDevice(devInfo.deviceID());\r
 469 \r
 470     cv::Mat src_host(size, type);\r
 471 \r
 472     declare.in(src_host, WARMUP_RNG);\r
 473 \r
 474     cv::gpu::GpuMat src(src_host);\r
 475     cv::gpu::GpuMat dst;\r
 476 \r
 477     TEST_CYCLE()\r
 478     {\r
 479         cv::gpu::rotate(src, dst, size, 30.0, 0, 0, interpolation);\r
 480     }\r
 481 }\r
 482 \r
 483 INSTANTIATE_TEST_CASE_P(ImgProc, Rotate, testing::Combine(\r
 484                         ALL_DEVICES, \r
 485                         GPU_TYPICAL_MAT_SIZES, \r
 486                         testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4),\r
 487                         testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC)));\r
 488 \r
 489 //////////////////////////////////////////////////////////////////////\r
 490 // CopyMakeBorder\r
 491 \r
 492 GPU_PERF_TEST(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, perf::MatType, BorderMode)\r
 493 {\r
 494     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 495     cv::Size size = GET_PARAM(1);\r
 496     int type = GET_PARAM(2);\r
 497     int borderType = GET_PARAM(3);\r
 498 \r
 499     cv::gpu::setDevice(devInfo.deviceID());\r
 500 \r
 501     cv::Mat src_host(size, type);\r
 502 \r
 503     declare.in(src_host, WARMUP_RNG);\r
 504 \r
 505     cv::gpu::GpuMat src(src_host);\r
 506     cv::gpu::GpuMat dst;\r
 507 \r
 508     TEST_CYCLE()\r
 509     {\r
 510         cv::gpu::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType);\r
 511     }\r
 512 }\r
 513 \r
 514 INSTANTIATE_TEST_CASE_P(ImgProc, CopyMakeBorder, testing::Combine(\r
 515                         ALL_DEVICES, \r
 516                         GPU_TYPICAL_MAT_SIZES, \r
 517                         testing::Values(CV_8UC1, CV_8UC4, CV_32FC1),\r
 518                         testing::Values((int) cv::BORDER_REPLICATE, (int) cv::BORDER_REFLECT, (int) cv::BORDER_WRAP, (int) cv::BORDER_CONSTANT)));\r
 519 \r
 520 //////////////////////////////////////////////////////////////////////\r
 521 // Integral\r
 522 \r
 523 GPU_PERF_TEST(Integral, cv::gpu::DeviceInfo, cv::Size)\r
 524 {\r
 525     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 526     cv::Size size = GET_PARAM(1);\r
 527 \r
 528     cv::gpu::setDevice(devInfo.deviceID());\r
 529 \r
 530     cv::Mat src_host(size, CV_8UC1);\r
 531 \r
 532     declare.in(src_host, WARMUP_RNG);\r
 533 \r
 534     cv::gpu::GpuMat src(src_host);\r
 535     cv::gpu::GpuMat dst;\r
 536     cv::gpu::GpuMat buf;\r
 537 \r
 538     TEST_CYCLE()\r
 539     {\r
 540         cv::gpu::integralBuffered(src, dst, buf);\r
 541     }\r
 542 }\r
 543 \r
 544 INSTANTIATE_TEST_CASE_P(ImgProc, Integral, testing::Combine(\r
 545                         ALL_DEVICES, \r
 546                         GPU_TYPICAL_MAT_SIZES));\r
 547 \r
 548 //////////////////////////////////////////////////////////////////////\r
 549 // IntegralSqr\r
 550 \r
 551 GPU_PERF_TEST(IntegralSqr, cv::gpu::DeviceInfo, cv::Size)\r
 552 {\r
 553     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 554     cv::Size size = GET_PARAM(1);\r
 555 \r
 556     cv::gpu::setDevice(devInfo.deviceID());\r
 557 \r
 558     cv::Mat src_host(size, CV_8UC1);\r
 559 \r
 560     declare.in(src_host, WARMUP_RNG);\r
 561 \r
 562     cv::gpu::GpuMat src(src_host);\r
 563     cv::gpu::GpuMat dst;\r
 564 \r
 565     TEST_CYCLE()\r
 566     {\r
 567         cv::gpu::sqrIntegral(src, dst);\r
 568     }\r
 569 }\r
 570 \r
 571 INSTANTIATE_TEST_CASE_P(ImgProc, IntegralSqr, testing::Combine(\r
 572                         ALL_DEVICES, \r
 573                         GPU_TYPICAL_MAT_SIZES));\r
 574 \r
 575 //////////////////////////////////////////////////////////////////////\r
 576 // ColumnSum\r
 577 \r
 578 GPU_PERF_TEST(ColumnSum, cv::gpu::DeviceInfo, cv::Size)\r
 579 {\r
 580     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 581     cv::Size size = GET_PARAM(1);\r
 582 \r
 583     cv::gpu::setDevice(devInfo.deviceID());\r
 584 \r
 585     cv::Mat src_host(size, CV_32FC1);\r
 586 \r
 587     declare.in(src_host, WARMUP_RNG);\r
 588 \r
 589     cv::gpu::GpuMat src(src_host);\r
 590     cv::gpu::GpuMat dst;\r
 591 \r
 592     TEST_CYCLE()\r
 593     {\r
 594         cv::gpu::columnSum(src, dst);\r
 595     }\r
 596 }\r
 597 \r
 598 INSTANTIATE_TEST_CASE_P(ImgProc, ColumnSum, testing::Combine(\r
 599                         ALL_DEVICES, \r
 600                         GPU_TYPICAL_MAT_SIZES));\r
 601 \r
 602 //////////////////////////////////////////////////////////////////////\r
 603 // CornerHarris\r
 604 \r
 605 GPU_PERF_TEST(CornerHarris, cv::gpu::DeviceInfo, perf::MatType)\r
 606 {\r
 607     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 608     int type = GET_PARAM(1);\r
 609 \r
 610     cv::gpu::setDevice(devInfo.deviceID());\r
 611     \r
 612     cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);\r
 613     ASSERT_FALSE(img.empty());\r
 614 \r
 615     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
 616 \r
 617     cv::gpu::GpuMat src(img);\r
 618     cv::gpu::GpuMat dst;\r
 619     cv::gpu::GpuMat Dx;\r
 620     cv::gpu::GpuMat Dy;\r
 621 \r
 622     int blockSize = 3;\r
 623     int ksize = 7;        \r
 624     double k = 0.5;\r
 625 \r
 626     TEST_CYCLE()\r
 627     {\r
 628         cv::gpu::cornerHarris(src, dst, Dx, Dy, blockSize, ksize, k);\r
 629     }\r
 630 }\r
 631 \r
 632 INSTANTIATE_TEST_CASE_P(ImgProc, CornerHarris, testing::Combine(\r
 633                         ALL_DEVICES, \r
 634                         testing::Values(CV_8UC1, CV_32FC1)));\r
 635 \r
 636 //////////////////////////////////////////////////////////////////////\r
 637 // CornerMinEigenVal\r
 638 \r
 639 GPU_PERF_TEST(CornerMinEigenVal, cv::gpu::DeviceInfo, perf::MatType)\r
 640 {\r
 641     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 642     int type = GET_PARAM(1);\r
 643 \r
 644     cv::gpu::setDevice(devInfo.deviceID());\r
 645     \r
 646     cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);\r
 647     ASSERT_FALSE(img.empty());\r
 648 \r
 649     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
 650 \r
 651     cv::gpu::GpuMat src(img);\r
 652     cv::gpu::GpuMat dst;\r
 653     cv::gpu::GpuMat Dx;\r
 654     cv::gpu::GpuMat Dy;\r
 655 \r
 656     int blockSize = 3;\r
 657     int ksize = 7; \r
 658 \r
 659     TEST_CYCLE()\r
 660     {\r
 661         cv::gpu::cornerMinEigenVal(src, dst, Dx, Dy, blockSize, ksize);\r
 662     }\r
 663 }\r
 664 \r
 665 INSTANTIATE_TEST_CASE_P(ImgProc, CornerMinEigenVal, testing::Combine(\r
 666                         ALL_DEVICES, \r
 667                         testing::Values(CV_8UC1, CV_32FC1)));\r
 668 \r
 669 //////////////////////////////////////////////////////////////////////\r
 670 // MulSpectrums\r
 671 \r
 672 GPU_PERF_TEST(MulSpectrums, cv::gpu::DeviceInfo, cv::Size)\r
 673 {\r
 674     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 675     cv::Size size = GET_PARAM(1);\r
 676 \r
 677     cv::gpu::setDevice(devInfo.deviceID());\r
 678 \r
 679     cv::Mat a_host(size, CV_32FC2);\r
 680     cv::Mat b_host(size, CV_32FC2);\r
 681 \r
 682     declare.in(a_host, b_host, WARMUP_RNG);\r
 683 \r
 684     cv::gpu::GpuMat a(a_host);\r
 685     cv::gpu::GpuMat b(b_host);\r
 686     cv::gpu::GpuMat dst;\r
 687 \r
 688     TEST_CYCLE()\r
 689     {\r
 690         cv::gpu::mulSpectrums(a, b, dst, 0);\r
 691     }\r
 692 }\r
 693 \r
 694 INSTANTIATE_TEST_CASE_P(ImgProc, MulSpectrums, testing::Combine(\r
 695                         ALL_DEVICES, \r
 696                         GPU_TYPICAL_MAT_SIZES));\r
 697 \r
 698 //////////////////////////////////////////////////////////////////////\r
 699 // Dft\r
 700 \r
 701 GPU_PERF_TEST(Dft, cv::gpu::DeviceInfo, cv::Size)\r
 702 {\r
 703     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 704     cv::Size size = GET_PARAM(1);\r
 705 \r
 706     cv::gpu::setDevice(devInfo.deviceID());\r
 707 \r
 708     cv::Mat src_host(size, CV_32FC2);\r
 709 \r
 710     declare.in(src_host, WARMUP_RNG);\r
 711 \r
 712     cv::gpu::GpuMat src(src_host);\r
 713     cv::gpu::GpuMat dst;\r
 714 \r
 715     declare.time(2.0);\r
 716 \r
 717     TEST_CYCLE()\r
 718     {\r
 719         cv::gpu::dft(src, dst, size);\r
 720     }\r
 721 }\r
 722 \r
 723 INSTANTIATE_TEST_CASE_P(ImgProc, Dft, testing::Combine(\r
 724                         ALL_DEVICES, \r
 725                         GPU_TYPICAL_MAT_SIZES));\r
 726 \r
 727 //////////////////////////////////////////////////////////////////////\r
 728 // Convolve\r
 729 \r
 730 GPU_PERF_TEST(Convolve, cv::gpu::DeviceInfo, cv::Size, int, bool)\r
 731 {\r
 732     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 733     cv::Size size = GET_PARAM(1);\r
 734     int templ_size = GET_PARAM(2);\r
 735     bool ccorr = GET_PARAM(3);\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, ccorr, 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                         testing::Bool()));\r
 761 \r
 762 //////////////////////////////////////////////////////////////////////\r
 763 // PyrDown\r
 764 \r
 765 GPU_PERF_TEST(PyrDown, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
 766 {\r
 767     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 768     cv::Size size = GET_PARAM(1);\r
 769     int type = GET_PARAM(2);\r
 770 \r
 771     cv::gpu::setDevice(devInfo.deviceID());\r
 772 \r
 773     cv::Mat src_host(size, type);\r
 774 \r
 775     declare.in(src_host, WARMUP_RNG);\r
 776 \r
 777     cv::gpu::GpuMat src(src_host);\r
 778     cv::gpu::GpuMat dst;\r
 779 \r
 780     TEST_CYCLE()\r
 781     {\r
 782         cv::gpu::pyrDown(src, dst);\r
 783     }\r
 784 }\r
 785 \r
 786 INSTANTIATE_TEST_CASE_P(ImgProc, PyrDown, testing::Combine(\r
 787                         ALL_DEVICES, \r
 788                         GPU_TYPICAL_MAT_SIZES,\r
 789                         testing::Values(CV_8UC1, CV_8UC4, CV_16SC3, CV_32FC1)));\r
 790 \r
 791 //////////////////////////////////////////////////////////////////////\r
 792 // PyrUp\r
 793 \r
 794 GPU_PERF_TEST(PyrUp, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
 795 {\r
 796     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 797     cv::Size size = GET_PARAM(1);\r
 798     int type = GET_PARAM(2);\r
 799 \r
 800     cv::gpu::setDevice(devInfo.deviceID());\r
 801 \r
 802     cv::Mat src_host(size, type);\r
 803 \r
 804     declare.in(src_host, WARMUP_RNG);\r
 805 \r
 806     cv::gpu::GpuMat src(src_host);\r
 807     cv::gpu::GpuMat dst;\r
 808 \r
 809     TEST_CYCLE()\r
 810     {\r
 811         cv::gpu::pyrUp(src, dst);\r
 812     }\r
 813 }\r
 814 \r
 815 INSTANTIATE_TEST_CASE_P(ImgProc, PyrUp, testing::Combine(\r
 816                         ALL_DEVICES, \r
 817                         GPU_TYPICAL_MAT_SIZES,\r
 818                         testing::Values(CV_8UC1, CV_8UC4, CV_16SC3, CV_32FC1)));\r
 819 \r
 820 //////////////////////////////////////////////////////////////////////\r
 821 // BlendLinear\r
 822 \r
 823 GPU_PERF_TEST(BlendLinear, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
 824 {\r
 825     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 826     cv::Size size = GET_PARAM(1);\r
 827     int type = GET_PARAM(2);\r
 828 \r
 829     cv::gpu::setDevice(devInfo.deviceID());\r
 830 \r
 831     cv::Mat img1_host(size, type);\r
 832     cv::Mat img2_host(size, type);\r
 833 \r
 834     declare.in(img1_host, img2_host, WARMUP_RNG);\r
 835 \r
 836     cv::gpu::GpuMat img1(img1_host);\r
 837     cv::gpu::GpuMat img2(img2_host);\r
 838     cv::gpu::GpuMat weights1(size, CV_32FC1, cv::Scalar::all(0.5));\r
 839     cv::gpu::GpuMat weights2(size, CV_32FC1, cv::Scalar::all(0.5));\r
 840     cv::gpu::GpuMat dst;\r
 841 \r
 842     TEST_CYCLE()\r
 843     {\r
 844         cv::gpu::blendLinear(img1, img2, weights1, weights2, dst);\r
 845     }\r
 846 }\r
 847 \r
 848 INSTANTIATE_TEST_CASE_P(ImgProc, BlendLinear, testing::Combine(\r
 849                         ALL_DEVICES, \r
 850                         GPU_TYPICAL_MAT_SIZES,\r
 851                         testing::Values(CV_8UC1, CV_32FC1)));\r
 852 \r
 853 //////////////////////////////////////////////////////////////////////\r
 854 // AlphaComp\r
 855 \r
 856 GPU_PERF_TEST(AlphaComp, cv::gpu::DeviceInfo, cv::Size, perf::MatType, AlphaOp)\r
 857 {\r
 858     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 859     cv::Size size = GET_PARAM(1);\r
 860     int type = GET_PARAM(2);\r
 861     int alpha_op = GET_PARAM(3);\r
 862 \r
 863     cv::gpu::setDevice(devInfo.deviceID());\r
 864 \r
 865     cv::Mat img1_host(size, type);\r
 866     cv::Mat img2_host(size, type);\r
 867 \r
 868     declare.in(img1_host, img2_host, WARMUP_RNG);\r
 869 \r
 870     cv::gpu::GpuMat img1(img1_host);\r
 871     cv::gpu::GpuMat img2(img2_host);\r
 872     cv::gpu::GpuMat dst;\r
 873 \r
 874     TEST_CYCLE()\r
 875     {\r
 876         cv::gpu::alphaComp(img1, img2, dst, alpha_op);\r
 877     }\r
 878 }\r
 879 \r
 880 INSTANTIATE_TEST_CASE_P(ImgProc, AlphaComp, testing::Combine(\r
 881                         ALL_DEVICES, \r
 882                         GPU_TYPICAL_MAT_SIZES,\r
 883                         testing::Values(CV_8UC4, CV_16UC4, CV_32SC4, CV_32FC4),\r
 884                         testing::Values((int)cv::gpu::ALPHA_OVER, (int)cv::gpu::ALPHA_IN, (int)cv::gpu::ALPHA_OUT, (int)cv::gpu::ALPHA_ATOP, (int)cv::gpu::ALPHA_XOR, (int)cv::gpu::ALPHA_PLUS, (int)cv::gpu::ALPHA_OVER_PREMUL, (int)cv::gpu::ALPHA_IN_PREMUL, (int)cv::gpu::ALPHA_OUT_PREMUL, (int)cv::gpu::ALPHA_ATOP_PREMUL, (int)cv::gpu::ALPHA_XOR_PREMUL, (int)cv::gpu::ALPHA_PLUS_PREMUL, (int)cv::gpu::ALPHA_PREMUL)));\r
 885 \r
 886 //////////////////////////////////////////////////////////////////////\r
 887 // Canny\r
 888 \r
 889 GPU_PERF_TEST_1(Canny, cv::gpu::DeviceInfo)\r
 890 {\r
 891     cv::gpu::DeviceInfo devInfo = GetParam();\r
 892 \r
 893     cv::gpu::setDevice(devInfo.deviceID());\r
 894 \r
 895     cv::Mat image_host = readImage("perf/1280x1024.jpg", cv::IMREAD_GRAYSCALE);\r
 896     ASSERT_FALSE(image_host.empty());\r
 897 \r
 898     cv::gpu::GpuMat image(image_host);\r
 899     cv::gpu::GpuMat dst;\r
 900     cv::gpu::CannyBuf buf;\r
 901 \r
 902     TEST_CYCLE()\r
 903     {\r
 904         cv::gpu::Canny(image, buf, dst, 50.0, 100.0);\r
 905     }\r
 906 }\r
 907 \r
 908 INSTANTIATE_TEST_CASE_P(ImgProc, Canny, ALL_DEVICES);\r
 909 \r
 910 //////////////////////////////////////////////////////////////////////\r
 911 // CalcHist\r
 912 \r
 913 GPU_PERF_TEST(CalcHist, cv::gpu::DeviceInfo, cv::Size)\r
 914 {\r
 915     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 916     cv::Size size = GET_PARAM(1);\r
 917 \r
 918     cv::gpu::setDevice(devInfo.deviceID());\r
 919 \r
 920     cv::Mat src_host(size, CV_8UC1);\r
 921 \r
 922     declare.in(src_host, WARMUP_RNG);\r
 923 \r
 924     cv::gpu::GpuMat src(src_host);\r
 925     cv::gpu::GpuMat hist;\r
 926     cv::gpu::GpuMat buf;\r
 927 \r
 928     TEST_CYCLE()\r
 929     {\r
 930         cv::gpu::calcHist(src, hist, buf);\r
 931     }\r
 932 }\r
 933 \r
 934 INSTANTIATE_TEST_CASE_P(ImgProc, CalcHist, testing::Combine(\r
 935                         ALL_DEVICES, \r
 936                         GPU_TYPICAL_MAT_SIZES));\r
 937 \r
 938 //////////////////////////////////////////////////////////////////////\r
 939 // EqualizeHist\r
 940 \r
 941 GPU_PERF_TEST(EqualizeHist, cv::gpu::DeviceInfo, cv::Size)\r
 942 {\r
 943     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 944     cv::Size size = GET_PARAM(1);\r
 945 \r
 946     cv::gpu::setDevice(devInfo.deviceID());\r
 947 \r
 948     cv::Mat src_host(size, CV_8UC1);\r
 949 \r
 950     declare.in(src_host, WARMUP_RNG);\r
 951 \r
 952     cv::gpu::GpuMat src(src_host);\r
 953     cv::gpu::GpuMat dst;\r
 954     cv::gpu::GpuMat hist;\r
 955     cv::gpu::GpuMat buf;\r
 956 \r
 957     TEST_CYCLE()\r
 958     {\r
 959         cv::gpu::equalizeHist(src, dst, hist, buf);\r
 960     }\r
 961 }\r
 962 \r
 963 INSTANTIATE_TEST_CASE_P(ImgProc, EqualizeHist, testing::Combine(\r
 964                         ALL_DEVICES, \r
 965                         GPU_TYPICAL_MAT_SIZES));\r
 966 \r
 967 //////////////////////////////////////////////////////////////////////\r
 968 // ImagePyramid\r
 969 \r
 970 GPU_PERF_TEST(ImagePyramid_build, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
 971 {\r
 972     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 973     cv::Size size = GET_PARAM(1);\r
 974     int type = GET_PARAM(2);\r
 975 \r
 976     cv::gpu::setDevice(devInfo.deviceID());\r
 977 \r
 978     cv::Mat src_host(size, type);\r
 979 \r
 980     declare.in(src_host, WARMUP_RNG);\r
 981 \r
 982     cv::gpu::GpuMat src(src_host);\r
 983 \r
 984     cv::gpu::ImagePyramid pyr;\r
 985     \r
 986     TEST_CYCLE()\r
 987     {\r
 988         pyr.build(src, 5);\r
 989     }\r
 990 }\r
 991 \r
 992 INSTANTIATE_TEST_CASE_P(ImgProc, ImagePyramid_build, testing::Combine(\r
 993                         ALL_DEVICES, \r
 994                         GPU_TYPICAL_MAT_SIZES,\r
 995                         testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));\r
 996 \r
 997 GPU_PERF_TEST(ImagePyramid_getLayer, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
 998 {\r
 999     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
1000     cv::Size size = GET_PARAM(1);\r
1001     int type = GET_PARAM(2);\r
1002 \r
1003     cv::gpu::setDevice(devInfo.deviceID());\r
1004 \r
1005     cv::Mat src_host(size, type);\r
1006 \r
1007     declare.in(src_host, WARMUP_RNG);\r
1008 \r
1009     cv::gpu::GpuMat src(src_host);\r
1010     cv::gpu::GpuMat dst;\r
1011 \r
1012     cv::gpu::ImagePyramid pyr(src, 3);\r
1013     \r
1014     TEST_CYCLE()\r
1015     {\r
1016         pyr.getLayer(dst, cv::Size(size.width / 2 + 10, size.height / 2 + 10));\r
1017     }\r
1018 }\r
1019 \r
1020 INSTANTIATE_TEST_CASE_P(ImgProc, ImagePyramid_getLayer, testing::Combine(\r
1021                         ALL_DEVICES, \r
1022                         GPU_TYPICAL_MAT_SIZES,\r
1023                         testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));\r
1024 \r
1025 #endif\r