Project1,分段切割、区域生长，sample100测试得到的结果没有边缘，但是不连续

最新推荐文章于 2022-10-23 09:28:28 发布
最新推荐文章于 2022-10-23 09:28:28 发布
阅读量194 收藏
点赞数
分类专栏： 0毕设
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36477987/article/details/105379311
版权

Project1,简化了提取索引点云，点云合并

#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 cloud2(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr result(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr part(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr partSeed(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr seed(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 = 6;//3.0 0.37
	float CurvatureThreshold = 0.01;    //设置曲率的阈值1.0

	//读取输入电云
	cout << "读取点云" << endl;
	//pcl::io::loadPCDFile("sample100.pcd", *cloud);
	loadLasFile("sample100.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>pointIdx1;

	/**
		开始循环
	*/
	for (size_t i = 0; i < trail->points.size() + 500; 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(-100000, min(a2, b22), -100000);//0xc0c0c0c0	0x3f3f3f3f
		Eigen::Vector3f m(100000, max(a2, b22) - 0.001, min(a3, b3));
		octree.boxSearch(n, m, pointIdx);
		cout << i << " 这段有点数：" << pointIdx.size() << "\t";
		pcl::copyPointCloud(*cloud, pointIdx, *part);

		/*cout << "保存1.pcd成功" << endl;
		pcl::io::savePCDFileASCII("1.pcd", *part);*/

		//分段切割种子点
		pcl::octree::OctreePointCloudSearch<pcl::PointXYZRGB> octree1(resolution);
		octree1.setInputCloud(part);
		octree1.addPointsFromInputCloud();

		Eigen::Vector3f p(a1 - range, min(trail->points[i + 8].y, trail->points[i + 12].y), -100000);//min(a2, b22)
		Eigen::Vector3f q(a1 + range, max(trail->points[i + 8].y, trail->points[i + 12].y) - 0.000001, min(a3, b3));//max(a2, b22) - 0.001
		octree1.boxSearch(p, q, pointIdx1);
		cout << "这段种子数：" << pointIdx1.size() << endl;
		pcl::copyPointCloud(*part, pointIdx1, *partSeed);
		*seed += *partSeed;

		/*	cout << "保存2.pcd成功" << endl;
			pcl::io::savePCDFileASCII("2.pcd", *partSeed);*/

			// 创建空的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(500);
		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);

		std::vector <pcl::PointIndices> clusters;
		reg.extract(clusters);
		pcl::PointIndices cluster;


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

		pcl::copyPointCloud(*part, cluster, *tempCloud);
		*result += *tempCloud;
	}

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

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

	return 0;
}

Project1,添加输入las文件的函数

#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 cloud2(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr result(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr part(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr partSeed(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr seed(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr colored(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 =6;//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>pointIdxRadiusSearch;
	std::vector<int>pointIdxRadiusSearch1;

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

	/**
		开始循环
	*/
	for (size_t i = 0; i < trail->points.size() + 500; 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(-100000, min(a2, b22), -100000);//0xc0c0c0c0	0x3f3f3f3f
		Eigen::Vector3f m(100000, max(a2, b22) - 0.001, min(a3, b3));
		octree.boxSearch(n, m, pointIdxRadiusSearch);
		cout << i<<" 这段有点数：" << pointIdxRadiusSearch.size() << "\t";
		for (size_t j = 0; j < pointIdxRadiusSearch.size(); ++j) {
			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);
		}

			/*cout << "保存1.pcd成功" << endl;
			pcl::io::savePCDFileASCII("1.pcd", *part);*/

		//分段切割种子点
		pcl::octree::OctreePointCloudSearch<pcl::PointXYZRGB> octree1(resolution);
		octree1.setInputCloud(part);
		octree1.addPointsFromInputCloud();

		Eigen::Vector3f p(a1 - range, min(trail->points[i + 8].y, trail->points[i + 12].y), -100000);//min(a2, b22)
		Eigen::Vector3f q(a1 + range, max(trail->points[i + 8].y, trail->points[i + 12].y)-0.000001, min(a3, b3));//max(a2, b22) - 0.001
		octree1.boxSearch(p, q, pointIdxRadiusSearch1);
		cout << "这段种子数：" << pointIdxRadiusSearch1.size() << endl;
		for (size_t j = 0; j < pointIdxRadiusSearch1.size(); ++j) {
			tempPnt.x = part->points[pointIdxRadiusSearch1[j]].x;
			tempPnt.y = part->points[pointIdxRadiusSearch1[j]].y;
			tempPnt.z = part->points[pointIdxRadiusSearch1[j]].z;
			tempPnt.rgb = part->points[pointIdxRadiusSearch1[j]].rgb;

			seed->push_back(tempPnt);
		}


		/*	cout << "保存2.pcd成功" << endl;
			pcl::io::savePCDFileASCII("2.pcd", *partSeed);*/

		// 创建空的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(500);
		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);

		std::vector <pcl::PointIndices> clusters;
		reg.extract(clusters);
		pcl::PointIndices cluster;
		
		
		//for (int j = 0;j < pointIdxRadiusSearch1.size();++j) {
		//	reg.getSegmentFromPoint(pointIdxRadiusSearch1[0], cluster);
		//	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);
		//	}
		//}


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

		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;

			result->push_back(tempPnt);
		}
		part->clear();
		partSeed->clear();
	}
	ofs.close();

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

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

	return 0;
}

Project1,pcd输入文件，修改点云变量名

#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 trail(new pcl::PointCloud<pcl::PointXYZ>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud2(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr result(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr part(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr partSeed(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr seed(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr colored(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 =6;//3.0 0.37
	float CurvatureThreshold = 0.01;    //设置曲率的阈值1.0
	
	//读取输入电云
	cout << "读取点云" << endl;
	pcl::io::loadPCDFile("o.pcd", *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>pointIdxRadiusSearch;
	std::vector<int>pointIdxRadiusSearch1;

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

	/**
		开始循环
	*/
	for (size_t i = 0; i < trail->points.size() + 500; 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(-100000, min(a2, b22), -100000);//0xc0c0c0c0	0x3f3f3f3f
		Eigen::Vector3f m(100000, max(a2, b22) - 0.001, min(a3, b3));
		octree.boxSearch(n, m, pointIdxRadiusSearch);
		cout << i<<" 这段有点数：" << pointIdxRadiusSearch.size() << "\t";
		for (size_t j = 0; j < pointIdxRadiusSearch.size(); ++j) {
			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);
		}

			/*cout << "保存1.pcd成功" << endl;
			pcl::io::savePCDFileASCII("1.pcd", *part);*/

		//分段切割种子点
		pcl::octree::OctreePointCloudSearch<pcl::PointXYZRGB> octree1(resolution);
		octree1.setInputCloud(part);
		octree1.addPointsFromInputCloud();

		Eigen::Vector3f p(a1 - range, min(trail->points[i + 8].y, trail->points[i + 12].y), -100000);//min(a2, b22)
		Eigen::Vector3f q(a1 + range, max(trail->points[i + 8].y, trail->points[i + 12].y)-0.000001, min(a3, b3));//max(a2, b22) - 0.001
		octree1.boxSearch(p, q, pointIdxRadiusSearch1);
		cout << "这段种子数：" << pointIdxRadiusSearch1.size() << endl;
		for (size_t j = 0; j < pointIdxRadiusSearch1.size(); ++j) {
			tempPnt.x = part->points[pointIdxRadiusSearch1[j]].x;
			tempPnt.y = part->points[pointIdxRadiusSearch1[j]].y;
			tempPnt.z = part->points[pointIdxRadiusSearch1[j]].z;
			tempPnt.rgb = part->points[pointIdxRadiusSearch1[j]].rgb;

			seed->push_back(tempPnt);
		}


		/*	cout << "保存2.pcd成功" << endl;
			pcl::io::savePCDFileASCII("2.pcd", *partSeed);*/

		// 创建空的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(500);
		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);

		std::vector <pcl::PointIndices> clusters;
		reg.extract(clusters);
		pcl::PointIndices cluster;
		
		
		//for (int j = 0;j < pointIdxRadiusSearch1.size();++j) {
		//	reg.getSegmentFromPoint(pointIdxRadiusSearch1[0], cluster);
		//	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);
		//	}
		//}


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

		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;

			result->push_back(tempPnt);
		}
		part->clear();
		partSeed->clear();
	}
	ofs.close();

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

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

	return 0;
}

Project1,分段切割、区域生长，sample100测试得到的结果没有边缘，但是不连续

#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::PointCloud<pcl::PointXYZRGB>::Ptr partSeed(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::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 =6;//3.0 0.37
	float CurvatureThreshold = 0.01;    //设置曲率的阈值1.0

	/*
	*读取las文件，打开点云，初始化octree
	*/
	std::ifstream ifs("sample10.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;
	part->height = 1;
	part->is_dense = false;
	part->points.resize(part->width * part->height);

	partSeed->width = 0;
	partSeed->height = 1;
	partSeed->is_dense = false;
	partSeed->points.resize(partSeed->width * partSeed->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 < cloud1->points.size() + 500; i += 20) {//cloud1->points.size()		cloud1->points.size()+500   500
		//
		a1 = cloud1->points[i].x;
		a2 = cloud1->points[i].y;//cloud1->points[i+8].y
		a3 = cloud1->points[i].z;
		b11 = cloud1->points[i + 20].x;
		b22 = cloud1->points[i + 20].y;//cloud1->points[i+12].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(-100000, min(a2, b22), -100000);//0xc0c0c0c0	0x3f3f3f3f
		Eigen::Vector3f m(100000, 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) {

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

			/*cout << "保存1.pcd成功" << endl;
			pcl::io::savePCDFileASCII("1.pcd", *part);*/

		//切割种子点
		pcl::octree::OctreePointCloudSearch<pcl::PointXYZRGB> octree1(resolution);
		octree1.setInputCloud(part);
		octree1.addPointsFromInputCloud();

		Eigen::Vector3f p(a1 - range, min(cloud1->points[i + 8].y, cloud1->points[i + 12].y), -100000);//min(a2, b22)
		Eigen::Vector3f q(a1 + range, max(cloud1->points[i + 8].y, cloud1->points[i + 12].y)-0.000001, min(a3, b3));//max(a2, b22) - 0.001
		octree1.boxSearch(p, q, pointIdxRadiusSearch1);
		cout << i<<"\t"<<"这段种子数：" << pointIdxRadiusSearch1.size() << endl;
		for (size_t j = 0; j < pointIdxRadiusSearch1.size(); ++j) {

			tempPnt.x = part->points[pointIdxRadiusSearch1[j]].x;
			tempPnt.y = part->points[pointIdxRadiusSearch1[j]].y;
			tempPnt.z = part->points[pointIdxRadiusSearch1[j]].z;
			tempPnt.rgb = part->points[pointIdxRadiusSearch1[j]].rgb;

			seedCloud->push_back(tempPnt);
		}
		//cout << "能到这里吗" << endl;

		/*	cout << "保存2.pcd成功" << endl;
			pcl::io::savePCDFileASCII("2.pcd", *partSeed);*/

		// 创建空的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(500);
		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);

		std::vector <pcl::PointIndices> clusters;
		reg.extract(clusters);
		pcl::PointIndices cluster;
		
		
		for (int j = 0;j < pointIdxRadiusSearch1.size();++j) {
			reg.getSegmentFromPoint(pointIdxRadiusSearch1[0], cluster);
			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);
			}
		}


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

		cout << "种子点" << part->points[pointIdxRadiusSearch1[0]].x << "\t" << part->points[pointIdxRadiusSearch1[0]].y << "\t" << part->points[pointIdxRadiusSearch1[0]].z << "\t" << endl;*/


		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();
		partSeed->clear();
	}
	ofs.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("0regionGrow.pcd", *cloud3);
	cout << "保存成功" << endl;

	cout << "切割后的点云保存到seedCloud，seedCloud.pcd" << endl;
	//cloud3->width = cluster.indices.size();	//保证与las数据点的个数一致	
	seedCloud->height = 1;
	seedCloud->is_dense = false;
	//cloud3->points.resize(cloud3->width * cloud3->height);
	pcl::io::savePCDFileASCII("0seedCloud.pcd", *seedCloud);
	cout << "保存成功" << endl;

	return 0;
}
frontierq
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Win32Project1_lessons2s_wxwidget测试_wxWidgets_Win32Project1.ilk_源
10-04
一个wxwidgets测试例子
android安卓源码海量项目合集打包-1
热门推荐
chenhao0568的专栏
06-11 13万+
下载地址 最后更新共计113个分类5177套源码29.2 GB。 卷 新加卷 的文件夹 PATH 列表 卷序列号为 00000200 5E7A:7F30 F:. ├─前台界面 │ ├─3D标签云卡片热门 │ │ Android TagCloudView云标签的灵活运用.rar │ │ Android 实现 标签 拖动 改变位置.rar │ │ android 流式布局和热门标签.zip │ │ ...
[论文总结] 智慧农业论文摘要阅读概览
You and Me
09-13 1万+
1. Design of a winter-jujube grading robot based on machine vision（Computers and Electronics in Agriculture） 摘要：Winter-jujube(冬枣)在中国是一种新鲜的水果。 收获后,winter-jujubes需要年级分成不同的类别根据其成熟度级别。 成熟winter-jujube可以认可他们的红色。 在这项研究中,一个winter-jujube分级机器人设计。 此外,一个方法结合YOLOv3算法和
《游戏引擎架构》中英词汇索引表
wolf96的专栏
05-05 5027
简介 此词汇索引表源自《游戏引擎架构》的中英索引，支持搜寻及排序，以方便读者查阅。遇到游戏相关的术语也可利用本表查找其中英翻译。欢迎提供意见反馈。 中英双语索引表 Search: 英文 中文 页数   2D angular acceleration 二维角加速率 580 2D angular dynamics 二维旋转动力学 5
光栅化全面解析
jj555666555的博客
07-20 1428
光栅化全面解析 0 两种方法 图形学中渲染过程基本上可以分解为两个主要任务：可见性和着色。光栅化可以说是一种解决可见性问题的方法。可见性包括能够分辨三维物体的哪些部分对摄像机是可见的。这些物体的某些部分可以被禁止，因为它们要么在摄像机的可见区域之外，要么被其他物体隐藏。 解决这个问题基本上可以通过两种方式进行。你可以通过图像中的每个像素追踪一条射线，找出相机与该射线相交的任何物体（如果有的话）之间的距离。通过该像素可见的物体就是相交距离最小的物体（一般用 t 表示）。这就是光线追踪中使用的技术。请注意，在这
单倍型定相软件Haplotype phasing
wangprince2017
12-20 4813
Haplotype phasing software Share: haplotype phasing software The Eagle software estimates haplotype phase either using a phased reference panel or within a genotyped cohort. Haplotype-specific association analysis was performed with Fisher’s exac...
【H.264】x264命令详解：x264 --fullhelp
郭老二
04-15 2535
1、简述 宏区块： macroblock：。是一种图像压缩的术语。 宏区块是运动预测的基本单位，一张完整的图像（frame）通常会被切割成几个宏区块。h.264 的宏区块大小是可变的，常用 16x16 pixels。 帧类型 “帧”基础知识： 影片可以看作是由一张张连续的图片组成的，每幅图片就是一帧。压缩的视频由3种不同类型的帧（Intra (I) frames (也叫 key frames)，P...
x264学习（2）——x264命令行参数解释
NB_vol_1的专栏
08-08 2393
原文地址：http://blog.csdn.net/liuchen1206/article/details/44174741 词汇翻译： macroblock：宏区块。是一种图像压缩的术语。 宏区块是运动预测的基本单位，一张完整的图像（frame）通常会被切割成几个宏区块。h.264 的宏区块大小是可变的，常用 16x16 pixels。 帮助 X264 内置帮助文档。运行 x2
面试常背八股文
你好，时光的博客
10-23 2957
java基础、数据库、计算机网络、操作系统、数据结构、Linux
[翻译论文]An effective approach for land-cover classification from airborne lidar fused with co-register
Yang_Wanli的博客
03-06 635
[翻译论文]An effective approach for land-cover classification from airborne lidar fused with co-registered data(2012) 一种有效的机载激光雷达土地覆盖分类方法 YANG CAO，HONG WEI，HUIJIE ZHAO，NA LI Doi：10.1080/01431161.2012.676746 文章目录1.导言1.1动机和目标1.2之前的工作和提出的方法2.特征空间3.分类框架4.采用DS方法进行初
LAxisCtrl_V1_0_4_sample_startdrive_tia_project_siemens_
10-03
sample project for startdrive with technology object
project1-data-1_测试_zip_
10-04
测试文件
SampleProject1
02-12
SampleProject1 设置三个系统[我假设所有步骤都在基于RedHat的Centos系统上执行]A. Server-1 [称其为Jenkins服务器] 为了在服务器上配置Jenkins。 您需要先安装Java，然后运行以下命令来安装Jenkins sudo yum ...
sampleproject1
03-26
sampleproject1
基于SSM+JSP的企业人事管理信息系统毕业设计(源码+录像+说明).rar
05-09
基于SSM+JSP的企业人事管理信息系统毕业设计(源码+录像+说明).rar 【项目技术】 开发语言：Java 框架：ssm+jsp 架构：B/S 数据库：mysql 【演示视频-编号：420】 https://pan.quark.cn/s/b3a97032fae7 【实现功能】 实现了员工基础数据的管理，考勤管理,福利管理,薪资管理,奖惩管理,考核管理,培训管理,招聘管理,公告管理,基础数据管理等功能。
node-v6.12.0-linux-ppc64le.tar.xz
最新发布
05-09
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
node-v6.8.0-linux-ppc64le.tar.xz
05-09
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
基于PaddleFL框架的联邦学习医疗影像识别系统源码+GUI界面+说明（高分）.zip
05-09
基于PaddleFL框架的联邦学习医疗影像识别系统源码+GUI界面+说明.zip该项目是个人毕设项目源码，评审分达到97分，都经过严格调试，确保可以运行！放心下载使用。该项目资源主要针对计算机相关专业的学生或从业者下载使用，也可作为期末课程设计、课程大作业、毕业设计等。 基于PaddleFL框架的联邦学习医疗影像识别系统源码+GUI界面+说明.zip该项目是个人毕设项目源码，评审分达到97分，都经过严格调试，确保可以运行！放心下载使用。该项目资源主要针对计算机相关专业的学生或从业者下载使用，也可作为期末课程设计、课程大作业、毕业设计等。 基于PaddleFL框架的联邦学习医疗影像识别系统源码+GUI界面+说明.zip该项目是个人毕设项目源码，评审分达到97分，都经过严格调试，确保可以运行！放心下载使用。该项目资源主要针对计算机相关专业的学生或从业者下载使用，也可作为期末课程设计、课程大作业、毕业设计等。 基于PaddleFL框架的联邦学习医疗影像识别系统源码+GUI界面+说明.zip该项目是个人毕设项目源码，评审分达到97分，都经过严格调试，确保可以运行！放心下载使用。该项目资源
FileEditorManager.getInstance();需要输入project的值 但是我不知道当前的project值
06-01
你可以通过以下代码获取当前的project值： ``` Project project = ProjectManager.getInstance().getOpenProjects()[0]; ``` 然后将其传递给`FileEditorManager.getInstance(project)`方法即可。需要注意的是，如果有多个project打开，则需要根据实际情况选择需要的project。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值