C++ 实现canny算子

已于 2024-09-12 13:49:10 修改
阅读量376 收藏 4
点赞数 4
分类专栏： c++学习 文章标签： c++ opencv 计算机视觉
于 2024-08-01 16:55:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43263382/article/details/140852128
版权

非极大值抑制
在这里插入图片描述

//

#include <iostream>
#include <opencv2/opencv.hpp>

cv::Mat getConvolutionKernel(cv::Size ksize, double sigam);
void GaussinaBlur(cv::Mat& input, cv::Mat& output, cv::Size ksize, double sigam);
void imagePading(cv::Mat& input, cv::Mat& output, int hight, int low, int left, int right);
void CalculatingGradient(cv::Mat& input, cv::Mat& Gradent, cv::Mat& theat, cv::Mat& dX, cv::Mat& dY);
void nmsFunction(cv::Mat grandent, cv::Mat dX, cv::Mat dY, cv::Mat& output);
void doubleThreshold(cv::Mat& input, cv::Mat& output, double lowTh, double highTh);

int main() {

	cv::Mat image = cv::imread("D:\\code\\c++Code\\TestCanny\\111.png", 0);

	image.convertTo(image, CV_64F);
	GaussinaBlur(image, image, cv::Size(3,3), 1.5);

	// 计算图像梯度
	cv::Mat Gradent;
	cv::Mat theat, dX, dY;
	CalculatingGradient(image, Gradent, theat, dX, dY);

	cv::Mat nmsImage;
	nmsFunction(Gradent, dX, dY, nmsImage);

	cv::Mat fImage;
	doubleThreshold(nmsImage, fImage, 50, 100);



    cv::normalize(nmsImage, nmsImage, 0, 255, cv::NORM_MINMAX);
	nmsImage.convertTo(nmsImage, CV_8U);
	//cv::convertScaleAbs(Gradent, Gradent);
	cv::imshow("gaussian", nmsImage);
	cv::waitKey(0);
}

// 高斯滤波
void GaussinaBlur(cv::Mat &input, cv::Mat &output, cv::Size ksize, double sigam) {
	// step1 : 生成卷积核
	cv::Mat convolutionKernel = getConvolutionKernel( ksize,  sigam);
	
	int width = ksize.width;
	int hight = ksize.height;

	int halfWidth = (width - 1) / 2;
	int halfHight = (hight - 1) / 2;
	

	int addHight = halfHight, addLow = halfHight, addLeft = halfWidth, addLight = halfWidth;
	
	cv::Mat pimage;
	imagePading(input, pimage, addHight, addLow, addLeft, addLight);

	// 卷积运算
	output = cv::Mat::zeros(input.size(), input.type());

	if (input.channels() == 1) {
		for (int i = halfHight; i < pimage.rows - halfHight; i++) {
			for (int j = halfWidth; j < pimage.cols - halfWidth; j++) {
				double sumA = 0;
				for (int z = i - halfHight; z <= i + halfHight / 2; z++) {
					for (int h = j - halfWidth; h <= j + halfWidth; h++) {
						sumA += pimage.at<double>(z, h) * convolutionKernel.at<double>(z - (i - halfHight), h - (j - halfWidth));
					}
				}
				pimage.at<double>(i, j) = sumA;
			}
		}
	}
	else if (input.channels() == 3)
	{
		for (int i = halfHight; i < pimage.rows - halfHight; i++) {
			for (int j = halfWidth; j < pimage.cols - halfWidth; j++) {
				cv::Vec3d sumA = 0;
				for (int z = i - halfHight; z <= i + halfHight / 2; z++) {
					for (int h = j - halfWidth; h <= j + halfWidth; h++) {
						sumA[0] += pimage.at<cv::Vec3d>(z, h)[0] * convolutionKernel.at<double>(z - (i - halfHight), h - (j - halfWidth));
						sumA[1] += pimage.at<cv::Vec3d>(z, h)[1] * convolutionKernel.at<double>(z - (i - halfHight), h - (j - halfWidth));
						sumA[2] += pimage.at<cv::Vec3d>(z, h)[2] * convolutionKernel.at<double>(z - (i - halfHight), h - (j - halfWidth));
					}
				}

				pimage.at<cv::Vec3d>(i, j) = sumA;
			}
		}
	}

	output = pimage(cv::Rect(halfHight, halfWidth,input.cols, input.rows));

}

void imagePading(cv::Mat& input, cv::Mat &output, int hight, int low, int left, int right) {

	// 填充0
	int rows = input.rows + hight + low;
	int cols = input.cols + left + right;

	if (input.channels() == 1) {
		output = cv::Mat::zeros(rows, cols, CV_64F);

		for (int i = 0; i < rows; i++) {
			for (int j = 0; j < cols; j++) {
				if (i >= hight && i < rows - low && j >= left && j < cols - right) {

					output.at<double>(i, j) = input.at<double>(i - hight, j - left);
				}
			}
		}
	}
	else if(input.channels() == 3)
	{
		output = cv::Mat::zeros(rows, cols, CV_64FC3);

		for (int c = 0; c < input.channels(); c++) {
			for (int i = 0; i < rows; i++) {
				for (int j = 0; j < cols; j++) {
					if (i >= hight && i < rows - low && j >= left && j < cols - right) {

						output.at<cv::Vec3d>(i, j)[0] = input.at<cv::Vec3d>(i - hight, j - left)[0];
						output.at<cv::Vec3d>(i, j)[1] = input.at<cv::Vec3d>(i - hight, j - left)[1];
						output.at<cv::Vec3d>(i, j)[2] = input.at<cv::Vec3d>(i - hight, j - left)[2];
					}
				}
			}
		}

	}


}

cv::Mat getConvolutionKernel(cv::Size ksize, double sigam) {   // size 

	// 生成卷积核
	cv::Mat convolutionKernel(ksize , CV_64FC1);
	int width = ksize.width;
	int hight = ksize.height;

	int centerW = (width - 1) / 2;
	int centerH = (hight - 1) / 2;

	double x, y;
	double sum = 0;

	for (int i = 0; i < hight; i++) {
		x = std::pow(i - centerH, 2);

		for (int j = 0; j < width; j++) {
			y = std::pow(j - centerW, 2);

			double temp = std::exp(-(x + y) / (2 * std::pow(sigam, 2)));
			convolutionKernel.at<double>(i, j) = temp;
			sum += temp;
		}
	}
	// 归一化
	convolutionKernel = convolutionKernel / sum;


	return convolutionKernel;
}


// 计算图像梯度
void CalculatingGradient(cv::Mat& input, cv::Mat& Gradent, cv::Mat& theat, cv::Mat& dX, cv::Mat& dY ){
	Gradent = cv::Mat::zeros(input.size(), input.type());
	theat = cv::Mat::zeros(input.size(), input.type());
	dX = cv::Mat::zeros(input.size(), input.type());
	dY = cv::Mat::zeros(input.size(), input.type());

	// 
	if (input.channels() == 1) {
		for (int i = 1; i < input.rows - 1; i++) {
			for (int j = 1; j < input.cols - 1; j++) {

				double dx2 = input.at<double>(i - 1, j + 1) + 2 * input.at<double>(i, j + 1) + input.at<double>(i + 1, j + 1) - input.at<double>(i - 1, j - 1) - 2 * input.at<double>(i, j - 1) - input.at<double>(i + 1, j - 1);
				double dy2 = input.at<double>(i + 1, j - 1) + 2 * input.at<double>(i + 1, j) + input.at<double>(i + 1, j + 1) - input.at<double>(i - 1, j - 1) - 2 * input.at<double>(i - 1, j) - input.at<double>(i - 1, j + 1);

				Gradent.at<double>(i, j) = std::sqrt(std::pow(dx2, 2) + std::pow(dy2, 2));

				theat.at<double>(i, j) = atan(dy2 / dx2);
				dX.at<double>(i, j) = dx2;
				dY.at<double>(i, j) = dy2;

			}
		}
	}
	else if (input.channels() == 3) {
		for (int i = 1; i < input.rows - 1; i++) {
			for (int j = 1; j < input.cols - 1; j++) {

				cv::Vec3d dx2 = input.at<cv::Vec3d>(i - 1, j + 1) + 2 * input.at<cv::Vec3d>(i, j + 1) + input.at<cv::Vec3d>(i + 1, j + 1) - input.at<cv::Vec3d>(i - 1, j - 1) - 2 * input.at<cv::Vec3d>(i, j - 1) - input.at<cv::Vec3d>(i + 1, j - 1);
				cv::Vec3d dy2 = input.at<cv::Vec3d>(i + 1, j - 1) + 2 * input.at<cv::Vec3d>(i + 1, j) + input.at<cv::Vec3d>(i + 1, j + 1) - input.at<cv::Vec3d>(i - 1, j - 1) - 2 * input.at<cv::Vec3d>(i - 1, j) - input.at<cv::Vec3d>(i - 1, j + 1);

				Gradent.at<cv::Vec3d>(i, j)[0] = std::sqrt(std::pow(dx2[0], 2) + std::pow(dy2[0], 2));
				Gradent.at<cv::Vec3d>(i, j)[1] = std::sqrt(std::pow(dx2[1], 2) + std::pow(dy2[1], 2));
				Gradent.at<cv::Vec3d>(i, j)[2] = std::sqrt(std::pow(dx2[2], 2) + std::pow(dy2[2], 2));

				theat.at<cv::Vec3d>(i, j)[0] = atan(dy2[0] / dx2[0]);
				theat.at<cv::Vec3d>(i, j)[1] = atan(dy2[1] / dx2[1]);
				theat.at<cv::Vec3d>(i, j)[2] = atan(dy2[2] / dx2[2]);

			}
		}
	}


}


// 非极大值抑制
void nmsFunction(cv::Mat grandent, cv::Mat dX, cv::Mat dY, cv::Mat &output) {

	double g1 = 0, g2 = 0 ,g3 = 0, g4 = 0 ;
	double wight = 0;
	output = cv::Mat::zeros(grandent.size(), grandent.type());

	for (int i = 1; i < grandent.rows - 1; i++) {
		for (int j = 1; j < grandent.cols - 1; j++) {
			
			if (std::abs(dY.at<double>(i, j)) > std::abs(dX.at<double>(i, j))) 
			{
				g2 = grandent.at<double>(i - 1, j);
				g3 = grandent.at<double>(i + 1, j);
				wight = std::abs(dX.at<double>(i, j) /dY.at<double>(i, j)) ;

				if (dY.at<double>(i, j) * dX.at<double>(i, j) > 0) {  // 同号
					
					g1 = grandent.at<double>(i - 1, j - 1);
					g4 = grandent.at<double>(i + 1, j + 1);
				}
				else
				{
					g1 = grandent.at<double>(i - 1, j + 1);
					g4 = grandent.at<double>(i + 1, j - 1);
				}
			}
			else if (std::abs(dY.at<double>(i, j)) < std::abs(dX.at<double>(i, j)))
			{
				g2 = grandent.at<double>(i, j - 1);
				g3 = grandent.at<double>(i, j + 1);
				wight = std::abs(dY.at<double>(i, j) /dX.at<double>(i, j));

				if (dY.at<double>(i, j) * dX.at<double>(i, j) > 0) {
					g1 = grandent.at<double>(i - 1, j - 1);
					g4 = grandent.at<double>(i + 1, j + 1);
				}
				else
				{
					g1 = grandent.at<double>(i + 1, j - 1);
					g4 = grandent.at<double>(i - 1, j + 1);
				}

			}
			double gA = wight * g1 + (1 - wight) * g2;
			double gB = wight * g4 + (1 - wight) * g3;

			if (grandent.at<double>(i, j) >= gA && grandent.at<double>(i, j) >= gB) {
				output.at<double>(i, j) = grandent.at<double>(i, j);
			}

		}

	}
}


// 双阈值
/*
	大于搞阈值置为255  在阈值中间先不动
*/

void doubleThreshold(cv::Mat& input, cv::Mat& output, double lowTh, double highTh) {

	output = cv::Mat::zeros(input.size(), CV_8U);

	// 强边缘
	for (int i = 0; i < input.rows; i++) {
		for (int j = 0; j < input.cols; j++) {
			if (input.at<double>(i, j) >= highTh) {
				output.at<uchar>(i, j) = 255;
			}
		}
	}

	// 弱边缘
	for (int i = 1; i < input.rows - 1; i++) {
		for (int j = 1; j < input.cols - 1; j++) {
			if (input.at<double>(i, j) < highTh && input.at<double>(i, j) >= lowTh) {
				
				if (output.at<uchar>(i - 1, j - 1) + output.at<uchar>(i - 1, j) + output.at<uchar>(i - 1, j + 1) +
					output.at<uchar>(i, j - 1) + output.at<uchar>(i, j + 1) +
					output.at<uchar>(i + 1, j - 1) + output.at<uchar>(i + 1, j) + output.at<uchar>(i + 1, j + 1)
					!= 0
					) {
					output.at<uchar>(i, j) = 255;
				}
				
			}
		}
	}

}
三维重建-光栅投影
关注
专栏目录
canny算子代码
11-05
cany算子用于边缘检测比其他算子结果更为精确，这是基于opencv的c++canny 算子源代码。
canny算子实现代码
12-23
canny算子实现代码，验证没问题,一切OK
Canny算子源代码
07-03
很详细的Canny算子代码，程序可以运行
canny matlab代码,Canny算子源代码
weixin_36268255的博客
03-17 634
【实例简介】很详细的Canny算子代码，程序可以运行【实例截图】【核心代码】Canny└── Canny├── Canny.aps├── Canny.clw├── Canny.cpp├── CannyDoc.cpp├── CannyDoc.h├── Canny.dsp├── Canny.dsw├── Canny.h├── Canny.ncb├── Canny.plg├── Canny.rc├── ...
用c++实现Canny算子
06-30
在C++中实现Canny算子通常涉及到以下几个关键步骤： 1. **噪声过滤**：首先，使用高斯滤波器来平滑图像，以减少噪声对边缘检测的影响。高斯滤波器的核大小和标准差可以根据实际图像的噪声水平来选择。 2. **计算...
C++实现canny算子（不调用OpenCV）
weixin_43143224的博客
12-20 1808
c++实现canny算子（不用OpenCV） canny算子我看到很多都是介绍原理，实现用OpenCV函数实现。下面我用c++实现了一下canny算子。 原理 原理参考CSDN博客，我觉得解释的很好CSDN博客 实现 用高斯滤波器平滑图像 void Glbq(BYTE * im, int h, int w, BYTE * om) //用的是灰度图像，0-255，所以用BYTE* { ...
基于c++用Canny算子提取边缘
04-06
本教程将深入探讨如何使用C++实现Canny算子来提取图像的边缘。 一、Canny算子的基本原理 Canny算子包括以下四个主要步骤： 1. **高斯滤波**：首先对图像进行高斯滤波，以消除噪声并平滑图像。高斯滤波器的核大小...
用c++ 实现 canny算子，并且达到最优水平
最新发布
06-08
Canny算子是一种广泛使用的边缘检测算法，它的实现可以分为以下几个步骤： 1. 高斯滤波：使用高斯滤波器对原始图像进行平滑处理，以减少噪声对边缘检测结果的影响。 2. 计算梯度：对平滑后的图像进行梯度计算，...
Canny算子c++实现
qq_38231713的博客
05-28 1502
数字图像处理作业，实现一个canny算子，这里只给出代码，opencv版本为3.4.5 #include <iostream> #include "opencv2/opencv.hpp" using namespace std; using namespace cv; /* 生成高斯卷积核 kernel */ void Gaussian_kernel(int kernel_size...
canny算子MATLAB代码过程
11-10
本程序主要功能为MATLAB中canny算子的代码实现。通过将MATLAB中canny算子用程序显示，表现canny算子的运行过程
matlab实现canny算法
04-14
matlab实现canny算法
Python实现Canny算子
m0_58058919的博客
09-19 2015
在之前的复现中犯了一个明显的错误，将梯度方向做了处理（四个方向），最好的处理方-处理成4个区间（0-45,45-90,09-135,135-180）用插值的方式进行梯度比较，插值的大小根据角度不同取权重乘以两个相邻像素。Canny算子是提取图像边缘的经典算法，在之前的基础学习过程中写过关于canny的python代码，最近的项目中需要用到才发现当初学的有所缺陷。
opencv代码分析--canny算子
07-01 663
一、canny算子优点 相比较于常见的robert算子、sobel算子、梯度求边缘等方法，使用canny算子可以提取单像素二值化的细边缘，这是其他方法所不具备的 二、opencv canny算子提取边缘基本原理 opencv中canny算子的基本原理主要有以下几个步骤： 1. 梯度或sobel算子求边缘图 下图是用梯度求的边缘图，梯度值取水平梯度和垂直梯度之和，可以看到求出的边缘
Canny边缘检测算子原理和matlab和opencv实现代码
qq_21603315的博客
11-27 7145
详细地分析了Canny边缘检测算子的数学原理，配有matlab和opencv实现代码
基于MATLAB的canny算子
思维蓝图
08-24 3万+
Matlab中的canny算子就做的相当好，其边缘检测效果非常优秀。为了使读者更容易读懂其中的算法，我将源代码转化为更加浅显易懂的代码。 代码下载地址：http://download.csdn.net/detail/jackinzhou/4523620 Matlab中的canny边缘检测算法如下： %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %说明
Canny边缘检测及C++实现
热门推荐
牧野的博客
08-28 5万+
Canny边缘检测算法是澳大利亚科学家John F. Canny在1986年提出来的，不得不提一下的是当年John Canny本人才28岁！到今天已经30年过去了，Canny算法仍然是图像边缘检测算法中最经典有效的算法之一。 一起睹一下大家芳容： John Canny研究了最优边缘检测方法所需的特性，给出了评价边缘检测性能优劣的3个指标： 1  好的信噪比，即将非边缘点判定为
canny算子的python实现以及pytorch实现
u010948546的博客
09-13 2450
canny算子的python实现和pytorch实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值