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, copyMakeBorder, testing::Combine(testing::ValuesIn(devices()),\r
 464                                                                          testing::Values(GPU_TYPICAL_MAT_SIZES), \r
 465                                                                          testing::Values(CV_8UC1, CV_8UC4, CV_32SC1)))\r
 466 {\r
 467     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 468     Size size = std::tr1::get<1>(GetParam());\r
 469     int type = std::tr1::get<2>(GetParam());\r
 470 \r
 471     setDevice(devInfo.deviceID());\r
 472 \r
 473     Mat src_host(size, type);\r
 474 \r
 475     declare.in(src_host, WARMUP_RNG);\r
 476 \r
 477     GpuMat src(src_host);\r
 478     GpuMat dst;\r
 479 \r
 480     declare.time(0.5).iterations(100);\r
 481 \r
 482     SIMPLE_TEST_CYCLE()\r
 483     {\r
 484         copyMakeBorder(src, dst, 5, 5, 5, 5);\r
 485     }\r
 486 \r
 487     Mat dst_host(dst);\r
 488 \r
 489     SANITY_CHECK(dst_host);\r
 490 }\r
 491 \r
 492 PERF_TEST_P(DevInfo_Size, integralBuffered, testing::Combine(testing::ValuesIn(devices()),\r
 493                                                              testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 494 {\r
 495     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 496     Size size = std::tr1::get<1>(GetParam());\r
 497 \r
 498     setDevice(devInfo.deviceID());\r
 499 \r
 500     Mat src_host(size, CV_8UC1);\r
 501 \r
 502     declare.in(src_host, WARMUP_RNG);\r
 503 \r
 504     GpuMat src(src_host);\r
 505     GpuMat dst;\r
 506     GpuMat buf;\r
 507 \r
 508     declare.time(0.5).iterations(100);\r
 509 \r
 510     SIMPLE_TEST_CYCLE()\r
 511     {\r
 512         integralBuffered(src, dst, buf);\r
 513     }\r
 514 \r
 515     Mat dst_host(dst);\r
 516 \r
 517     SANITY_CHECK(dst_host);\r
 518 }\r
 519 \r
 520 PERF_TEST_P(DevInfo_Size, integral, testing::Combine(testing::ValuesIn(devices()),\r
 521                                                      testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 522 {\r
 523     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 524     Size size = std::tr1::get<1>(GetParam());\r
 525 \r
 526     setDevice(devInfo.deviceID());\r
 527 \r
 528     Mat src_host(size, CV_8UC1);\r
 529 \r
 530     declare.in(src_host, WARMUP_RNG);\r
 531 \r
 532     GpuMat src(src_host);\r
 533     GpuMat sum, sqsum;\r
 534 \r
 535     declare.time(0.5).iterations(100);\r
 536 \r
 537     SIMPLE_TEST_CYCLE()\r
 538     {\r
 539         integral(src, sum, sqsum);\r
 540     }\r
 541 \r
 542     Mat sum_host(sum);\r
 543     Mat sqsum_host(sqsum);\r
 544 \r
 545     SANITY_CHECK(sum_host);\r
 546     SANITY_CHECK(sqsum_host);\r
 547 }\r
 548 \r
 549 PERF_TEST_P(DevInfo_Size, sqrIntegral, testing::Combine(testing::ValuesIn(devices()),\r
 550                                                         testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 551 {\r
 552     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 553     Size size = std::tr1::get<1>(GetParam());\r
 554 \r
 555     setDevice(devInfo.deviceID());\r
 556 \r
 557     Mat src_host(size, CV_8UC1);\r
 558 \r
 559     declare.in(src_host, WARMUP_RNG);\r
 560 \r
 561     GpuMat src(src_host);\r
 562     GpuMat dst;\r
 563 \r
 564     declare.time(0.5).iterations(100);\r
 565 \r
 566     SIMPLE_TEST_CYCLE()\r
 567     {\r
 568         sqrIntegral(src, dst);\r
 569     }\r
 570 \r
 571     Mat dst_host(dst);\r
 572 \r
 573     SANITY_CHECK(dst_host);\r
 574 }\r
 575 \r
 576 PERF_TEST_P(DevInfo_Size, columnSum, testing::Combine(testing::ValuesIn(devices()),\r
 577                                                       testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 578 {\r
 579     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 580     Size size = std::tr1::get<1>(GetParam());\r
 581 \r
 582     setDevice(devInfo.deviceID());\r
 583 \r
 584     Mat src_host(size, CV_32FC1);\r
 585 \r
 586     declare.in(src_host, WARMUP_RNG);\r
 587 \r
 588     GpuMat src(src_host);\r
 589     GpuMat dst;\r
 590 \r
 591     declare.time(0.5).iterations(100);\r
 592 \r
 593     SIMPLE_TEST_CYCLE()\r
 594     {\r
 595         columnSum(src, dst);\r
 596     }\r
 597 \r
 598     Mat dst_host(dst);\r
 599 \r
 600     SANITY_CHECK(dst_host);\r
 601 }\r
 602 \r
 603 PERF_TEST_P(DevInfo_MatType, cornerHarris, testing::Combine(testing::ValuesIn(devices()),\r
 604                                                             testing::Values(CV_8UC1, CV_32FC1)))\r
 605 {\r
 606     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 607     int type = std::tr1::get<1>(GetParam());\r
 608 \r
 609     setDevice(devInfo.deviceID());\r
 610     \r
 611     Mat img = readImage("gpu/stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE);\r
 612     ASSERT_FALSE(img.empty());\r
 613 \r
 614     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
 615 \r
 616     GpuMat src(img);\r
 617     GpuMat dst;\r
 618     GpuMat Dx;\r
 619     GpuMat Dy;\r
 620 \r
 621     int blockSize = 3;\r
 622     int ksize = 7;        \r
 623     double k = 0.5;\r
 624 \r
 625     declare.time(0.5).iterations(100);\r
 626 \r
 627     SIMPLE_TEST_CYCLE()\r
 628     {\r
 629         cornerHarris(src, dst, Dx, Dy, blockSize, ksize, k);\r
 630     }\r
 631 \r
 632     Mat dst_host(dst);\r
 633     Mat Dx_host(Dx);\r
 634     Mat Dy_host(Dy);\r
 635 \r
 636     SANITY_CHECK(dst_host);\r
 637     SANITY_CHECK(Dx_host);\r
 638     SANITY_CHECK(Dy_host);\r
 639 }\r
 640 \r
 641 PERF_TEST_P(DevInfo_MatType, cornerMinEigenVal, testing::Combine(testing::ValuesIn(devices()),\r
 642                                                             testing::Values(CV_8UC1, CV_32FC1)))\r
 643 {\r
 644     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 645     int type = std::tr1::get<1>(GetParam());\r
 646 \r
 647     setDevice(devInfo.deviceID());\r
 648     \r
 649     Mat img = readImage("gpu/stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE);\r
 650     ASSERT_FALSE(img.empty());\r
 651 \r
 652     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
 653 \r
 654     GpuMat src(img);\r
 655     GpuMat dst;\r
 656     GpuMat Dx;\r
 657     GpuMat Dy;\r
 658 \r
 659     int blockSize = 3;\r
 660     int ksize = 7; \r
 661 \r
 662     declare.time(0.5).iterations(100);\r
 663 \r
 664     SIMPLE_TEST_CYCLE()\r
 665     {\r
 666         cornerMinEigenVal(src, dst, Dx, Dy, blockSize, ksize);\r
 667     }\r
 668 \r
 669     Mat dst_host(dst);\r
 670     Mat Dx_host(Dx);\r
 671     Mat Dy_host(Dy);\r
 672 \r
 673     SANITY_CHECK(dst_host);\r
 674     SANITY_CHECK(Dx_host);\r
 675     SANITY_CHECK(Dy_host);\r
 676 }\r
 677 \r
 678 PERF_TEST_P(DevInfo_Size_MatType, mulSpectrums, testing::Combine(testing::ValuesIn(devices()),\r
 679                                                                  testing::Values(GPU_TYPICAL_MAT_SIZES),\r
 680                                                                  testing::Values(CV_8UC1, CV_32FC1)))\r
 681 {\r
 682     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 683     Size size = std::tr1::get<1>(GetParam());\r
 684     int type = std::tr1::get<2>(GetParam());\r
 685 \r
 686     setDevice(devInfo.deviceID());\r
 687 \r
 688     Mat a_host(size, CV_32FC2);\r
 689     Mat b_host(size, CV_32FC2);\r
 690 \r
 691     declare.in(a_host, b_host, WARMUP_RNG);\r
 692 \r
 693     GpuMat a(a_host);\r
 694     GpuMat b(b_host);\r
 695     GpuMat dst;\r
 696 \r
 697     declare.time(0.5).iterations(100);\r
 698 \r
 699     SIMPLE_TEST_CYCLE()\r
 700     {\r
 701         mulSpectrums(a, b, dst, 0);\r
 702     }\r
 703 \r
 704     Mat dst_host(dst);\r
 705 \r
 706     SANITY_CHECK(dst_host);\r
 707 }\r
 708 \r
 709 PERF_TEST_P(DevInfo_Size, dft, testing::Combine(testing::ValuesIn(devices()),\r
 710                                                 testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 711 {\r
 712     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 713     Size size = std::tr1::get<1>(GetParam());\r
 714 \r
 715     setDevice(devInfo.deviceID());\r
 716 \r
 717     Mat src_host(size, CV_32FC2);\r
 718 \r
 719     declare.in(src_host, WARMUP_RNG);\r
 720 \r
 721     GpuMat src(src_host);\r
 722     GpuMat dst;\r
 723 \r
 724     declare.time(2.0).iterations(100);\r
 725 \r
 726     SIMPLE_TEST_CYCLE()\r
 727     {\r
 728         dft(src, dst, size);\r
 729     }\r
 730 \r
 731     Mat dst_host(dst);\r
 732 \r
 733     SANITY_CHECK(dst_host);\r
 734 }\r
 735 \r
 736 PERF_TEST_P(DevInfo_Size, convolve, testing::Combine(testing::ValuesIn(devices()),\r
 737                                                 testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 738 {\r
 739     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 740     Size size = std::tr1::get<1>(GetParam());\r
 741 \r
 742     setDevice(devInfo.deviceID());\r
 743 \r
 744     Mat image_host(size, CV_32FC1);\r
 745     Mat templ_host(size, CV_32FC1);\r
 746 \r
 747     declare.in(image_host, templ_host, WARMUP_RNG);\r
 748 \r
 749     GpuMat image(image_host);\r
 750     GpuMat templ(templ_host);\r
 751     GpuMat dst;\r
 752     ConvolveBuf buf;\r
 753 \r
 754     declare.time(2.0).iterations(100);\r
 755 \r
 756     SIMPLE_TEST_CYCLE()\r
 757     {\r
 758         convolve(image, templ, dst, false, buf);\r
 759     }\r
 760 \r
 761     Mat dst_host(dst);\r
 762 \r
 763     SANITY_CHECK(dst_host);\r
 764 }\r
 765 \r
 766 PERF_TEST_P(DevInfo_Size_MatType, pyrDown, testing::Combine(testing::ValuesIn(devices()),\r
 767                                                             testing::Values(GPU_TYPICAL_MAT_SIZES),\r
 768                                                             testing::Values(CV_8UC1, CV_8UC4, CV_16SC3, CV_32FC1)))\r
 769 {\r
 770     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 771     Size size = std::tr1::get<1>(GetParam());\r
 772     int type = std::tr1::get<2>(GetParam());\r
 773 \r
 774     setDevice(devInfo.deviceID());\r
 775 \r
 776     Mat src_host(size, type);\r
 777 \r
 778     declare.in(src_host, WARMUP_RNG);\r
 779 \r
 780     GpuMat src(src_host);\r
 781     GpuMat dst;\r
 782 \r
 783     declare.time(0.5).iterations(100);\r
 784 \r
 785     SIMPLE_TEST_CYCLE()\r
 786     {\r
 787         pyrDown(src, dst);\r
 788     }\r
 789 \r
 790     Mat dst_host(dst);\r
 791 \r
 792     SANITY_CHECK(dst_host);\r
 793 }\r
 794 \r
 795 PERF_TEST_P(DevInfo_Size_MatType, pyrUp, testing::Combine(testing::ValuesIn(devices()),\r
 796                                                           testing::Values(GPU_TYPICAL_MAT_SIZES),\r
 797                                                           testing::Values(CV_8UC1, CV_8UC4, CV_16SC3, CV_32FC1)))\r
 798 {\r
 799     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 800     Size size = std::tr1::get<1>(GetParam());\r
 801     int type = std::tr1::get<2>(GetParam());\r
 802 \r
 803     setDevice(devInfo.deviceID());\r
 804 \r
 805     Mat src_host(size, type);\r
 806 \r
 807     declare.in(src_host, WARMUP_RNG);\r
 808 \r
 809     GpuMat src(src_host);\r
 810     GpuMat dst;\r
 811 \r
 812     declare.time(0.5).iterations(100);\r
 813 \r
 814     SIMPLE_TEST_CYCLE()\r
 815     {\r
 816         pyrUp(src, dst);\r
 817     }\r
 818 \r
 819     Mat dst_host(dst);\r
 820 \r
 821     SANITY_CHECK(dst_host);\r
 822 }\r
 823 \r
 824 PERF_TEST_P(DevInfo_Size_MatType, blendLinear, testing::Combine(testing::ValuesIn(devices()),\r
 825                                                                 testing::Values(GPU_TYPICAL_MAT_SIZES),\r
 826                                                                 testing::Values(CV_8UC1, CV_32FC1)))\r
 827 {\r
 828     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 829     Size size = std::tr1::get<1>(GetParam());\r
 830     int type = std::tr1::get<2>(GetParam());\r
 831 \r
 832     setDevice(devInfo.deviceID());\r
 833 \r
 834     Mat img1_host(size, type);\r
 835     Mat img2_host(size, type);\r
 836 \r
 837     declare.in(img1_host, img2_host, WARMUP_RNG);\r
 838 \r
 839     GpuMat img1(img1_host);\r
 840     GpuMat img2(img2_host);\r
 841     GpuMat weights1(size, CV_32FC1, Scalar::all(0.5));\r
 842     GpuMat weights2(size, CV_32FC1, Scalar::all(0.5));\r
 843     GpuMat dst;\r
 844 \r
 845     declare.time(0.5).iterations(100);\r
 846 \r
 847     SIMPLE_TEST_CYCLE()\r
 848     {\r
 849         blendLinear(img1, img2, weights1, weights2, dst);\r
 850     }\r
 851 \r
 852     Mat dst_host(dst);\r
 853 \r
 854     SANITY_CHECK(dst_host);\r
 855 }\r
 856 \r
 857 PERF_TEST_P(DevInfo, Canny, testing::ValuesIn(devices()))\r
 858 {\r
 859     DeviceInfo devInfo = GetParam();\r
 860 \r
 861     setDevice(devInfo.deviceID());\r
 862 \r
 863     Mat image_host = readImage("gpu/perf/aloe.jpg", CV_LOAD_IMAGE_GRAYSCALE);\r
 864     ASSERT_FALSE(image_host.empty());\r
 865 \r
 866     GpuMat image(image_host);\r
 867     GpuMat dst;\r
 868     CannyBuf buf;\r
 869 \r
 870     declare.time(0.5).iterations(100);\r
 871 \r
 872     SIMPLE_TEST_CYCLE()\r
 873     {\r
 874         Canny(image, buf, dst, 50.0, 100.0);\r
 875     }\r
 876 \r
 877     Mat dst_host(dst);\r
 878 \r
 879     SANITY_CHECK(dst_host);\r
 880 }\r
 881 \r
 882 PERF_TEST_P(DevInfo_Size, calcHist, testing::Combine(testing::ValuesIn(devices()),\r
 883                                                      testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 884 {\r
 885     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 886     Size size = std::tr1::get<1>(GetParam());\r
 887 \r
 888     setDevice(devInfo.deviceID());\r
 889 \r
 890     Mat src_host(size, CV_8UC1);\r
 891 \r
 892     declare.in(src_host, WARMUP_RNG);\r
 893 \r
 894     GpuMat src(src_host);\r
 895     GpuMat hist;\r
 896     GpuMat buf;\r
 897 \r
 898     declare.time(0.5).iterations(100);\r
 899 \r
 900     SIMPLE_TEST_CYCLE()\r
 901     {\r
 902         calcHist(src, hist, buf);\r
 903     }\r
 904 \r
 905     Mat hist_host(hist);\r
 906 \r
 907     SANITY_CHECK(hist_host);\r
 908 }\r
 909 \r
 910 PERF_TEST_P(DevInfo_Size, equalizeHist, testing::Combine(testing::ValuesIn(devices()),\r
 911                                                          testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 912 {\r
 913     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
 914     Size size = std::tr1::get<1>(GetParam());\r
 915 \r
 916     setDevice(devInfo.deviceID());\r
 917 \r
 918     Mat src_host(size, CV_8UC1);\r
 919 \r
 920     declare.in(src_host, WARMUP_RNG);\r
 921 \r
 922     GpuMat src(src_host);\r
 923     GpuMat dst;\r
 924     GpuMat hist;\r
 925     GpuMat buf;\r
 926 \r
 927     declare.time(0.5).iterations(100);\r
 928 \r
 929     SIMPLE_TEST_CYCLE()\r
 930     {\r
 931         equalizeHist(src, dst, hist, buf);\r
 932     }\r
 933 \r
 934     Mat dst_host(dst);\r
 935 \r
 936     SANITY_CHECK(dst_host);\r
 937 }\r