canny的使用代码（canny算子代码）

本篇文章给大家谈谈canny的使用代码，以及canny算子代码对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、3种python3的canny边缘检测之静态，可调节和自适应
• 2、跪求canny边缘检测算子的c源代码
• 3、matlab canny算子边缘检测函数代码
• 4、需要一段用Canny算子实现图像边缘检测的MATLAB程序，拜托高手们帮帮忙，很急啊！
• 5、图像的最边缘部分怎么进行平均过程 opencv
• 6、opencv里面对cvCanny函数使用的时候对图像有要求吗？为什么我的这段代码运行不了，不报错。

3种python3的canny边缘检测之静态，可调节和自适应

先看高级版的python3的canny的自适应边缘检测：

内容：

1 canny的边缘检测的介绍。

2 三种方法的canny的边缘检测，由浅入深地介绍：固定值的静态，可自调节的，自适应的。

说明：

1 环境：python3.8、opencv4.5.3和matplotlib3.4.3。

2 图片：来自品阅网正版免费图库。

3 实现自适应阈值的canny边缘检测的参考代码和文章：

上述的代码，本机均有报错，故对代码进行修改，注释和运行。

初级canny：

1 介绍：opencv中给出了canny边缘检测的接口，直接调用：

即可得到边缘检测的结果ret，其中，t1，t2是需要人为设置的阈值。

2 python的opencv的一行代码即可实现边缘检测。

3 Canny函数及使用：

4 Canny边缘检测流程：

去噪 -- 梯度 -- 非极大值抑制 -- 滞后阈值

5 代码：

6 操作和过程：

7 原图：

8 疑问：

ret = cv2.canny(img,t1,t2)，其中，t1，t2是需要人为设置的阈值，一般人怎么知道具体数值是多少，才是最佳的呀？所以，这是它的缺点。

中级canny：

1 中级canny，就是可调节的阈值，找到最佳的canny边缘检测效果。

2 采用cv2.createTrackbar来调节阈值。

3 代码：

4 操作和效果：

5 原图：

高级canny：

1 自适应canny的算法：

ret = cv2.canny(img,t1,t2)

即算法在运行过程中能够自适应地找到较佳的分割阈值t1，t2。

2 文件结构：

3 main.py代码：

4 dog.py代码：

5 bilateralfilt.py代码：

6 原图：

7 效果图：本文第一个gif图，此处省略。

小结：

1 本文由浅入深，总结的很好，适合收藏。

2 对于理解python的opencv的canny的边缘检测，很有帮助。

3 本文高级版canny自适应的算法参考2篇文章，虽然我进行代码的删除，注释，修改，优化等操作，故我不标注原创，对原作者表达敬意。

4 自己总结和整理，分享出来，希望对大家有帮助。

跪求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;ysz.cy;y++)

{

for(x=0;xsz.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; xsz.cx;x++)

{

for(y=0; ysz.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;ysz.cy-1;y++)

{

for(x=1;xsz.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;xsz.cx-1;x++)

{

for(y=1;ysz.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; ysz.cy; y++)

{

for(x=0; xsz.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;xsz.cx;x++)

{

pNSRst[x] = 0;

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

}

for(y=0;ysz.cy;y++)

{

pNSRst[y*sz.cx] = 0;

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

}

for(y=1;ysz.cy-1;y++)

{

for(x=1;xsz.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*gy0)

{

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;k256;k++)

{

nHist[k] = 0;

}

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

for(y=0;ysz.cy;y++)

{

for(x=0;xsz.cx;x++)

{

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

{

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

}

}

}

nEdgeNum = nHist[0];

nMaxMag = 0;

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

for(k=1;k256;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;ysz.cy;y++)

{

for(x=0;xsz.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;ysz.cy;y++)

{

for(x=0;xsz.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;k8;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

一、没有噪声时的检测结果 1 原始图像 

2 Sobel算子边缘检测 3 Prewitt算子边缘检测 4 Roberts算子边缘检测 5 Laplace算子边缘检测 6 Canny算子边缘检测

二、加入高斯噪声（μ=0，σ^2=0.01）检测结果 1 原始图像

2 Sobel算子边缘检测 3 Prewitt算子边缘检测 4 Roberts算子边缘检测 5 Laplace算子边缘检测 6 Canny算子边缘检测

三、加入高斯噪声（μ=0，σ^2=0.02）检测结果 1 原始图像

2 Sobel算子边缘检测 3 Prewitt算子边缘检测 4 Roberts算子边缘检测 5 Laplace算子边缘检测 6 Canny算子边缘检测

clear all; close all;

warning off all;

需要一段用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;ysz.cy;y++)

{

for(x=0;xsz.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; xsz.cx;x++)

{

for(y=0; ysz.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;ysz.cy-1;y++)

{

for(x=1;xsz.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;xsz.cx-1;x++)

{

for(y=1;ysz.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; ysz.cy; y++)

{

for(x=0; xsz.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;xsz.cx;x++)

{

pNSRst[x] = 0;

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

pNSRst[sz.cy-1+x] = 0;

}

for(y=0;ysz.cy;y++)

{

pNSRst[y*sz.cx] = 0;

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

}

for(y=1;ysz.cy-1;y++)

{

for(x=1;xsz.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*gy0)

{

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;k1024;k++)

{

nHist[k] = 0;

}

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

for(y=0;ysz.cy;y++)

{

for(x=0;xsz.cx;x++)

{

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

{

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

}

}

}

nEdgeNum = nHist[0];

nMaxMag = 0;

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

for(k=1;k1024;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;ysz.cy;y++)

{

for(x=0;xsz.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;ysz.cy;y++)

{

for(x=0;xsz.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;k8;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 (GradHori255)

{

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*gy0)

{

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;

}

图像的最边缘部分怎么进行平均过程 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;

}

opencv里面对cvCanny函数使用的时候对图像有要求吗？为什么我的这段代码运行不了，不报错。

cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, 0);

这句有问题，这个函数是创建一幅图片，最后一个参数代表通道数，但是你定义的图片的通道数是0，是不对的，一般是1或者3

cvCanny是对二值图进行检测的，所以img应该是一张二值图，image000保存检测结果，也要是二值图

关于canny的使用代码和canny算子代码的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。