我这有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=0i<(*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=0i<(*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=0y<sz.cyy++)
{
for(x=0x<sz.cxx++)
{
dDotMul = 0
dWeightSum = 0
for(i=(-nLen)i<=nLeni++)
{
//判断是否在图像内部
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=0x<sz.cxx++)
{
for(y=0y<sz.cyy++)
{
dDotMul = 0
dWeightSum = 0
for(i=(-nLen)i<=nLeni++)
{
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=1y<sz.cy-1y++)
{
for(x=1x<sz.cx-1x++)
{
pGradX[y*sz.cx +x] = (int)( pGray[y*sz.cx+x+1]-pGray[y*sz.cx+ x-1] )
}
}
//y方向方向导数
for(x=1x<sz.cx-1x++)
{
for(y=1y<sz.cy-1y++)
{
pGradY[y*sz.cx +x] = (int)(pGray[(y+1)*sz.cx +x] - pGray[(y-1)*sz.cx +x])
}
}
//求梯度
//中间变量
double dSqt1
double dSqt2
for(y=0y<sz.cyy++)
{
for(x=0x<sz.cxx++)
{ //二阶范数求梯度
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=0x<sz.cxx++)
{
pNSRst[x] = 0
//pNSRst[(sz.cy-1)*sz.cx+x] = 0
pNSRst[sz.cy-1+x] = 0
}
for(y=0y<sz.cyy++)
{
pNSRst[y*sz.cx] = 0
pNSRst[y*sz.cx + sz.cx-1] = 0
}
for(y=1y<sz.cy-1y++)
{
for(x=1x<sz.cx-1x++)
{ //当前点
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=0k<1024k++)
{
nHist[k] = 0
}
//统计直方图,利用直方图计算阈值
for(y=0y<sz.cyy++)
{
for(x=0x<sz.cxx++)
{
if(pGray[y*sz.cx+x]==128)
{
nHist[pMag[y*sz.cx+x]]++
}
}
}
nEdgeNum = nHist[0]
nMaxMag = 0
//统计经过“非最大值抑制”后有多少像素
for(k=1k<1024k++)
{
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=0y<sz.cyy++)
{
for(x=0x<sz.cxx++)
{
nPos = y*sz.cx + x
//如果该像素是可能的边界点，并且梯度大于高阈值，
//该像素作为一个边界的起点
if((pResult[nPos]==128) &&(pMag[nPos] >= nThrHigh))
{
//设置该点为边界点
pResult[nPos] = 255
TraceEdge(y,x,nThrLow,pResult,pMag,sz)
}
}
}
//其他点已经不可能为边界点
for(y=0y<sz.cyy++)
{
for(x=0x<sz.cxx++)
{
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=0k<8k++)
{
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 = 0pointy <480pointy++)
{
for (pointx = 0pointx <640 pointx++)
{
Position=640 * (479 - pointy)+pointx
pGradMag[Position]=m_pDibData[Position]
}
}
//第一步进行高斯平滑器滤波
//进入循环,使用3*3的结构元素，处理除去第一行和最后一行以及第一列和最后一列。
for (pointy = ptLeft.y+1pointy <= ptRight.y-1pointy++)
{
for (pointx = ptLeft.x+1pointx <= ptRight.x-1pointx++)
{
Position=640 * (479 - pointy)+pointx
for (m = 0m <3m++)
{
for (n = 0n <3n++)
{
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+1pointy <= ptRight.y-1pointy++)
{
for (pointx = ptLeft.x+1pointx <= ptRight.x-1pointx++)
{
pGradX[pointy*Width +pointx]=(int)(m_Newdata[pointy*Width +pointx+1]- m_Newdata[pointy*Width +pointx-1] )
}
}
//y方向方向导数
for (pointx = ptLeft.x+1pointx <= ptRight.x-1pointx++)
{
for (pointy = ptLeft.y+1pointy <= ptRight.y-1pointy++)
{
pGradY[pointy*Width +pointx] = (int)(m_Newdata[(pointy+1)*Width +pointx] - m_Newdata[(pointy-1)*Width +pointx])
}
}
//求梯度
for (pointy = ptLeft.y+1pointy <= ptRight.y-1pointy++)
{
for (pointx = ptLeft.x+1pointx <= ptRight.x-1pointx++)
{
Position=640 * (479 - pointy)+pointx
for (m = 0m <3m++)
{
for (n = 0n <3n++)
{
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.xpointx <= ptRight.xpointx++)
{
Position=640 * (479 - ptLeft.y)+pointx
pGradMag[Position]=0
Position=640 * (479 - ptRight.y)+pointx
pGradMag[Position]=0
}
//针对第一列以及最后一列的像素点
for (pointy = ptLeft.y+1pointy <= ptRight.y-1pointy++)
{
Position=640 * (479 - pointy)+ptLeft.x
pGradMag[Position]=0
Position=640 * (479 - pointy)+ptRight.x
pGradMag[Position]=0
}
//第三步进行抑制梯度图中的非局部极值点的像素
for (pointy = ptLeft.y+1pointy <= ptRight.y-1pointy++)
{
for (pointx = ptLeft.x+1pointx <= ptRight.x-1pointx++)
{ //当前点
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+1pointy <= ptRight.y-1pointy++)
{
for (pointx = ptLeft.x+1pointx <= ptRight.x-1pointx++)
{
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+1pointy <= ptRight.y-1pointy++)
{
for (pointx = ptLeft.x+1pointx <= ptRight.x-1pointx++)
{
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
}
姓名：高强 学号：17011210057【嵌牛导读】：本文主要介绍Canny图像边缘检测算法的步骤和对各个步骤的理解
【嵌牛鼻子】：边缘检测，Canny，步骤
【嵌牛提问】：canny边缘检测算法的步骤是怎样？
【嵌牛正文】：
1. Canny边缘检测算法的提出和指标
Canny算法是John Canny在1986年提出的，那年John Canny 28岁，该文章发表在PAMI顶级期刊上（1986.IEEE Transactions on Pattern Analysis and Machine Intelligence,vol. 8, 1986 , pp 679-698 ）。
Canny算子与Marr（LoG）边缘检测方法类似（Marr大爷号称计算机视觉之父），也属于是先平滑后求导数的方法。John Canny研究了最优边缘检测方法所需的特性，给出了评价边缘检测性能优劣的三个指标：
（1）好的信噪比 ，即将非边缘点判定为边缘点的概率要低，将边缘点判为非边缘点的概率要低；
（2）高的定位性能 ，即检测出的边缘点要尽可能在实际尘友边缘的中心；
（3）对单一边缘仅有唯一响应 ，即单个边缘产生多个响应的概率要低，并且虚假响应边缘应该得到最大抑制。
用一句话说，就是希望在提高对景物边缘的敏感性的同时，可以抑制噪声的方法才是好的边缘提取方法。
2. Canny边缘检测算法的步骤 ：
（1）图像高斯滤波进行降噪处理。
（2）用一阶偏导的有限差分计算梯度告森的幅值和方向。
（3）对梯度幅值进行非极大值抑制。
（4）用双阈值算法检测和连接边缘。
3. Canny边缘检测算法的通俗理解
Canny算法的目的就是边缘检测，何为边缘？图象局部区域亮度变化显著的部分，对于灰度图像来说，也就是灰度值有一个明显变化，既从一个灰度值在很小的缓冲区域内急剧变化到另一个灰度相差较大的灰度值。那么袜兄亩怎么表征这种灰度值的变化呢？这里想到的就是导数微分，导数就是表征变化率的，但是数字图像都是离散的，也就是导数肯定会用差分来代替。也就是具体算法中的步骤2，用相邻像素的差分来计算梯度的大小和方向。但是在真实的图像中，一般会有噪声，噪声会影响梯度的计算，所以步骤1要先滤波。理论上将图像梯度幅值的元素值越大，说明图像中该点的梯度值越大，但这不能说明该点就是边缘。在Canny算法中，步骤3的非极大值抑制是进行边缘检测的重要步骤，通俗意义上是指寻找像素点的局部最大值，沿着梯度方向，比较它前面和后面的梯度值，若梯度值局部最大则有可能为边缘像素，进行保留，否则就进行抑制。步骤4是一个典型算法，有时候我们并不能一刀切，也就是超过阈值的都是边缘点，而是设两个阈值，希望在高阈值和低阈值之间的点也可能是边缘点，而且这些点最好在高阈值的附近，也就是说这些中间阈值的点是高阈值边缘点的一种延伸。所以步骤4用了双阈值来进行检测和连接边缘。双阈值有时也叫做滞后阈值。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）