Canny边缘检测

原创 已于 2023-10-03 21:45:44 修改 · 86 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#图像处理 #opencv #算法

于 2023-10-03 21:44:23 首次发布
本文详细介绍了使用C++和OpenCV实现Canny边缘检测算法的过程，包括高斯滤波、计算梯度、非极大值抑制以及双阈值处理。作者还提供了代码示例和关键步骤的修改建议。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

参考（感谢大佬分享）： 

数字图像处理(c++ opencv)：图像分割-基本边缘检测--canny边缘检测 - 知乎 (zhihu.com)

这里面我觉得非极大值抑制那里的代码不太对，我在下面的代码中改了一下。

具体原理可以去某站学习。

我使用的是Code::Blocks+OpenCV，配置方法可见：

Code::Blocks+Opencv 环境搭建_zzz_zzzz_的博客-优快云博客

Project 的框架：

 Canny.h（自定义头文件）

#include<opencv2/opencv.hpp>

using namespace std;
using namespace cv;

//声明

//1 高斯滤波函数
void Gaussfilter_ly(Mat input, Mat &output, int Gauss_size, double Sigma);

//2 计算梯度幅值图像和方向图像
void Grad_dire_ly(Mat input, Mat& Gradimage, Mat& Direimage);

//3 非极大值抑制图像
void Nonmax_suppression_ly(Mat Gradimage, Mat Direimage, Mat& Suppimage);

//4 滞后阈值处理（双阈值）
void doubleThread_ly(Mat Suppimage, Mat& Edgeimage, int th_high, int th_low);

//5 canny函数
void canny_ly(Mat input_image, Mat& output_image, int th_high, int th_low, int Gauss_size, double sigmma);

Canny.cpp

#include "Canny.h"

//1 进行高斯滤波
/*
传入参数说明：
Mat input_image:原始图像
Mat& output_image:(引用，不需要参数传递，可以被带回）高斯模糊处理后的图像
int Gauss_size：高斯核的大小，高斯核越大，图像越模糊
double sigma:计算高斯核中数值的参数，sigma越大，图像越模糊
*/
void Gaussfilter_ly(Mat input_image, Mat& output_image, int Gauss_size, double Sigma)
{
	//保证高斯核大小为大于等于3的奇数
	if (Gauss_size < 3) Gauss_size = 3;
	else Gauss_size = (int)(Gauss_size / 2) * 2 + 1;

	//创建高斯核空间
	double** Gausskernel = new double* [Gauss_size];
	for (int i = 0; i < Gauss_size; i++)
	{
		Gausskernel[i] = new double[Gauss_size];
	}

	//高斯核模板中心到模板边缘的“距离”
	int center = Gauss_size / 2;

	double sum = 0;
	for (int i = 0; i < Gauss_size; i++)
	{
		for (int j = 0; j < Gauss_size; j++)
		{
		    //通过公式计算模板高斯核的数值
			Gausskernel[i][j] = exp(-((i - center) * (i - center) + (j - center) * (j - center)) / (2 * Sigma * Sigma));
			sum += Gausskernel[i][j];//为了后续方便归一化
		}
	}

	//高斯卷积核归一化
	double sum1 = 1 / sum;
	for (int i = 0; i < Gauss_size; i++)
	{
		for (int j = 0; j < Gauss_size; j++)
		{
			Gausskernel[i][j] *= sum1;
		}
	}

	//高斯模糊
	Mat tem_image = input_image.clone();
	int rows = input_image.rows - center;
	int cols = input_image.cols - center;
	for (int i = center; i < rows; i++)
	{
		for (int j = center; j < cols; j++)
		{
			double sum = 0;
			for (int m = -center; m <= center; m++)
			{
				for (int n = -center; n <= center; n++)
				{
				    //体现当前值sum是其周围值的加权平均
					sum += Gausskernel[center + m][center + n] * input_image.at<uchar>(i + m, j + n);
				}
			}
			tem_image.at<uchar>(i, j) = static_cast<uchar>(sum);//强制类型转换
		}
	}

	output_image = tem_image;

	//释放内存
	for (int i =0; i < Gauss_size; i++) delete[] Gausskernel[i];
	delete[] Gausskernel;
}


//2 计算梯度幅值图像,方向图像和边缘图像
/*
传入参数说明：
Mat input:高斯模糊处理后的图像
Mat& Gradimage:(引用，不需要参数传递，可以被带回）存贮图像像素的梯度赋值
Mat& Direimage:(引用，不需要参数传递，可以被带回）存贮图像像素的梯度方向
*/
void Grad_dire_ly(Mat input, Mat& Gradimage, Mat& Direimage)
{
	Mat tempGrad = Mat(input.size(), CV_16U, Scalar(0));//Scalar(0)表示黑色
	Mat tempDire = Mat(input.size(), CV_8U, Scalar(0));//Scalar(0)表示黑色

	int width = input.cols;
	int height = input.rows;

	for (int i = 1; i < height - 1; i++)
	{
		for (int j = 1; j < width - 1; j++)
		{
			//计算梯度及梯度幅值
			//Preeitt梯度算子 (Sobel算子也可以）
			int gx = input.at<uchar>(i + 1, j - 1) + input.at<uchar>(i + 1, j) + input.at<uchar>(i + 1, j + 1)
				- input.at<uchar>(i - 1, j - 1) - input.at<uchar>(i - 1, j) - input.at<uchar>(i - 1, j + 1);
			int gy = input.at<uchar>(i - 1, j + 1) + input.at<uchar>(i, j + 1) + input.at<uchar>(i + 1, j + 1)
				- input.at<uchar>(i - 1, j - 1) - input.at<uchar>(i, j - 1) - input.at<uchar>(i + 1, j - 1);
			int sum = gx + gy;//可以是 int sum =sqrt(gx^2+gy^2) //需要import math

			//梯度幅值图像
			tempGrad.at<ushort>(i, j) = abs(sum);

			//梯度方向图像
			//atan2(gy, gx)的取值为-PI-PI
			//dire的取值为-180-180
			double dire = atan2(gy, gx) * 180 / 3.1415926; //转化为度数

			if((dire >= -22.5 && dire < 22.5) || (dire >= 157.5 || dire < -157.5) )
                tempDire.at<uchar>(i, j) = 1; //1：水平
			else if((dire >= 22.5 && dire < 67.5) || (dire >= -157.5 && dire < -122.5))
			    tempDire.at<uchar>(i, j) = 2; //2：45
			else if((dire >= 67.5 && dire < 122.5) || (dire >= -122.5 && dire < -67.5))
			    tempDire.at<uchar>(i, j) = 3; //3：垂直
			else
			    tempDire.at<uchar>(i, j) = 4; //4：-45
		}
	}
	Gradimage = tempGrad;
	Direimage = tempDire;
}

//3 非极大值抑制图像
/*
传入参数说明：
Mat Gradimage:存贮梯度赋值的图像
Mat Direimage:存贮梯度方向的图像
Mat& Suppimage:(引用，不需要参数传递，可以被带回）非极大值抑制后的图像
*/
void Nonmax_suppression_ly(Mat Gradimage, Mat Direimage, Mat& Suppimage)
{
	Mat tempSupp = Mat(Gradimage.size(), Gradimage.type(), Scalar(0));

	int width = Gradimage.cols;
	int height = Gradimage.rows;

	for (int i = 1; i < height - 1; i++)
	{
		for (int j = 1; j < width - 1; j++)
		{
			switch (Direimage.at<uchar>(i, j))//当前循环到的像素的梯度方向
			{
				case 1 ://水平
					if (Gradimage.at<ushort>(i, j) >= Gradimage.at<ushort>(i - 1, j) && Gradimage.at<ushort>(i, j) >= Gradimage.at<ushort>(i + 1, j))
						tempSupp.at<ushort>(i, j) = Gradimage.at<ushort>(i, j);
					else
						tempSupp.at<ushort>(i, j) = 0;
					break;
				case 2://45度
					if (Gradimage.at<ushort>(i, j) >= Gradimage.at<ushort>(i + 1, j + 1) && Gradimage.at<ushort>(i, j) >= Gradimage.at<ushort>(i - 1, j - 1))
						tempSupp.at<ushort>(i, j) = Gradimage.at<ushort>(i, j);
					else
						tempSupp.at<ushort>(i, j) = 0;
					break;
				case 3://垂直
					if (Gradimage.at<ushort>(i, j) >= Gradimage.at<ushort>(i , j - 1) && Gradimage.at<ushort>(i, j) >= Gradimage.at<ushort>(i , j - 1))
						tempSupp.at<ushort>(i, j) = Gradimage.at<ushort>(i, j);
					else
						tempSupp.at<ushort>(i, j) = 0;
					break;
				case 4://-45度
				    if (Gradimage.at<ushort>(i, j) >= Gradimage.at<ushort>(i + 1, j - 1) && Gradimage.at<ushort>(i, j) >= Gradimage.at<ushort>(i - 1, j + 1))
						tempSupp.at<ushort>(i, j) = Gradimage.at<ushort>(i, j);
					else
						tempSupp.at<ushort>(i, j) = 0;
					break;
				default:

					break;
			}
		}
	}
	Suppimage = tempSupp;
}

//4 滞后阈值处理（双阈值）
/*
传入参数说明：
Mat Suppimage:存贮梯度赋值的图像
Mat& Edgeimage:(引用，不需要参数传递，可以被带回）边缘位置为255（白色）
int th_high:高阈值
int th_low:低阈值
*/
void doubleThread_ly(Mat Suppimage, Mat& Edgeimage, int th_high, int th_low)
{
    //保证高阈值大于低阈值
	int temp;
	if (th_high < th_low)
	{
		temp = th_high;
		th_high = th_low;
		th_low = temp;
	}

	Mat bw_h = Mat(Suppimage.size(), CV_8UC1, Scalar(0));
	Mat bw_l = Mat(Suppimage.size(), CV_8UC1, Scalar(0));

	int width = Suppimage.cols;
	int height = Suppimage.rows;

	for (int i = 0; i < height; i++)
	{
		for (int j = 0; j < width; j++)
		{
		    //bw_h中将梯度幅值大于等于高阈值的像素点（一定是边缘点）设为255
			if (Suppimage.at<ushort>(i, j) >= th_high)
				bw_h.at<uchar>(i, j) = 255;
			else
				bw_h.at<uchar>(i, j) = 0;

            //bw_l中将梯度幅值大于等于低阈值且小于高阈值的像素点（可能是边缘点）设为255
			if (Suppimage.at<ushort>(i, j) >= th_low && Suppimage.at<ushort>(i, j) < th_high)
				bw_l.at<uchar>(i, j) = 255;
			else
				bw_l.at<uchar>(i, j) = 0;
				}
	}

	Mat bw = bw_h.clone();//bw中将要存贮的是边缘点
	for (int i = 1; i < height - 1; i++)
	{
		for (int j = 1; j < width - 1; j++)
		{
			if (bw_h.at<uchar>(i, j) == 255)
			{
			    //对于一定是边缘的像素点，看它的八邻域内有没有可能是边缘的点
			    //如果有，将其加入到边缘点中
				if (bw_l.at<uchar>(i - 1, j - 1) == 255)
					bw.at<uchar>(i - 1, j - 1) = 255;
				if (bw_l.at<uchar>(i - 1, j) == 255)
					bw.at<uchar>(i - 1, j) = 255;
				if (bw_l.at<uchar>(i - 1, j+ 1) == 255)
					bw.at<uchar>(i - 1, j + 1) = 255;
				if (bw_l.at<uchar>(i, j - 1) == 255)
					bw.at<uchar>(i, j - 1) = 255;
				if (bw_l.at<uchar>(i, j + 1) == 255)
					bw.at<uchar>(i, j + 1) = 255;
				if (bw_l.at<uchar>(i + 1, j - 1) == 255)
                    bw.at<uchar>(i + 1, j - 1) = 255;
				if (bw_l.at<uchar>(i + 1, j) == 255)
					bw.at<uchar>(i + 1, j) = 255;
				if (bw_l.at<uchar>(i + 1, j + 1) == 255)
					bw.at<uchar>(i + 1, j + 1) = 255;
			}
		}
	}

	Edgeimage = bw;
}

//5 canny函数
/*
传入参数说明：
Mat input_image:原始图像
Mat& output_image:(引用，不需要参数传递，可以被带回）处理后的图像
int th_high:高阈值
int th_low:低阈值
int Gauss_size：高斯核的大小，高斯核越大，图像越模糊
double sigma:计算高斯核中数值的参数，sigma越大，图像越模糊
*/
void canny_ly(Mat input_image, Mat& output_image, int th_high, int th_low, int Gauss_size, double sigmma)
{
	Mat Gaussimage, Gradimage, Direimage, Suppimage, Edgeimage;//过程中生成的图像

	//1 高斯滤波函数
	Gaussfilter_ly(input_image, Gaussimage, Gauss_size, sigmma);

	//2 计算梯度幅值图像和方向图像
	Grad_dire_ly(Gaussimage, Gradimage, Direimage);

	//3 非极大值抑制图像
	Nonmax_suppression_ly(Gradimage, Direimage, Suppimage);

	//4 滞后阈值处理（双阈值）
	doubleThread_ly(Suppimage, Edgeimage, th_high, th_low);

	output_image = Edgeimage;
}

 main.cpp

#include "Canny.h"

using namespace std;
using namespace cv;

int main()
{
	Mat img1 = imread("D:/1.png", 0);//0表示以灰度方式读入

	if (img1.empty())//参数检查
	{
		cout << "wrong" << endl;
		return -1;
	}
	imshow("img1", img1);

	Mat img2;
	canny_ly(img1, img2, 60, 20, 3, 1);//Canny边缘检测，参数（原图像，边缘图像，高阈值，低阈值，高斯核，sigma）
	imshow("img2", img2);
	waitKey();

	return 0;
}

最后，结果如下：

也可以直接用opencv的Canny函数，一句代码就可以实现。真的是傻瓜使用方式。

canny边缘检测
万物琴弦存于你的泡沫之中，光锥之外
02-06 1177
Canny边缘检测算法通过一系列步骤（高斯滤波、梯度计算、非极大值抑制和双阈值检测）实现鲁棒的边缘检测。它被认为是边缘检测的“黄金标准”，因为它在检测边缘的同时能够很好地抑制噪声，并且能够精确地定位边缘。参数选择：Canny算法需要选择高阈值和低阈值，这些参数的选择对最终的边缘检测结果有很大影响。边缘连接：最后，通过检查弱边缘像素的邻域，如果弱边缘像素与强边缘像素相连，则将其保留为边缘的一部分。最小响应：Canny算法通过非极大值抑制和双阈值检测，确保每个边缘只被检测一次，从而减少了边缘的重复检测。
Canny边缘检测算法
爱学习的小刘芒的博客
06-21 1万+
Canny边缘检测算法---matlab , lingo , python中应用
Canny 边缘检测算法原理详解
qq_36812406的博客
05-13 1882
噪声抑制（高斯平滑）计算梯度（使用 Sobel 或类似算子）非极大值抑制（NMS）双阈值检测边缘连接（滞后阈值）优点描述边缘细化保留边缘响应的精确位置，宽边变细边去除虚假边缘剔除非局部最大响应的像素，减少伪边缘为边缘连接打基础只有局部最强点才能触发连接传播。
【OpenCV】Canny边缘检测
m0_73881415的博客
04-28 836
Canny 边缘检测算法是一种非常流行的边缘检测算法，是 John F. Canny 于 1986年提出的，被认为是最优的边缘检测算法。操作步骤按照如下进行：读取图像二值化图像。高斯滤波。计算图像的梯度和方向。非极大值抑制。双阈值筛选。
opencv之Canny边缘检测
hola173841439的博客
09-11 1639
Canny边缘检测是一种流行的边缘检测算法，用于检测图像中的边缘。灰度化：将图像转换为灰度图，减少计算复杂度。高斯滤波：使用高斯滤波器对图像进行平滑处理，以减少噪声对边缘检测的影响。计算梯度：通过计算图像的梯度（通常使用Sobel算子）来检测边缘的方向和强度。非极大值抑制：对梯度幅值进行非极大值抑制，以保留边缘并减少非边缘的杂点。双阈值处理：通过设置高阈值和低阈值，将强边缘和弱边缘分离出来。边缘连接：根据强边缘将弱边缘连接起来，形成最终的边缘检测结果。
Canny 边缘检测算法
sunny_code_的博客
02-09 974
非极大抑制后，图像中仍然可能存在噪声点。Canny 算法采用。使用高斯滤波对图像进行平滑处理，以减少噪声干扰。该阶段用于确定哪些边缘是真正的边缘，哪些是噪声。用于寻找灰度值变化最强的位置，即边缘。用于去除非边缘像素，使边缘更加清晰。，确保边缘的连续性。
Canny 边缘检测
Scabbards_的博客
01-27 1341
canny边缘检测一点小笔记
OpenCV---Canny边缘检测
MzKyle的博客
05-29 1401
Canny边缘检测算法摘要 Canny边缘检测是计算机视觉中的经典算法，通过高斯去噪、梯度计算、非极大值抑制、双阈值筛选和边缘连接5个步骤，提取单像素宽的高质量边缘。其优势在于抗噪性强、边缘连续性好，适用于目标检测、轮廓分析等场景。OpenCV中通过cv2.Canny()实现，关键参数包括高低阈值（推荐比例2:1）、Sobel核大小等。实际应用（如Robomaster灯条检测）需结合预处理（如CLAHE增强）和轮廓分析。
Canny边缘检测算法(python 实现）
热门推荐
MasterMiao的博客
08-14 8万+
文章目录最优边缘准则算法实现步骤1. 应用高斯滤波来平滑(模糊)图像，目的是去除噪声2. 计算梯度强度和方向3. 应用非最大抑制技术NMS来消除边误检4. 应用双阈值的方法来决定可能的（潜在的）边界5. 利用滞后技术来跟踪边界opencv实现Canny边缘检测手写代码参考文章 最优边缘准则     Canny 的目标是找到一个最优的边缘检测算法，最优边缘检测的含义是：     (1)最优检测：算法能够尽可能多地标识出图像中的实际边缘，漏检真实边缘的概率和误检非边缘的概率都尽可能小；     (2)最优定
Canny 边缘检测器：使用 Canny 边缘检测查找边缘-matlab开发
06-01
**Canny边缘检测器：MATLAB实现详解** Canny边缘检测是计算机视觉领域中一种经典的边缘检测算法，由John F. Canny于1986年提出。它旨在找到图像中的显著边缘，同时减少误检和漏检。Canny算法通过多步处理，包括高斯...
canny_边缘检测_目标检测_canny_canny边缘检测python_
10-01
Canny边缘检测是一种广泛应用于图像处理领域的算法，用于在数字图像中自动检测物体的边缘。这一算法由John F. Canny于1986年提出，它的主要目标是找到图像中的强边缘，同时减少误检和漏检。Canny边缘检测算法包含...
canny边缘检测算法-matlab
11-03
Canny边缘检测算法是数字图像处理领域中一种经典的边缘检测方法，由John F. Canny在1986年提出。这个算法以其高效性和准确性而著名，被广泛应用于各种图像处理任务中。在MATLAB中，我们可以利用内置函数或者自定义...
OpenCv实现Canny边缘检测
05-04
总的来说，Canny边缘检测算法以其出色的性能在图像处理领域中占据重要地位，不仅在边缘检测的精度上表现出色，而且对噪声有良好的抑制能力。在OpenCV库的支持下，开发者可以方便地将其应用到各种图像处理和计算机...
集成电路学习：什么是Image Processing图像处理
最新发布
limengshi138392的博客
08-13 385
本文系统介绍了图像处理技术。作为计算机视觉和人工智能的基础技术，图像处理通过计算机对图像进行分析加工，按处理方式可分为模拟和数字处理，按目的可分为增强、恢复、分割等类型。文章梳理了该技术从20世纪至今的发展历程，详细阐述了像素、灰度值等基本概念，以及图像采集、增强、压缩等核心技术。在医学影像、遥感测绘、工业检测等领域的广泛应用基础上，未来结合深度学习等新技术，图像处理将在诊断精度、实时分析等方面实现更大突破，展现出广阔的发展前景。
基于 FFmpeg 与 V4L2 的多路摄像头视频采集，图像处理处理与 RTMP 推流项目（开源）
2301_76564925的博客
08-05 1054
本文介绍了一个基于Linux平台的实时视频推流解决方案，采用V4L2采集摄像头数据，结合OpenCV进行图像处理，通过FFmpeg编码并推流至RTMP服务器。系统采用模块化设计，包含采集、处理、编码推流三大核心模块，通过线程安全队列实现异步解耦。项目支持多路视频流处理，可扩展自定义算法（如目标检测），具有低延迟、高吞吐量的特点。技术栈选择了V4L2（高效硬件访问）、FFmpeg（一站式音视频处理）和OpenCV（图像处理），并提供了开发环境配置和核心代码实现细节。该方案适用于直播、监控等场景，已在GitHu
OpenCV入门：图像处理基础教程
weixin_73958875的博客
08-07 1949
OpenCV是一个开源的计算机视觉库，提供2500多种优化算法，支持图像处理、视频分析、物体检测等任务。摘要介绍了OpenCV的基础功能：1）读取和显示图片；2）灰度图转换与保存；3）图像区域裁剪；4）视频读取与处理；5）RGB通道分离与合并；6）图像打码处理；7）图像组合；8）图像缩放。这些功能展示了OpenCV如何通过像素级操作实现基础图像处理，为更复杂的计算机视觉应用奠定基础。
【图像处理】小波变换（Wavelet Transform，WT）
shinuone的博客
08-13 555
小波变换是一种重要的图像多尺度分析工具，能够有效分离图像的时频信息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值