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);\r
  33 \r
  34     TEST_CYCLE(100)\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("gpu/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);\r
  60 \r
  61     TEST_CYCLE(100)\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("gpu/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);\r
  88 \r
  89     TEST_CYCLE(100)\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("gpu/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);\r
 117 \r
 118     TEST_CYCLE(100)\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, drawColorDisp, 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, CV_8UC1);\r
 137     declare.in(src_host, WARMUP_RNG);\r
 138     src_host.convertTo(src_host, type);\r
 139 \r
 140     GpuMat src(src_host);\r
 141     GpuMat dst(size, CV_8UC4);\r
 142 \r
 143     TEST_CYCLE(100)\r
 144     {\r
 145         drawColorDisp(src, dst, 255);\r
 146     }\r
 147 \r
 148     Mat dst_host(dst);\r
 149 \r
 150     SANITY_CHECK(dst_host);\r
 151 }\r
 152 \r
 153 PERF_TEST_P(DevInfo_Size_MatType, reprojectImageTo3D, testing::Combine(testing::ValuesIn(devices()),\r
 154                                                                        testing::Values(GPU_TYPICAL_MAT_SIZES), \r
 155                                                                        testing::Values(CV_8UC1, CV_16SC1)))\r
 156 {\r
 157     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 158     Size size = std::tr1::get<1>(GetParam());\r
 159     int type = std::tr1::get<2>(GetParam());\r
 160 \r
 161     setDevice(devInfo.deviceID());\r
 162 \r
 163     Mat src_host(size, type);\r
 164 \r
 165     declare.in(src_host, WARMUP_RNG);\r
 166 \r
 167     GpuMat src(src_host);\r
 168     GpuMat dst(size, CV_32FC4);\r
 169 \r
 170     TEST_CYCLE(100)\r
 171     {\r
 172         reprojectImageTo3D(src, dst, Mat::ones(4, 4, CV_32FC1));\r
 173     }\r
 174 \r
 175     Mat dst_host(dst);\r
 176 \r
 177     SANITY_CHECK(dst_host);\r
 178 }\r
 179 \r
 180 PERF_TEST_P(DevInfo_Size_MatType_CvtColorInfo, cvtColor, testing::Combine(testing::ValuesIn(devices()), \r
 181             testing::Values(GPU_TYPICAL_MAT_SIZES), \r
 182             testing::Values(CV_8UC1, CV_16UC1, CV_32FC1),\r
 183             testing::Values(CvtColorInfo(4, 4, CV_RGBA2BGRA), CvtColorInfo(4, 1, CV_BGRA2GRAY), CvtColorInfo(1, 4, CV_GRAY2BGRA), \r
 184                             CvtColorInfo(4, 4, CV_BGR2XYZ), CvtColorInfo(4, 4, CV_BGR2YCrCb), CvtColorInfo(4, 4, CV_YCrCb2BGR), \r
 185                             CvtColorInfo(4, 4, CV_BGR2HSV), CvtColorInfo(4, 4, CV_HSV2BGR))))\r
 186 {\r
 187     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 188     Size size = std::tr1::get<1>(GetParam());\r
 189     int type = std::tr1::get<2>(GetParam());\r
 190     CvtColorInfo info = std::tr1::get<3>(GetParam());\r
 191 \r
 192     setDevice(devInfo.deviceID());\r
 193 \r
 194     Mat src_host(size, CV_MAKETYPE(type, info.scn));\r
 195 \r
 196     declare.in(src_host, WARMUP_RNG);\r
 197 \r
 198     GpuMat src(src_host);\r
 199     GpuMat dst(size, CV_MAKETYPE(type, info.dcn));\r
 200 \r
 201     TEST_CYCLE(100)\r
 202     {\r
 203         cvtColor(src, dst, info.code, info.dcn);\r
 204     }\r
 205 \r
 206     Mat dst_host(dst);\r
 207 \r
 208     SANITY_CHECK(dst_host);\r
 209 }\r
 210 \r
 211 PERF_TEST_P(DevInfo_Size_MatType, threshold, testing::Combine(testing::ValuesIn(devices()),\r
 212                                                               testing::Values(GPU_TYPICAL_MAT_SIZES), \r
 213                                                               testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)))\r
 214 {\r
 215     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 216     Size size = std::tr1::get<1>(GetParam());\r
 217     int type = std::tr1::get<2>(GetParam());\r
 218 \r
 219     setDevice(devInfo.deviceID());\r
 220 \r
 221     Mat src_host(size, type);\r
 222 \r
 223     declare.in(src_host, WARMUP_RNG);\r
 224 \r
 225     GpuMat src(src_host);\r
 226     GpuMat dst(size, type);\r
 227 \r
 228     TEST_CYCLE(100)\r
 229     {\r
 230         threshold(src, dst, 100.0, 255.0, THRESH_BINARY);\r
 231     }\r
 232 \r
 233     Mat dst_host(dst);\r
 234 \r
 235     SANITY_CHECK(dst_host);\r
 236 }\r
 237 \r
 238 PERF_TEST_P(DevInfo_Size_MatType_Interpolation_SizeCoeff, resize, testing::Combine(testing::ValuesIn(devices()),\r
 239                                                                                    testing::Values(szSXGA, sz1080p), \r
 240                                                                                    testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_32FC1),\r
 241                                                                                    testing::Values((int)INTER_NEAREST, (int)INTER_LINEAR, (int)INTER_CUBIC),\r
 242                                                                                    testing::Values(0.5, 2.0)))\r
 243 {\r
 244     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 245     Size size = std::tr1::get<1>(GetParam());\r
 246     int type = std::tr1::get<2>(GetParam());\r
 247     int interpolation = std::tr1::get<3>(GetParam());\r
 248     double f = std::tr1::get<4>(GetParam());\r
 249 \r
 250     setDevice(devInfo.deviceID());\r
 251 \r
 252     Mat src_host(size, type);\r
 253 \r
 254     declare.in(src_host, WARMUP_RNG);\r
 255 \r
 256     GpuMat src(src_host);\r
 257     GpuMat dst;\r
 258 \r
 259     declare.time(1.0);\r
 260 \r
 261     TEST_CYCLE(100)\r
 262     {\r
 263         resize(src, dst, Size(), f, f, interpolation);\r
 264     }\r
 265 \r
 266     Mat dst_host(dst);\r
 267 \r
 268     SANITY_CHECK(dst_host);\r
 269 }\r
 270 \r
 271 PERF_TEST_P(DevInfo_Size_MatType_Interpolation, warpAffine, testing::Combine(testing::ValuesIn(devices()),\r
 272                                                                              testing::Values(GPU_TYPICAL_MAT_SIZES), \r
 273                                                                              testing::Values(CV_8UC1, CV_8UC4, CV_32FC1),\r
 274                                                                              testing::Values((int)INTER_NEAREST, (int)INTER_LINEAR, (int)INTER_CUBIC)))\r
 275 {\r
 276     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 277     Size size = std::tr1::get<1>(GetParam());\r
 278     int type = std::tr1::get<2>(GetParam());\r
 279     int interpolation = std::tr1::get<3>(GetParam());\r
 280 \r
 281     setDevice(devInfo.deviceID());\r
 282 \r
 283     Mat src_host(size, type);\r
 284 \r
 285     declare.in(src_host, WARMUP_RNG);\r
 286 \r
 287     GpuMat src(src_host);\r
 288     GpuMat dst(size, type);\r
 289 \r
 290     static double reflect[2][3] = { {-1,  0, 0},\r
 291                                     { 0, -1, 0}};\r
 292     reflect[0][2] = size.width;\r
 293     reflect[1][2] = size.height;\r
 294     Mat M(2, 3, CV_64F, (void*)reflect); \r
 295 \r
 296     TEST_CYCLE(100)\r
 297     {\r
 298         warpAffine(src, dst, M, size, interpolation);\r
 299     }\r
 300 \r
 301     Mat dst_host(dst);\r
 302 \r
 303     SANITY_CHECK(dst_host);\r
 304 }\r
 305 \r
 306 PERF_TEST_P(DevInfo_Size_MatType_Interpolation, warpPerspective, testing::Combine(testing::ValuesIn(devices()),\r
 307                                                                                   testing::Values(GPU_TYPICAL_MAT_SIZES), \r
 308                                                                                   testing::Values(CV_8UC1, CV_8UC4, CV_32FC1),\r
 309                                                                                   testing::Values((int)INTER_NEAREST, (int)INTER_LINEAR, (int)INTER_CUBIC)))\r
 310 {\r
 311     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 312     Size size = std::tr1::get<1>(GetParam());\r
 313     int type = std::tr1::get<2>(GetParam());\r
 314     int interpolation = std::tr1::get<3>(GetParam());\r
 315 \r
 316     setDevice(devInfo.deviceID());\r
 317 \r
 318     Mat src_host(size, type);\r
 319 \r
 320     declare.in(src_host, WARMUP_RNG);\r
 321 \r
 322     GpuMat src(src_host);\r
 323     GpuMat dst(size, type);\r
 324 \r
 325     static double reflect[3][3] = { {-1,  0, 0},\r
 326                                     { 0, -1, 0},\r
 327                                     { 0, 0, 1}};\r
 328     reflect[0][2] = size.width;\r
 329     reflect[1][2] = size.height;\r
 330     Mat M(3, 3, CV_64F, (void*)reflect); \r
 331 \r
 332     TEST_CYCLE(100)\r
 333     {\r
 334         warpPerspective(src, dst, M, size, interpolation);\r
 335     }\r
 336 \r
 337     Mat dst_host(dst);\r
 338 \r
 339     SANITY_CHECK(dst_host);\r
 340 }\r
 341 \r
 342 PERF_TEST_P(DevInfo_Size, buildWarpPlaneMaps, testing::Combine(testing::ValuesIn(devices()),\r
 343                                                                testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 344 {\r
 345     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 346     Size size = std::tr1::get<1>(GetParam());\r
 347 \r
 348     setDevice(devInfo.deviceID());\r
 349 \r
 350     GpuMat map_x(size, CV_32FC1);\r
 351     GpuMat map_y(size, CV_32FC1);\r
 352 \r
 353     TEST_CYCLE(100)\r
 354     {\r
 355         buildWarpPlaneMaps(size, Rect(0, 0, size.width, size.height), Mat::eye(3, 3, CV_32FC1), \r
 356                            Mat::ones(3, 3, CV_32FC1), Mat::zeros(1, 3, CV_32F), 1.0, map_x, map_y);\r
 357     }\r
 358 \r
 359     Mat map_x_host(map_x);\r
 360     Mat map_y_host(map_y);\r
 361 \r
 362     SANITY_CHECK(map_x_host);\r
 363     SANITY_CHECK(map_y_host);\r
 364 }\r
 365 \r
 366 PERF_TEST_P(DevInfo_Size, buildWarpCylindricalMaps, testing::Combine(testing::ValuesIn(devices()),\r
 367                                                                testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 368 {\r
 369     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 370     Size size = std::tr1::get<1>(GetParam());\r
 371 \r
 372     setDevice(devInfo.deviceID());\r
 373 \r
 374     GpuMat map_x(size, CV_32FC1);\r
 375     GpuMat map_y(size, CV_32FC1);\r
 376 \r
 377     TEST_CYCLE(100)\r
 378     {\r
 379         buildWarpCylindricalMaps(size, Rect(0, 0, size.width, size.height), Mat::eye(3, 3, CV_32FC1),\r
 380                                  Mat::ones(3, 3, CV_32FC1), 1.0, map_x, map_y);\r
 381     }\r
 382 \r
 383     Mat map_x_host(map_x);\r
 384     Mat map_y_host(map_y);\r
 385 \r
 386     SANITY_CHECK(map_x_host);\r
 387     SANITY_CHECK(map_y_host);\r
 388 }\r
 389 \r
 390 PERF_TEST_P(DevInfo_Size, buildWarpSphericalMaps, testing::Combine(testing::ValuesIn(devices()),\r
 391                                                                    testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 392 {\r
 393     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 394     Size size = std::tr1::get<1>(GetParam());\r
 395 \r
 396     setDevice(devInfo.deviceID());\r
 397 \r
 398     GpuMat map_x(size, CV_32FC1);\r
 399     GpuMat map_y(size, CV_32FC1);\r
 400 \r
 401     TEST_CYCLE(100)\r
 402     {\r
 403         buildWarpSphericalMaps(size, Rect(0, 0, size.width, size.height), Mat::eye(3, 3, CV_32FC1),\r
 404                                Mat::ones(3, 3, CV_32FC1), 1.0, map_x, map_y);\r
 405     }\r
 406 \r
 407     Mat map_x_host(map_x);\r
 408     Mat map_y_host(map_y);\r
 409 \r
 410     SANITY_CHECK(map_x_host);\r
 411     SANITY_CHECK(map_y_host);\r
 412 }\r
 413 \r
 414 PERF_TEST_P(DevInfo_Size_MatType_Interpolation, rotate, testing::Combine(testing::ValuesIn(devices()),\r
 415                                                                          testing::Values(GPU_TYPICAL_MAT_SIZES), \r
 416                                                                          testing::Values(CV_8UC1, CV_8UC4),\r
 417                                                                          testing::Values((int)INTER_NEAREST, (int)INTER_LINEAR, (int)INTER_CUBIC)))\r
 418 {\r
 419     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 420     Size size = std::tr1::get<1>(GetParam());\r
 421     int type = std::tr1::get<2>(GetParam());\r
 422     int interpolation = std::tr1::get<3>(GetParam());\r
 423 \r
 424     setDevice(devInfo.deviceID());\r
 425 \r
 426     Mat src_host(size, type);\r
 427 \r
 428     declare.in(src_host, WARMUP_RNG);\r
 429 \r
 430     GpuMat src(src_host);\r
 431     GpuMat dst(size, type);\r
 432 \r
 433     TEST_CYCLE(100)\r
 434     {\r
 435         rotate(src, dst, size, 30.0, 0, 0, interpolation);\r
 436     }\r
 437 \r
 438     Mat dst_host(dst);\r
 439 \r
 440     SANITY_CHECK(dst_host);\r
 441 }\r
 442 \r
 443 PERF_TEST_P(DevInfo_Size_MatType_BorderMode, copyMakeBorder, testing::Combine(testing::ValuesIn(devices()),\r
 444                                                                               testing::Values(GPU_TYPICAL_MAT_SIZES), \r
 445                                                                               testing::Values(CV_8UC1, CV_8UC4, CV_32FC1), \r
 446                                                                               testing::Values((int)BORDER_REPLICATE, (int)BORDER_CONSTANT)))\r
 447 {\r
 448     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 449     Size size = std::tr1::get<1>(GetParam());\r
 450     int type = std::tr1::get<2>(GetParam());\r
 451     int borderType = std::tr1::get<3>(GetParam());\r
 452 \r
 453     setDevice(devInfo.deviceID());\r
 454 \r
 455     Mat src_host(size, type);\r
 456 \r
 457     declare.in(src_host, WARMUP_RNG);\r
 458 \r
 459     GpuMat src(src_host);\r
 460     GpuMat dst;\r
 461 \r
 462     TEST_CYCLE(100)\r
 463     {\r
 464         copyMakeBorder(src, dst, 5, 5, 5, 5, borderType);\r
 465     }\r
 466 \r
 467     Mat dst_host(dst);\r
 468 \r
 469     SANITY_CHECK(dst_host);\r
 470 }\r
 471 \r
 472 PERF_TEST_P(DevInfo_Size, integralBuffered, testing::Combine(testing::ValuesIn(devices()),\r
 473                                                              testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 474 {\r
 475     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 476     Size size = std::tr1::get<1>(GetParam());\r
 477 \r
 478     setDevice(devInfo.deviceID());\r
 479 \r
 480     Mat src_host(size, CV_8UC1);\r
 481 \r
 482     declare.in(src_host, WARMUP_RNG);\r
 483 \r
 484     GpuMat src(src_host);\r
 485     GpuMat dst;\r
 486     GpuMat buf;\r
 487 \r
 488     TEST_CYCLE(100)\r
 489     {\r
 490         integralBuffered(src, dst, buf);\r
 491     }\r
 492 \r
 493     Mat dst_host(dst);\r
 494 \r
 495     SANITY_CHECK(dst_host);\r
 496 }\r
 497 \r
 498 PERF_TEST_P(DevInfo_Size, integral, testing::Combine(testing::ValuesIn(devices()),\r
 499                                                      testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 500 {\r
 501     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 502     Size size = std::tr1::get<1>(GetParam());\r
 503 \r
 504     setDevice(devInfo.deviceID());\r
 505 \r
 506     Mat src_host(size, CV_8UC1);\r
 507 \r
 508     declare.in(src_host, WARMUP_RNG);\r
 509 \r
 510     GpuMat src(src_host);\r
 511     GpuMat sum, sqsum;\r
 512 \r
 513     TEST_CYCLE(100)\r
 514     {\r
 515         integral(src, sum, sqsum);\r
 516     }\r
 517 \r
 518     Mat sum_host(sum);\r
 519     Mat sqsum_host(sqsum);\r
 520 \r
 521     SANITY_CHECK(sum_host);\r
 522     SANITY_CHECK(sqsum_host);\r
 523 }\r
 524 \r
 525 PERF_TEST_P(DevInfo_Size, sqrIntegral, testing::Combine(testing::ValuesIn(devices()),\r
 526                                                         testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 527 {\r
 528     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 529     Size size = std::tr1::get<1>(GetParam());\r
 530 \r
 531     setDevice(devInfo.deviceID());\r
 532 \r
 533     Mat src_host(size, CV_8UC1);\r
 534 \r
 535     declare.in(src_host, WARMUP_RNG);\r
 536 \r
 537     GpuMat src(src_host);\r
 538     GpuMat dst;\r
 539 \r
 540     TEST_CYCLE(100)\r
 541     {\r
 542         sqrIntegral(src, dst);\r
 543     }\r
 544 \r
 545     Mat dst_host(dst);\r
 546 \r
 547     SANITY_CHECK(dst_host);\r
 548 }\r
 549 \r
 550 PERF_TEST_P(DevInfo_Size, columnSum, testing::Combine(testing::ValuesIn(devices()),\r
 551                                                       testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 552 {\r
 553     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 554     Size size = std::tr1::get<1>(GetParam());\r
 555 \r
 556     setDevice(devInfo.deviceID());\r
 557 \r
 558     Mat src_host(size, CV_32FC1);\r
 559 \r
 560     declare.in(src_host, WARMUP_RNG);\r
 561 \r
 562     GpuMat src(src_host);\r
 563     GpuMat dst;\r
 564 \r
 565     TEST_CYCLE(100)\r
 566     {\r
 567         columnSum(src, dst);\r
 568     }\r
 569 \r
 570     Mat dst_host(dst);\r
 571 \r
 572     SANITY_CHECK(dst_host);\r
 573 }\r
 574 \r
 575 PERF_TEST_P(DevInfo_MatType, cornerHarris, testing::Combine(testing::ValuesIn(devices()),\r
 576                                                             testing::Values(CV_8UC1, CV_32FC1)))\r
 577 {\r
 578     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 579     int type = std::tr1::get<1>(GetParam());\r
 580 \r
 581     setDevice(devInfo.deviceID());\r
 582     \r
 583     Mat img = readImage("gpu/stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE);\r
 584     ASSERT_FALSE(img.empty());\r
 585 \r
 586     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
 587 \r
 588     GpuMat src(img);\r
 589     GpuMat dst;\r
 590     GpuMat Dx;\r
 591     GpuMat Dy;\r
 592 \r
 593     int blockSize = 3;\r
 594     int ksize = 7;        \r
 595     double k = 0.5;\r
 596 \r
 597     TEST_CYCLE(100)\r
 598     {\r
 599         cornerHarris(src, dst, Dx, Dy, blockSize, ksize, k);\r
 600     }\r
 601 \r
 602     Mat dst_host(dst);\r
 603     Mat Dx_host(Dx);\r
 604     Mat Dy_host(Dy);\r
 605 \r
 606     SANITY_CHECK(dst_host);\r
 607     SANITY_CHECK(Dx_host);\r
 608     SANITY_CHECK(Dy_host);\r
 609 }\r
 610 \r
 611 PERF_TEST_P(DevInfo_MatType, cornerMinEigenVal, testing::Combine(testing::ValuesIn(devices()),\r
 612                                                             testing::Values(CV_8UC1, CV_32FC1)))\r
 613 {\r
 614     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 615     int type = std::tr1::get<1>(GetParam());\r
 616 \r
 617     setDevice(devInfo.deviceID());\r
 618     \r
 619     Mat img = readImage("gpu/stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE);\r
 620     ASSERT_FALSE(img.empty());\r
 621 \r
 622     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
 623 \r
 624     GpuMat src(img);\r
 625     GpuMat dst;\r
 626     GpuMat Dx;\r
 627     GpuMat Dy;\r
 628 \r
 629     int blockSize = 3;\r
 630     int ksize = 7; \r
 631 \r
 632     TEST_CYCLE(100)\r
 633     {\r
 634         cornerMinEigenVal(src, dst, Dx, Dy, blockSize, ksize);\r
 635     }\r
 636 \r
 637     Mat dst_host(dst);\r
 638     Mat Dx_host(Dx);\r
 639     Mat Dy_host(Dy);\r
 640 \r
 641     SANITY_CHECK(dst_host);\r
 642     SANITY_CHECK(Dx_host);\r
 643     SANITY_CHECK(Dy_host);\r
 644 }\r
 645 \r
 646 PERF_TEST_P(DevInfo_Size_MatType, mulSpectrums, testing::Combine(testing::ValuesIn(devices()),\r
 647                                                                  testing::Values(GPU_TYPICAL_MAT_SIZES),\r
 648                                                                  testing::Values(CV_8UC1, CV_32FC1)))\r
 649 {\r
 650     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 651     Size size = std::tr1::get<1>(GetParam());\r
 652     int type = std::tr1::get<2>(GetParam());\r
 653 \r
 654     setDevice(devInfo.deviceID());\r
 655 \r
 656     Mat a_host(size, CV_32FC2);\r
 657     Mat b_host(size, CV_32FC2);\r
 658 \r
 659     declare.in(a_host, b_host, WARMUP_RNG);\r
 660 \r
 661     GpuMat a(a_host);\r
 662     GpuMat b(b_host);\r
 663     GpuMat dst;\r
 664 \r
 665     TEST_CYCLE(100)\r
 666     {\r
 667         mulSpectrums(a, b, dst, 0);\r
 668     }\r
 669 \r
 670     Mat dst_host(dst);\r
 671 \r
 672     SANITY_CHECK(dst_host);\r
 673 }\r
 674 \r
 675 PERF_TEST_P(DevInfo_Size, dft, testing::Combine(testing::ValuesIn(devices()),\r
 676                                                 testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 677 {\r
 678     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 679     Size size = std::tr1::get<1>(GetParam());\r
 680 \r
 681     setDevice(devInfo.deviceID());\r
 682 \r
 683     Mat src_host(size, CV_32FC2);\r
 684 \r
 685     declare.in(src_host, WARMUP_RNG);\r
 686 \r
 687     GpuMat src(src_host);\r
 688     GpuMat dst;\r
 689 \r
 690     declare.time(2.0);\r
 691 \r
 692     TEST_CYCLE(100)\r
 693     {\r
 694         dft(src, dst, size);\r
 695     }\r
 696 \r
 697     Mat dst_host(dst);\r
 698 \r
 699     SANITY_CHECK(dst_host);\r
 700 }\r
 701 \r
 702 PERF_TEST_P(DevInfo_Int_Int, convolve, testing::Combine(testing::ValuesIn(devices()),\r
 703                                                      testing::Values(512, 1024, 1536, 2048, 2560, 3072, 3584),\r
 704                                                      testing::Values(3, 9, 27, 32, 64)))\r
 705 {\r
 706     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 707     int image_size = std::tr1::get<1>(GetParam());\r
 708     int templ_size = std::tr1::get<2>(GetParam());\r
 709 \r
 710     setDevice(devInfo.deviceID());\r
 711 \r
 712     GpuMat image = createContinuous(image_size, image_size, CV_32FC1);\r
 713     GpuMat templ = createContinuous(templ_size, templ_size, CV_32FC1);\r
 714 \r
 715     image.setTo(Scalar(1.0));\r
 716     templ.setTo(Scalar(1.0));\r
 717 \r
 718     GpuMat dst;\r
 719     ConvolveBuf buf;\r
 720 \r
 721     declare.time(2.0);\r
 722 \r
 723     TEST_CYCLE(100)\r
 724     {\r
 725         convolve(image, templ, dst, false, buf);\r
 726     }\r
 727 \r
 728     Mat dst_host(dst);\r
 729 \r
 730     SANITY_CHECK(dst_host);\r
 731 }\r
 732 \r
 733 PERF_TEST_P(DevInfo_Size_MatType, pyrDown, testing::Combine(testing::ValuesIn(devices()),\r
 734                                                             testing::Values(GPU_TYPICAL_MAT_SIZES),\r
 735                                                             testing::Values(CV_8UC1, CV_8UC4, CV_16SC3, CV_32FC1)))\r
 736 {\r
 737     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 738     Size size = std::tr1::get<1>(GetParam());\r
 739     int type = std::tr1::get<2>(GetParam());\r
 740 \r
 741     setDevice(devInfo.deviceID());\r
 742 \r
 743     Mat src_host(size, type);\r
 744 \r
 745     declare.in(src_host, WARMUP_RNG);\r
 746 \r
 747     GpuMat src(src_host);\r
 748     GpuMat dst;\r
 749 \r
 750     TEST_CYCLE(100)\r
 751     {\r
 752         pyrDown(src, dst);\r
 753     }\r
 754 \r
 755     Mat dst_host(dst);\r
 756 \r
 757     SANITY_CHECK(dst_host);\r
 758 }\r
 759 \r
 760 PERF_TEST_P(DevInfo_Size_MatType, pyrUp, testing::Combine(testing::ValuesIn(devices()),\r
 761                                                           testing::Values(GPU_TYPICAL_MAT_SIZES),\r
 762                                                           testing::Values(CV_8UC1, CV_8UC4, CV_16SC3, CV_32FC1)))\r
 763 {\r
 764     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 765     Size size = std::tr1::get<1>(GetParam());\r
 766     int type = std::tr1::get<2>(GetParam());\r
 767 \r
 768     setDevice(devInfo.deviceID());\r
 769 \r
 770     Mat src_host(size, type);\r
 771 \r
 772     declare.in(src_host, WARMUP_RNG);\r
 773 \r
 774     GpuMat src(src_host);\r
 775     GpuMat dst;\r
 776 \r
 777     TEST_CYCLE(100)\r
 778     {\r
 779         pyrUp(src, dst);\r
 780     }\r
 781 \r
 782     Mat dst_host(dst);\r
 783 \r
 784     SANITY_CHECK(dst_host);\r
 785 }\r
 786 \r
 787 PERF_TEST_P(DevInfo_Size_MatType, blendLinear, testing::Combine(testing::ValuesIn(devices()),\r
 788                                                                 testing::Values(GPU_TYPICAL_MAT_SIZES),\r
 789                                                                 testing::Values(CV_8UC1, CV_32FC1)))\r
 790 {\r
 791     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 792     Size size = std::tr1::get<1>(GetParam());\r
 793     int type = std::tr1::get<2>(GetParam());\r
 794 \r
 795     setDevice(devInfo.deviceID());\r
 796 \r
 797     Mat img1_host(size, type);\r
 798     Mat img2_host(size, type);\r
 799 \r
 800     declare.in(img1_host, img2_host, WARMUP_RNG);\r
 801 \r
 802     GpuMat img1(img1_host);\r
 803     GpuMat img2(img2_host);\r
 804     GpuMat weights1(size, CV_32FC1, Scalar::all(0.5));\r
 805     GpuMat weights2(size, CV_32FC1, Scalar::all(0.5));\r
 806     GpuMat dst;\r
 807 \r
 808     TEST_CYCLE(100)\r
 809     {\r
 810         blendLinear(img1, img2, weights1, weights2, dst);\r
 811     }\r
 812 \r
 813     Mat dst_host(dst);\r
 814 \r
 815     SANITY_CHECK(dst_host);\r
 816 }\r
 817 \r
 818 PERF_TEST_P(DevInfo, Canny, testing::ValuesIn(devices()))\r
 819 {\r
 820     DeviceInfo devInfo = GetParam();\r
 821 \r
 822     setDevice(devInfo.deviceID());\r
 823 \r
 824     Mat image_host = readImage("gpu/perf/aloe.jpg", CV_LOAD_IMAGE_GRAYSCALE);\r
 825     ASSERT_FALSE(image_host.empty());\r
 826 \r
 827     GpuMat image(image_host);\r
 828     GpuMat dst;\r
 829     CannyBuf buf;\r
 830 \r
 831     TEST_CYCLE(100)\r
 832     {\r
 833         Canny(image, buf, dst, 50.0, 100.0);\r
 834     }\r
 835 \r
 836     Mat dst_host(dst);\r
 837 \r
 838     SANITY_CHECK(dst_host);\r
 839 }\r
 840 \r
 841 PERF_TEST_P(DevInfo_Size, calcHist, testing::Combine(testing::ValuesIn(devices()),\r
 842                                                      testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 843 {\r
 844     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 845     Size size = std::tr1::get<1>(GetParam());\r
 846 \r
 847     setDevice(devInfo.deviceID());\r
 848 \r
 849     Mat src_host(size, CV_8UC1);\r
 850 \r
 851     declare.in(src_host, WARMUP_RNG);\r
 852 \r
 853     GpuMat src(src_host);\r
 854     GpuMat hist;\r
 855     GpuMat buf;\r
 856 \r
 857     TEST_CYCLE(100)\r
 858     {\r
 859         calcHist(src, hist, buf);\r
 860     }\r
 861 \r
 862     Mat hist_host(hist);\r
 863 \r
 864     SANITY_CHECK(hist_host);\r
 865 }\r
 866 \r
 867 PERF_TEST_P(DevInfo_Size, equalizeHist, testing::Combine(testing::ValuesIn(devices()),\r
 868                                                          testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 869 {\r
 870     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 871     Size size = std::tr1::get<1>(GetParam());\r
 872 \r
 873     setDevice(devInfo.deviceID());\r
 874 \r
 875     Mat src_host(size, CV_8UC1);\r
 876 \r
 877     declare.in(src_host, WARMUP_RNG);\r
 878 \r
 879     GpuMat src(src_host);\r
 880     GpuMat dst;\r
 881     GpuMat hist;\r
 882     GpuMat buf;\r
 883 \r
 884     TEST_CYCLE(100)\r
 885     {\r
 886         equalizeHist(src, dst, hist, buf);\r
 887     }\r
 888 \r
 889     Mat dst_host(dst);\r
 890 \r
 891     SANITY_CHECK(dst_host);\r
 892 }\r