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     const double aplha = CV_PI / 4;\r
 331     double mat[2][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},\r
 332                          {std::sin(aplha),  std::cos(aplha), 0}};\r
 333     cv::Mat M(2, 3, CV_64F, (void*) mat);\r
 334 \r
 335     TEST_CYCLE()\r
 336     {\r
 337         cv::gpu::warpAffine(src, dst, M, size, interpolation, cv::BORDER_CONSTANT, cv::Scalar());\r
 338     }\r
 339 }\r
 340 \r
 341 INSTANTIATE_TEST_CASE_P(ImgProc, WarpAffine, testing::Combine(\r
 342                         ALL_DEVICES,\r
 343                         GPU_TYPICAL_MAT_SIZES,\r
 344                         testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4),\r
 345                         testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC)));\r
 346 \r
 347 //////////////////////////////////////////////////////////////////////\r
 348 // WarpPerspective\r
 349 \r
 350 GPU_PERF_TEST(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation)\r
 351 {\r
 352     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 353     cv::Size size = GET_PARAM(1);\r
 354     int type = GET_PARAM(2);\r
 355     int interpolation = GET_PARAM(3);\r
 356 \r
 357     cv::gpu::setDevice(devInfo.deviceID());\r
 358 \r
 359     cv::Mat src_host(size, type);\r
 360 \r
 361     declare.in(src_host, WARMUP_RNG);\r
 362 \r
 363     cv::gpu::GpuMat src(src_host);\r
 364     cv::gpu::GpuMat dst;\r
 365 \r
 366     const double aplha = CV_PI / 4;\r
 367     double mat[3][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},\r
 368                          {std::sin(aplha),  std::cos(aplha), 0},\r
 369                          {0.0,              0.0,             1.0}};\r
 370     cv::Mat M(3, 3, CV_64F, (void*) mat);\r
 371 \r
 372     TEST_CYCLE()\r
 373     {\r
 374         cv::gpu::warpPerspective(src, dst, M, size, interpolation, cv::BORDER_CONSTANT, cv::Scalar());\r
 375     }\r
 376 }\r
 377 \r
 378 INSTANTIATE_TEST_CASE_P(ImgProc, WarpPerspective, testing::Combine(\r
 379                         ALL_DEVICES,\r
 380                         GPU_TYPICAL_MAT_SIZES,\r
 381                         testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4),\r
 382                         testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC)));\r
 383 \r
 384 //////////////////////////////////////////////////////////////////////\r
 385 // BuildWarpPlaneMaps\r
 386 \r
 387 GPU_PERF_TEST(BuildWarpPlaneMaps, 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::buildWarpPlaneMaps(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), cv::Mat::zeros(1, 3, CV_32F), 1.0, map_x, map_y);\r
 401     }\r
 402 }\r
 403 \r
 404 INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpPlaneMaps, testing::Combine(\r
 405                         ALL_DEVICES,\r
 406                         GPU_TYPICAL_MAT_SIZES));\r
 407 \r
 408 //////////////////////////////////////////////////////////////////////\r
 409 // BuildWarpCylindricalMaps\r
 410 \r
 411 GPU_PERF_TEST(BuildWarpCylindricalMaps, 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::buildWarpCylindricalMaps(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, BuildWarpCylindricalMaps, testing::Combine(\r
 429                         ALL_DEVICES,\r
 430                         GPU_TYPICAL_MAT_SIZES));\r
 431 \r
 432 //////////////////////////////////////////////////////////////////////\r
 433 // BuildWarpSphericalMaps\r
 434 \r
 435 GPU_PERF_TEST(BuildWarpSphericalMaps, cv::gpu::DeviceInfo, cv::Size)\r
 436 {\r
 437     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 438     cv::Size size = GET_PARAM(1);\r
 439 \r
 440     cv::gpu::setDevice(devInfo.deviceID());\r
 441 \r
 442     cv::gpu::GpuMat map_x;\r
 443     cv::gpu::GpuMat map_y;\r
 444 \r
 445     TEST_CYCLE()\r
 446     {\r
 447         cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), cv::Mat::eye(3, 3, CV_32FC1),\r
 448                                         cv::Mat::ones(3, 3, CV_32FC1), 1.0, map_x, map_y);\r
 449     }\r
 450 }\r
 451 \r
 452 INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpSphericalMaps, testing::Combine(\r
 453                         ALL_DEVICES,\r
 454                         GPU_TYPICAL_MAT_SIZES));\r
 455 \r
 456 //////////////////////////////////////////////////////////////////////\r
 457 // Rotate\r
 458 \r
 459 GPU_PERF_TEST(Rotate, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation)\r
 460 {\r
 461     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 462     cv::Size size = GET_PARAM(1);\r
 463     int type = GET_PARAM(2);\r
 464     int interpolation = GET_PARAM(3);\r
 465 \r
 466     cv::gpu::setDevice(devInfo.deviceID());\r
 467 \r
 468     cv::Mat src_host(size, type);\r
 469 \r
 470     declare.in(src_host, WARMUP_RNG);\r
 471 \r
 472     cv::gpu::GpuMat src(src_host);\r
 473     cv::gpu::GpuMat dst;\r
 474 \r
 475     TEST_CYCLE()\r
 476     {\r
 477         cv::gpu::rotate(src, dst, size, 30.0, 0, 0, interpolation);\r
 478     }\r
 479 }\r
 480 \r
 481 INSTANTIATE_TEST_CASE_P(ImgProc, Rotate, testing::Combine(\r
 482                         ALL_DEVICES,\r
 483                         GPU_TYPICAL_MAT_SIZES,\r
 484                         testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4),\r
 485                         testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC)));\r
 486 \r
 487 //////////////////////////////////////////////////////////////////////\r
 488 // CopyMakeBorder\r
 489 \r
 490 GPU_PERF_TEST(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, perf::MatType, BorderMode)\r
 491 {\r
 492     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 493     cv::Size size = GET_PARAM(1);\r
 494     int type = GET_PARAM(2);\r
 495     int borderType = GET_PARAM(3);\r
 496 \r
 497     cv::gpu::setDevice(devInfo.deviceID());\r
 498 \r
 499     cv::Mat src_host(size, type);\r
 500 \r
 501     declare.in(src_host, WARMUP_RNG);\r
 502 \r
 503     cv::gpu::GpuMat src(src_host);\r
 504     cv::gpu::GpuMat dst;\r
 505 \r
 506     TEST_CYCLE()\r
 507     {\r
 508         cv::gpu::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType);\r
 509     }\r
 510 }\r
 511 \r
 512 INSTANTIATE_TEST_CASE_P(ImgProc, CopyMakeBorder, testing::Combine(\r
 513                         ALL_DEVICES,\r
 514                         GPU_TYPICAL_MAT_SIZES,\r
 515                         testing::Values(CV_8UC1, CV_8UC4, CV_32FC1),\r
 516                         testing::Values((int) cv::BORDER_REPLICATE, (int) cv::BORDER_REFLECT, (int) cv::BORDER_WRAP, (int) cv::BORDER_CONSTANT)));\r
 517 \r
 518 //////////////////////////////////////////////////////////////////////\r
 519 // Integral\r
 520 \r
 521 GPU_PERF_TEST(Integral, cv::gpu::DeviceInfo, cv::Size)\r
 522 {\r
 523     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 524     cv::Size size = GET_PARAM(1);\r
 525 \r
 526     cv::gpu::setDevice(devInfo.deviceID());\r
 527 \r
 528     cv::Mat src_host(size, CV_8UC1);\r
 529 \r
 530     declare.in(src_host, WARMUP_RNG);\r
 531 \r
 532     cv::gpu::GpuMat src(src_host);\r
 533     cv::gpu::GpuMat dst;\r
 534     cv::gpu::GpuMat buf;\r
 535 \r
 536     TEST_CYCLE()\r
 537     {\r
 538         cv::gpu::integralBuffered(src, dst, buf);\r
 539     }\r
 540 }\r
 541 \r
 542 INSTANTIATE_TEST_CASE_P(ImgProc, Integral, testing::Combine(\r
 543                         ALL_DEVICES,\r
 544                         GPU_TYPICAL_MAT_SIZES));\r
 545 \r
 546 //////////////////////////////////////////////////////////////////////\r
 547 // IntegralSqr\r
 548 \r
 549 GPU_PERF_TEST(IntegralSqr, cv::gpu::DeviceInfo, cv::Size)\r
 550 {\r
 551     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 552     cv::Size size = GET_PARAM(1);\r
 553 \r
 554     cv::gpu::setDevice(devInfo.deviceID());\r
 555 \r
 556     cv::Mat src_host(size, CV_8UC1);\r
 557 \r
 558     declare.in(src_host, WARMUP_RNG);\r
 559 \r
 560     cv::gpu::GpuMat src(src_host);\r
 561     cv::gpu::GpuMat dst;\r
 562 \r
 563     TEST_CYCLE()\r
 564     {\r
 565         cv::gpu::sqrIntegral(src, dst);\r
 566     }\r
 567 }\r
 568 \r
 569 INSTANTIATE_TEST_CASE_P(ImgProc, IntegralSqr, testing::Combine(\r
 570                         ALL_DEVICES,\r
 571                         GPU_TYPICAL_MAT_SIZES));\r
 572 \r
 573 //////////////////////////////////////////////////////////////////////\r
 574 // ColumnSum\r
 575 \r
 576 GPU_PERF_TEST(ColumnSum, cv::gpu::DeviceInfo, cv::Size)\r
 577 {\r
 578     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 579     cv::Size size = GET_PARAM(1);\r
 580 \r
 581     cv::gpu::setDevice(devInfo.deviceID());\r
 582 \r
 583     cv::Mat src_host(size, CV_32FC1);\r
 584 \r
 585     declare.in(src_host, WARMUP_RNG);\r
 586 \r
 587     cv::gpu::GpuMat src(src_host);\r
 588     cv::gpu::GpuMat dst;\r
 589 \r
 590     TEST_CYCLE()\r
 591     {\r
 592         cv::gpu::columnSum(src, dst);\r
 593     }\r
 594 }\r
 595 \r
 596 INSTANTIATE_TEST_CASE_P(ImgProc, ColumnSum, testing::Combine(\r
 597                         ALL_DEVICES,\r
 598                         GPU_TYPICAL_MAT_SIZES));\r
 599 \r
 600 //////////////////////////////////////////////////////////////////////\r
 601 // CornerHarris\r
 602 \r
 603 GPU_PERF_TEST(CornerHarris, cv::gpu::DeviceInfo, perf::MatType)\r
 604 {\r
 605     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 606     int type = GET_PARAM(1);\r
 607 \r
 608     cv::gpu::setDevice(devInfo.deviceID());\r
 609 \r
 610     cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);\r
 611     ASSERT_FALSE(img.empty());\r
 612 \r
 613     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
 614 \r
 615     cv::gpu::GpuMat src(img);\r
 616     cv::gpu::GpuMat dst;\r
 617     cv::gpu::GpuMat Dx;\r
 618     cv::gpu::GpuMat Dy;\r
 619 \r
 620     int blockSize = 3;\r
 621     int ksize = 7;\r
 622     double k = 0.5;\r
 623 \r
 624     TEST_CYCLE()\r
 625     {\r
 626         cv::gpu::cornerHarris(src, dst, Dx, Dy, blockSize, ksize, k);\r
 627     }\r
 628 }\r
 629 \r
 630 INSTANTIATE_TEST_CASE_P(ImgProc, CornerHarris, testing::Combine(\r
 631                         ALL_DEVICES,\r
 632                         testing::Values(CV_8UC1, CV_32FC1)));\r
 633 \r
 634 //////////////////////////////////////////////////////////////////////\r
 635 // CornerMinEigenVal\r
 636 \r
 637 GPU_PERF_TEST(CornerMinEigenVal, cv::gpu::DeviceInfo, perf::MatType)\r
 638 {\r
 639     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 640     int type = GET_PARAM(1);\r
 641 \r
 642     cv::gpu::setDevice(devInfo.deviceID());\r
 643 \r
 644     cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);\r
 645     ASSERT_FALSE(img.empty());\r
 646 \r
 647     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
 648 \r
 649     cv::gpu::GpuMat src(img);\r
 650     cv::gpu::GpuMat dst;\r
 651     cv::gpu::GpuMat Dx;\r
 652     cv::gpu::GpuMat Dy;\r
 653 \r
 654     int blockSize = 3;\r
 655     int ksize = 7;\r
 656 \r
 657     TEST_CYCLE()\r
 658     {\r
 659         cv::gpu::cornerMinEigenVal(src, dst, Dx, Dy, blockSize, ksize);\r
 660     }\r
 661 }\r
 662 \r
 663 INSTANTIATE_TEST_CASE_P(ImgProc, CornerMinEigenVal, testing::Combine(\r
 664                         ALL_DEVICES,\r
 665                         testing::Values(CV_8UC1, CV_32FC1)));\r
 666 \r
 667 //////////////////////////////////////////////////////////////////////\r
 668 // MulSpectrums\r
 669 \r
 670 GPU_PERF_TEST(MulSpectrums, cv::gpu::DeviceInfo, cv::Size)\r
 671 {\r
 672     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 673     cv::Size size = GET_PARAM(1);\r
 674 \r
 675     cv::gpu::setDevice(devInfo.deviceID());\r
 676 \r
 677     cv::Mat a_host(size, CV_32FC2);\r
 678     cv::Mat b_host(size, CV_32FC2);\r
 679 \r
 680     declare.in(a_host, b_host, WARMUP_RNG);\r
 681 \r
 682     cv::gpu::GpuMat a(a_host);\r
 683     cv::gpu::GpuMat b(b_host);\r
 684     cv::gpu::GpuMat dst;\r
 685 \r
 686     TEST_CYCLE()\r
 687     {\r
 688         cv::gpu::mulSpectrums(a, b, dst, 0);\r
 689     }\r
 690 }\r
 691 \r
 692 INSTANTIATE_TEST_CASE_P(ImgProc, MulSpectrums, testing::Combine(\r
 693                         ALL_DEVICES,\r
 694                         GPU_TYPICAL_MAT_SIZES));\r
 695 \r
 696 //////////////////////////////////////////////////////////////////////\r
 697 // Dft\r
 698 \r
 699 GPU_PERF_TEST(Dft, cv::gpu::DeviceInfo, cv::Size)\r
 700 {\r
 701     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 702     cv::Size size = GET_PARAM(1);\r
 703 \r
 704     cv::gpu::setDevice(devInfo.deviceID());\r
 705 \r
 706     cv::Mat src_host(size, CV_32FC2);\r
 707 \r
 708     declare.in(src_host, WARMUP_RNG);\r
 709 \r
 710     cv::gpu::GpuMat src(src_host);\r
 711     cv::gpu::GpuMat dst;\r
 712 \r
 713     declare.time(2.0);\r
 714 \r
 715     TEST_CYCLE()\r
 716     {\r
 717         cv::gpu::dft(src, dst, size);\r
 718     }\r
 719 }\r
 720 \r
 721 INSTANTIATE_TEST_CASE_P(ImgProc, Dft, testing::Combine(\r
 722                         ALL_DEVICES,\r
 723                         GPU_TYPICAL_MAT_SIZES));\r
 724 \r
 725 //////////////////////////////////////////////////////////////////////\r
 726 // Convolve\r
 727 \r
 728 GPU_PERF_TEST(Convolve, cv::gpu::DeviceInfo, cv::Size, int, bool)\r
 729 {\r
 730     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
 731     cv::Size size = GET_PARAM(1);\r
 732     int templ_size = GET_PARAM(2);\r
 733     bool ccorr = GET_PARAM(3);\r
 734 \r
 735     cv::gpu::setDevice(devInfo.deviceID());\r
 736 \r
 737     cv::gpu::GpuMat image = cv::gpu::createContinuous(size, CV_32FC1);\r
 738     cv::gpu::GpuMat templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);\r
 739 \r
 740     image.setTo(cv::Scalar(1.0));\r
 741     templ.setTo(cv::Scalar(1.0));\r
 742 \r
 743     cv::gpu::GpuMat dst;\r
 744     cv::gpu::ConvolveBuf buf;\r
 745 \r
 746     declare.time(2.0);\r
 747 \r
 748     TEST_CYCLE()\r
 749     {\r
 750         cv::gpu::convolve(image, templ, dst, ccorr, buf);\r
 751     }\r
 752 }\r
 753 \r
 754 INSTANTIATE_TEST_CASE_P(ImgProc, Convolve, testing::Combine(\r
 755                         ALL_DEVICES,\r
 756                         GPU_TYPICAL_MAT_SIZES,\r
 757                         testing::Values(3, 9, 27, 32, 64),\r
 758                         testing::Bool()));\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 \r
1024 \r
1025 //////////////////////////////////////////////////////////////////////\r
1026 // MulAndScaleSpectrums\r
1027 \r
1028 GPU_PERF_TEST(MulAndScaleSpectrums, cv::gpu::DeviceInfo, cv::Size)\r
1029 {\r
1030     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
1031     cv::Size size = GET_PARAM(1);\r
1032         \r
1033     cv::gpu::setDevice(devInfo.deviceID());\r
1034 \r
1035     int type = CV_32FC2;\r
1036 \r
1037     cv::Mat src1_host(size, type);\r
1038     cv::Mat src2_host(size, type);\r
1039     declare.in(src1_host, src2_host, WARMUP_RNG);\r
1040 \r
1041     cv::gpu::GpuMat src1(src1_host);\r
1042     cv::gpu::GpuMat src2(src2_host);\r
1043     cv::gpu::GpuMat dst(size, type);\r
1044     \r
1045     TEST_CYCLE()\r
1046     {        \r
1047         cv::gpu::mulSpectrums(src1, src2, dst, cv::DFT_ROWS, false);\r
1048     }\r
1049 }\r
1050 \r
1051 INSTANTIATE_TEST_CASE_P(ImgProc, MulAndScaleSpectrums, testing::Combine(\r
1052                         ALL_DEVICES,\r
1053                         GPU_TYPICAL_MAT_SIZES));\r
1054 \r
1055 \r
1056 \r
1057 //////////////////////////////////////////////////////////////////////\r
1058 // MulAndScaleSpectrumsScale\r
1059 \r
1060 \r
1061 GPU_PERF_TEST(MulAndScaleSpectrumsScale, cv::gpu::DeviceInfo, cv::Size)\r
1062 {\r
1063     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
1064     cv::Size size = GET_PARAM(1);\r
1065 \r
1066     float scale = 1.f / size.area();\r
1067     int type = CV_32FC2;\r
1068     \r
1069     cv::gpu::setDevice(devInfo.deviceID());\r
1070 \r
1071     cv::Mat src1_host(size, type);\r
1072     cv::Mat src2_host(size, type);\r
1073     declare.in(src1_host, src2_host, WARMUP_RNG);\r
1074 \r
1075     cv::gpu::GpuMat src1(src1_host);\r
1076     cv::gpu::GpuMat src2(src2_host);\r
1077     cv::gpu::GpuMat dst(size, type);\r
1078     \r
1079     TEST_CYCLE()\r
1080     {        \r
1081         cv::gpu::mulAndScaleSpectrums(src1, src2, dst, cv::DFT_ROWS, scale, false);\r
1082     }\r
1083 }\r
1084 \r
1085 INSTANTIATE_TEST_CASE_P(ImgProc, MulAndScaleSpectrumsScale, testing::Combine(\r
1086                         ALL_DEVICES,\r
1087                         GPU_TYPICAL_MAT_SIZES));\r
1088 \r
1089 \r
1090 \r
1091 \r
1092 #endif\r