diff --git a/modules/gpuimgproc/include/opencv2/gpuimgproc.hpp b/modules/gpuimgproc/include/opencv2/gpuimgproc.hpp index f880b6cab9..ea68590b51 100644 --- a/modules/gpuimgproc/include/opencv2/gpuimgproc.hpp +++ b/modules/gpuimgproc/include/opencv2/gpuimgproc.hpp @@ -48,9 +48,18 @@ #endif #include "opencv2/core/gpu.hpp" -#include "opencv2/core/base.hpp" #include "opencv2/imgproc.hpp" -#include "opencv2/gpufilters.hpp" + +#if defined __GNUC__ + #define __OPENCV_GPUIMGPROC_DEPR_BEFORE__ + #define __OPENCV_GPUIMGPROC_DEPR_AFTER__ __attribute__ ((deprecated)) +#elif (defined WIN32 || defined _WIN32) + #define __OPENCV_GPUIMGPROC_DEPR_BEFORE__ __declspec(deprecated) + #define __OPENCV_GPUIMGPROC_DEPR_AFTER__ +#else + #define __OPENCV_GPUIMGPROC_DEPR_BEFORE__ + #define __OPENCV_GPUIMGPROC_DEPR_AFTER__ +#endif namespace cv { namespace gpu { @@ -172,22 +181,42 @@ static inline void histRange(InputArray src, GpuMat hist[4], const GpuMat levels //////////////////////////////// Canny //////////////////////////////// -struct CV_EXPORTS CannyBuf +class CV_EXPORTS CannyEdgeDetector : public Algorithm { - void create(const Size& image_size, int apperture_size = 3); - void release(); +public: + virtual void detect(InputArray image, OutputArray edges) = 0; + virtual void detect(InputArray dx, InputArray dy, OutputArray edges) = 0; - GpuMat dx, dy; - GpuMat mag; - GpuMat map; - GpuMat st1, st2; - Ptr filterDX, filterDY; + virtual void setLowThreshold(double low_thresh) = 0; + virtual double getLowThreshold() const = 0; + + virtual void setHighThreshold(double high_thresh) = 0; + virtual double getHighThreshold() const = 0; + + virtual void setAppertureSize(int apperture_size) = 0; + virtual int getAppertureSize() const = 0; + + virtual void setL2Gradient(bool L2gradient) = 0; + virtual bool getL2Gradient() const = 0; }; -CV_EXPORTS void Canny(const GpuMat& image, GpuMat& edges, double low_thresh, double high_thresh, int apperture_size = 3, bool L2gradient = false); -CV_EXPORTS void Canny(const GpuMat& image, CannyBuf& buf, GpuMat& edges, double low_thresh, double high_thresh, int apperture_size = 3, bool L2gradient = false); -CV_EXPORTS void Canny(const GpuMat& dx, const GpuMat& dy, GpuMat& edges, double low_thresh, double high_thresh, bool L2gradient = false); -CV_EXPORTS void Canny(const GpuMat& dx, const GpuMat& dy, CannyBuf& buf, GpuMat& edges, double low_thresh, double high_thresh, bool L2gradient = false); +CV_EXPORTS Ptr createCannyEdgeDetector(double low_thresh, double high_thresh, int apperture_size = 3, bool L2gradient = false); + +// obsolete + +__OPENCV_GPUIMGPROC_DEPR_BEFORE__ void Canny(InputArray image, OutputArray edges, + double low_thresh, double high_thresh, int apperture_size = 3, bool L2gradient = false) __OPENCV_GPUIMGPROC_DEPR_AFTER__; +inline void Canny(InputArray image, OutputArray edges, double low_thresh, double high_thresh, int apperture_size, bool L2gradient) +{ + gpu::createCannyEdgeDetector(low_thresh, high_thresh, apperture_size, L2gradient)->detect(image, edges); +} + +__OPENCV_GPUIMGPROC_DEPR_BEFORE__ void Canny(InputArray dx, InputArray dy, OutputArray edges, + double low_thresh, double high_thresh, bool L2gradient = false) __OPENCV_GPUIMGPROC_DEPR_AFTER__; +inline void Canny(InputArray dx, InputArray dy, OutputArray edges, double low_thresh, double high_thresh, bool L2gradient) +{ + gpu::createCannyEdgeDetector(low_thresh, high_thresh, 3, L2gradient)->detect(dx, dy, edges); +} /////////////////////////// Hough Transform //////////////////////////// @@ -209,7 +238,7 @@ struct HoughCirclesBuf GpuMat edges; GpuMat accum; GpuMat list; - CannyBuf cannyBuf; + Ptr canny; }; CV_EXPORTS void HoughCircles(const GpuMat& src, GpuMat& circles, int method, float dp, float minDist, int cannyThreshold, int votesThreshold, int minRadius, int maxRadius, int maxCircles = 4096); @@ -224,6 +253,7 @@ class CV_EXPORTS GeneralizedHough_GPU : public cv::Algorithm public: static Ptr create(int method); + GeneralizedHough_GPU(); virtual ~GeneralizedHough_GPU(); //! set template to search @@ -245,7 +275,7 @@ protected: private: GpuMat edges_; - CannyBuf cannyBuf_; + Ptr canny_; }; ////////////////////////// Corners Detection /////////////////////////// @@ -359,4 +389,7 @@ CV_EXPORTS void blendLinear(const GpuMat& img1, const GpuMat& img2, const GpuMat }} // namespace cv { namespace gpu { +#undef __OPENCV_GPUIMGPROC_DEPR_BEFORE__ +#undef __OPENCV_GPUIMGPROC_DEPR_AFTER__ + #endif /* __OPENCV_GPUIMGPROC_HPP__ */ diff --git a/modules/gpuimgproc/perf/perf_canny.cpp b/modules/gpuimgproc/perf/perf_canny.cpp index ce6db2bb34..2bbf70a496 100644 --- a/modules/gpuimgproc/perf/perf_canny.cpp +++ b/modules/gpuimgproc/perf/perf_canny.cpp @@ -70,9 +70,10 @@ PERF_TEST_P(Image_AppertureSz_L2gradient, Canny, { const cv::gpu::GpuMat d_image(image); cv::gpu::GpuMat dst; - cv::gpu::CannyBuf d_buf; - TEST_CYCLE() cv::gpu::Canny(d_image, d_buf, dst, low_thresh, high_thresh, apperture_size, useL2gradient); + cv::Ptr canny = cv::gpu::createCannyEdgeDetector(low_thresh, high_thresh, apperture_size, useL2gradient); + + TEST_CYCLE() canny->detect(d_image, dst); GPU_SANITY_CHECK(dst); } diff --git a/modules/gpuimgproc/src/canny.cpp b/modules/gpuimgproc/src/canny.cpp index 9a33575648..888a224d75 100644 --- a/modules/gpuimgproc/src/canny.cpp +++ b/modules/gpuimgproc/src/canny.cpp @@ -47,46 +47,10 @@ using namespace cv::gpu; #if !defined (HAVE_CUDA) || defined (CUDA_DISABLER) -void cv::gpu::Canny(const GpuMat&, GpuMat&, double, double, int, bool) { throw_no_cuda(); } -void cv::gpu::Canny(const GpuMat&, CannyBuf&, GpuMat&, double, double, int, bool) { throw_no_cuda(); } -void cv::gpu::Canny(const GpuMat&, const GpuMat&, GpuMat&, double, double, bool) { throw_no_cuda(); } -void cv::gpu::Canny(const GpuMat&, const GpuMat&, CannyBuf&, GpuMat&, double, double, bool) { throw_no_cuda(); } -void cv::gpu::CannyBuf::create(const Size&, int) { throw_no_cuda(); } -void cv::gpu::CannyBuf::release() { throw_no_cuda(); } +Ptr cv::gpu::createCannyEdgeDetector(double, double, int, bool) { throw_no_cuda(); return Ptr(); } #else /* !defined (HAVE_CUDA) */ -void cv::gpu::CannyBuf::create(const Size& image_size, int apperture_size) -{ - if (apperture_size > 0) - { - ensureSizeIsEnough(image_size, CV_32SC1, dx); - ensureSizeIsEnough(image_size, CV_32SC1, dy); - - if (apperture_size != 3) - { - filterDX = createDerivFilter(CV_8UC1, CV_32S, 1, 0, apperture_size, false, 1, BORDER_REPLICATE); - filterDY = createDerivFilter(CV_8UC1, CV_32S, 0, 1, apperture_size, false, 1, BORDER_REPLICATE); - } - } - - ensureSizeIsEnough(image_size, CV_32FC1, mag); - ensureSizeIsEnough(image_size, CV_32SC1, map); - - ensureSizeIsEnough(1, image_size.area(), CV_16UC2, st1); - ensureSizeIsEnough(1, image_size.area(), CV_16UC2, st2); -} - -void cv::gpu::CannyBuf::release() -{ - dx.release(); - dy.release(); - mag.release(); - map.release(); - st1.release(); - st2.release(); -} - namespace canny { void calcMagnitude(PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzi dx, PtrStepSzi dy, PtrStepSzf mag, bool L2Grad); @@ -103,84 +67,157 @@ namespace canny namespace { - void CannyCaller(const GpuMat& dx, const GpuMat& dy, CannyBuf& buf, GpuMat& dst, float low_thresh, float high_thresh) + class CannyImpl : public CannyEdgeDetector { - using namespace canny; + public: + CannyImpl(double low_thresh, double high_thresh, int apperture_size, bool L2gradient) : + low_thresh_(low_thresh), high_thresh_(high_thresh), apperture_size_(apperture_size), L2gradient_(L2gradient) + { + old_apperture_size_ = -1; + } - buf.map.setTo(Scalar::all(0)); - calcMap(dx, dy, buf.mag, buf.map, low_thresh, high_thresh); + void detect(InputArray image, OutputArray edges); + void detect(InputArray dx, InputArray dy, OutputArray edges); - edgesHysteresisLocal(buf.map, buf.st1.ptr()); + void setLowThreshold(double low_thresh) { low_thresh_ = low_thresh; } + double getLowThreshold() const { return low_thresh_; } - edgesHysteresisGlobal(buf.map, buf.st1.ptr(), buf.st2.ptr()); + void setHighThreshold(double high_thresh) { high_thresh_ = high_thresh; } + double getHighThreshold() const { return high_thresh_; } - getEdges(buf.map, dst); + void setAppertureSize(int apperture_size) { apperture_size_ = apperture_size; } + int getAppertureSize() const { return apperture_size_; } + + void setL2Gradient(bool L2gradient) { L2gradient_ = L2gradient; } + bool getL2Gradient() const { return L2gradient_; } + + void write(FileStorage& fs) const + { + fs << "name" << "Canny_GPU" + << "low_thresh" << low_thresh_ + << "high_thresh" << high_thresh_ + << "apperture_size" << apperture_size_ + << "L2gradient" << L2gradient_; + } + + void read(const FileNode& fn) + { + CV_Assert( String(fn["name"]) == "Canny_GPU" ); + low_thresh_ = (double)fn["low_thresh"]; + high_thresh_ = (double)fn["high_thresh"]; + apperture_size_ = (int)fn["apperture_size"]; + L2gradient_ = (int)fn["L2gradient"] != 0; + } + + private: + void createBuf(Size image_size); + void CannyCaller(GpuMat& edges); + + double low_thresh_; + double high_thresh_; + int apperture_size_; + bool L2gradient_; + + GpuMat dx_, dy_; + GpuMat mag_; + GpuMat map_; + GpuMat st1_, st2_; + Ptr filterDX_, filterDY_; + int old_apperture_size_; + }; + + void CannyImpl::detect(InputArray _image, OutputArray _edges) + { + GpuMat image = _image.getGpuMat(); + + CV_Assert( image.type() == CV_8UC1 ); + CV_Assert( deviceSupports(SHARED_ATOMICS) ); + + if (low_thresh_ > high_thresh_) + std::swap(low_thresh_, high_thresh_); + + createBuf(image.size()); + + _edges.create(image.size(), CV_8UC1); + GpuMat edges = _edges.getGpuMat(); + + if (apperture_size_ == 3) + { + Size wholeSize; + Point ofs; + image.locateROI(wholeSize, ofs); + GpuMat srcWhole(wholeSize, image.type(), image.datastart, image.step); + + canny::calcMagnitude(srcWhole, ofs.x, ofs.y, dx_, dy_, mag_, L2gradient_); + } + else + { + filterDX_->apply(image, dx_); + filterDY_->apply(image, dy_); + + canny::calcMagnitude(dx_, dy_, mag_, L2gradient_); + } + + CannyCaller(edges); + } + + void CannyImpl::detect(InputArray _dx, InputArray _dy, OutputArray _edges) + { + GpuMat dx = _dx.getGpuMat(); + GpuMat dy = _dy.getGpuMat(); + + CV_Assert( dx.type() == CV_32SC1 ); + CV_Assert( dy.type() == dx.type() && dy.size() == dx.size() ); + CV_Assert( deviceSupports(SHARED_ATOMICS) ); + + if (low_thresh_ > high_thresh_) + std::swap(low_thresh_, high_thresh_); + + createBuf(dx.size()); + + _edges.create(dx.size(), CV_8UC1); + GpuMat edges = _edges.getGpuMat(); + + canny::calcMagnitude(dx_, dy_, mag_, L2gradient_); + + CannyCaller(edges); + } + + void CannyImpl::createBuf(Size image_size) + { + ensureSizeIsEnough(image_size, CV_32SC1, dx_); + ensureSizeIsEnough(image_size, CV_32SC1, dy_); + + if (apperture_size_ != 3 && apperture_size_ != old_apperture_size_) + { + filterDX_ = gpu::createDerivFilter(CV_8UC1, CV_32S, 1, 0, apperture_size_, false, 1, BORDER_REPLICATE); + filterDY_ = gpu::createDerivFilter(CV_8UC1, CV_32S, 0, 1, apperture_size_, false, 1, BORDER_REPLICATE); + old_apperture_size_ = apperture_size_; + } + + ensureSizeIsEnough(image_size, CV_32FC1, mag_); + ensureSizeIsEnough(image_size, CV_32SC1, map_); + + ensureSizeIsEnough(1, image_size.area(), CV_16UC2, st1_); + ensureSizeIsEnough(1, image_size.area(), CV_16UC2, st2_); + } + + void CannyImpl::CannyCaller(GpuMat& edges) + { + map_.setTo(Scalar::all(0)); + canny::calcMap(dx_, dy_, mag_, map_, static_cast(low_thresh_), static_cast(high_thresh_)); + + canny::edgesHysteresisLocal(map_, st1_.ptr()); + + canny::edgesHysteresisGlobal(map_, st1_.ptr(), st2_.ptr()); + + canny::getEdges(map_, edges); } } -void cv::gpu::Canny(const GpuMat& src, GpuMat& dst, double low_thresh, double high_thresh, int apperture_size, bool L2gradient) +Ptr cv::gpu::createCannyEdgeDetector(double low_thresh, double high_thresh, int apperture_size, bool L2gradient) { - CannyBuf buf; - Canny(src, buf, dst, low_thresh, high_thresh, apperture_size, L2gradient); -} - -void cv::gpu::Canny(const GpuMat& src, CannyBuf& buf, GpuMat& dst, double low_thresh, double high_thresh, int apperture_size, bool L2gradient) -{ - using namespace canny; - - CV_Assert(src.type() == CV_8UC1); - - if (!deviceSupports(SHARED_ATOMICS)) - CV_Error(cv::Error::StsNotImplemented, "The device doesn't support shared atomics"); - - if( low_thresh > high_thresh ) - std::swap( low_thresh, high_thresh); - - dst.create(src.size(), CV_8U); - buf.create(src.size(), apperture_size); - - if (apperture_size == 3) - { - Size wholeSize; - Point ofs; - src.locateROI(wholeSize, ofs); - GpuMat srcWhole(wholeSize, src.type(), src.datastart, src.step); - - calcMagnitude(srcWhole, ofs.x, ofs.y, buf.dx, buf.dy, buf.mag, L2gradient); - } - else - { - buf.filterDX->apply(src, buf.dx); - buf.filterDY->apply(src, buf.dy); - - calcMagnitude(buf.dx, buf.dy, buf.mag, L2gradient); - } - - CannyCaller(buf.dx, buf.dy, buf, dst, static_cast(low_thresh), static_cast(high_thresh)); -} - -void cv::gpu::Canny(const GpuMat& dx, const GpuMat& dy, GpuMat& dst, double low_thresh, double high_thresh, bool L2gradient) -{ - CannyBuf buf; - Canny(dx, dy, buf, dst, low_thresh, high_thresh, L2gradient); -} - -void cv::gpu::Canny(const GpuMat& dx, const GpuMat& dy, CannyBuf& buf, GpuMat& dst, double low_thresh, double high_thresh, bool L2gradient) -{ - using namespace canny; - - CV_Assert(TargetArchs::builtWith(SHARED_ATOMICS) && DeviceInfo().supports(SHARED_ATOMICS)); - CV_Assert(dx.type() == CV_32SC1 && dy.type() == CV_32SC1 && dx.size() == dy.size()); - - if( low_thresh > high_thresh ) - std::swap( low_thresh, high_thresh); - - dst.create(dx.size(), CV_8U); - buf.create(dx.size(), -1); - - calcMagnitude(dx, dy, buf.mag, L2gradient); - - CannyCaller(dx, dy, buf, dst, static_cast(low_thresh), static_cast(high_thresh)); + return new CannyImpl(low_thresh, high_thresh, apperture_size, L2gradient); } #endif /* !defined (HAVE_CUDA) */ diff --git a/modules/gpuimgproc/src/hough.cpp b/modules/gpuimgproc/src/hough.cpp index 15e5297623..a91725fff4 100644 --- a/modules/gpuimgproc/src/hough.cpp +++ b/modules/gpuimgproc/src/hough.cpp @@ -244,7 +244,8 @@ void cv::gpu::HoughCircles(const GpuMat& src, GpuMat& circles, HoughCirclesBuf& const float idp = 1.0f / dp; - cv::gpu::Canny(src, buf.cannyBuf, buf.edges, std::max(cannyThreshold / 2, 1), cannyThreshold); + buf.canny = gpu::createCannyEdgeDetector(std::max(cannyThreshold / 2, 1), cannyThreshold); + buf.canny->detect(src, buf.edges); ensureSizeIsEnough(2, src.size().area(), CV_32SC1, buf.list); unsigned int* srcPoints = buf.list.ptr(0); @@ -260,7 +261,13 @@ void cv::gpu::HoughCircles(const GpuMat& src, GpuMat& circles, HoughCirclesBuf& ensureSizeIsEnough(cvCeil(src.rows * idp) + 2, cvCeil(src.cols * idp) + 2, CV_32SC1, buf.accum); buf.accum.setTo(Scalar::all(0)); - circlesAccumCenters_gpu(srcPoints, pointsCount, buf.cannyBuf.dx, buf.cannyBuf.dy, buf.accum, minRadius, maxRadius, idp); + Ptr filterDX = gpu::createSobelFilter(CV_8UC1, CV_32S, 1, 0); + Ptr filterDY = gpu::createSobelFilter(CV_8UC1, CV_32S, 0, 1); + GpuMat dx, dy; + filterDX->apply(src, dx); + filterDY->apply(src, dy); + + circlesAccumCenters_gpu(srcPoints, pointsCount, dx, dy, buf.accum, minRadius, maxRadius, idp); int centersCount = buildCentersList_gpu(buf.accum, centers, votesThreshold); if (centersCount == 0) @@ -1355,6 +1362,11 @@ Ptr cv::gpu::GeneralizedHough_GPU::create(int method) return Ptr(); } +cv::gpu::GeneralizedHough_GPU::GeneralizedHough_GPU() +{ + canny_ = gpu::createCannyEdgeDetector(50, 100); +} + cv::gpu::GeneralizedHough_GPU::~GeneralizedHough_GPU() { } @@ -1365,12 +1377,21 @@ void cv::gpu::GeneralizedHough_GPU::setTemplate(const GpuMat& templ, int cannyTh CV_Assert(cannyThreshold > 0); ensureSizeIsEnough(templ.size(), CV_8UC1, edges_); - Canny(templ, cannyBuf_, edges_, cannyThreshold / 2, cannyThreshold); + + canny_->setLowThreshold(cannyThreshold / 2); + canny_->setHighThreshold(cannyThreshold); + canny_->detect(templ, edges_); if (templCenter == Point(-1, -1)) templCenter = Point(templ.cols / 2, templ.rows / 2); - setTemplateImpl(edges_, cannyBuf_.dx, cannyBuf_.dy, templCenter); + Ptr filterDX = gpu::createSobelFilter(CV_8UC1, CV_32S, 1, 0); + Ptr filterDY = gpu::createSobelFilter(CV_8UC1, CV_32S, 0, 1); + GpuMat dx, dy; + filterDX->apply(templ, dx); + filterDY->apply(templ, dy); + + setTemplateImpl(edges_, dx, dy, templCenter); } void cv::gpu::GeneralizedHough_GPU::setTemplate(const GpuMat& edges, const GpuMat& dx, const GpuMat& dy, Point templCenter) @@ -1387,9 +1408,18 @@ void cv::gpu::GeneralizedHough_GPU::detect(const GpuMat& image, GpuMat& position CV_Assert(cannyThreshold > 0); ensureSizeIsEnough(image.size(), CV_8UC1, edges_); - Canny(image, cannyBuf_, edges_, cannyThreshold / 2, cannyThreshold); - detectImpl(edges_, cannyBuf_.dx, cannyBuf_.dy, positions); + canny_->setLowThreshold(cannyThreshold / 2); + canny_->setHighThreshold(cannyThreshold); + canny_->detect(image, edges_); + + Ptr filterDX = gpu::createSobelFilter(CV_8UC1, CV_32S, 1, 0); + Ptr filterDY = gpu::createSobelFilter(CV_8UC1, CV_32S, 0, 1); + GpuMat dx, dy; + filterDX->apply(image, dx); + filterDY->apply(image, dy); + + detectImpl(edges_, dx, dy, positions); } void cv::gpu::GeneralizedHough_GPU::detect(const GpuMat& edges, const GpuMat& dx, const GpuMat& dy, GpuMat& positions) @@ -1425,7 +1455,6 @@ void cv::gpu::GeneralizedHough_GPU::download(const GpuMat& d_positions, OutputAr void cv::gpu::GeneralizedHough_GPU::release() { edges_.release(); - cannyBuf_.release(); releaseImpl(); } diff --git a/modules/gpuimgproc/test/test_canny.cpp b/modules/gpuimgproc/test/test_canny.cpp index b3ab5addc6..3d9d350165 100644 --- a/modules/gpuimgproc/test/test_canny.cpp +++ b/modules/gpuimgproc/test/test_canny.cpp @@ -81,28 +81,15 @@ GPU_TEST_P(Canny, Accuracy) double low_thresh = 50.0; double high_thresh = 100.0; - if (!supportFeature(devInfo, cv::gpu::SHARED_ATOMICS)) - { - try - { - cv::gpu::GpuMat edges; - cv::gpu::Canny(loadMat(img), edges, low_thresh, high_thresh, apperture_size, useL2gradient); - } - catch (const cv::Exception& e) - { - ASSERT_EQ(cv::Error::StsNotImplemented, e.code); - } - } - else - { - cv::gpu::GpuMat edges; - cv::gpu::Canny(loadMat(img, useRoi), edges, low_thresh, high_thresh, apperture_size, useL2gradient); + cv::Ptr canny = cv::gpu::createCannyEdgeDetector(low_thresh, high_thresh, apperture_size, useL2gradient); - cv::Mat edges_gold; - cv::Canny(img, edges_gold, low_thresh, high_thresh, apperture_size, useL2gradient); + cv::gpu::GpuMat edges; + canny->detect(loadMat(img, useRoi), edges); - EXPECT_MAT_SIMILAR(edges_gold, edges, 2e-2); - } + cv::Mat edges_gold; + cv::Canny(img, edges_gold, low_thresh, high_thresh, apperture_size, useL2gradient); + + EXPECT_MAT_SIMILAR(edges_gold, edges, 2e-2); } INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Canny, testing::Combine( diff --git a/samples/gpu/houghlines.cpp b/samples/gpu/houghlines.cpp index 299fa47cb4..38d9c8298e 100644 --- a/samples/gpu/houghlines.cpp +++ b/samples/gpu/houghlines.cpp @@ -31,7 +31,7 @@ int main(int argc, const char* argv[]) } Mat mask; - Canny(src, mask, 100, 200, 3); + cv::Canny(src, mask, 100, 200, 3); Mat dst_cpu; cv::cvtColor(mask, dst_cpu, COLOR_GRAY2BGR); diff --git a/samples/gpu/performance/tests.cpp b/samples/gpu/performance/tests.cpp index 7193ee93ae..99ba56cddb 100644 --- a/samples/gpu/performance/tests.cpp +++ b/samples/gpu/performance/tests.cpp @@ -1072,12 +1072,13 @@ TEST(Canny) gpu::GpuMat d_img(img); gpu::GpuMat d_edges; - gpu::CannyBuf d_buf; - gpu::Canny(d_img, d_buf, d_edges, 50.0, 100.0); + Ptr canny = gpu::createCannyEdgeDetector(50.0, 100.0); + + canny->detect(d_img, d_edges); GPU_ON; - gpu::Canny(d_img, d_buf, d_edges, 50.0, 100.0); + canny->detect(d_img, d_edges); GPU_OFF; }