modules/gpu/perf_cpu/perf_imgproc.cpp

   1 #include "perf_cpu_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::Size size = GET_PARAM(1);\r
  11     int type = GET_PARAM(2);\r
  12     int interpolation = GET_PARAM(3);\r
  13     int borderMode = GET_PARAM(4);\r
  14 \r
  15     cv::Mat src(size, type);\r
  16     fill(src, 0, 255);\r
  17 \r
  18     cv::Mat xmap(size, CV_32FC1);\r
  19     fill(xmap, 0, size.width);\r
  20 \r
  21     cv::Mat ymap(size, CV_32FC1);\r
  22     fill(ymap, 0, size.height);\r
  23 \r
  24     cv::Mat dst;\r
  25 \r
  26     cv::remap(src, dst, xmap, ymap, interpolation, borderMode);\r
  27 \r
  28     declare.time(20.0);\r
  29 \r
  30     TEST_CYCLE()\r
  31     {\r
  32         cv::remap(src, dst, xmap, ymap, interpolation, borderMode);\r
  33     }\r
  34 }\r
  35 \r
  36 INSTANTIATE_TEST_CASE_P(ImgProc, Remap, testing::Combine(\r
  37     ALL_DEVICES,\r
  38     GPU_TYPICAL_MAT_SIZES,\r
  39     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
  40                     MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
  41                     MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
  42     testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),\r
  43     testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));\r
  44 \r
  45 \r
  46 //////////////////////////////////////////////////////////////////////\r
  47 // Resize\r
  48 \r
  49 IMPLEMENT_PARAM_CLASS(Scale, double)\r
  50 \r
  51 GPU_PERF_TEST(Resize, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, Scale)\r
  52 {\r
  53     cv::Size size = GET_PARAM(1);\r
  54     int type = GET_PARAM(2);\r
  55     int interpolation = GET_PARAM(3);\r
  56     double f = GET_PARAM(4);\r
  57 \r
  58     cv::Mat src(size, type);\r
  59     fill(src, 0, 255);\r
  60 \r
  61     cv::Mat dst;\r
  62 \r
  63     cv::resize(src, dst, cv::Size(), f, f, interpolation);\r
  64 \r
  65     declare.time(20.0);\r
  66 \r
  67     TEST_CYCLE()\r
  68     {\r
  69         cv::resize(src, dst, cv::Size(), f, f, interpolation);\r
  70     }\r
  71 }\r
  72 \r
  73 INSTANTIATE_TEST_CASE_P(ImgProc, Resize, testing::Combine(\r
  74     ALL_DEVICES,\r
  75     GPU_TYPICAL_MAT_SIZES,\r
  76     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
  77                     MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
  78                     MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
  79     testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),\r
  80     testing::Values(Scale(0.5), Scale(2.0))));\r
  81 \r
  82 //////////////////////////////////////////////////////////////////////\r
  83 // WarpAffine\r
  84 \r
  85 GPU_PERF_TEST(WarpAffine, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, BorderMode)\r
  86 {\r
  87     cv::Size size = GET_PARAM(1);\r
  88     int type = GET_PARAM(2);\r
  89     int interpolation = GET_PARAM(3);\r
  90     int borderMode = GET_PARAM(4);\r
  91 \r
  92     cv::Mat src(size, type);\r
  93     fill(src, 0, 255);\r
  94 \r
  95     cv::Mat dst;\r
  96 \r
  97     const double aplha = CV_PI / 4;\r
  98     double mat[2][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},\r
  99                          {std::sin(aplha),  std::cos(aplha), 0}};\r
 100     cv::Mat M(2, 3, CV_64F, (void*) mat);\r
 101 \r
 102     cv::warpAffine(src, dst, M, size, interpolation, borderMode);\r
 103 \r
 104     declare.time(20.0);\r
 105 \r
 106     TEST_CYCLE()\r
 107     {\r
 108         cv::warpAffine(src, dst, M, size, interpolation, borderMode);\r
 109     }\r
 110 }\r
 111 \r
 112 INSTANTIATE_TEST_CASE_P(ImgProc, WarpAffine, testing::Combine(\r
 113     ALL_DEVICES,\r
 114     GPU_TYPICAL_MAT_SIZES,\r
 115     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
 116                     MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
 117                     MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
 118     testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),\r
 119     testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));\r
 120 \r
 121 //////////////////////////////////////////////////////////////////////\r
 122 // WarpPerspective\r
 123 \r
 124 GPU_PERF_TEST(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, BorderMode)\r
 125 {\r
 126     cv::Size size = GET_PARAM(1);\r
 127     int type = GET_PARAM(2);\r
 128     int interpolation = GET_PARAM(3);\r
 129     int borderMode = GET_PARAM(4);\r
 130 \r
 131     cv::Mat src(size, type);\r
 132     fill(src, 0, 255);\r
 133 \r
 134     cv::Mat dst;\r
 135 \r
 136     const double aplha = CV_PI / 4;\r
 137     double mat[3][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},\r
 138                          {std::sin(aplha),  std::cos(aplha), 0},\r
 139                          {0.0,              0.0,             1.0}};\r
 140     cv::Mat M(3, 3, CV_64F, (void*) mat);\r
 141 \r
 142     cv::warpPerspective(src, dst, M, size, interpolation, borderMode);\r
 143 \r
 144     declare.time(20.0);\r
 145 \r
 146     TEST_CYCLE()\r
 147     {\r
 148         cv::warpPerspective(src, dst, M, size, interpolation, borderMode);\r
 149     }\r
 150 }\r
 151 \r
 152 INSTANTIATE_TEST_CASE_P(ImgProc, WarpPerspective, testing::Combine(\r
 153     ALL_DEVICES,\r
 154     GPU_TYPICAL_MAT_SIZES,\r
 155     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
 156                     MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
 157                     MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
 158     testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),\r
 159     testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));\r
 160 \r
 161 //////////////////////////////////////////////////////////////////////\r
 162 // CopyMakeBorder\r
 163 \r
 164 GPU_PERF_TEST(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, MatType, BorderMode)\r
 165 {\r
 166     cv::Size size = GET_PARAM(1);\r
 167     int type = GET_PARAM(2);\r
 168     int borderType = GET_PARAM(3);\r
 169 \r
 170     cv::Mat src(size, type);\r
 171     fill(src, 0, 255);\r
 172 \r
 173     cv::Mat dst;\r
 174 \r
 175     cv::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType);\r
 176 \r
 177     TEST_CYCLE()\r
 178     {\r
 179         cv::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType);\r
 180     }\r
 181 }\r
 182 \r
 183 INSTANTIATE_TEST_CASE_P(ImgProc, CopyMakeBorder, testing::Combine(\r
 184     ALL_DEVICES,\r
 185     GPU_TYPICAL_MAT_SIZES,\r
 186     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
 187                     MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
 188                     MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
 189     testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));\r
 190 \r
 191 //////////////////////////////////////////////////////////////////////\r
 192 // Threshold\r
 193 \r
 194 CV_ENUM(ThreshOp, cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV)\r
 195 #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
 196 \r
 197 GPU_PERF_TEST(Threshold, cv::gpu::DeviceInfo, cv::Size, MatDepth, ThreshOp)\r
 198 {\r
 199     cv::Size size = GET_PARAM(1);\r
 200     int depth = GET_PARAM(2);\r
 201     int threshOp = GET_PARAM(3);\r
 202 \r
 203     cv::Mat src(size, depth);\r
 204     fill(src, 0, 255);\r
 205 \r
 206     cv::Mat dst;\r
 207 \r
 208     cv::threshold(src, dst, 100.0, 255.0, threshOp);\r
 209 \r
 210     TEST_CYCLE()\r
 211     {\r
 212         cv::threshold(src, dst, 100.0, 255.0, threshOp);\r
 213     }\r
 214 }\r
 215 \r
 216 INSTANTIATE_TEST_CASE_P(ImgProc, Threshold, testing::Combine(\r
 217     ALL_DEVICES,\r
 218     GPU_TYPICAL_MAT_SIZES,\r
 219     testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F), MatDepth(CV_64F)),\r
 220     ALL_THRESH_OPS));\r
 221 \r
 222 //////////////////////////////////////////////////////////////////////\r
 223 // Integral\r
 224 \r
 225 GPU_PERF_TEST(Integral, cv::gpu::DeviceInfo, cv::Size)\r
 226 {\r
 227     cv::Size size = GET_PARAM(1);\r
 228 \r
 229     cv::Mat src(size, CV_8UC1);\r
 230     fill(src, 0, 255);\r
 231 \r
 232     cv::Mat dst;\r
 233 \r
 234     cv::integral(src, dst);\r
 235 \r
 236     TEST_CYCLE()\r
 237     {\r
 238         cv::integral(src, dst);\r
 239     }\r
 240 }\r
 241 \r
 242 INSTANTIATE_TEST_CASE_P(ImgProc, Integral, testing::Combine(\r
 243     ALL_DEVICES,\r
 244     GPU_TYPICAL_MAT_SIZES));\r
 245 \r
 246 //////////////////////////////////////////////////////////////////////\r
 247 // HistEven_OneChannel\r
 248 \r
 249 GPU_PERF_TEST(HistEven_OneChannel, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
 250 {\r
 251     cv::Size size = GET_PARAM(1);\r
 252     int depth = GET_PARAM(2);\r
 253 \r
 254     cv::Mat src(size, depth);\r
 255     fill(src, 0, 255);\r
 256 \r
 257     int hbins = 30;\r
 258     float hranges[] = {0.0f, 180.0f};\r
 259     cv::Mat hist;\r
 260     int histSize[] = {hbins};\r
 261     const float* ranges[] = {hranges};\r
 262     int channels[] = {0};\r
 263 \r
 264     cv::calcHist(&src, 1, channels, cv::Mat(), hist, 1, histSize, ranges);\r
 265 \r
 266     TEST_CYCLE()\r
 267     {\r
 268         cv::calcHist(&src, 1, channels, cv::Mat(), hist, 1, histSize, ranges);\r
 269     }\r
 270 }\r
 271 \r
 272 INSTANTIATE_TEST_CASE_P(ImgProc, HistEven_OneChannel, testing::Combine(\r
 273     ALL_DEVICES,\r
 274     GPU_TYPICAL_MAT_SIZES,\r
 275     testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S))));\r
 276 \r
 277 //////////////////////////////////////////////////////////////////////\r
 278 // EqualizeHist\r
 279 \r
 280 GPU_PERF_TEST(EqualizeHist, cv::gpu::DeviceInfo, cv::Size)\r
 281 {\r
 282     cv::Size size = GET_PARAM(1);\r
 283 \r
 284     cv::Mat src(size, CV_8UC1);\r
 285     fill(src, 0, 255);\r
 286 \r
 287     cv::Mat dst;\r
 288 \r
 289     cv::equalizeHist(src, dst);\r
 290 \r
 291     TEST_CYCLE()\r
 292     {\r
 293         cv::equalizeHist(src, dst);\r
 294     }\r
 295 }\r
 296 \r
 297 INSTANTIATE_TEST_CASE_P(ImgProc, EqualizeHist, testing::Combine(\r
 298     ALL_DEVICES,\r
 299     GPU_TYPICAL_MAT_SIZES));\r
 300 \r
 301 //////////////////////////////////////////////////////////////////////\r
 302 // Canny\r
 303 \r
 304 IMPLEMENT_PARAM_CLASS(AppertureSize, int)\r
 305 IMPLEMENT_PARAM_CLASS(L2gradient, bool)\r
 306 \r
 307 GPU_PERF_TEST(Canny, cv::gpu::DeviceInfo, AppertureSize, L2gradient)\r
 308 {\r
 309     int apperture_size = GET_PARAM(1);\r
 310     bool useL2gradient = GET_PARAM(2);\r
 311 \r
 312     cv::Mat image = readImage("perf/1280x1024.jpg", cv::IMREAD_GRAYSCALE);\r
 313     ASSERT_FALSE(image.empty());\r
 314 \r
 315     cv::Mat dst;\r
 316 \r
 317     cv::Canny(image, dst, 50.0, 100.0, apperture_size, useL2gradient);\r
 318 \r
 319     TEST_CYCLE()\r
 320     {\r
 321         cv::Canny(image, dst, 50.0, 100.0, apperture_size, useL2gradient);\r
 322     }\r
 323 }\r
 324 \r
 325 INSTANTIATE_TEST_CASE_P(ImgProc, Canny, testing::Combine(\r
 326     ALL_DEVICES,\r
 327     testing::Values(AppertureSize(3), AppertureSize(5)),\r
 328     testing::Values(L2gradient(false), L2gradient(true))));\r
 329 \r
 330 //////////////////////////////////////////////////////////////////////\r
 331 // MeanShiftFiltering\r
 332 \r
 333 GPU_PERF_TEST_1(MeanShiftFiltering, cv::gpu::DeviceInfo)\r
 334 {\r
 335     cv::Mat img = readImage("gpu/meanshift/cones.png");\r
 336     ASSERT_FALSE(img.empty());\r
 337 \r
 338     cv::Mat dst;\r
 339 \r
 340     cv::pyrMeanShiftFiltering(img, dst, 50, 50);\r
 341 \r
 342     declare.time(15.0);\r
 343 \r
 344     TEST_CYCLE()\r
 345     {\r
 346         cv::pyrMeanShiftFiltering(img, dst, 50, 50);\r
 347     }\r
 348 }\r
 349 \r
 350 INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftFiltering, ALL_DEVICES);\r
 351 \r
 352 //////////////////////////////////////////////////////////////////////\r
 353 // Convolve\r
 354 \r
 355 IMPLEMENT_PARAM_CLASS(KSize, int)\r
 356 IMPLEMENT_PARAM_CLASS(Ccorr, bool)\r
 357 \r
 358 GPU_PERF_TEST(Convolve, cv::gpu::DeviceInfo, cv::Size, KSize, Ccorr)\r
 359 {\r
 360     cv::Size size = GET_PARAM(1);\r
 361     int templ_size = GET_PARAM(2);\r
 362     bool ccorr = GET_PARAM(3);\r
 363 \r
 364     ASSERT_FALSE(ccorr);\r
 365 \r
 366     cv::Mat image(size, CV_32FC1);\r
 367     image.setTo(1.0);\r
 368 \r
 369     cv::Mat templ(templ_size, templ_size, CV_32FC1);\r
 370     templ.setTo(1.0);\r
 371 \r
 372     cv::Mat dst;\r
 373 \r
 374     cv::filter2D(image, dst, image.depth(), templ);\r
 375 \r
 376     declare.time(10.0);\r
 377 \r
 378     TEST_CYCLE()\r
 379     {\r
 380         cv::filter2D(image, dst, image.depth(), templ);\r
 381     }\r
 382 }\r
 383 \r
 384 INSTANTIATE_TEST_CASE_P(ImgProc, Convolve, testing::Combine(\r
 385     ALL_DEVICES,\r
 386     GPU_TYPICAL_MAT_SIZES,\r
 387     testing::Values(KSize(3), KSize(9), KSize(17), KSize(27), KSize(32), KSize(64)),\r
 388     testing::Values(Ccorr(false), Ccorr(true))));\r
 389 \r
 390 ////////////////////////////////////////////////////////////////////////////////\r
 391 // MatchTemplate_8U\r
 392 \r
 393 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
 394 #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
 395 \r
 396 IMPLEMENT_PARAM_CLASS(TemplateSize, cv::Size)\r
 397 \r
 398 GPU_PERF_TEST(MatchTemplate_8U, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Channels, TemplateMethod)\r
 399 {\r
 400     cv::Size size = GET_PARAM(1);\r
 401     cv::Size templ_size = GET_PARAM(2);\r
 402     int cn = GET_PARAM(3);\r
 403     int method = GET_PARAM(4);\r
 404 \r
 405     cv::Mat image(size, CV_MAKE_TYPE(CV_8U, cn));\r
 406     fill(image, 0, 255);\r
 407 \r
 408     cv::Mat templ(templ_size, CV_MAKE_TYPE(CV_8U, cn));\r
 409     fill(templ, 0, 255);\r
 410 \r
 411     cv::Mat dst;\r
 412 \r
 413     cv::matchTemplate(image, templ, dst, method);\r
 414 \r
 415     TEST_CYCLE()\r
 416     {\r
 417         cv::matchTemplate(image, templ, dst, method);\r
 418     }\r
 419 };\r
 420 \r
 421 INSTANTIATE_TEST_CASE_P(ImgProc, MatchTemplate_8U, testing::Combine(\r
 422     ALL_DEVICES,\r
 423     GPU_TYPICAL_MAT_SIZES,\r
 424     testing::Values(TemplateSize(cv::Size(5, 5)), TemplateSize(cv::Size(16, 16)), TemplateSize(cv::Size(30, 30))),\r
 425     testing::Values(Channels(1), Channels(3), Channels(4)),\r
 426     ALL_TEMPLATE_METHODS));\r
 427 \r
 428 ////////////////////////////////////////////////////////////////////////////////\r
 429 // MatchTemplate_32F\r
 430 \r
 431 GPU_PERF_TEST(MatchTemplate_32F, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Channels, TemplateMethod)\r
 432 {\r
 433     cv::Size size = GET_PARAM(1);\r
 434     cv::Size templ_size = GET_PARAM(2);\r
 435     int cn = GET_PARAM(3);\r
 436     int method = GET_PARAM(4);\r
 437 \r
 438     cv::Mat image(size, CV_MAKE_TYPE(CV_32F, cn));\r
 439     fill(image, 0, 255);\r
 440 \r
 441     cv::Mat templ(templ_size, CV_MAKE_TYPE(CV_32F, cn));\r
 442     fill(templ, 0, 255);\r
 443 \r
 444     cv::Mat dst;\r
 445 \r
 446     cv::matchTemplate(image, templ, dst, method);\r
 447 \r
 448     TEST_CYCLE()\r
 449     {\r
 450         cv::matchTemplate(image, templ, dst, method);\r
 451     }\r
 452 };\r
 453 \r
 454 INSTANTIATE_TEST_CASE_P(ImgProc, MatchTemplate_32F, testing::Combine(\r
 455     ALL_DEVICES,\r
 456     GPU_TYPICAL_MAT_SIZES,\r
 457     testing::Values(TemplateSize(cv::Size(5, 5)), TemplateSize(cv::Size(16, 16)), TemplateSize(cv::Size(30, 30))),\r
 458     testing::Values(Channels(1), Channels(3), Channels(4)),\r
 459     testing::Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_CCORR))));\r
 460 \r
 461 //////////////////////////////////////////////////////////////////////\r
 462 // MulSpectrums\r
 463 \r
 464 CV_FLAGS(DftFlags, 0, cv::DFT_INVERSE, cv::DFT_SCALE, cv::DFT_ROWS, cv::DFT_COMPLEX_OUTPUT, cv::DFT_REAL_OUTPUT)\r
 465 \r
 466 GPU_PERF_TEST(MulSpectrums, cv::gpu::DeviceInfo, cv::Size, DftFlags)\r
 467 {\r
 468     cv::Size size = GET_PARAM(1);\r
 469     int flag = GET_PARAM(2);\r
 470 \r
 471     cv::Mat a(size, CV_32FC2);\r
 472     fill(a, 0, 100);\r
 473 \r
 474     cv::Mat b(size, CV_32FC2);\r
 475     fill(b, 0, 100);\r
 476 \r
 477     cv::Mat dst;\r
 478 \r
 479     cv::mulSpectrums(a, b, dst, flag);\r
 480 \r
 481     TEST_CYCLE()\r
 482     {\r
 483         cv::mulSpectrums(a, b, dst, flag);\r
 484     }\r
 485 }\r
 486 \r
 487 INSTANTIATE_TEST_CASE_P(ImgProc, MulSpectrums, testing::Combine(\r
 488     ALL_DEVICES,\r
 489     GPU_TYPICAL_MAT_SIZES,\r
 490     testing::Values(DftFlags(0), DftFlags(cv::DFT_ROWS))));\r
 491 \r
 492 //////////////////////////////////////////////////////////////////////\r
 493 // Dft\r
 494 \r
 495 GPU_PERF_TEST(Dft, cv::gpu::DeviceInfo, cv::Size, DftFlags)\r
 496 {\r
 497     cv::Size size = GET_PARAM(1);\r
 498     int flag = GET_PARAM(2);\r
 499 \r
 500     cv::Mat src(size, CV_32FC2);\r
 501     fill(src, 0, 100);\r
 502 \r
 503     cv::Mat dst;\r
 504 \r
 505     cv::dft(src, dst, flag);\r
 506 \r
 507     declare.time(10.0);\r
 508 \r
 509     TEST_CYCLE()\r
 510     {\r
 511         cv::dft(src, dst, flag);\r
 512     }\r
 513 }\r
 514 \r
 515 INSTANTIATE_TEST_CASE_P(ImgProc, Dft, testing::Combine(\r
 516     ALL_DEVICES,\r
 517     GPU_TYPICAL_MAT_SIZES,\r
 518     testing::Values(DftFlags(0), DftFlags(cv::DFT_ROWS), DftFlags(cv::DFT_INVERSE))));\r
 519 \r
 520 //////////////////////////////////////////////////////////////////////\r
 521 // CornerHarris\r
 522 \r
 523 IMPLEMENT_PARAM_CLASS(BlockSize, int)\r
 524 IMPLEMENT_PARAM_CLASS(ApertureSize, int)\r
 525 \r
 526 GPU_PERF_TEST(CornerHarris, cv::gpu::DeviceInfo, MatType, BorderMode, BlockSize, ApertureSize)\r
 527 {\r
 528     int type = GET_PARAM(1);\r
 529     int borderType = GET_PARAM(2);\r
 530     int blockSize = GET_PARAM(3);\r
 531     int apertureSize = GET_PARAM(4);\r
 532 \r
 533     cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);\r
 534     ASSERT_FALSE(img.empty());\r
 535 \r
 536     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
 537 \r
 538     cv::Mat dst;\r
 539 \r
 540     double k = 0.5;\r
 541 \r
 542     cv::cornerHarris(img, dst, blockSize, apertureSize, k, borderType);\r
 543 \r
 544     TEST_CYCLE()\r
 545     {\r
 546         cv::cornerHarris(img, dst, blockSize, apertureSize, k, borderType);\r
 547     }\r
 548 }\r
 549 \r
 550 INSTANTIATE_TEST_CASE_P(ImgProc, CornerHarris, testing::Combine(\r
 551     ALL_DEVICES,\r
 552     testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),\r
 553     testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_REFLECT)),\r
 554     testing::Values(BlockSize(3), BlockSize(5), BlockSize(7)),\r
 555     testing::Values(ApertureSize(0), ApertureSize(3), ApertureSize(5), ApertureSize(7))));\r
 556 \r
 557 //////////////////////////////////////////////////////////////////////\r
 558 // CornerMinEigenVal\r
 559 \r
 560 GPU_PERF_TEST(CornerMinEigenVal, cv::gpu::DeviceInfo, MatType, BorderMode, BlockSize, ApertureSize)\r
 561 {\r
 562     int type = GET_PARAM(1);\r
 563     int borderType = GET_PARAM(2);\r
 564     int blockSize = GET_PARAM(3);\r
 565     int apertureSize = GET_PARAM(4);\r
 566 \r
 567     cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);\r
 568     ASSERT_FALSE(img.empty());\r
 569 \r
 570     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
 571 \r
 572     cv::Mat dst;\r
 573 \r
 574     cv::cornerMinEigenVal(img, dst, blockSize, apertureSize, borderType);\r
 575 \r
 576     TEST_CYCLE()\r
 577     {\r
 578         cv::cornerMinEigenVal(img, dst, blockSize, apertureSize, borderType);\r
 579     }\r
 580 }\r
 581 \r
 582 INSTANTIATE_TEST_CASE_P(ImgProc, CornerMinEigenVal, testing::Combine(\r
 583     ALL_DEVICES,\r
 584     testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),\r
 585     testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_REFLECT)),\r
 586     testing::Values(BlockSize(3), BlockSize(5), BlockSize(7)),\r
 587     testing::Values(ApertureSize(0), ApertureSize(3), ApertureSize(5), ApertureSize(7))));\r
 588 \r
 589 //////////////////////////////////////////////////////////////////////\r
 590 // PyrDown\r
 591 \r
 592 GPU_PERF_TEST(PyrDown, cv::gpu::DeviceInfo, cv::Size, MatType)\r
 593 {\r
 594     cv::Size size = GET_PARAM(1);\r
 595     int type = GET_PARAM(2);\r
 596 \r
 597     cv::Mat src(size, type);\r
 598     fill(src, 0, 255);\r
 599 \r
 600     cv::Mat dst;\r
 601 \r
 602     cv::pyrDown(src, dst);\r
 603 \r
 604     TEST_CYCLE()\r
 605     {\r
 606         cv::pyrDown(src, dst);\r
 607     }\r
 608 }\r
 609 \r
 610 INSTANTIATE_TEST_CASE_P(ImgProc, PyrDown, testing::Combine(\r
 611     ALL_DEVICES,\r
 612     GPU_TYPICAL_MAT_SIZES,\r
 613     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
 614                     MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
 615                     MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4))));\r
 616 \r
 617 //////////////////////////////////////////////////////////////////////\r
 618 // PyrUp\r
 619 \r
 620 GPU_PERF_TEST(PyrUp, cv::gpu::DeviceInfo, cv::Size, MatType)\r
 621 {\r
 622     cv::Size size = GET_PARAM(1);\r
 623     int type = GET_PARAM(2);\r
 624 \r
 625     cv::Mat src(size, type);\r
 626     fill(src, 0, 255);\r
 627 \r
 628     cv::Mat dst;\r
 629 \r
 630     cv::pyrUp(src, dst);\r
 631 \r
 632     TEST_CYCLE()\r
 633     {\r
 634         cv::pyrUp(src, dst);\r
 635     }\r
 636 }\r
 637 \r
 638 INSTANTIATE_TEST_CASE_P(ImgProc, PyrUp, testing::Combine(\r
 639     ALL_DEVICES,\r
 640     GPU_TYPICAL_MAT_SIZES,\r
 641     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
 642                     MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
 643                     MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4))));\r
 644 \r
 645 //////////////////////////////////////////////////////////////////////\r
 646 // CvtColor\r
 647 \r
 648 GPU_PERF_TEST(CvtColor, cv::gpu::DeviceInfo, cv::Size, MatDepth, CvtColorInfo)\r
 649 {\r
 650     cv::Size size = GET_PARAM(1);\r
 651     int depth = GET_PARAM(2);\r
 652     CvtColorInfo info = GET_PARAM(3);\r
 653 \r
 654     cv::Mat src(size, CV_MAKETYPE(depth, info.scn));\r
 655     fill(src, 0, 255);\r
 656 \r
 657     cv::Mat dst;\r
 658 \r
 659     cv::cvtColor(src, dst, info.code, info.dcn);\r
 660 \r
 661     TEST_CYCLE()\r
 662     {\r
 663         cv::cvtColor(src, dst, info.code, info.dcn);\r
 664     }\r
 665 }\r
 666 \r
 667 INSTANTIATE_TEST_CASE_P(ImgProc, CvtColor, testing::Combine(\r
 668     ALL_DEVICES,\r
 669     GPU_TYPICAL_MAT_SIZES,\r
 670     testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F)),\r
 671     testing::Values(CvtColorInfo(4, 4, cv::COLOR_RGBA2BGRA),\r
 672                     CvtColorInfo(4, 1, cv::COLOR_BGRA2GRAY),\r
 673                     CvtColorInfo(1, 4, cv::COLOR_GRAY2BGRA),\r
 674                     CvtColorInfo(3, 3, cv::COLOR_BGR2XYZ),\r
 675                     CvtColorInfo(3, 3, cv::COLOR_XYZ2BGR),\r
 676                     CvtColorInfo(3, 3, cv::COLOR_BGR2YCrCb),\r
 677                     CvtColorInfo(3, 3, cv::COLOR_YCrCb2BGR),\r
 678                     CvtColorInfo(3, 3, cv::COLOR_BGR2YUV),\r
 679                     CvtColorInfo(3, 3, cv::COLOR_YUV2BGR),\r
 680                     CvtColorInfo(3, 3, cv::COLOR_BGR2HSV),\r
 681                     CvtColorInfo(3, 3, cv::COLOR_HSV2BGR),\r
 682                     CvtColorInfo(3, 3, cv::COLOR_BGR2HLS),\r
 683                     CvtColorInfo(3, 3, cv::COLOR_HLS2BGR))));\r
 684 \r
 685 #endif\r