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