PCL_点云分割_基于法线微分分割

最新推荐文章于 2024-08-16 14:35:33 发布
最新推荐文章于 2024-08-16 14:35:33 发布
阅读量2.8k 收藏 14
点赞数 1
分类专栏： PCL学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhan_zhan1/article/details/104755582
版权

根据不同尺度下法向量特征的差异性，利用pcl::DifferenceOfNormalsEstimation实现点云分割，在处理有较大尺度变化的场景点云分割效果较好，利用不同支撑半径去估算同一点的两个单位法向量，单位法向量的差定义DoN特征。
在这里插入图片描述
DoN算法：
DoN特征源于观察到基于所给半径估计的表面法向量可以反映曲面的内在几何特征，因此这种分割算法是基于法线估计的，需要计算点云中某一点的法线估计。而通常在计算法线估计的时候都会用到邻域信息，很明显邻域大小的选取会影响法线估计的结果。而在DoN算法中，邻域选择的大小就被称为support radius（支持半径）。对点云中某一点选取不同的支持半径，即可以得到不同的法线估计，而法线之间的差异，就是是所说的法线差异。
在这里插入图片描述
代码例程：
（1）对于输入点云数据中的每一点，利用较大的支撑半径rl计算法向量；

（2）对于输入点云数据中的每一点，利用较大的支撑半径rs计算法向量；

（3）对于输入点云数据中的每一点，单位化每一点的法向量差异
（4）过滤所得的向量域（DoN特征向量），分割出目标尺寸对应的点云；

/**
* @file don_segmentation.cpp
* Difference of Normals Example for PCL Segmentation Tutorials.
*
* @author Yani Ioannou
* @date 2012-09-24
* @修改 2015-6-16
*/
#include <string>

#include <pcl/point_types.h>
#include <pcl/io/pcd_io.h>
#include <pcl/search/organized.h>
#include <pcl/search/kdtree.h>
#include <pcl/features/normal_3d_omp.h>
#include <pcl/filters/conditional_removal.h>
#include <pcl/segmentation/extract_clusters.h>
#include <pcl/segmentation/impl/extract_clusters.hpp>

#include <pcl/features/don.h>
// for visualization
#include <pcl/visualization/pcl_visualizer.h>

using namespace pcl;
using namespace std;


pcl::PointCloud<pcl::PointXYZRGB>::Ptr getColoredCloud(pcl::PointCloud<pcl::PointXYZ>::Ptr input_, std::vector <pcl::PointIndices> clusters_, float r, float g, float b)
{
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr colored_cloud;

	if (!clusters_.empty())
	{
		colored_cloud = (new pcl::PointCloud<pcl::PointXYZRGB>)->makeShared();

		srand(static_cast<unsigned int> (time(0)));
		std::vector<unsigned char> colors;
		for (size_t i_segment = 0; i_segment < clusters_.size(); i_segment++)
		{
			colors.push_back(static_cast<unsigned char> (rand() % 256));
			colors.push_back(static_cast<unsigned char> (rand() % 256));
			colors.push_back(static_cast<unsigned char> (rand() % 256));
		}

		colored_cloud->width = input_->width;
		colored_cloud->height = input_->height;
		colored_cloud->is_dense = input_->is_dense;
		for (size_t i_point = 0; i_point < input_->points.size(); i_point++)
		{
			pcl::PointXYZRGB point;
			point.x = *(input_->points[i_point].data);
			point.y = *(input_->points[i_point].data + 1);
			point.z = *(input_->points[i_point].data + 2);
			point.r = r;
			point.g = g;
			point.b = b;
			colored_cloud->points.push_back(point);
		}

		std::vector< pcl::PointIndices >::iterator i_segment;
		int next_color = 0;
		for (i_segment = clusters_.begin(); i_segment != clusters_.end(); i_segment++)
		{
			std::vector<int>::iterator i_point;
			for (i_point = i_segment->indices.begin(); i_point != i_segment->indices.end(); i_point++)
			{
				int index;
				index = *i_point;
				colored_cloud->points[index].r = colors[3 * next_color];
				colored_cloud->points[index].g = colors[3 * next_color + 1];
				colored_cloud->points[index].b = colors[3 * next_color + 2];
			}
			next_color++;
		}
	}

	return (colored_cloud);
}

int
main(int argc, char *argv[])
{
	int VISUAL = 1, SAVE = 0;//0 indicate shows nothing, 1 indicate shows very step output 2 only shows the final results
							 ///The smallest scale to use in the DoN filter.
	double scale1 = 5, mean_radius;

	///The largest scale to use in the DoN filter.
	double scale2 = 10;

	///The minimum DoN magnitude to threshold by
	double threshold = 0.3;

	///segment scene into clusters with given distance tolerance using euclidean clustering
	double segradius = 10;

/*	if (argc < 6)
	{
		cerr << "usage: " << argv[0] << " inputfile smallscale(5) largescale(10) threshold(0.1) segradius(1.5) VISUAL(1) SAVE(0)" << endl;
		cerr << "usage: " << "smallscale largescale  segradius :multiple with mean radius of point cloud " << endl;
		exit(EXIT_FAILURE);
	}

	/// the file to read from.
	string infile = argv[1];
	/// small scale
	istringstream(argv[2]) >> scale1;
	/// large scale
	istringstream(argv[3]) >> scale2;
	istringstream(argv[4]) >> threshold;   // threshold for DoN magnitude
	istringstream(argv[5]) >> segradius;   // threshold for radius segmentation
	istringstream(argv[6]) >> VISUAL;
	istringstream(argv[7]) >> SAVE;
*/	// Load cloud in blob format
	pcl::PointCloud<PointXYZRGB>::Ptr cloud(new pcl::PointCloud<PointXYZRGB>);
	pcl::io::loadPCDFile("region_growing_tutorial.pcd", *cloud);
	// Create a search tree, use KDTreee for non-organized data.
	pcl::search::Search<PointXYZRGB>::Ptr tree;
	if (cloud->isOrganized())
	{
		tree.reset(new pcl::search::OrganizedNeighbor<PointXYZRGB>());
	}
	else
	{
		tree.reset(new pcl::search::KdTree<PointXYZRGB>(false));
	}

	// Set the input pointcloud for the search tree
	tree->setInputCloud(cloud);
	//caculate the mean radius of cloud and mutilply with corresponding input
	{
		int size_cloud = cloud->size();
		int step = size_cloud / 10;
		double total_distance = 0;
		int i, j = 1;
		for (i = 0; i<size_cloud; i += step, j++)
		{
			std::vector<int> pointIdxNKNSearch(2);
			std::vector<float> pointNKNSquaredDistance(2);
			tree->nearestKSearch(cloud->points[i], 2, pointIdxNKNSearch, pointNKNSquaredDistance);
			total_distance += pointNKNSquaredDistance[1] + pointNKNSquaredDistance[0];
		}
		mean_radius = sqrt((total_distance / j));
		cout << "mean radius of cloud is： " << mean_radius << endl;
		scale1 *= mean_radius;
		scale2 *= mean_radius;
		segradius *= mean_radius;
	}


	if (scale1 >= scale2)
	{
		cerr << "Error: Large scale must be > small scale!" << endl;
		exit(EXIT_FAILURE);
	}

	// Compute normals using both small and large scales at each point
	pcl::NormalEstimationOMP<PointXYZRGB, PointNormal> ne;
	ne.setInputCloud(cloud);
	ne.setSearchMethod(tree);

	/**
	* NOTE: setting viewpoint is very important, so that we can ensure
	* normals are all pointed in the same direction!
	*/
	ne.setViewPoint(std::numeric_limits<float>::max(), std::numeric_limits<float>::max(), std::numeric_limits<float>::max());

	// calculate normals with the small scale
	cout << "Calculating normals for scale..." << scale1 << endl;
	pcl::PointCloud<PointNormal>::Ptr normals_small_scale(new pcl::PointCloud<PointNormal>);

	ne.setRadiusSearch(scale1);
	ne.compute(*normals_small_scale);

	// calculate normals with the large scale
	cout << "Calculating normals for scale..." << scale2 << endl;
	pcl::PointCloud<PointNormal>::Ptr normals_large_scale(new pcl::PointCloud<PointNormal>);

	ne.setRadiusSearch(scale2);
	ne.compute(*normals_large_scale);
	//visualize the normals
	if (VISUAL = 1)
	{
		cout << "click q key to quit the visualizer and continue！！" << endl;
		boost::shared_ptr<pcl::visualization::PCLVisualizer> MView(new pcl::visualization::PCLVisualizer("Showing normals with different scale"));
		pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZRGB> green(cloud, 0, 255, 0);
		int v1(0), v2(0);
		MView->createViewPort(0.0, 0.0, 0.5, 1.0, v1);
		MView->createViewPort(0.5, 0.0, 1.0, 1.0, v2);
		MView->setBackgroundColor(1, 1, 1);
		MView->addPointCloud(cloud, green, "small_scale", v1);
		MView->addPointCloud(cloud, green, "large_scale", v2);
		MView->addPointCloudNormals<pcl::PointXYZRGB, pcl::PointNormal>(cloud, normals_small_scale, 100, mean_radius * 10, "small_scale_normal");
		MView->addPointCloudNormals<pcl::PointXYZRGB, pcl::PointNormal>(cloud, normals_large_scale, 100, mean_radius * 10, "large_scale_normal");
		MView->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 3, "small_scale", v1);
		MView->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_OPACITY, 0.5, "small_scale", v1);
		MView->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 3, "large_scale", v1);
		MView->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_OPACITY, 0.5, "large_scale", v1);
		MView->spin();

	}
	// Create output cloud for DoN results
	PointCloud<PointNormal>::Ptr doncloud(new pcl::PointCloud<PointNormal>);
	copyPointCloud<PointXYZRGB, PointNormal>(*cloud, *doncloud);

	cout << "Calculating DoN... " << endl;
	// Create DoN operator
	pcl::DifferenceOfNormalsEstimation<PointXYZRGB, PointNormal, PointNormal> don;
	don.setInputCloud(cloud);
	don.setNormalScaleLarge(normals_large_scale);
	don.setNormalScaleSmall(normals_small_scale);

	if (!don.initCompute())
	{
		std::cerr << "Error: Could not intialize DoN feature operator" << std::endl;
		exit(EXIT_FAILURE);
	}

	// Compute DoN
	don.computeFeature(*doncloud);


	//print some differencense of curvature
	{
		cout << "You may have some sense about the input threshold（curvature） next time for your data" << endl;
		int size_cloud = doncloud->size();
		int step = size_cloud / 10;
		for (int i = 0; i<size_cloud; i += step)cout << " " << doncloud->points[i].curvature << " " << endl;

	}

	//show the differences of curvature with both large and small scale 
	if (VISUAL = 1)
	{
		cout << "click q key to quit the visualizer and continue！！" << endl;
		boost::shared_ptr<pcl::visualization::PCLVisualizer> MView(new pcl::visualization::PCLVisualizer("Showing the difference of curvature of two scale"));
		pcl::visualization::PointCloudColorHandlerGenericField<pcl::PointNormal> handler_k(doncloud, "curvature");
		MView->setBackgroundColor(1, 1, 1);
		MView->addPointCloud(doncloud, handler_k);
		MView->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 3);
		MView->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_OPACITY, 0.5);
		MView->spin();
	}


	// Save DoN features
	pcl::PCDWriter writer;
	if (SAVE == 1) writer.write<pcl::PointNormal>("don.pcd", *doncloud, false);


	// Filter by magnitude
	cout << "Filtering out DoN mag <= " << threshold << "..." << endl;

	// Build the condition for filtering
	pcl::ConditionOr<PointNormal>::Ptr range_cond(
		new pcl::ConditionOr<PointNormal>()
		);
	range_cond->addComparison(pcl::FieldComparison<PointNormal>::ConstPtr(
		new pcl::FieldComparison<PointNormal>("curvature", pcl::ComparisonOps::GT, threshold))
		);
	// Build the filter
	pcl::ConditionalRemoval<PointNormal> condrem;
	condrem.setCondition(range_cond);
	condrem.setInputCloud(doncloud);

	pcl::PointCloud<PointNormal>::Ptr doncloud_filtered(new pcl::PointCloud<PointNormal>);

	// Apply filter
	condrem.filter(*doncloud_filtered);

	doncloud = doncloud_filtered;

	// Save filtered output
	std::cout << "Filtered Pointcloud: " << doncloud->points.size() << " data points." << std::endl;

	if (SAVE == 1)writer.write<pcl::PointNormal>("don_filtered.pcd", *doncloud, false);


	//show the results of keeping relative small curvature points 
	if (VISUAL == 1)
	{
		cout << "click q key to quit the visualizer and continue！！" << endl;
		boost::shared_ptr<pcl::visualization::PCLVisualizer> MView(new pcl::visualization::PCLVisualizer("Showing the results of keeping relative small curvature points"));
		pcl::visualization::PointCloudColorHandlerGenericField<pcl::PointNormal> handler_k(doncloud, "curvature");
		MView->setBackgroundColor(1, 1, 1);
		MView->addPointCloud(doncloud, handler_k);
		MView->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 3);
		MView->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_OPACITY, 0.5);
		MView->spin();
	}

	// Filter by magnitude
	cout << "Clustering using EuclideanClusterExtraction with tolerance <= " << segradius << "..." << endl;

	pcl::search::KdTree<PointNormal>::Ptr segtree(new pcl::search::KdTree<PointNormal>);
	segtree->setInputCloud(doncloud);

	std::vector<pcl::PointIndices> cluster_indices;
	pcl::EuclideanClusterExtraction<PointNormal> ec;

	ec.setClusterTolerance(segradius);
	ec.setMinClusterSize(50);
	ec.setMaxClusterSize(100000);
	ec.setSearchMethod(segtree);
	ec.setInputCloud(doncloud);
	ec.extract(cluster_indices);
	if (VISUAL == 1)
	{//visualize the clustering results
		pcl::PointCloud <pcl::PointXYZ>::Ptr tmp_xyz(new pcl::PointCloud<pcl::PointXYZ>);
		copyPointCloud<pcl::PointNormal, pcl::PointXYZ>(*doncloud, *tmp_xyz);
		pcl::PointCloud <pcl::PointXYZRGB>::Ptr colored_cloud = getColoredCloud(tmp_xyz, cluster_indices, 0, 255, 0);

		cout << "click q key to quit the visualizer and continue！！" << endl;
		boost::shared_ptr<pcl::visualization::PCLVisualizer> MView(new pcl::visualization::PCLVisualizer("visualize the clustering results"));
		pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> rgbps(colored_cloud);
		MView->setBackgroundColor(1, 1, 1);
		MView->addPointCloud(colored_cloud, rgbps);
		MView->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 3);
		MView->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_OPACITY, 0.5);
		MView->spin();

	}
	if (SAVE == 1)
	{
		int j = 0;
		for (std::vector<pcl::PointIndices>::const_iterator it = cluster_indices.begin(); it != cluster_indices.end(); ++it, j++)
		{
			pcl::PointCloud<PointNormal>::Ptr cloud_cluster_don(new pcl::PointCloud<PointNormal>);
			for (std::vector<int>::const_iterator pit = it->indices.begin(); pit != it->indices.end(); ++pit)
			{
				cloud_cluster_don->points.push_back(doncloud->points[*pit]);
			}

			cloud_cluster_don->width = int(cloud_cluster_don->points.size());
			cloud_cluster_don->height = 1;
			cloud_cluster_don->is_dense = true;

			//Save cluster
			cout << "PointCloud representing the Cluster: " << cloud_cluster_don->points.size() << " data points." << std::endl;
			stringstream ss;
			ss << "don_cluster_" << j << ".pcd";
			writer.write<pcl::PointNormal>(ss.str(), *cloud_cluster_don, false);
		}

	}

}

原例程运行出错：
在这里插入图片描述
滤波函数重载参数错误，应该是版本原因，按照提示修改如上。
在这里插入图片描述
电脑处理速度太慢了，运行到上图就手动停止了计算。

杉木~
关注
专栏目录
CloudCompare&PCL 基于法线微分的分割
dayuhaitang1的博客
04-17 637
文章目录一、原理概述二、实现代码三、实现效果参考资料 一、原理概述 该方法是一种基于尺度的分割，由于原理相对简单，因此其计算效率很可观，可以处理规模较大的点云数据。其具体的思路为：对输入点云中的每一点ppp，使用不同的半径r1>r2r1>r2r1>r2去估算同一点的两种单位法向量n(p,r1),n(p,r2)n(p,r_1),n(p,r_2)n(p,r1​),n(p,r2​)，将两次获取的法向量做差，通过这样我们就可以获取到点云中每个点的DoN（Different of Normal）特
PointCloudLib 法线微分算法(Don)分割点云 C++版本
linux_huangyu的博客
06-24 74
原始点云不同尺度上计算法向量计算出don特征量，并以颜色显示在点云上可以看出平面中心的点 不涉及到周围点变化的点 特征量比较低，以红色表示边缘过渡剧烈的点，特征量比较高，以蓝色表示以Don算法特征量来作为阈值分割点云，可以分割出剧烈变化的点云欧式聚类 分割出不同的点云PCL（Point Cloud Library）中的法线微分算法（Difference of Normals, DoN）是一种常用于点云处理的分割技术。
PCL—基于法线微分的分割—DON
weixin_48240054的博客
02-08 913
基于法线微分的分割 1.根据不同尺度下法向量特征的差异性，利用pcl::DifferenceOfNormalsEstimation实现点云分割，在处理有较大尺度变化的场景点云分割效果较好，利用不同支撑半径去估算同一点的两个单位法向量，单位法向量的差定义DoN特征。 2.DoN算法： DoN特征源于观察到基于所给半径估计的表面法向量可以反映曲面的内在几何特征，因此这种分割算法是基于法线估计的，需要计算点云中某一点的法线估计。而通常在计算法线估计的时候都会用到邻域信息，很明显邻域大小的选取会影响法线估计的结果
PCL中分割方法的介绍（3）
weixin_34221112的博客
04-20 138
（3）上两篇介绍了关于欧几里德分割，条件分割，最小分割法等等还有之前就有用RANSAC法的分割方法，这一篇是关于区域生成的分割法， 区 域生长的基本 思想是： 将具有相似性的像素集合起来构成区域。首先对每个需要分割的区域找出一个种子像素作为生长的起点，然后将种子像素周围邻域中与种子有相同或相似性质的像素 （根据事先确定的生长或相似准则来确定）合并到种子像素所在的区域中。而新的像素继续作为种子向四周...
PCL 法线微分分割（Don）
最新发布
xhm01291212的博客
08-16 1006
对于点云中的每个点云点P，使用计算该点的两个法向量，然后用两个单位法向量的计算Don特征。如下图：图1为大半径计算得到的法向量；图2为小半径计算得到的法向量；图3为一大一小两个法向量计算得出的Don特征。步骤：（1）建KD树，计算点云平均密度（即点云点之间的平均邻近距离）。（2）用户依据平均密度设置两个尺度的Don半径，然后分别计算两个Don半径下的法向量。（3）通过公式：计算两个尺度下Don法向量的差异。（4）得到对应的法线微分差异，得出Don结果。
PCL中分割方法的介绍（2）
weixin_34235457的博客
04-20 204
（2）关于上一篇博文中提到的欧几里德分割法称之为标准的距离分离，当然接下来介绍其他的与之相关的延伸出来的聚类的方法，我称之为条件欧几里德聚类法，（是我的个人理解），这个条件的设置是可以由我们自定义的，因为除了距离检查，聚类的点还需要满足一个特殊的自定义的要求，就是以第一个点为标准作为种子点，候选其周边的点作为它的对比或者比较的对象，如果满足条件就加入到聚类的对象中，至于到底怎么翻译我也蒙了，只能这...
PCL法线微分DoN（Difference of Normal）
com1098247427的博客
10-15 423
法线微分
PCL学习笔记（三十）-- 基于法线微分的分割
不学会C++不改名
07-29 1782
一、简介 根据不同尺度下法向量特征的差异性，利用类pcl::DifferenceOfNormalEstimation实现点云分割，该方法基于尺度的分割方法，可以根据给定尺度分割出对应尺度下的点云。基于Dof的多尺度分割方法计算效率高，可处理规模庞大的3D点云。该算法在概念上虽然非常简单，但在处理有较大尺度变化的场景点云分割时却异常有效。对输入点云P的每一个点p，利用不同的半径r1 > rs去估算同一点的两个单位法向量。利用输入点云的单位法向量的差定义DoN特征。通常DoN定义如下： ...
PCL——点云分割（基于法线微分的分割——DON）
cbb8234078009的博客
06-21 4107
基于点云频率的滤波方法 DON点云滤波 DoN算法应该算是一种比较先进的点云滤波算法。分割本质上还是由欧式分割算法完成的。算法的目的是在去除点云低频滤波，低频信息（例如建筑物墙面，地面）往往会对分割产生干扰，高频信息（例如建筑物窗框，路面障碍锥）往往尺度上很小，直接采用 基于临近信息 的滤波器会将此类信息合并至墙面或路面中。所以DoN算法利用了多尺度空间的思想，算法如下： （1） 在小尺度上计算点云法线1 （2）在大尺度上计算点云法线2 （3）法线1-法线2 （4） 滤去3中值较小的点 （5） 欧式分割
PCL学习笔记(44)——基于法线微分的DoN算法详解
Christo的博客
09-24 2428
DON算法1 DoN算法算法原理1.1 动机1.2 原理解析1.3 实验结果1.3 其他2 源码测试2.1 源码2.2 程序主要过程3 其他 1 DoN算法算法原理 首先算法的核心是利用多尺度的方法来提高模型的分割效果，但是多尺度在二维图像中有较多的应用，三维点云图像中应用较少，在二维图像中，尺度空间的概念通常用通过高斯核的卷积逐渐平滑的图像来描述，这样的高斯尺度空间在图像处理和二维计算机视觉中有广泛的应用，如边缘锐化和兴趣点选择。而将比例空间的概念扩展到无组织三维点云是一项非常困难的任务，因为缺少常规的从
基于PCL的欧式距离分割方法
11-21
基于PCL1.7.1 使用欧式距离并考虑法向量对点云数据进行分割
PCL：基于法线微分分割
m0_71596228的博客
04-13 389
在三维点云处理中，法线微分分割（Difference of Normals，简称DoN）是一种常用的分割方法，用于将点云中的物体或者场景进行分割成不同的部分或者簇。通过计算点云中每个点的法线向量，以及法线向量的变化率（差异），可以有效地分割出具有明显形状差异的部分，从而实现对点云的分割和提取。
【PCL】基于法线的差异来分割点云
qq_40985985的博客
09-13 2295
基于法线差异来分割点云 1. 法向量的计算及可视化 法线又称法向量，因为在三维的点云中，根据一个点的K近邻点或者一个点的radius半径范围内的点拟合一个平面，而垂直这个平面且经过改点的线称之为法向量。 法向量是点云点到另一个点的有方向的线段，可视化法向量，其实就是可视化的这条有方向的线段。 上一节已经学习了 使用积分图像进行正态估计，得出点云的法向量，并将其可视化显示或者存储。 那法向量还可以做什么呢？这一节将来探索基于法向量的差异来分割点云； 在本教程中，我们将学习如何使用在pcl :: Differe
PCL 区域生长分割【2024最新版】
热门推荐
点云侠的博客
07-25 40万+
区域生长算法原理介绍、代码实现以及一个具体实验场景的应用案例进一步实现将分割结果的分类保存至本地文件夹。博客长期更新，最近一次更新时间为：2024年9月1日。
PCL点云分割：Region Growing Segmentation
AmbitiousRuralDog的博客
05-10 8351
背景：官方网站指导：http://www.pointclouds.org/documentation/tutorials/region_growing_segmentation.php#region-growing-segmentation
PCL_第12章_分割【1】
yamgyutou的博客
05-10 1676
平面分割——planar segmentation 点云操作中，平面的分割是经常遇到的问题，下面的例子就是如何利用PCL库提拟合出的参数，之后就可以过滤掉在平面附近的点云。 #include <iostream> #include <pcl/ModelCoefficients.h> #include <pcl/io/pcd_io.h> #include &...
PCL分割学习
qq_41345281的博客
11-23 1920
1.点云切割概述 点云分割是根据空间，几何和纹理等特征对点云进行划分，使得同一划分内的点云拥有相似的特征，点云的有效分割往往是许多应用的前提，例如逆向工作，CAD领域对零件的不同扫描表面进行分割，然后才能更好的进行空洞修复曲面重建，特征描述和提取，进而进行基于3D内容的检索，组合重用等。 2.PCL中常用的点云分割方法 Plane model segmentation (平面模型分割）:这个算法能...
PCL点云平面分割
在工作中感悟，在学习中进取
12-24 893
PCL点云平面分割 多平面分割方法封装 /** \brief 多平面分割 * \param[in] cloud_in 待分割点云 * \param[in] maxiter 最大迭代次数 * \param[in] dist 判断是否为平面内点的距离阈值 * \param[in] proportion 非平面点所占点云比例,[0,1]之间取值 * \param[out] out_plane_vect 分割后的平面模型点云集合 * \return 0成功，-1失败 */ int g_multPlaneSeg(pc
PCL_第12章_分割【2】
yamgyutou的博客
05-14 1153
上面是上图像处理课程大湘老师PPT中的一个图，其实，我觉得点云中的很多技术都是从较为成熟的图像处理中借鉴过来的。就譬如之前关键点检测用到的Hough变换，以及上一篇分割笔记中有关区域生长的分割，还有这篇的最小割分割。 六、最小割分割算法_min cut segmentation 参考：https://www.cnblogs.com/ironstark/p/5008258.html 最小割(min-cut)并不是一个什么很新鲜的东西。它早就用在网络规划，求解桥问题，图像分割等领域，被移植到点云分割上..
vs2019 pcl ransac点云分割算法
04-03
VS2019是一个集成开发环境，它不是用于点云分割的算法。 PCL（Point Cloud Library）是一个用于点云处理的开源库，它包含许多点云处理算法，包括RANSAC点云分割算法。 RANSAC（随机抽样一致性）是一种基于随机采样的参数估计方法，它能够从包含噪声和异常值的数据中估计出最优参数。在点云分割中，RANSAC可以用于拟合平面、圆等几何形状，从而将点云分割成不同的部分。 在使用PCL进行点云分割时，可以使用以下步骤： 1. 读取点云数据并转换为PCL格式。 2. 根据需要选择要分割的形状（例如平面、圆等）。 3. 使用RANSAC算法估计形状的参数。 4. 将点云分割成不同的部分。 5. 可以进一步对分割后的部分进行处理，例如聚类、表面重建等。 在VS2019中，可以使用PCL库进行点云分割的开发。可以使用C++编写代码，并使用VS2019进行编译和调试。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值