PCL点云分割（1）

#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>   //基于采样一致性分割的类的头文件

int
main (int argc, char** argv)
{
pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);    // 填充点云
 cloud->width  = 15;
 cloud->height = 1;
 cloud->points.resize (cloud->width * cloud->height);  
// 生成数据，采用随机数填充点云的x,y坐标，都处于z为1的平面上
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 = 1.0;
 } 
 // 设置几个局外点，即重新设置几个点的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);
}

结果如下：开始打印的数据为手动添加的点云数据，并非都处于z为1的平面上，通过分割对象的处理后提取所有内点，即过滤掉z不等于1的点集

#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;intmain (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> ()); 
 

 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 ("table_scene_mug_stereo_textured.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 (0, 1.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 ("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 ("table_scene_mug_stereo_textured_cylinder.pcd", *cloud_cylinder, false);
 }  return (0);
}

#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)
{  
// Read in the cloud data  
  pcl::PCDReader reader;
pcl::PointCloud<pcl::PointXYZ>::Ptr cloud (new pcl::PointCloud<pcl::PointXYZ>), cloud_f (new pcl::PointCloud<pcl::PointXYZ>);
 
reader.read ("table_scene_lms400.pcd", *cloud);
 std::cout << "PointCloud before filtering has: " << cloud->points.size () << " data points." << std::endl; //*

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

//创建平面模型分割的对象并设置参数
 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 (newpcl::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_filtered->points.size ();  

while (cloud_filtered->points.size () > 0.3 * nr_points)
 {    
// Segment the largest planar component from the remaining cloud    seg.setInputCloud (cloud_filtered);
   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_filtered);
   extract.setIndices (inliers);
   extract.setNegative (false);    

// Get the points associated with the planar surface    extract.filter (*cloud_plane);
   std::cout << "PointCloud representing the planar component: " << cloud_plane->points.size () << " data points." << std::endl;    //  
    
    // 移去平面局内点，提取剩余点云
   extract.setNegative (true);
   extract.filter (*cloud_f);   
    *cloud_filtered = *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_filtered); std::vector<pcl::PointIndices> cluster_indices;
 pcl::EuclideanClusterExtraction<pcl::PointXYZ> ec;   //欧式聚类对象
 ec.setClusterTolerance (0.02);             // 设置近邻搜索的搜索半径为2cm
 ec.setMinClusterSize (100);                 //设置一个聚类需要的最少的点数目为100
 ec.setMaxClusterSize (25000);               //设置一个聚类需要的最大点数目为25000
 ec.setSearchMethod (tree);                    //设置点云的搜索机制  ec.setInputCloud (cloud_filtered);
 ec.extract (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>);    

for (std::vector<int>::const_iterator pit = it->indices.begin (); pit != it->indices.end (); ++pit)
   
   cloud_cluster->points.push_back (cloud_filtered->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 << "cloud_cluster_" << j << ".pcd";
   writer.write<pcl::PointXYZ> (ss.str (), *cloud_cluster, false); //*
   j++;
 }  
return (0);
}