devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

自动驾驶中的LiDAR点云分割算法有哪些？盘一盘业内常用的方法！

作者：知新_RL | 2024-03-13 14:15:24

赞

踩

激光点云地面分割综述

作者 | 高毅鹏  编辑 | 汽车人

原文链接：https://zhuanlan.zhihu.com/p/613155662

点击下方卡片，关注“自动驾驶之心”公众号

ADAS巨卷干货，即可获取

点击进入→自动驾驶之心【语义分割】技术交流群

后台回复【分割综述】获取语义分割、实例分割、全景分割、弱监督分割等超全学习资料！

目前常见的激光点云分割算法有基于平面拟合的方法和基于激光点云数据特点的方法两类。具体如下：

f5b150714461345eac84795e5131f9c7.png
点云地面分割算法

1基于平面拟合的方法-Ground Plane Fitting

算法思想：一种简单的处理方法就是沿着x方向（车头的方向）将空间分割成若干个子平面，然后对每个子平面使用地面平面拟合算法（GPF）从而得到能够处理陡坡的地面分割方法。该方法是在单帧点云中拟合全局平面，在点云数量较多时效果较好，点云稀疏时极易带来漏检和误检，比如16线激光雷达。

算法伪代码：

27a3aa048ecd22b39d332e58a3cf84e5.png
伪代码

算法流程是对于给定的点云 P ,分割的最终结果为两个点云集合，地面点云  和非地面点云  。此算法有四个重要参数，如下：

  • Niter : 进行奇异值分解(SVD)的次数，也即进行优化拟合的次数

  • NLPR : 用于选取LPR的最低高度点的数量

  • Thseed : 用于选取种子点的阈值，当点云内的点的高度小于LPR的高度加上此阈值时，我们将该点加入种子点集

  • Thdist : 平面距离阈值，我们会计算点云中每一个点到我们拟合的平面的正交投影的距离，而这个平面距离阈值，就是用来判定点是否属于地面

种子点集的选择

我们首先选取一个种子点集(seed point set)，这些种子点来源于点云中高度（即z值）较小的点，种子点集被用于建立描述地面的初始平面模型，那么如何选取这个种子点集呢？我们引入最低点代表（Lowest Point Representative, LPR）的概念。LPR就是NLPR个最低高度点的平均值，LPR保证了平面拟合阶段不受测量噪声的影响。

36462f757bcd2cf2b2250d4b32b7c2db.png
种子点的选择

输入是一帧点云，这个点云内的点已经沿着z方向（即高度）做了排序，取 num_lpr_ 个最小点，求得高度平均值 lpr_height（即LPR），选取高度小于 lpr_height + th_seeds_的点作为种子点。

具体代码实现如下：

  1. /*
  2.     @brief Extract initial seeds of the given pointcloud sorted segment.
  3.     This function filter ground seeds points accoring to heigt.
  4.     This function will set the `g_ground_pc` to `g_seed_pc`.
  5.     @param p_sorted: sorted pointcloud
  6.     
  7.     @param ::num_lpr_: num of LPR points
  8.     @param ::th_seeds_: threshold distance of seeds
  9.     @param ::
  10. */
  11. void PlaneGroundFilter::extract_initial_seeds_(const pcl::PointCloud<VPoint> &p_sorted)
  12. {
  13.     // LPR is the mean of low point representative
  14.     double sum = 0;
  15.     int cnt = 0;
  16.     // Calculate the mean height value.
  17.     for (int i = 0; i < p_sorted.points.size() && cnt < num_lpr_; i++)
  18.     {
  19.         sum += p_sorted.points[i].z;
  20.         cnt++;
  21.     }
  22.     double lpr_height = cnt != 0 ? sum / cnt : 0; // in case divide by 0
  23.     g_seeds_pc->clear();
  24.     // iterate pointcloud, filter those height is less than lpr.height+th_seeds_
  25.     for (int i = 0; i < p_sorted.points.size(); i++)
  26.     {
  27.         if (p_sorted.points[i].z < lpr_height + th_seeds_)
  28.         {
  29.             g_seeds_pc->points.push_back(p_sorted.points[i]);
  30.         }
  31.     }
  32.     // return seeds points
  33. }

平面模型

接下来我们建立一个平面模型，点云中的点到这个平面的正交投影距离小于阈值Thdist，则认为该点属于地面，否则属于非地面。采用一个简单的线性模型用于平面模型估计，如下：

ax+by+cz+d=0

即：

3a88c8e908c924e3a3156b88919ddaee.png

其中d30966fcabe811125ed268fa5e859faf.png,通过初始点集的协方差矩阵C来求解n，从而确定一个平面，种子点集作为初始点集，其协方差矩阵为

f72ad452b0751da691499645d933ff92.png

这个协方差矩阵 C 描述了种子点集的散布情况，其三个奇异向量可以通过奇异值分解（SVD）求得，这三个奇异向量描述了点集在三个主要方向的散布情况。由于是平面模型，垂直于平面的法向量 n 表示具有最小方差的方向，可以通过计算具有最小奇异值的奇异向量来求得。

那么在求得了 n 以后， d 可以通过代入种子点集的平均值  ,s(它代表属于地面的点) 直接求得。整个平面模型计算代码如下：

  1. /*
  2.     @brief The function to estimate plane model. The
  3.     model parameter `normal_` and `d_`, and `th_dist_d_`
  4.     is set here.
  5.     The main step is performed SVD(UAV) on covariance matrix.
  6.     Taking the sigular vector in U matrix according to the smallest
  7.     sigular value in A, as the `normal_`. `d_` is then calculated 
  8.     according to mean ground points.
  10.     @param g_ground_pc:global ground pointcloud ptr.
  11.     
  12. */
  13. void PlaneGroundFilter::estimate_plane_(void)
  14. {
  15.     // Create covarian matrix in single pass.
  16.     // TODO: compare the efficiency.
  17.     Eigen::Matrix3f cov;
  18.     Eigen::Vector4f pc_mean;
  19.     pcl::computeMeanAndCovarianceMatrix(*g_ground_pc, cov, pc_mean);
  20.     // Singular Value Decomposition: SVD
  21.     JacobiSVD<MatrixXf> svd(cov, Eigen::DecompositionOptions::ComputeFullU);
  22.     // use the least singular vector as normal
  23.     normal_ = (svd.matrixU().col(2));
  24.     // mean ground seeds value
  25.     Eigen::Vector3f seeds_mean = pc_mean.head<3>();
  26.  
  27.     // according to normal.T*[x,y,z] = -d
  28.     d_ = -(normal_.transpose() * seeds_mean)(0, 0);
  29.     // set distance threhold to `th_dist - d`
  30.     th_dist_d_ = th_dist_ - d_;
  31.  
  32.     // return the equation parameters
  33. }

优化平面主循环

  1. extract_initial_seeds_(laserCloudIn);
  2. g_ground_pc = g_seeds_pc;
  3. // Ground plane fitter mainloop
  4. for (int i = 0; i < num_iter_; i++)
  5. {
  6.     estimate_plane_();
  7.     g_ground_pc->clear();
  8.     g_not_ground_pc->clear();
  9.  
  10.     //pointcloud to matrix
  11.     MatrixXf points(laserCloudIn_org.points.size(), 3);
  12.     int j = 0;
  13.     for (auto p : laserCloudIn_org.points)
  14.     {
  15.         points.row(j++) << p.x, p.y, p.z;
  16.     }
  17.     // ground plane model
  18.     VectorXf result = points * normal_;
  19.     // threshold filter
  20.     for (int r = 0; r < result.rows(); r++)
  21.     {
  22.         if (result[r] < th_dist_d_)
  23.         {
  24.             g_all_pc->points[r].label = 1u; // means ground
  25.             g_ground_pc->points.push_back(laserCloudIn_org[r]);
  26.         }
  27.         else
  28.         {
  29.             g_all_pc->points[r].label = 0u; // means not ground and non clusterred
  30.             g_not_ground_pc->points.push_back(laserCloudIn_org[r]);
  31.         }
  32.     }
  33. }

得到这个初始的平面模型以后，我们会计算点云中每一个点到该平面的正交投影的距离，即 points * normal_，并且将这个距离与设定的阈值  (即th_dist_d_) 比较，当高度差小于此阈值，我们认为该点属于地面，当高度差大于此阈值，则为非地面点。经过分类以后的所有地面点被当作下一次迭代的种子点集，迭代优化。

2基于雷达数据本身特点的方法-Ray Ground Filter

https://github.com/suyunzzz/ray_filter_ground

算法思想

Ray Ground Filter算法的核心是以射线（Ray）的形式来组织点云。将点云的 (x, y, z)三维空间降到（x,y）平面来看，计算每一个点到车辆x正方向的平面夹角 θ, 对360度进行微分，分成若干等份，每一份的角度为0.2度。

a65b9acc686b514d9f1059b84dc708f3.png
激光线束等间隔划分示意图（通常以激光雷达角度分辨率划分）
fffe9ca4f17df142b1ec954a9fe15d39.png
同一角度范围内激光线束在水平面的投影以及在Z轴方向的高度折线示意图

为了方便对同一角度的线束进行处理，要将原来直角坐标系的点云转换成柱坐标描述的点云数据结构。对同一夹角的线束上的点按照半径的大小进行排序，通过前后两点的坡度是否大于我们事先设定的坡度阈值，从而判断点是否为地面点。

0334dc91a9975d93b11cc42498876814.png
线激光线束纵截面与俯视示意图（n=4）

通过如下公式转换成柱坐标的形式：

9e9028da7996e55735286a249190d47d.png
转换成柱坐标的公式

radius表示点到lidar的水平距离(半径)，theta是点相对于车头正方向(即x方向)的夹角。对点云进行水平角度微分之后，可得到1800条射线，将这些射线中的点按照距离的远近进行排序。通过两个坡度阈值以及当前点的半径求得高度阈值，通过判断当前点的高度（即点的z值）是否在地面加减高度阈值范围内来判断当前点是为地面。

伪代码

fc001afdbc92066a02957b66f0f4dd60.png
伪代码

  • local_max_slope_ ：设定的同条射线上邻近两点的坡度阈值。

  • general_max_slope_ ：整个地面的坡度阈值

遍历1800条射线，对于每一条射线进行如下操作：

  1. 计算当前点和上一个点的水平距离pointdistance

  2. 根据local_max_slope_和pointdistance计算当前的坡度差阈值height_threshold

  3. 根据general_max_slope_和当前点的水平距离计算整个地面的高度差阈值general_height_threshold

  4. 若当前点的z坐标小于前一个点的z坐标加height_threshold并大于前一个点的z坐标减去height_threshold：

  5. 若当前点z坐标小于雷达安装高度减去general_height_threshold并且大于相加，认为是地面点

  6. 否则：是非地面点。

  7. 若pointdistance满足阈值并且前点的z坐标小于雷达安装高度减去height_threshold并大于雷达安装高度加上height_threshold，认为是地面点。

  1. /*!
  2.  *
  3.  * @param[in] in_cloud Input Point Cloud to be organized in radial segments
  4.  * @param[out] out_organized_points Custom Point Cloud filled with XYZRTZColor data
  5.  * @param[out] out_radial_divided_indices Indices of the points in the original cloud for each radial segment
  6.  * @param[out] out_radial_ordered_clouds Vector of Points Clouds, each element will contain the points ordered
  7.  */
  8. void PclTestCore::XYZI_to_RTZColor(const pcl::PointCloud<pcl::PointXYZI>::Ptr in_cloud,
  9.                                    PointCloudXYZIRTColor &out_organized_points,
  10.                                    std::vector<pcl::PointIndices> &out_radial_divided_indices,
  11.                                    std::vector<PointCloudXYZIRTColor> &out_radial_ordered_clouds)
  12. {
  13.     out_organized_points.resize(in_cloud->points.size());
  14.     out_radial_divided_indices.clear();
  15.     out_radial_divided_indices.resize(radial_dividers_num_);
  16.     out_radial_ordered_clouds.resize(radial_dividers_num_);
  17.  
  18.     for (size_t i = 0; i < in_cloud->points.size(); i++)
  19.     {
  20.         PointXYZIRTColor new_point;
  21. //计算radius和theta
  22. //方便转到柱坐标下。
  23.         auto radius = (float)sqrt(
  24.             in_cloud->points[i].x * in_cloud->points[i].x + in_cloud->points[i].y * in_cloud->points[i].y);
  25.         auto theta = (float)atan2(in_cloud->points[i].y, in_cloud->points[i].x) * 180 / M_PI;
  26.         if (theta < 0)
  27.         {
  28.             theta += 360;
  29.         }
  30.         //角度的微分
  31.         auto radial_div = (size_t)floor(theta / RADIAL_DIVIDER_ANGLE);
  32.         //半径的微分
  33.         auto concentric_div = (size_t)floor(fabs(radius / concentric_divider_distance_));
  34.  
  35.         new_point.point = in_cloud->points[i];
  36.         new_point.radius = radius;
  37.         new_point.theta = theta;
  38.         new_point.radial_div = radial_div;
  39.         new_point.concentric_div = concentric_div;
  40.         new_point.original_index = i;
  41.  
  42.         out_organized_points[i] = new_point;
  43.  
  44.         //radial divisions更加角度的微分组织射线
  45.         out_radial_divided_indices[radial_div].indices.push_back(i);
  46.  
  47.         out_radial_ordered_clouds[radial_div].push_back(new_point);
  48.  
  49.     } //end for
  50.  
  51.     //将同一根射线上的点按照半径（距离）排序
  52. #pragma omp for
  53.     for (size_t i = 0; i < radial_dividers_num_; i++)
  54.     {
  55.         std::sort(out_radial_ordered_clouds[i].begin(), out_radial_ordered_clouds[i].end(),
  56.                   [](const PointXYZIRTColor &a, const PointXYZIRTColor &b) { return a.radius < b.radius; });
  57.     }
  58. }
  59.  
  60. /*!
  61.  * Classifies Points in the PointCoud as Ground and Not Ground
  62.  * @param in_radial_ordered_clouds Vector of an Ordered PointsCloud ordered by radial distance from the origin
  63.  * @param out_ground_indices Returns the indices of the points classified as ground in the original PointCloud
  64.  * @param out_no_ground_indices Returns the indices of the points classified as not ground in the original PointCloud
  65.  */
  66. void PclTestCore::classify_pc(std::vector<PointCloudXYZIRTColor> &in_radial_ordered_clouds,
  67.                               pcl::PointIndices &out_ground_indices,
  68.                               pcl::PointIndices &out_no_ground_indices)
  69. {
  70.     out_ground_indices.indices.clear();
  71.     out_no_ground_indices.indices.clear();
  72. #pragma omp for
  73.     for (size_t i = 0; i < in_radial_ordered_clouds.size(); i++) //sweep through each radial division 遍历每一根射线
  74.     {
  75.         float prev_radius = 0.f;
  76.         float prev_height = -SENSOR_HEIGHT;
  77.         bool prev_ground = false;
  78.         bool current_ground = false;
  79.         for (size_t j = 0; j < in_radial_ordered_clouds[i].size(); j++) //loop through each point in the radial div
  80.         {
  81.             float points_distance = in_radial_ordered_clouds[i][j].radius - prev_radius;//计算当前点和上一个点的水平距离pointdistance
  82.             float height_threshold = tan(DEG2RAD(local_max_slope_)) * points_distance;//根据local_max_slope_和pointdistance计算当前的坡度差阈值height_threshold
  83.             float current_height = in_radial_ordered_clouds[i][j].point.z;
  84.             float general_height_threshold = tan(DEG2RAD(general_max_slope_)) * in_radial_ordered_clouds[i][j].radius;//根据general_max_slope_和当前点的水平距离计算整个地面的高度差阈值general_height_threshold
  85.  
  86.             //for points which are very close causing the height threshold to be tiny, set a minimum value
  87.             if (points_distance > concentric_divider_distance_ && height_threshold < min_height_threshold_)
  88.             {
  89.                 height_threshold = min_height_threshold_;
  90.             }
  91.  
  92.             //check current point height against the LOCAL threshold (previous point)
  93.             if (current_height <= (prev_height + height_threshold) && current_height >= (prev_height - height_threshold))
  94.             {
  95.                 //Check again using general geometry (radius from origin) if previous points wasn't ground
  96.                 if (!prev_ground)
  97.                 {
  98.                     if (current_height <= (-SENSOR_HEIGHT + general_height_threshold) && current_height >= (-SENSOR_HEIGHT - general_height_threshold))
  99.                     {
  100.                         current_ground = true;
  101.                     }
  102.                     else
  103.                     {
  104.                         current_ground = false;
  105.                     }
  106.                 }
  107.                 else
  108.                 {
  109.                     current_ground = true;
  110.                 }
  111.             }
  112.             else
  113.             {
  114.                 //check if previous point is too far from previous one, if so classify again
  115.                 if (points_distance > reclass_distance_threshold_ &&
  116.                     (current_height <= (-SENSOR_HEIGHT + height_threshold) && current_height >= (-SENSOR_HEIGHT - height_threshold)))
  117.                 {
  118.                     current_ground = true;
  119.                 }
  120.                 else
  121.                 {
  122.                     current_ground = false;
  123.                 }
  124.             }
  125.  
  126.             if (current_ground)
  127.             {
  128.                 out_ground_indices.indices.push_back(in_radial_ordered_clouds[i][j].original_index);
  129.                 prev_ground = true;
  130.             }
  131.             else
  132.             {
  133.                 out_no_ground_indices.indices.push_back(in_radial_ordered_clouds[i][j].original_index);
  134.                 prev_ground = false;
  135.             }
  136.  
  137.             prev_radius = in_radial_ordered_clouds[i][j].radius;
  138.             prev_height = in_radial_ordered_clouds[i][j].point.z;
  139.         }
  140.     }
  141. }

3基于雷达数据本身特点的方法-urban road filter

原文：

Real-Time LIDAR-Based Urban Road and Sidewalk Detection for Autonomous Vehicles

代码：

https://github.com/jkk-research/urban_road_filter

z_zero_method

0f8e1122a8d76fb6c243c34866970dd7.png
z_zero_method

首先将数据组织成[channels][thetas]

对于每一条线，对角度进行排序

  1. 以当前点p为中心，向左选k个点，向右选k个点

  2. 分别计算左边及右边k个点与当前点在x和y方向差值的均值

  3. 同时计算左边及右边k个点的最大z值max1及max2

  4. 根据余弦定理求解余弦角

如果余弦角度满足阈值且max1减去p.z满足阈值或max2减去p.z满足阈值且max2-max1满足阈值，认为此点为障碍物，否则就认为是地面点。

x_zero_method

X-zero和Z-zero方法可以找到避开测量的X和Z分量的人行道，X-zero和Z-zero方法都考虑了体素的通道数，因此激光雷达必须与路面平面不平行，这是上述两种算法以及整个城市道路滤波方法的已知局限性。X-zero方法去除了X方向的值，使用柱坐标代替。

89506cb10c2fc131249df959716009b8.png 940c1544fb16cb080c1009cefca7f1ad.png
x_zero_method

首先将数据组织成[channels][thetas]

对于每一条线，对角度进行排序

  1. 以当前点p为中心，向右选第k/2个点p1和第k个点p2

  2. 分别计算p及p1、p1及p2、p及p2间z方向的距离

  3. 根据余弦定理求解余弦角

如果余弦角度满足阈值且p1.z-p.z满足阈值或p1.z-p2.z满足阈值且p.z-p2.z满足阈值，认为此点为障碍物

star_search_method

该方法将点云划分为矩形段，这些形状的组合像一颗星；这就是名字的来源，从每个路段提取可能的人行道起点，其中创建的算法对基于Z坐标的高度变化不敏感，这意味着在实践中，即使当激光雷达相对于路面平面倾斜时，该算法也会表现良好，在柱坐标系中处理点云。

具体实现：

4060423f310df7b46af74c6a6cd20c93.png
star_search_method

4参考文献：

https://blog.csdn.net/AdamShan/article/details/84569000

https://zhuanlan.zhihu.com/p/553575548

视频课程来了！

自动驾驶之心为大家汇集了毫米波雷达视觉融合、高精地图、BEV感知、传感器标定、自动驾驶协同感知、语义分割、自动驾驶仿真、L4感知等多个方向学习视频，欢迎大家自取（扫码进入学习）！

d3d007955efc1a8bc0d759cff5e62cb8.png

（扫码学习最新视频）

国内首个自动驾驶学习社区

近1000人的交流社区，和20+自动驾驶技术栈学习路线，想要了解更多自动驾驶感知（分类、检测、分割、关键点、车道线、3D目标检测、多传感器融合、目标跟踪、光流估计、轨迹预测）、自动驾驶定位建图（SLAM、高精地图）、自动驾驶规划控制、领域技术方案、AI模型部署落地实战、行业动态、岗位发布，欢迎扫描下方二维码，加入自动驾驶之心知识星球，这是一个真正有干货的地方，与领域大佬交流入门、学习、工作、跳槽上的各类难题，日常分享论文+代码+视频，期待交流！

f6c26711614c7931523b5f27c876248b.jpeg

【自动驾驶之心】全栈技术交流群

自动驾驶之心是首个自动驾驶开发者社区，聚焦目标检测、语义分割、全景分割、实例分割、关键点检测、车道线、目标跟踪、3D目标检测、BEV感知、多传感器融合、SLAM、光流估计、深度估计、轨迹预测、高精地图、NeRF、规划控制、模型部署落地、自动驾驶仿真测试、产品经理、硬件配置、AI求职交流等方向；

6c77054a0254a99d151af44e46021a3b.jpeg

添加汽车人助理微信邀请入群

备注：学校/公司+方向+昵称

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号