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)\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 \r
 736     cv::gpu::setDevice(devInfo.deviceID());\r
 737 \r
 738     cv::gpu::GpuMat image = cv::gpu::createContinuous(size, CV_32FC1);\r
 739     cv::gpu::GpuMat templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);\r
 740 \r
 741     image.setTo(cv::Scalar(1.0));\r
 742     templ.setTo(cv::Scalar(1.0));\r
 743 \r
 744     cv::gpu::GpuMat dst;\r
 745     cv::gpu::ConvolveBuf buf;\r
 746 \r
 747     declare.time(2.0);\r
 748 \r
 749     TEST_CYCLE()\r
 750     {\r
 751         cv::gpu::convolve(image, templ, dst, false, buf);\r
 752     }\r
 753 }\r
 754 \r
 755 INSTANTIATE_TEST_CASE_P(ImgProc, Convolve, testing::Combine(\r
 756                         ALL_DEVICES, \r
 757                         GPU_TYPICAL_MAT_SIZES,\r
 758                         testing::Values(3, 9, 27, 32, 64)));\r
 759 \r
 760 //////////////////////////////////////////////////////////////////////\r
 761 // PyrDown\r
 762 \r
 763 GPU_PERF_TEST(PyrDown, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
 764 {\r
 765     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 766     cv::Size size = GET_PARAM(1);\r
 767     int type = GET_PARAM(2);\r
 768 \r
 769     cv::gpu::setDevice(devInfo.deviceID());\r
 770 \r
 771     cv::Mat src_host(size, type);\r
 772 \r
 773     declare.in(src_host, WARMUP_RNG);\r
 774 \r
 775     cv::gpu::GpuMat src(src_host);\r
 776     cv::gpu::GpuMat dst;\r
 777 \r
 778     TEST_CYCLE()\r
 779     {\r
 780         cv::gpu::pyrDown(src, dst);\r
 781     }\r
 782 }\r
 783 \r
 784 INSTANTIATE_TEST_CASE_P(ImgProc, PyrDown, testing::Combine(\r
 785                         ALL_DEVICES, \r
 786                         GPU_TYPICAL_MAT_SIZES,\r
 787                         testing::Values(CV_8UC1, CV_8UC4, CV_16SC3, CV_32FC1)));\r
 788 \r
 789 //////////////////////////////////////////////////////////////////////\r
 790 // PyrUp\r
 791 \r
 792 GPU_PERF_TEST(PyrUp, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
 793 {\r
 794     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 795     cv::Size size = GET_PARAM(1);\r
 796     int type = GET_PARAM(2);\r
 797 \r
 798     cv::gpu::setDevice(devInfo.deviceID());\r
 799 \r
 800     cv::Mat src_host(size, type);\r
 801 \r
 802     declare.in(src_host, WARMUP_RNG);\r
 803 \r
 804     cv::gpu::GpuMat src(src_host);\r
 805     cv::gpu::GpuMat dst;\r
 806 \r
 807     TEST_CYCLE()\r
 808     {\r
 809         cv::gpu::pyrUp(src, dst);\r
 810     }\r
 811 }\r
 812 \r
 813 INSTANTIATE_TEST_CASE_P(ImgProc, PyrUp, testing::Combine(\r
 814                         ALL_DEVICES, \r
 815                         GPU_TYPICAL_MAT_SIZES,\r
 816                         testing::Values(CV_8UC1, CV_8UC4, CV_16SC3, CV_32FC1)));\r
 817 \r
 818 //////////////////////////////////////////////////////////////////////\r
 819 // BlendLinear\r
 820 \r
 821 GPU_PERF_TEST(BlendLinear, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
 822 {\r
 823     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 824     cv::Size size = GET_PARAM(1);\r
 825     int type = GET_PARAM(2);\r
 826 \r
 827     cv::gpu::setDevice(devInfo.deviceID());\r
 828 \r
 829     cv::Mat img1_host(size, type);\r
 830     cv::Mat img2_host(size, type);\r
 831 \r
 832     declare.in(img1_host, img2_host, WARMUP_RNG);\r
 833 \r
 834     cv::gpu::GpuMat img1(img1_host);\r
 835     cv::gpu::GpuMat img2(img2_host);\r
 836     cv::gpu::GpuMat weights1(size, CV_32FC1, cv::Scalar::all(0.5));\r
 837     cv::gpu::GpuMat weights2(size, CV_32FC1, cv::Scalar::all(0.5));\r
 838     cv::gpu::GpuMat dst;\r
 839 \r
 840     TEST_CYCLE()\r
 841     {\r
 842         cv::gpu::blendLinear(img1, img2, weights1, weights2, dst);\r
 843     }\r
 844 }\r
 845 \r
 846 INSTANTIATE_TEST_CASE_P(ImgProc, BlendLinear, testing::Combine(\r
 847                         ALL_DEVICES, \r
 848                         GPU_TYPICAL_MAT_SIZES,\r
 849                         testing::Values(CV_8UC1, CV_32FC1)));\r
 850 \r
 851 //////////////////////////////////////////////////////////////////////\r
 852 // AlphaComp\r
 853 \r
 854 GPU_PERF_TEST(AlphaComp, cv::gpu::DeviceInfo, cv::Size, perf::MatType, AlphaOp)\r
 855 {\r
 856     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 857     cv::Size size = GET_PARAM(1);\r
 858     int type = GET_PARAM(2);\r
 859     int alpha_op = GET_PARAM(3);\r
 860 \r
 861     cv::gpu::setDevice(devInfo.deviceID());\r
 862 \r
 863     cv::Mat img1_host(size, type);\r
 864     cv::Mat img2_host(size, type);\r
 865 \r
 866     declare.in(img1_host, img2_host, WARMUP_RNG);\r
 867 \r
 868     cv::gpu::GpuMat img1(img1_host);\r
 869     cv::gpu::GpuMat img2(img2_host);\r
 870     cv::gpu::GpuMat dst;\r
 871 \r
 872     TEST_CYCLE()\r
 873     {\r
 874         cv::gpu::alphaComp(img1, img2, dst, alpha_op);\r
 875     }\r
 876 }\r
 877 \r
 878 INSTANTIATE_TEST_CASE_P(ImgProc, AlphaComp, testing::Combine(\r
 879                         ALL_DEVICES, \r
 880                         GPU_TYPICAL_MAT_SIZES,\r
 881                         testing::Values(CV_8UC4, CV_16UC4, CV_32SC4, CV_32FC4),\r
 882                         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
 883 \r
 884 //////////////////////////////////////////////////////////////////////\r
 885 // Canny\r
 886 \r
 887 GPU_PERF_TEST_1(Canny, cv::gpu::DeviceInfo)\r
 888 {\r
 889     cv::gpu::DeviceInfo devInfo = GetParam();\r
 890 \r
 891     cv::gpu::setDevice(devInfo.deviceID());\r
 892 \r
 893     cv::Mat image_host = readImage("perf/1280x1024.jpg", cv::IMREAD_GRAYSCALE);\r
 894     ASSERT_FALSE(image_host.empty());\r
 895 \r
 896     cv::gpu::GpuMat image(image_host);\r
 897     cv::gpu::GpuMat dst;\r
 898     cv::gpu::CannyBuf buf;\r
 899 \r
 900     TEST_CYCLE()\r
 901     {\r
 902         cv::gpu::Canny(image, buf, dst, 50.0, 100.0);\r
 903     }\r
 904 }\r
 905 \r
 906 INSTANTIATE_TEST_CASE_P(ImgProc, Canny, ALL_DEVICES);\r
 907 \r
 908 //////////////////////////////////////////////////////////////////////\r
 909 // CalcHist\r
 910 \r
 911 GPU_PERF_TEST(CalcHist, cv::gpu::DeviceInfo, cv::Size)\r
 912 {\r
 913     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 914     cv::Size size = GET_PARAM(1);\r
 915 \r
 916     cv::gpu::setDevice(devInfo.deviceID());\r
 917 \r
 918     cv::Mat src_host(size, CV_8UC1);\r
 919 \r
 920     declare.in(src_host, WARMUP_RNG);\r
 921 \r
 922     cv::gpu::GpuMat src(src_host);\r
 923     cv::gpu::GpuMat hist;\r
 924     cv::gpu::GpuMat buf;\r
 925 \r
 926     TEST_CYCLE()\r
 927     {\r
 928         cv::gpu::calcHist(src, hist, buf);\r
 929     }\r
 930 }\r
 931 \r
 932 INSTANTIATE_TEST_CASE_P(ImgProc, CalcHist, testing::Combine(\r
 933                         ALL_DEVICES, \r
 934                         GPU_TYPICAL_MAT_SIZES));\r
 935 \r
 936 //////////////////////////////////////////////////////////////////////\r
 937 // EqualizeHist\r
 938 \r
 939 GPU_PERF_TEST(EqualizeHist, cv::gpu::DeviceInfo, cv::Size)\r
 940 {\r
 941     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 942     cv::Size size = GET_PARAM(1);\r
 943 \r
 944     cv::gpu::setDevice(devInfo.deviceID());\r
 945 \r
 946     cv::Mat src_host(size, CV_8UC1);\r
 947 \r
 948     declare.in(src_host, WARMUP_RNG);\r
 949 \r
 950     cv::gpu::GpuMat src(src_host);\r
 951     cv::gpu::GpuMat dst;\r
 952     cv::gpu::GpuMat hist;\r
 953     cv::gpu::GpuMat buf;\r
 954 \r
 955     TEST_CYCLE()\r
 956     {\r
 957         cv::gpu::equalizeHist(src, dst, hist, buf);\r
 958     }\r
 959 }\r
 960 \r
 961 INSTANTIATE_TEST_CASE_P(ImgProc, EqualizeHist, testing::Combine(\r
 962                         ALL_DEVICES, \r
 963                         GPU_TYPICAL_MAT_SIZES));\r
 964 \r
 965 //////////////////////////////////////////////////////////////////////\r
 966 // ImagePyramid\r
 967 \r
 968 GPU_PERF_TEST(ImagePyramid_build, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
 969 {\r
 970     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 971     cv::Size size = GET_PARAM(1);\r
 972     int type = GET_PARAM(2);\r
 973 \r
 974     cv::gpu::setDevice(devInfo.deviceID());\r
 975 \r
 976     cv::Mat src_host(size, type);\r
 977 \r
 978     declare.in(src_host, WARMUP_RNG);\r
 979 \r
 980     cv::gpu::GpuMat src(src_host);\r
 981 \r
 982     cv::gpu::ImagePyramid pyr;\r
 983     \r
 984     TEST_CYCLE()\r
 985     {\r
 986         pyr.build(src, 5);\r
 987     }\r
 988 }\r
 989 \r
 990 INSTANTIATE_TEST_CASE_P(ImgProc, ImagePyramid_build, testing::Combine(\r
 991                         ALL_DEVICES, \r
 992                         GPU_TYPICAL_MAT_SIZES,\r
 993                         testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));\r
 994 \r
 995 GPU_PERF_TEST(ImagePyramid_getLayer, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
 996 {\r
 997     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 998     cv::Size size = GET_PARAM(1);\r
 999     int type = GET_PARAM(2);\r
1000 \r
1001     cv::gpu::setDevice(devInfo.deviceID());\r
1002 \r
1003     cv::Mat src_host(size, type);\r
1004 \r
1005     declare.in(src_host, WARMUP_RNG);\r
1006 \r
1007     cv::gpu::GpuMat src(src_host);\r
1008     cv::gpu::GpuMat dst;\r
1009 \r
1010     cv::gpu::ImagePyramid pyr(src, 3);\r
1011     \r
1012     TEST_CYCLE()\r
1013     {\r
1014         pyr.getLayer(dst, cv::Size(size.width / 2 + 10, size.height / 2 + 10));\r
1015     }\r
1016 }\r
1017 \r
1018 INSTANTIATE_TEST_CASE_P(ImgProc, ImagePyramid_getLayer, testing::Combine(\r
1019                         ALL_DEVICES, \r
1020                         GPU_TYPICAL_MAT_SIZES,\r
1021                         testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));\r
1022 \r
1023 #endif\r