引导滤波(GuidedFilter)原理及C++实现

最新推荐文章于 2024-05-11 22:16:21 发布
置顶 最新推荐文章于 2024-05-11 22:16:21 发布
阅读量7.7k 收藏 70
点赞数 5
分类专栏： 【图像处理算法】 图像处理经典算法c++实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40647819/article/details/89763505
版权

写在前面

引导滤波是何恺明读博士的时候提出来的一种去噪保边算法，很有名。作者其主页上给出了该算法的Matlab实现和原文。而且他提出的基于暗通道去雾算法技惊四座，获CVPR2009最佳论文（膜拜），近几年在CV领域的成果也相当丰硕，关于他的研究动态，可以访问http://kaiminghe.com/。

优点：

1、应用面很广、很广；

2、能够克服双边滤波的梯度翻转现象，在滤波后图像的细节上更优；

3、最重要的优点，快，效率高，时间复杂度为O(N)，N是像素个数，也就是说与掩膜窗口尺寸无关了，我们知道传统双边滤波效率是很低的。还有更快的Fast Guide Filter：https://arxiv.org/abs/1505.00996

应用：图像增强、图像融合、图像去雾、图像去噪、羽化、美颜、三维重建等等。

如果你仅仅只是需要运用这个算法，现在opencv 3.0和MATLAB 14都已经添加了guided filter的API，可以直接调用。

opencv中的API如下void cv::ximgproc::guidedFilter()，具体的可以参考opencv的帮助文档关于导向滤波的介绍guidedFilter。

但是需要提醒的是，opencv中guidedFilter()函数包含在ximgproc模块下，但是从官方下载的标准的opencv.exe程序中并不包含该模块，需要分别下载opencv的source文件和contrib模块的source文件，然后自己编译，具体可以参考opencv3.1.0+contrib模块编译总结。

 

原理

说实话，引导滤波的理论还是蛮深的，不容易讲清楚，我这小菜鸡看了原文，还看了很多博客，也是一知半解。好在作者在原文中给出了伪代码，程序实现起来比较简单，我基于OpenCV写了一个，经过测试，和作者的Matlab实现效果是一样的。

为了不误导读者，还是等我自己完全搞明白了，再详细写原理。这里就推荐几个原理写的好的博客吧：

1、https://www.cnblogs.com/riddick/p/8367591.html

2、白马负金羁-导向滤波(Guided Filter)的解析与实现

3、https://www.cnblogs.com/yzl050819/p/7515250.html

 

伪代码：

 

基于OpenCV的C++实现

实现分为两种：灰度图作为引导图、彩色图作为引导图，值得说明的是：两种实现的滤波图像都只能对单通道图像进行处理。若需要处理彩色图像，在main中只需将图像split，然后对各个通道分别滤波，最后merge就可以了。作者还在原文中指出，用彩色图作为引导图能更好地保持边缘细节，我后面的效果也确实印证了这一点。

灰度图作为引导图（main中可以处理彩色图像）

#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>

//
//   GUIDEDFILTER   O(1) time implementation of guided filter.
//   -guidance image : I(should be a gray - scale / single channel image)
//   -filtering input image : p(should be a gray - scale / single channel image)
//   -local window radius : r
//   -regularization parameter : eps
/
cv::Mat GuidedFilter(cv::Mat& I, cv::Mat& p, int r, double eps){
	int wsize = 2 * r + 1;
	//数据类型转换
	I.convertTo(I, CV_64F, 1.0 / 255.0);
	p.convertTo(p, CV_64F, 1.0 / 255.0);

	//meanI=fmean(I)
	cv::Mat mean_I;
	cv::boxFilter(I, mean_I, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波

	//meanP=fmean(P)
	cv::Mat mean_p;
	cv::boxFilter(p, mean_p, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波

	//corrI=fmean(I.*I)
	cv::Mat mean_II;
	mean_II = I.mul(I);
	cv::boxFilter(mean_II, mean_II, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波

	//corrIp=fmean(I.*p)
	cv::Mat mean_Ip;
	mean_Ip = I.mul(p);
	cv::boxFilter(mean_Ip, mean_Ip, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波

	//varI=corrI-meanI.*meanI
	cv::Mat var_I, mean_mul_I;
	mean_mul_I=mean_I.mul(mean_I);
	cv::subtract(mean_II, mean_mul_I, var_I);

	//covIp=corrIp-meanI.*meanp
	cv::Mat cov_Ip;
	cv::subtract(mean_Ip, mean_I.mul(mean_p), cov_Ip);

	//a=conIp./(varI+eps)
	//b=meanp-a.*meanI
	cv::Mat a, b;
	cv::divide(cov_Ip, (var_I+eps),a);
	cv::subtract(mean_p, a.mul(mean_I), b);

	//meana=fmean(a)
	//meanb=fmean(b)
	cv::Mat mean_a, mean_b;
	cv::boxFilter(a, mean_a, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波
	cv::boxFilter(b, mean_b, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波

	//q=meana.*I+meanb
	cv::Mat q;
	q = mean_a.mul(I) + mean_b;

	//数据类型转换
	I.convertTo(I, CV_8U, 255);
	p.convertTo(p, CV_8U, 255);
	q.convertTo(q, CV_8U, 255);

	return q;

}

int main(){
	cv::Mat src = cv::imread("I:\\Learning-and-Practice\\2019Change\\Image process algorithm\\Img\\woman.jpg");
	if (src.empty()){
		return -1;
	}

	//if (src.channels() > 1)  
	//	cv::cvtColor(src, src, CV_RGB2GRAY);
	
	//自编GuidedFilter测试
	double t2 = (double)cv::getTickCount(); //测时间

	cv::Mat dst1, src_input, I;
	src.copyTo(src_input);
	if (src.channels() > 1)
	   cv::cvtColor(src, I, CV_RGB2GRAY); //若引导图为彩色图，则转为灰度图
	std::vector<cv::Mat> p,q;
	if (src.channels() > 1){             //输入为彩色图
		cv::split(src_input, p);
		for (int i = 0; i < src.channels(); ++i){
			dst1 = GuidedFilter(I, p[i], 9, 0.1*0.1);
			q.push_back(dst1);
		}
		cv::merge(q, dst1);
	}
	else{                               //输入为灰度图
		src.copyTo(I);
		dst1 = GuidedFilter(I, src_input, 9, 0.1*0.1);
	}

	t2 = (double)cv::getTickCount() - t2;
	double time2 = (t2 *1000.) / ((double)cv::getTickFrequency());
	std::cout << "MyGuidedFilter_process=" << time2 << " ms. " << std::endl << std::endl;

	cv::namedWindow("GuidedImg", CV_WINDOW_NORMAL);
	cv::imshow("GuidedImg", I);
	cv::namedWindow("src", CV_WINDOW_NORMAL);
	cv::imshow("src", src);
	cv::namedWindow("GuidedFilter_box", CV_WINDOW_NORMAL);
	cv::imshow("GuidedFilter_box", dst1);
	cv::waitKey(0);

}

效果(核半径=9，eps=0.1*0.1)

                       引导图                                                            输入图                                                             结果图

 

                          引导图                                                            输入图                                                             结果图

 

 

彩色图作为引导图（只能处理单通道图像）

#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>


///
//   GUIDEDFILTER_COLOR   O(1) time implementation of guided filter using a color image as the guidance.
//
//   -guidance image : I(should be a color(RGB) image)
//	 -filtering input image : p(should be a gray - scale / single channel image)
//   -local window radius : r
//   -regularization parameter : eps
///
cv::Mat GuidedFilter_Color(cv::Mat& I, cv::Mat& p, int r, double eps ){
	int wsize = 2 * r + 1;
	//数据类型转换
	I.convertTo(I, CV_64F, 1.0 / 255.0);
	p.convertTo(p, CV_64F, 1.0 / 255.0);
	
	//引导图通道分离
	if (I.channels() == 1){
		std::cout<<"I should be a color(RGB) image "<<std::endl;
	}
	std::vector<cv::Mat> rgb;
	cv::split(I, rgb);

	//meanI=fmean(I)
	cv::Mat mean_I_r, mean_I_g, mean_I_b;
	cv::boxFilter(rgb[0], mean_I_b, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波
	cv::boxFilter(rgb[1], mean_I_g, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波
	cv::boxFilter(rgb[2], mean_I_r, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波

	//meanP=fmean(P)
	cv::Mat mean_p;
	cv::boxFilter(p, mean_p, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波

	//corrI=fmean(I.*I)
	cv::Mat mean_II_rr, mean_II_rg, mean_II_rb, mean_II_gb, mean_II_gg, mean_II_bb;
	cv::boxFilter(rgb[2].mul(rgb[2]), mean_II_rr, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波
	cv::boxFilter(rgb[2].mul(rgb[1]), mean_II_rg, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波
	cv::boxFilter(rgb[2].mul(rgb[0]), mean_II_rb, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波
	cv::boxFilter(rgb[1].mul(rgb[0]), mean_II_gb, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波
	cv::boxFilter(rgb[1].mul(rgb[1]), mean_II_gg, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波
	cv::boxFilter(rgb[0].mul(rgb[0]), mean_II_bb, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波

	//corrIp=fmean(I.*p)
	cv::Mat mean_Ip_r, mean_Ip_g, mean_Ip_b;
	mean_Ip_b = rgb[0].mul(p);
	mean_Ip_g = rgb[1].mul(p);
	mean_Ip_r = rgb[2].mul(p);
	cv::boxFilter(mean_Ip_b, mean_Ip_b, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波
	cv::boxFilter(mean_Ip_g, mean_Ip_g, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波
	cv::boxFilter(mean_Ip_r, mean_Ip_r, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波

	//covIp=corrIp-meanI.*meanp
	cv::Mat cov_Ip_r, cov_Ip_g, cov_Ip_b;
	cv::subtract(mean_Ip_r, mean_I_r.mul(mean_p), cov_Ip_r);
	cv::subtract(mean_Ip_g, mean_I_g.mul(mean_p), cov_Ip_g);
	cv::subtract(mean_Ip_b, mean_I_b.mul(mean_p), cov_Ip_b);

	//varI=corrI-meanI.*meanI
	//variance of I in each local patch : the matrix Sigma in Eqn(14).
	//Note the variance in each local patch is a 3x3 symmetric matrix :
	//           rr, rg, rb
	//   Sigma = rg, gg, gb
	//           rb, gb, bb
	cv::Mat var_I_rr, var_I_rg, var_I_rb, var_I_gb, var_I_gg, var_I_bb;
	cv::subtract(mean_II_rr, mean_I_r.mul(mean_I_r), var_I_rr);
	cv::subtract(mean_II_rg, mean_I_r.mul(mean_I_g), var_I_rg);
	cv::subtract(mean_II_rb, mean_I_r.mul(mean_I_b), var_I_rb);
	cv::subtract(mean_II_gb, mean_I_g.mul(mean_I_b), var_I_gb);
	cv::subtract(mean_II_gg, mean_I_g.mul(mean_I_g), var_I_gg);
	cv::subtract(mean_II_bb, mean_I_b.mul(mean_I_b), var_I_bb);

	//a=conIp./(varI+eps)
	int cols = p.cols;
	int rows = p.rows;
	cv::Mat Mat_a = cv::Mat::zeros(rows, cols,CV_64FC3);
	std::vector<cv::Mat> a;
	cv::split(Mat_a, a);
	double rr, rg, rb, gg, gb, bb;
	for (int i = 0; i < rows; ++i){
		for (int j = 0; j < cols; ++j){
			rr = var_I_rr.at<double>(i, j); rg = var_I_rg.at<double>(i, j); rb = var_I_rb.at<double>(i, j);
			gg = var_I_gg.at<double>(i, j); gb = var_I_gb.at<double>(i, j);
		    bb = var_I_bb.at<double>(i, j);
			cv::Mat sigma = (cv::Mat_<double>(3, 3) << rr, rg, rb,
													   rg, gg, gb,
				                                       rb, gb, bb);
			cv::Mat cov_Ip = (cv::Mat_<double>(1, 3) << cov_Ip_r.at<double>(i, j), cov_Ip_g.at<double>(i, j), cov_Ip_b.at<double>(i, j));
			cv::Mat eye = cv::Mat::eye(3, 3, CV_64FC1);
			sigma = sigma + eps*eye;
			cv::Mat sigma_inv = sigma.inv();//求逆矩阵
			cv::Mat tmp = cov_Ip*sigma_inv;
			a[2].at<double>(i, j) = tmp.at<double>(0, 0);//r
			a[1].at<double>(i, j) = tmp.at<double>(0, 1);//g
			a[0].at<double>(i, j) = tmp.at<double>(0, 2);//b
		}
	}

	//b=meanp-a.*meanI
	cv::Mat b = mean_p - a[0].mul(mean_I_b) - a[1].mul(mean_I_g) - a[2].mul(mean_I_r);

	//meana=fmean(a)
	//meanb=fmean(b)
	cv::Mat mean_a_r, mean_a_g, mean_a_b, mean_b;
	cv::boxFilter(a[0], mean_a_b, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波
	cv::boxFilter(a[1], mean_a_g, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波
	cv::boxFilter(a[2], mean_a_r, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波
	cv::boxFilter(b, mean_b, -1, cv::Size(wsize, wsize), cv::Point(-1, -1), true, cv::BORDER_REFLECT);//盒子滤波

	//q=meana.*I+meanb
	cv::Mat q = mean_a_r.mul(rgb[2]) + mean_a_g.mul(rgb[1]) + mean_a_b.mul(rgb[0]) + mean_b;

	//数据类型转换
	I.convertTo(I, CV_8UC3, 255);
	p.convertTo(p, CV_8U, 255);
	q.convertTo(q, CV_8U, 255);

	return q;
}

int main(){
	cv::Mat I = cv::imread("I:\\Learning-and-Practice\\2019Change\\Image process algorithm\\Img\\woman1.jpeg");
	cv::Mat P = cv::imread("I:\\Learning-and-Practice\\2019Change\\Image process algorithm\\Img\\woman1.jpeg");
	if (I.empty() || P.empty()){
		return -1;
	}
	if (P.channels() > 1)
		cv::cvtColor(P, P, CV_RGB2GRAY);
	
	//自编GuidedFilter测试
	double t2 = (double)cv::getTickCount(); //测时间
	cv::Mat q;
	q = GuidedFilter_Color(I, P, 9, 0.2*0.2);
	t2 = (double)cv::getTickCount() - t2;
	double time2 = (t2 *1000.) / ((double)cv::getTickFrequency());
	std::cout << "MyGuidedFilter_process=" << time2 << " ms. " << std::endl << std::endl;

	cv::namedWindow("GuidedImg");
	cv::imshow("GuidedImg", I);
	cv::namedWindow("src");
	cv::imshow("src", P);
	cv::namedWindow("GuidedFilter", CV_WINDOW_NORMAL);
	cv::imshow("GuidedFilter", q);
	cv::waitKey(0);

}

效果(核半径=9，eps=0.1*0.1)

                         引导图                                                            输入图                                                             结果图

这里的结果图比用灰度图作为引导，边缘保持更好，可以仔细对比观察面部和鼻子。

小武~~
关注
  • 5
    点赞
  • 踩
  • 70
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
引导滤波算法matlab,引导滤波(guided image filtering）原理及C++实现
weixin_33478634的博客
03-23 710
templatevoid CImageObj::BoxFilter(K** src, T** dst, int r){int w = 2 * r + 1;int pixCount = w * w;int nx = m_width;int ny = m_height;int i, j, m, n;for (i = 0; i < ny; ++i){for (j = 0; j < nx; +...
引导滤波(guided image filtering）原理及C++实现
cyh706510441的专栏
10-28 1万+
引导滤波 引导滤波是由何凯明等人与2010年提出，它本质上具有O(N)复杂度，相对于双边滤波有更好的边缘保持特性，且不会出现梯度反转现象。在不同引导图像的引导下，可广泛应用于降噪、去雾、高动态范围压缩等。 该方法基于局部线性模型： 代码实现 0、伪代码 1、MATLAB代码 见参考资料【2】 2、C++实现 template void C
matlab中的引导滤波函数imguidedfilter()
最新发布
Vertira的博客
05-11 581
matlab中的引导滤波函数imguidedfilter()
guided Filter--引导滤波算法原理及实现
满城风絮
10-28 6万+
http://blog.csdn.net/zwlq1314521/article/details/51007943 http://cn.mathworks.com/help/images/ref/imguidedfilter.html?requestedDomain=www.mathworks.com http://www.pudn.com/Download/item/id/3225837.h
引导滤波（guidedFilter）与边窗盒式滤波(sideWindowBoxFilter)的C++与OpenCV实现
u014230360的博客
04-16 1993
引导滤波（guidedFilter）与边窗盒式滤波(sideWindowBoxFilter)的C++与OpenCV实现 好久没更博客了。去年年底跳了槽，转回了工业检测领域，忙于找工作和开发新算法，同时担心泄露技术秘密，所以一直没有更新博客。刚过去的三个月试用期里开发了两个原创算法，一个已经申请专利（涉及工业品区域边界轮廓提取），一个正准备申请（涉及复杂纹理下的圆孔提取），也算是值得骄傲的一件事了。待专利授权下来后，我可以给大家讲一讲这两个新算法，目前就暂且保密啦。 引导滤波和边窗滤波都是近几年出现.
引导滤波原理及C++代码实现
I good vegetable a!
11-21 2565
前置内容 在学习引导滤波，最好对高斯滤波和双边滤波有过理解，对于高斯滤波:Wij=1Kiexp(−∣xj−xi∣2σ2)W_{ij} = \frac{1}{K_i}exp(-\frac{|x_j-x_i|^2}{\sigma^2})Wij​=Ki​1​exp(−σ2∣xj​−xi​∣2​)，其中WWW是权重，iii和jjj是像素的索引，KKK是归一化的常量。公式可以看出，权重只和像素之间的空间距离...
快速引导滤波原理详解（fast guided filter）
吹吹自然风
12-02 1421
引导滤波原理详解，fast guided filter
引导滤波matlab代码实现,引导图滤波（Guided Image Filtering）原理以及OpenCV实现
weixin_40006185的博客
03-23 2059
引导图滤波器是一种自适应权重滤波器，能够在平滑图像的同时起到保持边界的作用，具体公式推导请查阅原文献《Guided Image Filtering》以及matlab源码：http://kaiminghe.com/eccv10/index.html。这里只说一下自适应权重原理、C++实现灰度图像以及彩色图像的引导图滤波、验证结果。自适应权重原理引导图滤波作为一种线性滤波器，可以简单定义为如下形式：其...
引导图滤波（Guided Image Filtering）原理以及OpenCV实现
weixin_36670529的博客
03-17 3100
引导图滤波器是一种自适应权重滤波器，能够在平滑图像的同时起到保持边界的作用，具体公式推导请查阅原文献《Guided Image Filtering》以及matlab源码：http://kaiminghe.com/eccv10/index.html。这里只说一下自适应权重原理、C++实现灰度图像以及彩色图像的引导图滤波、验证结果。 自适应权重原理 引导图滤波作为一种线性滤波器，可以简单定义为如下形式：其中I是引导图像(guided Image)，P是输入的待滤波图像，Q是滤波后的输出图像，W是根据引导图.
fast-guided-filter-code-v1.rar_Fast 引导滤波_fast guided filter_引导滤波
07-15
引导滤波对图像进行滤波，可以去除大部分的噪声，平滑图像效果较突出，还能保持图像的边缘信息，实现效果较好！在传统的引导滤波上采取下采样的方法实现加速。
GuidedFilter：Guided Filter的实现和比较
02-02
在GuidedFilter-master这个压缩包中，可能包含了该滤波器的源代码实现，以及用于测试和对比的示例数据。 总的来说，Guided Filter是一种实用的图像处理工具，其原理和应用广泛涵盖图像处理和计算机视觉领域。在...
opencv-基于c++实现的opencv图像处理算法之图像滤波算法引导滤波.zip
04-17
在C++中，实现引导滤波可能需要编写自定义函数，因为OpenCV库内没有直接支持的接口。基本步骤如下： 1. 导入必要的OpenCV库： ```cpp #include ``` 2. 定义引导滤波函数，包括滤波器大小、引导图像和阈值等...
引导滤波_Cpp_Python.rar
08-18
使用C++与Python实现的引导滤波（guided image filter）代码，附件中包含一个cpp文件、一个python文件与一张测试图像。 博客链接为：https://blog.csdn.net/u013921430/article/details/99695647
伪彩色增强+引导滤波.rar
04-05
在OpenCV中，可以使用filter2D或GuidedFilter函数来实现引导滤波。 在VS2013环境中，我们需要配置好OpenCV库的路径，确保编译器能够找到相关头文件和库文件。然后，可以编写C++代码，调用OpenCV的API来实现伪彩色...
OTSU算法（大津法—最大类间方差法）原理及实现
热门推荐
小武的博客
05-13 17万+
写在前面 大津法（OTSU）是一种确定图像二值化分割阈值的算法，由日本学者大津于1979年提出。从大津法的原理上来讲，该方法又称作最大类间方差法，因为按照大津法求得的阈值进行图像二值化分割后，前景与背景图像的类间方差最大。 它被认为是图像分割中阈值选取的最佳算法，计算简单，不受图像亮度和对比度的影响，因此在数字图像处理上得到了广泛的应用。它是按图像的灰度特性，将图像分成背景和前景两部分。因方差...
Canny算子边缘检测原理及实现
小武的博客
06-11 11万+
写在前面 Canny边缘检是在在1986年提出来的，到今天已经30多年过去了，但Canny算法仍然是图像边缘检测算法中最经典、先进的算法之一。 相比Sobel、Prewitt等算子，Canny算法更为优异。Sobel、Prewitt等算子有如下缺点： 没有充分利用边缘的梯度方向。 最后得到的二值图，只是简单地利用单阈值进行处理。 而Canny算法基于这两点做了改进，提出了： 基于边缘梯度...
自适应阈值（adaptiveThreshold）分割原理及实现
小武的博客
05-14 8万+
背景介绍及原理 前面介绍了OTSU算法和最大熵算法，但这两种算法都属于全局阈值法，所以对于某些光照不均的图像，这种全局阈值分割的方法会显得苍白无力，如下图： 显然，这样的阈值处理结果不是我们想要的，那么就需要一种方法来应对这样的情况。 这种办法就是自适应阈值法(adaptiveThreshold)，它的思想不是计算全局图像的阈值，而是根据图像不同区域亮...
区域生长算法原理及实现
小武的博客
05-14 5万+
写在前面 前面写了OTSU算法、最大熵算法、自适应阈值法，这些都是基于阈值的分割算法。 今天写一下基于区域的分割算法，其中最为有名和经典的就是区域生长算法。值得说明的是：OpenCV没有提供区域生长算法的API。 优点：基本思想相对简单，通常能将具有相同特征的联通区域分割出来，并能提供很好的边界信息和分割结果。在没有先验知识可以利用时，可以取得最佳的性能，可以用来分割比较复杂的图象，如自然景...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值