Project2 分段切割路面，只取一个种子点

于 2020-04-08 14:54:34 发布
阅读量98 收藏
点赞数
分类专栏： 0毕设
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36477987/article/details/105386187
版权

分段切割路面，只取一个种子点

#include <pcl/visualization/cloud_viewer.h>
#include <iostream>//标准C++库中的输入输出类相关头文件。
#include <pcl/io/io.h>
#include <pcl/io/pcd_io.h>//pcd 读写类相关的头文件。
#include <pcl/io/ply_io.h>
#include <pcl/point_types.h> //PCL中支持的点类型头文件。
#include <pcl/octree/octree.h>
#include<fstream>  
#include <string>  
#include <vector> 
#include <LasOperator.h> 
#include <liblas/liblas.hpp>
#include <pcl/filters/passthrough.h>
#include <pcl/segmentation/region_growing.h>
#include <pcl/search/search.h>
#include <pcl/search/kdtree.h>
#include <pcl/features/normal_3d.h>

using namespace std;

void loadLasFile(string s, pcl::PointCloud<pcl::PointXYZRGB> &cloud);
void loadLasFile(string s, pcl::PointCloud<pcl::PointXYZRGB> &cloud) {
	/*
		*读取las文件
		*/
	std::ifstream ifs(s, std::ios::in | std::ios::binary); // 打开las文件
	liblas::ReaderFactory f;
	liblas::Reader reader = f.CreateWithStream(ifs); // 读取las文件

	unsigned long int nbPoints = reader.GetHeader().GetPointRecordsCount();//获取las数据点的个数

	cloud.width = nbPoints;	//保证与las数据点的个数一致	
	cloud.height = 1;
	cloud.is_dense = false;
	cloud.points.resize(cloud.width * cloud.height);

	int i = 0;
	uint16_t r1, g1, b1;
	int r2, g2, b2;
	uint32_t rgb;
	while (reader.ReadNextPoint()) {
		// 获取las数据的x，y，z信息
		cloud.points[i].x = (reader.GetPoint().GetX());
		cloud.points[i].y = (reader.GetPoint().GetY());
		cloud.points[i].z = (reader.GetPoint().GetZ());

		//获取las数据的r，g，b信息
		r1 = (reader.GetPoint().GetColor().GetRed());
		g1 = (reader.GetPoint().GetColor().GetGreen());
		b1 = (reader.GetPoint().GetColor().GetBlue());
		r2 = ceil(((float)r1 / 65536)*(float)256);
		g2 = ceil(((float)g1 / 65536)*(float)256);
		b2 = ceil(((float)b1 / 65536)*(float)256);
		rgb = ((int)r2) << 16 | ((int)g2) << 8 | ((int)b2);
		cloud.points[i].rgb = *reinterpret_cast<float*>(&rgb);

		i++;
	}
}

int main() {

	/**
		定义变量
	*/
	//输入点云，轨迹线，保存种子
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointCloud<pcl::PointXYZ>::Ptr trail(new pcl::PointCloud<pcl::PointXYZ>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr result(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr seedCloud(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr colored(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr tempCloud(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointXYZRGB tempPnt;
	//变量
	float x1, y1, x2, y2, a1, a2, a3, b11, b22, b3;//向量1，a,b为轨迹线上2点
	x1 = y1 = a1 = a2 = a3 = b11 = b22 = b3 = 0;
	x2 = 0; y2 = 1;

	float r = 1;	//半径2
	//float SmoothnessThreshold = 0.37;//3.0 0.37
	//float CurvatureThreshold = 0.01;    //设置曲率的阈值1.0

	//读取输入电云
	cout << "读取点云" << endl;
	//pcl::io::loadPCDFile("sample100.pcd", *cloud);
	loadLasFile("sample10.las", *cloud);
	//读取轨迹线
	cout << "读取轨迹线" << endl;
	pcl::io::loadPCDFile("trail.pcd", *trail);
	cout << "原始点数: " << cloud->width << " \t" << "轨迹线点数: " << trail->width << endl;

	//cloud构建八叉树
	cout << "构建八叉树" << endl;
	float resolution = 128.0f;
	pcl::octree::OctreePointCloudSearch<pcl::PointXYZRGB> octree(resolution);
	octree.setInputCloud(cloud);
	octree.addPointsFromInputCloud();

	std::vector<int>pointIdx;
	std::vector<int>seedIdx;

	/**
		开始循环
	*/
	for (size_t i = 0; i < trail->points.size(); i += 20) {//cloud1->points.size()		cloud1->points.size()+500   500
		cout << "-------------------------------------------------------------" << endl;
		a1 = trail->points[i].x;
		a2 = trail->points[i].y;//cloud1->points[i+8].y
		a3 = trail->points[i].z;
		b11 = trail->points[i + 20].x;
		b22 = trail->points[i + 20].y;//cloud1->points[i+12].y
		b3 = trail->points[i + 20].z;
		x1 = a1 - b11;
		y1 = a2 - b22;
		float cosa = (x1*x2 + y1 * y2) / (sqrt(x1*x1 + y1 * y1) + sqrt(x2*x2 + y2 * y2));
		float sina = sqrt(1 - cosa * cosa);
		float range = r / sina;

		//分段切割种子点
		Eigen::Vector3f n(a1-r, min(a2, b22), -100000);//0xc0c0c0c0	0x3f3f3f3f
		Eigen::Vector3f m(a1+r, max(a2, b22) - 0.001, min(a3, b3));
		octree.boxSearch(n, m, pointIdx);
		cout << i<<"\t这段种子数：\t" << pointIdx.size() << endl;
		pcl::copyPointCloud(*cloud, pointIdx, *tempCloud);
		*seedCloud += *tempCloud;

		seedIdx.insert(seedIdx.end(),pointIdx.begin(),pointIdx.end());
	}

	// 创建空的tree   设置搜索的方式或者说是结构
	pcl::search::Search<pcl::PointXYZRGB>::Ptr tree = boost::shared_ptr<pcl::search::Search<pcl::PointXYZRGB> >(new pcl::search::KdTree<pcl::PointXYZRGB>);
	//求法线
	//创建一个normal点云
	pcl::PointCloud <pcl::Normal>::Ptr normals(new pcl::PointCloud <pcl::Normal>);
	pcl::NormalEstimation<pcl::PointXYZRGB, pcl::Normal> normal_estimator;
	normal_estimator.setSearchMethod(tree);
	normal_estimator.setInputCloud(cloud);
	normal_estimator.setKSearch(50);
	normal_estimator.compute(*normals);

	//创造区域生长分割对象	聚类对象<点，法线>
	pcl::RegionGrowing<pcl::PointXYZRGB, pcl::Normal> reg; //首先建立reg寄存器(区域曾长的对象）
	reg.setMinClusterSize(50);  //最小的聚类的点数(小于这参数的平面被忽略不计）
	reg.setMaxClusterSize(30000000);  //最大的(一般随便设置）
	reg.setSearchMethod(tree);    //搜索方式(采用的默认是K—d树法）
	reg.setNumberOfNeighbours(30); //设置搜索的邻域点的个数，周围多少个点决定这是一个平面(决定容错率，设置大时有倾斜也可接受，设置小时检测到的平面会很小）
	reg.setInputCloud(cloud);         //输入点
									  //reg.setIndices (indices);
	reg.setInputNormals(normals);     //输入的法线

	reg.setSmoothnessThreshold(0.37 / 180.0 * M_PI);//3.0 设置平滑度(设置两个法线在多大夹角内可当做是共面的）SmoothnessThreshold  0.37
	reg.setCurvatureThreshold(0.01);//CurvatureThreshold

	std::vector <pcl::PointIndices> clusters;
	pcl::PointIndices cluster;

	reg.extract(clusters);
	reg.getSegmentFromPoint(seedIdx[0], cluster);
	cout << "取得的种子是：" << seedIdx[0] << "\t生长后点数：" << cluster.indices.size() << endl;
	cout << "种子点" << cloud->points[seedIdx[0]].x << "\t" << cloud->points[seedIdx[0]].y << "\t" << cloud->points[seedIdx[0]].z << "\t" << endl;
	cout << "-------------------------------------------------------------" << endl;

	//pcl::copyPointCloud(*cloud, cluster, *result);
	pcl::copyPointCloud(*cloud, cluster, *tempCloud);
	*result += *tempCloud;

	colored = reg.getColoredCloud();

	cout << "上色的点云: colored.pcd" << endl;
	pcl::io::savePCDFileASCII("0colored.pcd", *colored);
	cout << "保存成功" << endl;

	cout << "生长后的点云: result.pcd" << endl;
	pcl::io::savePCDFileASCII("0result.pcd", *result);
	cout << "保存成功" << endl;

	cout << "切割后的点云: seedCloud.pcd" << endl;
	pcl::io::savePCDFileASCII("0seedCloud.pcd", *seedCloud);
	cout << "保存成功" << endl;

	return 0;
}

古老版

#include <pcl/visualization/cloud_viewer.h>
#include <iostream>//标准C++库中的输入输出类相关头文件。
#include <pcl/io/io.h>
#include <pcl/io/pcd_io.h>//pcd 读写类相关的头文件。
#include <pcl/io/ply_io.h>
#include <pcl/point_types.h> //PCL中支持的点类型头文件。
#include <pcl/octree/octree.h>
#include<fstream>  
#include <string>  
#include <vector> 
#include <LasOperator.h> 
#include <liblas/liblas.hpp>
#include <pcl/filters/passthrough.h>
#include <pcl/segmentation/region_growing.h>
#include <pcl/search/search.h>
#include <pcl/search/kdtree.h>
#include <pcl/features/normal_3d.h>

using namespace std;


int main() {

	/**
		定义变量
	*/
	//输入点云，轨迹线，保存种子
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud1(new pcl::PointCloud<pcl::PointXYZ>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud2(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud3(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr part(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointXYZRGB tempPnt;
	//变量
	float x1, y1, x2, y2, a1, a2, a3, b11, b22, b3;//向量1，a,b为轨迹线上2点
	x1 = y1 = a1 = a2 = a3 = b11 = b22 = b3 = 0;
	x2 = 0; y2 = 1;

	float r = 1;	//半径2
	float SmoothnessThreshold =3 ;//3.0 0.37
	float CurvatureThreshold = 1;    //设置曲率的阈值1.0

	/*
	*读取las文件，打开点云，初始化octree
	*/
	std::ifstream ifs("2.las", std::ios::in | std::ios::binary); // 打开las文件
	liblas::ReaderFactory f;
	liblas::Reader reader = f.CreateWithStream(ifs); // 读取las文件

	unsigned long int nbPoints = reader.GetHeader().GetPointRecordsCount();//获取las数据点的个数

	cloud->width = nbPoints;	//保证与las数据点的个数一致	
	cloud->height = 1;
	cloud->is_dense = false;
	cloud->points.resize(cloud->width * cloud->height);

	part->width = 0;
	cloud->height = 1;
	cloud->is_dense = false;
	cloud->points.resize(cloud->width * cloud->height);

	int i = 0;
	uint16_t r1, g1, b1;
	int r2, g2, b2;
	uint32_t rgb;
	while (reader.ReadNextPoint()) {
		// 获取las数据的x，y，z信息
		cloud->points[i].x = (reader.GetPoint().GetX());
		cloud->points[i].y = (reader.GetPoint().GetY());
		cloud->points[i].z = (reader.GetPoint().GetZ());

		//获取las数据的r，g，b信息
		r1 = (reader.GetPoint().GetColor().GetRed());
		g1 = (reader.GetPoint().GetColor().GetGreen());
		b1 = (reader.GetPoint().GetColor().GetBlue());
		r2 = ceil(((float)r1 / 65536)*(float)256);
		g2 = ceil(((float)g1 / 65536)*(float)256);
		b2 = ceil(((float)b1 / 65536)*(float)256);
		rgb = ((int)r2) << 16 | ((int)g2) << 8 | ((int)b2);
		cloud->points[i].rgb = *reinterpret_cast<float*>(&rgb);

		i++;
	}

	float resolution = 128.0f;
	pcl::octree::OctreePointCloudSearch<pcl::PointXYZRGB> octree(resolution);
	octree.setInputCloud(cloud);
	octree.addPointsFromInputCloud();
	std::vector<int>pointIdxRadiusSearch;
	std::vector<int>pointIdxRadiusSearch1;
	cout << "原始点云: " << cloud->width << " \t" << cloud->points.size() << endl;

	//读取轨迹线
	pcl::io::loadPCDFile("trail.pcd", *cloud1);
	cout << "轨迹线: " << cloud1->width << " \t" << cloud1->points.size() << endl;

	//seed.txt保存切割得到的种子索引
	ofstream ofs;
	ofs.open("seed.txt");

	//cluster保存区域生长得到的分段
	
	//pcl::PointIndices tempCluster;

	/**
		开始循环
	*/
	for (size_t i = 0; i <200 ; i += 20) {//cloud1->points.size()
		//
		a1 = cloud1->points[i].x;
		a2 = cloud1->points[i].y;
		a3 = cloud1->points[i].z;
		b11 = cloud1->points[i + 20].x;
		b22 = cloud1->points[i + 20].y;
		b3 = cloud1->points[i + 20].z;
		x1 = a1 - b11;
		y1 = a2 - b22;
		float cosa = (x1*x2 + y1 * y2) / (sqrt(x1*x1 + y1 * y1) + sqrt(x2*x2 + y2 * y2));
		float sina = sqrt(1 - cosa * cosa);
		float range = r / sina;

		//分段
		Eigen::Vector3f n(-10000, min(a2, b22), -10);//0xc0c0c0c0	0x3f3f3f3f
		Eigen::Vector3f m(10000, max(a2, b22) - 0.001, min(a3, b3));
		octree.boxSearch(n, m, pointIdxRadiusSearch);
		cout << "这段有点数：" << pointIdxRadiusSearch.size() << endl;
		for (size_t j = 0; j < pointIdxRadiusSearch.size(); ++j) {
			//cout << pointIdxRadiusSearch[j] << "\t";
			tempPnt.x = cloud->points[pointIdxRadiusSearch[j]].x;
			tempPnt.y = cloud->points[pointIdxRadiusSearch[j]].y;
			tempPnt.z = cloud->points[pointIdxRadiusSearch[j]].z;
			tempPnt.rgb = cloud->points[pointIdxRadiusSearch[j]].rgb;

			part->push_back(tempPnt);
		}

		if(i==20)
		pcl::io::savePCDFileASCII("1.pcd", *part);
		if (i == 40) {
			pcl::io::savePCDFileASCII("2.pcd", *part);
		}
		if(i==40)
			pcl::io::savePCDFileASCII("3.pcd", *part);

		//切割种子点
		Eigen::Vector3f p(a1 - range, min(a2, b22), -10);
		Eigen::Vector3f q(a1 + range, max(a2, b22) - 0.001, min(a3, b3));
		octree.boxSearch(p, q, pointIdxRadiusSearch1);
		cout<<"这段种子数："<< pointIdxRadiusSearch1.size() << endl;

		if (pointIdxRadiusSearch1.size() > 0) {
			/*normal_estimator.setInputCloud(part);
			normal_estimator.compute(*normals);

			reg.setInputCloud(part);
			reg.setInputNormals(normals);*/
			// 创建空的tree   设置搜索的方式或者说是结构
			pcl::search::Search<pcl::PointXYZRGB>::Ptr tree = boost::shared_ptr<pcl::search::Search<pcl::PointXYZRGB> >(new pcl::search::KdTree<pcl::PointXYZRGB>);
			//求法线
			//创建一个normal点云
			pcl::PointCloud <pcl::Normal>::Ptr normals(new pcl::PointCloud <pcl::Normal>);
			pcl::NormalEstimation<pcl::PointXYZRGB, pcl::Normal> normal_estimator;
			normal_estimator.setSearchMethod(tree);
			normal_estimator.setInputCloud(part);
			normal_estimator.setKSearch(50);
			normal_estimator.compute(*normals);

			//创造区域生长分割对象	聚类对象<点，法线>
			pcl::RegionGrowing<pcl::PointXYZRGB, pcl::Normal> reg; //首先建立reg寄存器(区域曾长的对象）
			reg.setMinClusterSize(50);  //最小的聚类的点数(小于这参数的平面被忽略不计）
			reg.setMaxClusterSize(30000000);  //最大的(一般随便设置）
			reg.setSearchMethod(tree);    //搜索方式(采用的默认是K—d树法）
			reg.setNumberOfNeighbours(30); //设置搜索的邻域点的个数，周围多少个点决定这是一个平面(决定容错率，设置大时有倾斜也可接受，设置小时检测到的平面会很小）
			reg.setInputCloud(part);         //输入点
											  //reg.setIndices (indices);
			reg.setInputNormals(normals);     //输入的法线

			reg.setSmoothnessThreshold(SmoothnessThreshold / 180.0 * M_PI);//3.0 设置平滑度(设置两个法线在多大夹角内可当做是共面的）
			reg.setCurvatureThreshold(CurvatureThreshold); 

			pcl::PointIndices cluster;

			reg.getSegmentFromPoint(pointIdxRadiusSearch1[0], cluster);
			cout << "取得的种子是：" << pointIdxRadiusSearch1[0] << "\t生长后点数：" << cluster.indices.size() << endl;
			cout << "-------------------------------------------------------------" << endl;
			/*cluster.indices += tempCluster.indices;
			tempCluster.indices.clear();*/

			
			for (int j = 0; j < cluster.indices.size(); ++j) {
				tempPnt.x = part->points[cluster.indices[j]].x;
				tempPnt.y = part->points[cluster.indices[j]].y;
				tempPnt.z = part->points[cluster.indices[j]].z;
				tempPnt.rgb = part->points[cluster.indices[j]].rgb;

				cloud3->push_back(tempPnt);
			}
		}
		//cluster.indices.clear();
		pointIdxRadiusSearch.clear();
		pointIdxRadiusSearch1.clear();
		part->clear();
	}
	ofs.close();

	//pcl::io::savePCDFileASCII("seed.pcd", *cloud2);//存储为pcd类型文件
	//cout << "保存种子成功" << endl;

	//pcl::PointIndices cluster;
	//ifstream ifs1;
	//ifs1.open("seed.txt");
	//int seed = 0;
	//ifs1 >> seed;
	//ifs1.close();

	cout << "生长后的点云保存到cloud3，regionGrow.pcd" << endl;
	//cloud3->width = cluster.indices.size();	//保证与las数据点的个数一致	
	cloud3->height = 1;
	cloud3->is_dense = false;
	//cloud3->points.resize(cloud3->width * cloud3->height);

	pcl::io::savePCDFileASCII("regionGrow.pcd", *cloud3);
	cout << "保存成功" << endl;

	//cout << "写入切割后文件" << endl;
	//
	//ofs.open("clusterRoad.txt");
	//for (int i = 0; i < cluster.indices.size(); ++i) {
	//	ofs << cloud->points[cluster.indices[i]].x << "\t";
	//	ofs << cloud->points[cluster.indices[i]].y << "\t";
	//	ofs << cloud->points[cluster.indices[i]].z << endl;

	//}
	//ofs.close();
	//cout << "写入文件完成" << endl;
	return 0;
}
frontierq
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值