modules/gpu/perf/perf_imgproc.cpp

   1 #include "perf_precomp.hpp"\r
   2 \r
   3 PERF_TEST_P(DevInfo_Size_MatType_Interpolation_BorderMode, remap, testing::Combine(testing::ValuesIn(devices()), \r
   4                                                                   testing::Values(GPU_TYPICAL_MAT_SIZES), \r
   5                                                                   testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_32FC1), \r
   6                                                                   testing::Values((int)INTER_NEAREST, (int)INTER_LINEAR, (int)INTER_CUBIC),\r
   7                                                                   testing::Values((int)BORDER_REFLECT101, (int)BORDER_REPLICATE, (int)BORDER_CONSTANT)))\r
   8 {\r
   9     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
  10     Size size = std::tr1::get<1>(GetParam());\r
  11     int type = std::tr1::get<2>(GetParam());\r
  12     int interpolation = std::tr1::get<3>(GetParam());\r
  13     int borderMode = std::tr1::get<4>(GetParam());\r
  14 \r
  15     setDevice(devInfo.deviceID());\r
  16 \r
  17     Mat src_host(size, type);\r
  18 \r
  19     declare.in(src_host, WARMUP_RNG);\r
  20 \r
  21     GpuMat src(src_host);\r
  22     GpuMat dst(size, type);\r
  23 \r
  24     Mat xmap_host(size, CV_32FC1);\r
  25     Mat ymap_host(size, CV_32FC1);\r
  26     randu(xmap_host, -300, size.width + 300);\r
  27     randu(ymap_host, -300, size.height + 300);\r
  28 \r
  29     GpuMat xmap(xmap_host);\r
  30     GpuMat ymap(ymap_host);\r
  31 \r
  32     declare.time(3.0).iterations(100);\r
  33 \r
  34     SIMPLE_TEST_CYCLE()\r
  35     {\r
  36         remap(src, dst, xmap, ymap, interpolation, borderMode);\r
  37     }\r
  38 \r
  39     Mat dst_host = dst;\r
  40 \r
  41     SANITY_CHECK(dst_host);\r
  42 }\r
  43 \r
  44 PERF_TEST_P(DevInfo, meanShiftFiltering, testing::ValuesIn(devices()))\r
  45 {\r
  46     DeviceInfo devInfo = GetParam();\r
  47 \r
  48     setDevice(devInfo.deviceID());\r
  49 \r
  50     Mat img = readImage("meanshift/cones.png");\r
  51     ASSERT_FALSE(img.empty());\r
  52     \r
  53     Mat rgba;\r
  54     cvtColor(img, rgba, CV_BGR2BGRA);\r
  55 \r
  56     GpuMat src(rgba);\r
  57     GpuMat dst(src.size(), CV_8UC4);\r
  58 \r
  59     declare.time(5.0).iterations(100);\r
  60 \r
  61     SIMPLE_TEST_CYCLE()\r
  62     {\r
  63         meanShiftFiltering(src, dst, 50, 50);\r
  64     }\r
  65 \r
  66     Mat dst_host = dst;\r
  67 \r
  68     SANITY_CHECK(dst_host);\r
  69 }\r
  70 \r
  71 PERF_TEST_P(DevInfo, meanShiftProc, testing::ValuesIn(devices()))\r
  72 {\r
  73     DeviceInfo devInfo = GetParam();\r
  74 \r
  75     setDevice(devInfo.deviceID());\r
  76 \r
  77     Mat img = readImage("meanshift/cones.png");\r
  78     ASSERT_FALSE(img.empty());\r
  79     \r
  80     Mat rgba;\r
  81     cvtColor(img, rgba, CV_BGR2BGRA);\r
  82 \r
  83     GpuMat src(rgba);\r
  84     GpuMat dstr(src.size(), CV_8UC4);\r
  85     GpuMat dstsp(src.size(), CV_16SC2);\r
  86 \r
  87     declare.time(5.0).iterations(100);\r
  88 \r
  89     SIMPLE_TEST_CYCLE()\r
  90     {\r
  91         meanShiftProc(src, dstr, dstsp, 50, 50);\r
  92     }\r
  93 \r
  94     Mat dstr_host = dstr;\r
  95     Mat dstsp_host = dstsp;\r
  96 \r
  97     SANITY_CHECK(dstr_host);\r
  98     SANITY_CHECK(dstsp_host);\r
  99 }\r
 100 \r
 101 PERF_TEST_P(DevInfo, meanShiftSegmentation, testing::ValuesIn(devices()))\r
 102 {\r
 103     DeviceInfo devInfo = GetParam();\r
 104 \r
 105     setDevice(devInfo.deviceID());\r
 106 \r
 107     Mat img = readImage("meanshift/cones.png");\r
 108     ASSERT_FALSE(img.empty());\r
 109     \r
 110     Mat rgba;\r
 111     cvtColor(img, rgba, CV_BGR2BGRA);\r
 112 \r
 113     GpuMat src(rgba);\r
 114     Mat dst(src.size(), CV_8UC4);\r
 115 \r
 116     declare.time(5.0).iterations(100);\r
 117 \r
 118     SIMPLE_TEST_CYCLE()\r
 119     {\r
 120         meanShiftSegmentation(src, dst, 10, 10, 20);\r
 121     }\r
 122 \r
 123     SANITY_CHECK(dst);\r
 124 }\r
 125 \r
 126 PERF_TEST_P(DevInfo_Size_MatType, reprojectImageTo3D, testing::Combine(testing::ValuesIn(devices()),\r
 127                                                                        testing::Values(GPU_TYPICAL_MAT_SIZES), \r
 128                                                                        testing::Values(CV_8UC1, CV_16SC1)))\r
 129 {\r
 130     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 131     Size size = std::tr1::get<1>(GetParam());\r
 132     int type = std::tr1::get<2>(GetParam());\r
 133 \r
 134     setDevice(devInfo.deviceID());\r
 135 \r
 136     Mat src_host(size, type);\r
 137 \r
 138     declare.in(src_host, WARMUP_RNG);\r
 139 \r
 140     GpuMat src(src_host);\r
 141     GpuMat dst(size, CV_32FC4);\r
 142 \r
 143     declare.time(0.5).iterations(100);\r
 144 \r
 145     SIMPLE_TEST_CYCLE()\r
 146     {\r
 147         reprojectImageTo3D(src, dst, Mat::ones(4, 4, CV_32FC1));\r
 148     }\r
 149 \r
 150     Mat dst_host(dst);\r
 151 \r
 152     SANITY_CHECK(dst_host);\r
 153 }\r
 154 \r
 155 PERF_TEST_P(DevInfo_Size_MatType_CvtColorInfo, cvtColor, testing::Combine(testing::ValuesIn(devices()), \r
 156             testing::Values(GPU_TYPICAL_MAT_SIZES), \r
 157             testing::Values(CV_8UC1, CV_16UC1, CV_32FC1),\r
 158             testing::Values(CvtColorInfo(4, 4, CV_RGBA2BGRA), CvtColorInfo(4, 1, CV_BGRA2GRAY), CvtColorInfo(1, 4, CV_GRAY2BGRA), \r
 159                             CvtColorInfo(4, 4, CV_BGR2XYZ), CvtColorInfo(4, 4, CV_BGR2YCrCb), CvtColorInfo(4, 4, CV_BGR2HSV))))\r
 160 {\r
 161     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 162     Size size = std::tr1::get<1>(GetParam());\r
 163     int type = std::tr1::get<2>(GetParam());\r
 164     CvtColorInfo info = std::tr1::get<3>(GetParam());\r
 165 \r
 166     setDevice(devInfo.deviceID());\r
 167 \r
 168     Mat src_host(size, CV_MAKETYPE(type, info.scn));\r
 169 \r
 170     declare.in(src_host, WARMUP_RNG);\r
 171 \r
 172     GpuMat src(src_host);\r
 173     GpuMat dst(size, CV_MAKETYPE(type, info.dcn));\r
 174 \r
 175     declare.time(0.5).iterations(100);\r
 176 \r
 177     SIMPLE_TEST_CYCLE()\r
 178     {\r
 179         cvtColor(src, dst, info.code, info.dcn);\r
 180     }\r
 181 \r
 182     Mat dst_host(dst);\r
 183 \r
 184     SANITY_CHECK(dst_host);\r
 185 }\r
 186 \r
 187 PERF_TEST_P(DevInfo_Size_MatType, threshold, testing::Combine(testing::ValuesIn(devices()),\r
 188                                                               testing::Values(GPU_TYPICAL_MAT_SIZES), \r
 189                                                               testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)))\r
 190 {\r
 191     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 192     Size size = std::tr1::get<1>(GetParam());\r
 193     int type = std::tr1::get<2>(GetParam());\r
 194 \r
 195     setDevice(devInfo.deviceID());\r
 196 \r
 197     Mat src_host(size, type);\r
 198 \r
 199     declare.in(src_host, WARMUP_RNG);\r
 200 \r
 201     GpuMat src(src_host);\r
 202     GpuMat dst(size, type);\r
 203 \r
 204     declare.time(0.5).iterations(100);\r
 205 \r
 206     SIMPLE_TEST_CYCLE()\r
 207     {\r
 208         threshold(src, dst, 100.0, 255.0, THRESH_BINARY);\r
 209     }\r
 210 \r
 211     Mat dst_host(dst);\r
 212 \r
 213     SANITY_CHECK(dst_host);\r
 214 }\r
 215 \r
 216 PERF_TEST_P(DevInfo_Size_MatType_Interpolation_SizeCoeff, resize, testing::Combine(testing::ValuesIn(devices()),\r
 217                                                                                    testing::Values(GPU_TYPICAL_MAT_SIZES), \r
 218                                                                                    testing::Values(CV_8UC1, CV_8UC4),\r
 219                                                                                    testing::Values((int)INTER_NEAREST, (int)INTER_LINEAR),\r
 220                                                                                    testing::Values(0.5, 2.0)))\r
 221 {\r
 222     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 223     Size size = std::tr1::get<1>(GetParam());\r
 224     int type = std::tr1::get<2>(GetParam());\r
 225     int interpolation = std::tr1::get<3>(GetParam());\r
 226     double f = std::tr1::get<4>(GetParam());\r
 227 \r
 228     setDevice(devInfo.deviceID());\r
 229 \r
 230     Mat src_host(size, type);\r
 231 \r
 232     declare.in(src_host, WARMUP_RNG);\r
 233 \r
 234     GpuMat src(src_host);\r
 235     GpuMat dst;\r
 236 \r
 237     declare.time(0.5).iterations(100);\r
 238 \r
 239     SIMPLE_TEST_CYCLE()\r
 240     {\r
 241         resize(src, dst, Size(), f, f, interpolation);\r
 242     }\r
 243 \r
 244     Mat dst_host(dst);\r
 245 \r
 246     SANITY_CHECK(dst_host);\r
 247 }\r
 248 \r
 249 PERF_TEST_P(DevInfo_Size_MatType_Interpolation, warpAffine, testing::Combine(testing::ValuesIn(devices()),\r
 250                                                                              testing::Values(GPU_TYPICAL_MAT_SIZES), \r
 251                                                                              testing::Values(CV_8UC1, CV_8UC4, CV_32FC1),\r
 252                                                                              testing::Values((int)INTER_NEAREST, (int)INTER_LINEAR, (int)INTER_CUBIC)))\r
 253 {\r
 254     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 255     Size size = std::tr1::get<1>(GetParam());\r
 256     int type = std::tr1::get<2>(GetParam());\r
 257     int interpolation = std::tr1::get<3>(GetParam());\r
 258 \r
 259     setDevice(devInfo.deviceID());\r
 260 \r
 261     Mat src_host(size, type);\r
 262 \r
 263     declare.in(src_host, WARMUP_RNG);\r
 264 \r
 265     GpuMat src(src_host);\r
 266     GpuMat dst(size, type);\r
 267 \r
 268     static double reflect[2][3] = { {-1,  0, 0},\r
 269                                     { 0, -1, 0}};\r
 270     reflect[0][2] = size.width;\r
 271     reflect[1][2] = size.height;\r
 272     Mat M(2, 3, CV_64F, (void*)reflect); \r
 273 \r
 274     declare.time(0.5).iterations(100);\r
 275 \r
 276     SIMPLE_TEST_CYCLE()\r
 277     {\r
 278         warpAffine(src, dst, M, size, interpolation);\r
 279     }\r
 280 \r
 281     Mat dst_host(dst);\r
 282 \r
 283     SANITY_CHECK(dst_host);\r
 284 }\r
 285 \r
 286 PERF_TEST_P(DevInfo_Size_MatType_Interpolation, warpPerspective, testing::Combine(testing::ValuesIn(devices()),\r
 287                                                                                   testing::Values(GPU_TYPICAL_MAT_SIZES), \r
 288                                                                                   testing::Values(CV_8UC1, CV_8UC4, CV_32FC1),\r
 289                                                                                   testing::Values((int)INTER_NEAREST, (int)INTER_LINEAR, (int)INTER_CUBIC)))\r
 290 {\r
 291     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 292     Size size = std::tr1::get<1>(GetParam());\r
 293     int type = std::tr1::get<2>(GetParam());\r
 294     int interpolation = std::tr1::get<3>(GetParam());\r
 295 \r
 296     setDevice(devInfo.deviceID());\r
 297 \r
 298     Mat src_host(size, type);\r
 299 \r
 300     declare.in(src_host, WARMUP_RNG);\r
 301 \r
 302     GpuMat src(src_host);\r
 303     GpuMat dst(size, type);\r
 304 \r
 305     static double reflect[3][3] = { {-1,  0, 0},\r
 306                                     { 0, -1, 0},\r
 307                                     { 0, 0, 1}};\r
 308     reflect[0][2] = size.width;\r
 309     reflect[1][2] = size.height;\r
 310     Mat M(3, 3, CV_64F, (void*)reflect); \r
 311 \r
 312     declare.time(0.5).iterations(100);\r
 313 \r
 314     SIMPLE_TEST_CYCLE()\r
 315     {\r
 316         warpPerspective(src, dst, M, size, interpolation);\r
 317     }\r
 318 \r
 319     Mat dst_host(dst);\r
 320 \r
 321     SANITY_CHECK(dst_host);\r
 322 }\r
 323 \r
 324 PERF_TEST_P(DevInfo_Size_MatType_Interpolation, rotate, testing::Combine(testing::ValuesIn(devices()),\r
 325                                                                          testing::Values(GPU_TYPICAL_MAT_SIZES), \r
 326                                                                          testing::Values(CV_8UC1, CV_8UC4),\r
 327                                                                          testing::Values((int)INTER_NEAREST, (int)INTER_LINEAR, (int)INTER_CUBIC)))\r
 328 {\r
 329     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 330     Size size = std::tr1::get<1>(GetParam());\r
 331     int type = std::tr1::get<2>(GetParam());\r
 332     int interpolation = std::tr1::get<3>(GetParam());\r
 333 \r
 334     setDevice(devInfo.deviceID());\r
 335 \r
 336     Mat src_host(size, type);\r
 337 \r
 338     declare.in(src_host, WARMUP_RNG);\r
 339 \r
 340     GpuMat src(src_host);\r
 341     GpuMat dst(size, type);\r
 342 \r
 343     declare.time(0.5).iterations(100);\r
 344 \r
 345     SIMPLE_TEST_CYCLE()\r
 346     {\r
 347         rotate(src, dst, size, 30.0, 0, 0, interpolation);\r
 348     }\r
 349 \r
 350     Mat dst_host(dst);\r
 351 \r
 352     SANITY_CHECK(dst_host);\r
 353 }\r
 354 \r
 355 PERF_TEST_P(DevInfo_Size_MatType, copyMakeBorder, testing::Combine(testing::ValuesIn(devices()),\r
 356                                                                          testing::Values(GPU_TYPICAL_MAT_SIZES), \r
 357                                                                          testing::Values(CV_8UC1, CV_8UC4, CV_32SC1)))\r
 358 {\r
 359     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 360     Size size = std::tr1::get<1>(GetParam());\r
 361     int type = std::tr1::get<2>(GetParam());\r
 362 \r
 363     setDevice(devInfo.deviceID());\r
 364 \r
 365     Mat src_host(size, type);\r
 366 \r
 367     declare.in(src_host, WARMUP_RNG);\r
 368 \r
 369     GpuMat src(src_host);\r
 370     GpuMat dst;\r
 371 \r
 372     declare.time(0.5).iterations(100);\r
 373 \r
 374     SIMPLE_TEST_CYCLE()\r
 375     {\r
 376         copyMakeBorder(src, dst, 5, 5, 5, 5);\r
 377     }\r
 378 \r
 379     Mat dst_host(dst);\r
 380 \r
 381     SANITY_CHECK(dst_host);\r
 382 }\r
 383 \r
 384 PERF_TEST_P(DevInfo_Size, integral, testing::Combine(testing::ValuesIn(devices()),\r
 385                                                      testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 386 {\r
 387     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 388     Size size = std::tr1::get<1>(GetParam());\r
 389 \r
 390     setDevice(devInfo.deviceID());\r
 391 \r
 392     Mat src_host(size, CV_8UC1);\r
 393 \r
 394     declare.in(src_host, WARMUP_RNG);\r
 395 \r
 396     GpuMat src(src_host);\r
 397     GpuMat dst;\r
 398     GpuMat buf;\r
 399 \r
 400     declare.time(0.5).iterations(100);\r
 401 \r
 402     SIMPLE_TEST_CYCLE()\r
 403     {\r
 404         integralBuffered(src, dst, buf);\r
 405     }\r
 406 \r
 407     Mat dst_host(dst);\r
 408 \r
 409     SANITY_CHECK(dst_host);\r
 410 }\r
 411 \r
 412 PERF_TEST_P(DevInfo_Size, sqrIntegral, testing::Combine(testing::ValuesIn(devices()),\r
 413                                                         testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 414 {\r
 415     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 416     Size size = std::tr1::get<1>(GetParam());\r
 417 \r
 418     setDevice(devInfo.deviceID());\r
 419 \r
 420     Mat src_host(size, CV_8UC1);\r
 421 \r
 422     declare.in(src_host, WARMUP_RNG);\r
 423 \r
 424     GpuMat src(src_host);\r
 425     GpuMat dst;\r
 426 \r
 427     declare.time(0.5).iterations(100);\r
 428 \r
 429     SIMPLE_TEST_CYCLE()\r
 430     {\r
 431         sqrIntegral(src, dst);\r
 432     }\r
 433 \r
 434     Mat dst_host(dst);\r
 435 \r
 436     SANITY_CHECK(dst_host);\r
 437 }\r
 438 \r
 439 PERF_TEST_P(DevInfo_Size, columnSum, testing::Combine(testing::ValuesIn(devices()),\r
 440                                                       testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 441 {\r
 442     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 443     Size size = std::tr1::get<1>(GetParam());\r
 444 \r
 445     setDevice(devInfo.deviceID());\r
 446 \r
 447     Mat src_host(size, CV_32FC1);\r
 448 \r
 449     declare.in(src_host, WARMUP_RNG);\r
 450 \r
 451     GpuMat src(src_host);\r
 452     GpuMat dst;\r
 453 \r
 454     declare.time(0.5).iterations(100);\r
 455 \r
 456     SIMPLE_TEST_CYCLE()\r
 457     {\r
 458         columnSum(src, dst);\r
 459     }\r
 460 \r
 461     Mat dst_host(dst);\r
 462 \r
 463     SANITY_CHECK(dst_host);\r
 464 }\r
 465 \r
 466 PERF_TEST_P(DevInfo_MatType, cornerHarris, testing::Combine(testing::ValuesIn(devices()),\r
 467                                                             testing::Values(CV_8UC1, CV_32FC1)))\r
 468 {\r
 469     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 470     int type = std::tr1::get<1>(GetParam());\r
 471 \r
 472     setDevice(devInfo.deviceID());\r
 473     \r
 474     Mat img = readImage("stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE);\r
 475     ASSERT_FALSE(img.empty());\r
 476 \r
 477     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
 478 \r
 479     GpuMat src(img);\r
 480     GpuMat dst;\r
 481     GpuMat Dx;\r
 482     GpuMat Dy;\r
 483 \r
 484     int blockSize = 3;\r
 485     int ksize = 7;        \r
 486     double k = 0.5;\r
 487 \r
 488     declare.time(0.5).iterations(100);\r
 489 \r
 490     SIMPLE_TEST_CYCLE()\r
 491     {\r
 492         cornerHarris(src, dst, Dx, Dy, blockSize, ksize, k);\r
 493     }\r
 494 \r
 495     Mat dst_host(dst);\r
 496     Mat Dx_host(Dx);\r
 497     Mat Dy_host(Dy);\r
 498 \r
 499     SANITY_CHECK(dst_host);\r
 500     SANITY_CHECK(Dx_host);\r
 501     SANITY_CHECK(Dy_host);\r
 502 }\r
 503 \r
 504 PERF_TEST_P(DevInfo_MatType, cornerMinEigenVal, testing::Combine(testing::ValuesIn(devices()),\r
 505                                                             testing::Values(CV_8UC1, CV_32FC1)))\r
 506 {\r
 507     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 508     int type = std::tr1::get<1>(GetParam());\r
 509 \r
 510     setDevice(devInfo.deviceID());\r
 511     \r
 512     Mat img = readImage("stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE);\r
 513     ASSERT_FALSE(img.empty());\r
 514 \r
 515     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
 516 \r
 517     GpuMat src(img);\r
 518     GpuMat dst;\r
 519     GpuMat Dx;\r
 520     GpuMat Dy;\r
 521 \r
 522     int blockSize = 3;\r
 523     int ksize = 7; \r
 524 \r
 525     declare.time(0.5).iterations(100);\r
 526 \r
 527     SIMPLE_TEST_CYCLE()\r
 528     {\r
 529         cornerMinEigenVal(src, dst, Dx, Dy, blockSize, ksize);\r
 530     }\r
 531 \r
 532     Mat dst_host(dst);\r
 533     Mat Dx_host(Dx);\r
 534     Mat Dy_host(Dy);\r
 535 \r
 536     SANITY_CHECK(dst_host);\r
 537     SANITY_CHECK(Dx_host);\r
 538     SANITY_CHECK(Dy_host);\r
 539 }\r
 540 \r
 541 PERF_TEST_P(DevInfo_Size_MatType, mulSpectrums, testing::Combine(testing::ValuesIn(devices()),\r
 542                                                                  testing::Values(GPU_TYPICAL_MAT_SIZES),\r
 543                                                                  testing::Values(CV_8UC1, CV_32FC1)))\r
 544 {\r
 545     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 546     Size size = std::tr1::get<1>(GetParam());\r
 547     int type = std::tr1::get<2>(GetParam());\r
 548 \r
 549     setDevice(devInfo.deviceID());\r
 550 \r
 551     Mat a_host(size, CV_32FC2);\r
 552     Mat b_host(size, CV_32FC2);\r
 553 \r
 554     declare.in(a_host, b_host, WARMUP_RNG);\r
 555 \r
 556     GpuMat a(a_host);\r
 557     GpuMat b(b_host);\r
 558     GpuMat dst;\r
 559 \r
 560     declare.time(0.5).iterations(100);\r
 561 \r
 562     SIMPLE_TEST_CYCLE()\r
 563     {\r
 564         mulSpectrums(a, b, dst, 0);\r
 565     }\r
 566 \r
 567     Mat dst_host(dst);\r
 568 \r
 569     SANITY_CHECK(dst_host);\r
 570 }\r
 571 \r
 572 PERF_TEST_P(DevInfo_Size, dft, testing::Combine(testing::ValuesIn(devices()),\r
 573                                                 testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 574 {\r
 575     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 576     Size size = std::tr1::get<1>(GetParam());\r
 577 \r
 578     setDevice(devInfo.deviceID());\r
 579 \r
 580     Mat src_host(size, CV_32FC2);\r
 581 \r
 582     declare.in(src_host, WARMUP_RNG);\r
 583 \r
 584     GpuMat src(src_host);\r
 585     GpuMat dst;\r
 586 \r
 587     declare.time(2.0).iterations(100);\r
 588 \r
 589     SIMPLE_TEST_CYCLE()\r
 590     {\r
 591         dft(src, dst, size);\r
 592     }\r
 593 \r
 594     Mat dst_host(dst);\r
 595 \r
 596     SANITY_CHECK(dst_host);\r
 597 }\r
 598 \r
 599 PERF_TEST_P(DevInfo_Size, convolve, testing::Combine(testing::ValuesIn(devices()),\r
 600                                                 testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 601 {\r
 602     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 603     Size size = std::tr1::get<1>(GetParam());\r
 604 \r
 605     setDevice(devInfo.deviceID());\r
 606 \r
 607     Mat image_host(size, CV_32FC1);\r
 608     Mat templ_host(size, CV_32FC1);\r
 609 \r
 610     declare.in(image_host, templ_host, WARMUP_RNG);\r
 611 \r
 612     GpuMat image(image_host);\r
 613     GpuMat templ(templ_host);\r
 614     GpuMat dst;\r
 615     ConvolveBuf buf;\r
 616 \r
 617     declare.time(2.0).iterations(100);\r
 618 \r
 619     SIMPLE_TEST_CYCLE()\r
 620     {\r
 621         convolve(image, templ, dst, false, buf);\r
 622     }\r
 623 \r
 624     Mat dst_host(dst);\r
 625 \r
 626     SANITY_CHECK(dst_host);\r
 627 }\r
 628 \r
 629 PERF_TEST_P(DevInfo_Size_MatType, pyrDown, testing::Combine(testing::ValuesIn(devices()),\r
 630                                                             testing::Values(GPU_TYPICAL_MAT_SIZES),\r
 631                                                             testing::Values(CV_8UC1, CV_8UC4, CV_16SC3, CV_32FC1)))\r
 632 {\r
 633     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 634     Size size = std::tr1::get<1>(GetParam());\r
 635     int type = std::tr1::get<2>(GetParam());\r
 636 \r
 637     setDevice(devInfo.deviceID());\r
 638 \r
 639     Mat src_host(size, type);\r
 640 \r
 641     declare.in(src_host, WARMUP_RNG);\r
 642 \r
 643     GpuMat src(src_host);\r
 644     GpuMat dst;\r
 645 \r
 646     declare.time(0.5).iterations(100);\r
 647 \r
 648     SIMPLE_TEST_CYCLE()\r
 649     {\r
 650         pyrDown(src, dst);\r
 651     }\r
 652 \r
 653     Mat dst_host(dst);\r
 654 \r
 655     SANITY_CHECK(dst_host);\r
 656 }\r
 657 \r
 658 PERF_TEST_P(DevInfo_Size_MatType, pyrUp, testing::Combine(testing::ValuesIn(devices()),\r
 659                                                           testing::Values(GPU_TYPICAL_MAT_SIZES),\r
 660                                                           testing::Values(CV_8UC1, CV_8UC4, CV_16SC3, CV_32FC1)))\r
 661 {\r
 662     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 663     Size size = std::tr1::get<1>(GetParam());\r
 664     int type = std::tr1::get<2>(GetParam());\r
 665 \r
 666     setDevice(devInfo.deviceID());\r
 667 \r
 668     Mat src_host(size, type);\r
 669 \r
 670     declare.in(src_host, WARMUP_RNG);\r
 671 \r
 672     GpuMat src(src_host);\r
 673     GpuMat dst;\r
 674 \r
 675     declare.time(0.5).iterations(100);\r
 676 \r
 677     SIMPLE_TEST_CYCLE()\r
 678     {\r
 679         pyrUp(src, dst);\r
 680     }\r
 681 \r
 682     Mat dst_host(dst);\r
 683 \r
 684     SANITY_CHECK(dst_host);\r
 685 }\r
 686 \r
 687 PERF_TEST_P(DevInfo_Size_MatType, blendLinear, testing::Combine(testing::ValuesIn(devices()),\r
 688                                                                 testing::Values(GPU_TYPICAL_MAT_SIZES),\r
 689                                                                 testing::Values(CV_8UC1, CV_32FC1)))\r
 690 {\r
 691     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 692     Size size = std::tr1::get<1>(GetParam());\r
 693     int type = std::tr1::get<2>(GetParam());\r
 694 \r
 695     setDevice(devInfo.deviceID());\r
 696 \r
 697     Mat img1_host(size, type);\r
 698     Mat img2_host(size, type);\r
 699 \r
 700     declare.in(img1_host, img2_host, WARMUP_RNG);\r
 701 \r
 702     GpuMat img1(img1_host);\r
 703     GpuMat img2(img2_host);\r
 704     GpuMat weights1(size, CV_32FC1, Scalar::all(0.5));\r
 705     GpuMat weights2(size, CV_32FC1, Scalar::all(0.5));\r
 706     GpuMat dst;\r
 707 \r
 708     declare.time(0.5).iterations(100);\r
 709 \r
 710     SIMPLE_TEST_CYCLE()\r
 711     {\r
 712         blendLinear(img1, img2, weights1, weights2, dst);\r
 713     }\r
 714 \r
 715     Mat dst_host(dst);\r
 716 \r
 717     SANITY_CHECK(dst_host);\r
 718 }\r
 719 \r
 720 PERF_TEST_P(DevInfo, Canny, testing::ValuesIn(devices()))\r
 721 {\r
 722     DeviceInfo devInfo = GetParam();\r
 723 \r
 724     setDevice(devInfo.deviceID());\r
 725 \r
 726     Mat image_host = readImage("perf/aloe.jpg", CV_LOAD_IMAGE_GRAYSCALE);\r
 727     ASSERT_FALSE(image_host.empty());\r
 728 \r
 729     GpuMat image(image_host);\r
 730     GpuMat dst;\r
 731     CannyBuf buf;\r
 732 \r
 733     declare.time(0.5).iterations(100);\r
 734 \r
 735     SIMPLE_TEST_CYCLE()\r
 736     {\r
 737         Canny(image, buf, dst, 50.0, 100.0);\r
 738     }\r
 739 \r
 740     Mat dst_host(dst);\r
 741 \r
 742     SANITY_CHECK(dst_host);\r
 743 }\r