图像处理之Canny边缘检测C++实现

最新推荐文章于 2023-05-27 22:24:59 发布
最新推荐文章于 2023-05-27 22:24:59 发布
阅读量1.1k 收藏 10
点赞数 1
分类专栏： 数字图像处理 文章标签： canny 边缘检测
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43294951/article/details/102752010
版权

canny检测的思路也比较简单
首先对整幅图像高斯平滑，然后求梯度的赋值以及相角
然后进行非极大抑制；然后阈值分割，为了防止阈值不合适出现的信息缺失，对强边缘进行八邻域搜索是否有弱边缘，然后对弱边缘也进行邻域搜索，然后对图像进行二值化
第一步
高斯平滑
对图像以行的形式平滑，然后进行转置，按同样的方向进行卷积，代码如下

void gauss(Mat& image)//高斯滤波器
{
	int nr = image.rows;
	int nl = image.cols;
	for (int i = 0; i < nr; i++)//对图像横向高斯滤波，模板为1/4[1,2,1]
	{
		float* p = image.ptr<float>(i);
		for (int j = 1; j < nl - 1; j++)
		{
			p[j] = (p[j - 1] + 2 * p[j] + p[j + 1]) / 4;
		}
	}
	image = image.t();//转置之后再进行一次滤波，达到二维滤波的效果
	for (int i = 0; i < nl; i++)
	{
		float* p = image.ptr<float>(i);
		for (int j = 1; j < nr - 1; j++)
		{
			p[j] = (p[j - 1] + 2 * p[j] + p[j + 1]) / 4;
		}
	}
	image = image.t();//再转置
}

计算梯度幅值比较简单，直接上代码

void countPQMY(const Mat& image, Mat& P, Mat& Q, Mat& M, Mat& Y)//这一部分计算横向梯度P(x,y) 纵向梯度Q(x,y) 角度Y（x,y） 幅值M（x,y）
{
	int nr = image.rows;
	int nl = image.cols;
	for (int i = 0; i < nr - 1; i++)
	{
		const float* up = image.ptr<float>(i);
		const float* down = image.ptr<float>(i + 1);
		float* p = P.ptr<float>(i);
		float* q = Q.ptr<float>(i);
		float* m = M.ptr<float>(i);
		float* y = Y.ptr<float>(i);
		for (int j = 0; j < nl - 1; j++)
		{
			p[j] = (-up[j] + up[j + 1] - down[j] + down[j + 1]) / 2;
			q[j] = -(-up[j] - up[j + 1] + down[j] + down[j + 1]) / 2;
			m[j] = sqrtf(p[j] * p[j] + q[j] * q[j]);
			y[j] = atan2(q[j], p[j]);
		}
	}
}

非极大抑制
这是canny的一大特色，为什么要算方向和幅值呢，在这里就要用到。
对于一个像素的八邻域而言，我们可以按圆的划分格式，将其平均分成八等分，那么像素点正右边就pi/8~-pi/8的范围内，以此类推。
然后对每一个点，看着沿梯度方向的两个点幅值是否比它大。
如果大的话，说明该点并不是强边缘，将该点幅值设0；否则保持
代码如下

void NMS(Mat& M, const Mat& Y)//M是幅值，Y是角度，此处进行非极大抑制
{
	int nr = M.rows;
	int nl = M.cols;
	for (int i = 1; i < nr - 1; i++)
	{
		float* mu = M.ptr<float>(i - 1);
		float* mm = M.ptr<float>(i);
		float* md = M.ptr<float>(i + 1);
		const float* y = Y.ptr<float>(i);
		for (int j = 1; j < nl - 1; j++)
		{
			if (y[j]<M_PI / 8 && y[j] >-M_PI / 8)
			{
				if (mm[j] <= mm[j + 1] && mm[j] <= mm[j - 1])
				{
					mm[j] = 0;
				}
			}
			else if (y[j] >= M_PI / 8 && y[j] < M_PI / 8 * 3)
			{
				if (mm[j] <= mu[j + 1] && mm[j] <= md[j - 1])
				{
					mm[j] = 0;
				}
			}
			else if (y[j] >= M_PI / 8 * 3 || y[j] <= -M_PI / 8 * 3)
			{
				if (mm[j] <= mu[j] && mm[j] <= md[j])
				{
					mm[j] = 0;
				}
			}
			else if (y[j]<-M_PI / 8 && y[j] >-M_PI / 8 * 3)
			{
				if (mm[j] <= mu[j - 1] && mm[j] <= md[j + 1])
				{
					mm[j] = 0;
				}
			}
		}
	}
}

然后阈值分割得到强边缘图，若边缘图

void proc(const Mat& M, Mat &M1, int div)//阈值分割，M原图像，M1是被处理之后的图像，div指的是阈值多少
{
	int nr = M.rows;
	int nl = M.cols;
	for (int i = 0; i < nr; i++)
	{
		const float* m = M.ptr<float>(i);
		float* m1 = M1.ptr<float>(i);
		for (int j = 0; j < nl; j++)
		{
			if (m[j] < div)
			{
				m1[j] = 0;
			}
			else
			{
				m1[j] = 255;
			}
		}
	}//二值化过程
}

当然为了防止越界，定义了一个bool函数用于检测是否越界

bool test(int i, int j, Mat& M)//要判断有没有越界，定义为bool
{
	if (i < 0 || j < 0 || i >= M.rows || j >= M.cols)
		return false;
	else
		return true;
}

八邻域查找
对于查找，可以先找到一个强边缘点，然后讲这个点入栈；
在这个点的八邻域搜索是否存在弱边缘；
如果有将该点入栈，并对该点打上标记；
对一个点的八邻域搜索完之后，从栈里面取出栈顶然后对这个点的八邻域进行搜索；
搜索到最后一定会将首次压栈的点的八邻域及其附属八邻域全部探索完。代码如下

void TwoE(const Mat& M1, const Mat& M2, Mat& MM)//M1指的是低阈值，M2指的是高阈值处理的图像，MM是最终要展示的图像
{
	//M1指的是低阈值得到的图像
	//M2指的是高阈值得到的图像
	//MM指的是用于是不是已经将M1探索过了
	//类型均为float CV_32FC型
	int nr = M1.rows;
	int nl = M1.cols;
	stack<int>p;
	for (int i = 1; i < nr - 1; i++)
	{
		const float* m2 = M2.ptr<float>(i);
		for (int j = 1; j < nl - 1; j++)
		{
			if (m2[j] == 255)
			{
				p.push(i);//遍历，寻找高阈值点，并将这个点压入栈
				//然后对这个点的八邻域寻找，看有没有符合低阈值图像上的点，有的话标记为1
				p.push(j);//有的话入栈，寻找完一次八邻域，取出栈顶元素，对他搜寻八邻域
				while (!p.empty())//以此往复进行，当栈空代表该点的所有可行八邻域的八邻域等等全部搜索过
				{
					int yy = p.top();
					p.pop();
					int xx = p.top();
					p.pop();
					for (int m = -1; m <= 1; m++)
					{
						if (xx + m >= 0 && xx + m < nr)
						{
							const float* m1 = M1.ptr<float>(xx + m);
							float* mm = MM.ptr<float>(xx + m);
							for (int n = -1; n <= 1; n++)
							{
								if (m == 0 && n == 0)
								{

								}
								else if (test(xx + m, yy + n, MM) && (mm[yy + n] == 0) && (m1[yy + n] == 255))
								{
									p.push(xx + m);
									p.push(yy + n);
									mm[yy + n] = 1;
								}
							}
						}
					}
				}
			}
		}
	}
	for (int i = 0; i < nr; i++)
	{
		const float* m2 = M2.ptr<float>(i);
		float* mm = MM.ptr<float>(i);
		for (int j = 0; j < nl; j++)
		{
			if ((mm[j] == 1) || (m2[j] == 255))
			{
				mm[j] = 255;
			}
		}
	}//二值化
}

测试结果如下
在这里插入图片描述
全部代码如下

#include <iostream>
#include <opencv2/opencv.hpp>
#include <Eigen/Dense>
#include <math.h>
#include <stack>
#define _MATH_DEFINES_DEFINED
using namespace std;
using namespace cv;
using namespace Eigen;
void gauss(Mat& image)//高斯滤波器
{
	int nr = image.rows;
	int nl = image.cols;
	for (int i = 0; i < nr; i++)//对图像横向高斯滤波，模板为1/4[1,2,1]
	{
		float* p = image.ptr<float>(i);
		for (int j = 1; j < nl - 1; j++)
		{
			p[j] = (p[j - 1] + 2 * p[j] + p[j + 1]) / 4;
		}
	}
	image = image.t();//转置之后再进行一次滤波，达到二维滤波的效果
	for (int i = 0; i < nl; i++)
	{
		float* p = image.ptr<float>(i);
		for (int j = 1; j < nr - 1; j++)
		{
			p[j] = (p[j - 1] + 2 * p[j] + p[j + 1]) / 4;
		}
	}
	image = image.t();//再转置
}
void countPQMY(const Mat& image, Mat& P, Mat& Q, Mat& M, Mat& Y)//这一部分计算横向梯度P(x,y) 纵向梯度Q(x,y) 角度Y（x,y） 幅值M（x,y）
{
	int nr = image.rows;
	int nl = image.cols;
	for (int i = 0; i < nr - 1; i++)
	{
		const float* up = image.ptr<float>(i);
		const float* down = image.ptr<float>(i + 1);
		float* p = P.ptr<float>(i);
		float* q = Q.ptr<float>(i);
		float* m = M.ptr<float>(i);
		float* y = Y.ptr<float>(i);
		for (int j = 0; j < nl - 1; j++)
		{
			p[j] = (-up[j] + up[j + 1] - down[j] + down[j + 1]) / 2;
			q[j] = -(-up[j] - up[j + 1] + down[j] + down[j + 1]) / 2;
			m[j] = sqrtf(p[j] * p[j] + q[j] * q[j]);
			y[j] = atan2(q[j], p[j]);
		}
	}
}
void NMS(Mat& M, const Mat& Y)//M是幅值，Y是角度，此处进行非极大抑制
{
	int nr = M.rows;
	int nl = M.cols;
	for (int i = 1; i < nr - 1; i++)
	{
		float* mu = M.ptr<float>(i - 1);
		float* mm = M.ptr<float>(i);
		float* md = M.ptr<float>(i + 1);
		const float* y = Y.ptr<float>(i);
		for (int j = 1; j < nl - 1; j++)
		{
			if (y[j]<M_PI / 8 && y[j] >-M_PI / 8)
			{
				if (mm[j] <= mm[j + 1] && mm[j] <= mm[j - 1])
				{
					mm[j] = 0;
				}
			}
			else if (y[j] >= M_PI / 8 && y[j] < M_PI / 8 * 3)
			{
				if (mm[j] <= mu[j + 1] && mm[j] <= md[j - 1])
				{
					mm[j] = 0;
				}
			}
			else if (y[j] >= M_PI / 8 * 3 || y[j] <= -M_PI / 8 * 3)
			{
				if (mm[j] <= mu[j] && mm[j] <= md[j])
				{
					mm[j] = 0;
				}
			}
			else if (y[j]<-M_PI / 8 && y[j] >-M_PI / 8 * 3)
			{
				if (mm[j] <= mu[j - 1] && mm[j] <= md[j + 1])
				{
					mm[j] = 0;
				}
			}
		}
	}
}
void proc(const Mat& M, Mat &M1, int div)//阈值分割，M原图像，M1是被处理之后的图像，div指的是阈值多少
{
	int nr = M.rows;
	int nl = M.cols;
	for (int i = 0; i < nr; i++)
	{
		const float* m = M.ptr<float>(i);
		float* m1 = M1.ptr<float>(i);
		for (int j = 0; j < nl; j++)
		{
			if (m[j] < div)
			{
				m1[j] = 0;
			}
			else
			{
				m1[j] = 255;
			}
		}
	}//二值化过程
}
bool test(int i, int j, Mat& M)//要判断有没有越界，定义为bool
{
	if (i < 0 || j < 0 || i >= M.rows || j >= M.cols)
		return false;
	else
		return true;
}
void TwoE(const Mat& M1, const Mat& M2, Mat& MM)//M1指的是低阈值，M2指的是高阈值处理的图像，MM是最终要展示的图像
{
	//M1指的是低阈值得到的图像
	//M2指的是高阈值得到的图像
	//MM指的是用于是不是已经将M1探索过了
	//类型均为float CV_32FC型
	int nr = M1.rows;
	int nl = M1.cols;
	stack<int>p;
	for (int i = 1; i < nr - 1; i++)
	{
		const float* m2 = M2.ptr<float>(i);
		for (int j = 1; j < nl - 1; j++)
		{
			if (m2[j] == 255)
			{
				p.push(i);//遍历，寻找高阈值点，并将这个点压入栈
				//然后对这个点的八邻域寻找，看有没有符合低阈值图像上的点，有的话标记为1
				p.push(j);//有的话入栈，寻找完一次八邻域，取出栈顶元素，对他搜寻八邻域
				while (!p.empty())//以此往复进行，当栈空代表该点的所有可行八邻域的八邻域等等全部搜索过
				{
					int yy = p.top();
					p.pop();
					int xx = p.top();
					p.pop();
					for (int m = -1; m <= 1; m++)
					{
						if (xx + m >= 0 && xx + m < nr)
						{
							const float* m1 = M1.ptr<float>(xx + m);
							float* mm = MM.ptr<float>(xx + m);
							for (int n = -1; n <= 1; n++)
							{
								if (m == 0 && n == 0)
								{

								}
								else if (test(xx + m, yy + n, MM) && (mm[yy + n] == 0) && (m1[yy + n] == 255))
								{
									p.push(xx + m);
									p.push(yy + n);
									mm[yy + n] = 1;
								}
							}
						}
					}
				}
			}
		}
	}
	for (int i = 0; i < nr; i++)
	{
		const float* m2 = M2.ptr<float>(i);
		float* mm = MM.ptr<float>(i);
		for (int j = 0; j < nl; j++)
		{
			if ((mm[j] == 1) || (m2[j] == 255))
			{
				mm[j] = 255;
			}
		}
	}//二值化
}
int main()
{
	//Mat image = cv::imread("I://A.jpg", IMREAD_GRAYSCALE);
	//cv::Mat_<uchar>im2 = image;
	Mat Image = imread("I://C.jpg", IMREAD_GRAYSCALE);
	Mat image;
	Image.convertTo(image, CV_32FC1);
	int flow = 15;
	Mat F = image.clone();
	gauss(F);
	//cout << image << endl;
	//cout << F << endl;
	Mat P = Mat::zeros(image.rows, image.cols, CV_32FC1);//构建零矩阵
	Mat Q = Mat::zeros(image.rows, image.cols, CV_32FC1);
	Mat M = Mat::zeros(image.rows, image.cols, CV_32FC1);
	Mat Y = Mat::zeros(image.rows, image.cols, CV_32FC1);
	Mat M1 = Mat::zeros(image.rows, image.cols, CV_32FC1);
	Mat M2 = Mat::zeros(image.rows, image.cols, CV_32FC1);
	Mat MM = Mat::zeros(image.rows, image.cols, CV_32FC1);
	countPQMY(image, P, Q, M, Y);
	NMS(M, Y);
	/*cout << image << endl;
	cout << P << endl;
	cout << Q << endl;
	cout << M << endl;
	cout << Y << endl;
	cout << Z << endl;*/
	proc(M, M1, flow);
	proc(M, M2, 2 * flow);
	TwoE(M1, M2, MM);
	//cout << M1 << endl;
	cv::imshow("原图", Image);
	cv::imshow("低阈值", M1);
	cv::imshow("高阈值", M2);
	cv::imshow("canny", MM);
	cv::waitKey(0);
}
鹏鹏诶
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
Canny边缘检测c++代码
08-18
Canny边缘检测c++代码！！！
Canny边缘检测及C++实现
热门推荐
牧野的博客
08-28 5万+
Canny边缘检测算法是澳大利亚科学家John F. Canny在1986年提出来的，不得不提一下的是当年John Canny本人才28岁！到今天已经30年过去了，Canny算法仍然是图像边缘检测算法中最经典有效的算法之一。 一起睹一下大家芳容： John Canny研究了最优边缘检测方法所需的特性，给出了评价边缘检测性能优劣的3个指标： 1  好的信噪比，即将非边缘点判定为
otsu算法_字形的识别算法及其在2D增强现实中的应用研究
weixin_39636645的博客
12-06 176
介绍字形(或最常被称为光学字形)的识别是一个很重要的交叉主题，在许多不同领域都有应用。光学字形最流行的应用是增强现实，其中计算机视觉算法在视频流中找到它们，并用人工生成的对象替代，从而创建一个视图，该视图在现实世界中是一半真实，一半是虚拟物体。光学字形应用的另一个领域是机器人技术，其中字形可用于向机器人发出命令，或帮助机器人在某些环境中导航，其中字形可用于指示机器人方向。这是光学字形应用...
图像处理（五）：八邻域边缘跟踪与区域生长算法
sinat_31425585的博客
11-17 5万+
通常在进行边缘检测之后，需要通过边缘跟踪来将离散的边缘串接起来，常使用的方法为：边缘跟踪和区域生长两种方法。边缘跟踪又分为八邻域和四邻域两种，具体原理可以参考残影、的博客。 实现步骤： 1、灰度化并进行Canny边缘检测 2、按照预先设定的跟踪方向（顺时针）进行边缘跟踪 3、每次跟踪的终止条件为：8邻域都不存在轮廓 这里需要理解的点： 代码中为什么更新当前方向时，需要curr_d -=...
(二)OpenCV特征提取与检测_09_LBP特征检测
weixin_45553439的博客
02-18 423
LBP(Local Binary Patterns)特征 局部二值模式(Local Binary Pattern)主要用来实现2D图像纹理分析。其基本思想是用每个像素跟它周围的像素相比较得到局部图像结构，假设中心像素值大于相邻像素值则则相邻像素点赋值为1，否则赋值为0，最终对每个像素点都会得到一个二进制八位的表示，比如11100111。假设3x3的窗口大小，这样对每个像素点来说组合得到的像素值的...
OpenCV之Canny边缘检测（C++实现）
xddwz的博客
12-23 1万+
canny算子简介 首先看一下最有边缘检测的三个主要评价标准： 低错误率：标出尽可能多的实际边缘，同时尽可能的减少噪声产生的误报。 高定位性：标识出的边缘要与图像中的实际边缘尽可能接近。 最小响应：图像中的边缘只能标识一次，并且可能存在的图像噪声不应标识为边缘。 为了满足这些要求，canny使用的变分法，这是一种寻找满足特定功能的函数的方法。最优检测用4个指数函数项的和表示，但是它非常近似于高斯函数的一阶导数。 canny边缘检测的步骤 第一步：消除噪声 一般情况下，使用高斯平滑滤波器降噪，以
区域生长算法的一种C++实现
weixin_30376509的博客
01-08 776
　　区域生长算法是一种图像分割方法，能够将图像中具有相同特征的连通区域分割出来，同时保证较好的边缘信息。 　　区域生长算法的优点是简单，容易实现；但空间和时间复杂度较高，对分割图像要求较高，否则容易形成孔洞和过分割。 　　区域生长算法的基本思想是首先获取分割区域的一个种子点，然后在种子点的周围搜索与该种子点有相似性质的像素点，合并到种子区域中。然后将合并的像素作为新的种子点继续搜索，直到种子区...
Canny边缘检测算法（C++实现）
HUSTER_Gy的博客
12-07 7030
步骤 用高斯滤波器平滑图像； 用一阶偏导有限差分计算梯度幅值和方向； 对梯度幅值应用非极大值抑制； 用双阈值算法检测和连接边缘。 一、openCV在C++中的应用 首先，在mac的Xcode上安装配置openCV库，参考一下链接（科学上网访问）https://medium.com/@jaskaranvirdi/setting-up-opencv-and-c-developme...
C++实现Canny边缘检测（原理+底层代码）
shinuone的博客
05-27 1279
检测步骤：1、使用高斯滤波器进行平滑处理；2、利用一阶偏导计算x与y方向的梯度幅值和方向；3、对梯度幅值进行NMS非极大值抑制；4、用双阈值算法检测和边缘连接。
基于C++的Canny边缘检测（数字图像处理）
毕业作品网站
05-09 1480
数字图像处理—Canny边缘检测 一、实验环境 操作系统：Ubuntu 18.04 LTS IDE：Qt Creator (with CMake) 第三方库：OpenCV 4.1.1 编译器：g++ 二、实验目的 通过课堂的学习，已经对图像分割的相关理论知识已经有了全面的了解，知道了许多图像分割的算法及算子，了解到不同的算子算法有着不同的优缺点，为了更好更直观地对图像分割进行深入理解，达到理论联系实际的目的，现实现Canny算子 三、实验原理 Canny算法采用先平滑后求导数的方法，先用高斯模板进行平
canny边缘检测算子，C++算法实现
08-29
canny边缘检测算子，运用C++来写的，后面还有许多其他的边缘检测算子更新
Canny边缘检测C++代码
08-15
OPENCV2代码，用于图片中的边缘检测
利用canny算子实现边缘检测（C++）
03-20
能较好的实现边缘的提取，而且实现了边缘图像和原始图像相加
C++实现图像处理Canny边缘检测设计
06-25
C++实现图像处理Canny边缘检测设计
基于QT（C++）实现数字图像处理-Canny边缘检测【100010172】
12-16
已经对图像分割的相关理论知识已经有了全面的了解，知道了许多图像分割的算法及算子，了解到不同的算子算法有着不同的优缺点，为了更好更直观地对图像分割进行深入理解，达到理论联系实际的目的，现实现Canny算子。
OpenCV实现canny边缘检测（C++实现）.zip
04-12
C++ OpenCV驱动程序，OpenCV beta工程环境。 项目代码可直接编译运行~
Canny边缘检测
03-05
根据论文J. Canny, "A Computational Approach to Edge Detection," in IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. PAMI-8, no. 6, pp. 679-698, Nov....实现Canny边缘检测
人工智能之口罩检测算法
鹏鹏的博客
02-27 1万+
由于疫情的影响，口罩检测已经成为各个程序员竞相开发的一种算法。 百度的人脸检测SDK使用的还不错，他们还把口罩检测也给开源了 我这里使用基于OPENCV的检测 一般的思路可能就是手机带有口罩和没有戴口罩的数据集进行训练，但是我暂时没有找到这些数据集，我就采用使用opencv原来带有的训练集先检测出人脸，然后再对人脸检测鼻子和嘴巴。但是由于opencv的检测鼻子和嘴巴的算法准确性不高，需要经过附加条...
欧拉运动放大算法实现心率检测
鹏鹏的博客
05-16 3800
由于疫情的影响，一系列的非接触设备的到应用，如无人消毒机器人、红外测温。除了体温，心率也是衡量人体状况的重要指标。心率可以通过颈动脉、桡动脉还有皮肤颜色来进行提取。2012年，Wu等人基于欧拉视频放大(EVM)技术设计了一个非接触式心率检测系统在相机和目标人物本身没有明显晃动的情况下，且光照条件良好时，该系统测得心率的结果，能够获得临床级别的准确度。之后又有学者提出了基于相位的微小运动放大算法。近年来传统的运动放大技术还是EVM和PVM，自动识别和视觉增强方面的发展和探索空间还比较大。本文运用欧拉运动放大技
Canny边缘检测c++
最新发布
07-28
Python中的Canny边缘检测算法是一种基于图像梯度的边缘检测算法，它可以在图像中检测出边缘，并将其转换为二值...Canny边缘检测算法在图像处理领域中得到了广泛的应用，可以用于图像分割、目标检测、图像识别等方面。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值