added gpu::Canny function

modules/gpu/include/opencv2/gpu/gpu.hpp

@@ -976,7 +976,32 @@ namespace cv
         //! performs linear blending of two images
         //! to avoid accuracy errors sum of weigths shouldn't be very close to zero
         CV_EXPORTS void blendLinear(const GpuMat& img1, const GpuMat& img2, const GpuMat& weights1, const GpuMat& weights2, 
-            GpuMat& result, Stream& stream = Stream::Null());       
+            GpuMat& result, Stream& stream = Stream::Null());
+
+        
+        struct CV_EXPORTS CannyBuf;
+        
+        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);
+
+        struct CV_EXPORTS CannyBuf
+        {
+            CannyBuf() {}
+            explicit CannyBuf(const Size& image_size, int apperture_size = 3) {create(image_size, apperture_size);}
+            CannyBuf(const GpuMat& dx_, const GpuMat& dy_);
+
+            void create(const Size& image_size, int apperture_size = 3);
+            
+            void release();
+
+            GpuMat dx, dy;
+            GpuMat dx_buf, dy_buf;
+            GpuMat edgeBuf;
+            GpuMat trackBuf1, trackBuf2;
+            Ptr<FilterEngine_GPU> filterDX, filterDY;
+        };
 
         ////////////////////////////// Matrix reductions //////////////////////////////
 

modules/gpu/src/imgproc_gpu.cpp

@@ -92,8 +92,13 @@ void cv::gpu::pyrDown(const GpuMat&, GpuMat&, PyrDownBuf&, Stream&) { throw_nogp
 void cv::gpu::pyrUp(const GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
 void cv::gpu::PyrUpBuf::create(Size, int) { throw_nogpu(); }
 void cv::gpu::pyrUp(const GpuMat&, GpuMat&, PyrUpBuf&, Stream&) { throw_nogpu(); }
-
-
+void cv::gpu::Canny(const GpuMat&, GpuMat&, double, double, int, bool) { throw_nogpu(); }
+void cv::gpu::Canny(const GpuMat&, CannyBuf&, GpuMat&, double, double, int, bool) { throw_nogpu(); }
+void cv::gpu::Canny(const GpuMat&, const GpuMat&, GpuMat&, double, double, bool) { throw_nogpu(); }
+void cv::gpu::Canny(const GpuMat&, const GpuMat&, CannyBuf&, GpuMat&, double, double, bool) { throw_nogpu(); }
+cv::gpu::CannyBuf::CannyBuf(const GpuMat&, const GpuMat&) { throw_nogpu(); }
+void cv::gpu::CannyBuf::create(const Size&, int) { throw_nogpu(); }
+void cv::gpu::CannyBuf::release() { throw_nogpu(); }
 
 #else /* !defined (HAVE_CUDA) */
 
@@ -1627,6 +1632,149 @@ void cv::gpu::pyrUp(const GpuMat& src, GpuMat& dst, PyrUpBuf& buf, Stream& strea
     buf.filter->apply(buf.buf, dst, Rect(0, 0, buf.buf.cols, buf.buf.rows), stream);
 }
 
+
+//////////////////////////////////////////////////////////////////////////////
+// Canny
+
+cv::gpu::CannyBuf::CannyBuf(const GpuMat& dx_, const GpuMat& dy_) : dx(dx_), dy(dy_)
+{
+    CV_Assert(dx_.type() == CV_32SC1 && dy_.type() == CV_32SC1 && dx_.size() == dy_.size());
+
+    create(dx_.size(), -1);
+}
+
+void cv::gpu::CannyBuf::create(const Size& image_size, int apperture_size)
+{
+    ensureSizeIsEnough(image_size, CV_32SC1, dx);
+    ensureSizeIsEnough(image_size, CV_32SC1, dy);
+
+    if (apperture_size == 3)
+    {
+        ensureSizeIsEnough(image_size, CV_32SC1, dx_buf);
+        ensureSizeIsEnough(image_size, CV_32SC1, dy_buf);
+    }
+    else if(apperture_size > 0)
+    {
+        if (!filterDX)
+            filterDX = createDerivFilter_GPU(CV_8UC1, CV_32S, 1, 0, apperture_size, BORDER_REPLICATE);
+        if (!filterDY)
+            filterDY = createDerivFilter_GPU(CV_8UC1, CV_32S, 0, 1, apperture_size, BORDER_REPLICATE);
+    }
+
+    ensureSizeIsEnough(image_size.height + 2, image_size.width + 2, CV_32FC1, edgeBuf);
+
+    ensureSizeIsEnough(1, image_size.width * image_size.height, CV_16UC2, trackBuf1);
+    ensureSizeIsEnough(1, image_size.width * image_size.height, CV_16UC2, trackBuf2);
+}
+
+void cv::gpu::CannyBuf::release()
+{
+    dx.release();
+    dy.release();
+    dx_buf.release();
+    dy_buf.release();
+    edgeBuf.release();
+    trackBuf1.release();
+    trackBuf2.release();
+}
+
+namespace cv { namespace gpu { namespace canny
+{    
+    void calcSobelRowPass_gpu(PtrStep src, PtrStepi dx_buf, PtrStepi dy_buf, int rows, int cols);
+
+    void calcMagnitude_gpu(PtrStepi dx_buf, PtrStepi dy_buf, PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols, bool L2Grad);
+    void calcMagnitude_gpu(PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols, bool L2Grad);
+
+    void calcMap_gpu(PtrStepi dx, PtrStepi dy, PtrStepf mag, PtrStepi map, int rows, int cols, float low_thresh, float high_thresh);
+    
+    void edgesHysteresisLocal_gpu(PtrStepi map, ushort2* st1, int rows, int cols);
+
+    void edgesHysteresisGlobal_gpu(PtrStepi map, ushort2* st1, ushort2* st2, int rows, int cols);
+
+    void getEdges_gpu(PtrStepi map, PtrStep dst, int rows, int cols);
+}}}
+
+namespace
+{
+    void CannyCaller(CannyBuf& buf, GpuMat& dst, float low_thresh, float high_thresh)
+    {
+        using namespace cv::gpu::canny;
+
+        calcMap_gpu(buf.dx, buf.dy, buf.edgeBuf, buf.edgeBuf, dst.rows, dst.cols, low_thresh, high_thresh);
+        
+        edgesHysteresisLocal_gpu(buf.edgeBuf, buf.trackBuf1.ptr<ushort2>(), dst.rows, dst.cols);
+        
+        edgesHysteresisGlobal_gpu(buf.edgeBuf, buf.trackBuf1.ptr<ushort2>(), buf.trackBuf2.ptr<ushort2>(), dst.rows, dst.cols);
+        
+        getEdges_gpu(buf.edgeBuf, dst, dst.rows, dst.cols);
+    }
+}
+
+void cv::gpu::Canny(const GpuMat& src, GpuMat& dst, double low_thresh, double high_thresh, int apperture_size, bool L2gradient)
+{
+    CannyBuf buf(src.size(), apperture_size);
+    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 cv::gpu::canny;
+
+    CV_Assert(src.type() == CV_8UC1);
+
+    if( low_thresh > high_thresh )
+        std::swap( low_thresh, high_thresh);
+
+    dst.create(src.size(), CV_8U);
+    dst.setTo(Scalar::all(0));
+    
+    buf.create(src.size(), apperture_size);
+    buf.edgeBuf.setTo(Scalar::all(0));
+
+    if (apperture_size == 3)
+    {
+        calcSobelRowPass_gpu(src, buf.dx_buf, buf.dy_buf, src.rows, src.cols);
+
+        calcMagnitude_gpu(buf.dx_buf, buf.dy_buf, buf.dx, buf.dy, buf.edgeBuf, src.rows, src.cols, L2gradient);
+    }
+    else
+    {
+        buf.filterDX->apply(src, buf.dx, Rect(0, 0, src.cols, src.rows));
+        buf.filterDY->apply(src, buf.dy, Rect(0, 0, src.cols, src.rows));
+
+        calcMagnitude_gpu(buf.dx, buf.dy, buf.edgeBuf, src.rows, src.cols, L2gradient);
+    }
+
+    CannyCaller(buf, dst, static_cast<float>(low_thresh), static_cast<float>(high_thresh));
+}
+
+void cv::gpu::Canny(const GpuMat& dx, const GpuMat& dy, GpuMat& dst, double low_thresh, double high_thresh, bool L2gradient)
+{
+    CannyBuf buf(dx, dy);
+    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 cv::gpu::canny;
+
+    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);
+    dst.setTo(Scalar::all(0));
+    
+    buf.dx = dx; buf.dy = dy;
+    buf.create(dx.size(), -1);
+    buf.edgeBuf.setTo(Scalar::all(0));
+
+    calcMagnitude_gpu(dx, dy, buf.edgeBuf, dx.rows, dx.cols, L2gradient);
+
+    CannyCaller(buf, dst, static_cast<float>(low_thresh), static_cast<float>(high_thresh));
+}
+
 #endif /* !defined (HAVE_CUDA) */
 
 

modules/gpu/test/test_imgproc.cpp

@@ -2217,4 +2217,71 @@ TEST_P(PyrUp, Accuracy)
 
 INSTANTIATE_TEST_CASE_P(ImgProc, PyrUp, testing::ValuesIn(devices()));
 
+////////////////////////////////////////////////////////
+// Canny
+
+struct Canny : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int, bool> >
+{
+    static cv::Mat img;
+
+    static void SetUpTestCase() 
+    {
+        img = readImage("stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE); 
+    }
+
+    static void TearDownTestCase() 
+    {
+        img.release();
+    } 
+
+    cv::gpu::DeviceInfo devInfo;
+    int apperture_size;
+    bool L2gradient;
+
+    double low_thresh;
+    double high_thresh;
+
+    cv::Mat edges_gold;
+
+    virtual void SetUp() 
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        apperture_size = std::tr1::get<1>(GetParam());
+        L2gradient = std::tr1::get<2>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        low_thresh = 50.0;
+        high_thresh = 100.0;
+        
+        cv::Canny(img, edges_gold, low_thresh, high_thresh, apperture_size, L2gradient);
+    }
+};
+
+cv::Mat Canny::img;
+
+TEST_P(Canny, Accuracy)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(apperture_size);
+    PRINT_PARAM(L2gradient);
+
+    cv::Mat edges;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat d_edges;
+
+        cv::gpu::Canny(cv::gpu::GpuMat(img), d_edges, low_thresh, high_thresh, apperture_size, L2gradient);
+
+        d_edges.download(edges);
+    );
+
+    EXPECT_MAT_SIMILAR(edges_gold, edges, 1.0);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, Canny, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(3, 5),
+                        testing::Values(false, true)));
+
 #endif // HAVE_CUDA

samples/gpu/performance/tests.cpp

@@ -937,3 +937,25 @@ TEST(equalizeHist)
         GPU_OFF;
     }
 }
+
+
+TEST(Canny)
+{
+    Mat img = imread(abspath("aloeL.jpg"), CV_LOAD_IMAGE_GRAYSCALE);
+
+    if (img.empty()) throw runtime_error("can't open aloeL.jpg");
+
+    Mat edges(img.size(), CV_8UC1);
+
+    CPU_ON;
+    Canny(img, edges, 50.0, 100.0);
+    CPU_OFF;
+    
+    gpu::GpuMat d_img(img);
+    gpu::GpuMat d_edges(img.size(), CV_8UC1);
+    gpu::CannyBuf d_buf(img.size());
+
+    GPU_ON;
+    gpu::Canny(d_img, d_buf, d_edges, 50.0, 100.0);
+    GPU_OFF;
+}