A Staged Real-Time Ground Segmentation Algorithm of 3D LiDAR Point Cloud

Abstract

Ground segmentation is a crucial task in the field of 3D LiDAR perception for autonomous driving. It is commonly used as a preprocessing step for tasks such as object detection and road extraction. However, the existing ground segmentation algorithms often struggle to meet the requirements of robustness and real-time performance due to significant variations in ground slopes and flatness across different scenes, as well as the influence of objects such as grass, flowerbeds, and trees in the environment. To address these challenges, this paper proposes a staged real-time ground segmentation algorithm. The proposed algorithm not only achieves high real-time performance but also exhibits improved robustness. Based on a concentric zone model, the algorithm filters out reflected noise points and vertical non-ground points in the first stage, improving the validity of the fitted ground plane. In the second stage, the algorithm effectively addresses the issue of undersegmentation of ground points through three steps: ground plane fitting, ground plane validity judgment, and ground plane repair. The experimental results on the SemanticKITTI dataset demonstrate that the proposed algorithm outperforms the existing methods in terms of segmentation results.

1. Introduction

In recent years, 3D LiDAR has increasingly been employed in autonomous vehicles and mobile robots [1]. Its operating principle involves emitting laser pulses toward targets and capturing the reflected signals. By calculating the round-trip time of the laser pulses, the distance to the targets is determined, resulting in the generation of a 3D point cloud. Compared to 3D stereo cameras, 3D LiDAR offers advantages such as high measurement accuracy, long detection range, minimal sensitivity to lighting conditions, and resistance to electromagnetic interference. Consequently, it is commonly used in tasks such as localization and mapping [2,3], object detection [4,5], pedestrian detection and tracking [6,7], and scene segmentation [8].

As a preprocessing step, ground segmentation algorithms play a crucial role in filtering out irrelevant information for subsequent perception tasks [9]. By dividing the 3D point cloud into ground and non-ground points, this algorithm can effectively reduce data volume and computational requirements. Specifically, the point cloud classified as ground points can be utilized for road edge extraction [10,11], navigation [12,13], and automatic parking [14], while the non-ground points can be used for object and vehicles detection [15,16,17], obstacle avoidance [18,19], and target tracking [20,21]. Therefore, ground segmentation algorithms hold significant research value in the field of autonomous driving.

Currently, significant progress has been made in algorithms related to ground segmentation. Huang et al. [22] introduced a fast ground point segmentation algorithm by incorporating Markov random fields. Bogoslavskyi et al. [23] proposed a method to convert point clouds from mechanically rotating multi-line LiDAR sensors into range images, which can then be used for ground segmentation. Himmelsbach et al. [24] were the first to apply the concept of ground fitting and introduced a ground segmentation algorithm based on ground line fitting. Hu et al. [25] and Lim et al. [26] conducted further research based on ground fitting and proposed ground segmentation algorithms by fitting ground plane equations. Furthermore, with the rapid development of deep learning in recent years, Qi et al. [27] and Hua et al. [28] proposed PointNet++ and Pointwise CNN networks based on convolutional neural networks, respectively, achieving high-precision point cloud segmentation.

Due to the common usage of ground segmentation algorithms as preprocessing steps, they need to balance accuracy and speed. Traditional methods such as range images [23], higher-order inference [22], and ground plane fitting [24,25,26] have lower computational requirements but exhibit lower segmentation accuracy. On the other hand, learning-based methods [27,28] can achieve high-precision segmentation but often require more computational resources and struggle with real-time tasks. Additionally, manually annotating point cloud datasets incurs high labor costs.

In response to the above challenges, this paper proposes a staged ground point segmentation algorithm based on ground plane fitting, which is specifically designed for real-time tasks. This algorithm is an improvement from Patchwork++ [29]: it fixes the rough segmentation of the point cloud at details in Patchwork++. The algorithm has a clearer structural hierarchy than the existing methods, and additional modules have been designed for more detailed segmentation of the point cloud. The contributions of this paper are threefold:

• First, in the first stage of interference point removal, two modules are designed: region-wise reflected noise removal and region-wise vertical interference removal. These modules effectively address the issue of non-ground points interfering with ground plane fitting.
• Second, in the second stage of ground plane fitting and ground point segmentation, this paper introduces novel criteria for assessing the validity of fitted planes and the region-wise invalid ground plane repair module. These address the issue of undersegmentation of ground points caused by failed ground plane fitting.
• Finally, the proposed algorithm is evaluated on the SemanticKITTI dataset [30]. The experimental results demonstrate that, compared to the existing methods, the proposed algorithm achieves the best segmentation results.

2. Related Work

2.1. 2.5D Grid-Based Method

It is the case that 2.5D grid-based methods are commonly used to represent original point cloud data in two-dimensional space, reducing the data volume. Among them, 2.5D refers to grid partitioning in planar space, where each grid has its own height. This is a simplified and discretized representation of some three-dimensional information of the environment. Among these methods, elevation maps are widely employed. Douillard et al. [31] constructed an elevation map by calculating the average height of all the points within each grid cell and subsequently performed ground point segmentation using clustering methods. While this algorithm exhibits certain advantages in terms of segmentation accuracy, it requires significant computational resources. On the other hand, Sun et al. [10] proposed a fast ground point segmentation algorithm based on elevation differences. This algorithm constructs a uniform polar grid model and performs ground point segmentation by computing the elevation differences between each point and its neighboring points within the grid. Anand et al. [32] divided the point cloud into 0.5 m × 0.5 m cells and performed ground point extraction and filtering by comparing the z-value of each point within the cells.

2.2. Ground Modeling

Ground modeling utilizes plane fitting techniques to estimate ground planes from point cloud data and performs ground point segmentation based on the fitted ground plane model. Himmelsbach et al. [24] utilized a uniform polar grid model to fit linear equations representing the ground plane within each sector ring region and segmented the ground points based on these equations. This algorithm has low computational complexity but is not suitable for rugged terrain. Hu et al. [25] divided a point cloud into multiple rectangular cells along the direction of motion of a vehicle and performed ground point segmentation by fitting a plane equation for each cell. Zermas et al. [33] employed a uniform polar grid model to fit the ground plane equation, which enhanced the algorithm’s robustness. To address the computational complexity issue in plane-fitting-based methods, Lim et al. [26] and Lee et al. [29] proposed the Patchwork and Patchwork++ algorithms, respectively, based on the concentric zone model. These algorithms effectively improve segmentation accuracy and efficiency.

2.3. Adjacent Points and Local Features

This method segments ground points by extracting the relationships between neighboring points and local features from 3D point cloud data. Among these methods, the range images method is commonly used. Bogoslavskyi et al. [23,34] transformed point clouds generated by mechanically rotating multi-line LiDAR into range images and subsequently utilized the feature relationships between adjacent pixels in the image for point cloud segmentation. Guo et al. [35] combined the concentric zone model with the range images method and proposed a coarse-to-fine ground point segmentation method. On the other hand, region-growing-based point cloud segmentation algorithms were proposed earlier. Moosmann et al. [36] randomly selected initial seed points and performed region growing using local convexity as a similarity criterion, thereby achieving point cloud segmentation.

2.4. Higher-Order Inference

In ground point segmentation tasks, the sparsity issue of LiDAR point clouds often leads to misclassification of points. Therefore, higher-order inference algorithms used in visual segmentation tasks have also been applied in point cloud segmentation. Rummelhard et al. [37] proposed a 3D point cloud ground-labeling adaptive method based on local ground elevation estimation. This method models the ground as a spatiotemporal conditional random field to segment the point cloud. Huang et al. [22] introduced a fast ground point segmentation method based on a coarse-to-fine Markov random field. This method first performs coarse segmentation using an improved elevation map and then achieves fine segmentation by solving a Markov random field model.

2.5. Learning-Based Method

Deep learning methods were initially applied to image segmentation tasks and achieved excellent segmentation results. However, in point cloud segmentation tasks, deep learning methods started relatively late. Qi et al. [8] proposed an end-to-end network model called PointNet, which was the first to use raw point cloud data for segmentation. Building upon PointNet, Qi et al. [27] further proposed a new network model called PointNet++, which addressed the issue of not extracting local features around each point in PointNet. Varney et al. [38] employed a dense pyramid structure instead of the traditional “U”-shaped architecture to extract more features and demonstrated through experiments that the network exhibited superior performance.

3. Materials and Methods

This algorithm, based on the concentric zone model (CZM), designs several key modules to achieve ground extraction from LiDAR point cloud. CZM divides a point cloud into multiple sector ring regions with regular intervals of radial and azimuthal angle. Meanwhile, the density of sector ring regions in each zone can be set through parameters. The key modules include region-wise reflected noise removal (R-RNR), region-wise vertical interference removal (R-VIR), region-wise ground plane fitting (R-GPF), region-wise ground plane validity judgment (R-GPVJ), region-wise invalid ground plane repair (R-IGPR), and region-wise ground point segmentation (R-GPS). Based on the functionality of each module, they can be divided into two stages: interference point removal stage and ground plane fitting stage. The overall framework of the algorithm is illustrated in Figure 1.

3.1. Problem Definition

Given a set of LiDAR point cloud P, where each point $p_i$ contains its three-dimensional coordinates $(x,y,z)$ and the reflection intensity I, the problem of ground point extraction aims to classify each point $p_i$ in P as either a ground point or a non-ground point. Ground points typically represent road surfaces, sidewalks, parking lots, and other ground elements, while non-ground points encompass buildings, vehicles, vegetation, pedestrians, and other non-ground elements. If we define the set of ground points as G and the set of non-ground points as N, the set P can be represented as follows:

$$P=\bigcup _i{p}_i=G\cup N$$

(1)

3.2. CZM: Concentric Zone Model

Because the ground surface is typically not a perfectly flat plane, it is necessary to divide the point cloud set P into multiple small regions and assume that the ground in each region is a flat surface. Based on the above idea, the uniform polar grid model [39,40] was proposed as shown in Figure 2a. The uniform polar grid model divides the set P into multiple rings based on the radial distance from the center, and each ring is further divided into smaller sector ring regions based on the azimuth angle. However, there are some obvious problems with the model. When the sector ring region is located too close to the center, its area becomes small, resulting in fewer points being contained within it. In addition, due to the sparsity problem of the point cloud, the point cloud becomes sparser as the distance from the center increases. This means that sector ring regions located far from the center will also contain fewer points. Both scenarios can lead to poor ground plane fitting within the sector ring regions.

To address these issues, we employ the concentric zone model (CZM), which is the same as that used in Patchwork [26] and Patchwork++ [29]. As depicted in Figure 2b, CZM can be parameterized to adjust the density of sector ring regions in each zone. By setting the number of sector ring regions to be divided in each zone, the concentric zone model can ensure that the rings closer to and farther from the center have fewer sector ring regions.

3.3. Stage One: Interference Point Removal

Interference point removal in Stage One is employed to remove reflected noise points and vertical non-ground interference points, providing more effective and reliable point cloud data for subsequent ground plane fitting.

3.3.1. R-RNR: Region-Wise Reflected Noise Removal

In the set of LiDAR point cloud P, noise points tend to occur below the ground plane. These noise points can significantly affect the reliability of the fitted ground plane.

According to the research conducted by Zhao X et al. [41], as shown in Figure 3, when a laser beam illuminates surfaces made of materials such as glass or metal, specular reflection often occurs. If the specular reflection contacts an obstacle, it will reflect to the laser receiver along the opposite path. Since the sensor is unaware of this reflection, the acquired points will be located incorrectly. These points are referred to as reflected noise points. As the incident angle increases, the reflection intensity of these noise points decreases. Based on this principle, Patchwork++ [29] introduces reflected noise removal (RNR) module. This module searches for all points in the point cloud that are below the specified height one by one and identifies the points with reflection intensity below the threshold as reflected noise points.

However, as shown in Figure 4, due to variations in reflectivity among different materials or non-uniform reflectivity on material surfaces, it is common for the reflection intensity of reflected noise points to exceed the set threshold, resulting in incomplete removal of reflected noise points. To address this issue, the proposed algorithm introduces region-wise reflected noise removal (R-RNR) module. The R-RNR performs reflected noise removal separately for each sector ring region. The method first extracts a point set ($P_{z,R\text{-}RNR}$) from the sector ring region with z-value below the threshold value ($Z_{th,R\text{-}RNR}$) and counts the number of points ($N_z$) in this set. Then, from $P_{z,R\text{-}RNR}$, a point set ($P_{I,R\text{-}RNR}$) is extracted based on reflection intensity below the threshold value ($I_{th,R\text{-}RNR}$), and the number of points ($N_I$) in this set is counted (here $Z_{th,R\text{-}RNR}\le 0$ m and $0<I_{th,R\text{-}RNR}\le 1$). The determination of the reflected noise point set ($P_{RN}$) is described as follows:

$$P_{RN}=\left\{\begin{array}{cc}{P}_{z,R\text{-}RNR}\hfill & \hfill N_z\le N_{zthr,}{N}_I\ge N_{Ithr}\\ P_{I,R\text{-}RNR}\hfill & \hfill others\end{array}\right.$$

(2)

where $N_{zthr}$ is the threshold value for the number of points with z-value less than $Z_{th,R\text{-}RNR}$, and $N_{Ithr}$ is the threshold value for the number of points with reflection intensity lower than $I_{th,R\text{-}RNR}$.

3.3.2. R-VIR: Region-Wise Vertical Interference Removal

As shown in Figure 5, when large vertical elements such as walls appear in the scene, the number of vertical points in some sector ring regions can be significantly greater than the number of ground points. These abundant vertical points can heavily interfere with ground plane fitting, resulting in a significant deviation between the fitted ground plane and the actual ground, thereby affecting the final ground point segmentation.

To address the above issue, this algorithm introduces a module for region-wise vertical interference point removal to remove large-scale vertical interference points from each sector ring region point set. This module first extracts a point set ($P_{z,R\text{-}VIR}$) from the sector ring region with z-value greater than the threshold value ($Z_{th,R\text{-}VIR}$). To prevent ground points from being incorrectly identified as vertical interference points, $Z_{th,R\text{-}VIR}$ is set to be greater than 0 m. Then, from $P_{z,R\text{-}VIR}$, $N_{th,R\text{-}VIR}$ points with the smallest z-value are selected as the initial seed points. The principal component analysis (PCA) method [42] is used to fit a plane, obtaining the unit normal vector $(A,B,C)$ and the plane equation $Ax+By+Cz+D=0$. If the angle between the unit normal vector and the Z-axis is less than the threshold value (${\theta }_{th,R\text{-}VIR}$), the fitted plane is classified as a vertical plane. The distance from each point in $P_{z,R\text{-}VIR}$ to the fitted plane is calculated. If the distance is less than the threshold value ($d_{th,R\text{-}VIR}$), the point is considered a vertical interference point, and it is removed from $P_{z,R\text{-}VIR}$. The above steps are repeated until the angle between the unit normal vector of the fitted plane and the Z-axis is less than or equal to the threshold value(${\theta }_{th,R\text{-}VIR}$), or the number of points in $P_{z,R\text{-}VIR}$ is less than $N_{th,R\text{-}VIR}$. Finally, all the vertical interference points are filtered out from the sector ring region point set.

In addition, this algorithm uses the formula for the orthogonal distance to calculate the distance d between the point $p(x,y,z)$ and the fitted plane $Ax+By+Cz+D=0$.

$$d=\frac{\left|Ax+By+Cz+D\right|}{\sqrt{A^2+B^2+C^2}}$$

(3)

In the plane equation $Ax+By+Cz+D=0$ fitted using the PCA method [42], the unit normal vector of the plane is $(A,B,C)$. Therefore, $A^2+B^2+C^2=1$. So, the distance calculation method can be further modified to the following formula.

$$d=\left|Ax+By+Cz+D\right|$$

(4)

3.4. Stage Two: Ground Plane Fitting and Ground Point Segmentation

After obtaining reliable point cloud data through Stage One, Stage Two is employed for ground plane fitting and ground point segmentation. This stage consists of four main modules: R-GPF, R-GPVJ, R-IGPR, and R-GPS. The first three modules aim to obtain the ground plane fitting equation for each sector ring region, while the last module is responsible for partitioning each point based on the fitted ground plane.

3.4.1. R-GPF: Region-Wise Ground Plane Fitting

Based on the idea of the concentric zone model, it can be assumed that the ground plane within each sector ring region is a complete plane. Therefore, based on the point cloud within the sector ring region, an ideal ground plane equation can be fitted.

The R-GPF module used in this algorithm follows the same approach as that used in Patchwork++ [29]. First, $N_{th,R\text{-}GPF}$ points with the lowest z-value are selected from the sector ring region point set after removing interference points. The average z-value ($z_{avg}$) is calculated for these selected points. Then, all points within the sector ring region point set that have z-value less than $z_{avg}+z_{th\text{-}seed}$ are reselected as initial seed points, where $z_{th\text{-}seed}$ is the height threshold for the initial seed points. By selecting the initial seed points based on the calculated average z-value, the presence of outlier points within the initial seed points can be effectively avoided. The initial seed points are used as the points to be fitted, and the PCA method [42] is employed to fit a plane, obtaining the unit normal vector $(A,B,C)$ and the plane equation $Ax+By+Cz+D=0$. The distance (d) between each point in the sector ring region point set and the fitted plane is calculated and compared with the threshold ($d_{th,R\text{-}GPF}$). If $d\le d_{th,R\text{-}GPF}$, the point is considered to be close to the fitted plane and becomes a new seed point. If $d>d_{th,R\text{-}GPF}$, no further processing is performed on the point. Based on the new seed points, the above operations are repeated $N_{R\text{-}GPF}$ times to iteratively obtain the final fitted ground plane equation. Through multiple iterations, the fitted ground plane gradually converges to the actual ground plane. Here, $N_{R\text{-}GPF}$ should be a small value to avoid a large computational burden.

In this module, Formula (4) is used to compute the distance between the point and the plane.

3.4.2. R-GPVJ: Region-Wise Ground Plane Validity Judgment

Due to issues such as insufficient fitted points, inclusion of outliers, and the absence of the fitted plane within some sector ring regions, the fitted planes within certain sector ring regions may significantly deviate from the actual ground surface, making them unreliable for subsequent ground point segmentation. Therefore, it is necessary to analyze the validity of the fitted ground planes within each sector ring region.

This module assesses the validity of the fitted ground plane using three criteria: plane uprightness, plane elevation, and plane flatness.

Plane uprightness is represented by the angle (${\theta }_Z$) between the unit normal vector of the fitted plane and the Z-axis. A smaller ${\theta }_Z$ indicates a more perpendicular alignment with the horizontal plane. In practical situations, the slope of the ground should conform to architectural design specifications and should not be excessively steep. Thus, when ${\theta }_Z$ exceeds the threshold value (${\theta }_{th,R\text{-}GPVJ}$), the uprightness requirement of the fitted plane is considered satisfied.

Plane elevation is represented by the average z-value ($z_{avg}$) of the fitted plane’s seed points. A larger $z_{avg}$ indicates a higher average elevation of the fitted plane. In real-world scenarios, the ground plane generally has a lower elevation, except for uphill sections. Therefore, when $z_{avg}$ is below the threshold value ($z_{th,R\text{-}GPVJ}$), the elevation requirement of the fitted plane is considered satisfied.

Plane flatness is assessed using the singular value ($S_n$) of the fitted plane’s normal direction. A larger $S_n$ indicates a less flat plane. In practical situations, the ground plane is typically flat, except for non-structured roads that may exhibit unevenness. Therefore, when $S_n$ falls below the threshold value ($S_{th,R\text{-}GPVJ}$), the flatness requirement of the fitted plane is considered satisfied.

${\theta }_{th,R\text{-}GPVJ}$ is applicable to all sector ring regions and is set manually in advance. On the other hand, $z_{th,R\text{-}GPVJ}$ and $S_{th,R\text{-}GPVJ}$ have different values for each concentric zone in the model, and these values are dynamically updated based on the average elevation and flatness of all the sector ring regions on each ring.

Based on these three criteria, this module designs a table for judging the validity of the fitted plane, as shown in

Table 1. Criteria for judging the validity of fitted planes.

State	Uprightness	Elevation	Flatness	Validity
1	✗	-	-	✗
2	✔	✗	✗	✗
3	✔	✔	-	✔
4	✔	-	✔	✔

. Among them, uprightness, elevation, and flatness are conditions, and validity is the final judgment result. Table 1 shows all four judgment rules. Since uprightness is most accurate for excluding the ground, the fitted ground plane is directly judged invalid if uprightness is not satisfied, as shown in state 1. The fitted ground plane can be judged valid as long as one of the elevation and flatness is satisfied, provided that the uprightness is satisfied, as shown in states 3 and 4. This is because, in our experiments, we found that, if we require all three criteria to be satisfied at the same time, the conditions are too stringent and the algorithm will incorrectly exclude some ground planes, such as pavements and rough roads. Moreover, for the case where only uprightness is satisfied, we will also judge the fitted ground plane as invalid, as shown in state 2.

3.4.3. R-IGPR: Region-Wise Invalid Ground Plane Repair

When there are outlier points or a relatively low proportion of ground points in a sector ring region, the fitted plane corresponding to that sector ring region will be deemed an invalid fitted plane by the R-GPVJ module. In this case, directly classifying all the points in that sector ring region as non-ground points would lead to undersegmentation issues. Therefore, this algorithm proposes the R-IGPR module to re-estimate and repair the ground plane for the sector ring regions where the fitted plane is invalid based on known conditions.

This module evaluates and re-estimates the invalid fitted planes based on the concept of neighborhoods. In this context, the neighborhood considers only sector ring regions of the same zone. As shown in Figure 6a, when the sector ring region containing the invalid plane is located at a non-edge position in the zone, the validity of the four neighboring planes needs to be considered. As shown in Figure 6b, when the sector ring region containing the invalid plane is located at the edge position of the zone, only the validity of the three neighboring planes needs to be considered. If the number of valid neighboring planes is greater than or equal to two, the sector ring region is considered suitable for ground plane repair. Otherwise, no repair is performed. For sector ring regions eligible for ground plane repair, the calculation method is as follows.

Assuming there are n valid fitted planes in its neighborhood, the plane equations are given by $A_{i}x+B_{i}y+C_{i}z+D_i=0,i=1,2,\dots ,n$. The equation for the re-patched ground plane is as follows:

$$\frac{{\displaystyle \sum _{i=1}^n}{A}_i}{n}x+\frac{{\displaystyle \sum _{i=1}^n}{B}_i}{n}y+\frac{{\displaystyle \sum _{i=1}^n}{C}_i}{n}z+\frac{{\displaystyle \sum _{i=1}^n}{D}_i}{n}=0$$

(5)

3.4.4. R-GPS: Region-Wise Ground Point Segmentation

Finally, based on the processing results of all the above modules, the point cloud dataset P is divided into ground points and non-ground points.

First, the reflected noise points, vertical interference points, and points from sector ring regions with invalid fitted planes are directly classified as non-ground points. The remaining points need to be divided based on the fitted planes within the sector ring regions. After calculating the orthogonal distance (d) between each point in the sector ring region and the fitted plane, it is compared with the threshold ($d_{th,R\text{-}GPS}$). If $d\le d_{th,R\text{-}GPS}$, the point is considered close to the fitted plane and classified as a ground point. Otherwise, it is classified as a non-ground point. Note in particular that, for the plane equation $Ax+By+Cz+D=0$ repaired by the R-IGPR module, $A^2+B^2+C^2\ne 1$. It is therefore necessary to use Formula (3) to calculate the orthogonal distance.

4. Results and Discussion

4.1. Dataset Preparation

In this experiment, we evaluate the performance of the proposed algorithm compared to that of the existing algorithms in ground segmentation using the SemanticKITTI dataset [30]. The SemanticKITTI dataset [30] is a large-scale dataset designed for autonomous driving scenarios. The dataset was collected using a 64-line mechanical rotating LiDAR mounted on a vehicle, capturing real-world driving environments. The dataset consists of 22 sequences, where sequences 00–10 contain both the raw point cloud data and per-point annotated class labels, while sequences 11–20 include only the raw point cloud data. We conducted experiments using sequences 00–10 containing labels. The dataset contains seven major classes and twenty-eight minor classes, with road, sidewalk, parking, and other ground categorized under the ground class. Therefore, in this experiment, the ground class is considered to be ground points, while the remaining classes are considered to be non-ground points. The sequence 00–10 contains a total of 23,210 frames of point cloud in different scenes, so using this dataset allows for objective comparison of segmentation methods.

4.2. Evaluation Metrics

In this experiment, precision, recall, and F1-score are used as evaluation metrics to quantitatively compare the segmentation performance of the different methods. If we define $N_{TP}$, $N_{FP}$, $N_{TN}$, and $N_{FN}$ as the quantities of true positives, false positives, true negatives, and false negatives, respectively, the calculation methods for the evaluation metrics are as follows:

$$precision=\frac{N_{TP}}{N_{TP}+N_{FP}}$$

(6)

$$recall=\frac{N_{TP}}{N_{TP}+N_{FN}}$$

(7)

$$F1=\frac{2\ast precision\ast recall}{precision+recall}$$

(8)

4.3. Parameter Setting

The concentric zone model is divided into four zones of different specifications. In order of distance from near to far, each zone contains two, four, four, and four rings, and each ring in the zone contains sixteen, thirty-two, forty-five, and sixteen sector ring regions, respectively. The parameter settings for the R-RNR module are as follows: $Z_{th,R\text{-}RNR}=-0.3$ m, $I_{th,R\text{-}RNR}=0.2$, $N_{zth}=40$, and $N_{Ith}=1$. The parameter settings for the R-VIR module are as follows: $Z_{th,R\text{-}VIR}=0.2$ m, $N_{th,R\text{-}VIR}=20$, $d_{th,R\text{-}VIR}=0.3$ m, and ${\theta }_{th,R\text{-}VIR}=45°$. The parameter settings for the R-GPF module are as follows: $N_{th,R\text{-}GPF}=20$, $z_{th\text{-}seed}=0.2$ m, $d_{th,R\text{-}GPF}=0.1$ m, and $N_{R\text{-}GPF}=3$. The parameter settings for the R-GPVJ module are as follows: ${\theta }_{th,R\text{-}GPVJ}=45°$. The parameter settings for the R-GPS module in the region are as follows: $d_{th,R\text{-}GPS}=0.1$ m.

4.4. Comparison with Existing Methods

The comparative segmentation results between the proposed algorithm and existing algorithms are shown in Figure 7 and

Table 2. Comparison of evaluation metrics for different algorithms.

Method	Precision (%)	Recall (%)	F1 (%)	Time (ms)
LineFit [24]	87.80	71.95	78.00	267.9
GPF [33]	74.50	95.55	82.50	179.8
Patchwork [26]	72.74	98.12	82.59	15.3
Patchwork++ [29]	73.23	99.30	83.32	28.6
Proposed	77.26	98.59	85.69	30.6

. Figure 7 shows the intuitive segmentation results of five algorithms, from which it can be seen that, compared to Patchwork [26] and Patchwork++ [29], the algorithm proposed in this paper has fewer red points. In addition, although the number of red points in the GPF [33] is similar to that in the proposed algorithm, the proposed algorithm has fewer blue points and more green points. Meanwhile, the segmentation result of LineFit [24] shows that there are obviously few green points while there are many blue points, indicating that the segmentation result of this algorithm is very unsatisfactory. From the evaluation metrics in Table 2, it is evident that the proposed algorithm achieves the highest F1-score, while the precision is only lower than LineFit [24] and the recall is only lower than Patchwork++ [29]. These indicate that, compared to the LineFit [24], GPF [33], Patchwork [26] and Patchwork++ [29] algorithms, the proposed algorithm exhibits the best integrated performance in ground segmentation.

The significantly greater precision of the proposed algorithm compared to that of the other algorithms can be attributed to its superior segmentation performance in capturing fine details, particularly in the transition regions between ground and non-ground points. As illustrated in Figure 7, the segmentation results of the proposed algorithm have fewer red and blue points in the road edge region. This is mainly due to the first stage of the proposed algorithm, which effectively removes a majority of the interference points, thereby improving the fitting precision in complex scenes with rich details. Additionally, the second state of the proposed algorithm repairs invalid fitted ground planes, further enhancing the integrity of the fitted planes and resulting in more precise ground point segmentation.

However, the proposed algorithm still has limitations when facing a large lawn area, as shown in the second graph of Figure 7f. Although the proposed algorithm works better compared to Patchwork [26] and Patchwork++ [29], there are still many lawns incorrectly classified as ground. In contrast, LineFit [24] and GPF [33] do very well in this area. This is mainly due to the fact that the difference between the lawn and the actual ground is small enough that the module cannot completely exclude the ground plane fitted to the lawn area, which can lead to subsequent misclassification.

Overall, the results demonstrate that the proposed algorithm outperforms the existing algorithms in terms of ground point segmentation effectiveness, as indicated by its F1-score. The algorithm’s ability to capture fine details and accurately segment ground points, especially in challenging scenarios, contributes to its superior performance.

4.5. Effect of R-RNR

This experiment compared the RNR module proposed in Patchwork++ [29] with the R-RNR module proposed in this paper. Figure 8 shows that, when the point cloud contains reflected noise with uneven reflection intensity, the RNR module can identify only obvious reflected noise points with low reflection intensity. However, the R-RNR module can successfully identify all the reflected noise points. This indicates that the proposed R-RNR module in this paper significantly outperforms the RNR module proposed in Patchwork++ [29] in terms of its ability to filter out reflective noise.

4.6. Algorithm Speed

The segmentation speeds of different algorithms are compared on a platform equipped with an Intel(R) Core(TM) i9-9900K CPU, and no GPU resources were used. Table 2 shows that the segmentation time of LineFit [24] and GPF [33] is much larger than the other algorithms, which completely fails to satisfy real-time requirements. This is because LineFit [24] divides the point cloud into 43,200 bins and fits the points in each bin statistically and linearly, which has large computational complexity. Meanwhile, GPF [33] fits the global point cloud onto a ground plane, causing a huge computational burden due to the large number of fitted seed points. In contrast, Patchwork [26] divides the point cloud into fewer regions, and the number of seed points required to fit the ground plane is drastically reduced, so Patchwork [26] has the lowest computational complexity. Patchwork++ [29], as an improvement of Patchwork [26], adds more modules to improve the segmentation accuracy, so the computational complexity has increased compared to Patchwork [26]. The proposed algorithm, as an improvement of Patchwork++ [29], adds modules with lower computational complexity to handle the details, and some unnecessary modules are removed to improve the segmentation speed. Therefore, the computational complexity of the proposed algorithm is only slightly increased compared to Patchwork++ [29].

In a word, the processing time of the proposed method is comparable to that of the existing real-time segmentation algorithm Patchwork++ [29], and slightly slower than that of Patchwork [26]. The computational complexity of the proposed method is low and can meet the real-time requirements.

Furthermore, we count the time taken for each part of the proposed algorithm as shown in

Table 3. Percentage of time occupation for each part of the proposed algorithm.

Part	Percentage of Time (%)
CZM	10.7
R-RNR	11.3
R-VIR	9.4
R-GPF	12.6
R-GPVJ	7.2
R-IGPR	7.4
R-GPS	11.6
Others	29.8

. Other parts include steps such as conversion of data formats, data preprocessing, and visualization of results and therefore take up a relatively long time. In addition to this, the R-GPF module takes up the most time due to the fact that it requires multiple ground plane fits for each sector ring region. The R-VIR module, which also requires ground plane fitting, occupies less time due to the fact that the number of sector ring regions containing vertical interference points is generally small, and therefore the number of vertical plane fits is relatively small. Further, the R-RNR module needs to compare and count the height and reflection intensity of each point in the sector ring region and finally judge and divide them again, so this module takes up a relatively large amount of time as well. The R-GPVJ module and the R-IGPR module require only a criterion judgment for the fitted plane equations and a small number of planes to be repaired, so the computational complexity is relatively low. Finally, the R-GPS module needs to calculate the orthogonal distances of a large number of points to the plane and make judgments, so this module also has high computational complexity. In addition, since the above modules are all based on point cloud in a single sector ring region for processing, parallel computing can be achieved for each sector ring region.

5. Conclusions

This paper proposes a staged real-time ground segmentation algorithm based on 3D LiDAR point cloud. Through experimental verification, the proposed algorithm effectively addresses the issue of undersegmentation of ground points caused by inaccurate and incomplete ground plane fitting in existing algorithms, thus improving the effectiveness of ground segmentation. Moreover, similar to the existing real-time algorithms, the proposed algorithm has low computational complexity, ensuring fast segmentation speed.

In future research, we plan to use this algorithm as a preprocessing step, where the segmented ground points and non-ground points can be utilized for road extraction and object detection tasks, respectively. Additionally, we aim to design an adaptive algorithm to reduce the number of parameters that need to be set manually.