FASTSeg3D: A Fast, Efficient, and Adaptive Ground Filtering Algorithm for 3D Point Clouds in Mobile Sensing Applications

Abstract

Background: Accurate ground segmentation in 3D point clouds is critical for robotic perception, enabling robust navigation, object detection, and environmental mapping. However, existing methods struggle with over-segmentation, under-segmentation, and computational inefficiency, particularly in dynamic or complex environments. Methods: This study proposes FASTSeg3D, a novel two-stage algorithm for real-time ground filtering. First, Range Elevation Estimation (REE) organizes point clouds efficiently while filtering outliers. Second, adaptive Window-Based Model Fitting (WBMF) addresses over-segmentation by dynamically adjusting to local geometric features. The method was rigorously evaluated in four challenging scenarios: large objects (vehicles), pedestrians, small debris/vegetation, and rainy conditions across day/night cycles. Results: FASTSeg3D achieved state-of-the-art performance, with a mean error of <7%, error sensitivity < 10%, and IoU scores > 90% in all scenarios except extreme cases (rainy/night small-object conditions). It maintained a processing speed 10× faster than comparable methods, enabling real-time operation. The algorithm also outperformed benchmarks in F1 score (avg. 94.2%) and kappa coefficient (avg. 0.91), demonstrating superior robustness. Conclusions: FASTSeg3D addresses critical limitations in ground segmentation by balancing speed and accuracy, making it ideal for real-time robotic applications in diverse environments. Its computational efficiency and adaptability to edge cases represent a significant advancement for autonomous systems.

1. Introduction

Perception is a vital step toward automation in robotic devices. With growing interest in autonomous systems, safety and efficiency remain paramount [1]. A key component of effective perception tasks for robotic devices is obtaining accurate orientation and depth information about their surroundings. Therefore, many applications—such as scene registration and reconstruction (for reverse engineering), simultaneous localization and mapping (SLAM) for autonomous navigation and control, and three-dimensional (3D) object detection—require sensors that can collect 3D and depth information to complete tasks successfully and efficiently.

Although recent research trends have explored depth estimation using monocular cameras, this approach is inherently challenging [2,3] and its depth estimation accuracy over a distance is still inferior compared to sensors that can directly capture high-precision point clouds with rich and reliable environmental information for processing and interpretation by robots.

The mobile Light Detection and Ranging (LiDAR) sensor, also referred to as the mobile laser scanner (MLS), is a common sensor of choice for autonomous navigation systems (robots) to capture 3D point cloud information for perception tasks. With a point density or resolution greater than 100 pts/m² and a shorter survey distance, the MLS point cloud offers rich and reliable information about the environment [4,5]. However, these point clouds are usually unstructured, sparse, noisy, and have uneven sampling density. Therefore, ground filtering of point clouds is a crucial preprocessing step in autonomous robot perception systems, and its performance has a strong influence on the overall performance of the perception system. Nevertheless, ground filtering generally suffers from over-segmentation, under-segmentation, or slow segmentation, making it a non-trivial task [6,7,8].

Given these problems, this study proposes a fast ground filtering technique called FASTSeg3D, as presented in Figure 1. A two-stage ground filtering process is performed to extract candidate ground point clouds using a fast point representation technique to quickly organize, downsample, and filter outlier points in the point cloud simultaneously. A sliding-window model fitting approach is used in the second stage to address the over-segmentation problem adaptively, making it robust enough for complex terrains while still achieving real-time filtering. The main contributions of the study are summarized as follows:

• A range elevation estimation (REE) technique for fast organization of 3D point clouds, filtering of outliers, and estimation of terrain heights
• A window-based model fitting (WBMF) technique to adaptively address the over-segmentation problem and greatly reduce the number of false-positive segmented regions without compromising real-time filtering.
• A fast and adaptable ground filtering/segmentation algorithm (FASTSeg3D) for efficient organization, filtering/segmentation of ground and non-ground points within 3D point clouds in real time.

The remainder of this paper is organized as follows. Section 2 reviews related work. Section 3 describes the proposed method in detail. Section 4 shows, analyses, and discusses the experimental results, and Section 5 summarizes the article and prospects for future work.

2. Related Works

To be an effective preprocessing step, the ground filtering/segmentation technique has to be sufficiently fast, efficient, and robust. Unlike supervised approaches that involve learned parameters and lots of training, point cloud segmentation algorithms (including unsupervised clustering algorithms) are fundamentally the results of geometric constraints and statistical rules [8,9,10,11]. These algorithms generally have a well-defined approach towards segmenting regions and are interpretable and reusable. Also, they do not need to be retrained or relabelled to improve accuracy [11,12]. These attributes make them more data efficient than deep learning approaches. Although deep learning approaches are very efficient for applications that do not require real-time usage or have limited memory, point cloud filtering/segmentation algorithms are still a very common choice for applications that require real-time usage or fast preprocessing for downstream applications [13,14,15].

Several traditional techniques have been proposed for ground filtering/segmentation. These techniques are commonly utilized to establish ground planes for Digital Terrain Models (DTM) and Digital Surface Models (DSM) and aim to model and analyse terrain features by fitting ground models to the point cloud data. Various techniques have been employed, including ground filtering based on the construction of surface models, elevation differences, or morphological operations (i.e., erosion, dilation, opening and closing) [11,16,17].

2.1. Reference Ground Surface Filtering

Ground filtering based on a ground surface constructs a reference surface function and then classifies points by their spatial distance from the reference surface. This process is sometimes referred to as plane or ground fitting, or surface-based filtering [18,19]. Typically, a set of ground seed points is selected using specific criteria and gradually refined using various techniques to establish the reference surface function. The criteria for selecting ground seed points can include random selection [19], mean elevation values [20,21,22], or local lowest points [23,24]. The random sample consensus (RANSAC) plane segmentation method, proposed by [19], is one of the earliest approaches for selecting seed ground points and remains effective for flat roads with distinct boundaries. In this method, a minimal subset of data points is randomly selected, and a plane or surface model is fitted to these points. This process is repeated using regression techniques until a surface model with the highest number of inliers is obtained. Due to its fast and robust nature, many variations of RANSAC have been proposed for ground filtering [25,26,27]. However, a common drawback of these methods is their performance on curved or uneven terrains.

Some researchers proposed alternative regression techniques to address this problem [18,28,29,30]. Refs. [18,28] suggested using Gaussian process regression (GPR) to segment point clouds into multiple one-dimensional (1D) GPR problems with a covariance function, aiming to reduce complexity and improve computational efficiency. However, this method struggles on steep slopes and does not guarantee continuity in overall ground elevation. Ref. [29] proposed a more complex regression technique to accurately estimate ground heights. That approach integrated GPR with robust locally weighted regression (RLWR) to form a hybrid regression model, which proved to be robust in estimating road surfaces. Nevertheless, the success of that method depended on the accurate selection of pavement seed points, and it was more computationally demanding compared to GPR alone. Ref. [30] divided the ground surface into even segments and applied the region-growing clustering algorithm to the initial seed ground points for each segment. The approach aimed to segment the ground planes according to a specific distance threshold.

Ref. [20] constructed a reference ground surface model by interpolating initial seed points selected based on their mean elevation values. The reference ground surface was iteratively refined by assigning appropriate weights to each point. Ref. [31] improved that concept by introducing a hierarchical or multi-scale interpolation approach, allowing for data processing at multiple resolutions. Ref. [32] proposed the multi-scale curvature classification (MCC) method, which employed thin plate spline (TPS) interpolation to generate a reference ground surface from the seed points. The MCC method is simple and requires minimal user-defined parameters, such as initial scale and curvature tolerance. While MCC is highly effective in complex vegetation terrains, it struggles in very dense areas and regions with steep slopes, leading to misclassification of points. Its accuracy can also be influenced by the choice of parameters. Researchers have since proposed improvements to the MCC algorithm, such as the parameter-free hierarchical TPS interpolation by [33], enhanced smoothing TPS between adjacent levels by [34], and saliency-aware TPS interpolation for a terrain-adaptive ground filtering method by [35].

Ref. [36] used the moving-window weighted iterative least-squares fitting method to select seed points and applied the region-growing method [37,38] to reconstruct the complete set of ground points. Another approach to seed point selection for surface fitting or filtering is the progressive triangulated irregular network (TIN) densification filtering (PTDF) approach introduced by [23], which selects the lowest points as seed points. Although many improvements have been proposed to address the time consumption issue in the PTDF approach [24,39,40,41], PTDF variants still struggle to retain ground points in steep regions and may suffer from misclassification of ground points as non-ground due to the seed point selection strategy.

Reference ground surface models can also be established using active shape models. Ref. [42] proposed an algorithm utilizing an active shape model that behaved like a rubber cloth with elasticity and rigidity to estimate the ground surface. The surface shape was controlled by an energy function that minimized the energy to determine the surface position in a parametric form. Ref. [43] introduced the Cloth Simulation Filtering (CSF) method, an easy-to-use, fast, and efficient algorithm for ground filtering. The input LiDAR point cloud data were inverted, and a rigid cloth of a set resolution was used to cover the inverted surface, simulating the behaviour of a physical membrane. The interactions between cloth nodes and LiDAR points were analysed to determine the positions of the cloth nodes and approximate the reference ground surface. Finally, ground points were extracted by comparing the original LiDAR points with the generated surface. While this approach was efficient and adaptable to different terrains [43,44,45,46], it was still prone to environmental noise and struggled with complex terrains with steep slopes and large variability.

2.2. Elevation Differences Filtering

Slope or elevation ground filtering extracts ground points based on the slope differences between two points. This concept was introduced by [47], who assessed the local maximum slope and the elevation difference of the landscape. This approach is fast and effective when applied to fused point clouds built from multiple 3D scans but suffers from overfitting and is unsuitable for complex terrains. Many researchers have proposed improvements to adapt this approach to more complex terrain [48,49,50]. Ref. [49] proposed an adaptive method that automatically updated the slope threshold after each iteration. To address errors due to directional sensitivity, ref. [48] proposed the Multi-directional Ground Filtering (MGF) algorithm, which incorporated a two-dimensional neighbourhood in directional scanning. Ref. [50] applied a slope-based filter to each profile of LiDAR points in one direction and another filter to the same profile in the opposite direction (180 degrees apart) to address over-filtering, especially in cliff-like terrains. However, that approach was parameter-sensitive and computationally demanding.

Ref. [51] adopted that approach to propose the elevation map method. Initially introduced by researchers at Stanford University, the algorithm segments the point cloud into cells and calculates the maximum height difference within each cell. If the difference surpasses a certain threshold, all points in the cell are classified as non-ground points. Although this straightforward method can manage irregular terrains, it may lead to incorrect classifications in cells with a sparse number of points or those containing overhanging structures. Ref. [52] proposed using a multi-volume grid elevation map to store the start and end heights of the consistent vertical regions in each cell, tracking the ground planes. However, their solution did not focus on coarse-to-fine ground segmentation and was insensitive to slope terrain.

The slope and elevation map ground filtering method demonstrates the potential for establishing distinct geometric features for ground filtering [53,54]. This is also explored in Conditional Random Field (CRF) methods, like the Markov Random Field (MRF) method, which uses gradient cues of the road geometry to implement belief propagation for classifying the robot’s environment into different regions [55,56]. While this approach has proven robust on uneven terrain, it is time-consuming.

2.3. Morphological Operations Filtering

Some researchers apply morphological operations to point cloud data (PCD) for ground filtering. These non-linear operations are used to expand or reduce certain object sizes [57,58,59]. This concept was applied by [60] to PCD for ground filtering, but it was ineffective in filtering large-sized objects. To address this, ref. [61] proposed progressive morphological filters (PMFs), which gradually increased the window size to accommodate larger objects. Ref. [62] suggested adapting the algorithm to different terrains without the need for constant-slope assumptions. Due to the computational demands of PMFs, ref. [63] proposed the simple morphological filter (SMRF), which employed a linear increase in window size and a slope thresholding technique to filter objects. Ref. [64] introduced the use of differential morphological profiles (DMPs) on points’ residuals from the approximated surface, forming a top-hat scale space to extract ground points based on their geometric attributes. Many other researchers have proposed methods to enhance the effectiveness of morphological filters (MFs) in complex terrains [64,65,66,67,68]. However, MFs are less effective for complex structures and varying object sizes and may become computationally expensive when performance improvements are sought.

3. Methods

3.1. Problem Definition

For a given 3D point with Cartesian coordinates $\{x_i,y_i,z_i\}$, in a 3D LiDAR point cloud $P=\{\{x_1,y_1,z_1\},\{x_2,y_2,z_2\},\{x_3,y_3,z_3\},\dots ,\{x_n,y_n,z_n\}$, where $p_i\in {\mathbf{R}}^3$ and P contain N points, the task is to estimate the number of points $p_i$ in P, with guaranteed recall and precision performance, that can be classified as a ground class, including relatively flat [69] surfaces like drivable surfaces, terrain, pavements, and other flat surfaces or a non-ground class, which includes vehicles, humans, and static and movable objects.

3.2. FastSeg3D: Point Cloud Data Representation

To estimate the elevation of each point in the 2D map, the range elevation estimation (REE) technique was proposed. Ideally, the lowest (sets of) height(s) within a given grid cell of a point cloud are expected to be ground points, and it is based on this assumption that elevation features are extracted and height thresholds are determined. But this is not always the case. For instance, some grids do not contain ground points, road and drivable terrains are not always flat, and occasionally, noisy points are observed below the ground points as a result of reflected points from objects and this can lead to under-segmentation. To address noisy points, refs. [70,71] observed that noisy points usually contained a noticeably smaller intensity as compared to their neighbouring points and the authors proposed intensity correction techniques to address the effect of noisy points on lane detection and improve the simultaneous localization and mapping (SLAM) framework, respectively. Also, the incidence angle ($\varphi$) of each point affects the intensity of each point. Ref. [72] conducted some analysis on the impact of the incidence angle on intensity and reported that reflectance was proportional to the incidence angle. This also explained the relatively smaller intensity of noisy points.

Since the 2D range image representation technique has demonstrated its performance, effectiveness in point distribution over varying distances and inexpensive computational cost for point cloud representation, like the ring elevation map [73] and the polar grid technique [29], the FastSeg3D employs similar data representation method, as shown in Figure 2, to achieving a fast means of organising the raw captured point clouds. The range values $r_i$ and azimuthal angle ${\theta }_i$ (horizontal angles) of each point $p_i$ in the point cloud, P is used to represent all points as a 2D image $P_{(r,\theta )}$.

To achieve this, an empty placeholder 2D image $P_{(r,\theta )}$ is created, and a data structure $\{I_{(r,\theta )},L_{(r,\theta )},E_{(r,\theta )},d_{(r,\theta )},{\alpha }_{(r,\theta )}\}$ is also created for fast lookup, where the attributes in the data structure are the unique features of every point in the point cloud: cloud index $I_{(r,\theta )}$, point labels $L_{(r,\theta )}$, elevation value $E_{(r,\theta )}$, distance of point to origin $d_{(r,\theta )}$, and inclination angle ${\alpha }_{(r,\theta )}$. The range value and azimuthal angle values for a given point $p_i$ in the point cloud, P can be expressed as:

$$r_i=\sqrt{{x_i}^2+{y_i}^2}$$

(1)

$$\begin{array}{cc}\hfill {\theta }_i& =floor{\displaystyle \frac{{\theta }_{degree}}{360}}\hfill \end{array}$$

(2)

where:

$$\begin{array}{cc}\hfill {\theta }_{degree}=& \left\{\begin{array}{cc}0,\hfill & \mathrm{if}{y}_{(r,\theta )}, \mathrm{and}{x}_{(r,\theta )}=0\hfill \\ arctan2(y_{(r,\theta )},x_{(r,\theta )}),\hfill & \mathrm{if}{y}_{(r,\theta )}\ge 0\hfill \\ arctan2(y_{(r,\theta )},x_{(r,\theta )})+2\pi ,\hfill & \mathrm{if}{y}_{(r,\theta )}<0\hfill \end{array}\right.\hfill \end{array}$$

The maximum row range of the 2D image $P_{r,\varphi }$ is determined by the approximate maximum range of accurate measurements from most common LiDAR systems like the Velodyne 32E, and 64E, used by autonomous robots. This value is usually around 70 m, therefore the range of values for the row of the 2D image, which represents the range values of each point in the point cloud, was set to 0–70 m. The maximum column range of the 2D image $P_{r,\theta }$ is determined by using the rated angular resolution (horizontal/azimuth) of the LiDAR datasheet, which is between the range of ${0.1}^{\circ }$ to ${0.4}^{\circ }$. Since the LiDAR sensor/system performs a ${360}^{\circ }$ scan, it is divided by the resolution to estimate the maximum column range, that is, ${\displaystyle \frac{{360}^{\circ }}{{0.4}^{\circ }}}$, which gives a value of 900. Now, the best case, which is ${\displaystyle \frac{{360}^{\circ }}{{0.1}^{\circ }}}$, gives a value of 3600, but this is only possible if the LiDAR system is run at a very low RPM of about 300, which is not ideal for capturing point clouds in real time. Most LiDAR systems used for navigational purposes are configured to run at maximum speed (approximately 20 Hz) with an RPM of about 1200, which accounts for the angular resolution of ${0.4}^{\circ }$. With a calculated value of 900, the formula $2^n$ is used to find the closest value to but greater than 900 to ensure that the image representation of the point cloud conforms with the standard computer vision resolution for images. Therefore, the maximum column value was set to 1024 for 32-beam laser LiDAR and 2048 for 64-beam laser LiDAR systems.

Every point in the point cloud is allocated to a cell/pixel in the 2D image once its calculated values fall within the 2D range image. The angular resolution for each cell of the 2D range image can be obtained from the LiDAR field of view (FOV); this could be ${360}^{\circ }$ divided by the maximum column value (this could be 1024 or 2048). Additionally, the vertical resolution can be obtained from the range values, which were set to 70 m divided by the LiDAR number of lasers. For instance, the Velodyne 32E has 32 laser scanners and the Velodyne 64E has 64. Points that fall within the range of 0–2 m are filtered out to account for points that fall on the ego vehicle during the LiDAR system scan. This condition can be expressed as follows:

$$p_{(r,\theta )}\in y_{(i,j)}\left\{\begin{array}{cc}{R}_i\le R_{(r,\theta )}<R_{r+1},\hfill & \mathrm{where}i\in \{0,\mathbf{I}-1\}\hfill \\ i={\theta }_{norm}=\lfloor \frac{{\theta }_{norm}}{360}\rfloor ,\hfill & \mathrm{where}i\in \{0,\mathbf{I}\}\hfill \end{array}\right.$$

(3)

3.3. Algorithm 1: Range Elevation Estimation (REE)

After allocating points to the 2D range image the minimum elevation values and the elevation thresholds of each cell/pixel in the point cloud are estimated and used to determine the ground and non-ground points from all valid points in the 2D range image. Traversing across adjacent points, i.e., across the columns in the 2D range image, the minimum elevation, $E_{min}$, is determined by comparing the third spatial coordinate value of the previous point, $z_{(i-1,j)}$ and the current point, $z_{(i,j)}$, to find the minimum value. This value is set as the minimum value for the current cell or pixel.

The elevation values are calculated using the $z_{(r,\theta )}$ coordinate of each point in the point cloud and an elevation tolerance $E_t$ of $0.2$ m along the row, which is also called the adjacent points $z_{(i-1,j)},z_{(i,j)}$ of the range image. The elevation tolerance $E_t$ is allowed enough tolerance to accommodate all possible ground points during the first segmentation process. For the condition $r=0$, where the row number is zero, the elevation value is the same as the minimum third spatial coordinate of the point(s) in the current cell/pixel. This can be expressed as:

$$E_{min(i-1,j)}=\left\{\begin{array}{cc}{E}_{(i,j)},\hfill & P_{(r,\theta )}\mathrm{for}r=0\hfill \\ E_{(i-1,j)}+E_t,\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

(4)

The REE algorithm is shown in Algorithm 1.

Using the set elevation threshold $E_t$ and the estimated minimum elevation for each cell $E_{min(i,j)}$, a threshold value $E_{th}$ is set for each cell and used to segment points in that cell as a ground or non-ground point. Therefore, points equal to or above the threshold value $E_{th}$ are labelled as non-ground points, and points below as ground points. This is expressed as:

$$E_{th}=E_{min(i,j)}+E_t$$

(5)

The complexity of the REE algorithm is shown in Appendix A.1.

Algorithm 1 Coarse segmentation (REE)

Input: raw point cloud $P=\{p_1,p_2,\dots ,p_N\}$

Output: coarsely segmented ground/non-ground labels

Parameters:

i.    $E_t$: elevation tolerance (default: $0.2\mathrm{m}$)

ii.   $R_{max}$: maximum LiDAR range (default: $70\mathrm{m}$)

iii.    Angular resolution $\mathrm{\Delta }\theta :{0.4}^{\circ }$

1: Initialize 2D range image $P_{(r,\theta )}$ with dimensions $\left({\displaystyle \frac{R_{max}}{\mathrm{\Delta }r}}\right)\times \left({\displaystyle \frac{360}{\mathrm{\Delta }\theta }}\right)$

2: for each $p_i=(x_i,y_i,z_i)$ in cloud P do

3:       Compute range $r_i=\sqrt{x_i^2+y_i^2}$;

4:       Compute azimuth ${\theta }_i=\arctan 2(y_i,x_i)$;

5:       Map $p_i$ to cell $(r,\theta )$ in $P_{(r,\theta )}$;

6: end for

7: for each row r in $P_{(r,\theta )}$ do

8:       Compute minimum elevation $E_{min}(r,\theta )$;

9:       $E_{min(i,j)}=min(E_{(i,j)},E_{(i-1,j)}+E_t)$;

10:     if $r=0$ then

11:          $E_{min}(r,\theta )=min\left(z_i\right)$;

12:     else

13:          $E_{min}(r,\theta )=min(E_{min}(r-1,\theta )+E_t,min\left(z_i\right))$;

14:     end if

15:     Label points in cell $(r,\theta )$;

16:     if $z_i\ge E_{min}(r,\theta )+E_t$; then

17:          label as non-ground: $labe{l}_{(r,\theta )}=non\text{\_}ground$;

18:     else

19:          label as ground: $labe{l}_{(r,\theta )}=ground$;

20:     end if

21: end for

22: Return labelled point cloud;

3.4. Algorithm 2: Window-Based Model Fitting (WBMF)

The REE coarse segmentation techniques result in a high level of over-segmentation of ground points, as observed in Figure 3. This is understandable because all valid points within the range image are labelled as ground points before the elevation threshold $E_{th}$ is used to segment non-ground points. To address this, the window-based model fitting technique is employed to adaptively calculate the unique spatial and geometric features of each point in a predefined region/window size which is a subsection of the entire range image, as shown in Figure 4 and Algorithm 2. This window is traversed across the column, and the spatial and geometric features for each point within the current window are re-calculated. These values are updated in the data structure and used to perform a fine-grain segmentation of the initially segmented points in the point cloud.

The 2D image is divided into smaller regions by calculating the subset region dimension, which is depicted as $w,c$ $\mathrm{where}(w\le r,w\%r=0),\mathrm{and}(c\le \theta ,c\%\theta =0)$, as shown in Appendix A.2. This is also referred to as the window dimension. The best seed points $G^k$ are determined and used for the plane model $M_w$ and the normal vector $\overrightarrow{n_w}$ using the principal component analysis (PCA) [74] technique. Details are shown in Appendix A.2.

Algorithm 2 Window-based model fitting (WBMF)

Input: coarsely labelled point cloud from REE image, $P_{(M\times N)}$

Output: refined ground/non-ground labels

Parameters:

i.    W: window size

ii.   $E_t$: elevation tolerance (default: $0.2\mathrm{m}$)

iii.   Window dimensions $w_r=64$, $w_c=14$ (for $1024\times 70$ grid)

iv.   Slope threshold ${\alpha }_{th}={10}^{\circ }$, distance threshold $d_{th}=1 \mathrm{m}$, elevation threshold $E_{th}=0.2 \mathrm{m}$

v.    Min/max seed points per window: $5/20$

vi.   $G^k$: candidate ground points, where k represents candidate points for $W_{(w,c)}$

vii.    NOTE: 0 indicates ground label, and 1 indicates non-ground.

1: Divide 2D range image into sliding windows $W_{(w,c)}$ of size $w_r\times w_c$

2: for each window $W_{(w,c)}$ in $P_{(M\times N)}$ do

3:       Select candidate ground seeds $G^k$ with lowest elevation in $W_{(w,c)}$

4:       Compute covariance matrix M of $G^k$:

5:       $M={\displaystyle \frac{1}{k}}{\sum }_{i=1}^k(p_i-\mu ){(p_i-\mu )}^T$, where $\mu =\mathrm{mean}\left(G^k\right)$

6:       Perform PCA on M to compute normal vector $\overrightarrow{n}=(a,b,c)$

7:       if $j\ge k$ then

8:             for each point $p_j$ in $W_{(w,c)}$ do

9:                   Compute distance to plane: $d_j={\displaystyle \frac{|a{x}_j+b{y}_j+c{z}_j+d|}{\sqrt{a^2+b^2+c^2}}}$

10:                 Compute inclination angle: ${\alpha }_j=arctan\left({\displaystyle \frac{z_j}{d_j}}\right)$

11:                 if $d_j>d_{th}$ OR ${\alpha }_j>{\alpha }_{th}$ OR $z_j>E_{th}$ then

12:                       Reclassify as non-ground: $labe{l}_{(r,\theta )}=1$

13:                 end if

14:           end for

15:     else

16:           add $W_{(w,c)}$ to $W_{(w+1,c)}$

17:     end if

18: end for

19: Return refined labels

4. Results and Discussion

To validate the study’s contribution and verify the progressiveness of both modules (REE, and WBMF), in this section, the performance increase is presented with the introduction of each module and the accuracy-to-speed tradeoff. Then, FASTSEG3D is compared to some existing methods like the CSF [43], RANSAC [19], PTDF [23], and more similar and recent works by [75,76]. Demonstrations of the FASTSEG3D modules alongside the ground truth are shown in Figure 5.

4.1. Experimental Setup

The experiment for all algorithms was performed on the C++ Point Cloud Library (PCL) using the same computer (Ryzen 9 5900x and 32 GB of RAM) for consistency. Then, the NuScenes [77] dataset was adopted to evaluate and compare the proposed FASTSEG3D ground removal algorithm to other efficient algorithms. Based on the point-wise labels, the points labelled as flat.terrain, flat.other, flat.sidewalk, and flat.driveable [77] were considered to be ground points, points labelled as noise were ignored, and every other point was considered to be a non-ground point.

4.2. Experimental Parameters

To conduct the experiments, the following settings were used: the range image dimensions were configured as $(\mathrm{row},\mathrm{column})=\{(x_{\min },x_{\max }),(y_{\min },y_{\max })\}=\{(0,1024),(0,70\mathrm{m})\}$ for the nuScenes dataset. Elevation tolerance was set to $E_t=0.2\mathrm{m}$.

For WBMF, the window dimensions were defined by rows ($w_r$) and columns ($w_c$), with $w_r={\displaystyle \frac{1024}{16}}$ and $w_c={\displaystyle \frac{16}{5}}$. The number of seed points per window was constrained between a minimum of 5 and a maximum of 20. Additional thresholds included a distance threshold to the window origin $d_{\mathrm{th}}=1\mathrm{m}$, inclination angle threshold ${\alpha }_{\mathrm{th}}={10}^{\circ }$, and elevation threshold $E_{\mathrm{th}}=0.2\mathrm{m}$.

4.3. Evaluation Metrics

To evaluate the proposed approach, the mean error sensitivity ($error\text{\_}1$ and $error\text{\_}2$), frames per second ($fps$), the mean intersection over union ($IoU\text{\_}1$ and $IoU\text{\_}2$), the harmonic mean of precision and recall ($f1\text{\_}score\text{\_}1$ and $f1\text{\_}score\text{\_}2$), the mean kappa coefficient ($kappa\text{\_}coeff$), and the mean accuracy ($accuracy$) for predicted ground and non-ground points in each scene were calculated [11,78,79,80]. The harmonic mean of precision and recall measures the balance between the precision and recall, and the kappa coefficient assesses the reliability of the classification method.

To assess the performance of the proposed algorithm in varying scenarios, the algorithm was tested under different conditions. These conditions included varying lighting (day and night), scenes with predominantly large objects such as vehicles in heavy or dense traffic ($big\text{\_}obj$), scenes with predominantly pedestrians in heavy or dense traffic ($ped$), heavy and fast-moving traffic with lots of objects in rainy, cloudy weather ($rainy$), and scenes with predominantly small objects ($small\text{\_}obj$), like vegetation, debris, and traffic cones in heavy or dense traffic. The total numbers of object points and ground points for each scene are presented in

Table 1. Total numbers of object points and ground points for each scene.

	Scenarios (Day)				Scenarios (Night)
Points	bobj	sobj	ped	rainy	bobj	sobj	ped	rainy
Ground	397,807	700,934	568,069	480,057	530,289	683,107	634,778	507,694
Objects	1,025,658	688,002	820,475	908,719	858,359	705,829	753,806	880,922

. The total number of object points in each scene explains the rationale behind their selection.

A total of eight scenes were selected based on these conditions from the nuScene LiDAR dataset with a total of 313 LiDAR scan samples. The metrics used can be expressed as:

$$error\text{\_}1={\displaystyle \frac{FN}{TP+FN}}$$

(6)

$$error\text{\_}2={\displaystyle \frac{FP}{TN+FP}}$$

(7)

$$IoU\text{\_}1={\displaystyle \frac{TP}{TP+FP+FN}}$$

(8)

$$IoU\text{\_}2={\displaystyle \frac{TN}{TP+FP+FN}}$$

(9)

$$f1\text{\_}score\text{\_}1=2\times {\displaystyle \frac{recal{l}_1\times precisio{n}_1}{recal{l}_1+precisio{n}_1}}$$

(10)

$$f1\text{\_}score\text{\_}2=2\times {\displaystyle \frac{recal{l}_2\times precisio{n}_2}{recal{l}_2+precisio{n}_2}}$$

(11)

$$kapp{a}_{coeff}={\displaystyle \frac{P_0-P_e}{1-P_e}}$$

(12)

$$accuracy={\displaystyle \frac{TN+TP}{TP+TN+FP+FN}}$$

(13)

$$fps={\displaystyle \frac{1}{\mathrm{time}\mathrm{per}\mathrm{frame}}}$$

(14)

where $TP,TN,FN,\mathrm{and}FP$ represents the number of true positives, true negatives, false negatives, and false positives for predicted points, $recall\text{\_}1$ and $precision\text{\_}1$ represents the recall and precision for ground points, and $recall\text{\_}2$ and $precision\text{\_}2$ represents the recall and precision for non-ground points; $P_0$ represents the observed agreement, and $P_e$ represents the expected agreement by chance.

These metrics give an in-depth insight into how reliable and robust a classification method is for ground filtering. For autonomous driving, these metrics are important to measure the ability of the proposed algorithm to correctly and reliably identify all relevant instances of a target class within a dataset.

The FASTSEG3D modular evaluation begins by showing the performance-to-speed tradeoff in

Table 2. Performance metrics for different FastSeg3D modules across scenarios (day).

	Scenarios (Day)
	bobj		sobj		ped		rainy
Metrics	Mean	Range	Mean	Range	Mean	Range	Mean	Range
FPS (Hz)
REE	129.82	24.61	127.69	9.36	136.61	28.83	154.95	9.13
WMBF	55.93	10.29	46.69	4.20	51.12	5.45	59.62	2.33
error_1 (%)
REE	14.31	17.98	6.73	4.53	5.07	10.68	1.28	0.25
WMBF	0.39	1.61	0.72	0.71	0.24	2.66	0.07	0.13
error_2 (%)
REE	7.82	8.25	11.03	5.72	10.02	7.69	9.89	2.55
WMBF	3.54	3.12	3.15	1.89	6.26	3.83	2.22	1.06
IoU_1 (%)
REE	74.83	28.58	87.88	5.73	88.06	14.52	92.83	1.47
WMBF	91.75	12.00	95.69	2.76	94.67	6.53	96.63	1.09
IoU_2 (%)
REE	85.65	9.66	79.40	10.38	84.76	11.25	88.35	2.28
WMBF	96.22	4.37	93.07	5.89	95.43	9.71	95.76	2.53
f1_score_1 (%)
REE	85.36	18.08	93.55	3.28	93.61	8.50	96.28	0.79
WMBF	96.38	8.36	97.80	1.45	97.25	3.48	98.29	0.72
f1_score_2 (%)
REE	92.25	5.58	88.50	6.57	91.72	6.66	93.81	1.28
WMBF	97.39	2.21	98.87	3.21	97.49	7.16	97.78	1.35
kappa_coeff (%)
REE	77.61	23.30	82.05	9.85	85.34	12.45	90.10	2.06
WMBF	92.01	7.17	93.67	4.65	92.76	10.06	95.07	2.06
accuracy (%)
REE	90.05	9.63	91.75	4.38	92.87	6.13	95.36	0.97
WMBF	97.15	3.45	97.13	2.00	96.63	4.21	97.76	0.94

for day scenarios and

Table 3. Performance metrics for different FastSeg3D modules across scenarios (night).

	Scenarios (Night)
	bobj		sobj		ped		rainy
Metrics	Mean	Range	Mean	Range	Mean	Range	Mean	Range
FPS (Hz)
REE	128.63	34.34	126.32	20.62	126.78	44.24	132.85	20.18
WMBF	49.82	4.06	47.96	8.28	48.20	6.66	49.85	7.24
error_1 (%)
REE	8.78	11.69	10.83	15.59	8.26	6.93	5.83	8.78
WMBF	0.61	1.68	5.75	7.24	1.30	0.94	0.60	1.11
error_2 (%)
REE	12.43	6.37	13.64	13.51	12.46	2.55	18.11	20.87
WMBF	5.22	3.43	5.63	3.16	2.49	2.18	9.69	14.16
IoU_1 (%)
REE	82.09	15.70	81.77	19.17	84.61	8.98	79.00	25.58
WMBF	92.52	8.67	88.87	13.52	93.62	4.49	89.98	17.13
IoU_2 (%)
REE	80.02	7.35	72.00	32.83	78.04	5.20	77.36	17.79
WMBF	93.07	6.15	83.05	18.06	91.16	3.12	88.62	8.06
f1_score_1 (%)
REE	90.10	9.61	89.87	11.73	91.65	5.38	88.08	16.73
WMBF	96.10	4.75	93.49	9.54	96.70	2.42	92.88	11.40
f1_score_2 (%)
REE	88.89	4.59	83.40	23.02	87.66	3.29	87.16	11.52
WMBF	96.77	4.01	91.47	8.11	96.82	2.30	94.95	2.25
kappa_coeff (%)
REE	79.00	13.66	73.38	29.12	79.31	6.94	75.42	20.76
WMBF	91.93	7.43	84.03	14.78	92.53	4.53	86.34	17.61
accuracy (%)
REE	89.67	7.17	88.00	12.70	90.08	4.02	87.94	10.28
WMBF	96.06	4.49	92.17	10.14	96.48	2.37	92.67	7.47

, for night scenarios. Generally, metric values above 80% and error values below 10% are considered very good scores for prediction. The range values show the spread between the best and worst metrics for the samples of a given scene. The smaller the spread, the better the method.

Similar to the point cloud 2D image representation of [73], the range elevation map representation of point clouds addresses the limitations of the traditional polar representation for uneven distribution of points over distance. This becomes the premise for the success of the REE technique. Capitalizing on the evenly distributed point cloud to estimate ground points, which are expected to be all points less than the point with the minimum elevation and a certain slope threshold for all points with similar ranges, the REE successfully achieved a rough segmentation. However, the REE module had limited accuracy for ground removal because its threshold for elevation was fixed. This led to a high number of false positives and false negatives as shown in Table 2 and Table 3. These were most obvious in the accuracy and kappa coefficient metrics. In particular, the kappa coefficient for both day and night revealed the reliability or the level of agreement by chance of the REE module.

The WBMF technique takes advantage of the initially classified points of the REE module to refine the initial segmentation. Because points within a similar range could include flat terrains that are above the slope threshold, calculating the surface normal of that region and refining the labels according to the surface normal threshold values for that region was successful, as shown in Figure 5.

4.4. Comparative Methods

The proposed method, FASTSEG3D, was compared with three well-known filtering algorithms and two more recent algorithms, including Cloth Simulation Filtering (CSF) by [43], random sample consensus (RANSAC) by [19], Progressive Triangulated Irregular Network (TIN) Densification Filtering (PTDF) by [23], and more recent works by [75,76]. All algorithms were tested using the same experimental setup as shown in

Table 4. Parameters for compared methods.

Method	Parameters	Tuning Strategy
FASTSeg3D	$E_t=0.2\mathrm{m},$${\alpha }_{th}={10}^{\circ },$$d_{th}=1\mathrm{m}$	Empirical validation on nuScenes
CSF [43]	Cloth resolution = 0.5 m, rigidness = 3, iterations = 500	Default values from original paper
RANSAC [19]	Distance threshold = 0.3 m, max iterations = 1000	Grid search on validation set
PTDF [23]	Max edge length = 1.5 m, angle threshold = 5°	As per PCL implementation
PatchWork++ [75]	Sector size = 100, elevation threshold = 0.1 m	Default values from GitHub v1.0 repo
JPC [76]	Jump distance = 0.5 m, height threshold = 0.2 m	Author-provided configuration

.

For a fair comparison, the parameter setups for all baseline methods were configured according to their original implementations or recommendations. These included CSF, RANSAC, PTDF, PatchWork++, and JPC, as detailed in Table 4. Each method was either tuned via default settings, validation-based optimization, or author-provided configurations to ensure consistency and reproducibility across evaluations.

RANSAC and PTDF were implemented using the PCL [81] and Fade2.5D [82] library, and CSF [43,75,76] was implemented using the publicly available C++ codes (CSF https://github.com/jianboqi/CSF, PatchWork++ https://github.com/url-kaist/patchwork-plusplus, JPC https://github.com/wangx1996/Fast-Ground-Segmentation-Based-on-JPC accessed on 25 April 2022), respectively.

Table 5. Performance-to-speed comparison of FASTSEG3D against other algorithms (day).

	Scenarios (Day)
	bobj		sobj		ped		rainy
Metrics	Mean	Range	Mean	Range	Mean	Range	Mean	Range
FPS (Hz)
Proposed	55.93	10.29	46.69	4.20	51.12	5.45	59.62	2.33
CSF [43]	0.41	1.39	0.22	0.48	0.16	0.88	0.25	0.28
RANSAC [19]	10.76	6.29	11.03	1.27	11.71	3.19	13.38	1.22
PTDF [23]	0.47	1.42	0.25	0.49	0.24	0.76	0.38	0.17
PatchWork++ [75]	5.29	0.98	4.63	0.19	4.92	0.62	5.33	0.12
JPC [76]	45.00	17.22	39.72	13.31	47.44	10.19	50.87	7.53
error_1 (%)
Proposed	0.39	1.61	0.72	0.71	0.24	2.66	0.07	0.13
CSF [43]	5.63	53.30	0.50	1.40	1.60	7.19	0.13	0.56
RANSAC [19]	0.43	1.82	7.12	8.65	1.45	5.19	7.24	3.43
PTDF [23]	7.19	6.22	9.65	10.95	6.36	9.45	6.87	3.78
PatchWork++ [75]	4.17	10.98	7.64	7.76	4.12	10.50	3.58	0.97
JPC [76]	2.14	5.02	5.99	3.31	1.79	4.07	0.28	0.23
error_2 (%)
Proposed	3.54	3.12	3.15	1.89	6.26	3.83	2.22	1.06
CSF [43]	11.09	49.64	6.88	3.73	10.66	17.59	4.81	1.75
RANSAC [19]	5.93	4.33	3.88	2.90	9.67	24.59	7.68	2.41
PTDF [23]	13.31	38.12	10.14	4.22	11.45	15.66	8.91	3.93
PatchWork++ [75]	2.42	2.80	4.46	1.94	4.03	5.17	2.54	2.49
JPC [76]	7.74	7.13	9.86	2.40	11.28	14.06	11.98	1.09
IoU_1 (%)
Proposed	91.75	12.00	95.69	2.76	94.67	6.53	96.63	1.09
CSF [43]	73.52	62.04	93.20	3.07	84.97	27.49	91.54	2.67
RANSAC [19]	90.90	10.00	90.89	8.11	91.71	18.45	88.32	4.56
PTDF [23]	72.11	48.29	89.70	5.09	82.11	31.32	90.22	3.21
PatchWork++ [75]	89.96	17.35	88.48	6.38	90.49	10.15	92.32	1.39
JPC [76]	84.65	23.51	88.41	3.35	89.45	10.84	92.18	0.85
IoU_2 (%)
Proposed	96.22	4.37	93.07	5.89	95.43	9.71	95.76	2.53
CSF [43]	87.28	49.69	92.64	3.22	88.36	17.63	95.13	1.70
RANSAC [19]	93.78	4.00	85.19	13.78	88.68	26.50	83.16	6.26
PTDF [23]	86.52	39.23	89.67	6.22	86.23	19.40	92.33	8.10
PatchWork++ [75]	96.08	5.19	88.62	6.40	89.74	12.59	92.02	2.75
JPC [76]	91.90	12.32	89.16	3.85	91.83	10.81	90.01	4.26
f1_score_1 (%)
Proposed	96.38	8.36	97.80	1.45	97.25	3.48	98.29	0.72
CSF [43]	84.04	50.62	96.48	1.65	91.74	17.47	95.58	1.46
RANSAC [19]	95.21	5.50	95.22	4.54	95.63	10.65	93.80	2.53
PTDF [23]	81.44	33.10	92.38	2.52	89.30	12.98	93.47	2.22
PatchWork++ [75]	94.68	9.95	93.88	3.62	94.99	5.69	96.00	0.75
JPC [76]	91.58	14.13	93.85	1.88	94.41	6.18	95.93	0.46
f1_score_2 (%)
Proposed	97.39	2.21	98.87	3.21	97.49	5.16	97.78	1.35
CSF [43]	93.00	35.08	96.18	1.73	93.77	10.45	97.50	0.90
RANSAC [19]	96.79	2.13	91.98	8.30	93.86	16.40	90.80	3.65
PTDF [23]	90.03	38.22	91.43	3.40	92.12	11.06	95.49	4.10
PatchWork++ [75]	98.00	2.72	93.96	3.62	96.49	3.90	97.71	2.05
JPC [76]	95.43	4.00	90.33	3.16	92.94	8.17	93.42	0.67
kappa_coeff (%)
Proposed	92.01	7.17	93.67	4.65	92.76	10.06	95.07	2.06
CSF [43]	77.57	68.34	92.66	3.37	85.61	27.06	93.09	2.34
RANSAC [19]	88.81	17.31	87.21	12.71	89.52	26.38	84.60	6.16
PTDF [23]	78.43	62.08	88.54	4.37	82.03	27.85	88.75	4.26
PatchWork++ [75]	92.68	11.25	87.85	7.21	91.49	9.15	93.71	2.56
JPC [76]	87.05	17.20	84.18	5.03	87.38	13.78	89.37	1.10
accuracy (%)
Proposed	97.15	3.45	97.13	2.00	96.63	4.21	97.76	0.94
CSF [43]	90.46	40.89	96.33	1.69	92.93	13.18	96.81	1.11
RANSAC [19]	96.22	3.14	94.01	5.89	94.94	12.85	92.59	2.98
PTDF [23]	87.93	38.77	90.01	5.01	90.31	13.27	90.79	4.79
PatchWork++ [75]	94.62	8.25	93.92	3.62	95.90	4.36	97.10	1.53
JPC [76]	94.19	6.47	92.49	2.36	93.81	6.88	94.97	0.53

, for the day scenarios, and

Table 6. Performance-to-speed comparison of FASTSEG3D against other algorithms (night).

	Scenarios (Night)
	bobj		sobj		ped		rainy
Metrics	Mean	Range	Mean	Range	Mean	Range	Mean	Range
FPS (Hz)
Proposed	49.82	4.06	47.96	8.28	48.20	6.66	49.85	7.24
CSF [43]	0.17	0.61	0.33	0.65	0.15	0.13	0.09	0.28
RANSAC [19]	11.46	1.60	10.68	1.19	11.28	2.67	11.40	1.81
PTDF [23]	0.11	0.44	0.18	0.70	0.30	0.23	0.05	0.14
PatchWork++ [75]	4.88	0.47	4.68	0.73	4.63	0.37	4.87	0.65
JPC [76]	42.79	18.39	39.67	18.16	42.64	40.20	42.06	23.95
error_1 (%)
Proposed	0.61	1.68	5.75	7.24	1.30	0.94	0.60	1.11
CSF [43]	1.46	4.90	3.41	6.35	1.42	3.18	0.99	2.46
RANSAC [19]	4.25	8.60	21.47	26.14	6.50	5.38	5.58	16.60
PTDF [23]	6.79	9.68	16.10	19.49	5.68	8.96	6.55	13.04
PatchWork++ [75]	6.72	7.86	13.96	15.41	8.70	7.29	8.11	13.58
JPC [76]	4.25	11.39	12.26	24.36	9.21	9.16	4.15	7.80
error_2 (%)
Proposed	5.22	3.43	5.63	3.16	2.49	2.18	9.69	14.16
CSF [43]	10.12	10.33	11.70	18.14	6.82	3.29	17.94	24.95
RANSAC [19]	7.57	8.98	7.08	12.36	2.68	3.02	11.57	20.41
PTDF [23]	11.44	9.23	9.45	12.89	5.24	6.11	19.13	26.71
PatchWork++ [75]	3.77	2.17	5.97	5.44	3.77	1.37	7.82	10.92
JPC [76]	8.81	6.75	10.34	6.83	8.38	3.63	15.55	17.23
IoU_1 (%)
Proposed	92.52	8.67	88.87	13.52	93.62	4.49	89.98	17.13
CSF [43]	84.42	20.75	84.73	28.68	91.13	8.15	74.62	40.84
RANSAC [19]	89.23	11.88	74.19	22.72	91.83	5.53	83.30	24.08
PTDF [23]	82.11	21.03	85.21	26.22	89.28	9.19	75.11	37.18
PatchWork++ [75]	87.89	8.92	80.44	15.27	87.39	7.66	80.05	27.57
JPC [76]	87.74	9.36	81.18	18.05	85.35	10.37	80.59	21.11
IoU_2 (%)
Proposed	93.07	6.15	83.05	18.06	91.16	3.12	88.62	8.06
CSF [43]	89.12	10.94	85.05	16.88	92.10	3.27	81.53	23.20
RANSAC [19]	88.25	8.54	66.09	40.45	88.74	6.46	83.50	16.74
PTDF [23]	85.10	11.90	80.77	20.02	88.60	5.10	80.45	25.49
PatchWork++ [75]	92.38	6.69	81.72	20.76	89.72	3.19	87.93	9.22
JPC [76]	87.40	5.66	73.49	36.44	81.75	5.65	81.24	15.23
f1_score_1 (%)
Proposed	96.10	4.75	93.49	9.54	96.70	2.42	92.88	11.40
CSF [43]	91.47	12.59	91.55	18.03	95.35	4.56	84.89	28.67
RANSAC [19]	94.28	6.58	85.05	14.92	95.74	3.05	90.73	14.67
PTDF [23]	90.23	13.40	88.60	21.32	93.40	6.01	80.30	25.31
PatchWork++ [75]	93.54	5.11	89.12	9.55	93.26	4.44	88.73	18.05
JPC [76]	93.45	5.41	89.52	11.30	92.08	6.19	89.12	13.35
f1_score_2 (%)
Proposed	96.77	4.01	91.47	8.11	96.82	2.30	94.95	2.25
CSF [43]	94.22	6.22	91.87	10.19	95.89	1.78	89.66	14.48
RANSAC [19]	93.75	4.75	78.84	29.69	94.03	3.69	90.95	10.03
PTDF [23]	90.33	7.80	86.77	12.21	90.98	4.71	87.11	17.51
PatchWork++ [75]	96.03	3.66	89.82	12.91	94.58	1.77	93.55	5.26
JPC [76]	93.27	3.24	84.22	25.57	89.95	3.43	89.61	9.56
kappa_coeff (%)
Proposed	91.93	7.43	84.03	14.78	92.53	4.53	86.34	17.61
CSF [43]	85.75	18.22	83.51	27.59	91.25	6.31	75.19	40.02
RANSAC [19]	88.04	11.33	64.93	39.99	89.77	6.04	81.76	22.26
PTDF [23]	76.79	16.09	83.76	18.60	86.34	6.93	75.73	39.30
PatchWork++ [75]	89.57	7.78	79.02	18.51	87.85	5.43	82.33	22.42
JPC [76]	86.74	7.91	73.98	33.98	82.04	9.16	78.88	19.49
accuracy (%)
Proposed	96.06	4.49	92.17	10.14	96.48	2.37	92.67	7.47
CSF [43]	93.13	8.34	91.97	13.67	95.65	2.84	87.81	19.59
RANSAC [19]	94.09	5.78	82.87	19.99	95.04	3.07	91.00	11.36
PTDF [23]	89.46	8.22	85.46	13.41	92.02	3.04	84.94	17.38
PatchWork++ [75]	95.11	3.60	89.79	9.45	94.02	2.24	91.93	8.39
JPC [76]	93.44	3.93	87.81	15.17	91.18	4.84	89.59	10.25

, for the night scenarios, show the performance and speed of each algorithm as compared to FASTSG3D.

The result demonstrated that the proposed ground filtering method, FASTSEG3D, performed excellently in segmenting the ground and non-ground points of the given dataset. When all samples were observed, FASTSEG3D was able to achieve an error sensitivity rate for both ground and non-ground points ($error\text{\_}1$ and $error\text{\_}2$) of a mean error of less than 7% across all scenarios and an error value of 10% or less across all samples for every scenario for both the day and night test conditions, except for $error\text{\_}2$ values for the rainy-scene night condition.

Comparatively, refs. [19,76] achieved similar performance for only the mean day test condition. Ref. [43] achieved this for the mean $error\text{\_}1$ day and night test conditions. However, there were a few outlier results that gave some erroneous values across all samples for the day test condition for the big-object scenario; this can be seen from its range value of 53.30. Ref. [75] only achieved similar results for the mean $error\text{\_}2$ day and night test conditions. Although [75] performed better than FastSeg3D in the $error\text{\_}2$ rainy night scenario, FASTSEG3D outperformed [75] by executing its segmentation approximately 10 times faster. The proposed algorithm also demonstrated consistently better IoU scores for both ground and non-ground points across all test conditions maintaining a mean IoU score of above 90% except for the small-object and rainy-weather night conditions.

From Table 6, the rainy and small-object scenarios showed that all methods struggled in the ground filtering task, and this was also observed in the kappa coefficient values. This may be as a result of two key factors:

• LiDAR sensor noise: Rain droplets introduce false returns, increasing outliers below the true ground elevation. At night, reduced ambient light exacerbates noise in low-reflectivity regions (e.g., wet asphalt).
• Sparse ground points: In dense traffic/rainy scenes, ground regions are occluded, leading to sparsity. REE’s elevation threshold ($E_t$) struggles to distinguish ground from low-lying noise (e.g., puddles, tire splashes).

This means that these conditions make certain features associated with objects (like small objects or objects in poor lighting) harder to detect. Furthermore, Table 1 shows that the proportion of ground to non-ground points for most of the scenarios was not balanced, with non-ground points always suppressing the number of ground points. For scenarios with predominantly non-ground points, a smaller number of misclassified ground points (false positives, FPs) tended to have more effect on the metrics as compared to non-ground points. This was most obvious in the $f1\text{\_}score$ and $IoU$ scores of the big-object day test condition.

The proposed algorithm was the only one to maintain a mean F1 score above 90% across all test conditions and scenarios. Ref. [75]’s algorithm achieved similar results during the day condition, while CSF was close to the night condition. Although [76] had similar processing speed, the range for the processing speed showed that FASTSEG3D was more consistent across all scenarios, maintaining a better percentage difference. Furthermore, FASTSEG3D consistently achieved better performance than [76]. The percentage difference $perDiff$ can be expressed as:

$$\begin{array}{c}\hfill perDiff={\displaystyle \frac{range\times 100}{mean}}\end{array}$$

(15)

The kappa coefficient revealed how reliable all models compared were in the rainy and small-object night conditions. Overall the performance of the proposed algorithm was the most consistent across all test conditions. The mean kappa score was consistently above 90% except for the rainy and small-object scenarios in night test conditions. Figure 6 shows the accuracy graph of all methods across all samples, scenarios, and test conditions. Figure 6d,h also show how all methods struggled in performance for the rainy and small-object scenarios; however, the proposed algorithm performed consistently better.

5. Conclusions

This study introduced FASTSeg3D, a fast and efficient ground segmentation algorithm designed for the real-time processing of 3D point clouds. The proposed method employed a two-stage approach, utilizing the range elevation estimation (REE) technique for fast organization and initial segmentation of point clouds, followed by a window-based model fitting (WBMF) technique to address over-segmentation and improve accuracy, using the unique geometric features of the initially segmented points. Through this combination, FASTSeg3D effectively handled complex terrains and reduced false positives while maintaining high computational efficiency.

Four common challenging scenarios were selected under two test conditions (day and night test conditions) to reflect the most common and most tasking scenarios in real-world navigation tasks. These scenarios included scenes with predominantly large objects such as vehicles in heavy or dense traffic, scenes with predominantly pedestrians in heavy or dense traffic, heavy and fast-moving traffic with lots of objects in rainy, cloudy weather, and scenes with predominantly small objects, like vegetation, debris, and traffic cones in heavy or dense traffic. A total of eight scenarios consisting of 313 samples were selected for testing and comparative analysis.

Results showed that FASTSEG3D was the most consistent of the compared methods in terms of segmentation accuracy, kappa coefficient, processing speed, intersection over union (IoU), error sensitivity, and F1 score. FASTSEG3D consistently achieved an error sensitivity rate of less than 10% across all scenarios, and its mean error remained below 7% for both ground and non-ground points in day and night test conditions. The algorithm maintained IoU scores above 90% across most test conditions, except in the challenging rainy and small-object night scenarios, where it still performed better than other methods.

Notably, FASTSEG3D’s F1 score remained above 90% across all scenarios, making it the only algorithm to achieve such performance consistency. The kappa coefficient demonstrated FASTSEG3D’s reliability, consistently maintaining a score above 90% across most conditions, again except for the most challenging rainy and small-object night scenarios. In terms of processing speed, FASTSEG3D outperformed other effective methods significantly, achieving a speed of approximately 10 times faster than that of the method with the most similar level of performance.

Future work will focus on three directions: (1) integrating intensity and temporal features to suppress rain-induced noise, inspired by recent advances in multi-modal filtering; (2) developing adaptive window sizing and thresholding to handle non-uniform terrains without manual tuning; and (3) deploying FASTSeg3D on embedded platforms (e.g., NVIDIA Jetson) to validate real-world applicability in autonomous vehicles. These enhancements aim to bridge the gap between controlled benchmarking and operational reliability in unstructured environments.

6. Patents

This manuscript is currently under patent consideration and is protected under a successfully filled provisional patent, which can be found at https://patentscope.wipo.int/search/en/WO2025052319 (accessed on 13 March 2025).