modules/gpu/perf/perf_imgproc.cpp

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