点云分割是根据空间，几何和纹理等特征对点云进行划分，使得同一划分内的点云拥有相似的特征，点云的有效分割往往是许多应用的前提，例如逆向工作，CAD领域对零件的不同扫描表面进行分割，然后才能更好的进行空洞修复曲面重建，特征描述和提取，进而进行基于3D内容的检索，组合重用等。

案例分析

用一组点云数据做简单的平面的分割：

planar_segmentation.cpp

#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  = ;

  cloud->height = ;

  cloud->points.resize (cloud->width * cloud->height);

  // 生成数据，采用随机数填充点云的x,y坐标，都处于z为1的平面上

  for (size_t i = ; i < cloud->points.size (); ++i)

  {

    cloud->points[i].x =  * rand () / (RAND_MAX + 1.0f);

    cloud->points[i].y =  * rand () / (RAND_MAX + 1.0f);

    cloud->points[i].z = 1.0;

  }

  // 设置几个局外点，即重新设置几个点的z值，使其偏离z为1的平面

  cloud->points[].z = 2.0;

  cloud->points[].z = -2.0;

  cloud->points[].z = 4.0;

  std::cerr << "Point cloud data: " << cloud->points.size () << " points" << std::endl;  //打印

  for (size_t i = ; 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 () == )

  {

    PCL_ERROR ("Could not estimate a planar model for the given dataset.");

    return (-);

  }

  //打印出平面模型

  std::cerr << "Model coefficients: " << coefficients->values[] << " "

                                      << coefficients->values[] << " "

                                      << coefficients->values[] << " "

                                      << coefficients->values[] << std::endl;

  std::cerr << "Model inliers: " << inliers->indices.size () << std::endl;

  for (size_t i = ; 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 ();

}

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

（2）实现圆柱体模型的分割：采用随机采样一致性估计从带有噪声的点云中提取一个圆柱体模型。

新建文件cylinder_segmentation.cpp

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

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

  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

  seg.setDistanceThreshold (0.05);         //设置内点到模型的距离允许最大值

  seg.setRadiusLimits (, 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 ();

}

试验打印的结果如下

原始点云可视化的结果.三维场景中有平面，杯子，和其他物体

产生分割以后的平面和圆柱点云，查看的结果如下

   

（3）PCL中实现欧式聚类提取。对三维点云组成的场景进行分割

#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 (new pcl::PointCloud<pcl::PointXYZ> ());

  pcl::PCDWriter writer;

  seg.setOptimizeCoefficients (true);

  seg.setModelType (pcl::SACMODEL_PLANE);    //分割模型

  seg.setMethodType (pcl::SAC_RANSAC);       //随机参数估计方法

  seg.setMaxIterations ();                //最大的迭代的次数

  seg.setDistanceThreshold (0.02);           //设置阀值

  int i=, 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 () == )

    {

      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

  ec.setMaxClusterSize ();               //设置一个聚类需要的最大点数目为25000

  ec.setSearchMethod (tree);                    //设置点云的搜索机制

  ec.setInputCloud (cloud_filtered);

  ec.extract (cluster_indices);           //从点云中提取聚类，并将点云索引保存在cluster_indices中

  //迭代访问点云索引cluster_indices,直到分割处所有聚类

  int j = ;

  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 = ;

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

}

运行结果：

不再一一查看可视化的结果

为了更切合实际的应用我会在这些基本的程序的基础上，进行与实际结合的实例，因为这些都是官方给的实例，我是首先学习一下，至少过一面，这样在后期结合实际应用的过程中会更加容易一点。（因为我也是一边学习，然后回头再在基础上进行更修）

同时有很多在我的微信公众号上的同学后台与我交流，有时候不能即时回复敬请谅解，（之前，就有一个不知道哪个学校的关注后就一直问我问题，告诉它基本的案例，还要我告诉他怎么实现，本人不才，我也是入门者阿，）

请扫面二维码关注

最新文章

  1. 窗体作为控件嵌入panel
  2. md5算法
  3. linux的&lt;pthread.h&gt;
  4. Win7 x64下进程保护与文件保护(ObRegisterCallbacks)
  5. php 下载远程图片 的几种方法(转)
  6. poj 1201 差分约束
  7. 学习Learn Python The Hard Way 前言中的一段话，可与君共勉
  8. Array.asList()注意
  9. jquery parseInt()的问题
  10. if else配对问题
  11. UVa 11408 - Count DePrimes
  12. hdu 3986 Harry Potter and the Final Battle
  13. BZOJ 4517: [Sdoi2016]排列计数 [容斥原理]
  14. Vue项目搭建及原理二
  15. UVA - 11997：K Smallest Sums
  16. uni-app编写小程序
  17. 关于python中loc和iloc方法
  18. java的OSGi确实是个坑
  19. （一）python的前世今生
  20. Centos、Ubuntu开启命令模式

热门文章

  1. windows 64位下,React-Native环境搭建详解 (Android)
  2. InlineModelAdmin对象的学习
  3. JAVA中如何正确的用String转Date
  4. Vue（六）：条件与循环
  5. keepAlive参数详解
  6. Spring boot 通用配置文件模板
  7. gf框架之grpool - 高性能的goroutine池
  8. 菜鸟学Java（十五）——Java反射机制（二）
  9. redis中键空间通知
  10. JAVA Zero Copy的相关知识【转】