基于sobel和canny算法的水珠边缘检测 - 图文

基于sobel和canny算法的水珠边缘检测

李建国1，李幸汶1，卜祥洲1，陈涛2

（1.河南宏博测控技术有限公司；2.河南工业大学）

摘要：水珠识别分析方法是利用数字图像处理及模式识别技术实现，本文简要说明了水珠通过边缘检测实现模式识别和计算的原理。同时，着重讨论了水珠识别过程中的噪声识别算法，详尽地阐述了识别过程中的阈值选取方法。此应用表明了算法的实时性好，可靠性高，能很好地满足工业生产和检测要求，大大提高了水珠识别的自动化与智能化。

关键词：水珠识别 边缘检测 边缘轮廓

引言

图像识别是计算机视觉领域的一个非常活跃的课题。近几年来人们对图像识别做了大量的研究，提出了很多种算法和方法，但电力行业应用的相对较少。传统的图像识别方法已不能满足高精度，高效率的要求。电力输配电企业对绝缘子的憎水性要求较高，因为其憎水性直接决定着绝缘子绝缘性能的好坏，并可以减少高压电击穿和污闪故障的发生。因绝缘子的憎水性变差而导致泄漏电流的增加，大大提高了输配电线路的安全隐患。因此，迫切需要提高绝缘子憎水性能安全检测的手段，实现检测的自动化和智能化。目前，检测系统都是拆卸绝缘子并通过实验室法进行测试，不能实现在线检测。对于在线喷水并通过CCD取像得到的图像，核心功能是水珠识别算法，算法的不同就决定了检测效果有很大的差别。那么，设计一个既快速又稳定的水珠识别算法，对水珠识别来说具有十分重要的意义。本文就是在如何准确提取水珠面积（或轮廓）的思想下，提出的一种新的识别算法。且通过人机交互接口，还可以满足其它行业（如建材或医疗）不同精度和质量级别需求。

工作原理

其基本工作原理：喷水装置在喷雾过程中，通过取像 CCD（Charge coupled Device）在线拍摄图像数据，图像数据经图像采集卡收集并传入计算机，由系统水珠识别算法设置相应的阈值，检测水珠边缘界线并计算水珠面积和所占用面积比，同时通过水珠的边缘轮廓计算水珠的形状因子。形状因子决定了水珠是否有粘连或流动，而面积反应了水珠的大小。计算这些元素，首先需要得到水珠的外形或形状轮廓，即：水珠边缘的检测。

Sobel（索贝尔）算子：

索贝尔算子（Sobel operator）是图像处理中的常用算子之一，主要用作边缘检测。在

技术上，它是一离散性差分算子，用来运算图像亮度函数的梯度之近似值。在图像的任何一点使用此算子，将会产生对应的梯度矢量或是其法矢量。对梯度幅值进行非极大值抑制，若（x，y）像素点的梯度幅值M（x，y）大于或等于沿梯度方向上，即：平行于H（x，y）方向的两个相邻像素点的梯度幅值，则判定该点为可能的边缘点。[5]p3

该算子包含两组3x3的矩阵，分别为横向及纵向运算模板，如果用Sobel算子检测图像的边缘，可以先分别用水平算子和垂直算子对图像进行平面卷积[2]p1，即可分别得出横向及纵向的亮度差分近似值。如果以A代表原始图像，Gx及Gy分别代表经横向及纵向边缘检测的图像，其公式如下:

??10?1???1?2?1?????00??A Gx=??20?2??A Gy=?0??10?1???1?2?1?????图像的每一个像素的横向及纵向梯度近似值可用以下的公式结合，来计算梯度的大小： Gx = (-1)*f(x-1,y-1)+0*f(x,y-1)+1*f(x+1,y-1)+(-2)*f(x-1,y)+0*f(x,y)+2*f(x+1,y)+

(-1)*f(x-1,y+1)+0*f(x,y+1)+1*f(x+1,y+1)

= [f(x+1,y-1)+2*f(x+1,y)+f(x+1,y+1)]-[f(x-1,y-1)+2*f(x-1,y)+f(x-1,y+1)]Gy = 1*f(x-1,y-1)+2*f(x,y-1)+1*f(x+1,y-1)+0*f(x-1,y)+0*f(x,y)+0*f(x+1,y)+ (-1)*f(x-1,y+1)+(-2)*f(x,y+1)+(-1)*f(x+1,y+1)

= [f(x-1,y-1)+2*f(x,y-1)+f(x+1,y-1)]-[f(x-1,y+1)+2*f(x,y+1)+f(x+1,y+1)] 其中f(a,b),表示图像(a,b)点的灰度值。图像的每一个像素的横向及纵向灰度值通过以下公式结合,来计算该点灰度的大小：

22G?Gx?Gy[3]p2

通常,为了提高效率,使用不开方的近似值：

G?Gx?Gy

如果梯度G大于某一阈值，则认为该点（x，y）为边缘点。 可用以下公式计算梯度方向： ?Gy???arctan?G?x??? ? 上例中，如果角度Θ等于零，即代表图像在该处拥有纵向边缘，左方较右方暗。

在边沿检测中，常用的一种模板是Sobel 算子。Sobel 算子有两个，一个用来检测水平边沿，另一个用来检测垂直边沿。与“和”相比，Sobel算子对于象素的位置的影响做了加权，因此效果更好。

Sobel算子另一种形式是各向同性Sobel(Isotropic Sobel)算子，也由一个水平和垂直边沿检测算子组成。各向同性Sobel算子和普通Sobel算子相比，它的位置加权系数更为准确，在检测不同方向的边沿时梯度的幅度一致。由于水珠图像的特殊性，处理该类型图像轮廓时，并不需要对梯度方向进行运算，所以程序并没有给出各向同性Sobel算子的处理方法。

由于Sobel算子是滤波算子的形式，用于提取边缘，可以利用快速卷积函数。因为其简

单有效，因此应用广泛。美中不足的是Sobel算子并没有将图像的主体与背景严格地区分开来，Sobel算子没有基于图像灰度进行处理，且没有严格地模拟人的视觉生理特征，所以提取的图像轮廓有时并不能令人满意。处理图像的时候关注的是图像与背景不同的部分，并没有把关注点与图像背景区分开来。基于此给出了下面阈值化轮廓提取算法，该算法已在数学上证明当像素点满足正态分布时所求解是最优化的。 Canny算子：

拉普拉斯算子是2阶微分算子，相当于求取2次微分，精度比较高，但对噪声过于敏感是它的重大缺点，所以这种算子并不是特别常用。索贝尔（Sobel）算子是最常用的一种一阶算子，方法简单、效果好，但提取出的边缘比较粗，要进行细化处理。坎尼（Canny）算子在使用时，要提供给一些参数用于控制算法的性能。对于不同的图像或不同的边缘提取要求，应该提供不同的参数，以达到最佳效果。它也有模板运算方法，模板的大小也比较大，与提供的参数有关。标准的大小差不多是17*17，可根据算子的可分离性用快速算法，使用标准算子非常慢。坎尼（Canny）算子的2值化也很有特色，具有一定的智能性。

RGB图像边缘计算在图像中的方向相同，只有两个边缘具有相同的方向。如果问题只是检测边缘，单独分量方法通常可产生可接受的结果。然而，如果把准确度做为重点，明显需要一个适用于向量梯度的新定义。[1]p281

Canny边缘检测算法一般分为四步：

一、用一个高斯滤波器平滑输入图象；[1]p463~466

二、用一阶偏导的有限差分来计算梯度幅值和方向（角度）图像； 三、对梯度幅值图像进行非极大值抑制； 四、用双阈值算法检测和连接边缘。

坎尼方法基于三个基本目标：

1．低错误率。所有边缘都应被找到，并且应该没有伪响应。也就是检测以的边缘必须

可能是真实的边缘。

2．边缘点应被很好地定位。已定位边缘必须尽可能接近真实边缘。也就是由检测标记为边缘的点和真实边缘的中心之间的距离应该最小。

3．单一的边缘点响应。对于真实的边缘点，检测器仅应返回一个点。也就是真实边缘周围的局部最大数应该是最小的。这意味着在仅存一个单一边缘点的位置，检测器不应指出多个边缘像素。

坎尼的工作本质是从数学上表达了上面的三个准则，并试图找到这些表达式的最佳解。通常，寻找一个满足这一目标的、严格形式的解是很困难的（或不可能的）。然而，对由加性高斯白噪声污染的一维台阶边缘使用数字最佳化会得到这样一个结论，即参最佳台阶边缘检测器的一个较好近似是高斯一阶导数：

dedx?x22?2??x?2e?x22?2

使用一个环形二维高斯函数平滑图像，计算结果的梯度，然后使用幅度和方向来估计每一点处的边缘强度和方向。令

f(x,y)表示输入图像， G(x,y)表示高斯函数：

x2?y2G(x,y)?e2?2

利用G(x,y)和f(x,y)的卷积形成一幅平滑的图像fx(x,y)：

fs(x,y)?G(x,y)?f(x,y)

这一操作源自计算梯度和方向：

?gy?22M(x,y)?gx?gy和?(x,y)?arctan ?? 其中，gx??fs?x，gy??fs?y。

?gx?任何滤波器模板对都可以用来得到gx和gy，使用一个大小为n?n的高斯模板来实现，

M(x,y)和?(x,y)与计算出它们的图像尺寸相同的阵列。

Canny算法提取的图像边缘基本上可以满足视觉的要求，但达不到单像素级别，尤其是在边缘的拐角点处，多对一响应现象严重。为获得单像素级精细边缘，我们引入数学形态学算法实现对边缘细化处理，本文采用文献

[4]的算法。

算法的设计

基本工作原理：CCD（Charge coupled Device）拍摄的水珠图像数据经采集卡收集并传入

计算机，由系统降噪算法识别杂质，经过滤波后去除无关信息。经过边缘检测和连接边缘形成完整的水珠轮廓，分别计算闭合区域面积和周长，得到最大水珠的面积比。 2.1 建立憎水性对照表

根据不同的水珠面积和比例，参照相关的周长与形状因子的大小，可以确定介质的憎水性能。所以，在进行测试和计算之前，需要一个对照表。 2.2边缘检测实验程序：

这是一个图像对象提取方案,分别在水平方向和垂直方向检测边缘。

// Sobel算子

/* m_nValues = {-1, 0, 1

-2, 0, 2 -1, 0, 1} */

// 检测垂直平边沿

C3By3Filter Filter1;

Filter1.m_nValues[0][0] = -1; Filter1.m_nValues[0][1] = 0; Filter1.m_nValues[0][2] = 1; Filter1.m_nValues[1][0] = -2; Filter1.m_nValues[1][1] = 0; Filter1.m_nValues[1][2] = 2; Filter1.m_nValues[2][0] = -1; Filter1.m_nValues[2][1] = 0; Filter1.m_nValues[2][2] = 1;

// 检测水平边沿

/* m_nValues = {-1,-2,-1

0, 0, 0 1, 2, 1} */

C3By3Filter Filter2;

Filter2.m_nValues[0][0] = -1; Filter2.m_nValues[0][1] = -2; Filter2.m_nValues[0][2] = -1;

Filter2.m_nValues[1][0] = 0; Filter2.m_nValues[1][1] = 0; Filter2.m_nValues[1][2] = 0; Filter2.m_nValues[2][0] = 1; Filter2.m_nValues[2][1] = 2; Filter2.m_nValues[2][2] = 1;

// 水平算子基于x方向和垂直算子基于y方向，对图像进行平面卷积 for (int y=0; bSuccess && y

for (int x=0; bSuccess && x

if (dibCopy.m_pWorkingArea->PointInSelection(CPoint(x, y))) {

COLORREF c1 = Filter1.Filter(dibCopy, lpDibBitsSrc, x, y); COLORREF c2 = Filter2.Filter(dibCopy, lpDibBitsSrc, x, y); int r = max(GetRValue(c1), GetRValue(c2)); int g = max(GetGValue(c1), GetGValue(c2)); int b = max(GetBValue(c1), GetBValue(c2)); bSuccess = SetPixel(x+rectDest.left, y+

rectDest.top, RGB(r, g, b), lpDibBitsDest);

}

}

}

CANY检测的函数部分：

// 一维高斯分布函数，用于平滑函数中生成的高斯滤波系数

void CreatGauss(double sigma, double **pdKernel, int *pnWidowSize) {

LONG i; int nCenter; double dDis; double dValue; double dSum = 0;

//数组中心点

//数组中一点到中心点距离 //中间变量

// [-3*sigma,3*sigma] 以内数据，会覆盖绝大部分滤波系数

*pnWidowSize = 1+ 2*ceil(3*sigma); nCenter = (*pnWidowSize)/2;

*pdKernel = new double[*pnWidowSize]; for(i=0;i<(*pnWidowSize);i++) {//生成高斯数据

dDis = double(i - nCenter);

dValue = exp(-(1/2)*dDis*dDis/(sigma*sigma))/

(sqrt(2*3.1415926)*sigma);

(*pdKernel)[i] = dValue;

dSum+=dValue; }

for(i=0;i<(*pnWidowSize);i++) {//归一化

(*pdKernel)[i]/=dSum; } }

//用高斯滤波器平滑原图像

void GaussianSmooth(SIZE sz, LPBYTE pGray,LPBYTE pResult, double sigma) {

LONG x, y, i; int nWindowSize; int nLen;

//高斯滤波器长度 //窗口长度 //一维高斯滤波器

//高斯系数与图像数据的点乘

double *pdKernel; double dDotMul;

double dWeightSum; //滤波系数总和 double *pdTemp;

pdTemp = new double[sz.cx*sz.cy];

CreatGauss(sigma, &pdKernel, &nWindowSize); //产生一维高斯数据 nLen = nWindowSize/2;

for(y=0;y

for(x=0;x

dDotMul = 0;

dWeightSum = 0;

for(i=(-nLen);i<=nLen;i++){

if((i+x)>=0 && (i+x)

//判断是否在图像内部

dDotMul+=(double)pGray[y*sz.cx+(i+x)] *

pdKernel[nLen+i];

}

} }

}

dWeightSum += pdKernel[nLen+i];

pdTemp[y*sz.cx+x] = dDotMul/dWeightSum;

//y方向滤波

for(x=0; x

for(y=0; y

dDotMul = 0; dWeightSum = 0;

for(i=(-nLen);i<=nLen;i++){

if((i+y)>=0 && (i+y)< sz.cy){

dDotMul +=

(double)pdTemp[(y+i)*sz.cx+x]*pdKernel[nLen+i]; dWeightSum += pdKernel[nLen+i]; } }

} }

delete []pdKernel; pdKernel = NULL; delete []pdTemp; pdTemp = NULL;

pResult[y*sz.cx+x] = (unsigned char)dDotMul/dWeightSum;

}

// 方向导数,求梯度

void Grad(SIZE sz, LPBYTE pGray,int *pGradX, int *pGradY, int *pMag) {

LONG y,x;

for(y=1;y

for(x=1;x

pGradX[y*sz.cx +x] = (int)( pGray[y*sz.cx+x+1]-

pGray[y*sz.cx+ x-1] );

} }

for(x=1;x

for(y=1;y

pGradY[y*sz.cx +x] = (int)(pGray[(y+1)*sz.cx +x] –

pGray[(y-1)*sz.cx +x]);

} }

double dSqt1; //中间变量 double dSqt2;

for(y=0; y

//求梯度

for(x=0; x

dSqt1 = pGradX[y*sz.cx + x]*pGradX[y*sz.cx + x]; dSqt2 = pGradY[y*sz.cx + x]*pGradY[y*sz.cx + x]; pMag[y*sz.cx+x] = (int)(sqrt(dSqt1+dSqt2)+0.5); } } }

//非最大抑制

void NonmaxSuppress(int *pMag, int *pGradX, int *pGradY,

SIZE sz, LPBYTE pNSRst)

{

LONG y,x; int nPos;

//梯度分量

int gx; int gy;

//中间变量

int g1,g2,g3,g4; double weight;

double dTmp,dTmp1,dTmp2;

//设置图像边缘为不可能的分界点

for(x=0;x

pNSRst[x] = 0;

pNSRst[(sz.cy-1)*sz.cx+x] = 0; }

for(y=0;y

pNSRst[y*sz.cx] = 0;

pNSRst[y*sz.cx + sz.cx-1] = 0; }

for(y=1;y

for(x=1;x

nPos = y*sz.cx + x; //当前点

if(pMag[nPos] == 0){ //如果当前像素梯度幅度为0，则不是边界点

pNSRst[nPos] = 0; }

else{ //当前点的梯度幅度

dTmp = pMag[nPos]; gx = pGradX[nPos]; gy = pGradY[nPos];

//x,y方向导数

//如果方向导数y分量比x分量大，说明导数方向趋向于y分量

if(abs(gy) > abs(gx)){ //计算插值比例

weight = fabs(gx)/fabs(gy); g2 = pMag[nPos-sz.cx]; g4 = pMag[nPos+sz.cx];

//如果x,y两个方向导数的符号相同，C 为当前像素，与g1-g4 的位置关系为：

// g1 g2 // C // g4 g3

if(gx*gy>0){

g1 = pMag[nPos-sz.cx-1]; g3 = pMag[nPos+sz.cx+1]; }

//如果x,y两个方向的方向导数方向相反，C是当前像素，与g1-g4的关系为：

// g2 g1 // C // g3 g4

else {

g1 = pMag[nPos-sz.cx+1]; g3 = pMag[nPos+sz.cx-1]; } }

//如果方向导数x分量比y分量大，说明导数的方向趋向于x分量

else{ //插值比例

weight = fabs(gy)/fabs(gx); g2 = pMag[nPos+1]; g4 = pMag[nPos-1];

//如果x,y两个方向的方向导数符号相同，当前像素C与 g1-g4的关系为 // g3 // g4 C g2 // g1

if(gx * gy > 0){

g1 = pMag[nPos+sz.cx+1]; g3 = pMag[nPos-sz.cx-1]; }

// 如果x,y两个方向导数的方向相反，C与g1-g4的关系为 // g1 // g4 C g2 // g3

else{

g1 = pMag[nPos-sz.cx+1]; g3 = pMag[nPos+sz.cx-1]; } }

{//利用 g1-g4 对梯度进行插值

dTmp1 = weight*g1 + (1-weight)*g2; dTmp2 = weight*g3 + (1-weight)*g4;

//当前像素的梯度是局部的最大值，该点可能是边界点

if(dTmp>=dTmp1 && dTmp>=dTmp2) {

pNSRst[nPos] = 128; } else {

pNSRst[nPos] = 0; //不可能是边界点 } } } } } }

// 统计pMag的直方图，判定阈值

void EstimateThreshold(int *pMag, SIZE sz, int *pThrHigh,

int *pThrLow, LPBYTE pGray, double dRatHigh, double dRatLow) {

LONG y,x,k;

//该数组的大小和梯度值的范围有关，如果采用本程序的算法 //那么梯度的范围不会超过pow(2,10)

int nHist[256]; //可能边界数 int nEdgeNum; int nMaxMag; int nHighCount; nMaxMag = 0; for(k=0;k<256;k++){

nHist[k] = 0; }

//最大梯度数

//初始化

//统计直方图,利用直方图计算阈值

for(y=0;y

for(x=0;x

if(pGray[y*sz.cx+x]==128){

nHist[pMag[y*sz.cx+x]]++; } } }

nEdgeNum = nHist[0]; nMaxMag = 0;

//统计经过“非最大值抑制”后有多少像素

for(k=1;k<256;k++){

if(nHist[k] != 0){

nMaxMag = k; }

//梯度为0的点是不可能为边界点的经过non-maximum suppression后有多少像素

nEdgeNum += nHist[k];

}

//梯度比高阈值*pThrHigh 小的像素点总书目

nHighCount = (int)(dRatHigh * nEdgeNum + 0.5); k=1;

nEdgeNum = nHist[1]; //计算高阈值

while((k<(nMaxMag-1)) && (nEdgeNum < nHighCount)){

k++;

nEdgeNum += nHist[k]; }

*pThrHigh = k; //低阈值

*pThrLow = (int)((*pThrHigh) * dRatLow + 0.5); }

//利用函数寻找边界起点

void Hysteresis(int *pMag, SIZE sz, double dRatLow,

double dRatHigh, LPBYTE pResult)

{

LONG y,x;

int nThrHigh,nThrLow; int nPos;

//估计TraceEdge 函数需要的低阈值，以及Hysteresis函数使用的高阈值

EstimateThreshold(pMag,sz,&nThrHigh,&nThrLow,pResult,

dRatHigh,dRatLow);

//寻找大于dThrHigh的点，这些点用来当作边界点，然后用TraceEdge函数跟踪该点对应的边界

for(y=0;y

for(x=0;x

nPos = y*sz.cx + x;

//如果该像素是可能的边界点，并且梯度大于高阈值，该像素作为一个边界的起点

if((pResult[nPos]==128) && (pMag[nPos] >= nThrHigh)){

pResult[nPos] = 255; //设置该点为边界点 TraceEdge(y,x,nThrLow,pResult,pMag,sz);

} } }

for(y=0;y

//其他点已经不可能为边界点

for(x=0;x

nPos = y*sz.cx + x; if(pResult[nPos] != 255){

pResult[nPos] = 0; } } } }

/*根据Hysteresis 执行的结果，从一个像素点开始搜索，搜索以该像素点为边界起点的一条边界的一条边界的所有边界点，函数采用了递归算法。从（x,y)坐标出发，进行边界点的跟踪，跟踪只考虑pResult中没有处理并且可能是边界点的像素（=128），像素值为0表明该点不可能是边界点，像素值为255表明该点已经是边界点*/

void TraceEdge(int y, int x, int nThrLow, LPBYTE pResult,

int *pMag, SIZE sz)

{

int xNum[8] = {1,1,0,-1,-1,-1,0,1}; int yNum[8] = {0,1,1,1,0,-1,-1,-1}; LONG yy,xx,k; for(k=0;k<8;k++){

yy = y+yNum[k]; xx = x+xNum[k];

if(pResult[yy*sz.cx+xx]==128 && pMag[yy*sz.cx+xx]>=nThrLow){

pResult[yy*sz.cx+xx]=255;//该点设为边界点，以该点为中心再进行跟踪 TraceEdge(yy,xx,nThrLow,pResult,pMag,sz); } }

//对8邻域像素进行查询

}

// Canny算子

void Canny(LPBYTE pGray, SIZE sz, double sigma, double dRatLow, double dRatHigh, LPBYTE pResult) { //经过高斯滤波后的图像

LPBYTE pGaussSmooth;

pGaussSmooth=new unsigned char[sz.cx*sz.cy]; //x方向导数的指针 int *pGradX;

pGradX = new int[sz.cx*sz.cy];

//y方向

int *pGradY;

pGradY = new int[sz.cx*sz.cy];

//梯度的幅度

int *pGradMag;

pGradMag = new int[sz.cx*sz.cy];

//对原图高斯滤波

GaussianSmooth(sz,pGray,pGaussSmooth,sigma);

//计算方向导数和梯度的幅度

Grad(sz,pGaussSmooth,pGradX,pGradY,pGradMag);

//应用非最大抑制

NonmaxSuppress(pGradMag,pGradX,pGradY,sz,pResult);

//应用Hysteresis，找到所有边界

Hysteresis(pGradMag,sz,dRatLow,dRatHigh,pResult); delete[] pGradX; pGradX = NULL; delete[] pGradY; pGradY = NULL; delete[] pGradMag; pGradMag = NULL; delete[] pGaussSmooth;

pGaussSmooth = NULL; }

void OnCanny() {

if (! m_fOpenFile){

return; }

m_fDone = TRUE;

RGBToGray(szImg, aRGB, aGray, BPP); Canny(aGray,szImg,0.1,0.9,0.76,aBinImg); ShowGrayImage(\} 演示图像：

Sobel边缘检测后的图像

Canny边缘检测后的图像

根据上图对照，明显可以得出canny 检测比sobel检测的效果更好。 三、结束语

1、sobel算子根据像素点上下、左右邻点灰度值加权值，在边缘处打到极大值这一现象检测边缘。对噪声具有平滑作用，提供较为精确的边缘方向信息，但是边缘定位精度不够高。当对精度要求不是很高的时候，是一种较为常用的边缘检测方法。

2、canny算子是边缘检测中最具有代表的一种局部极值边缘检测。无论从视觉效果还是客观评价来看，canny算子提取的边缘线性连接程度较好，对此类边缘提取比较完整，边缘线很细腻。

参考文献

[1] 数字图像处理《第三版》中文版（Rafael C.Ganzalez）, 2014.04(7)

[2] 吴术路，WU Shu-lu.基于Sobel算子图像边缘检测的MATLAB实现，2010,06(19) [3] 王瀚闻，基于索贝尔算子的高分辨率遥感影像分割技术研究，内蒙古大学生命科学学院2000年，1674-098X(2012)08(a)-0018-01

[4] MaIIatS，ZhongS. Characterization of SignaIs from MuItiscaIe Edges[J].IEEE Trans on

PAMI，1992，14（7）：710-732

[5] MeerP，Georgescu B. Edge Detection with Embedded Confidence［J］.IEEE Trans on PAMI，2001，23（120）：1351-1365.

本文来源：https://www.bwwdw.com/article/y8n6.html