///直通濾波
//#include "pch.h"
//#include <pcl/point_cloud.h>
//#include <pcl/point_types.h>
//#include <pcl/filters/passthrough.h>//直通濾波
//#include <pcl/io/pcd_io.h>  //文件輸入輸出
//
//using namespace std;
//
///** \brief 直通濾波
//	* \param[in] cloud_in 輸入點云
//	* \param[in] z_small Z方向小值
//	* \param[in] z_big   z方向大值
//	* \param[in] x_small X方向小值
//	* \param[in] x_big X方向大值
//	* \param[in] y_small Y方向小值
//	* \param[in] y_big Y方向大值
//	* \param[out] cloud_out 輸出點云
//	*/
//void passFilter(pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud_in,
//	float z_small, float z_big, float x_small, float x_big, float y_small, float y_big,
//	pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud_out)
//{
//	pcl::PointCloud < pcl::PointXYZ >::Ptr cloud(new pcl::PointCloud < pcl::PointXYZ >);
//	pcl::PassThrough<pcl::PointXYZ> pass; // 設置濾波器對象
//	pass.setInputCloud(cloud_in);
//	pass.setFilterFieldName("z");
//	pass.setFilterLimits(z_small, z_big);
//	pass.filter(*cloud);
//	pass.setInputCloud(cloud);
//	pass.setFilterFieldName("x");
//	pass.setFilterLimits(x_small, x_big);
//	pass.filter(*cloud);
//	pass.setInputCloud(cloud);
//	pass.setFilterFieldName("y");
//	pass.setFilterLimits(y_small, y_big);
//	pass.filter(*cloud_out);
//
//	pcl::io::savePCDFile<pcl::PointXYZ>("F://cout-saved//demo_filter.pcd", *cloud_out);
//	cout << "there are " << cloud_out->points.size() << " points after filtering." << endl;
//
//}
//
//int main(int argc, char **argv)
//{
//
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);//聲明數組
//
//	if (pcl::io::loadPCDFile<pcl::PointXYZ>("F://cout-saved//flange.pcd", *cloud) == -1)
//	{
//		PCL_ERROR("Cloudn't read file!");
//		return -1;
//	}//讀取點云文件
//
//	void passFilter(cloud, 74.0, 86.0, -7.0, 15.0, 74.0, 80.0, *cloud_out);
//	
//
//}//測試代碼
//#include "pch.h"
//#include <iostream>
//#include <pcl/io/pcd_io.h>
//#include <pcl/point_types.h>
//
//int
//main(int argc, char** argv)
//{
//	pcl::PointCloud<pcl::PointXYZ> cloud;
//
//	// Fill in the cloud data
//	cloud.width = 5;
//	cloud.height = 1;
//	cloud.is_dense = false;
//	cloud.points.resize(cloud.width * cloud.height);
//
//	for (size_t i = 0; i < cloud.points.size(); ++i)
//	{
//		cloud.points[i].x = 1024 * rand() / (RAND_MAX + 1.0f);
//		cloud.points[i].y = 1024 * rand() / (RAND_MAX + 1.0f);
//		cloud.points[i].z = 1024 * rand() / (RAND_MAX + 1.0f);
//	}
//
//	pcl::io::savePCDFileASCII("test_pcd.pcd", cloud);
//	std::cerr << "Saved " << cloud.points.size() << " data points to test_pcd.pcd." << std::endl;
//
//	for (size_t i = 0; i < cloud.points.size(); ++i)
//		std::cerr << "    " << cloud.points[i].x << " " << cloud.points[i].y << " " << cloud.points[i].z << std::endl;
//	system("pause");
//	return (0);
//}//
//#include <iostream> //標準輸入輸出流
//
//#include <pcl/io/pcd_io.h> //PCL的PCD格式文件的輸入輸出頭文件
//
//#include <pcl/point_types.h> //PCL對各種格式的點的支持頭文件
//
//#include <pcl/visualization/cloud_viewer.h>//點云查看窗口頭文件
//
//int main(int argc, char** argv)
//
//{
//
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>); // 創建點云（指針）
//
//
//
//	if (pcl::io::loadPCDFile<pcl::PointXYZ>("C:\\Users\\Wzf\\Desktop\\rabbit\\rabbit_t.pcd", *cloud) == -1) //* 讀入PCD格式的文件，如果文件不存在，返回-1
//
//	{
//
//		PCL_ERROR("Couldn't read file test_pcd.pcd \n"); //文件不存在時，返回錯誤，終止程序。
//
//		return (-1);
//
//	}
//
//	pcl::visualization::CloudViewer viewer("Simple Cloud Viewer");//直接創造一個顯示窗口
//
//	viewer.showCloud(cloud);//再這個窗口顯示點云
//
//	while (!viewer.wasStopped())
//
//	{
//
//	}
//
//	return (0);
//
//}點云數據txt轉pcd格式
//#include "pch.h"
//#include<iostream> 
//#include<fstream>
//#include<vector>
//#include<string>
//#include<pcl\io\pcd_io.h>
//#include<pcl\point_types.h>
//using namespace std;
//int main()
//{	//定義一種類型表示TXT中xyz	
//	typedef struct TXT_Point_XYZ	
//	{	
//		double x;		
//	    double y;		
//	    double z;	
//	}TOPOINT_XYZ; 	
//	//讀取txt文件	
//	int num_txt;	
//	FILE *fp_txt;	
//	TXT_Point_XYZ txt_points;	
//	vector<TXT_Point_XYZ> my_vTxtPoints;	
//	fp_txt = fopen("C://Users//HEHE//Desktop//Chair.txt","r"); 	
//	if (fp_txt)	
//	{		
//		while (fscanf(fp_txt, "%lf %lf %lf", &txt_points.x, &txt_points.y, &txt_points.z) != EOF)		
//		{//將點存入容器尾部			
//			my_vTxtPoints.push_back(txt_points);		
//		}	
//	}	
//	else		
//		cout << "讀取txt文件失敗"<<endl; 	
//	num_txt = my_vTxtPoints.size(); 	
//	//寫入點云數據	
//	pcl::PointCloud<pcl::PointXYZ> ::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);	
//	cloud->width = num_txt;	
//	cloud->height = 1;	
//	cloud->is_dense = false;	
//	cloud->points.resize(cloud->width*cloud->height);	
//	for (int i = 0; i < cloud->points.size(); ++i)	
//	{		
//		cloud->points[i].x = my_vTxtPoints[i].x;		
//		cloud->points[i].y = my_vTxtPoints[i].y;		
//		cloud->points[i].z = my_vTxtPoints[i].z;	
//	}	
//	pcl::io::savePCDFileASCII("C://Users//HEHE//Desktop//Chair.pcd", *cloud);	
//	cout<< "從 Chair.txt讀取" << cloud->points.size() << "點寫入Chair.pcd" << endl;		
//	//打印出寫入的點    cout << "_________________________________" << endl;	
//	for (size_t i = 0; i < cloud->points.size(); ++i)		
//		cout << "    " << cloud->points[i].x		
//		<< " " << cloud->points[i].y		
//		<< " " << cloud->points[i].z << endl; 	
//	return 0;
//}體素濾波
//#include "pch.h"
//#include <iostream>
//#include <pcl/io/pcd_io.h>
//#include <pcl/point_types.h>
//#include <pcl/filters/voxel_grid.h>
//
//
//int
//main(int argc, char** argv)
//{
//
//	pcl::PCLPointCloud2::Ptr cloud(new pcl::PCLPointCloud2());
//	pcl::PCLPointCloud2::Ptr cloud_filtered(new pcl::PCLPointCloud2());
//
//	//點云對象的讀取
//	pcl::PCDReader reader;
//
//	reader.read("C://Users//HEHE//Desktop//Chair.pcd", *cloud);    //讀取點云到cloud中
//
//	std::cerr << "PointCloud before filtering: " << cloud->width * cloud->height
//		<< " data points (" << pcl::getFieldsList(*cloud) << ").";
//
//	/******************************************************************************
//	創建一個葉大小為1cm的pcl::VoxelGrid濾波器，
//  **********************************************************************************/
//	pcl::VoxelGrid<pcl::PCLPointCloud2> sor;  //創建濾波對象
//	sor.setInputCloud(cloud);            //設置需要過濾的點云給濾波對象
//	//sor.setLeafSize(0.01f, 0.01f, 0.01f);  //設置濾波時創建的體素體積為1cm的立方體
//	sor.setLeafSize(10.0f, 10.0f, 10.0f);
//	sor.filter(*cloud_filtered);           //執行濾波處理，存儲輸出
//
//	std::cerr << "PointCloud after filtering: " << cloud_filtered->width * cloud_filtered->height
//		<< " data points (" << pcl::getFieldsList(*cloud_filtered) << ").";
//
//	pcl::PCDWriter writer;
//	writer.write("C://Users//HEHE//Desktop//Chair_downsampled.pcd", *cloud_filtered,
//		Eigen::Vector4f::Zero(), Eigen::Quaternionf::Identity(), false);
//
//	return (0);
//}statisticalOutlierRemoval濾波器移除離群點
//#include "pch.h"
//#include <iostream>
//#include <pcl/io/pcd_io.h>
//#include <pcl/point_types.h>
//#include <pcl/filters/statistical_outlier_removal.h>
//
//int
//main(int argc, char** argv)
//{
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_filtered(new pcl::PointCloud<pcl::PointXYZ>);
//
//	// 定義讀取對象
//	pcl::PCDReader reader;
//	// 讀取點云文件
//	reader.read<pcl::PointXYZ>("C://Users//HEHE//Desktop//Chair.pcd", *cloud);
//
//	std::cerr << "Cloud before filtering: " << std::endl;
//	std::cerr << *cloud << std::endl;
//
//	// 創建濾波器，對每個點分析的臨近點的個數設置為50 ，并將標準差的倍數設置為1  這意味著如果一
//	 //個點的距離超出了平均距離一個標準差以上，則該點被標記為離群點，并將它移除，存儲起來
//	pcl::StatisticalOutlierRemoval<pcl::PointXYZ> sor;   //創建濾波器對象
//	sor.setInputCloud(cloud);                           //設置待濾波的點云
//	sor.setMeanK(50);                               //設置在進行統計時考慮查詢點臨近點數
//	sor.setStddevMulThresh(1.0);                      //設置判斷是否為離群點的閥值
//	sor.filter(*cloud_filtered);                    //存儲
//
//	std::cerr << "Cloud after filtering: " << std::endl;
//	std::cerr << *cloud_filtered << std::endl;
//
//	pcl::PCDWriter writer;
//	writer.write<pcl::PointXYZ>("C://Users//HEHE//Desktop//Chair_inliers.pcd", *cloud_filtered, false);
//
//	sor.setNegative(true);
//	sor.filter(*cloud_filtered);
//	writer.write<pcl::PointXYZ>("C://Users//HEHE//Desktop//Chair_outliers.pcd", *cloud_filtered, false);
//
//	return (0);
//}直通濾波算法
//#include "pch.h"
//#include <pcl/io/pcd_io.h>  //文件輸入輸出
//#include <pcl/point_types.h>  //點類型相關定義
//#include <pcl/visualization/cloud_viewer.h>  //點云可視化相關定義
//#include <pcl/filters/passthrough.h>  //直通濾波相關
//#include <pcl/common/common.h>  
//#include <iostream>#include <vector>
//using namespace std; 
//int main()
//{	//1.讀取點云	
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);	
//	if (pcl::io::loadPCDFile<pcl::PointXYZ>("C://Users//HEHE//Desktop//back_1.pcd", *cloud) == -1)	
//	{		
//		PCL_ERROR("Cloudn't read file!");		
//		return -1;	
//	}	cout << "there are " << cloud->points.size()<<" points before filtering." << endl; 	
//	//2.取得點云坐標極值	
//	pcl::PointXYZ minPt, maxPt;	pcl::getMinMax3D(*cloud, minPt, maxPt); 	
//	//3.直通濾波	
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_filter(new pcl::PointCloud<pcl::PointXYZ>);	
//	pcl::PassThrough<pcl::PointXYZ> pass;     //創建濾波器對象	
//	pass.setInputCloud(cloud);                //設置待濾波的點云	
//	pass.setFilterFieldName("x");             //設置在Z軸方向上進行濾波
//	//pass.setFilterLimits(0, maxPt.z - 12);    //設置濾波范圍(從最高點向下12米去除)在該范圍外的濾除掉
//	//pass.setFilterLimits(0, 0.5);//點云中z坐標在括號范圍外的點過濾掉	結果全是0
//	pass.setFilterLimits(0, 20);
//	pass.setFilterLimitsNegative(false);      //保留 代表了是否顯示被過濾掉的點，如果設置為true則將被過濾的以紅色表示，沒過濾的用綠色表示。默認是false.
//	pass.filter(*cloud_filter);               //濾波并存儲 	
//	//4.濾波結果保存	
//	pcl::io::savePCDFile<pcl::PointXYZ>("C://Users//HEHE//Desktop//demo_filter.pcd", *cloud_filter);	
//	cout << "there are " << cloud_filter->points.size() << " points after filtering." << endl;		
//	system("pause");	
//	return 0;
//}直通濾波算法
//#include "pch.h"
//#include <pcl/io/pcd_io.h>  //文件輸入輸出
//#include <pcl/point_types.h>  //點類型相關定義
//#include <pcl/visualization/cloud_viewer.h>  //點云可視化相關定義
//#include <pcl/filters/passthrough.h>  //直通濾波相關
//#include <pcl/common/common.h>  
//#include <iostream>
//#include <vector>
//using namespace std; 
//int main()
//{	//1.讀取點云	
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);	
//	if (pcl::io::loadPCDFile<pcl::PointXYZ>("C://Users//HEHE//Desktop//flange_filter2.pcd", *cloud) == -1)	
//	{		
//		PCL_ERROR("Cloudn't read file!");		
//		return -1;	
//	}	cout << "there are " << cloud->points.size()<<" points before filtering." << endl; 	
//	//2.取得點云坐標極值	
//	pcl::PointXYZ minPt, maxPt;	pcl::getMinMax3D(*cloud, minPt, maxPt); 	
//	//3.直通濾波	
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_filter(new pcl::PointCloud<pcl::PointXYZ>);	
//	pcl::PassThrough<pcl::PointXYZ> pass;     //創建濾波器對象	
//	pass.setInputCloud(cloud);                //設置待濾波的點云
//	//第一步過濾上下Y上
//	//pass.setFilterFieldName("y");             //設置在Z軸方向上進行濾波
//	//pass.setFilterLimits(0, maxPt.z - 12);    //設置濾波范圍(從最高點向下12米去除)在該范圍外的濾除掉
//	//pass.setFilterLimits(0, 0.5);8//點云中z坐標在括號范圍外的點過濾掉	結果全是0
//	//pass.setFilterLimits(8, 13);
//	//第二步過濾前后Z上
//	//pass.setFilterFieldName("z");
//	//pass.setFilterLimits(74.5, 85.5);
//	//第三步：過濾左右X上
//	pass.setFilterFieldName("x");
//	pass.setFilterLimits(-10, 13.5);
//	pass.setFilterLimitsNegative(false);      //保留 代表了是否顯示被過濾掉的點，如果設置為true則將被過濾的以紅色表示，沒過濾的用綠色表示。默認是false.
//	pass.filter(*cloud_filter);               //濾波并存儲 	
//	//4.濾波結果保存	
//	pcl::io::savePCDFile<pcl::PointXYZ>("C://Users//HEHE//Desktop//flange_filter3.pcd", *cloud_filter);	
//	cout << "there are " << cloud_filter->points.size() << " points after filtering." << endl;		
//	system("pause");	
//	return 0;
//}半徑濾波
//#include "pch.h"
//#include <pcl/io/pcd_io.h>  //文件輸入輸出
//#include <pcl/point_types.h>  //點類型相關定義
//#include <pcl/visualization/cloud_viewer.h>  //點云可視化相關定義
//#include <pcl/filters/radius_outlier_removal.h>  //濾波相關
//#include <pcl/common/common.h>  
//#include <iostream>
//
//using namespace std;
//
//int main()
//{
//	//1.讀取點云
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);
//	pcl::PCDReader r;
//	r.read<pcl::PointXYZ>("C://Users//HEHE//Desktop//flange_filter3_Radius_filter.pcd", *cloud);
//	cout << "there are " << cloud->points.size() << " points before filtering." << endl;
//
//	//2.半徑濾波
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_filter(new pcl::PointCloud<pcl::PointXYZ>);
//	pcl::RadiusOutlierRemoval<pcl::PointXYZ> sor;
//	sor.setInputCloud(cloud);//設置輸入點云
//	//第一次半徑濾波
//	//sor.setRadiusSearch(0.5);//設置在0.2米半徑的范圍內找鄰近點
//	//sor.setMinNeighborsInRadius(40);//設置查詢點的鄰近點集數小于15的刪除
//	sor.setRadiusSearch(0.2);//設置在0.2米半徑的范圍內找鄰近點
//	sor.setMinNeighborsInRadius(5);
//	sor.setNegative(false);
//	//sor.setKeepOrganized(true);//保持結構點云
//	sor.filter(*cloud_filter);//應用濾波器
//
//	//3.濾波結果保存
//	pcl::PCDWriter w;
//	w.writeASCII<pcl::PointXYZ>("C://Users//HEHE//Desktop//flange_filter3_Radius_filter2.pcd", *cloud_filter);
//	cout << "there are " << cloud_filter->points.size() << " points after filtering." << endl;
//
//	system("pause");
//	return 0;
//}//#include "pch.h"
//#include <pcl/ModelCoefficients.h>
//#include <pcl/point_types.h>
//#include <pcl/io/pcd_io.h>
//#include <pcl/filters/extract_indices.h>
//#include <pcl/filters/voxel_grid.h>
//#include <pcl/features/normal_3d.h>
//#include <pcl/kdtree/kdtree.h>
//#include <pcl/sample_consensus/method_types.h>
//#include <pcl/sample_consensus/model_types.h>
//#include <pcl/segmentation/sac_segmentation.h>
//#include <pcl/segmentation/extract_clusters.h>
//
//
//int
//main(int argc, char** argv)
//{
//	//讀入點云數據table_scene_lms400.pcd
//	pcl::PCDReader reader;
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>), cloud_f(new pcl::PointCloud<pcl::PointXYZ>);
//	reader.read("C://Users//HEHE//Desktop//flange_filter3_Radius_filter2.pcd", *cloud);
//	std::cout << "PointCloud before filtering has: " << cloud->points.size() << " data points." << std::endl; //*
//	///*從輸入的.PCD文件載入數據后，我們創建了一個VoxelGrid濾波器對數據進行下采樣，我們在這里進行下采樣的原       因是來加速處理過程，越少的點意味著分割循環中處理起來越快。*/
//	 Create the filtering object: downsample the dataset using a leaf size of 1cm
//	//pcl::VoxelGrid<pcl::PointXYZ> vg; //體素柵格下采樣對象
//	//pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_filtered(new pcl::PointCloud<pcl::PointXYZ>);
//	//vg.setInputCloud(cloud);
//	//vg.setLeafSize(0.01f, 0.01f, 0.01f); //設置采樣的體素大小
//	//vg.filter(*cloud_filtered);  //執行采樣保存數據
//	//std::cout << "PointCloud after filtering has: " << cloud_filtered->points.size() << " data points." << std::endl; //*
//
//	// Create the segmentation object for the planar model and set all the parameters
//	pcl::SACSegmentation<pcl::PointXYZ> seg;//創建分割對象
//	pcl::PointIndices::Ptr inliers(new pcl::PointIndices);
//	pcl::ModelCoefficients::Ptr coefficients(new pcl::ModelCoefficients);
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_plane(new pcl::PointCloud<pcl::PointXYZ>());
//	pcl::PCDWriter writer;
//	seg.setOptimizeCoefficients(true);  //設置對估計的模型參數進行優化處理
//	seg.setModelType(pcl::SACMODEL_PLANE);//設置分割模型類別
//	seg.setMethodType(pcl::SAC_RANSAC);//設置用哪個隨機參數估計方法
//	seg.setMaxIterations(100);  //設置最大迭代次數
//	seg.setDistanceThreshold(0.02);    //設置判斷是否為模型內點的距離閾值
//
//	int i = 0, nr_points = (int) cloud->points.size();
//	while (cloud ->points.size() > 0.3 * nr_points)
//	{
//		// Segment the largest planar component from the remaining cloud
//		/*為了處理點云中包含多個模型，我們在一個循環中執行該過程，并在每次模型被提取后，我們保存剩余的點，進行迭代。模型內點通過分割過程獲取，如下*/
//		seg.setInputCloud(cloud);
//		seg.segment(*inliers, *coefficients);
//		if (inliers->indices.size() == 0)
//		{
//			std::cout << "Could not estimate a planar model for the given dataset." << std::endl;
//			break;
//		}
//
//		//移去平面局內點，提取剩余點云
//		pcl::ExtractIndices<pcl::PointXYZ> extract;   //創建點云提取對象
//		extract.setInputCloud(cloud);    //設置輸入點云
//		extract.setIndices(inliers);   //設置分割后的內點為需要提取的點集
//		extract.setNegative(false); //設置提取內點而非外點
//		// Get the points associated with the planar surface
//		extract.filter(*cloud_plane);   //提取輸出存儲到cloud_plane
//		std::cout << "PointCloud representing the planar component: " << cloud_plane->points.size() << " data points." << std::endl;
//
//		// Remove the planar inliers, extract the rest
//		extract.setNegative(true);
//		extract.filter(*cloud_f);
//		*cloud = *cloud_f;
//	}
//
//	// Creating the KdTree object for the search method of the extraction
//	pcl::search::KdTree<pcl::PointXYZ>::Ptr tree(new pcl::search::KdTree<pcl::PointXYZ>);
//	tree->setInputCloud(cloud); //創建點云索引向量，用于存儲實際的點云信息
//
//	std::vector<pcl::PointIndices> cluster_indices;
//	pcl::EuclideanClusterExtraction<pcl::PointXYZ> ec;
//	ec.setClusterTolerance(4.0); //設置近鄰搜索的搜索半徑為2cm(源代碼0.02)
//	ec.setMinClusterSize(200);//設置一個聚類需要的最少點數目為100
//	ec.setMaxClusterSize(25000);//設置一個聚類需要的最大點數目為25000
//	ec.setSearchMethod(tree);//設置點云的搜索機制
//	ec.setInputCloud(cloud);
//	ec.extract(cluster_indices);//從點云中提取聚類，并將點云索引保存在cluster_indices中
//
//	/*為了從點云索引向量中分割出每個聚類，必須迭代訪問點云索引，每次創建一個新的點云數據集，并且將所有當前聚類的點寫入到點云數據集中。*/
//	//迭代訪問點云索引cluster_indices，直到分割出所有聚類
//	int j = 0;
//	for (std::vector<pcl::PointIndices>::const_iterator it = cluster_indices.begin(); it != cluster_indices.end(); ++it)
//	{
//		pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_cluster(new pcl::PointCloud<pcl::PointXYZ>);
//		//創建新的點云數據集cloud_cluster，將所有當前聚類寫入到點云數據集中
//		for (std::vector<int>::const_iterator pit = it->indices.begin(); pit != it->indices.end(); ++pit)
//			cloud_cluster->points.push_back(cloud->points[*pit]); //*
//		cloud_cluster->width = cloud_cluster->points.size();
//		cloud_cluster->height = 1;
//		cloud_cluster->is_dense = true;
//
//		std::cout << "PointCloud representing the Cluster: " << cloud_cluster->points.size() << " data points." << std::endl;
//		std::stringstream ss;
//		ss << "C://Users//HEHE//Desktop//cloud_cluster_" << j << ".pcd";
//		writer.writeASCII<pcl::PointXYZ>(ss.str(), *cloud_cluster, false); //*
//		j++;
//	}
//	
//	std::cout << "there are " << j << " yuan" << std::endl;
//
//	system("pause");
//
//	return (0);
//}歐式距離聚類，實現點云分割
//#include "pch.h"
//#include <pcl/ModelCoefficients.h>
//#include <pcl/point_types.h>
//#include <pcl/io/pcd_io.h>
//#include <pcl/filters/extract_indices.h>
//#include <pcl/filters/voxel_grid.h>
//#include <pcl/features/normal_3d.h>
//#include <pcl/kdtree/kdtree.h>
//#include <pcl/sample_consensus/method_types.h>
//#include <pcl/sample_consensus/model_types.h>
//#include <pcl/segmentation/sac_segmentation.h>
//#include <pcl/segmentation/extract_clusters.h>
//#include <iostream>
//using namespace std;
//
//int
//main(int argc, char** argv)
//{
//	// 申明存儲點云的對象.
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);
//
//	//讀取Pcd文件
//	//if (pcl::io::loadPCDFile<pcl::PointXYZ>("C://Users//HEHE//Desktop//flange_filter3_Radius_filter2.pcd", *cloud) == -1)	
//	if (pcl::io::loadPCDFile<pcl::PointXYZ>("F://cout-saved//back_1_remove.pcd", *cloud) == -1)
//	{		
//		PCL_ERROR("Cloudn't read file!");		
//		return -1;	
//	} cout << "there are " << cloud->points.size()<<" points before filtering." << endl; 	
//
//
//	// 建立kd-tree對象用來搜索 .
//	pcl::search::KdTree<pcl::PointXYZ>::Ptr kdtree(new pcl::search::KdTree<pcl::PointXYZ>);
//	kdtree->setInputCloud(cloud);
//
//	// Euclidean 聚類對象.
//	pcl::EuclideanClusterExtraction<pcl::PointXYZ> clustering;//類EuclideanClusterExtraction是基于歐式距離進行聚類分割的類
//	clustering.setClusterTolerance(4.0);//設置在歐氏空間中所使用的搜索半徑設置的過小可能導致聚類被劃分到幾個集群，設置的過大可能將聚類進行聯通
//	clustering.setMinClusterSize(100);// 設置聚類包含的的最小點數目
//	clustering.setMaxClusterSize(25000); //設置聚類包含的的最大點數目
//	clustering.setSearchMethod(kdtree);//類的關鍵成員函數
//	clustering.setInputCloud(cloud);//指定輸入的點云進行聚類分割
//	std::vector<pcl::PointIndices> clusters;// cluster存儲點云聚類分割的結果。PointIndices存儲對應點集的索引
//	clustering.extract(clusters);
//
//	// For every cluster...
//	int currentClusterNum = 1;
//	for (std::vector<pcl::PointIndices>::const_iterator i = clusters.begin(); i != clusters.end(); ++i)
//	{
//		//添加所有的點云到一個新的點云中
//		pcl::PointCloud<pcl::PointXYZ>::Ptr cluster(new pcl::PointCloud<pcl::PointXYZ>);
//		for (std::vector<int>::const_iterator point = i->indices.begin(); point != i->indices.end(); point++)
//			cluster->points.push_back(cloud->points[*point]);
//		cluster->width = cluster->points.size();
//		cluster->height = 1;
//		cluster->is_dense = true;
//
//		// 保存
//		if (cluster->points.size() <= 0)
//			break;
//		std::cout << "Cluster " << currentClusterNum << " has " << cluster->points.size() << " points." << std::endl;
//		std::string fileName = "F://cout-saved//cluster" + boost::to_string(currentClusterNum) + ".pcd";
//		pcl::io::savePCDFileASCII(fileName, *cluster);
//
//		currentClusterNum++;
//	}
//}PCL尋找點云邊界
//#include "pch.h"
//#include <iostream>
//#include <vector>
//#include <ctime>
//#include <boost/thread/thread.hpp>
//#include <pcl/io/pcd_io.h>
//#include <pcl/visualization/pcl_visualizer.h>
//#include <pcl/console/parse.h>
//#include <pcl/features/eigen.h>
//#include <pcl/features/feature.h>
//#include <pcl/features/normal_3d.h>
//#include <pcl/impl/point_types.hpp>
//#include <pcl/features/boundary.h>
//#include <pcl/visualization/cloud_viewer.h>
//using namespace std;
//
//int main(int argc, char **argv)
//{
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);//聲明數組
//	
//	if (pcl::io::loadPCDFile<pcl::PointXYZ>("C://Users//HEHE//Desktop//back_1.pcd", *cloud) == -1)
//		{		
//			PCL_ERROR("Cloudn't read file!");		
//			return -1;	
//		} 
//		
//
//	std::cout << "points size is:" << cloud->size() << std::endl;
//	pcl::PointCloud<pcl::Normal>::Ptr normals(new pcl::PointCloud<pcl::Normal>);
//	pcl::PointCloud<pcl::Boundary> boundaries;//Boundary,表示點是否位于表面邊界的描述的點結構
//
//	pcl::BoundaryEstimation<pcl::PointXYZ, pcl::Normal, pcl::Boundary> est; //BoundaryEstimation使用角度標準估計一組點是否位于表面邊界上
//
//	pcl::search::KdTree<pcl::PointXYZ>::Ptr tree(new pcl::search::KdTree<pcl::PointXYZ>());
//	
//	pcl::KdTreeFLANN<pcl::PointXYZ> kdtree;  //創建一個快速k近鄰查詢,查詢的時候若該點在點云中，則第一個近鄰點是其本身
//	kdtree.setInputCloud(cloud);
//	int k =2;
//	float everagedistance =0;
//	for (int i =0; i < cloud->size()/2;i++)
//	{
//			vector<int> nnh ; //表示定義一個容器nnh，容器內的值為int類型。（與數組類似，但是容器的大小可變）//索引
//			vector<float> squaredistance;//歐式距離
//			//  pcl::PointXYZ p;
//			//   p = cloud->points[i];
//			kdtree.nearestKSearch(cloud->points[i],k,nnh,squaredistance);
//			everagedistance += sqrt(squaredistance[1]);
//			//   cout<<everagedistance<<endl;
//	}
//
//	everagedistance = everagedistance/(cloud->size()/2);
//	cout<<"everage distance is : "<<everagedistance<<endl;
//
//	pcl::NormalEstimation<pcl::PointXYZ, pcl::Normal> normEst;  //其中pcl::PointXYZ表示輸入類型數據，pcl::Normal表示輸出類型,且pcl::Normal前三項是法向，最后一項是曲率
//	normEst.setInputCloud(cloud);
//	normEst.setSearchMethod(tree);
//	// normEst.setRadiusSearch(2);  //法向估計的半徑
//	normEst.setKSearch(15);  //法向估計的點數
//	normEst.compute(*normals);
//	cout << "normal size is " << normals->size() << endl;
//
//	//normal_est.setViewPoint(0,0,0); //這個應該會使法向一致
//	est.setInputCloud(cloud);
//	est.setInputNormals(normals);
//	//  est.setAngleThreshold(90);
//	//   est.setSearchMethod (pcl::search::KdTree<pcl::PointXYZ>::Ptr (new pcl::search::KdTree<pcl::PointXYZ>));
//	est.setSearchMethod(tree);
//	est.setKSearch(160);  //一般這里的數值越高，最終邊界識別的精度越好 //表示計算點云法向量時，搜索的點云個數
//	//est.setRadiusSearch(everagedistance*10);  //搜索半徑
//	est.compute(boundaries);
//
//	pcl::PointCloud<pcl::PointXYZ>::Ptr boundPoints(new pcl::PointCloud<pcl::PointXYZ>);
//	pcl::PointCloud<pcl::PointXYZ> noBoundPoints;
//	int countBoundaries = 0;
//	for (int i = 0; i < cloud->size(); i++) 
//	{
//		uint8_t x = (boundaries.points[i].boundary_point);
//		int a = static_cast<int>(x); //該函數的功能是強制類型轉換
//		if (a == 1)
//		{
//			//  boundPoints.push_back(cloud->points[i]);
//			(*boundPoints).push_back(cloud->points[i]);
//			countBoundaries++;
//		}
//		else
//			noBoundPoints.push_back(cloud->points[i]);
//
//	}
//	std::cout << "boudary size is：" << countBoundaries << std::endl;
//
//	pcl::io::savePCDFileASCII("C://Users//HEHE//Desktop//boudary.pcd", *boundPoints);
//	pcl::io::savePCDFileASCII("C://Users//HEHE//Desktop//NoBoundpoints.pcd", noBoundPoints);
//	pcl::visualization::CloudViewer viewer("test");
//	viewer.showCloud(boundPoints);
//	while (!viewer.wasStopped())
//	{
//	}
//	return 0;
//}2邊界
//#include "pch.h"
//#include <iostream>
//#include <pcl/console/parse.h>
//#include <pcl/filters/extract_indices.h>
//#include <pcl/io/pcd_io.h>
//#include <pcl/point_types.h> 
//#include <pcl/visualization/pcl_visualizer.h>
//#include <boost/thread/thread.hpp>
//#include <pcl/features/boundary.h>
//#include <math.h>
//#include <boost/make_shared.hpp> 
//#include <pcl/point_cloud.h>
//#include <pcl/visualization/cloud_viewer.h>  
//#include <pcl/visualization/range_image_visualizer.h>
//#include <pcl/features/normal_3d.h>  
//#include <pcl/filters/covariance_sampling.h>
//#include <pcl/filters/normal_space.h>
//#include <pcl/kdtree/kdtree_flann.h> 
//#include <pcl/io/ply_io.h> 
//#include <pcl/filters/statistical_outlier_removal.h> 
//int estimateBorders(pcl::PointCloud<pcl::PointXYZ>::Ptr &cloud,float re,float reforn) 
//{  	
//	pcl::PointCloud<pcl::Boundary> boundaries; //保存邊界估計結果	
//	pcl::BoundaryEstimation<pcl::PointXYZ, pcl::Normal, pcl::Boundary> boundEst; //定義一個進行邊界特征估計的對象	
//	pcl::NormalEstimation<pcl::PointXYZ, pcl::Normal> normEst; //定義一個法線估計的對象	
//	pcl::PointCloud<pcl::Normal>::Ptr normals(new pcl::PointCloud<pcl::Normal>); //保存法線估計的結果	
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_boundary (new pcl::PointCloud<pcl::PointXYZ>); 	
//	normEst.setInputCloud(pcl::PointCloud<pcl::PointXYZ>::Ptr(cloud)); 	
//	normEst.setRadiusSearch(reforn); //設置法線估計的半徑	
//	normEst.compute(*normals); //將法線估計結果保存至normals	
//	//輸出法線的個數	
//    std:cout<<"reforn: "<<reforn<<std::endl;	
//	std::cerr << "normals: " << normals->size() << std::endl; 	
//	boundEst.setInputCloud(cloud); //設置輸入的點云	
//	boundEst.setInputNormals(normals); //設置邊界估計的法線，因為邊界估計依賴于法線	
//	boundEst.setRadiusSearch(re); //設置邊界估計所需要的半徑	
//	boundEst.setAngleThreshold(M_PI/4); //邊界估計時的角度閾值	
//	boundEst.setSearchMethod(pcl::search::KdTree<pcl::PointXYZ>::Ptr (new pcl::search::KdTree<pcl::PointXYZ>)); //設置搜索方式KdTree	
//	boundEst.compute(boundaries); //將邊界估計結果保存在boundaries 	
//	//輸出邊界點的個數	
//	std::cerr << "boundaries: " <<boundaries.points.size() << std::endl; 	
//	//存儲估計為邊界的點云數據，將邊界結果保存為pcl::PointXYZ類型	
//	for(int i = 0; i < cloud->points.size(); i++) 	
//	{ 				
//		if(boundaries[i].boundary_point > 0) 		
//		{ 			
//			cloud_boundary->push_back(cloud->points[i]); 		
//		} 	
//	}  	
//	//可視化	
//	boost::shared_ptr<pcl::visualization::PCLVisualizer> MView (new pcl::visualization::PCLVisualizer ("點云庫PCL從入門到精通案例"));		
//	int v1(0); 	
//	MView->createViewPort (0.0, 0.0, 0.5, 1.0, v1); 	
//	MView->setBackgroundColor (0.3, 0.3, 0.3, v1); 	
//	MView->addText ("Raw point clouds", 10, 10, "v1_text", v1); 	
//	int v2(0); 
//	MView->createViewPort (0.5, 0.0, 1, 1.0, v2); 	
//	MView->setBackgroundColor (0.5, 0.5, 0.5, v2); 	
//	MView->addText ("Boudary point clouds", 10, 10, "v2_text", v2);  	
//	MView->addPointCloud<pcl::PointXYZ> (cloud, "sample cloud",v1);	
//	MView->addPointCloud<pcl::PointXYZ> (cloud_boundary, "cloud_boundary",v2);	
//	MView->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_COLOR, 1,0,0, "sample cloud",v1);	
//	MView->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_COLOR, 0,1,0, "cloud_boundary",v2);	
//	MView->addCoordinateSystem (1.0);	MView->initCameraParameters (); 	
//	MView->spin(); 	return 0;
//} 
//int	main(int argc, char** argv)
//	{	
//		//srand(time(NULL)); 	
//	float re,reforn;	
//	re=std::atof(argv[2]);	
//	reforn=std::atof(argv[3]);	
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_src (new pcl::PointCloud<pcl::PointXYZ>);    	
//	//Laden der PCD-Files 	
//	pcl::io::loadPCDFile (argv[1], *cloud_src);      
//	// 創建濾波器對象    
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_filtered(new pcl::PointCloud<pcl::PointXYZ>);    
//	pcl::StatisticalOutlierRemoval<pcl::PointXYZ> sor;    
//	sor.setInputCloud (cloud_src);    
//	sor.setMeanK (100);//尋找每個點的50個最近鄰點    
//	sor.setStddevMulThresh (1.0);//一個點的最近鄰距離超過全局平均距離的一個標準差以上，就會舍棄    
//	sor.filter (*cloud_filtered);    
//	std::cout<<"cloud_src: "<<cloud_src->points.size()<<std::endl;    
//	std::cout<<"cloud_filtered: "<<cloud_filtered->points.size()<<std::endl;  
//	estimateBorders(cloud_filtered,re,reforn); 	
//	return 0;
//}//#include "pch.h"
//#include <iostream>
//#include <vector>
//#include <ctime>
//#include <boost/thread/thread.hpp>
//#include <pcl/io/pcd_io.h>
//#include <pcl/visualization/pcl_visualizer.h>
//#include <pcl/console/parse.h>
//#include <pcl/features/eigen.h>
//#include <pcl/features/feature.h>
//#include <pcl/features/normal_3d.h>
//#include <pcl/impl/point_types.hpp>
//#include <pcl/features/boundary.h>
//#include <pcl/visualization/cloud_viewer.h>
//using namespace std;
//
//int main(int argc, char **argv)
//{
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);
//	// if (pcl::io::loadPCDFile<pcl::PointXYZ>("/home/yxg/pcl/pcd/mid.pcd",*cloud) == -1)
//	if (pcl::io::loadPCDFile<pcl::PointXYZ>("F://cout-saved//back_1.pcd", *cloud) == -1)
//	//if (pcl::io::loadPCDFile<pcl::PointXYZ>(argv[1], *cloud) == -1)
//	{
//		PCL_ERROR("COULD NOT READ FILE mid.pcl \n");
//		return (-1);
//	}
//
//	std::cout << "points sieze is:" << cloud->size() << std::endl;
//	pcl::PointCloud<pcl::Normal>::Ptr normals(new pcl::PointCloud<pcl::Normal>);
//	pcl::PointCloud<pcl::Boundary> boundaries;
//	pcl::BoundaryEstimation<pcl::PointXYZ, pcl::Normal, pcl::Boundary> est;
//	pcl::search::KdTree<pcl::PointXYZ>::Ptr tree(new pcl::search::KdTree<pcl::PointXYZ>());  //創建kdtree搜索對象
//	/*
//	pcl::KdTreeFLANN<pcl::PointXYZ> kdtree;  //創建一個快速k近鄰查詢,查詢的時候若該點在點云中，則第一個近鄰點是其本身
//	kdtree.setInputCloud(cloud);        //設置查詢空間
//	int k =2;
//	float everagedistance =0;
//	for (int i =0; i < cloud->size()/2;i++)
//	{
//			vector<int> nnh ;
//			vector<float> squaredistance;
//			//  pcl::PointXYZ p;
//			//   p = cloud->points[i];
//			kdtree.nearestKSearch(cloud->points[i],k,nnh,squaredistance);
//			everagedistance += sqrt(squaredistance[1]);
//			//   cout<<everagedistance<<endl;
//	}
//
//	everagedistance = everagedistance/(cloud->size()/2);
//	cout<<"everage distance is : "<<everagedistance<<endl;
//
//*/
//
//
//
//	pcl::NormalEstimation<pcl::PointXYZ, pcl::Normal> normEst;  //其中pcl::PointXYZ表示輸入類型數據，pcl::Normal表示輸出類型,且pcl::Normal前三項是法向，最后一項是曲率
//	normEst.setInputCloud(cloud);
//	normEst.setSearchMethod(tree);
//	std::cerr << "構建法向量" << endl;
//	normEst.setRadiusSearch(0.3);  //法向估計的半徑
//   //normEst.setKSearch(20);  //法向估計的點數
//	normEst.compute(*normals);
//	cout << "normal size is " << normals->size() << endl;
//
//	//normal_est.setViewPoint(0,0,0); //這個應該會使法向一致
//	est.setInputCloud(cloud);
//	est.setInputNormals(normals);
//	est.setAngleThreshold(M_PI / 3.0);
//	//   est.setSearchMethod (pcl::search::KdTree<pcl::PointXYZ>::Ptr (new pcl::search::KdTree<pcl::PointXYZ>));
//	est.setSearchMethod(tree);
//	//est.setKSearch(500);  //一般這里的數值越高，最終邊界識別的精度越好
//	est.setRadiusSearch(1);  //搜索半徑
//	est.compute(boundaries);
//
//
//	//  pcl::PointCloud<pcl::PointXYZ> boundPoints;
//	pcl::PointCloud<pcl::PointXYZ> boundPoints;
//	pcl::PointCloud<pcl::PointXYZ>::Ptr noBoundPoints(new pcl::PointCloud<pcl::PointXYZ>);
//
//	int countBoundaries = 0;
//	for (int i = 0; i < cloud->size(); i++) {
//		uint8_t x = (boundaries.points[i].boundary_point);
//		int a = static_cast<int>(x); //該函數的功能是強制類型轉換
//		if (a == 1)
//		{
//			//  boundPoints.push_back(cloud->points[i]);
//			boundPoints.points.push_back(cloud->points[i]);
//			countBoundaries++;
//		}
//		else
//			noBoundPoints->points.push_back(cloud->points[i]);
//
//	}
//
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloudptr(new pcl::PointCloud<pcl::PointXYZ>);
//	cloudptr = boundPoints.makeShared();
//	cloudptr->width = cloudptr->size();
//	cloudptr->height = 1;
//
//	std::cout << "boudary size is：" << countBoundaries << std::endl;
//	//  pcl::io::savePCDFileASCII("boudary.pcd",boundPoints);
//	std::cerr << "存儲文件" << std::endl;
//	std::cerr << cloudptr->size() << " " << cloudptr->width << " " << cloudptr->height << endl;
//	pcl::io::savePCDFileBinary("F://cout-saved//boudary.pcd", *cloudptr);
//
//	noBoundPoints->width = noBoundPoints->size();
//	noBoundPoints->height = 1;
//	std::cerr << "存儲非邊界點文件" << std::endl;
//	std::cerr << noBoundPoints->size() << endl;
//	pcl::io::savePCDFileBinary("F://cout-saved//NoBoundpoints.pcd", *noBoundPoints);
//
//	//可視化
//	pcl::visualization::PCLVisualizer viewer("視窗");
//	viewer.setBackgroundColor(0, 0, 0);
//
//	int v1(0);
//	int v2(1);
//	viewer.createViewPort(0.0, 0.0, 0.5, 1.0, v1);
//	viewer.createViewPort(0.5, 0.0, 1.0, 1.0, v2);
//
//	pcl::visualization::PointCloudColorHandlerGenericField<pcl::PointXYZ> fildColor(cloudptr, "z");//按照z字段進行渲染
//	pcl::visualization::PointCloudColorHandlerGenericField<pcl::PointXYZ> fildColor_r(cloud, "z");//按照z字段進行渲染
//
//	viewer.addPointCloud<pcl::PointXYZ>(cloudptr, fildColor, "sample", v1);//顯示點云，其中fildColor為顏色顯示
//	viewer.setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 1, "sample");//設置點云大小
//
//	viewer.addPointCloud<pcl::PointXYZ>(cloud, fildColor_r, "sample_1", v2);//顯示點云，其中fildColor為顏色顯示
//	viewer.setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 1, "sample_1");//設置點云大小
//	while (!viewer.wasStopped())
//	{
//		viewer.spinOnce();
//	}
//	return (0);
//}
//#include"pch.h"
//#include <iostream>
//#include <pcl/ModelCoefficients.h>
//#include <pcl/io/pcd_io.h>
//#include <pcl/point_types.h>
//#include <pcl/sample_consensus/method_types.h>   //隨機參數估計方法頭文件
//#include <pcl/sample_consensus/model_types.h>   //模型定義頭文件
//#include <pcl/segmentation/sac_segmentation.h>   //基于采樣一致性分割的類的頭文件 
//using namespace std;
//int 
//main(int argc, char** argv)
//{	
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);
//		
//	if (pcl::io::loadPCDFile<pcl::PointXYZ>("C://Users//HEHE//Desktop//cluster1.pcd", *cloud) == -1)
//		{		
//			PCL_ERROR("Cloudn't read file!");		
//			return -1;	
//		} cout << "there are points size is " << cloud->points.size()<< endl; 	
//	// 設置幾個局外點，即重新設置幾個點的z值，使其偏離z為1的平面	
//	cloud->points[0].z = 2.0;	
//	cloud->points[3].z = -2.0;	
//	cloud->points[6].z = 4.0; 	
//	std::cerr << "Point cloud data: " << cloud->points.size() << " points" << std::endl;  //打印	
//	for (size_t i = 0; i < cloud->points.size(); ++i)		
//		std::cerr << "    " << cloud->points[i].x << " "		
//		<< cloud->points[i].y << " "		
//		<< cloud->points[i].z << std::endl;	
//	//創建分割時所需要的模型系數對象，coefficients及存儲內點的點索引集合對象inliers	
//	pcl::ModelCoefficients::Ptr coefficients(new pcl::ModelCoefficients);	
//	pcl::PointIndices::Ptr inliers(new pcl::PointIndices);	
//	// 創建分割對象	
//	pcl::SACSegmentation<pcl::PointXYZ> seg;	
//	// 可選擇配置，設置模型系數需要優化	
//	seg.setOptimizeCoefficients(true);	
//	// 必要的配置，設置分割的模型類型，所用的隨機參數估計方法，距離閥值，輸入點云	
//	seg.setModelType(pcl::SACMODEL_PLANE);  
//	//設置模型類型	
//	seg.setMethodType(pcl::SAC_RANSAC);     
//	//設置隨機采樣一致性方法類型	
//	seg.setDistanceThreshold(0.01);          
//	//設定距離閥值，距離閥值決定了點被認為是局內點是必須滿足的條件，表示點到估計模型的距離最大值， 	
//	seg.setInputCloud(cloud);	
//	//引發分割實現，存儲分割結果到點幾何inliers及存儲平面模型的系數coefficients	
//	seg.segment(*inliers, *coefficients); 	
//	if (inliers->indices.size() == 0)	
//	{		
//		PCL_ERROR("Could not estimate a planar model for the given dataset.");		
//		return (-1);	
//	} 	
//	//打印出平面模型	
//	std::cerr << "Model coefficients: " << coefficients->values[0] << " "		
//		<< coefficients->values[1] << " "		
//		<< coefficients->values[2] << " "		
//		<< coefficients->values[3] << std::endl; 	
//	std::cerr << "Model inliers: " << inliers->indices.size() << std::endl;	
//	for (size_t i = 0; i < inliers->indices.size(); ++i)		
//		std::cerr << inliers->indices[i] << "    " << cloud->points[inliers->indices[i]].x << " "		
//		<< cloud->points[inliers->indices[i]].y << " "		
//		<< cloud->points[inliers->indices[i]].z << std::endl; 
//	return (0);
//}//刪除pcd格式的強度信息
//#include "pch.h"
//#include <iostream>
//#include <string.h>
//#include <pcl/io/auto_io.h>
//
//int main(int argc, char** argv)
//{
//	std::string filename = "F:\\cout-saved\\back_1.pcd";
//	pcl::PointCloud<pcl::PointXYZI>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZI>);
//	if (pcl::io::loadPCDFile(filename, *cloud) < 0)
//	{
//		std::cout << "open file error" << std::endl;
//		Sleep(3000);
//		return -1;
//	}
//
//	pcl::PointCloud<pcl::PointXYZ>::Ptr new_cloud(new pcl::PointCloud<pcl::PointXYZ >);
//	new_cloud->width = cloud->width;
//	new_cloud->height = cloud->height;
//	new_cloud->points.resize(cloud->points.size());
//	for (int i = 0; i < cloud->points.size(); ++i)
//	{
//		new_cloud->points[i].x = cloud->points[i].x;
//		new_cloud->points[i].y = cloud->points[i].y;
//		new_cloud->points[i].z = cloud->points[i].z;
//	}
//
//	if (pcl::io::savePCDFile("F:\\cout-saved\\back_1_remove.pcd", *new_cloud) < 0)
//	{
//		std::cout << "save file error" << std::endl;
//		Sleep(3000);
//		return -1;
//	}
//	else
//	{
//		std::cout << "save file success" << std::endl;
//		Sleep(3000);
//		return 0;
//	}
//}
//
//#include "pch.h"
//#include <pcl/ModelCoefficients.h>
//#include <pcl/io/pcd_io.h>
//#include <pcl/point_types.h>
//#include <pcl/filters/extract_indices.h>
//#include <pcl/filters/passthrough.h>
//#include <pcl/features/normal_3d.h>
//#include <pcl/sample_consensus/method_types.h>
//#include <pcl/sample_consensus/model_types.h>
//#include <pcl/segmentation/sac_segmentation.h>
//
//typedef pcl::PointXYZ PointT;
//
//int
//main(int argc, char** argv)
//{
//	// All the objects needed
//	pcl::PCDReader reader;                    //PCD文件讀取對象
//	pcl::PassThrough<PointT> pass;             //直通濾波對象
//	pcl::NormalEstimation<PointT, pcl::Normal> ne;  //法線估計對象
//	pcl::SACSegmentationFromNormals<PointT, pcl::Normal> seg;    //分割對象
//	pcl::PCDWriter writer;            //PCD文件讀取對象
//	pcl::ExtractIndices<PointT> extract;      //點提取對象
//	pcl::ExtractIndices<pcl::Normal> extract_normals;    ///點提取對象
//	pcl::search::KdTree<PointT>::Ptr tree(new pcl::search::KdTree<PointT>());
//
//	// Datasets
//	pcl::PointCloud<PointT>::Ptr cloud(new pcl::PointCloud<PointT>);
//	pcl::PointCloud<PointT>::Ptr cloud_filtered(new pcl::PointCloud<PointT>);
//	pcl::PointCloud<pcl::Normal>::Ptr cloud_normals(new pcl::PointCloud<pcl::Normal>);
//	pcl::PointCloud<PointT>::Ptr cloud_filtered2(new pcl::PointCloud<PointT>);
//	pcl::PointCloud<pcl::Normal>::Ptr cloud_normals2(new pcl::PointCloud<pcl::Normal>);
//	pcl::ModelCoefficients::Ptr coefficients_plane(new pcl::ModelCoefficients), coefficients_cylinder(new pcl::ModelCoefficients);
//	pcl::PointIndices::Ptr inliers_plane(new pcl::PointIndices), inliers_cylinder(new pcl::PointIndices);
//
//	// Read in the cloud data
//	reader.read("F://cout-saved//back_1_remove.pcd", *cloud);
//	std::cerr << "PointCloud has: " << cloud->points.size() << " data points." << std::endl;
//
//	// 直通濾波，將Z軸不在（0，1.5）范圍的點過濾掉，將剩余的點存儲到cloud_filtered對象中
//	pass.setInputCloud(cloud);
//	pass.setFilterFieldName("z");
//	pass.setFilterLimits(74.5, 85.5);
//	pass.filter(*cloud_filtered);
//	std::cerr << "PointCloud after filtering has: " << cloud_filtered->points.size() << " data points." << std::endl;
//
//	// 過濾后的點云進行法線估計，為后續進行基于法線的分割準備數據
//	ne.setSearchMethod(tree);
//	ne.setInputCloud(cloud_filtered);
//	ne.setKSearch(50);
//	ne.compute(*cloud_normals);
//
//	// Create the segmentation object for the planar model and set all the parameters
//	seg.setOptimizeCoefficients(true);
//	seg.setModelType(pcl::SACMODEL_NORMAL_PLANE);
//	seg.setNormalDistanceWeight(0.1);
//	seg.setMethodType(pcl::SAC_RANSAC);
//	seg.setMaxIterations(100);
//	seg.setDistanceThreshold(0.03);
//	seg.setInputCloud(cloud_filtered);
//	seg.setInputNormals(cloud_normals);
//	//獲取平面模型的系數和處在平面的內點
//	seg.segment(*inliers_plane, *coefficients_plane);
//	std::cerr << "Plane coefficients: " << *coefficients_plane << std::endl;
//
//	// 從點云中抽取分割的處在平面上的點集
//	extract.setInputCloud(cloud_filtered);
//	extract.setIndices(inliers_plane);
//	extract.setNegative(false);
//
//	// 存儲分割得到的平面上的點到點云文件
//	pcl::PointCloud<PointT>::Ptr cloud_plane(new pcl::PointCloud<PointT>());
//	extract.filter(*cloud_plane);
//	std::cerr << "PointCloud representing the planar component: " << cloud_plane->points.size() << " data points." << std::endl;
//	writer.write("F://cout-saved//table_scene_mug_stereo_textured_plane.pcd", *cloud_plane, false);
//
//	// Remove the planar inliers, extract the rest
//	extract.setNegative(true);
//	extract.filter(*cloud_filtered2);
//	extract_normals.setNegative(true);
//	extract_normals.setInputCloud(cloud_normals);
//	extract_normals.setIndices(inliers_plane);
//	extract_normals.filter(*cloud_normals2);
//
//	// Create the segmentation object for cylinder segmentation and set all the parameters
//	seg.setOptimizeCoefficients(true);   //設置對估計模型優化
//	seg.setModelType(pcl::SACMODEL_CYLINDER);  //設置分割模型為圓柱形
//	seg.setMethodType(pcl::SAC_RANSAC);       //參數估計方法
//	seg.setNormalDistanceWeight(0.1);       //設置表面法線權重系數
//	seg.setMaxIterations(10000);              //設置迭代的最大次數10000
//	seg.setDistanceThreshold(0.05);         //設置內點到模型的距離允許最大值
//	seg.setRadiusLimits(0, 0.1);             //設置估計出的圓柱模型的半徑的范圍
//	seg.setInputCloud(cloud_filtered2);
//	seg.setInputNormals(cloud_normals2);
//
//	// Obtain the cylinder inliers and coefficients
//	seg.segment(*inliers_cylinder, *coefficients_cylinder);
//	std::cerr << "Cylinder coefficients: " << *coefficients_cylinder << std::endl;
//
//	// Write the cylinder inliers to disk
//	extract.setInputCloud(cloud_filtered2);
//	extract.setIndices(inliers_cylinder);
//	extract.setNegative(false);
//	pcl::PointCloud<PointT>::Ptr cloud_cylinder(new pcl::PointCloud<PointT>());
//	extract.filter(*cloud_cylinder);
//	if (cloud_cylinder->points.empty())
//		std::cerr << "Can't find the cylindrical component." << std::endl;
//	else
//	{
//		std::cerr << "PointCloud representing the cylindrical component: " << cloud_cylinder->points.size() << " data points." << std::endl;
//		writer.write("F://cout-saved//table_scene_mug_stereo_textured_cylinder.pcd", *cloud_cylinder, false);
//	}
//	return (0);
//}//#include "pch.h"
//#include <pcl/io/pcd_io.h>  //文件輸入輸出
//#include <pcl/point_types.h>  //點類型相關定義
//#include <pcl/visualization/cloud_viewer.h>  //點云可視化相關定義
//#include <pcl/filters/radius_outlier_removal.h>  //濾波相關
//#include <pcl/common/common.h>  
//#include <iostream>
//
//using namespace std;
//
//int main()
//{
//	//1.讀取點云
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);
//	pcl::PCDReader r;
//	r.read<pcl::PointXYZ>("F://cout-saved//back_1.pcd", *cloud);
//	cout << "there are " << cloud->points.size() << " points before filtering." << endl;
//
//	//2.半徑濾波
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_filter(new pcl::PointCloud<pcl::PointXYZ>);
//	pcl::RadiusOutlierRemoval<pcl::PointXYZ> sor;
//	sor.setInputCloud(cloud);
//	//sor.setRadiusSearch(0.02);//0.02米
//	sor.setRadiusSearch(0.8);//搜查半徑0.8mm
//	sor.setMinNeighborsInRadius(100);
//	sor.setNegative(false);
//	sor.filter(*cloud_filter);
//
//	//3.濾波結果保存
//	pcl::PCDWriter w;
//	w.writeASCII<pcl::PointXYZ>("F://cout-saved//back_1_radius.pcd", *cloud_filter);
//	cout << "there are " << cloud_filter->points.size() << " points after filtering." << endl;
//
//	system("pause");
//	return 0;
//}統計濾波
//#include "pch.h"
//#include <iostream>
//#include <pcl/io/pcd_io.h>
//#include <pcl/point_types.h>
//#include <pcl/filters/statistical_outlier_removal.h> 
//int
//main (int argc, char** argv)
//{  
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud (new pcl::PointCloud<pcl::PointXYZ>); 
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_filtered (new pcl::PointCloud<pcl::PointXYZ>);   // 定義讀取對象  
//	pcl::PCDReader reader;  // 讀取點云文件  
//	reader.read<pcl::PointXYZ> ("F://cout-saved//back_1.pcd", *cloud);   
//	std::cerr << "Cloud before filtering: " << std::endl;  
//	std::cerr << *cloud << std::endl;   
//	// 創建濾波器，對每個點分析的臨近點的個數設置為50 ，并將標準差的倍數設置為1  這意味著如果一   
//	//個點的距離超出了平均距離一個標準差以上，則該點被標記為離群點，并將它移除，存儲起來  
//	pcl::StatisticalOutlierRemoval<pcl::PointXYZ> sor;   //創建濾波器對象  
//	sor.setInputCloud (cloud);                            //設置待濾波的點云  
//	//sor.setMeanK (100);                               //設置在進行統計時考慮查詢點臨近點數  
//	//sor.setStddevMulThresh (1.0);   //back_1_inliers.pcd                   //設置判斷是否為離群點的閥值  
//
//	sor.setMeanK (250);                               //設置在進行統計時考慮查詢點臨近點數  
//	//sor.setStddevMulThresh (1.0); //2 
//	//sor.setStddevMulThresh(2.0);//3
//	//sor.setStddevMulThresh(0.6);//4
//	sor.setStddevMulThresh(0.3);//4
//	sor.filter (*cloud_filtered);                    //存儲   
//	std::cerr << "Cloud after filtering: " << std::endl; 
//	std::cerr << *cloud_filtered << std::endl;   
//	pcl::PCDWriter writer;  writer.write<pcl::PointXYZ> ("F://cout-saved//back_1_inliers5.pcd", *cloud_filtered, false);   
//	sor.setNegative (true);  
//	sor.filter (*cloud_filtered);  
//	writer.write<pcl::PointXYZ> ("F://cout-saved//back_1_outliers5.pcd", *cloud_filtered, false);   
//	return (0);
//}分離地面
//#include "pch.h"
//#include <iostream>
//#include <pcl/ModelCoefficients.h>
//#include <pcl/io/pcd_io.h>
//#include <pcl/point_types.h>
//#include <pcl/sample_consensus/method_types.h>
//#include <pcl/sample_consensus/model_types.h>
//#include <pcl/segmentation/sac_segmentation.h>
//#include <pcl/visualization/cloud_viewer.h>
//#include <pcl/filters/extract_indices.h> 
//void viewerOneOff(pcl::visualization::PCLVisualizer& viewer)
//{    
//	viewer.setBackgroundColor(0,0,1);
//} 
//int main (int argc, char** argv)
//{    
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);    
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_filtered(new pcl::PointCloud<pcl::PointXYZ>);    
//	pcl::PCDReader reader;    // 讀入點云PCD文件    
//	reader.read("F://cout-saved//back_1_inliers5.pcd",*cloud);     
//	std::cerr << "Point cloud data: " << cloud->points.size () << " points" << std::endl;        
//	pcl::ModelCoefficients::Ptr coefficients (new pcl::ModelCoefficients);    
//	pcl::PointIndices::Ptr inliers (new pcl::PointIndices);    
//	// Create the segmentation object    
//	pcl::SACSegmentation<pcl::PointXYZ> seg;//創建一個分割方法
//	// pcl::ModelCoefficients coefficients; //申明模型的參數
//   // pcl::PointIndices inliers; //申明存儲模型的內點的索引
//	// Optional    
//	seg.setOptimizeCoefficients (true);//選擇最優化參數的因子    
//	// Mandatory    
//	seg.setModelType (pcl::SACMODEL_PLANE);//平面模型    
//	seg.setMethodType (pcl::SAC_RANSAC);//分割平面模型所用的分割方法
//	//在這個Plane Model Segmentation算法里，Ransac為了找到點云的平面，不停的改變平面模型（ax + by + cz + d = 0）的參數：a, b, c和d。
//	//經過多次調參后，找出哪一組的參數能使得這個模型一定程度上擬合最多的點。
//	//這個程度就是由distance threshold這個參數來設置。那找到這組參數后，這些能夠被擬合的點就是平面的點
//	//設置誤差容忍范圍  設置最小的距離閾值 單位mm（根據自己的數據單位為mm，所以此處也是毫米單位）    
//	seg.setDistanceThreshold (0.4);//把distance threshold調大，離平面更遠的點也被算進平面來。distance threshold 可以等同于平面厚度閾值    
//	seg.setInputCloud (cloud);//設置輸入的點云    
//	seg.segment (*inliers, *coefficients);    
//	if (inliers->indices.size () == 0)    
//	{        
//		PCL_ERROR ("Could not estimate a planar model for the given dataset.");        
//		return (-1);   
//	}      
//	// 提取地面    
//	pcl::ExtractIndices<pcl::PointXYZ> extract;//ExtractIndices濾波器，基于某一分割算法提取點云中的一個子集    
//	extract.setInputCloud (cloud);    
//	extract.setIndices (inliers);//設置分割后的內點為需要提取的點集    
//	extract.filter (*cloud_filtered);     
//	std::cerr << "Ground cloud after filtering: " << std::endl;    
//	std::cerr << *cloud_filtered << std::endl;     
//	pcl::PCDWriter writer;    
//	writer.write<pcl::PointXYZ> ("F://cout-saved//back_1_inliers5_ground.pcd", *cloud_filtered, false);     
//	// 提取除地面外的物體    
//	extract.setNegative (true);//設置提取內點而非外點 或者相反   
//	extract.filter (*cloud_filtered);     
//	std::cerr << "Object cloud after filtering: " << std::endl;    
//	std::cerr << *cloud_filtered << std::endl;     
//	writer.write<pcl::PointXYZ> ("F://cout-saved//back_1_inliers5_No_ground.pcd", *cloud_filtered, false);     
//	// 點云可視化    
//	pcl::visualization::CloudViewer viewer("Filtered");    
//	viewer.showCloud(cloud_filtered);    
//	viewer.runOnVisualizationThreadOnce(viewerOneOff);    
//	while(!viewer.wasStopped())
//	{        }    
//	return (0);
//}
////#include "pch.h"
//#include <iostream>           //標準C++庫中的輸入輸出類相關頭文件。
//#include <pcl/io/pcd_io.h>   //pcd 讀寫類相關的頭文件。
//#include <pcl/point_types.h> //PCL中支持的點類型頭文件。
//#include <pcl/common/common.h> 
//double Max_X;
//double Min_X;
//double Max_Z;
//double Min_Z;
//int
//main(int argc, char** argv)
//{
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_filtered(new pcl::PointCloud<pcl::PointXYZ>);   // 定義讀取對象  
//	pcl::PCDReader reader;  // 讀取點云文件  
//	reader.read<pcl::PointXYZ>("F://cout-saved//back_1.pcd", *cloud);
//	std::cerr << "Cloud before filtering: " << std::endl;
//	std::cerr << *cloud << std::endl;
//	//定義儲存極值的兩個點
//	pcl::PointXYZ minpt, maxpt;
//	pcl::getMinMax3D(*cloud, minpt, maxpt);
//	//輸出結果
//	/*std::cout << "max:x" << maxpt.x << std::endl;
//	std::cout << "max:y" << maxpt.y << std::endl;
//	std::cout << "max:z" << maxpt.z << std::endl;
//	std::cout << "min:x" << minpt.x << std::endl;
//	std::cout << "min:y" << minpt.y << std::endl;
//	std::cout << "min:z" << minpt.z << std::endl;*/
//	Max_X = maxpt.x;
//	Min_X = minpt.x;
//	Max_Z = maxpt.z;
//	Min_Z = minpt.z;
//	std::cout << "max:X : " << Max_X << std::endl;
//	std::cout << "min:X : " << Min_X << std::endl;
//	std::cout << "max:Z : " << Max_Z << std::endl;
//	std::cout << "min:Z : " << Min_Z << std::endl;
//
//
//
//	system("pause");
//	return 0;
//}PCL尋找點云邊界
//#include "pch.h"
//#include <iostream>
//#include <vector>
//#include <ctime>
//#include <boost/thread/thread.hpp>
//#include <pcl/io/pcd_io.h>
//#include <pcl/visualization/pcl_visualizer.h>
//#include <pcl/console/parse.h>
//#include <pcl/features/eigen.h>
//#include <pcl/features/feature.h>
//#include <pcl/features/normal_3d.h>
//#include <pcl/impl/point_types.hpp>
//#include <pcl/features/boundary.h>
//#include <pcl/visualization/cloud_viewer.h>
//using namespace std;
//
//int main(int argc, char **argv)
//{
//	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);//聲明數組
//
//	if (pcl::io::loadPCDFile<pcl::PointXYZ>("F://cout-saved//back_1.pcd", *cloud) == -1)
//	{
//		PCL_ERROR("Cloudn't read file!");
//		return -1;
//	}
//
//
//	std::cout << "points size is:" << cloud->size() << std::endl;
//	pcl::PointCloud<pcl::Normal>::Ptr normals(new pcl::PointCloud<pcl::Normal>);
//	pcl::PointCloud<pcl::Boundary> boundaries;//Boundary,表示點是否位于表面邊界的描述的點結構
//
//	pcl::BoundaryEstimation<pcl::PointXYZ, pcl::Normal, pcl::Boundary> est; //BoundaryEstimation使用角度標準估計一組點是否位于表面邊界上
//
//	pcl::search::KdTree<pcl::PointXYZ>::Ptr tree(new pcl::search::KdTree<pcl::PointXYZ>());
//
//	pcl::KdTreeFLANN<pcl::PointXYZ> kdtree;  //創建一個快速k近鄰查詢,查詢的時候若該點在點云中，則第一個近鄰點是其本身
//	kdtree.setInputCloud(cloud);
//
//	pcl::NormalEstimation<pcl::PointXYZ, pcl::Normal> normEst;  //其中pcl::PointXYZ表示輸入類型數據，pcl::Normal表示輸出類型,且pcl::Normal前三項是法向，最后一項是曲率
//	normEst.setInputCloud(cloud);
//	normEst.setSearchMethod(tree);
//
//	normEst.setKSearch(15);  //法向估計的點數
//	normEst.compute(*normals);
//	cout << "normal size is " << normals->size() << endl;
//
//	//normal_est.setViewPoint(0,0,0); //這個應該會使法向一致
//	est.setInputCloud(cloud);
//	est.setInputNormals(normals);
//	//  est.setAngleThreshold(90);
//
//	est.setSearchMethod(tree);
//	est.setKSearch(160);  //一般這里的數值越高，最終邊界識別的精度越好 //表示計算點云法向量時，搜索的點云個數
//
//	est.compute(boundaries);
//
//	pcl::PointCloud<pcl::PointXYZ>::Ptr boundPoints(new pcl::PointCloud<pcl::PointXYZ>);
//	pcl::PointCloud<pcl::PointXYZ> noBoundPoints;
//	int countBoundaries = 0;
//	for (int i = 0; i < cloud->size(); i++)
//	{
//		uint8_t x = (boundaries.points[i].boundary_point);
//		int a = static_cast<int>(x); //該函數的功能是強制類型轉換
//		if (a == 1)
//		{
//			//  boundPoints.push_back(cloud->points[i]);
//			(*boundPoints).push_back(cloud->points[i]);
//			countBoundaries++;
//		}
//		else
//			noBoundPoints.push_back(cloud->points[i]);
//
//	}
//	std::cout << "boudary size is：" << countBoundaries << std::endl;
//
//	pcl::io::savePCDFileBinary("F://cout-saved//boudary.pcd", *boundPoints);
//	pcl::io::savePCDFileBinary("F://cout-saved//NoBoundpoints.pcd", noBoundPoints);
//	pcl::visualization::CloudViewer viewer("test");
//	viewer.showCloud(boundPoints);
//	while (!viewer.wasStopped())
//	{
//	}
//	return 0;
//}

?

總結

以上是生活随笔為你收集整理的不知道什么时间收集的code的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。