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