PCL学习笔记（三十）-- 基于法线微分的分割

最新推荐文章于 2024-04-13 11:34:52 发布
最新推荐文章于 2024-04-13 11:34:52 发布
阅读量1.7k 收藏 17
点赞数 1
分类专栏： PCL学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45006390/article/details/119211494
版权

一、简介

    根据不同尺度下法向量特征的差异性，利用类pcl::DifferenceOfNormalEstimation实现点云分割，该方法基于尺度的分割方法，可以根据给定尺度分割出对应尺度下的点云。基于Dof的多尺度分割方法计算效率高，可处理规模庞大的3D点云。该算法在概念上虽然非常简单，但在处理有较大尺度变化的场景点云分割时却异常有效。对输入点云P的每一个点p，利用不同的半径r1 > rs去估算同一点的两个单位法向量。利用输入点云的单位法向量的差定义DoN特征。通常DoN定义如下：

\Delta n(p, r_{s},r_{l})=\frac{n(p,r_{s})-n(p,r_{l})}{2}

    式中，rs，rl属于R，rs < rl，n(p, r)是在支撑半径为r的条件下，点p的表面法向量估计值。注意，该特征的输出值是单位法向量。因此，输出值是有方向的，该输出值的方向是关键特征，然而，该算子的范数提供了一个更易操作的量化方式，并且范围在0和1之间。

    DoN特征远于观察到基于所给半径估计的表面法向量反映了曲面的内在几何特征。尽管，有许多方法可以去估计曲面法向量，但是常用的方法主要有两种，第一种是根据支撑半径，另一种是根据固定的邻近点的数量。综合来看，支撑半径决定了法向量表示的曲面结构的尺度。

    利用DoN算子进行分割的步骤：

    （1）对于输入点云数据的每一点，利用较大的支撑半径rl计算法向量。

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

    （3）对于输入点云数据的每一点，单位话每一点的DoN特征。

    （4）过滤所得的向量域（DoN特征向量），分割出目标尺度对应的点云。

二、代码分析

    1）估计法向量严重影响了算法的整体计算效率，所以采用NormalEstimationOMP类，借助多处理器技术，该类充分利用OpenMP去使用多线程去计算法向量。也可以仅仅使用单线程的pcl::NormalEstimation类或者GPU加速的类pcl::gpu::NormalEstimation。无论使用哪个类，设定一个任意但固定的视点非常重要，在法向量估计过程中，视点用于判断法线的最终方向，唯一的视点保证了在不同尺度下估计的法向量都有一致的方向：

  // 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 ());//随机设定视点的坐标

    2）接下来我们分别设置大尺度和小尺度两种支撑半径，利用法向量估计类计算输入点云的法线。这里，请使用NormalEstimation.setRadiusSearch()方法而不是NormalEstimation.set-MaximumNeighbours方法进行法向量估计。因为，法向量估计如果仅依赖于紧邻点，而不是依赖支撑半径的完整曲面，是不是和DoN特征向量估计的。对于密度较大的输入点云，如果支撑半径设置的较大，计算法向量是计算量很大的任务。当进行大尺度的支撑半径搜索时，一个简单的提升计算速度的方法是对输入点云进行均匀下采样处理：

  // 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);

    3）这里利用pcl::DifferenceOfNormalsEstimation类计算DoN向量域，pcl::DifferenceOfNormals-Estimation类有三个参数。第一个参数是输入点云的类型，在本例中是pcl::PointXYZRGB。第二个参数是输入点云所计算出的法向量类型，在本例中是pcl::PointNormal。第三个参数是输出的向量域类型，在本例中，也是pcl::PointNormal类型。接下来设置输入点云，并计算输入点云的两个法向量，并利用pcl::DifferenceOfNormalsEstimation::initCompute()方法来核对计算特征向量的要求是否满足。最后利用pcl::DifferenceOfNormalsEstimation::computeFeature()方法计算DoN特征向量：

  // 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);

    4）当计算出每一个的DoN向量域，仍然保留完整的输入点云。为了开始分割，必须利用DoN特征向量的计算结果区分点云。常用的量化标准如下表所示：

点的向量域描述使用场景
float normal[3]DoN向量通过DoN相对角度分类
float curvatureDoN的二范数通过尺度效应进行滤波，较大的模对输入尺度参数有较大效应
float normal[0]DoN向量的x部分利用方向尺度进行滤波，例如建筑外墙可能有较大的DoN向量的x部分、y部分或者z部分
float normal[1]DoN向量的y部分
float normal[2]DoN向量的z部分

    接下来，利用条件输入函数设定上述的量化标准，对输入点云进行滤波，滤波后的点云与输入尺度参数有极大的关联性：

  // 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);

    5）整体代码如下：

#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>
#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].r = colors[3 * next_color + 1];
				colored_cloud->points[index].r = colors[3 * next_color + 2];
			}
			next_color++;
		}
	}
	return(colored_cloud);
}

int main(int argc, char* argv[])
{
	int VISUAL = 1, SAVE = 0;
	double segRadius, mean_radius, threshold, scale1, scale2;
	if (argc < 6)
	{
		cerr << "usage: " << argv[0] << " inputfile smallscale(5) largescale(10) threshold(0.1) segradius(1.5) VISUAL(1) SAVE(0)" << std::endl;
		cerr << "usage: " << "smallscale largescale segradius :multiple with mean radius of point cloud" << std::endl;
		exit(EXIT_FAILURE);
	}

	string infile = argv[1];
	istringstream(argv[2]) >> scale1;																//利用较小尺度辅助计算点集的法向量
	istringstream(argv[3]) >> scale2;																//利用较大尺度辅助计算点集的法向量
	istringstream(argv[4]) >> threshold;
	istringstream(argv[5]) >> segRadius;															//设置聚类半径
	istringstream(argv[6]) >> VISUAL;																//设置可视化标志位
	istringstream(argv[7]) >> SAVE;																	//设置存储文件标志位

	pcl::PointCloud<PointXYZRGB>::Ptr cloud(new pcl::PointCloud<PointXYZRGB>);						//加载点云
	pcl::io::loadPCDFile(infile.c_str(), *cloud);
	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));
	}
	tree->setInputCloud(cloud);																		//初始化kdtree
	{
		int size_cloud = cloud->size();																//设置点云的大小
		int step = size_cloud / 10;																	//设置kdtree的搜索步长
		double total_distance = 0;
		int i, j = 1;
		for (i = 0;i < size_cloud;i += step, j++)
		{
			std::vector<int> pointIdxNKNSearch(2);													//设置k近邻搜索索引的动态数组
			std::vector<float> pointNKNSquaredDistance(2);											//设置k近邻搜索的距离的动态数组
			tree->nearestKSearch(cloud->points[i], 2, pointIdxNKNSearch, pointNKNSquaredDistance);	//利用kdtree进行k近邻搜索
			total_distance += pointNKNSquaredDistance[1] + pointNKNSquaredDistance[0];				//计算k近邻搜索的距离之和
		}
		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);
	}

	pcl::NormalEstimationOMP<PointXYZRGB, PointNormal> ne;											//使用NormalEstimationOMP类，利用多线程进行计算
	ne.setInputCloud(cloud);
	ne.setSearchMethod(tree);

	ne.setViewPoint(std::numeric_limits<float>::max(), std::numeric_limits<float>::max(), std::numeric_limits<float>::max());

	cout << "Caculating normals for scale..." << scale1 << endl;									//利用较小尺度辅助半径计算输入点集的法向量
	pcl::PointCloud<PointNormal>::Ptr normals_small_scale(new pcl::PointCloud<PointNormal>);

	ne.setRadiusSearch(scale1);
	ne.compute(*normals_small_scale);
	
	cout << "Caculating normals for scale..." << scale2 << endl;									//利用较大尺度辅助半径计算输入点集的法向量
	pcl::PointCloud<PointNormal>::Ptr normals_large_scale(new pcl::PointCloud<PointNormal>);

	ne.setRadiusSearch(scale2);
	ne.compute(*normals_large_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 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);												//初始化不同的视口v1与v2
		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();
	}

	PointCloud<PointNormal>::Ptr doncloud(new pcl::PointCloud<PointNormal>);
	copyPointCloud<PointXYZRGB, PointNormal>(*cloud, *doncloud);									//计算DoN向量域

	cout << "Caculating DoN..." << endl;
	pcl::DifferenceOfNormalsEstimation<PointXYZRGB, PointNormal, PointNormal>don;					//计算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);
	}
	don.computeFeature(*doncloud);

	{
		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;
	}

	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();
	}

	pcl::PCDWriter writer;
	if (SAVE = 1)																					//判断是否保存don文件
		writer.write<pcl::PointNormal>("don.pcd", *doncloud, false);
	cout << "Filtering out DoN mag <= " << threshold << "..." << endl;

	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)));
	
	pcl::ConditionalRemoval<PointNormal> condrem;													//初始化一个条件滤波器
	condrem.setCondition(range_cond);																//设置滤波条件
	condrem.setInputCloud(doncloud);																//将DoN后的点云作为输入
	pcl::PointCloud<PointNormal>::Ptr doncloud_filtered(new pcl::PointCloud<PointNormal>);
	condrem.filter(*doncloud_filtered);																//执行滤波
	doncloud = doncloud_filtered;
	std::cout << "Filted PointCloud: " << doncloud->points.size() << " data points." << std::endl;

	if (SAVE == 1)
		writer.write<pcl::PointNormal>("don_filtered.pcd", *doncloud, false);						//保存滤波后的文件

	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();
	}

	cout << "Clustering using EuclideanClusterExtration 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)																					//欧式聚类以后进行可视化
	{
		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;

			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);
		}
	}
}

三、编译结果：

    1）曲率信息可视化结果：

    2）利用曲率分类结果可视化

    3）进一步欧式聚类分割结果

看到我请叫我学C++
关注
专栏目录
PointCloudLib 法线微分算法(Don)分割点云 C++版本
linux_huangyu的博客
06-24 71
原始点云不同尺度上计算法向量计算出don特征量，并以颜色显示在点云上可以看出平面中心的点 不涉及到周围点变化的点 特征量比较低，以红色表示边缘过渡剧烈的点，特征量比较高，以蓝色表示以Don算法特征量来作为阈值分割点云，可以分割出剧烈变化的点云欧式聚类 分割出不同的点云PCL（Point Cloud Library）中的法线微分算法（Difference of Normals, DoN）是一种常用于点云处理的分割技术。
PCL——点云分割（基于法线微分的分割——DON）
cbb8234078009的博客
06-21 4089
基于点云频率的滤波方法 DON点云滤波 DoN算法应该算是一种比较先进的点云滤波算法。分割本质上还是由欧式分割算法完成的。算法的目的是在去除点云低频滤波，低频信息（例如建筑物墙面，地面）往往会对分割产生干扰，高频信息（例如建筑物窗框，路面障碍锥）往往尺度上很小，直接采用 基于临近信息 的滤波器会将此类信息合并至墙面或路面中。所以DoN算法利用了多尺度空间的思想，算法如下： （1） 在小尺度上计算点云法线1 （2）在大尺度上计算点云法线2 （3）法线1-法线2 （4） 滤去3中值较小的点 （5） 欧式分割
PCL—基于法线微分的分割—DON
weixin_48240054的博客
02-08 910
基于法线微分的分割 1.根据不同尺度下法向量特征的差异性，利用pcl::DifferenceOfNormalsEstimation实现点云分割，在处理有较大尺度变化的场景点云分割效果较好，利用不同支撑半径去估算同一点的两个单位法向量，单位法向量的差定义DoN特征。 2.DoN算法： DoN特征源于观察到基于所给半径估计的表面法向量可以反映曲面的内在几何特征，因此这种分割算法是基于法线估计的，需要计算点云中某一点的法线估计。而通常在计算法线估计的时候都会用到邻域信息，很明显邻域大小的选取会影响法线估计的结果
PCL_点云分割_基于法线微分分割
zhan_zhan1的博客
03-09 2884
根据不同尺度下法向量特征的差异性，利用pcl::DifferenceOfNormalsEstimation实现点云分割，在处理有较大尺度变化的场景点云分割效果较好，利用不同支撑半径去估算同一点的两个单位法向量，单位法向量的差定义DoN特征。 DoN算法： DoN特征源于观察到基于所给半径估计的表面法向量可以反映曲面的内在几何特征，因此这种分割算法是基于法线估计的，需要计算点云中某一点的法线估计。...
CloudCompare&PCL 基于法线微分的分割
dayuhaitang1的博客
04-17 632
文章目录一、原理概述二、实现代码三、实现效果参考资料 一、原理概述 该方法是一种基于尺度的分割，由于原理相对简单，因此其计算效率很可观，可以处理规模较大的点云数据。其具体的思路为：对输入点云中的每一点ppp，使用不同的半径r1&gt;r2r1&gt;r2r1&gt;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）特
pcl-1.12 pcl-1.12 pcl-1.12 pcl-1.12
06-09
pcl-1.12 pcl-1.12 pcl-1.12 pcl-1.12
PCL-1.12.1-AllInOne-msvc2019-win64.exe
08-02
PCL-1.12.1
PCL：实现法线微分DoN分割（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
10-06 138
PCL：实现法线微分DoN分割（附完整源码）
基于PCL的欧式距离分割方法
11-21
基于PCL1.7.1 使用欧式距离并考虑法向量对点云数据进行分割
PCL点云处理之基于法向量分割提取平面点和立面点（三十七）
weixin_44329757的博客
01-03 2450
基于法向量的点云分割
PCL学习笔记(34)——基于法线的边界提取
Christo的博客
09-21 746
源码 #include <iostream&gt; #include <pcl/console/parse.h&gt; #include <pcl/filters/extract_indices.h&gt; #include <pcl/io/pcd_io.h&gt; #include <pcl/point_types.h&gt; #include <pcl/visualization/pcl_visualizer.h&gt; #include <boost/thr
一种基于法向量的点云分割方法
dayuhaitang1的博客
03-05 1684
文章目录一、简介二、代码实现三、修改（另一种测试）四、小结 一、简介 因为之前看过一篇关于使用法向量进行点云分割的文章，公式如下所示，感觉有点意思，所以也就顺手实现一下看看效果。其思路也比较简单，就是根据邻近点与当前点法向量之间的差分平均值来与我们实现设置好的阈值相比较，如果大于这个阈值就属于一类地物，反之则属于另一类地物。由于手上也没啥数据，所以就以pcl中的示例数据来测试了一下。 二、代码实现 main.m clc clear close all; %获取点云数据 [fileName,pa
PCL：基于法线微分分割
最新发布
m0_71596228的博客
04-13 384
在三维点云处理中，法线微分分割（Difference of Normals，简称DoN）是一种常用的分割方法，用于将点云中的物体或者场景进行分割成不同的部分或者簇。通过计算点云中每个点的法线向量，以及法线向量的变化率（差异），可以有效地分割出具有明显形状差异的部分，从而实现对点云的分割和提取。
【PCL】基于法线的差异来分割点云
qq_40985985的博客
09-13 2289
基于法线差异来分割点云 1. 法向量的计算及可视化 法线又称法向量，因为在三维的点云中，根据一个点的K近邻点或者一个点的radius半径范围内的点拟合一个平面，而垂直这个平面且经过改点的线称之为法向量。 法向量是点云点到另一个点的有方向的线段，可视化法向量，其实就是可视化的这条有方向的线段。 上一节已经学习了 使用积分图像进行正态估计，得出点云的法向量，并将其可视化显示或者存储。 那法向量还可以做什么呢？这一节将来探索基于法向量的差异来分割点云； 在本教程中，我们将学习如何使用在pcl :: Differe
PCL 法向量夹角约束的欧式聚类分割
点云侠的博客
04-05 1010
目前广为流传的欧式聚类都是不考虑法向量的。但是，完整版的点云欧式聚类算法是可以附带法向量夹角约束的。具体使用方法见本文！！！
法线差异分割（Difference of Normals Based Segmentation）
席小贱
12-06 2829
Difference of Normals Based Segmentation 学习《Difference of Normals as a Multi-scale Operator in Unorganized Point Clouds》 提起这个Difference of Normals Based Segmentation（DoN）就不得不提一下图像处理里面经常提到的尺度空间的概念，...
PCL点云处理之基于法向差异的图像分割（九十七）
weixin_44329757的博客
01-30 879
点云法线差异分割
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值