canny演算法實現

A. 圖像的最邊緣部分怎麼進行平均過程 opencv

在opencv中顯示邊緣檢測很簡單，只需調用一個cvCanny函數，其使用的是Canny演算法來實現對圖像的邊緣檢測．
函數原型為：
void cvCanny( const CvArr* image,CvArr* edges,double threshold1,double threshold2, int aperture_size=3 );
第一個參數為待檢測的圖像，注意一點，其必須是灰度圖．
第二個參數為輸出的邊緣圖，其也是一個灰度圖．
後三個參數與Canny演算法直接相關，threshold1和threshold2 當中的小閾值用來控制邊緣連接，大的閾值用來控制強邊緣的初始分割，aperture_size運算元內核大小，可以去看看Canny演算法．
從彩色圖到灰度圖需要使用到cvCvtColor函數，其接受三個參數，第一為輸入，第二為輸出，第三個為轉換的標識，我們這邊是RGB到GRAY，使用的是CV_RGB2GRAY．
參考demo代碼如下：

#include <iostream>

#include <string>
#include <sstream>
#include <opencv/cv.h>
#include <opencv/highgui.h>

using namespace std;

int String2int(const string& str_)
{
int _nre = 0;
stringstream _ss;
_ss << str_;
_ss >> _nre;
return _nre;
}

void DoCanny(const string& strFileName_)
{
//原彩色圖片
IplImage* _pIplImageIn = cvLoadImage(strFileName_.data());

if (_pIplImageIn == NULL)
{
return;
}
//彩色圖片轉換成灰度圖放置的圖片
IplImage* _pIplImageCanny = cvCreateImage(cvGetSize(_pIplImageIn), _pIplImageIn->depth, 1);
cvCvtColor(_pIplImageIn, _pIplImageCanny, CV_RGB2GRAY);//CV_RGB2GRAY將rgb圖轉成灰度圖
//只有邊緣路徑的圖片
IplImage* _pIplImageOut = cvCreateImage(cvGetSize(_pIplImageIn), IPL_DEPTH_8U, 1);

//邊緣檢測只能作用於灰度圖
if (_pIplImageCanny->nChannels != 1)
{
return;
}

//邊緣檢測操作
cvCanny(_pIplImageCanny, _pIplImageOut, 1, 110, 3);

cvNamedWindow("Src");
cvShowImage("Src", _pIplImageIn);
cvNamedWindow("Canny");
cvShowImage("Canny", _pIplImageOut);

cvWaitKey(0);

cvReleaseImage(&_pIplImageIn);
cvReleaseImage(&_pIplImageCanny);
cvReleaseImage(&_pIplImageOut);

cvDestroyWindow("Src");
cvDestroyWindow("Canny");

}

int main(int argc, char* argv[])
{
if (argc < 2)
{
cout << "You should give the filename of picture!" << endl;
return -1;
}
DoCanny(argv[1]);
return 0;
}

B. canny演算法的最優邊緣准則

Canny 的目標是找到一個最優的邊緣檢測演算法，最優邊緣檢測的含義是：
(1)最優檢測：演算法能夠盡可能多地標識出圖像中的實際邊緣，漏檢真實邊緣的概率和誤檢非邊緣的概率都盡可能小；
(2)最優定位準則：檢測到的邊緣點的位置距離實際邊緣點的位置最近，或者是由於雜訊影響引起檢測出的邊緣偏離物體的真實邊緣的程度最小；
(3)檢測點與邊緣點一一對應：運算元檢測的邊緣點與實際邊緣點應該是一一對應。
為了滿足這些要求 Canny 使用了變分法（calculus of variations），這是一種尋找優化特定功能的函數的方法。最優檢測使用四個指數函數項表示，但是它非常近似於高斯函數的一階導數。

C. 需要一段用Canny運算元實現圖像邊緣檢測的MATLAB程序，拜託高手們幫幫忙，很急啊！

Matlab上有CANNY運算元的庫函數啊，直接調用就行了。
我這有VC++的邊緣檢測演算法，很長的。稍微改一下就可以用在Matlab上。
/ 一維高斯分布函數，用於平滑函數中生成的高斯濾波系數
void CFunction::CreatGauss(double sigma, double **pdKernel, int *pnWidowSize)
{
LONG i;
//數組中心點
int nCenter;
//數組中一點到中心點距離
double dDis;
//中間變數
double dValue;
double dSum;
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 CFunction::GaussianSmooth(SIZE sz, LPBYTE pGray, LPBYTE pResult, double sigma)
{
LONG x, y;
LONG 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;
//x方向濾波
for(y=0;y<sz.cy;y++)
{
for(x=0;x<sz.cx;x++)

{
dDotMul = 0;
dWeightSum = 0;
for(i=(-nLen);i<=nLen;i++)
{
//判斷是否在圖像內部
if((i+x)>=0 && (i+x)<sz.cx)
{
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<sz.cx;x++)
{
for(y=0; y<sz.cy; 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];
}
}
pResult[y*sz.cx+x] = (unsigned char)(int)dDotMul/dWeightSum;
}
}
delete []pdKernel;
pdKernel = NULL;
delete []pdTemp;
pdTemp = NULL;
}

// 方向導數,求梯度
void CFunction::Grad(SIZE sz, LPBYTE pGray,int *pGradX, int *pGradY, int *pMag)
{
LONG y,x;
//x方向的方向導數
for(y=1;y<sz.cy-1;y++)
{
for(x=1;x<sz.cx-1;x++)
{
pGradX[y*sz.cx +x] = (int)( pGray[y*sz.cx+x+1]-pGray[y*sz.cx+ x-1] );
}
}
//y方向方向導數
for(x=1;x<sz.cx-1;x++)
{
for(y=1;y<sz.cy-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<sz.cy; y++)
{
for(x=0; x<sz.cx; 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 CFunction::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<sz.cx;x++)
{
pNSRst[x] = 0;
//pNSRst[(sz.cy-1)*sz.cx+x] = 0;
pNSRst[sz.cy-1+x] = 0;
}
for(y=0;y<sz.cy;y++)
{
pNSRst[y*sz.cx] = 0;
pNSRst[y*sz.cx + sz.cx-1] = 0;
}
for(y=1;y<sz.cy-1;y++)
{
for(x=1;x<sz.cx-1;x++)
{ //當前點
nPos = y*sz.cx + x;
//如果當前像素梯度幅度為0，則不是邊界點
if(pMag[nPos] == 0)
{
pNSRst[nPos] = 0;
}
else
{ //當前點的梯度幅度
dTmp = pMag[nPos];
//x,y方向導數
gx = pGradX[nPos];
gy = pGradY[nPos];
//如果方向導數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 CFunction::EstimateThreshold(int *pMag, SIZE sz, int *pThrHigh, int *pThrLow, LPBYTE pGray,
double dRatHigh, double dRatLow)
{
LONG y,x,k;
//該數組的大小和梯度值的范圍有關，如果採用本程序的演算法
//那麼梯度的范圍不會超過pow(2,10)
int nHist[1024];
//可能邊界數
int nEdgeNum;
//最大梯度數
int nMaxMag;
int nHighCount;
nMaxMag = 0;
//初始化
for(k=0;k<1024;k++)
{
nHist[k] = 0;
}
//統計直方圖,利用直方圖計算閾值
for(y=0;y<sz.cy;y++)
{
for(x=0;x<sz.cx;x++)
{
if(pGray[y*sz.cx+x]==128)
{
nHist[pMag[y*sz.cx+x]]++;
}
}
}
nEdgeNum = nHist[0];
nMaxMag = 0;
//統計經過「非最大值抑制」後有多少像素
for(k=1;k<1024;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 CFunction::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<sz.cy;y++)
{
for(x=0;x<sz.cx;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<sz.cy;y++)
{
for(x=0;x<sz.cx;x++)
{
nPos = y*sz.cx + x;
if(pResult[nPos] != 255)
{
pResult[nPos] = 0;
}
}
}
}

//根據Hysteresis 執行的結果，從一個像素點開始搜索，搜索以該像素點為邊界起點的一條邊界的
//一條邊界的所有邊界點，函數採用了遞歸演算法
// 從（x,y)坐標出發，進行邊界點的跟蹤，跟蹤只考慮pResult中沒有處理並且可能是邊界
// 點的像素（=128），像素值為0表明該點不可能是邊界點，像素值為255表明該點已經是邊界點

void CFunction::TraceEdge(int y, int x, int nThrLow, LPBYTE pResult, int *pMag, SIZE sz)
{
//對8鄰域像素進行查詢
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[640 * (479 - yy)+xx]==128 && pMag[640 * (479 - yy)+xx]>=nThrLow )
{
//該點設為邊界點
pResult[640 * (479 - yy)+xx] = 255;
//以該點為中心再進行跟蹤
TraceEdge(yy,xx,nThrLow,pResult,pMag,sz);
}
}
}

// Canny運算元
BOOL CFunction::Canny(LPBYTE m_pDibData,CPoint ptLeft, CPoint ptRight , double sigma, double dRatLow, double dRatHigh)
{
BYTE* m_Newdata;//每一步處理後的圖像數據
m_Newdata = (BYTE*)malloc(maxImage);
memcpy(m_Newdata,(BYTE *)m_pDibData,maxImage);

//經過抑制局部像素非最大值的處理後的數據
BYTE* pResult;//每一步處理後的圖像數據
pResult = (BYTE*)malloc(maxImage);
memcpy(pResult,(BYTE *)m_pDibData,maxImage);

int pointy,pointx,m,n,i=0;
long Position;
int GradHori;
int GradVert;
//存儲結構元素的數組
BYTE array[9]={0};

//設定兩個閾值
int nThrHigh,nThrLow;

//梯度分量
int gx;
int gy;
//中間變數
int g1,g2,g3,g4;
double weight;
double dTmp,dTmp1,dTmp2;

int Width,Higth;
Width=ptRight.x-ptLeft.x+1;
Higth=ptRight.y-ptLeft.y+1;
CSize sz=CSize(Width,Higth);

//x方向導數的指針
int *pGradX= new int[maxImage];
memset(pGradX,0,maxImage);
//y方向
int *pGradY;
pGradY = new int [maxImage];
memset(pGradY,0,maxImage);
//梯度的幅度
int *pGradMag;
pGradMag = new int [maxImage];
//對pGradMag進行初始化
for (pointy = 0;pointy <480;pointy++)
{
for (pointx = 0;pointx <640 ;pointx++)
{
Position=640 * (479 - pointy)+pointx;
pGradMag[Position]=m_pDibData[Position];
}
}

//第一步進行高斯平滑器濾波
//進入循環,使用3*3的結構元素，處理除去第一行和最後一行以及第一列和最後一列。
for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
{
for (pointx = ptLeft.x+1;pointx <= ptRight.x-1;pointx++)
{
Position=640 * (479 - pointy)+pointx;
for (m = 0;m < 3;m++)
{
for (n = 0;n < 3;n++)
{
array[m*3+n]=m_pDibData[Position+640*(1-m)+n-1];
}
}
GradHori=abs(array[0]+2*array[1]+array[2]+2*array[3]+4*array[4]+2*array[5]+array[6]+2*array[7]+array[8]);
GradHori=(int)(0.0625*GradHori+0.5);
if (GradHori>255)
{
m_Newdata[Position]=255;
}
else
m_Newdata[Position]=GradHori;
}
}

//第二步用一階偏導的有限差分來計算梯度的幅值和方向
//x方向的方向導數
for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
{
for (pointx = ptLeft.x+1;pointx <= ptRight.x-1;pointx++)
{
pGradX[pointy*Width +pointx]=(int)(m_Newdata[pointy*Width +pointx+1]- m_Newdata[pointy*Width +pointx-1] );
}
}
//y方向方向導數
for (pointx = ptLeft.x+1;pointx <= ptRight.x-1;pointx++)
{
for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
{
pGradY[pointy*Width +pointx] = (int)(m_Newdata[(pointy+1)*Width +pointx] - m_Newdata[(pointy-1)*Width +pointx]);
}
}
//求梯度
for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
{
for (pointx = ptLeft.x+1;pointx <= ptRight.x-1;pointx++)
{
Position=640 * (479 - pointy)+pointx;
for (m = 0;m < 3;m++)
{
for (n = 0;n < 3;n++)
{
array[m*3+n]=m_Newdata[Position+640*(1-m)+n-1];
}
}
GradHori=abs((-1)*array[0]+(-2)*array[3]+2*array[7]+array[8]);
GradVert=abs((-1)*array[0]-2*array[1]+2*array[5]+array[8]);
GradHori =(int)((float)sqrt(pow(GradHori,2)+pow(GradVert,2))+0.5);
pGradMag[Position]=GradHori;
}
}
//針對第一行的像素點及最後一行的像素點
for (pointx = ptLeft.x;pointx <= ptRight.x;pointx++)
{
Position=640 * (479 - ptLeft.y)+pointx;
pGradMag[Position]=0;
Position=640 * (479 - ptRight.y)+pointx;
pGradMag[Position]=0;
}
//針對第一列以及最後一列的像素點
for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
{
Position=640 * (479 - pointy)+ptLeft.x;
pGradMag[Position]=0;
Position=640 * (479 - pointy)+ptRight.x;
pGradMag[Position]=0;
}

//第三步進行抑制梯度圖中的非局部極值點的像素
for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
{
for (pointx = ptLeft.x+1;pointx <= ptRight.x-1;pointx++)
{ //當前點
Position=640 * (479 - pointy)+pointx;
//如果當前像素梯度幅度為0，則不是邊界點
if(pGradMag[Position] == 0)
{
pGradMag[Position] = 0;
}
else
{ //當前點的梯度幅度
dTmp = pGradMag[Position];
//x,y方向導數
gx = pGradX[Position];
gy = pGradY[Position];
//如果方向導數y分量比x分量大，說明導數方向趨向於y分量
if(abs(gy) > abs(gx))
{
//計算插值比例
weight = fabs(gx)/fabs(gy);
g2 = pGradMag[Position-640];
g4 = pGradMag[Position+640];
//如果x,y兩個方向導數的符號相同
//C 為當前像素，與g1-g4 的位置關系為：
//g1 g2
// C
// g4 g3
if(gx*gy>0)
{
g1 = pGradMag[Position-640-1];
g3 = pGradMag[Position+640+1];
}
//如果x,y兩個方向的方向導數方向相反
//C是當前像素，與g1-g4的關系為：
// g2 g1
// C
// g3 g4
else
{
g1 = pGradMag[Position-640+1];
g3 = pGradMag[Position+640-1];
}
}
//如果方向導數x分量比y分量大，說明導數的方向趨向於x分量
else
{
//插值比例
weight = fabs(gy)/fabs(gx);
g2 = pGradMag[Position+1];
g4 = pGradMag[Position-1];
//如果x,y兩個方向的方向導數符號相同
//當前像素C與 g1-g4的關系為
// g3
// g4 C g2
// g1
if(gx * gy > 0)
{
g1 = pGradMag[Position+640+1];
g3 = pGradMag[Position-640-1];
}
//如果x,y兩個方向導數的方向相反
// C與g1-g4的關系為
// g1
// g4 C g2
// g3
else
{
g1 =pGradMag[Position-640+1];
g3 =pGradMag[Position+640-1];
}
}
//利用 g1-g4 對梯度進行插值
{
dTmp1 = weight*g1 + (1-weight)*g2;
dTmp2 = weight*g3 + (1-weight)*g4;
//當前像素的梯度是局部的最大值
//該點可能是邊界點
if(dTmp>=dTmp1 && dTmp>=dTmp2)
{
pResult[Position] = 128;
}
else
{
//不可能是邊界點
pResult[Position] = 0;
}
}
}
}
}

//第四步根據梯度計算及經過非最大值得印製後的結果設定閾值
//估計TraceEdge 函數需要的低閾值，函數使用的高閾值
EstimateThreshold(pGradMag, sz,&nThrHigh,&nThrLow,pResult,dRatHigh,dRatLow);
//尋找大於dThrHigh的點，這些點用來當作邊界點，
//然後用TraceEdge函數跟蹤該點對應的邊界
for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
{
for (pointx = ptLeft.x+1;pointx <= ptRight.x-1;pointx++)
{
Position=640 * (479 - pointy)+pointx;
//如果該像素是可能的邊界點，並且梯度大於高閾值，
//該像素作為一個邊界的起點
if((pResult[Position]==128) && (pGradMag[Position] >= nThrHigh))
{
//設置該點為邊界點
pResult[Position] = 255;
TraceEdge(pointy,pointx,nThrLow,pResult,pGradMag,sz);
}
}
}
//其他點已經不可能為邊界點
for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
{
for (pointx = ptLeft.x+1;pointx <= ptRight.x-1;pointx++)
{
Position=640 * (479 - pointy)+pointx;
if(pResult[Position] != 255)
{
pResult[Position] = 0;
}
}
}

//計算方向導數和梯度的幅度
// Grad(sz,pGaussSmooth,pGradX,pGradY,pGradMag);
//應用非最大抑制
// NonmaxSuppress(pGradMag,pGradX,pGradY,sz,pResult);
//應用Hysteresis，找到所有邊界
// Hysteresis(pGradMag,sz,dRatLow,dRatHigh,pResult);

memcpy(m_pDibData,(BYTE *)pResult,maxImage);

delete[] pResult;
pResult = NULL;
delete[] pGradX;
pGradX = NULL;
delete[] pGradY;
pGradY = NULL;
delete[] pGradMag;
pGradMag = NULL;
delete[] m_Newdata;
m_Newdata = NULL;

return true;
}

D. Canny運算元的步驟

較高的亮度梯度比較有可能是邊緣，但是沒有一個確切的值來限定多大的亮度梯度是邊緣多大，所以 Canny 使用了滯後閾值。
滯後閾值需要兩個閾值——高閾值與低閾值。假設圖像中的重要邊緣都是連續的曲線，這樣我們就可以跟蹤給定曲線中模糊的部分，並且避免將沒有組成曲線的雜訊像素當成邊緣。所以我們從一個較大的閾值開始，這將標識出我們比較確信的真實邊緣，使用前面導出的方向信息，我們從這些真正的邊緣開始在圖像中跟蹤整個的邊緣。在跟蹤的時候，我們使用一個較小的閾值，這樣就可以跟蹤曲線的模糊部分直到我們回到起點。
一旦這個過程完成，我們就得到了一個二值圖像，每點表示是否是一個邊緣點。
一個獲得亞像素精度邊緣的改進實現是在梯度方向檢測二階方向導數的過零點

它在梯度方向的三階方向導數滿足符號條件

其中

...表示用高斯核平滑原始圖像得到的尺度空間表示 L 計算得到的偏導數。用這種方法得到的邊緣片斷是連續曲線，這樣就不需要另外的邊緣跟蹤改進。滯後閾值也可以用於亞像素邊緣檢測。

E. Canny運算元的結論

Canny 演算法適用於不同的場合。它的參數允許根據不同實現的特定要求進行調整以識別不同的邊緣特性。對於PC上的實時圖像處理來說可能慢得無法使用，尤其是在使用大的高斯濾波器的情況下。但是，我們討論計算能力的時候，也要考慮到隨著處理器速度不斷提升，有望在未來幾年使得這不再成為一個問題。

F. canny演算法的參數設置

Canny 演算法包含許多可以調整的參數，它們將影響到演算法的計算的時間與實效。
高斯濾波器的大小：第一步所有的平滑濾波器將會直接影響 Canny 演算法的結果。較小的濾波器產生的模糊效果也較少，這樣就可以檢測較小、變化明顯的細線。較大的濾波器產生的模糊效果也較多，將較大的一塊圖像區域塗成一個 特定點的顏色值。這樣帶來的結果就是對於檢測較大、平滑的邊緣更加有用，例如彩虹的邊緣。
雙閾值：使用兩個閾值比使用一個閾值更加靈活，但是它還是有閾值存在的共性問題。設置的閾值過高，可能會漏掉重要信息；閾值過低，將會把枝節信息看得很重要。很難給出一個適用於所有圖像的通用閾值。目前還沒有一個經過驗證的實現方法。

G. canny演算法的OpenCV中的Canny函數

採用
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
當中的小閾值用來控制邊緣連接，大的閾值用來控制強邊緣的初始分割。

H. canny演算法的演算法概述

Canny邊緣檢測運算元是John F. Canny於 1986 年開發出來的一個多級邊緣檢測演算法。更為重要的是 Canny 創立了邊緣檢測計算理論（Computational theory of edge detection）解釋這項技術如何工作。
通常情況下邊緣檢測的目的是在保留原有圖像屬性的情況下，顯著減少圖像的數據規模。目前有多種演算法可以進行邊緣檢測，雖然Canny演算法年代久遠，但可以說它是邊緣檢測的一種標准演算法，而且仍在研究中廣泛使用。

I. 跪求canny邊緣檢測運算元的c源代碼

canny運算元代碼

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

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

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

void NonmaxSuppress(int *pMag, int *pGradX, int *pGradY, SIZE sz, LPBYTE pNSRst);

void EstimateThreshold(int *pMag, SIZE sz, int *pThrHigh, int *pThrLow, LPBYTE pGray,
double dRatHigh, double dRatLow);

void Hysteresis(int *pMag, SIZE sz, double dRatLow, double dRatHigh, LPBYTE pResult);

void TraceEdge(int y, int x, int nThrLow, LPBYTE pResult, int *pMag, SIZE sz);

void Canny(LPBYTE pGray, SIZE sz, double sigma, double dRatLow,
double dRatHigh, LPBYTE pResult);

#include "afx.h"
#include "math.h"
#include "canny.h"

// 一維高斯分布函數，用於平滑函數中生成的高斯濾波系數
void CreatGauss(double sigma, double **pdKernel, int *pnWidowSize)
{

LONG i;

//數組中心點
int nCenter;

//數組中一點到中心點距離
double dDis;

//中間變數
double dValue;
double dSum;
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;
LONG 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;

//x方向濾波
for(y=0;y<sz.cy;y++)
{
for(x=0;x<sz.cx;x++)
{
dDotMul = 0;
dWeightSum = 0;
for(i=(-nLen);i<=nLen;i++)
{
//判斷是否在圖像內部
if((i+x)>=0 && (i+x)<sz.cx)
{
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<sz.cx;x++)
{
for(y=0; y<sz.cy; 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];
}
}
pResult[y*sz.cx+x] = (unsigned char)dDotMul/dWeightSum;
}
}

delete []pdKernel;
pdKernel = NULL;

delete []pdTemp;
pdTemp = NULL;

}

// 方向導數,求梯度
void Grad(SIZE sz, LPBYTE pGray,int *pGradX, int *pGradY, int *pMag)
{
LONG y,x;

//x方向的方向導數
for(y=1;y<sz.cy-1;y++)
{
for(x=1;x<sz.cx-1;x++)
{
pGradX[y*sz.cx +x] = (int)( pGray[y*sz.cx+x+1]-pGray[y*sz.cx+ x-1] );
}
}

//y方向方向導數
for(x=1;x<sz.cx-1;x++)
{
for(y=1;y<sz.cy-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<sz.cy; y++)
{
for(x=0; x<sz.cx; 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<sz.cx;x++)
{
pNSRst[x] = 0;
pNSRst[(sz.cy-1)*sz.cx+x] = 0;

}
for(y=0;y<sz.cy;y++)
{
pNSRst[y*sz.cx] = 0;
pNSRst[y*sz.cx + sz.cx-1] = 0;
}

for(y=1;y<sz.cy-1;y++)
{
for(x=1;x<sz.cx-1;x++)
{
//當前點
nPos = y*sz.cx + x;

//如果當前像素梯度幅度為0，則不是邊界點
if(pMag[nPos] == 0)
{
pNSRst[nPos] = 0;
}
else
{
//當前點的梯度幅度
dTmp = pMag[nPos];

//x,y方向導數
gx = pGradX[nPos];
gy = pGradY[nPos];

//如果方向導數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<sz.cy;y++)
{
for(x=0;x<sz.cx;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<sz.cy;y++)
{
for(x=0;x<sz.cx;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<sz.cy;y++)
{
for(x=0;x<sz.cx;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)
{
//對8鄰域像素進行查詢
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);
}
}
}

// 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 CChildWnd::OnCanny()
{
if (! m_fOpenFile)
{
return;
}
m_fDone = TRUE;
RGBToGray(szImg, aRGB, aGray, BPP);
Canny(aGray,szImg,0.1,0.9,0.76,aBinImg);

ShowGrayImage("l",szImg,aBinImg);
}
//*/

J. 用C語言編程實現CANNY演算法

創建一個名字為canny.par的文件，就同你建立一個test.txt一樣