1 /*M/////////////////////////////////////////////////////////////////////////////////////// 2 // 3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 // 5 // By downloading, copying, installing or using the software you agree to this license. 6 // If you do not agree to this license, do not download, install, 7 // copy or use the software. 8 // 9 // 10 // License Agreement 11 // For Open Source Computer Vision Library 12 // 13 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 // Copyright (C) 2009, Willow Garage Inc., all rights reserved. 15 // Third party copyrights are property of their respective owners. 16 // 17 // Redistribution and use in source and binary forms, with or without modification, 18 // are permitted provided that the following conditions are met: 19 // 20 // * Redistribution's of source code must retain the above copyright notice, 21 // this list of conditions and the following disclaimer. 22 // 23 // * Redistribution's in binary form must reproduce the above copyright notice, 24 // this list of conditions and the following disclaimer in the documentation 25 // and/or other materials provided with the distribution. 26 // 27 // * The name of the copyright holders may not be used to endorse or promote products 28 // derived from this software without specific prior written permission. 29 // 30 // This software is provided by the copyright holders and contributors "as is" and 31 // any express or implied warranties, including, but not limited to, the implied 32 // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 // In no event shall the Intel Corporation or contributors be liable for any direct, 34 // indirect, incidental, special, exemplary, or consequential damages 35 // (including, but not limited to, procurement of substitute goods or services; 36 // loss of use, data, or profits; or business interruption) however caused 37 // and on any theory of liability, whether in contract, strict liability, 38 // or tort (including negligence or otherwise) arising in any way out of 39 // the use of this software, even if advised of the possibility of such damage. 40 // 41 //M*/ 42 43 #include "test_precomp.hpp" 44 45 #ifdef HAVE_CUDA 46 47 using namespace cvtest; 48 49 namespace 50 { 51 IMPLEMENT_PARAM_CLASS(KSize, cv::Size) 52 IMPLEMENT_PARAM_CLASS(Anchor, cv::Point) 53 IMPLEMENT_PARAM_CLASS(Deriv_X, int) 54 IMPLEMENT_PARAM_CLASS(Deriv_Y, int) 55 IMPLEMENT_PARAM_CLASS(Iterations, int) 56 57 cv::Mat getInnerROI(cv::InputArray m_, cv::Size ksize) 58 { 59 cv::Mat m = getMat(m_); 60 cv::Rect roi(ksize.width, ksize.height, m.cols - 2 * ksize.width, m.rows - 2 * ksize.height); 61 return m(roi); 62 } 63 64 cv::Mat getInnerROI(cv::InputArray m, int ksize) 65 { 66 return getInnerROI(m, cv::Size(ksize, ksize)); 67 } 68 } 69 70 ///////////////////////////////////////////////////////////////////////////////////////////////// 71 // Blur 72 73 PARAM_TEST_CASE(Blur, cv::cuda::DeviceInfo, cv::Size, MatType, KSize, Anchor, BorderType, UseRoi) 74 { 75 cv::cuda::DeviceInfo devInfo; 76 cv::Size size; 77 int type; 78 cv::Size ksize; 79 cv::Point anchor; 80 int borderType; 81 bool useRoi; 82 83 virtual void SetUp() 84 { 85 devInfo = GET_PARAM(0); 86 size = GET_PARAM(1); 87 type = GET_PARAM(2); 88 ksize = GET_PARAM(3); 89 anchor = GET_PARAM(4); 90 borderType = GET_PARAM(5); 91 useRoi = GET_PARAM(6); 92 93 cv::cuda::setDevice(devInfo.deviceID()); 94 } 95 }; 96 97 CUDA_TEST_P(Blur, Accuracy) 98 { 99 cv::Mat src = randomMat(size, type); 100 101 cv::Ptr<cv::cuda::Filter> blurFilter = cv::cuda::createBoxFilter(src.type(), -1, ksize, anchor, borderType); 102 103 cv::cuda::GpuMat dst = createMat(size, type, useRoi); 104 blurFilter->apply(loadMat(src, useRoi), dst); 105 106 cv::Mat dst_gold; 107 cv::blur(src, dst_gold, ksize, anchor, borderType); 108 109 EXPECT_MAT_NEAR(dst_gold, dst, 1.0); 110 } 111 112 INSTANTIATE_TEST_CASE_P(CUDA_Filters, Blur, testing::Combine( 113 ALL_DEVICES, 114 DIFFERENT_SIZES, 115 testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)), 116 testing::Values(KSize(cv::Size(3, 3)), KSize(cv::Size(5, 5)), KSize(cv::Size(7, 7))), 117 testing::Values(Anchor(cv::Point(-1, -1)), Anchor(cv::Point(0, 0)), Anchor(cv::Point(2, 2))), 118 testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT)), 119 WHOLE_SUBMAT)); 120 121 ///////////////////////////////////////////////////////////////////////////////////////////////// 122 // Filter2D 123 124 PARAM_TEST_CASE(Filter2D, cv::cuda::DeviceInfo, cv::Size, MatType, KSize, Anchor, BorderType, UseRoi) 125 { 126 cv::cuda::DeviceInfo devInfo; 127 cv::Size size; 128 int type; 129 cv::Size ksize; 130 cv::Point anchor; 131 int borderType; 132 bool useRoi; 133 134 virtual void SetUp() 135 { 136 devInfo = GET_PARAM(0); 137 size = GET_PARAM(1); 138 type = GET_PARAM(2); 139 ksize = GET_PARAM(3); 140 anchor = GET_PARAM(4); 141 borderType = GET_PARAM(5); 142 useRoi = GET_PARAM(6); 143 144 cv::cuda::setDevice(devInfo.deviceID()); 145 } 146 }; 147 148 CUDA_TEST_P(Filter2D, Accuracy) 149 { 150 cv::Mat src = randomMat(size, type); 151 cv::Mat kernel = randomMat(cv::Size(ksize.width, ksize.height), CV_32FC1, 0.0, 1.0); 152 153 cv::Ptr<cv::cuda::Filter> filter2D = cv::cuda::createLinearFilter(src.type(), -1, kernel, anchor, borderType); 154 155 cv::cuda::GpuMat dst = createMat(size, type, useRoi); 156 filter2D->apply(loadMat(src, useRoi), dst); 157 158 cv::Mat dst_gold; 159 cv::filter2D(src, dst_gold, -1, kernel, anchor, 0, borderType); 160 161 EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1.0); 162 } 163 164 INSTANTIATE_TEST_CASE_P(CUDA_Filters, Filter2D, testing::Combine( 165 ALL_DEVICES, 166 DIFFERENT_SIZES, 167 testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC4)), 168 testing::Values(KSize(cv::Size(3, 3)), KSize(cv::Size(5, 5)), KSize(cv::Size(7, 7)), KSize(cv::Size(11, 11)), KSize(cv::Size(13, 13)), KSize(cv::Size(15, 15))), 169 testing::Values(Anchor(cv::Point(-1, -1)), Anchor(cv::Point(0, 0)), Anchor(cv::Point(2, 2))), 170 testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT)), 171 WHOLE_SUBMAT)); 172 173 ///////////////////////////////////////////////////////////////////////////////////////////////// 174 // Laplacian 175 176 PARAM_TEST_CASE(Laplacian, cv::cuda::DeviceInfo, cv::Size, MatType, KSize, UseRoi) 177 { 178 cv::cuda::DeviceInfo devInfo; 179 cv::Size size; 180 int type; 181 cv::Size ksize; 182 bool useRoi; 183 184 virtual void SetUp() 185 { 186 devInfo = GET_PARAM(0); 187 size = GET_PARAM(1); 188 type = GET_PARAM(2); 189 ksize = GET_PARAM(3); 190 useRoi = GET_PARAM(4); 191 192 cv::cuda::setDevice(devInfo.deviceID()); 193 } 194 }; 195 196 CUDA_TEST_P(Laplacian, Accuracy) 197 { 198 cv::Mat src = randomMat(size, type); 199 200 cv::Ptr<cv::cuda::Filter> laplacian = cv::cuda::createLaplacianFilter(src.type(), -1, ksize.width); 201 202 cv::cuda::GpuMat dst = createMat(size, type, useRoi); 203 laplacian->apply(loadMat(src, useRoi), dst); 204 205 cv::Mat dst_gold; 206 cv::Laplacian(src, dst_gold, -1, ksize.width); 207 208 EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 0.0 : 1e-3); 209 } 210 211 INSTANTIATE_TEST_CASE_P(CUDA_Filters, Laplacian, testing::Combine( 212 ALL_DEVICES, 213 DIFFERENT_SIZES, 214 testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1)), 215 testing::Values(KSize(cv::Size(1, 1)), KSize(cv::Size(3, 3))), 216 WHOLE_SUBMAT)); 217 218 ///////////////////////////////////////////////////////////////////////////////////////////////// 219 // SeparableLinearFilter 220 221 PARAM_TEST_CASE(SeparableLinearFilter, cv::cuda::DeviceInfo, cv::Size, MatDepth, Channels, KSize, Anchor, BorderType, UseRoi) 222 { 223 cv::cuda::DeviceInfo devInfo; 224 cv::Size size; 225 int depth; 226 int cn; 227 cv::Size ksize; 228 cv::Point anchor; 229 int borderType; 230 bool useRoi; 231 232 int type; 233 234 virtual void SetUp() 235 { 236 devInfo = GET_PARAM(0); 237 size = GET_PARAM(1); 238 depth = GET_PARAM(2); 239 cn = GET_PARAM(3); 240 ksize = GET_PARAM(4); 241 anchor = GET_PARAM(5); 242 borderType = GET_PARAM(6); 243 useRoi = GET_PARAM(7); 244 245 cv::cuda::setDevice(devInfo.deviceID()); 246 247 type = CV_MAKE_TYPE(depth, cn); 248 } 249 }; 250 251 CUDA_TEST_P(SeparableLinearFilter, Accuracy) 252 { 253 cv::Mat src = randomMat(size, type); 254 cv::Mat rowKernel = randomMat(Size(ksize.width, 1), CV_32FC1, 0.0, 1.0); 255 cv::Mat columnKernel = randomMat(Size(ksize.height, 1), CV_32FC1, 0.0, 1.0); 256 257 cv::Ptr<cv::cuda::Filter> filter = cv::cuda::createSeparableLinearFilter(src.type(), -1, rowKernel, columnKernel, anchor, borderType); 258 259 cv::cuda::GpuMat dst = createMat(size, type, useRoi); 260 filter->apply(loadMat(src, useRoi), dst); 261 262 cv::Mat dst_gold; 263 cv::sepFilter2D(src, dst_gold, -1, rowKernel, columnKernel, anchor, 0, borderType); 264 265 EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 1.0 : 1e-2); 266 } 267 268 INSTANTIATE_TEST_CASE_P(CUDA_Filters, SeparableLinearFilter, testing::Combine( 269 ALL_DEVICES, 270 DIFFERENT_SIZES, 271 testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)), 272 IMAGE_CHANNELS, 273 testing::Values(KSize(cv::Size(3, 3)), 274 KSize(cv::Size(7, 7)), 275 KSize(cv::Size(13, 13)), 276 KSize(cv::Size(15, 15)), 277 KSize(cv::Size(17, 17)), 278 KSize(cv::Size(23, 15)), 279 KSize(cv::Size(31, 3))), 280 testing::Values(Anchor(cv::Point(-1, -1)), Anchor(cv::Point(0, 0)), Anchor(cv::Point(2, 2))), 281 testing::Values(BorderType(cv::BORDER_REFLECT101), 282 BorderType(cv::BORDER_REPLICATE), 283 BorderType(cv::BORDER_CONSTANT), 284 BorderType(cv::BORDER_REFLECT)), 285 WHOLE_SUBMAT)); 286 287 ///////////////////////////////////////////////////////////////////////////////////////////////// 288 // Sobel 289 290 PARAM_TEST_CASE(Sobel, cv::cuda::DeviceInfo, cv::Size, MatDepth, Channels, KSize, Deriv_X, Deriv_Y, BorderType, UseRoi) 291 { 292 cv::cuda::DeviceInfo devInfo; 293 cv::Size size; 294 int depth; 295 int cn; 296 cv::Size ksize; 297 int dx; 298 int dy; 299 int borderType; 300 bool useRoi; 301 302 int type; 303 304 virtual void SetUp() 305 { 306 devInfo = GET_PARAM(0); 307 size = GET_PARAM(1); 308 depth = GET_PARAM(2); 309 cn = GET_PARAM(3); 310 ksize = GET_PARAM(4); 311 dx = GET_PARAM(5); 312 dy = GET_PARAM(6); 313 borderType = GET_PARAM(7); 314 useRoi = GET_PARAM(8); 315 316 cv::cuda::setDevice(devInfo.deviceID()); 317 318 type = CV_MAKE_TYPE(depth, cn); 319 } 320 }; 321 322 CUDA_TEST_P(Sobel, Accuracy) 323 { 324 if (dx == 0 && dy == 0) 325 return; 326 327 cv::Mat src = randomMat(size, type); 328 329 cv::Ptr<cv::cuda::Filter> sobel = cv::cuda::createSobelFilter(src.type(), -1, dx, dy, ksize.width, 1.0, borderType); 330 331 cv::cuda::GpuMat dst = createMat(size, type, useRoi); 332 sobel->apply(loadMat(src, useRoi), dst); 333 334 cv::Mat dst_gold; 335 cv::Sobel(src, dst_gold, -1, dx, dy, ksize.width, 1.0, 0.0, borderType); 336 337 EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 0.0 : 0.1); 338 } 339 340 INSTANTIATE_TEST_CASE_P(CUDA_Filters, Sobel, testing::Combine( 341 ALL_DEVICES, 342 DIFFERENT_SIZES, 343 testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)), 344 IMAGE_CHANNELS, 345 testing::Values(KSize(cv::Size(3, 3)), KSize(cv::Size(5, 5)), KSize(cv::Size(7, 7))), 346 testing::Values(Deriv_X(0), Deriv_X(1), Deriv_X(2)), 347 testing::Values(Deriv_Y(0), Deriv_Y(1), Deriv_Y(2)), 348 testing::Values(BorderType(cv::BORDER_REFLECT101), 349 BorderType(cv::BORDER_REPLICATE), 350 BorderType(cv::BORDER_CONSTANT), 351 BorderType(cv::BORDER_REFLECT)), 352 WHOLE_SUBMAT)); 353 354 ///////////////////////////////////////////////////////////////////////////////////////////////// 355 // Scharr 356 357 PARAM_TEST_CASE(Scharr, cv::cuda::DeviceInfo, cv::Size, MatDepth, Channels, Deriv_X, Deriv_Y, BorderType, UseRoi) 358 { 359 cv::cuda::DeviceInfo devInfo; 360 cv::Size size; 361 int depth; 362 int cn; 363 int dx; 364 int dy; 365 int borderType; 366 bool useRoi; 367 368 int type; 369 370 virtual void SetUp() 371 { 372 devInfo = GET_PARAM(0); 373 size = GET_PARAM(1); 374 depth = GET_PARAM(2); 375 cn = GET_PARAM(3); 376 dx = GET_PARAM(4); 377 dy = GET_PARAM(5); 378 borderType = GET_PARAM(6); 379 useRoi = GET_PARAM(7); 380 381 cv::cuda::setDevice(devInfo.deviceID()); 382 383 type = CV_MAKE_TYPE(depth, cn); 384 } 385 }; 386 387 CUDA_TEST_P(Scharr, Accuracy) 388 { 389 if (dx + dy != 1) 390 return; 391 392 cv::Mat src = randomMat(size, type); 393 394 cv::Ptr<cv::cuda::Filter> scharr = cv::cuda::createScharrFilter(src.type(), -1, dx, dy, 1.0, borderType); 395 396 cv::cuda::GpuMat dst = createMat(size, type, useRoi); 397 scharr->apply(loadMat(src, useRoi), dst); 398 399 cv::Mat dst_gold; 400 cv::Scharr(src, dst_gold, -1, dx, dy, 1.0, 0.0, borderType); 401 402 EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 0.0 : 0.1); 403 } 404 405 INSTANTIATE_TEST_CASE_P(CUDA_Filters, Scharr, testing::Combine( 406 ALL_DEVICES, 407 DIFFERENT_SIZES, 408 testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)), 409 IMAGE_CHANNELS, 410 testing::Values(Deriv_X(0), Deriv_X(1)), 411 testing::Values(Deriv_Y(0), Deriv_Y(1)), 412 testing::Values(BorderType(cv::BORDER_REFLECT101), 413 BorderType(cv::BORDER_REPLICATE), 414 BorderType(cv::BORDER_CONSTANT), 415 BorderType(cv::BORDER_REFLECT)), 416 WHOLE_SUBMAT)); 417 418 ///////////////////////////////////////////////////////////////////////////////////////////////// 419 // GaussianBlur 420 421 PARAM_TEST_CASE(GaussianBlur, cv::cuda::DeviceInfo, cv::Size, MatDepth, Channels, KSize, BorderType, UseRoi) 422 { 423 cv::cuda::DeviceInfo devInfo; 424 cv::Size size; 425 int depth; 426 int cn; 427 cv::Size ksize; 428 int borderType; 429 bool useRoi; 430 431 int type; 432 433 virtual void SetUp() 434 { 435 devInfo = GET_PARAM(0); 436 size = GET_PARAM(1); 437 depth = GET_PARAM(2); 438 cn = GET_PARAM(3); 439 ksize = GET_PARAM(4); 440 borderType = GET_PARAM(5); 441 useRoi = GET_PARAM(6); 442 443 cv::cuda::setDevice(devInfo.deviceID()); 444 445 type = CV_MAKE_TYPE(depth, cn); 446 } 447 }; 448 449 CUDA_TEST_P(GaussianBlur, Accuracy) 450 { 451 cv::Mat src = randomMat(size, type); 452 double sigma1 = randomDouble(0.1, 1.0); 453 double sigma2 = randomDouble(0.1, 1.0); 454 455 cv::Ptr<cv::cuda::Filter> gauss = cv::cuda::createGaussianFilter(src.type(), -1, ksize, sigma1, sigma2, borderType); 456 457 cv::cuda::GpuMat dst = createMat(size, type, useRoi); 458 gauss->apply(loadMat(src, useRoi), dst); 459 460 cv::Mat dst_gold; 461 cv::GaussianBlur(src, dst_gold, ksize, sigma1, sigma2, borderType); 462 463 EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 4.0 : 1e-4); 464 } 465 466 INSTANTIATE_TEST_CASE_P(CUDA_Filters, GaussianBlur, testing::Combine( 467 ALL_DEVICES, 468 DIFFERENT_SIZES, 469 testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)), 470 IMAGE_CHANNELS, 471 testing::Values(KSize(cv::Size(3, 3)), 472 KSize(cv::Size(5, 5)), 473 KSize(cv::Size(7, 7)), 474 KSize(cv::Size(9, 9)), 475 KSize(cv::Size(11, 11)), 476 KSize(cv::Size(13, 13)), 477 KSize(cv::Size(15, 15)), 478 KSize(cv::Size(17, 17)), 479 KSize(cv::Size(19, 19)), 480 KSize(cv::Size(21, 21)), 481 KSize(cv::Size(23, 23)), 482 KSize(cv::Size(25, 25)), 483 KSize(cv::Size(27, 27)), 484 KSize(cv::Size(29, 29)), 485 KSize(cv::Size(31, 31))), 486 testing::Values(BorderType(cv::BORDER_REFLECT101), 487 BorderType(cv::BORDER_REPLICATE), 488 BorderType(cv::BORDER_CONSTANT), 489 BorderType(cv::BORDER_REFLECT)), 490 WHOLE_SUBMAT)); 491 492 ///////////////////////////////////////////////////////////////////////////////////////////////// 493 // Erode 494 495 PARAM_TEST_CASE(Erode, cv::cuda::DeviceInfo, cv::Size, MatType, Anchor, Iterations, UseRoi) 496 { 497 cv::cuda::DeviceInfo devInfo; 498 cv::Size size; 499 int type; 500 cv::Point anchor; 501 int iterations; 502 bool useRoi; 503 504 virtual void SetUp() 505 { 506 devInfo = GET_PARAM(0); 507 size = GET_PARAM(1); 508 type = GET_PARAM(2); 509 anchor = GET_PARAM(3); 510 iterations = GET_PARAM(4); 511 useRoi = GET_PARAM(5); 512 513 cv::cuda::setDevice(devInfo.deviceID()); 514 } 515 }; 516 517 CUDA_TEST_P(Erode, Accuracy) 518 { 519 cv::Mat src = randomMat(size, type); 520 cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U); 521 522 cv::Ptr<cv::cuda::Filter> erode = cv::cuda::createMorphologyFilter(cv::MORPH_ERODE, src.type(), kernel, anchor, iterations); 523 524 cv::cuda::GpuMat dst = createMat(size, type, useRoi); 525 erode->apply(loadMat(src, useRoi), dst); 526 527 cv::Mat dst_gold; 528 cv::erode(src, dst_gold, kernel, anchor, iterations); 529 530 cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1)); 531 532 EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0); 533 } 534 535 INSTANTIATE_TEST_CASE_P(CUDA_Filters, Erode, testing::Combine( 536 ALL_DEVICES, 537 DIFFERENT_SIZES, 538 testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)), 539 testing::Values(Anchor(cv::Point(-1, -1)), Anchor(cv::Point(0, 0)), Anchor(cv::Point(2, 2))), 540 testing::Values(Iterations(1), Iterations(2), Iterations(3)), 541 WHOLE_SUBMAT)); 542 543 ///////////////////////////////////////////////////////////////////////////////////////////////// 544 // Dilate 545 546 PARAM_TEST_CASE(Dilate, cv::cuda::DeviceInfo, cv::Size, MatType, Anchor, Iterations, UseRoi) 547 { 548 cv::cuda::DeviceInfo devInfo; 549 cv::Size size; 550 int type; 551 cv::Point anchor; 552 int iterations; 553 bool useRoi; 554 555 virtual void SetUp() 556 { 557 devInfo = GET_PARAM(0); 558 size = GET_PARAM(1); 559 type = GET_PARAM(2); 560 anchor = GET_PARAM(3); 561 iterations = GET_PARAM(4); 562 useRoi = GET_PARAM(5); 563 564 cv::cuda::setDevice(devInfo.deviceID()); 565 } 566 }; 567 568 CUDA_TEST_P(Dilate, Accuracy) 569 { 570 cv::Mat src = randomMat(size, type); 571 cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U); 572 573 cv::Ptr<cv::cuda::Filter> dilate = cv::cuda::createMorphologyFilter(cv::MORPH_DILATE, src.type(), kernel, anchor, iterations); 574 575 cv::cuda::GpuMat dst = createMat(size, type, useRoi); 576 dilate->apply(loadMat(src, useRoi), dst); 577 578 cv::Mat dst_gold; 579 cv::dilate(src, dst_gold, kernel, anchor, iterations); 580 581 cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1)); 582 583 EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0); 584 } 585 586 INSTANTIATE_TEST_CASE_P(CUDA_Filters, Dilate, testing::Combine( 587 ALL_DEVICES, 588 DIFFERENT_SIZES, 589 testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)), 590 testing::Values(Anchor(cv::Point(-1, -1)), Anchor(cv::Point(0, 0)), Anchor(cv::Point(2, 2))), 591 testing::Values(Iterations(1), Iterations(2), Iterations(3)), 592 WHOLE_SUBMAT)); 593 594 ///////////////////////////////////////////////////////////////////////////////////////////////// 595 // MorphEx 596 597 CV_ENUM(MorphOp, MORPH_OPEN, MORPH_CLOSE, MORPH_GRADIENT, MORPH_TOPHAT, MORPH_BLACKHAT) 598 599 PARAM_TEST_CASE(MorphEx, cv::cuda::DeviceInfo, cv::Size, MatType, MorphOp, Anchor, Iterations, UseRoi) 600 { 601 cv::cuda::DeviceInfo devInfo; 602 cv::Size size; 603 int type; 604 int morphOp; 605 cv::Point anchor; 606 int iterations; 607 bool useRoi; 608 609 virtual void SetUp() 610 { 611 devInfo = GET_PARAM(0); 612 size = GET_PARAM(1); 613 type = GET_PARAM(2); 614 morphOp = GET_PARAM(3); 615 anchor = GET_PARAM(4); 616 iterations = GET_PARAM(5); 617 useRoi = GET_PARAM(6); 618 619 cv::cuda::setDevice(devInfo.deviceID()); 620 } 621 }; 622 623 CUDA_TEST_P(MorphEx, Accuracy) 624 { 625 cv::Mat src = randomMat(size, type); 626 cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U); 627 628 cv::Ptr<cv::cuda::Filter> morph = cv::cuda::createMorphologyFilter(morphOp, src.type(), kernel, anchor, iterations); 629 630 cv::cuda::GpuMat dst = createMat(size, type, useRoi); 631 morph->apply(loadMat(src, useRoi), dst); 632 633 cv::Mat dst_gold; 634 cv::morphologyEx(src, dst_gold, morphOp, kernel, anchor, iterations); 635 636 cv::Size border = cv::Size(kernel.cols + (iterations + 1) * kernel.cols + 2, kernel.rows + (iterations + 1) * kernel.rows + 2); 637 638 EXPECT_MAT_NEAR(getInnerROI(dst_gold, border), getInnerROI(dst, border), 0.0); 639 } 640 641 INSTANTIATE_TEST_CASE_P(CUDA_Filters, MorphEx, testing::Combine( 642 ALL_DEVICES, 643 DIFFERENT_SIZES, 644 testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)), 645 MorphOp::all(), 646 testing::Values(Anchor(cv::Point(-1, -1)), Anchor(cv::Point(0, 0)), Anchor(cv::Point(2, 2))), 647 testing::Values(Iterations(1), Iterations(2), Iterations(3)), 648 WHOLE_SUBMAT)); 649 650 #endif // HAVE_CUDA 651
