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