精华内容
下载资源
问答
  • canny 算子

    2018-04-23 21:05:36
    使用该文档可以了解canny算子的原理及实现该程序的代码。
  • 基于数学形态学和Canny算子的边缘提取方法-基于数学形态学和Canny算子的边缘提取方法.pdf 基于数学形态学和Canny算子的边缘提取方法.
  • canny算子发明人发表的关于canny算子的文章,里面有详细的介绍,canny算子是由john canny发明的。
  • Python+OpenCV图像处理—— 边缘检测之 Canny算子 OpenCV边缘检测的一般步骤为: 滤波 增强 检测 常用的边缘检测的算子和滤波器有: Sobel算子 Laplacian算子 Canny算子 Scharr滤波器 Canny算子 Canny 的...

    Python+OpenCV图像处理—— 边缘检测之 Canny算子

    OpenCV边缘检测的一般步骤为:

    滤波
    增强
    检测

    常用的边缘检测的算子和滤波器有:

    Sobel算子
    Laplacian算子
    Canny算子
    Scharr滤波器

    Canny算子

    Canny 的目标是找到一个最优的边缘检测算法,最优边缘检测的含义是:
    好的检测- 算法能够尽可能多地标识出图像中的实际边缘。
    好的定位- 标识出的边缘要尽可能与实际图像中的实际边缘尽可能接近。
    最小响应- 图像中的边缘只能标识一次,并且可能存在的图像噪声不应标识为边缘。

    算法步骤:

    ①高斯模糊 - GaussianBlur
      ②灰度转换 - cvtColor
      ③计算梯度 – Sobel/Scharr
      ④非最大信号抑制
      ⑤高低阈值输出二值图像

    代码如下:

    #Canny边缘提取
    import cv2 as cv
    def Canny_imag(image):
        blur= cv.GaussianBlur(image, (3, 3), 0)
        M = cv.cvtColor(blur, cv.COLOR_RGB2GRAY)
        # x = cv.Sobel(gray, cv.CV_16SC1, 1, 0) #x方向梯度
        # y = cv.Sobel(gray, cv.CV_16SC1, 0, 1) #y方向梯度
        # edge_output = cv.Canny(x, y, 50, 150)
        a = cv.Canny(M, 50, 150)
        cv.imshow("Canny Edge", a)
        dst = cv.bitwise_and(image, image, mask= a)
        cv.imshow("Color Edge", dst)
    src = cv.imread('15.jpg')
    cv.namedWindow('input_image', cv.WINDOW_NORMAL) #设置为WINDOW_NORMAL可以任意缩放
    cv.imshow('input_image', src)
    Canny_imag(src)
    cv.waitKey(0)
    cv.destroyAllWindows()
    

    其中第9行代码可以用6、7、8行代码代替!两种方法效果一样。

    OpenCV的Canny函数用于在图像中查找边缘,其
    函数原型有两种:
    直接调用Canny算法在单通道灰度图像中查找边缘,
    其函数原型为:Canny(image, threshold1, threshold2[, edges[, apertureSize[, L2gradient]]]) -> edges
    image参数表示8位输入图像。
    threshold1参数表示设置的低阈值。
    threshold2参数表示设置的高阈值,一般设定为低阈值的3倍 (根据Canny算法的推荐)。
    edges参数表示输出边缘图像,单通道8位图像。
    apertureSize参数表示Sobel算子的大小。
    L2gradient参数表示一个布尔值,如果为真,则使用更精确的L2范数进行计算(即两个方向的倒数的平方和再开方),否则使用L1范数(直接将两个方向导数的绝对值相加)。

    使用带自定义图像渐变的Canny算法在图像中查找边缘,
    其函数原型为:Canny(dx, dy, threshold1, threshold2[, edges[, L2gradient]]) -> edges
    dx参数表示输入图像的x导数(x导数满足16位,选择CV_16SC1或CV_16SC3)
    dy参数表示输入图像的y导数(y导数满足16位,选择CV_16SC1或CV_16SC3)。
    threshold1参数表示设置的低阈值。
    threshold2参数表示设置的高阈值,一般设定为低阈值的3倍 (根据Canny算法的推荐)。
    edges参数表示输出边缘图像,单通道8位图像。
    L2gradient参数表示L2gradient参数表示一个布尔值,如果为真,则使用更精确的L2范数进行计算(即两个方向的倒数的平方和再开方),否则使用L1范数(直接将两个方向导数的绝对值相加)。

    import cv2
    
    #********************Sobel边缘检测*****************************
    def edge_sobel( src ):
        kernelSize = (3, 3)
        gausBlurImg = cv2.GaussianBlur( src, kernelSize, 0 )
    
        #转换为灰度图
        channels = src.shape[2]
        if channels > 1:
            src_gray = cv2.cvtColor( gausBlurImg, cv2.COLOR_RGB2GRAY )
        else:
            src_gray = src.clone()
    
        scale = 1
        delta = 0
        depth = cv2.CV_16S
    
        #求X方向梯度(创建grad_x, grad_y矩阵)
        grad_x = cv2.Sobel( src_gray, depth, 1, 0 )
        abs_grad_x = cv2.convertScaleAbs( grad_x )
    
        #求Y方向梯度
        grad_y = cv2.Sobel( src_gray, depth, 0, 1 )
        abs_grad_y = cv2.convertScaleAbs( grad_y )
    
        #合并梯度(近似)
        edgeImg = cv2.addWeighted( abs_grad_x, 0.5, abs_grad_y, 0.5, 0 )
        return edgeImg
    
    #********************Laplacian边缘检测*****************************
    def edge_laplacian( src ):
        scale = 1
        delta = 0
        depth = cv2.CV_16S
    
        if src.shape[2] > 1:
            src_gray = cv2.cvtColor( src, cv2.COLOR_RGB2GRAY )
        else:
            src_gray = src.clone()
    
        kernelSize = (3, 3)
        gausBlurImg = cv2.GaussianBlur( src_gray, kernelSize, 0 )
        laplacianImg = cv2.Laplacian( gausBlurImg, depth, kernelSize )
        edgeImg = cv2.convertScaleAbs( laplacianImg )
        return edgeImg
    
    #********************Canny边缘检测*****************************
    def edge_canny( src, threshold1, threshold2 ):
        kernelSize = (3, 3)
    
        gausBlurImg = cv2.GaussianBlur( src, kernelSize, 0 )
        edgeImg = cv2.Canny( gausBlurImg, threshold1, threshold2 )
        return edgeImg
    
    #********************主函数*****************************
    imgSrc = cv2.imread( "1.jpg" )
    
    sobelImg = edge_sobel( imgSrc )
    laplacianImg = edge_laplacian( imgSrc )
    cannyImg = edge_canny( imgSrc, 20, 60 )
    
    cv2.imshow( "Origin", imgSrc )
    cv2.imshow( "Sobel", sobelImg )
    cv2.imshow( "Laplacian", laplacianImg )
    cv2.imshow( "Canny", cannyImg )
    
    cv2.waitKey( 0 )
    cv2.destroyAllWindows()
    
    
    展开全文
  • Canny算子

    2016-03-24 16:30:34
    一、Canny算子概述  通常情况下边缘检测的目的是在保留原有图像属性的情况下,显著减少图像的数据规模。目前有多种算法可以进行边缘检测,虽然Canny算法年代久远,但可以说它是边缘检测的一种标准算法,而且仍在...

    一、Canny算子概述

            通常情况下边缘检测的目的是在保留原有图像属性的情况下,显著减少图像的数据规模。目前有多种算法可以进行边缘检测,虽然Canny算法年代久远,但可以说它是边缘检测的一种标准算法,而且仍在研究中广泛使用。

            Canny算子的基本原理:总的来说,图像的边缘检测必须满足两个步骤:

    (1)有效的抑制噪声,使用高斯算子对图像进行平滑;

    (2)尽量精确的确定边缘的位置;

    二、算法的实现步骤

    Canny边缘检测算法可以分为以下5个步骤:
    1.  应用高斯滤波来平滑图像,目的是去除噪声;
    2.  找寻图像的强度梯度(intensity gradients);
    3.  应用非最大抑制(non-maximum suppression)技术来消除边误检(本来不是但检测出来是);
    4.  应用双阈值的方法来决定可能的(潜在的)边界;
    5.  利用滞后技术来跟踪边界;
    在Canny算法中,首先在x和y方向求一阶导数,然后组合为4个方向的导数。这些方向的导数达到局部最大值的点就是组成边缘的候选点。Canny算法最重要的一个新的特点是其试图将独立边的候选像素拼装成轮廓。轮廓的形成是对这些像素运用滞后性阈值。
    三、函数
    void cvCanny( const CvArr* image, CvArr* edges, double threshold1,double threshold2, int aperture_size=3 );
    参数说明:
    image    输入图像.
    edges    输出的边缘图像
    threshold1   第一个阈值
    threshold2   第二个阈值
    aperture_size  Sobel 算子内核大小 (见 cvSobel).
    函数 cvCanny 采用 CANNY 算法发现输入图像的边缘而且在输出图像中标识这些边缘。threshold1和threshold2 当中的小阈值用来控制边缘连接,大的阈值用来控制强边缘的初始分割。

     
     
     

     

    展开全文
  • canny算子

    2008-03-20 23:21:03
    VC6.0canny算子边缘检测,通过编译
  • 用c++实现Canny算子

    2020-06-30 16:17:28
    主要用C++实现canny算子。没有直接调用opencv的canny算子,自己实现canny算子的函数。
  • 以下代码是canny算子中的非极大值抑制算法·····································································%非极大值抑制function ...

    以下代码是canny算子中的非极大值抑制算法

    ·····································································

    %非极大值抑制

    function Max = cannyMax(direction,ix,iy,M)

    [m,n] = size(M);

    % 根据梯度幅度确定各点梯度的方向,并找出四个方向可能存在边缘点的坐标。

    switch direction

    case 1

    idx = find((iy<=0 & ix>-iy)  | (iy>=0 & ix|iy|

    case 2

    idx = find((ix>0 & -iy>=ix)  | (ix<0 & -iy<=ix));%|iy|>|ix|

    case 3

    idx = find((ix<=0 & ix>iy) | (ix>=0 & ix|ix|

    case 4

    idx = find((iy<0 & ix<=iy) | (iy>0 & ix>=iy));%|ix|>|iy|

    end

    %排除外部像素的干扰

    if ~isempty(idx)%如果idx不为空

    v = mod(idx,m);%求除法后的模数

    extIdx = find(v==1 | v==0 | idx<=m | (idx>(n-1)*m));%找出外部像素

    idx(extIdx) = [];%令外部像素为空

    end

    ixv = ix(idx); %得到此时方向下的ix

    iyv = iy(idx); %得到此时方向下的iy

    gradM = M(idx);%得到此时方向下的各点幅度,中心点

    %计算4个方向的梯度幅度,得到局部最大值

    switch direction

    case 1

    d = abs(iyv./ixv);%求绝对值,d<1

    gradM1 = M(idx+m).*(1-d) + M(idx+m-1).*d; %中心右上的最大值

    gradM2 = M(idx-m).*(1-d) + M(idx-m+1).*d; %中心左下的最大值,以下case中按方向同理

    case 2

    d = abs(ixv./iyv);

    gradM1 = M(idx-1).*(1-d) + M(idx+m-1).*d;

    gradM2 = M(idx+1).*(1-d) + M(idx-m+1).*d;

    case 3

    d = abs(ixv./iyv);

    gradM1 = M(idx-1).*(1-d) + M(idx-m-1).*d;

    gradM2 = M(idx+1).*(1-d) + M(idx+m+1).*d;

    case 4

    d = abs(iyv./ixv);

    gradM1 = M(idx-m).*(1-d) + M(idx-m-1).*d;

    gradM2 = M(idx+m).*(1-d) + M(idx+m+1).*d;

    end

    Max = idx(gradM>=gradM1 & gradM>=gradM2);%返回此时方向下局部的,即非极大值抑制的最大值

    ····························································································

    上面的代码中,第二个switch语句case中

    d = abs(iyv./ixv);

    gradM1 = M(idx+m).*(1-d) + M(idx+m-1).*d; %中心右上的最大值

    gradM2 = M(idx-m).*(1-d) + M(idx-m+1).*d; %中心左下的最大值,以下case中按方向同理

    为什么gradM1、gradM1代表中心右上的最大值,中心左下的最大值,这个方向根据式子是怎么来的啊?

    展开全文
  • 本程序主要功能为MATLAB中canny算子的代码实现。通过将MATLAB中canny算子用程序显示,表现canny算子的运行过程
  • 利用CANNY算子进行图像处理的matlab代码,canny算子作为一个基础的图像处理算子
  • Canny算子源码

    2016-09-20 16:36:13
    老外写的Canny算子C源码,效果非常不错
  • canny算子的完整代码,有6个步骤,可以运行,对了解canny算子的具体过程有帮助
  • canny算子代码

    2015-11-05 11:02:59
    cany算子用于边缘检测比其他算子结果更为精确,这是基于opencv的c++canny 算子源代码。
  • 使用VS+opencv+canny算子进行图像的边缘提取,Canny算子可以把找到的边缘点的位置与灰度变化最大的像素点的位置重合,并且能够区分伪边缘,边缘检测的目的是提取目标物体的精边界,识别精边界是在目标体的像素级精度...
  • Canny算子 edge detection

    2012-04-16 10:59:30
    经典的canny算子,用于提取图像边缘,边缘保持滤波预处理的Canny算子较原有Canny算子在边缘检测性能方面有一定的改善;边缘保持滤在Canny算子实施边缘检测前,运用具有边缘保持性能的滤波器做预处理.仿真实验主、客观...
  • 第一篇csdn的博客就从canny算子开始吧,之前经常看大牛们的博客,但是由于自己太烂也比较菜,所以没有写,作为csdn的第一篇博客,就好好shu说说canny算子。 之前都是看浅墨的csdn,今天自己照着敲了敲,但是居然报...

    第一篇csdn的博客就从canny算子开始吧,之前经常看大牛们的博客,但是由于自己太烂也比较菜,所以没有写,作为csdn的第一篇博客,就好好shu说说canny算子。

    之前都是看浅墨的csdn,今天自己照着敲了敲,但是居然报了中断!头疼的搞了半天,终于搞的有点明白了

    本系列文章由@浅墨_毛星云 出品,转载请注明出处。  

     

    文章链接: http://blog.csdn.net/poem_qianmo/article/details/25560901

    作者:毛星云(浅墨)    微博:http://weibo.com/u/1723155442

    知乎:http://www.zhihu.com/people/mao-xing-yun

    邮箱: happylifemxy@163.com

    写作当前博文时配套使用的OpenCV版本: 2.4.9

    附上浅墨的转载,浅墨的版本是2.4.9,而我的版本是3.3.1

    浅墨的代码是

    //简单的canny用法,直接用
        Canny(src,src,150,100,3);

    输出的边缘图是原图,我331版本呢就会报中断

    0x00007FFCC61E50D8 处(位于 ConsoleApplication7.exe 中)有未经处理的异常: Microsoft C++ 异常: cv::Exception,位于内存位置 0x000000902B2FF100 处。

    改正的方法就是把输出改一下,弄成一个新的窗口就可以了

    //直接用

        Canny(src,src1,150,100,3);

    展开全文
  • 本资源提供了五种边缘检测算子,包括Sobel 算子、roberts 算子、prewitt 算子、log算子、canny算子,用于图像处理中的图像边缘检测。
  • 本次文档,实现了对canny算子、sobel算子、laplacian算子等多种算子的边缘提取对比,使用的MATLAB实现
  • Canny算子边缘提取

    2015-08-16 17:07:05
    Canny算子边缘提取
  • Canny算子提取边缘

    2014-06-23 17:29:50
    该代码为Canny算子提取边缘,Canny算子在抑制噪声和边缘准确性方面有很好的折中,边缘提取效果良好,经测试程序运行稳定无bug。
  • canny算子的使用

    2018-06-08 09:48:47
    利用canny算子进行边缘检测,生成的边缘图可以是灰度图,也可以是彩色图。用户可以自行选择。
  • canny算子边缘提取

    2013-04-08 11:54:31
    在matlab中,编写的canny算子进行边缘提取,并且与matlab自带的canny算子进行比较。
  • https://blog.csdn.net/fengye2two/article/details/79190759 https://www.jianshu.com/p/bed4ffe996a1
  • VS2013 自适应Canny算子

    2017-04-11 15:39:22
    VS2013 自适应Canny算子

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,416
精华内容 966
关键字:

canny算子