canny運算元程序

① 求python中採用canny運算元提取圖像邊緣的源程序

需要抄下載pyopencv

#coding=utf-8

importpyopencvascv

#讀取圖像

image=cv.imread("d:/lena.jpg")

#因為Canny演算法只支持灰度圖像,所以要事先轉換

grayImage=cv.Mat(image.size(),cv.CV_8UC3)

cv.cvtColor(image,grayImage,cv.CV_RGB2GRAY)

#先生成空的邊緣圖像

edges=cv.Mat(grayImage.size(),grayImage.type())

#進行Canny轉換

cv.Canny(grayImage,edges,100,150)

#顯示圖像

cv.namedWindow("CannyImage")

cv.imshow("CannyImage",edges)

cv.waitKey()

② 跪求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);
}
//*/

③ matlab canny運算元邊緣檢測函數代碼

I = imread('lena.bmp'); %%如果是其他類型圖像,請先轉換為灰度圖

%%沒有雜訊時的檢測結果

BW_sobel = edge(I,'sobel');

BW_prewitt = edge(I,'prewitt');

BW_roberts = edge(I,'roberts');

BW_laplace = edge(I,'log');

BW_canny = edge(I,'canny'); figure(1);

subplot(2,3,1),imshow(I),xlabel('原始圖像');

subplot(2,3,2),imshow(BW_sobel),xlabel('sobel檢測');

subplot(2,3,3),imshow(BW_prewitt),xlabel('prewitt檢測');

subplot(2,3,4),imshow(BW_roberts),xlabel('roberts檢測');

subplot(2,3,5),imshow(BW_laplace),xlabel('laplace檢測');

subplot(2,3,6),imshow(BW_canny),xlabel('canny檢測');

%%加入高斯雜訊（μ=0，σ^2=0.01）檢測結果

I_g1 = imnoise(I,'gaussian',0,0.01);

BW_sobel = edge(I_g1,'sobel');

BW_prewitt = edge(I_g1,'prewitt');

BW_roberts = edge(I_g1,'roberts');

BW_laplace = edge(I_g1,'log');

BW_canny = edge(I_g1,'canny'); figure(2);

subplot(2,3,1),imshow(I_g1),xlabel('加入高斯雜訊(μ=0，σ^2=0.01)圖像');

subplot(2,3,2),imshow(BW_sobel),xlabel('sobel檢測');

subplot(2,3,3),imshow(BW_prewitt),xlabel('prewitt檢測');

subplot(2,3,4),imshow(BW_roberts),xlabel('roberts檢測');

subplot(2,3,5),imshow(BW_laplace),xlabel('laplace檢測');

subplot(2,3,6),imshow(BW_canny),xlabel('canny檢測');

%%加入高斯雜訊（μ=0，σ^2=0.02）檢測結果

I_g2 = imnoise(I,'gaussian',0,0.02);

BW_sobel = edge(I_g2,'sobel');

BW_prewitt = edge(I_g2,'prewitt');

BW_roberts = edge(I_g2,'roberts');

BW_laplace = edge(I_g2,'log');

BW_canny = edge(I_g2,'canny'); figure(3);

subplot(2,3,1),imshow(I_g2),xlabel('加入高斯雜訊(μ=0，σ^2=0.02)圖像');

subplot(2,3,2),imshow(BW_sobel),xlabel('sobel檢測');

subplot(2,3,3),imshow(BW_prewitt),xlabel('prewitt檢測');

subplot(2,3,4),imshow(BW_roberts),xlabel('roberts檢測');

subplot(2,3,5),imshow(BW_laplace),xlabel('laplace檢測');

subplot(2,3,6),imshow(BW_canny),xlabel('c