高斯滤波(GaussianFilter)原理及C++实现

最新推荐文章于 2025-07-03 11:09:20 发布
原创 最新推荐文章于 2025-07-03 11:09:20 发布 · 置顶 · 3.5w 阅读 · 375 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

写在前面

首先，搞清楚几个概念：滤波(高通、低通、带通、带阻) 、模糊、去噪、平滑，看下图：

preview

                                              

滤波是对输入信号进行卷积处理的一个过程，写成一个表达式的形式是这样的：
滤波 = 卷积（ 输入信号 ，卷积模板 ）， 卷积模板/掩膜 的不同决定了不同的滤波方式，也因此产生了高通、低通、带通、带阻等基本的滤波方式。

针对低通滤波，就是保留将信号中的低频部分，抑制高频部分。要达到这个目的，可以利用均值掩膜、高斯掩膜等对输入信号进行处理。
采用均值掩膜对输入信号进行卷积的滤波方式叫均值滤波；
采用高斯掩膜对输入信号进行卷积的滤波方式叫高斯滤波；

这里高斯滤波，也叫高斯模糊。

应用：高斯滤波是一种线性平滑滤波器，对于服从正态分布的噪声有很好的抑制作用。在实际场景中，我们通常会假定图像包含的噪声为高斯白噪声，所以在许多实际应用的预处理部分，都会采用高斯滤波抑制噪声，如车牌识别等。

opencv函数声明:

void GaussianBlur(InputArray src, OutputArray dst, Size ksize, 
                  double sigmaX, double sigmaY=0,
                  int borderType=BORDER_DEFAULT )

Github: https://github.com/2209520576/Image-Processing-Algorithm/blob/master/Image%20Filtering/GaussianFilter.cpp

原理

高斯滤波和均值滤波一样，都是利用一个掩膜和图像进行卷积求解。不同之处在于：均值滤波器的模板系数都是相同的为1，而高斯滤波器的模板系数，则随着距离模板中心的增大而系数减小（服从二维高斯分布）。所以，高斯滤波器相比于均值滤波器对图像个模糊程度较小，更能够保持图像的整体细节。

二维高斯分布

高斯分布公式终于要出场了！

                                                   f(x,y)=\frac{1}{(\sqrt{2\pi }\sigma )^{^{2}}}e^{-((x-ux)^{^{2}}+(y-uy)^{2})/2\sigma ^{^{2}}}

其中不必纠结于系数\frac{1}{(\sqrt{2\pi }\sigma )^{^{2}}},因为它只是一个常数！并不会影响互相之间的比例关系，并且最终都要进行归一化，所以在实际计算时我们是忽略它而只计算后半部分:

                                                  f(x,y)=e^{-((x-ux)^{^{2}}+(y-uy)^{2})/2\sigma ^{^{2}}}

其中(x,y)为掩膜内任一点的坐标，(ux,uy)为掩膜内中心点的坐标，在图像处理中可认为是整数；σ是标准差。

例如：要产生一个3×3的高斯滤波器模板，以模板的中心位置为坐标原点进行取样。模板在各个位置的坐标，如下所示（x轴水平向右，y轴竖直向下）  

这样，将各个位置的坐标带入到高斯函数中，得到的值就是模板的系数。
对于窗口模板的大小为 (2k+1)×(2k+1)，模板中各个元素值的计算公式如下：

                                                         
这样计算出来的模板有两种形式：小数和整数。

  • 小数形式的模板，就是直接计算得到的值，没有经过任何的处理；
  • 整数形式的，则需要进行归一化处理，将模板左上角的值归一化为1，具体介绍请看这篇博文。使用整数的模板时，需要在模板的前面加一个系数，系数为模板系数和的倒数。

生成高斯掩膜（小数形式）

知道了高斯分布原理，实现起来也就不困难了。

首先我们要确定我们生产掩模的尺寸wsize，然后设定高斯分布的标准差。生成的过程，我们首先根据模板的大小，找到模板的中心位置center。 然后就是遍历，根据高斯分布的函数，计算模板中每个系数的值。

最后模板的每个系数要除以所有系数的和。这样就得到了小数形式的模板。 

///////////////////////////////
//x，y方向联合实现获取高斯模板
//////////////////////////////
void generateGaussMask(cv::Mat& Mask,cv::Size wsize, double sigma){
	Mask.create(wsize,CV_64F);
	int h = wsize.height;
	int w = wsize.width;
	int center_h = (h - 1) / 2;
	int center_w = (w - 1) / 2;
	double sum = 0.0;
	double x, y;
	for (int i = 0; i < h; ++i){
		y = pow(i - center_h, 2);
		for (int j = 0; j < w; ++j){
			x = pow(j - center_w, 2);
			//因为最后都要归一化的，常数部分可以不计算，也减少了运算量
			double g = exp(-(x + y) / (2 * sigma*sigma));
			Mask.at<double>(i, j) = g;
			sum += g;
		}
	}
	Mask = Mask / sum;
}

3×3,σ=0.8的小数型模板：

 

σ的意义及选取

通过上述的实现过程，不难发现，高斯滤波器模板的生成最重要的参数就是高斯分布的标准差σ。标准差代表着数据的离散程度，如果σ较小，那么生成的模板的中心系数较大，而周围的系数较小，这样对图像的平滑效果就不是很明显；反之，σ较大，则生成的模板的各个系数相差就不是很大，比较类似均值模板，对图像的平滑效果比较明显。

来看下一维高斯分布的概率分布密度图：

于是我们有如下结论：σ越小分布越瘦高，σ越大分布越矮胖。

σ越大，分布越分散，各部分比重差别不大，于是生成的模板各元素值差别不大，类似于平均模板；
σ越小，分布越集中，中间部分所占比重远远高于其他部分，反映到高斯模板上就是中心元素值远远大于其他元素值，于是自然而然就相当于中间值得点运算。

 

基于OpenCV的c++实现

////////////////////////////
//按二维高斯函数实现高斯滤波
///////////////////////////
void GaussianFilter(cv::Mat& src, cv::Mat& dst, cv::Mat window){
	int hh = (window.rows - 1) / 2;
	int hw = (window.cols - 1) / 2;
	dst = cv::Mat::zeros(src.size(),src.type());
	//边界填充
	cv::Mat Newsrc;
	cv::copyMakeBorder(src, Newsrc, hh, hh, hw, hw, cv::BORDER_REPLICATE);//边界复制
	
	//高斯滤波
	for (int i = hh; i < src.rows + hh;++i){
		for (int j = hw; j < src.cols + hw; ++j){
			double sum[3] = { 0 };

			for (int r = -hh; r <= hh; ++r){
				for (int c = -hw; c <= hw; ++c){
					if (src.channels() == 1){
						sum[0] = sum[0] + Newsrc.at<uchar>(i + r, j + c) * window.at<double>(r + hh, c + hw);
					}
					else if (src.channels() == 3){
						cv::Vec3b rgb = Newsrc.at<cv::Vec3b>(i+r,j + c);
						sum[0] = sum[0] + rgb[0] * window.at<double>(r + hh, c + hw);//B
						sum[1] = sum[1] + rgb[1] * window.at<double>(r + hh, c + hw);//G
						sum[2] = sum[2] + rgb[2] * window.at<double>(r + hh, c + hw);//R
					}
				}
			}

			for (int k = 0; k < src.channels(); ++k){
				if (sum[k] < 0)
					sum[k] = 0;
				else if (sum[k]>255)
					sum[k] = 255;
			}
			if (src.channels() == 1)
			{
				dst.at<uchar>(i - hh, j - hw) = static_cast<uchar>(sum[0]);
			}
			else if (src.channels() == 3)
			{
				cv::Vec3b rgb = { static_cast<uchar>(sum[0]), static_cast<uchar>(sum[1]), static_cast<uchar>(sum[2]) };
				dst.at<cv::Vec3b>(i-hh, j-hw) = rgb;
			}

		}
	}

}

只处理单通道或者三通道图像，模板生成后，其滤波（卷积过程）就比较简单了。不过，这样的高斯滤波过程，其循环运算次数为m×n×ksize×ksize，其中m，n为图像的尺寸；ksize为高斯滤波器的尺寸。这样其时间复杂度为O(ksize2)，随滤波器的模板的尺寸呈平方增长，当高斯滤波器的尺寸较大时，其运算效率是极低的。为了，提高滤波的运算速度，可以将二维的高斯滤波过程分解开来。

 

分离实现高斯滤波

由于高斯函数的可分离性，尺寸较大的高斯滤波器可以分成两步进行：首先将图像在水平（竖直）方向与一维高斯函数进行卷积；然后将卷积后的结果在竖直（水平）方向使用相同的一维高斯函数得到的模板进行卷积运算。具体实现代码如下：

////////////////////////////////////
//分离计算实现高斯滤波，更加高效
///////////////////////////////////
void separateGaussianFilter(cv::Mat& src, cv::Mat& dst, int wsize, double sigma){
	//获取一维高斯滤波模板
	cv::Mat window;
	window.create(1 , wsize, CV_64F);
	int center = (wsize - 1) / 2;
	double sum = 0.0;
	for (int i = 0; i < wsize; ++i){
		double g = exp(-(pow(i - center, 2)) / (2 * sigma*sigma));
		window.at<double>(0, i) = g;
		sum += g;
	}
	window = window / sum;
	//std::cout << window << std::endl;

	//边界填充
	int boder = (wsize - 1) / 2;
	dst = cv::Mat::zeros(src.size(), src.type());
	cv::Mat Newsrc;
	cv::copyMakeBorder(src, Newsrc, boder, boder, boder, boder, cv::BORDER_REPLICATE);//边界复制

	//高斯滤波--水平方向
	for (int i = boder; i < src.rows + boder; ++i){
		for (int j = boder; j < src.cols + boder; ++j){
			double sum[3] = { 0 };

			for (int r = -boder; r <= boder; ++r){
					if (src.channels() == 1){
						sum[0] = sum[0] + Newsrc.at<uchar>(i, j + r) * window.at<double>(0, r + boder); //行不变列变
					}
					else if (src.channels() == 3){
						cv::Vec3b rgb = Newsrc.at<cv::Vec3b>(i, j +r);
						sum[0] = sum[0] + rgb[0] * window.at<double>(0, r + boder);//B
						sum[1] = sum[1] + rgb[1] * window.at<double>(0, r + boder);//G
						sum[2] = sum[2] + rgb[2] * window.at<double>(0, r + boder);//R
				}
			}
			for (int k = 0; k < src.channels(); ++k){
				if (sum[k] < 0)
					sum[k] = 0;
				else if (sum[k]>255)
					sum[k] = 255;
			}
			if (src.channels() == 1){
				dst.at<uchar>(i - boder, j - boder) = static_cast<uchar>(sum[0]);
			}
			else if (src.channels() == 3){
				cv::Vec3b rgb = { static_cast<uchar>(sum[0]), static_cast<uchar>(sum[1]), static_cast<uchar>(sum[2]) };
				dst.at<cv::Vec3b>(i - boder, j - boder) = rgb;
			}
		}
	}

	//高斯滤波--垂直方向
	//对水平方向处理后的dst边界填充
	cv::copyMakeBorder(dst, Newsrc, boder, boder, boder, boder, cv::BORDER_REPLICATE);//边界复制
	for (int i = boder; i < src.rows + boder; ++i){
		for (int j = boder; j < src.cols + boder; ++j){
			double sum[3] = { 0 };

			for (int r = -boder; r <= boder; ++r){
					if (src.channels() == 1){
						sum[0] = sum[0] + Newsrc.at<uchar>(i + r, j ) * window.at<double>(0, r + boder); //列不变行变
					}
					else if (src.channels() == 3){
						cv::Vec3b rgb = Newsrc.at<cv::Vec3b>(i + r, j);
						sum[0] = sum[0] + rgb[0] * window.at<double>(0, r + boder);//B
						sum[1] = sum[1] + rgb[1] * window.at<double>(0, r + boder);//G
						sum[2] = sum[2] + rgb[2] * window.at<double>(0, r + boder);//R
					}
				}
			for (int k = 0; k < src.channels(); ++k){
				if (sum[k] < 0)
					sum[k] = 0;
				else if (sum[k]>255)
					sum[k] = 255;
			}
			if (src.channels() == 1){
				dst.at<uchar>(i - boder, j - boder) = static_cast<uchar>(sum[0]);
			}
			else if (src.channels() == 3){
				cv::Vec3b rgb = { static_cast<uchar>(sum[0]), static_cast<uchar>(sum[1]), static_cast<uchar>(sum[2]) };
				dst.at<cv::Vec3b>(i - boder, j - boder) = rgb;
			}
	   	}	
	}
 }

首先得到一维高斯函数的模板，在卷积（滤波）的过程中，保持行不变，列变化，在水平方向上做卷积运算；接着在上述得到的结果上，保持列不边，行变化，在竖直方向上做卷积运算。 这样分解开来，算法的时间复杂度为O(ksize)，运算量和滤波器的模板尺寸呈线性增长。

 

测试：

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

	//暴力实现
	generateGaussMask(Mask, cv::Size(3, 3), 0.8);//获取二维高斯滤波模板
	std::cout << Mask << std::endl;
	GaussianFilter(src, dst1, Mask);

	//分离实现
	separateGaussianFilter( src, dst2, 7, 2);
	
	
	cv::namedWindow("src");
	cv::imshow("src", src);
	cv::namedWindow("暴力实现",CV_WINDOW_NORMAL);
	cv::imshow("暴力实现", dst1);
	cv::namedWindow("分离实现", CV_WINDOW_NORMAL);
	cv::imshow("分离实现", dst2);
	//cv::imwrite("I:\\Learning-and-Practice\\2019Change\\Image process algorithm\\Image Filtering\\GaussianFilter\\txt.jpg", dst2);
	cv::waitKey(0);
	return 0;
}

效果

参考：

https://www.zhihu.com/question/54918332（讲解很幽默，很通俗易懂）

https://www.cnblogs.com/wangguchangqing/p/6407717.html（讲解非常专业，很全面，有公式、图像、代码、效果展示）

C++实现高斯滤波算法
ByteEchoX的博客
09-13 468
首先，让我们了解一下高斯滤波的原理。高斯滤波通过将每个像素的值与周围像素的加权平均值进行替换来平滑图像。权重是根据高斯函数计算得出的，离中心像素越远的像素具有较低的权重。通过以上代码，您可以在C++环境中实现高斯滤波算法，并对图像进行平滑处理。此外，您还需要安装OpenCV库，并在编译时链接相应的库文件。在本文中，我们将使用C++语言实现高斯滤波算法，并提供相应的源代码。函数，它接受输入图像、内核大小和标准差作为参数，并返回高斯滤波后的图像。在上面的代码中，我们使用了OpenCV库来读取和处理图像。
C/C++ 高斯滤波算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-07 7734
卷积操作：将高斯核与原图像进行卷积操作，即将高斯核与图像上的每个像素点进行加权求和，求得滤波后的像素点值。权重的计算方式是将高斯核的每个元素与对应位置的像素值相乘，然后再将所有乘积相加。高斯滤波算法是一种常用的图像模糊算法，主要用于降低图像噪声和平滑图像细节。算法的基本思想是将每个像素点的值通过周围像素的权重平均计算得到。构建高斯核：根据高斯函数的定义，计算出指定标准差的高斯核，通常是一个正态分布矩阵。高斯核的大小一般是一个奇数，例如3x3、5x5等。一种常用的处理方式是通过对称复制或者补零来扩展边界。
高斯滤波 c++实现
weixin_54721788的博客
03-20 7670
高斯滤波 To smooth the image, a Gaussian filter kernel is convolved with the image. 高斯滤波的实质就是用高斯核对图片进行卷积操作 算法较为简单，在复杂度运行效率方面还有很多需要改进的 从RGB色转为灰度色算法（转） - carekee - 博客园 (cnblogs.com) 彩图转灰度图 Mat gray(Mat& image) { Mat dst = Mat::zeros(image.size(),
Graphviz 2.28.0图形可视化软件深入解析与应用
最新发布
weixin_42591413的博客
07-03 1145
Graphviz是一个开源的图形可视化软件。它使用DOT语言作为图形的描述语言，并且可以将DOT源文件转换成图形文件。Graphviz广泛应用于软件工程中的程序依赖关系分析，网络拓扑图的绘制，以及任何需要以图形方式表示结构或流程的场景。
高斯滤波及高斯卷积核C++实现
weixin_30807779的博客
08-24 1836
高斯滤波是一种线性平滑滤波，适用于消除高斯噪声，在图像处理的降噪、平滑中应用较多，特别是对抑制或消除服从正态分布的噪声非常有效。高斯滤波的过程其实就是对整幅图像进行加权平均操作的过程。滤波后图像上每一个像素的灰度值大小，由其本身和邻域内的其他像素共同决定。具体实现是：用一个大小为（2*N+1）的模板（或称卷积核、掩模）依次扫描图像中的每一个像素，用模板确定的邻域内...
高斯滤波的c++代码实现
01-19
分别利用一阶高斯与二阶高斯实现了图像的滤波算法，总体来说一阶高斯滤波会更加的快速
halcon图像预处理之图像平滑
qq_29187197的博客
09-18 9714
图像预处理就是在提取目标物之前对图像进行一些预处理，预处理通常包括两大方向：图像去噪和图像增强。 1. 图像去噪 （1）时域去噪 中值滤波：Media_Image 中值滤波的原理是拿特征区域在图像滑动，每一点（与特征区域的中点重合）的值为特征区域所覆盖的范围的中值 均值滤波·：mean_image 均值滤波的原理是拿特征区域在图像滑动，每一点（与特征区域的中点重合）的值为特征区域所覆盖的...
C++实现快速高斯滤波
保持分享欲
11-28 735
二维方式是根据kernel的大小以及sigma大小生成一个 size*size的卷积核，然后再做卷积。计算量是imgWidth * imgHeight * size * size，但如果用两个一维来替代，则计算量是imgWidth * imgHeight * size * 2,计算量大大减少。看这篇文章的道友想必对高斯滤波已经很熟悉，在此就不进行赘述了，也可以看看参考资料的文章回顾一下。此处的数据类型ImagePro可以根据自己的需求进行定义。
PCL 点云高斯滤波
纵马踏花向自由
10-03 651
高斯滤波 是一种平滑点云的常用方法，通过在点云上应用高斯核，减少噪声和尖锐边缘，得到更平滑的表面。它可以有效去除小尺度的噪声，保留较大结构的几何形状，因此常用于预处理阶段的点云数据平滑。
C++实现二维高斯滤波
qq_58381894的博客
08-16 467
C++实现二维高斯滤波。
基于C++的高斯滤波设计与实现
05-13
基于C++的高斯滤波设计与实现
数字图像高斯滤波C++源代码
06-15
对一幅数字图片进行高斯滤波，编程语言C/C++
c++滤波程序，含有中值、高斯、平滑滤波
03-09
中值、高斯、平滑滤波，c++编写，已调试。中值、高斯、平滑滤波，c++编写，已调试。
关于高斯滤波的详细原理解释及应用
10-09
有关高斯滤波的原理详细推导、解释，从图片的最基本的原理开始，到滤波模板的由来、以及怎么进行滤波进行详细阐述
opencv-12-高斯滤波-双边滤波(附C++代码实现)
Fxxk CPP
05-10 1107
开始之前 这几天由于自己的原因没有写, 一个是因为自己懒了, 一个是感觉这里遇到点问题不想往下写了, 我们先努力结束这个章节吧, 之前介绍了比较常用而且比较好理解的均值和中值滤波, 但是呢,在例程Smoothing Images, 还有给出的其他的滤波方式, 主要是高斯滤波和双边滤波, 我们这一次完结掉滤波与平滑的这个部分, 写的有点多了,反而不想再写了, 加油 目录 文章目录开始之前目录本文目标正文高斯滤波(Gaussian Filter)高斯滤波原理C++ 实现opencv 高斯滤波高斯滤波效果对比双
高斯滤波及其原理
热门推荐
weixin_43294620的博客
12-14 2万+
高斯滤波及其原理 一、高斯函数的基础 1.1 期望、方差与标准差 用来刻画随机变量某一方面特征的常数被称为随机变量的数字特征，其常用的有： 数学期望： ​ 在概率论和统计学中，数学期望（mean）是试验中每次可能结果的概率乘以其结果的总和，是最基本的数学特征之一。它反映随机变量平均取值的大小。 ​ 需要注意的是，期望值并不一定等同于常识中的“期望”——“期望值”也许与每一个结果都不相等。期望值是该变量输出值的平均数。期望值并不一定包含于变量的输出值集合里。大数定律表明，随着重复次数接近无穷大，数值的算术
c++实现高斯滤波器
qq_42026692的博客
03-02 681
//高斯滤波器实现 void gausBlur(cv::Mat srcImage, cv::Mat dstImage, int ksize, double sigma){ const double PI = 4.0 / (atan(1.0)); //定义卷积核大小 double **tempMatrix = new doublle*[ksize]; for(int i = 0; i < ksize; ++i){ tempMatrix [i] = new double[ksize]; }
高斯滤波——数字图像处理学习五（C++版）
weixin_43897847的博客
07-06 1990
一、高斯滤波简介 高斯滤波是一种线性平滑滤波，适用于消除高斯噪声。高斯噪声的概率密度函数服从高斯分布（正态分布），它是一类噪声。 高斯滤波广泛应用于图像处理的减噪过程。通俗的讲，高斯滤波就是对整幅图像进行加权平均。每一个像素点的值，都由其本身和邻域内的其他像素值经过加权平均后得到。高斯滤波的具体操作是：用一个模板（或称卷积、掩模）扫描图像中的每一个像素，用模板确定的邻域内像素的加权平均灰度值去替代模板中心像素点的值。 二、高斯滤波函数 1、一维高斯分布 2、二维...
c++实现kd树搜索，高斯滤波的点云去噪
06-17
<think>我们参考了引用[1][2][3]中关于使用PCL库进行高斯滤波的方法，但用户要求自己实现基于KD树的高斯滤波点云去噪。因此，我们将不使用PCL库，而是自行构建KD树并实现高斯滤波。高斯滤波的核心思想：对于点云中的每个点，我们搜索其邻域内的点（通常以某个半径或固定数量），然后使用高斯函数计算权重，对邻域内点的属性（如位置）进行加权平均，从而达到平滑去噪的效果。步骤：1.构建KD树：将点云数据组织成KD树结构，以便高效地进行邻域搜索。2.对于每个点，使用KD树搜索其邻域内的点（半径搜索）。3.计算每个邻域点的高斯权重（根据距离）。4.对邻域点的位置进行加权平均，得到该点的新位置。5.输出平滑后的点云。注意：高斯滤波中，高斯函数的标准差σ控制着平滑的程度。σ越大，平滑效果越明显，但细节损失可能越多。实现细节：-邻域搜索半径：通常取3σ，因为3σ之外的点权重非常小，可以忽略。-高斯函数：$w_i=\exp\left(-\frac{d_i^2}{2\sigma^2}\right)$，其中$d_i$是邻域点到中心点的距离。-归一化：加权平均时需要除以所有权重之和。我们将按照以下步骤编写代码：1.定义点云数据结构（这里我们使用简单的结构体表示点）。2.实现KD树的构建（包括节点结构和构建函数）。3.实现半径搜索（使用KD树加速）。4.对点云中的每个点进行高斯滤波。注意：在实际点云处理中，我们通常处理的是三维点，所以这里我们使用三维KD树（分割轴按x,y,z循环）。但为了简化，用户问题中可能要求的是二维（如图像），但根据引用，用户要求的是点云去噪，因此我们实现三维KD树。然而，引用[1][2][3]中都是处理三维点云，所以我们按三维点云处理。代码结构：步骤1：定义点类型和KD树节点步骤2：构建KD树步骤3：实现半径搜索步骤4：高斯滤波主函数由于点云可能很大，我们需要注意效率。KD树的构建是O(nlogn)，每个点的邻域搜索平均是O(logn)，因此总的时间复杂度约为O(nlogn)。注意：我们这里实现的是简单版本，没有考虑KD树的动态更新（点云滤波后点位置改变，但KD树是构建在原始点云上的）。因此，我们有两种选择：a)在原始点云上搜索邻域，但滤波后的新位置写入另一个点云（不改变原始点云结构）。b)如果允许改变原始点云，则需要重新构建KD树（但通常滤波是离线的，可以一次性处理）。我们采用方法a)，因为滤波过程中每个点的新位置依赖于原始点云的位置，所以不能一边滤波一边更新KD树。代码实现：1.定义点类型：```cpp#include<iostream>#include<vector>#include<cmath>#include<algorithm>#include<limits>structPoint3D{floatx,y,z;//可以添加其他属性，但滤波通常只处理位置Point3D():x(0),y(0),z(0){}Point3D(floatx,floaty,floatz):x(x),y(y),z(z){}};```2.KD树节点：```cppstructKdNode{Point3Dpoint;//点数据intaxis;//分割轴（0=x,1=y,2=z）KdNode*left;KdNode*right;KdNode():axis(0),left(nullptr),right(nullptr){}};```3.KD树构建函数（递归）：```cpp//用于比较点的坐标，按指定轴排序boolcompareByAxis(constPoint3D&a,constPoint3D&b,intaxis){if(axis==0)returna.x<b.x;elseif(axis==1)returna.y<b.y;elsereturna.z<b.z;}//构建KD树的递归函数KdNode*buildKdTree(std::vector<Point3D>&points,intdepth=0){if(points.empty())returnnullptr;intaxis=depth%3;//三维，所以轮流选择x,y,z轴//按当前轴排序，并找到中位数点automid=points.begin()+points.size()/2;std::nth_element(points.begin(),mid,points.end(),[axis](constPoint3D&a,constPoint3D&b){returncompareByAxis(a,b,axis);});KdNode*node=newKdNode();node->point=*mid;node->axis=axis;//递归构建左右子树std::vector<Point3D>leftPoints(points.begin(),mid);std::vector<Point3D>rightPoints(mid+1,points.end());node->left=buildKdTree(leftPoints,depth+1);node->right=buildKdTree(rightPoints,depth+1);returnnode;}```4.KD树半径搜索（递归）：```cpp//计算两点之间距离的平方floatsquaredDistance(constPoint3D&a,constPoint3D&b){floatdx=a.x-b.x;floatdy=a.y-b.y;floatdz=a.z-b.z;returndx*dx+dy*dy+dz*dz;}//半径搜索：搜索以target为中心，半径为radius范围内的点，存储在neighbors中voidradiusSearch(KdNode*node,constPoint3D&target,floatradius,std::vector<Point3D>&neighbors){if(node==nullptr)return;floatdist_sq=squaredDistance(node->point,target);//如果当前节点在半径内，加入结果集if(dist_sq<=radius*radius){neighbors.push_back(node->point);}//确定搜索方向intaxis=node->axis;floatdelta;if(axis==0)delta=target.x-node->point.x;elseif(axis==1)delta=target.y-node->point.y;elsedelta=target.z-node->point.z;//选择首先搜索的分支（根据分割面判断）KdNode*near=delta<=0?node->left:node->right;KdNode*far=delta<=0?node->right:node->left;radiusSearch(near,target,radius,neighbors);//如果分割面与搜索球相交（即|delta|<=radius），则另一侧也可能有满足条件的点if(delta*delta<=radius*radius){radiusSearch(far,target,radius,neighbors);}}```5.高斯滤波函数：```cpp//对点云进行高斯滤波std::vector<Point3D>gaussianFilter(conststd::vector<Point3D>&points,floatsigma,KdNode*root){floatradius=3*sigma;//设置搜索半径为3σstd::vector<Point3D>filteredPoints;filteredPoints.reserve(points.size());for(constauto&point:points){std::vector<Point3D>neighbors;radiusSearch(root,point,radius,neighbors);//搜索邻域点//如果邻域内没有其他点（或只有自己），则无法滤波，保留原位置（或可以特殊处理，这里我们保留原位置）if(neighbors.empty()){filteredPoints.push_back(point);continue;}//计算加权平均floattotalWeight=0.0f;Point3Dsum(0,0,0);for(constauto&neighbor:neighbors){floatdist_sq=squaredDistance(point,neighbor);//高斯权重：注意，这里点自身也在邻域内，也会被计算floatweight=exp(-dist_sq/(2*sigma*sigma));totalWeight+=weight;sum.x+=neighbor.x*weight;sum.y+=neighbor.y*weight;sum.z+=neighbor.z*weight;}//归一化if(totalWeight>0){sum.x/=totalWeight;sum.y/=totalWeight;sum.z/=totalWeight;filteredPoints.push_back(sum);}else{//如果权重和为零，则保留原始点（这种情况很少，但为了避免除0）filteredPoints.push_back(point);}}returnfilteredPoints;}```6.主函数示例：```cppintmain(){//假设我们有一组点云数据pointsstd::vector<Point3D>points=...;//从文件或传感器读取点云//构建KD树std::vector<Point3D>pointsCopy=points;//因为构建过程中会改变数组，所以用副本KdNode*root=buildKdTree(pointsCopy);//设置高斯滤波参数floatsigma=0.1f;//根据点云密度和噪声情况调整//进行高斯滤波std::vector<Point3D>filteredPoints=gaussianFilter(points,sigma,root);//释放KD树内存（这里省略，实际应用中需要写一个销毁函数）//输出或使用滤波后的点云filteredPointsreturn0;}```注意：-内存管理：构建的KD树在使用后需要销毁，避免内存泄漏。这里没有提供销毁函数，实际应用中需要添加。-效率：在点云非常大的情况下，可以考虑使用近似邻域搜索（如限制最多邻域点数）或使用并行计算（如对每个点的滤波独立，可以并行处理）。-参数调整：σ的选择很重要，需要根据点云中噪声的水平和点间距来调整。引用说明：我们参考了引用[1][2][3]中关于高斯滤波在点云处理中的应用，但本实现为自行编写，不依赖PCL库。相关问题：1.如何选择高斯滤波的σ参数？2.KD树在点云处理中还有哪些应用？3.除了高斯滤波，还有哪些点云去噪方法？4.如何评估点云去噪的效果？</think>### 基于 KD 树的高斯滤波点云去噪 C++ 实现 以下是使用 KD 树加速高斯滤波的点云去噪实现方案，结合了引用[1][2][3]中 PCL 库的核心思想，但采用原生 C++ 实现： #### 核心算法原理 1. **高斯滤波**：对每个点邻域内点加权平均，权重由高斯函数 $w_i = \exp\left(-\frac{d_i^2}{2\sigma^2}\right)$ 决定 2. **KD 树加速**：通过空间分割优化邻域搜索，复杂度从 $O(n^2)$ 降至 $O(n\log n)$ 3. **半径截断**：设置 $3\sigma$ 搜索半径，忽略权重小于 $0.1\%$ 的点[^4] #### 完整实现代码 ```cpp #include <vector> #include <cmath> #include <algorithm> #include <queue> // 点云数据结构 struct Point3D { float x, y, z; Point3D(float x=0, float y=0, float z=0) : x(x), y(y), z(z) {} }; // KD 树节点 struct KdNode { Point3D point; int axis; // 分割轴 (0=x, 1=y, 2=z) KdNode* left; KdNode* right; KdNode(Point3D p, int a) : point(p), axis(a), left(nullptr), right(nullptr) {} }; // KD 树构建 (递归) KdNode* buildKdTree(std::vector<Point3D>& points, int depth = 0) { if (points.empty()) return nullptr; int axis = depth % 3; // 三维空间循环选择轴 size_t mid = points.size() / 2; // 按当前轴排序并选取中位数 std::nth_element(points.begin(), points.begin() + mid, points.end(), [axis](const Point3D& a, const Point3D& b) { if (axis == 0) return a.x < b.x; if (axis == 1) return a.y < b.y; return a.z < b.z; }); KdNode* node = new KdNode(points[mid], axis); // 递归构建子树 auto mid_iter = points.begin() + mid; std::vector<Point3D> left(points.begin(), mid_iter); std::vector<Point3D> right(mid_iter + 1, points.end()); node->left = buildKdTree(left, depth + 1); node->right = buildKdTree(right, depth + 1); return node; } // 半径搜索 (使用KD树加速) void radiusSearch(KdNode* node, const Point3D& query, float radius, std::vector<Point3D>& neighbors) { if (!node) return; // 计算距离平方 float dx = query.x - node->point.x; float dy = query.y - node->point.y; float dz = query.z - node->point.z; float dist_sq = dx*dx + dy*dy + dz*dz; // 检查当前点是否在范围内 if (dist_sq <= radius*radius) { neighbors.push_back(node->point); } // 确定搜索方向 float delta; switch (node->axis) { case 0: delta = dx; break; case 1: delta = dy; break; default: delta = dz; } // 优先搜索更近的分支 KdNode* near = (delta <= 0) ? node->left : node->right; KdNode* far = (delta <= 0) ? node->right : node->left; radiusSearch(near, query, radius, neighbors); // 仅当分割面与查询球相交时才搜索远分支 if (delta*delta <= radius*radius) { radiusSearch(far, query, radius, neighbors); } } // 高斯滤波主函数 std::vector<Point3D> gaussianFilterKD( const std::vector<Point3D>& points, float sigma, int max_threads = 4) { // 1. 构建KD树 std::vector<Point3D> points_copy = points; // 不修改原始数据 KdNode* root = buildKdTree(points_copy); // 2. 设置滤波参数 const float radius = 3.0f * sigma; // 3σ原则[^4] std::vector<Point3D> filtered; filtered.reserve(points.size()); // 3. 对每个点进行滤波 for (const auto& query : points) { std::vector<Point3D> neighbors; radiusSearch(root, query, radius, neighbors); float total_weight = 0.0f; Point3D sum(0, 0, 0); for (const auto& p : neighbors) { // 计算距离平方 float dx = query.x - p.x; float dy = query.y - p.y; float dz = query.z - p.z; float dist_sq = dx*dx + dy*dy + dz*dz; // 计算高斯权重 float weight = exp(-dist_sq / (2 * sigma * sigma)); total_weight += weight; // 加权累加 sum.x += p.x * weight; sum.y += p.y * weight; sum.z += p.z * weight; } // 归一化处理 if (total_weight > 1e-6) { filtered.emplace_back( sum.x / total_weight, sum.y / total_weight, sum.z / total_weight ); } else { filtered.push_back(query); // 保留原始点 } } // 4. 释放KD树内存 (实际应用需实现析构) // destroyTree(root); return filtered; } ``` #### 关键参数说明 | 参数 | 推荐值 | 作用 | |------|--------|------| | `sigma` | 点云平均间距的1.5-2倍 | 控制平滑强度，值越大平滑效果越强 | | `radius` | $3\sigma$ | 搜索半径，覆盖99.7%的贡献区域 | | `max_threads` | CPU核心数 | 并行处理加速计算[^1] | #### 性能优化技巧 1. **并行计算**：使用 OpenMP 并行化滤波循环 ```cpp #pragma omp parallel for num_threads(max_threads) for (size_t i = 0; i < points.size(); ++i) ``` 2. **内存优化**：复用 KD 树结构，避免重复构建 3. **近似搜索**：限制最大邻域点数（如100个） 4. **批次处理**：对大规模点云分块处理 #### 算法特点 1. **保留特征**：相比均值滤波，能更好保持边缘特征[^4] 2. **自适应**：权重随距离指数衰减，符合物理特性 3. **鲁棒性**：对高斯噪声有理论最优去噪效果 > **注意**：实际点云处理中，可结合法线估计进行各向异性滤波，进一步提升特征保持能力[^2]。
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值