大红鹰葡京会娱乐Canny边缘检查实验算法的贯彻

图像边缘音信主要集中在高频段,平日说图像锐化或检查评定边缘,实质正是高频滤波。大家知道微分运算是求时域信号的变化率,具有增强高频分量的功用。在空白运算中的话,对图像的锐化正是持筹握算微分。由于数字图像的离散时域信号,微分运算就改为总括差分或梯度。图像处理中有各类边缘检查实验(梯度)算子,常用的统揽常见1阶差分,罗Bert算子(交叉差分),Sobel算子等等,是依据寻找梯度强度。拉普Russ算子(二阶差分)是依照过零点检验。通过总括梯度,设置阀值,获得边缘图像。

图像边缘音讯首要集中在高频段,常常说图像锐化或检查测试边缘,实质正是高频滤波。大家领略微分运算是求确定性信号的变化率,具有增强高频分量的效果。在空白运算中的话,对图像的锐化就是持筹握算微分。由于数字图像的离散功率信号,微分运算就改为总计差分或梯度。图像处理中有三种边缘检查实验(梯度)算子,常用的牢笼一般一阶差分,罗Bert算子(交叉差分),Sobel算子等等,是基于寻找梯度强度。拉普Russ算子(二阶差分)是依照过零点检查实验。通过测算梯度,设置阀值,获得边缘图像。

Canny边缘检查评定算子是一种多级检测算法。一9玖零年由JohnF. Canny提议,同时提议了边缘检测的叁大准则:

Canny边缘检查实验算子是1种多级检查测试算法。一玖八九年由JohnF. Canny建议,同时提议了边缘检查实验的3大准则:

  1. 低错误率的边缘检查评定:检查实验算法应该规范地找到图像中的尽只怕多的边缘,尽只怕的削减遗漏未检验和误检。
  2. 最优定位:检查测试的边缘点应该规范地定位于边缘的着力。
  3. 图像中的任意边缘应该只被标记三次,同时图像噪声不应发生伪边缘。
  1. 低错误率的边缘检查测试:检查实验算法应该规范地找到图像中的尽或然多的边缘,尽大概的滑坡漏检和误检。
  2. 最优定位:检验的边缘点应该规范地定位于边缘的主导。
  3. 图像中的任意边缘应该只被标记三遍,同时图像噪声不应产生伪边缘。

Canny算法出现未来一贯是作为1种标准的边缘检查测试算法,此后也油然则生了种种基于Canny算法的立异算法。时至后天,Canny算法及其各个变种照旧是1种名牌产品特产产品新品优质产品精的边缘检查实验算法。而且只有前提条件很适合,你很难找到1种边缘检查评定算子能一目掌握地比Canny算子做的更加好。

Canny算法出现之后平昔是当做壹种标准的边缘检查实验算法,此后也应运而生了各类基于Canny算法的字斟句酌算法。时至后天,Canny算法及其种种变种照旧是一种优质的边缘检查测试算法。而且唯有前提条件很吻合,你很难找到1种边缘检查评定算子能领会地比Canny算子做的越来越好。

有关种种差分算子,还有Canny算子的简约介绍,那里就不罗嗦了,网上都足以找获得。直接进去Canny算法的兑现。Canny算法分为几步。

有关各类差分算子,还有Canny算子的归纳介绍,那里就不罗嗦了,网上都足以找获得。直接进去Canny算法的落到实处。Canny算法分为几步。

  1. 高斯模糊。
  1. 高斯模糊。

这一步很简单,类似于LoG算子(Laplacian of
Gaussian)作高斯模糊一样,首要功用正是剔除噪声。因为噪音也集中于高频能量信号,很不难被辨认为伪边缘。应用高斯模糊去除噪声,下降伪边缘的甄别。可是由于图像边缘音讯也是频仍功率信号,高斯模糊的半径选取很重点,过大的半径很简单让部分弱边缘检验不到。

这一步很简短,类似于LoG算子(Laplacian of
Gaussian)作高斯模糊一样,首要意义正是去除噪声。因为噪音也集中于高频非复信号,很简单被识别为伪边缘。应用高斯模糊去除噪声,下落伪边缘的识别。不过出于图像边缘新闻也是累累数字信号,高斯模糊的半径选拔很要紧,过大的半径很不难让有个别弱边缘检查评定不到。

大红鹰葡京会娱乐 1  
大红鹰葡京会娱乐 2

大红鹰葡京会娱乐 3  
大红鹰葡京会娱乐 4

            
Lena原图                                      
莉娜高斯歪曲,半径2

            
Lena原图                                      
Lena高斯歪曲,半径2

  1. 测算梯度幅值和取向。
  1. 总括梯度幅值和趋势。

图像的边缘能够本着分裂倾向,由此经典Canny算法用了四个梯度算子来分别计算水平,垂直和对角线方向的梯度。不过普通都毫无五个梯度算子来分别计算多少个样子。常用的边缘差分算子(如Rober,Prewitt,Sobel)总括水平和垂直方向的差分Gx和Gy。那样就足以如下总括梯度模和动向:

图像的边缘能够本着差异倾向,由此经典Canny算法用了多少个梯度算子来分别计算水平,垂直和对角线方向的梯度。但是普通都并非八个梯度算子来分别计算八个样子。常用的边缘差分算子(如罗布er,Prewitt,Sobel)总括水平和垂直方向的差分Gx和Gy。那样就足以如下计算梯度模和样子:

大红鹰葡京会娱乐 5

大红鹰葡京会娱乐 6

梯度角度θ范围从弧度-π到π,然后把它好像到八个样子,分别代表水平,垂直和四个对角线方向(0°,45°,90°,13伍°)。能够以±iπ/八(i=一,三,5,七)分割,落在每个地方的梯度角给贰个特定值,代表多少个方向之一。

梯度角度θ范围从弧度-π到π,然后把它相仿到多少个方向,分别表示水平,垂直和多个对角线方向(0°,4五°,90°,13伍°)。能够以±iπ/八(i=一,三,5,柒)分割,落在各地的梯度角给七个一定值,代表四个样子之壹。

此处作者选取Sobel算子总括梯度。Sobel算法很简短,随处都得以找到,就不列出代码来了。相对于任何边缘算子,Sobel算子得出来的边缘粗大明亮。

那边自个儿采纳Sobel算子总计梯度。Sobel算法非常粗略,随地都足以找到,就不列出代码来了。相对于其余边缘算子,Sobel算子得出去的边缘粗大明亮。

大红鹰葡京会娱乐 7

大红鹰葡京会娱乐 8

 

 

 

 

 

 

下图是对上边半径贰的高斯模糊图像L通道(HSL)应用Sobel算子的梯度模图,未有施加任何阀值。

下图是对地点半径二的高斯模糊图像L通道(HSL)应用Sobel算子的梯度模图,未有施加任何阀值。

大红鹰葡京会娱乐 9

大红鹰葡京会娱乐 10

           Sobel算子,无阀值

           Sobel算子,无阀值

  1. 非最大值抑制。
  1. 非最大值抑制。

非最大值抑制是一种边缘细化措施。平日得出去的梯度边缘不止2个像素宽,而是多少个像素宽。就好像咱们所说Sobel算子得出去的边缘粗大而知晓,从地方Lena图的Sobel结果能够看得出来。因而那样的梯度图依旧很“模糊”。而轨道三渴求,边缘唯有2个规范的点小幅度。非最大值抑制能支持保留部分最大梯度而防止有所别的梯度值。这表示只保留了梯度转移中最辛辣的职分。算法如下:

非最大值抑制是壹种边缘细化措施。平常得出来的梯度边缘不止贰个像素宽,而是七个像素宽。就好像大家所说Sobel算子得出来的边缘粗大而知道,从地点Lena图的Sobel结果能够看得出来。因而那样的梯度图依然很“模糊”。而轨道3渴求,边缘唯有一个精确的点大幅度。非最大值抑制能援助保留部分最大梯度而防止有所其余梯度值。那代表只保留了梯度转移中最尖锐的职位。算法如下:

  1. 比较当前点的梯度强度和正负梯度方向点的梯度强度。
  2. 如若当前点的梯度强度和同方向的其他点的梯度强度相相比较是最大,保留其值。不然抑制,即设为0。比如当前点的趋势指向正上方90°方向,那它必要和垂直方向,它的正上方和正下方的像素相比。
  1. 正如当前点的梯度强度和正负梯度方向点的梯度强度。
  2. 若果当前点的梯度强度和同方向的别的点的梯度强度相相比较是最大,保留其值。不然抑制,即设为0。比如当前点的矛头指向正上方90°方向,那它要求和垂直方向,它的正上方和正下方的像素相比较。

专注,方向的正负是不起效用的,比如东北方向和东北方向是均等的,都认为是对角线的三个主旋律。前边我们把梯度方向近似到水平,垂直和四个对角线八个样子,所以每一种像素依据本人方向在那四个趋势之1实行相比较,决定是不是保留。那一部分的代码也很简短,列出如下。pModule,pDirection分别记录了上一步梯度模值和梯度方向。

留神,方向的正负是不起作用的,比如西北方向和东北方向是同一的,都觉得是对角线的二个趋势。前面大家把梯度方向近似到水平,垂直和几个对角线八个方向,所以各样像素根据本身方向在那八个样子之一进行相比,决定是不是保留。这一片段的代码也很简短,列出如下。pModule,pDirection分别记录了上一步梯度模值和梯度方向。

大红鹰葡京会娱乐 11大红鹰葡京会娱乐 12

大红鹰葡京会娱乐 13大红鹰葡京会娱乐 14

pmoddrow = pModule + Width + 1; 
pdirdrow = pDirection + Width + 1;
pstrongdrow = pStrong + Width + 1;
for (i = 1; i < Hend - 1; i++)
{
  pstrongd = pstrongdrow;
  pmodd = pmoddrow;
  pdird = pdirdrow;
  for (j = 1; j < Wend - 1; j++)
    {
            switch (*pdird)
            {
            case 0:        // x direction
            case 4:
                if (*pmodd > *(pmodd - 1) && *pmodd > *(pmodd + 1))
                    *pstrongd = 255;
                break;
            case 1:        // northeast-southwest direction. Notice the data order on y direction of bmp data
            case 5:
                if (*pmodd > *(pmodd + Width + 1) && *pmodd > *(pmodd - Width - 1))
                    *pstrongd = 255;
                break;
            case 2:        // y direction
            case 6:
                if (*pmodd > *(pmodd - Width) && *pmodd > *(pmodd + Width))
                    *pstrongd = 255;
                break;
            case 3:        // northwest-southeast direction. Notice the data order on y direction of bmp data
            case 7:
                if (*pmodd > *(pmodd + Width - 1) && *pmodd > *(pmodd - Width + 1))
                    *pstrongd = 255;
                break;
            default:
                ASSERT(0);
                break;
            }
            pstrongd++;
            pmodd++;
            pdird++;
    }
    pstrongdrow += Width;
    pmoddrow += Width;
    pdirdrow += Width;
}
pmoddrow = pModule + Width + 1; 
pdirdrow = pDirection + Width + 1;
pstrongdrow = pStrong + Width + 1;
for (i = 1; i < Hend - 1; i++)
{
  pstrongd = pstrongdrow;
  pmodd = pmoddrow;
  pdird = pdirdrow;
  for (j = 1; j < Wend - 1; j++)
    {
            switch (*pdird)
            {
            case 0:        // x direction
            case 4:
                if (*pmodd > *(pmodd - 1) && *pmodd > *(pmodd + 1))
                    *pstrongd = 255;
                break;
            case 1:        // northeast-southwest direction. Notice the data order on y direction of bmp data
            case 5:
                if (*pmodd > *(pmodd + Width + 1) && *pmodd > *(pmodd - Width - 1))
                    *pstrongd = 255;
                break;
            case 2:        // y direction
            case 6:
                if (*pmodd > *(pmodd - Width) && *pmodd > *(pmodd + Width))
                    *pstrongd = 255;
                break;
            case 3:        // northwest-southeast direction. Notice the data order on y direction of bmp data
            case 7:
                if (*pmodd > *(pmodd + Width - 1) && *pmodd > *(pmodd - Width + 1))
                    *pstrongd = 255;
                break;
            default:
                ASSERT(0);
                break;
            }
            pstrongd++;
            pmodd++;
            pdird++;
    }
    pstrongdrow += Width;
    pmoddrow += Width;
    pdirdrow += Width;
}

View
Code

View
Code

下图是非最大值抑制的结果。可知边缘宽度已经大大压缩。但是这么些图像中因为尚未运用任何阀值,还富含大批量小梯度模值的点,也等于图中很暗的地点。上边,阀值要登台了。

下图是非最大值抑制的结果。可知边缘宽度已经大大收缩。但是这些图像中因为未有行使任何阀值,还带有多量小梯度模值的点,相当于图中很暗的地点。下边,阀值要出演了。

大红鹰葡京会娱乐 15

大红鹰葡京会娱乐 16

             非最大值抑制结果

             非最大值抑制结果

  1. 双阀值。
  1. 双阀值。

貌似的边缘质量评定算法用二个阀值来滤除噪声或颜料变化引起的小的梯度值,而保留大的梯度值。Canny算法应用双阀值,即1个高阀值和二个低阀值来分别边缘像素。借使边缘像素点梯度值超越高阀值,则被认为是强边缘点。假如边缘梯度值小于高阀值,大于低阀值,则标记为弱边缘点。小于低阀值的点则被压制掉。这一步算法很简单。

相似的边缘检查实验算法用八个阀值来滤除噪声或颜色变化引起的小的梯度值,而保留大的梯度值。Canny算法应用双阀值,即1个高阀值和二个低阀值来区别边缘像素。倘使边缘像素点梯度值大于高阀值,则被认为是强边缘点。倘诺边缘梯度值小于高阀值,大于低阀值,则标记为弱边缘点。小于低阀值的点则被压制掉。这一步算法很粗大略。

  1. 失败边界跟踪。
  1. 战败边界跟踪。

由来,强边缘点能够认为是真正边缘。弱边缘点则或者是真的边缘,也说不定是噪声或颜料变化引起的。为取得准确的结果,后者引起的弱边缘点应该去掉。日常认为实际边缘引起的弱边缘点和强边缘点是连着的,而又噪声引起的弱边缘点则不会。所谓的落前面界跟踪算法检查一个弱边缘点的八连通领域像素,只要有强边缘点存在,那么那一个弱边缘点被认为是真是边缘保留下去。

迄今停止,强边缘点可以认为是确实边缘。弱边缘点则大概是的确边缘,也说不定是噪声或颜色变化引起的。为获得准确的结果,后者引起的弱边缘点应该去掉。日常认为真正边缘引起的弱边缘点和强边缘点是连着的,而又噪声引起的弱边缘点则不会。所谓的向下面界跟踪算法检查2个弱边缘点的八连通领域像素,只要有强边缘点存在,那么这一个弱边缘点被认为是真是边缘保留下去。

本条算法搜索全体连接的弱边缘,如若一条连接的弱边缘的此外多个点和强边缘点连通,则保留那条弱边缘,不然抑制那条弱边缘。搜索时能够用广度优先恐怕深度优先算法,小编在此地完结了应该是最不难的深度优先算法。三回连通一条边缘的吃水优先算法如下:

本条算法搜索所有连接的弱边缘,假设一条连接的弱边缘的其余二个点和强边缘点连通,则保留那条弱边缘,不然抑制那条弱边缘。搜索时能够用广度优先或许深度优先算法,小编在此间达成了应该是最不难的深度优先算法。1回连通一条边缘的吃水优先算法如下:

  1. 预备三个栈s,1个体系q,设联通提醒变量connected为假。从图像的第一个点起来,进入二。
  2. 1旦那几个点是弱边界点并且未有被标记,把它标志,并把它看成第贰个因素放入栈s中,同时把它放入记录连通曲线的队列q,进入三。即使那个点不是弱边界也许曾经被标记过,到图像的下二个点,重复二。
  3. 从栈s中取出二个要素,查找它的八像素领域。假使贰个世界像素是弱边界并且未有被标记过,把这一个圈子像素标记,并进入栈s中,同时参加队列q。同时招来领域对应的强边界图,假诺有三个像素是强边界,表示那条弱边界曲线和强边界联通,设置connected为真。重复叁直到栈中没有成分了。假若connected为假,则相继从队列q中取出各样成分,清空标记。如果connected为真,保留标记。
  4. 清空队列q,设置connected为假,移动到图像的下一个点,到二。
  1. 防微杜渐3个栈s,一个连串q,设联通提示变量connected为假。从图像的首先个点开始,进入二。
  2. 1旦这么些点是弱边界点并且未有被标记,把它标志,并把它当做第三个要素放入栈s中,同时把它放入记录连通曲线的类别q,进入叁。假若那几个点不是弱边界或许曾经被标记过,到图像的下三个点,重复二。
  3. 从栈s中取出3个元素,查找它的8像素领域。假若贰个世界像素是弱边界并且未有被标记过,把那几个小圈子像素标记,并投入栈s中,同时参加队列q。同时招来领域对应的强边界图,要是有贰个像素是强边界,表示那条弱边界曲线和强边界联通,设置connected为真。重复叁直到栈中没有成分了。假若connected为假,则相继从队列q中取出每种元素,清空标记。假设connected为真,保留标记。
  4. 清空队列q,设置connected为假,移动到图像的下叁个点,到二。

大红鹰葡京会娱乐 17大红鹰葡京会娱乐 18

大红鹰葡京会娱乐 19大红鹰葡京会娱乐 20

// 5. Edge tracking by hysteresis
    stack<CPoint> s;
    queue<CPoint> q;
    BOOL connected = FALSE;
    long row_idx = Width;
    for (i = 1; i < Height - 1; i++, row_idx += Width)
    {
        for (j = 1; j < Width - 1; j++)
        {
            pweakd = pWeak + row_idx + j;
            if (*pweakd == 255)
            {
                s.push(CPoint(j, i));
                q.push(CPoint(j, i));
                *pweakd = 1;        // Label it

                while (!s.empty())
                {
                    CPoint p = s.top();
                    s.pop();
                    // Search weak edge 8-point neighborhood
                    pweakd = pWeak + p.y*Width + p.x;
                    if (*(pweakd - Width - 1) == 255)
                    {
                        CPoint np = CPoint(p.x - 1, p.y - 1);
                        s.push(np);
                        q.push(np);
                        *(pweakd - Width - 1) = 1;        // Label it
                    }
                    if (*(pweakd - Width) == 255)
                    {
                        CPoint np = CPoint(p.x, p.y - 1);
                        s.push(np);
                        q.push(np);
                        *(pweakd - Width) = 1;        // Label it
                    }
                    if (*(pweakd - Width + 1) == 255)
                    {
                        CPoint np = CPoint(p.x + 1, p.y - 1);
                        s.push(np);
                        q.push(np);
                        *(pweakd - Width + 1) = 1;        // Label it
                    }
                    if (*(pweakd - 1) == 255)
                    {
                        CPoint np = CPoint(p.x - 1, p.y);
                        s.push(np);
                        q.push(np);
                        *(pweakd - 1) = 1;        // Label it
                    }
                    if (*(pweakd + 1) == 255)
                    {
                        CPoint np = CPoint(p.x + 1, p.y);
                        s.push(np);
                        q.push(np);
                        *(pweakd + 1) = 1;        // Label it
                    }
                    if (*(pweakd + Width - 1) == 255)
                    {
                        CPoint np = CPoint(p.x - 1, p.y + 1);
                        s.push(np);
                        q.push(np);
                        *(pweakd + Width - 1) = 1;        // Label it
                    }
                    if (*(pweakd + Width) == 255)
                    {
                        CPoint np = CPoint(p.x, p.y + 1);
                        s.push(np);
                        q.push(np);
                        *(pweakd + Width) = 1;        // Label it
                    }
                    if (*(pweakd + Width + 1) == 255)
                    {
                        CPoint np = CPoint(p.x + 1, p.y + 1);
                        s.push(np);
                        q.push(np);
                        *(pweakd + Width + 1) = 1;        // Label it
                    }
                    // Search strong edge 8-point neighborhood
                    if (connected == FALSE)
                    {
                        pstrongd = pStrong + p.y*Width + p.x;
                        for (int m = -1; m <= 1; m++)
                        {
                            for (int n = -1; n <= 1; n++)
                            {
                                if (*(pstrongd + m*Width + n) == 255)
                                {
                                    connected = TRUE;
                                    goto next;
                                }
                            }
                        }
                    }
                next:
                    continue;
                }
                // No more element in the stack
                if (connected == FALSE)
                {
                    // The weak edge is not connected to any strong edge. Suppress it.
                    while (!q.empty())
                    {
                        CPoint p = q.front();
                        q.pop();
                        pWeak[p.y*Width + p.x] = 0;
                    }
                }
                else
                {
                    // Clean the queue
                    while (!q.empty()) q.pop();
                    connected = FALSE;
                }
            }
        }
    }
    // Add the connected weak edges (labeled) into strong edge image.
    // All strong edge pixels are labeled 255, otherwise 0.
    for (i = 0; i < len; i++)
    {
        if (pWeak[i] == 1) pStrong[i] = 255;
    }
// 5. Edge tracking by hysteresis
    stack<CPoint> s;
    queue<CPoint> q;
    BOOL connected = FALSE;
    long row_idx = Width;
    for (i = 1; i < Height - 1; i++, row_idx += Width)
    {
        for (j = 1; j < Width - 1; j++)
        {
            pweakd = pWeak + row_idx + j;
            if (*pweakd == 255)
            {
                s.push(CPoint(j, i));
                q.push(CPoint(j, i));
                *pweakd = 1;        // Label it

                while (!s.empty())
                {
                    CPoint p = s.top();
                    s.pop();
                    // Search weak edge 8-point neighborhood
                    pweakd = pWeak + p.y*Width + p.x;
                    if (*(pweakd - Width - 1) == 255)
                    {
                        CPoint np = CPoint(p.x - 1, p.y - 1);
                        s.push(np);
                        q.push(np);
                        *(pweakd - Width - 1) = 1;        // Label it
                    }
                    if (*(pweakd - Width) == 255)
                    {
                        CPoint np = CPoint(p.x, p.y - 1);
                        s.push(np);
                        q.push(np);
                        *(pweakd - Width) = 1;        // Label it
                    }
                    if (*(pweakd - Width + 1) == 255)
                    {
                        CPoint np = CPoint(p.x + 1, p.y - 1);
                        s.push(np);
                        q.push(np);
                        *(pweakd - Width + 1) = 1;        // Label it
                    }
                    if (*(pweakd - 1) == 255)
                    {
                        CPoint np = CPoint(p.x - 1, p.y);
                        s.push(np);
                        q.push(np);
                        *(pweakd - 1) = 1;        // Label it
                    }
                    if (*(pweakd + 1) == 255)
                    {
                        CPoint np = CPoint(p.x + 1, p.y);
                        s.push(np);
                        q.push(np);
                        *(pweakd + 1) = 1;        // Label it
                    }
                    if (*(pweakd + Width - 1) == 255)
                    {
                        CPoint np = CPoint(p.x - 1, p.y + 1);
                        s.push(np);
                        q.push(np);
                        *(pweakd + Width - 1) = 1;        // Label it
                    }
                    if (*(pweakd + Width) == 255)
                    {
                        CPoint np = CPoint(p.x, p.y + 1);
                        s.push(np);
                        q.push(np);
                        *(pweakd + Width) = 1;        // Label it
                    }
                    if (*(pweakd + Width + 1) == 255)
                    {
                        CPoint np = CPoint(p.x + 1, p.y + 1);
                        s.push(np);
                        q.push(np);
                        *(pweakd + Width + 1) = 1;        // Label it
                    }
                    // Search strong edge 8-point neighborhood
                    if (connected == FALSE)
                    {
                        pstrongd = pStrong + p.y*Width + p.x;
                        for (int m = -1; m <= 1; m++)
                        {
                            for (int n = -1; n <= 1; n++)
                            {
                                if (*(pstrongd + m*Width + n) == 255)
                                {
                                    connected = TRUE;
                                    goto next;
                                }
                            }
                        }
                    }
                next:
                    continue;
                }
                // No more element in the stack
                if (connected == FALSE)
                {
                    // The weak edge is not connected to any strong edge. Suppress it.
                    while (!q.empty())
                    {
                        CPoint p = q.front();
                        q.pop();
                        pWeak[p.y*Width + p.x] = 0;
                    }
                }
                else
                {
                    // Clean the queue
                    while (!q.empty()) q.pop();
                    connected = FALSE;
                }
            }
        }
    }
    // Add the connected weak edges (labeled) into strong edge image.
    // All strong edge pixels are labeled 255, otherwise 0.
    for (i = 0; i < len; i++)
    {
        if (pWeak[i] == 1) pStrong[i] = 255;
    }

View
Code

View
Code

上面是对Lena图总计Canny边缘检查实验的梯度模图和2值化图,高斯半径2,高阀值拾0,低阀值50。

上边是对莉娜图总括Canny边缘检查实验的梯度模图和2值化图,高斯半径贰,高阀值拾0,低阀值50。

大红鹰葡京会娱乐 21  
大红鹰葡京会娱乐 22

大红鹰葡京会娱乐 23  
大红鹰葡京会娱乐 24

            
Canny检查测试梯度模图                        Canny检查测试梯度贰值图

            
Canny检验梯度模图                        Canny检测梯度二值图

用作比较,上边是用1阶差分和Sobel算子对原图计算的结果,阀值拾0。由于壹阶差分的梯度值相对较小,我对壹阶差分的梯度值放大了自然倍数,使得它和Sobel的梯度值保持壹致的档次。

作为相比,上边是用一阶差分和Sobel算子对原图总结的结果,阀值拾0。由于1阶差分的梯度值相对较小,作者对1阶差分的梯度值放大了必然倍数,使得它和Sobel的梯度值保持同一的水准。

大红鹰葡京会娱乐 25  
大红鹰葡京会娱乐 26

大红鹰葡京会娱乐 27  
大红鹰葡京会娱乐 28

               一阶差分梯度模图         
              壹阶差分梯度二值图

               一阶差分梯度模图         
              一阶差分梯度二值图

大红鹰葡京会娱乐 29  
大红鹰葡京会娱乐 30

大红鹰葡京会娱乐 31  
大红鹰葡京会娱乐 32

                 Sobel梯度模图            
             Sobel梯度贰值图

                 Sobel梯度模图            
             Sobel梯度2值图

很明显,Canny边缘检查实验的作用是很明朗的。比较普通的梯度算法大大抑制了噪声引起的伪边缘,而且是边缘细化,易于后续处理。对于相比度较低的图像,通过调节参数,Canny算法也能有很好的功力。

很令人侧目,Canny边缘检查评定的效益是很引人侧目标。比较日常的梯度算法大大抑制了噪声引起的伪边缘,而且是边缘细化,易于后续处理。对于比较度较低的图像,通过调节和测试参数,Canny算法也能有很好的作用。

大红鹰葡京会娱乐 33  
大红鹰葡京会娱乐 34  
大红鹰葡京会娱乐 35

大红鹰葡京会娱乐 36  
大红鹰葡京会娱乐 37  
大红鹰葡京会娱乐 38

                       原图               
            Canny梯度模,高斯半径二,低阀值30,高阀值100      
Canny梯度2值化图,高斯半径贰,低阀值30,高阀值100

                       原图               
            Canny梯度模,高斯半径二,低阀值30,高阀值十0      
Canny梯度二值化图,高斯半径贰,低阀值30,高阀值100

大红鹰葡京会娱乐 39  
大红鹰葡京会娱乐 40  
大红鹰葡京会娱乐 41

大红鹰葡京会娱乐 42  
大红鹰葡京会娱乐 43  
大红鹰葡京会娱乐 44

                      原图               
         Canny梯度模,高斯半径壹,低阀值40,高阀值80 
Canny梯度二值化图,高斯半径一,低阀值40,高阀值80

                      原图               
         Canny梯度模,高斯半径壹,低阀值40,高阀值80 
Canny梯度贰值化图,高斯半径一,低阀值40,高阀值80

参考

参考

Canny edge
detector

Canny edge
detector

canny
算法

canny
算法

 

 

相关文章

admin

网站地图xml地图