Canny算子边缘检测原理以及实现

最新推荐文章于 2023-08-24 00:05:19 发布
最新推荐文章于 2023-08-24 00:05:19 发布
阅读量1.3k 收藏 14
点赞数
分类专栏： Opencv C++ 文章标签： cv 边缘检测 opencv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43587345/article/details/106606788
版权
C++ 同时被 2 个专栏收录
38 篇文章 5 订阅
订阅专栏
Opencv
10 篇文章 0 订阅
订阅专栏

Canny算子边缘检测原理以及实现

原理解析

基于卷积运算的边缘检测算法，比如Sobel、Prewitt等，有以下几个缺点：

  • 没有充分利用边缘的梯度方向。
  • 最后输出的边缘二值图，只是简单的利用阈值进行处理，显然如果阈值过大，则会损失很多边缘信息；如果阈值过小，则会出现很多的噪声。

而Canny边缘检测基于这两点进行的改进，提出：

  • 基于梯度方向的非极大值抑制。
  • 双阈值的滞后阈值处理。

步骤

  1. 利用高斯滤波来平滑图像，目的是去噪声。
  2. 寻找图像的强度梯度，和方向。
  3. 利用非极大值抑制来消除边误检。（其实是对边缘强度图进行细化）
  4. 双阈值的滞后阈值处理。

1、高斯平滑（略）

2、计算梯度幅度和方向

这个步骤可采用的算子有：Roberts、Prewitt、Sobel、Scharr等。
一般采用soble算子，OpenCV也是如此，利用soble水平和垂直算子与输入图像卷积计算dx、dy。也可用Prewitt和Scharr，不建议用Roberts，因为Roberts算子边缘检测使用了很少的邻域像素来近似边缘强度，因为对图像的噪声具有高度敏感性。
下面采用soble算子为例：
soble算子具有分离性。图像f(x,y)分别于卷积核Sobel.x和卷积核Sobel.y卷积得到水平方向的强度梯度dx和垂直方向的强度梯度dy。
在这里插入图片描述
边缘强度为：
在这里插入图片描述
为了简化计算，幅值也可以作如下近似：
在这里插入图片描述
梯度方向为：
在这里插入图片描述

3、利用非极大值抑制来消除边误检。

在这里插入图片描述
如图a，在点(1,1)处放置坐标轴。图b，知道梯度方向后的邻域，将(1,1)点的边缘强度912与左下方的270以及右上方的292做比较，912>270&&912>292,所以这个点可以极大值，如果不全大于这两个值，则就需要抑制了，令这个点(1,1)=0。其他的点方法类似。
至于方向如何判断呢？梯度方向一般离散化为一下四种情况：
在这里插入图片描述
非极大值抑制的第二种方式：插值法
插值法能够更加的衡量梯度方向上的边缘强度。
在这里插入图片描述
在这里插入图片描述

4. 双阈值的滞后阈值处理

  • 选取系数TH和TL，比率为2:1或3:1
  • 将小于低阈值的点抛弃，赋0；将大于高阈值的点立即标记（这些点为确定边缘点）
  • 将小于高阈值，大于低阈值的点使用8连通区域确定

代码：

#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
cv::Mat non_maximum_suppression_Inter(cv::Mat dx, cv::Mat dy);
sobel算子/
//阶乘
int factorial(int n) {
	int fac = 1;
	//0的阶乘
	if (n == 0)
		return fac;
	for (int i = 1; i <= n; ++i) {
		fac *= i;
	}
	return fac;
}

//获得Sobel平滑算子
cv::Mat getSobelSmoooth(int wsize) {
	int n = wsize - 1;
	cv::Mat SobelSmooothoper = cv::Mat::zeros(cv::Size(wsize, 1), CV_32FC1);
	for (int k = 0; k <= n; k++) {
		float *pt = SobelSmooothoper.ptr<float>(0);
		pt[k] = factorial(n) / (factorial(k)*factorial(n - k));
	}
	return SobelSmooothoper;
}

//获得Sobel差分算子
cv::Mat getSobeldiff(int wsize) {
	cv::Mat Sobeldiffoper = cv::Mat::zeros(cv::Size(wsize, 1), CV_32FC1);
	cv::Mat SobelSmoooth = getSobelSmoooth(wsize - 1);
	for (int k = 0; k < wsize; k++) {
		if (k == 0)
			Sobeldiffoper.at<float>(0, k) = 1;
		else if (k == wsize - 1)
			Sobeldiffoper.at<float>(0, k) = -1;
		else
			Sobeldiffoper.at<float>(0, k) = SobelSmoooth.at<float>(0, k) - SobelSmoooth.at<float>(0, k - 1);
	}
	return Sobeldiffoper;
}

//卷积实现
void conv2D(cv::Mat& src, cv::Mat& dst, cv::Mat kernel, int ddepth, cv::Point anchor = cv::Point(-1, -1), int delta = 0, int borderType = cv::BORDER_DEFAULT) {
	cv::Mat  kernelFlip;
	cv::flip(kernel, kernelFlip, -1);
	cv::filter2D(src, dst, ddepth, kernelFlip, anchor, delta, borderType);
}


//可分离卷积———先垂直方向卷积，后水平方向卷积
void sepConv2D_Y_X(cv::Mat& src, cv::Mat& dst, cv::Mat kernel_Y, cv::Mat kernel_X, int ddepth, cv::Point anchor = cv::Point(-1, -1), int delta = 0, int borderType = cv::BORDER_DEFAULT) {
	cv::Mat dst_kernel_Y;
	conv2D(src, dst_kernel_Y, kernel_Y, ddepth, anchor, delta, borderType); //垂直方向卷积
	conv2D(dst_kernel_Y, dst, kernel_X, ddepth, anchor, delta, borderType); //水平方向卷积
}

//可分离卷积———先水平方向卷积，后垂直方向卷积
void sepConv2D_X_Y(cv::Mat& src, cv::Mat& dst, cv::Mat kernel_X, cv::Mat kernel_Y, int ddepth, cv::Point anchor = cv::Point(-1, -1), int delta = 0, int borderType = cv::BORDER_DEFAULT) {
	cv::Mat dst_kernel_X;
	conv2D(src, dst_kernel_X, kernel_X, ddepth, anchor, delta, borderType); //水平方向卷积
	conv2D(dst_kernel_X, dst, kernel_Y, ddepth, anchor, delta, borderType); //垂直方向卷积
}


//Sobel算子边缘检测
//dst_X 垂直方向
//dst_Y 水平方向
void Sobel(cv::Mat& src, cv::Mat& dst_X, cv::Mat& dst_Y, cv::Mat& dst, int wsize, int ddepth, cv::Point anchor = cv::Point(-1, -1), int delta = 0, int borderType = cv::BORDER_DEFAULT) {

	cv::Mat SobelSmooothoper = getSobelSmoooth(wsize); //平滑系数
	cv::Mat Sobeldiffoper = getSobeldiff(wsize); //差分系数

	//可分离卷积———先垂直方向平滑，后水平方向差分——得到垂直边缘
	sepConv2D_Y_X(src, dst_X, SobelSmooothoper.t(), Sobeldiffoper, ddepth);

	//可分离卷积———先水平方向平滑，后垂直方向差分——得到水平边缘
	sepConv2D_X_Y(src, dst_Y, SobelSmooothoper, Sobeldiffoper.t(), ddepth);

	//边缘强度（近似）
	dst = abs(dst_X) + abs(dst_Y);
	cv::convertScaleAbs(dst, dst); //求绝对值并转为无符号8位图
}


//确定一个点的坐标是否在图像内
bool checkInRang(int r, int c, int rows, int cols) {
	if (r >= 0 && r < rows && c >= 0 && c < cols)
		return true;
	else
		return false;
}

//从确定边缘点出发，延长边缘
void trace(cv::Mat &edgeMag_noMaxsup, cv::Mat &edge, float TL, int r, int c, int rows, int cols) {
	if (edge.at<uchar>(r, c) == 0) {
		edge.at<uchar>(r, c) = 255;
		for (int i = -1; i <= 1; ++i) {
			for (int j = -1; j <= 1; ++j) {
				float mag = edgeMag_noMaxsup.at<float>(r + i, c + j);
				if (checkInRang(r + i, c + j, rows, cols) && mag >= TL)
					trace(edgeMag_noMaxsup, edge, TL, r + i, c + j, rows, cols);
			}
		}
	}
}

//Canny边缘检测
void Edge_Canny(cv::Mat &src, cv::Mat &edge, float TL, float TH, int wsize = 3, bool L2graydient = false) {
	int rows = src.rows;
	int cols = src.cols;

	//高斯滤波
	cv::GaussianBlur(src, src, cv::Size(5, 5), 0.8);
	//sobel算子
	cv::Mat dx, dy, sobel_dst;
	Sobel(src, dx, dy, sobel_dst, wsize, CV_32FC1);

	//计算梯度幅值
	cv::Mat edgeMag;
	if (L2graydient)
		cv::magnitude(dx, dy, edgeMag); //开平方
	else
		edgeMag = abs(dx) + abs(dy); //绝对值之和近似

	//计算梯度方向 以及 非极大值抑制
	cv::Mat edgeMag_noMaxsup = cv::Mat::zeros(rows, cols, CV_32FC1);
	for (int r = 1; r < rows - 1; ++r) {
		for (int c = 1; c < cols - 1; ++c) {
			float x = dx.at<float>(r, c);
			float y = dy.at<float>(r, c);
			float angle = std::atan2f(y, x) / CV_PI * 180; //当前位置梯度方向
			float mag = edgeMag.at<float>(r, c);  //当前位置梯度幅值

			//非极大值抑制
			//垂直边缘--梯度方向为水平方向-3*3邻域内左右方向比较
			if (abs(angle) < 22.5 || abs(angle) > 157.5) {
				float left = edgeMag.at<float>(r, c - 1);
				float right = edgeMag.at<float>(r, c + 1);
				if (mag >= left && mag >= right)
					edgeMag_noMaxsup.at<float>(r, c) = mag;
			}

			//水平边缘--梯度方向为垂直方向-3*3邻域内上下方向比较
			if ((angle >= 67.5 && angle <= 112.5) || (angle >= -112.5 && angle <= -67.5)) {
				float top = edgeMag.at<float>(r - 1, c);
				float down = edgeMag.at<float>(r + 1, c);
				if (mag >= top && mag >= down)
					edgeMag_noMaxsup.at<float>(r, c) = mag;
			}

			//+45°边缘--梯度方向为其正交方向-3*3邻域内右上左下方向比较
			if ((angle > 112.5 && angle <= 157.5) || (angle > -67.5 && angle <= -22.5)) {
				float right_top = edgeMag.at<float>(r - 1, c + 1);
				float left_down = edgeMag.at<float>(r + 1, c - 1);
				if (mag >= right_top && mag >= left_down)
					edgeMag_noMaxsup.at<float>(r, c) = mag;
			}


			//+135°边缘--梯度方向为其正交方向-3*3邻域内右下左上方向比较
			if ((angle >= 22.5 && angle < 67.5) || (angle >= -157.5 && angle < -112.5)) {
				float left_top = edgeMag.at<float>(r - 1, c - 1);
				float right_down = edgeMag.at<float>(r + 1, c + 1);
				if (mag >= left_top && mag >= right_down)
					edgeMag_noMaxsup.at<float>(r, c) = mag;
			}
		}
	}

	//双阈值处理及边缘连接
	edge = cv::Mat::zeros(rows, cols, CV_8UC1);
	for (int r = 1; r < rows - 1; ++r) {
		for (int c = 1; c < cols - 1; ++c) {
			float mag = edgeMag_noMaxsup.at<float>(r, c);
			//大于高阈值，为确定边缘点
			if (mag >= TH)
				trace(edgeMag_noMaxsup, edge, TL, r, c, rows, cols);
			else if (mag < TL)
				edge.at<uchar>(r, c) = 0;
		}
	}
}
void Edge_Canny_in(cv::Mat &src, cv::Mat &edge, float TL, float TH, int wsize = 3, bool L2graydient = false) {
	int rows = src.rows;
	int cols = src.cols;

	//高斯滤波
	cv::GaussianBlur(src, src, cv::Size(5, 5), 0.8);
	//sobel算子
	cv::Mat dx, dy, sobel_dst;
	Sobel(src, dx, dy, sobel_dst, wsize, CV_32FC1);

	//计算梯度幅值
	cv::Mat edgeMag;
	if (L2graydient)
		cv::magnitude(dx, dy, edgeMag); //开平方
	else
		edgeMag = abs(dx) + abs(dy); //绝对值之和近似

	cv::Mat edgeMag_noMaxsup = non_maximum_suppression_Inter(dx, dy);

	//双阈值处理及边缘连接
	edge = cv::Mat::zeros(rows, cols, CV_8UC1);
	for (int r = 1; r < rows - 1; ++r) {
		for (int c = 1; c < cols - 1; ++c) {
			float mag = edgeMag_noMaxsup.at<float>(r, c);
			//大于高阈值，为确定边缘点
			if (mag >= TH)
				trace(edgeMag_noMaxsup, edge, TL, r, c, rows, cols);
			else if (mag < TL)
				edge.at<uchar>(r, c) = 0;
		}
	}
}
int main() {
	cv::Mat src = cv::imread("l0.png");

	if (src.empty()) {
		return -1;
	}
	if (src.channels() > 1) cv::cvtColor(src, src, cv::ColorConversionCodes::COLOR_BGR2GRAY);
	cv::Mat edge, edge_in,dst;

	//Canny
	Edge_Canny(src, edge, 20, 60);
	Edge_Canny_in(src, edge_in, 20, 60);
	//opencv自带Canny
	cv::Canny(src, dst, 20, 60);

	cv::namedWindow("src");
	imshow("src", src);
	cv::namedWindow("My_canny");
	imshow("My_canny", edge);
	cv::namedWindow("My_canny_in");
	imshow("My_canny_in", edge_in);
	cv::namedWindow("Opencv_canny");
	imshow("Opencv_canny", dst);
	cv::waitKey(0);
	return 0;
}
//非极大值抑制 ： 插值比较
cv::Mat non_maximum_suppression_Inter(cv::Mat dx, cv::Mat dy)
{
	//使用平方和开方的方式计算边缘强度
	cv::Mat edgeMag;
	cv::magnitude(dx, dy, edgeMag);
	//宽高
	int rows = dx.rows;
	int cols = dy.cols;
	//边缘强度的非极大抑制
	cv::Mat edgeMag_nonMaxSup = cv::Mat::zeros(dx.size(), dx.type());
	for (int r = 1; r < rows - 1; r++)
	{
		for (int c = 1; c < cols - 1; c++)
		{
			float x = dx.at<float>(r, c);
			float y = dy.at<float>(r, c);
			if (x == 0 && y == 0)
				continue;
			float angle = atan2f(y, x) / CV_PI * 180;
			//领域内八个方向上的边缘强度
			float leftTop = edgeMag.at<float>(r - 1, c - 1);
			float top = edgeMag.at<float>(r - 1, c);
			float rightBottom = edgeMag.at<float>(r + 1, c + 1);
			float right = edgeMag.at<float>(r, c + 1);
			float rightTop = edgeMag.at<float>(r - 1, c + 1);
			float leftBottom = edgeMag.at<float>(r + 1, c - 1);
			float bottom = edgeMag.at<float>(r + 1, c);
			float left = edgeMag.at<float>(r, c - 1);
			float mag = edgeMag.at<float>(r, c);
			//左上方与上方的插值 右下方和下方的插值
			if ((angle > 45 && angle <= 90) || (angle > -135 && angle <= -90))
			{
				float ratio = x / y;
				float top = edgeMag.at<float>(r - 1, c);
				//插值
				float leftTop_top = ratio * leftTop + (1 - ratio)*top;
				float rightBottom_bottom = ratio * rightBottom + (1 - ratio)*bottom;
				if (mag > leftTop_top && mag > rightBottom_bottom)
					edgeMag_nonMaxSup.at<float>(r, c) = mag;
			}
			//右上方和上方的插值 左下方和下方的插值
			if ((angle > 90 && angle <= 135) || (angle > -90 && angle <= -45))
			{
				float ratio = abs(x / y);
				float rightTop_top = ratio * rightTop + (1 - ratio)*top;
				float leftBottom_bottom = ratio * leftBottom + (1 - ratio)*bottom;
				if (mag > rightTop_top && mag > leftBottom_bottom)
					edgeMag_nonMaxSup.at<float>(r, c) = mag;
			}
			//左上方和左方的插值 右下方和右方的插值
			if ((angle >= 0 && angle <= 45) || (angle > -180 && angle <= -135))
			{
				float ratio = y / x;
				float rightBottom_right = ratio * rightBottom + (1 - ratio)*right;
				float leftTop_left = ratio * leftTop + (1 - ratio)*left;
				if (mag > rightBottom_right && mag > leftTop_left)
					edgeMag_nonMaxSup.at<float>(r, c) = mag;
			}
			//右上方和右方的插值 左下方和左方的插值
			if ((angle > 135 && angle <= 180) || (angle > -45 && angle <= 0))
			{
				float ratio = abs(y / x);
				float rightTop_right = ratio * rightTop + (1 - ratio)*right;
				float leftBottom_left = ratio * leftBottom + (1 - ratio)*left;
				if (mag > rightTop_right && mag > leftBottom_left)
					edgeMag_nonMaxSup.at<float>(r, c) = mag;
			}
		}
	}
	return edgeMag_nonMaxSup;
}
走过，莫回头
关注
  • 0
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Canny边缘检测算法(Canny edge detector)
数据联盟
04-17 1万+
Canny边缘检测算子是澳洲计算机科学家约翰·坎尼（John F. Canny）于1986年开发出来的一个多级边缘检测算法。 算法步骤 1. 降噪 任何边缘检测算法都不可能在未经处理的原始数据上很好地处理，所以第一步是对原始数据与高斯平滑模板作卷积，得到的图像与原始图像相比有些轻微的模糊（blurred）。这样，单独的一个像素噪声在经过高斯平滑的图像上变得几乎没有影响。 2. 寻找图像中的亮度梯度...
Canny算子边缘检测原理学习教案.pptx
11-21
"Canny算子边缘检测原理学习教案.pptx" Canny算子边缘检测原理是图像处理中的一种常用技术，用于检测图像中的边缘信息。边缘检测是图像处理的重要步骤，对图像的后续处理有着重要的影响。图像边缘是指图像中灰度有...
openCV实战-系列教程5：边缘检测（Canny边缘检测/高斯滤波器/Sobel算子/非极大值抑制/线性插值法/梯度方向/双阈值检测 ）、原理解析、源码解读
最新发布
机器学习与软件工程
08-24 4025
openCV实战-系列教程5：边缘检测（Canny边缘检测/高斯滤波器/Sobel算子/非极大值抑制/线性插值法/梯度方向/双阈值检测）、原理解析、源码解读
NNDL 实验六 卷积神经网络（1）卷积 边缘检测之传统边缘检测算子和基于pytorch的Canny边缘检测
qq_58153224的博客
10-20 2288
受生物学上感受野机制的启发而提出。 一般是由卷积层、汇聚层和全连接层交叉堆叠而成的前馈神经网络 有三个结构上的特性：局部连接、权重共享、汇聚。 具有一定程度上的平移、缩放和旋转不变性。 和前馈神经网络相比，卷积神经网络的参数更少。 主要应用在图像和视频分析的任务上，其准确率一般也远远超出了其他的神经网络模型。 近年来卷积神经网络也广泛地应用到自然语言处理、推荐系统等领域。这里只涉及通常意义上的图像卷积。在本书后面的实现中，算子都继承paddle.nn.Layer，并使用支持反向传播的飞桨API进行实现，这样
关于suzuki 轮廓跟踪算法
chchzh的专栏
11-06 2727
关于suzuki 轮廓跟踪算法 算定义了几个概念： 连通区域，由相同像素点组成的区域，，如果自称区域的点为1，则称之为1-部件，否则为0-部件。 点（i，j）的邻域是指： 其中左侧的为点的4-邻域，用于连通域的路径搜索。右侧的为8-邻域，用于边缘跟踪。 边缘点序号NBD，标识边缘点。 边缘序号LNBD，标识边缘的从属关系。 边缘类型，表示一个边缘的类型属性，外边缘和孔边缘（outer/hole）。 图像帧（Frame），图像的最外边界所形成的连通域，即图像的背...
Canny边缘检测算法及实现
leonardohaig的博客
05-21 1万+
提取图片的边缘信息是底层数字图像处理的基本任务之一.
Canny边缘检测算法原理及其VC实现详解(一)
热门推荐
奋斗斌斌的专栏
10-20 17万+
图象的边缘是指图象局部区域亮度变化显著的部分，该区域的灰度剖面一般可以看作是一个阶跃，既从一个灰度值在很小的缓冲区域内急剧变化到另一个灰度相差较大的灰度值。图象的边缘部分集中了图象的大部分信息，图象边缘的确定与提取对于整个图象场景的识别与理解是非常重要的，同时也是图象分割所依赖的重要特征，边缘检测主要是图象的灰度变化的度量、检测和定位，自从1959提出边缘检测以来，经过五十多年的发展，已有许多中不
Canny算子边缘检测原理PPT教学课件.pptx
10-06
本资源是关于Canny算子边缘检测原理的PPT教学课件，介绍了图像边缘检测的基本概念、传统边缘检测算子、Canny算子的原理和实现过程。 一、图像边缘检测的基本概念 图像边缘是指图像中灰度有显著变化的像素点的集合...
Canny-算子边缘检测原理解析
05-04
Canny算子是由John Canny在1986年提出的，它是一种有效的边缘检测算法，旨在在保持高检测性能的同时，降低误检率并减少噪声的影响。 Canny算子的主要目标是找到图像中灰度变化显著的像素点，这些点在频域中被视为...
Canny算子边缘检测原理解析学习教案.pptx
11-21
Canny算子边缘检测原理解析学习教案 Canny算子是一种经典的边缘检测算法，能够有效地检测图像中的边缘信息。下面是对Canny算子边缘检测原理解析的详细介绍。 图像边缘是什么？ 图像边缘是指图像中灰度有显著变化...
Canny算子边缘检测原理PPT学习教案.pptx
10-06
Canny算子是一种经典的图像边缘检测算法，由John Canny在1986年提出，因其在检测性能、定位精度和边缘响应次数最少这三大准则上的优化，被誉为边缘检测领域内的理想算法。Canny算子的主要目标是在提高对图像边缘敏感...
边缘检测之canny
qq_26496077的博客
03-10 1599
Canny边缘检测算法可以分为5个步骤： 一：使用高斯滤波器，平滑图像，滤除噪声 1）噪声表现形式 噪声在图像上常表现为一引起超强视觉效果的孤立像素点或像素块。一般，噪声信号与要研究的对象不相关，它以无用的信息形式出现，扰乱图像的可观测信息。 2）噪声对数字图像的影响 对于数字图像信号，噪声表现为或大或小的极值，这些极值通过加减作用于图像像素的真实灰度值上，对图像造成亮、暗点干扰，极大降低了图像质...
图像二维卷积操作与边缘检测的Python实现（另附canny边缘检测算法）
weixin_44088154的博客
09-14 3324
关于卷积 1、卷积的定义 卷积是两个变量在某范围内相乘后求和的结果。如果卷积的变量是序列x(n)和h(n)，则卷积的结果 其中星号*表示卷积。当时序n=0时，序列h(-i)是h(i)的时序i取反的结果；时序取反使得h(i)以纵轴为中心翻转180度，所以这种相乘后求和的计算法称为卷积和，简称卷积。另外，n是使h(-i)位移的量，不同的n对应不同的卷积结果。 例： f(x) =C（k）*g（i），其中C(k)代表卷积操作数，g(i)代表样本数据, f(x)代表输出结果。 假设g(i)是一个一维的函数，而且代表
Canny边缘检测算法
Oops的博客
03-03 4205
为什么要用非极大值抑制？ 以目标检测为例：目标检测的过程中在同一目标的位置上会产生大量的候选框，这些候选框相互之间可 能会有重叠，此时我们需要利用非极大值抑制找到最佳的目标边界框，消除冗余的边界框。 ...
数组？列表？矩阵？or 向量？（求助贴）
m0_51503599的博客
09-29 231
先上个图片 我用opencv得到了四个点得坐标但它的形式为<class ‘numpy.ndarray’> 不知道它是什么，做了测试 a.nparry = ([[[ 55 , 49]], [[ 55 ,220]], [[290, 220]], [[290 , 49]]]) print(a) # print(a.shape) 不能够输出 print(a.shape) 而且蓝色部分想变为reshape((4, 2))也不行 import cv2 import numpy
opencv基础44- Canny边缘检测详解-cv.Canny()
小海聊智造
08-07 1万+
Canny边缘检测是一种经典的边缘检测算法，由John F.Canny在1986年提出。它被广泛应用于计算机视觉和图像处理领域，是一种多阶段的边缘检测算法，能够有效地检测图像中的边缘并抑制噪声。Canny边缘检测的主要步骤如下：噪声抑制：首先，通过使用高斯滤波器对图像进行平滑处理，以去除图像中的噪声。高斯滤波器可以有效地平滑图像，同时保持边缘的细节。计算梯度幅值和方向：使用Sobel算子计算图像中每个像素点的水平和垂直方向的梯度值。然后，根据梯度值计算每个像素点的梯度幅值和方向。
【canny边缘检测】canny边缘检测原理及代码详解
DK_csdn1的博客
12-09 2万+
前言 本文通过介绍canny边缘检测原理与代码解析，希望能让大家深入理解canny边缘检测 canny边缘检测算法主要流程 # 一、高斯模糊 图像去噪是进行边缘检测的第一步，通过去噪可以去除图像中的一些噪点，从而使边缘检测时免受噪点干扰。 一般去噪卷积核中心点的值由周围点像素均值决定，以3×3卷积核的8邻域为例，如下图所示，（0，0）点坐标值由周围坐标与本身的均值决定。 ![在这里插入图片描述](https://img-blog.csdn
Python代码实现Canny算法——图像边缘轮廓提取
sodaANDcola的博客
08-20 1万+
Python代码实现Canny算法——图像边缘轮廓提取 一、Canny算法主要思路： 1.通过高斯核进行滤波，去除噪声点，使图像平滑 2.通过求取偏导，使用梯度强度和方向来提取边缘轮廓 3.采用非极大值抑制的方法，将提取到的粗犷的边缘轮廓细化 4.采用双阈值来进一步过滤噪声即过滤掉不想要的线条，同时保证轮廓的连续性 1.高斯核滤波 众所周知，正态分布又叫做高斯分布，高斯核滤波其实就是正态分布的一个应用。 高斯分布：(和标准的二维正态分布有点差别) Gσ=1/(2πσ1σ2)∗e−(x−μ)2/σ12+(y−
Canny边缘检测及C++实现
牧野的博客
08-28 5万+
Canny边缘检测算法是澳大利亚科学家John F. Canny在1986年提出来的，不得不提一下的是当年John Canny本人才28岁！到今天已经30年过去了，Canny算法仍然是图像边缘检测算法中最经典有效的算法之一。 一起睹一下大家芳容： John Canny研究了最优边缘检测方法所需的特性，给出了评价边缘检测性能优劣的3个指标： 1  好的信噪比，即将非边缘点判定为
canny算子边缘检测原理
07-27
Canny算子是一种常用的边缘检测算法，它能够有效地提取图像中的边缘信息。其原理包括以下几个步骤： 1. 噪声抑制：首先对输入图像进行高斯滤波，以减少噪声对边缘检测的影响。 2. 计算梯度幅值和方向：对滤波后的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值