In this chapter, we present a comprehensive evaluation of our bounded-error LiDAR compression framework. Our experimental analysis is organized into several sections. First, we introduce the KITTI dataset and describe its key characteristics, which make it an ideal testbed for evaluating LiDAR compression in real-world driving scenarios. Next, we detail our evaluation metrics and error settings, where the reconstruction error threshold T varies from 0.25 cm to 10 cm in increments of 0.25 cm. The performance is assessed in terms of compression ratio, encoding/decoding runtime, and reconstruction error measured by both mean and maximum axis-wise and Euclidean (L2) errors.
4.1. Dataset Introduction
Each bin file contains a single LiDAR scan acquired by a 64-beam Velodyne sensor (Velodyne, San Jose, CA, USA), where each scan typically comprises approximately 100,000 points. Every point is represented by a set of four floating-point values corresponding to the x, y, and z coordinates and the reflectivity. Given that the LiDAR sensor operates at 10 Hz, each bin file represents approximately 0.1 s of data.
To ensure that our evaluation captures a broad range of real-world scenarios, we selected sequences from several distinct environments provided by KITTI. Specifically, our experiments include scenes categorized as City, Residential, Road, Campus, and Person. This diverse selection allows us to assess the performance and robustness of our compression framework under various operating conditions and scene complexities.
4.2. Evaluation Metrics and Error Settings
A lower value of CR indicates that the method achieves a higher degree of compression, which is crucial for reducing storage requirements and transmission bandwidth. In addition to compression efficiency, we measure the computational overhead by recording the encoding time () and decoding time (), both reported in seconds. These timing metrics help determine whether the compression and decompression processes can be performed in real time on edge devices; a method that achieves excellent compression but requires excessive processing time may not be suitable for in-vehicle applications.
Again, both the mean and maximum errors are calculated across the dataset. The error threshold represents the maximum allowable deviation in real-world coordinates between the original and reconstructed points. In our experiments, is varied from 0.25 cm up to 10 cm in increments of 0.25 cm, thereby providing a detailed performance profile at 0.25 cm bins. Although the KITTI’s Velodyne sensor (Velodyne, San Jose, CA, USA) typically achieves an accuracy of approximately 2 cm, extending the threshold to 10 cm allows us to explore the trade-off between compression efficiency and reconstruction fidelity over a broader range. This extended range is particularly useful for applications where a slight degradation in geometric precision is acceptable in exchange for significantly reduced data volumes and lower bandwidth requirements for cloud-edge data transmission.
4.3. Comparison Among Compression Methods
In our experimental evaluation, we investigated the overall performance of our bounded-error compression framework by comparing the traditional lossless Huffman coding baseline with three families of bounded-error techniques (EB-HC, EB-3D, and the extended EB-HC-3D) implemented in two variants corresponding to either an axis-aligned (Axis) or an overall Euclidean (L2) error metric. The error threshold T varied from 0.25 cm to 10 cm. Because the LiDAR sensor’s inherent precision is approximately 2 cm, we report our results in two regimes: one with T ∈ [0.25, 2] cm that reflects the sensor’s accuracy, and another with T ∈ (2, 10] cm, where the allowed error exceeds the sensor precision.
Under single-bin conditions, the baseline Huffman method consistently achieves a CR of roughly 0.65, meaning that about 65% of the original data volume is retained after compression, with extremely fast encoding and . In contrast, the bounded-error methods significantly reduce the data volume. When the error threshold is maintained within the [0.25, 2] cm range, the EB-HC variant (regardless of whether it uses an Axis or L2 metric) typically reduces the compressed data size to approximately 35% of the original. In these cases, encoding is completed in less than half a second and decoding takes only a fraction of a second. The extended EB-HC-3D method, which exploits three-dimensional correlations more aggressively, further reduces the CR to around 28%, although its decoding process is somewhat slower. Meanwhile, the EB-3D methods tend to retain a higher fraction of the original data (around 54–55%) in this low-threshold regime, as they prioritize lower computational complexity over maximum compression efficiency. Notably, while the mean reconstruction error for each method provides an indication of the average geometric deviation introduced during compression, all methods are designed so that their maximum error remains below the prescribed threshold T, thereby ensuring that the critical geometric fidelity is preserved.
As the permitted error increases beyond the sensor’s precision (with T ∈ [2, 10] cm), all bounded-error methods achieve even greater compression. In this higher-threshold regime, the EB-HC techniques typically achieve compression ratios near 28–29%, whereas the EB-HC-3D methods can compress the data to roughly 20%. The EB-3D variants, meanwhile, exhibit compression ratios in the low 40-percent range. Although processing times in this regime tend to be slightly reduced due to the relaxed error constraints, the overall trend is clear: higher allowed errors yield more aggressive compression.
When multiple bins are processed together, the performance trends observed in the single-bin tests are further enhanced by the exploitation of inter-bin correlations. In multi-bin experiments, the baseline Huffman method still delivers a CR of approximately 0.65; however, the bounded-error methods achieve even lower ratios. For instance, in a typical campus scenario with T ∈ [0.25, 2] cm, the EB-HC method compresses the data to about 35% of its original volume, with on the order of 4 to 4.5 s and approaching 1.7 s. Interestingly, in the multi-bin experiments for the Campus and Person scenes, the EB-3D methods (as implemented via the extended EB-HC-3D variant) yield better compression ratios than the corresponding EB-HC methods. This is likely because the point clouds in these scenes are relatively sparse and exhibit slow motion; as a result, consecutive bins show little change, making an octree-based subdivision approach particularly effective. In urban scenes, such as those found in the city dataset, the EB-3D method typically achieves compression ratios in the high 40-percent range with of less than one second, while still maintaining competitive encoding performance.
For the low-error regime (T ∈ [0.25, 2] cm), which corresponds to the sensor’s inherent precision, the measured CD values are extremely low—often on the order of or less. For instance, at (T = 0.25) cm the EB-HC methods achieve CD values of approximately in both Axis and L2 modes, while the EB-HC-3D variants report values of about . This indicates that the reconstructed point clouds align extremely well with the ground-truth at the local scale. In this regime, the lossless baseline naturally yields an IoU of 1.0, and the bounded-error methods preserve nearly the entire volumetric occupancy.
At the borderline case of (T = 2) cm—the upper limit of the low-error regime—the performance of the different bounded-error methods begins to diverge. However, the local geometric fidelity, as measured by the Chamfer Distance, increases modestly to values on the order of , reflecting the increased error allowance. In contrast, the EB-octree methods—which leverage octree subdivision to capture three-dimensional spatial correlations—exhibit CD values typically in the range of and maintain nearly perfect IoU values (close to 1.0 for the Axis variant and around 0.99 for the L2 variant). The extended EB-HC-3D methods fall between these two extremes, with CD values around and IoU values near 0.79. These differences at T = 2 cm underscore the trade-offs among the three methods in balancing local geometric detail against overall volumetric preservation.
In the high-error regime (T ∈ (2, 10] cm), the compression methods are allowed to be more aggressive. In this case, while the CD values increase modestly relative to the low-error regime—indicating that fine-scale geometric details are still largely maintained—the Occupancy IoU values vary considerably depending on the method. Methods that aim for maximum compression, such as the EB-HC variants, may experience a dramatic drop in IoU (to roughly 0.31–0.34), suggesting that a significant portion of the volumetric occupancy is lost or merged. In contrast, the extended EB-HC-3D variants tend to achieve intermediate IoU values (around 0.64), and the EB-octree methods—although slightly less aggressive in compression—excel at preserving volumetric fidelity, with IoU values ranging from about 0.77 up to nearly 1.0 at lower BE values, and around 0.84–0.87 at (T = 10) cm.
In summary, our results clearly demonstrate that by allowing a controlled error (quantified either as along individual axes or as in terms of the Euclidean norm), our bounded-error compression methods can dramatically reduce the storage requirements of LiDAR point clouds relative to the lossless Huffman baseline. Under single-bin conditions, when the error threshold is maintained within the sensor’s precision, our methods compress the data to roughly 25–35% of their original size. Multi-bin processing, which exploits temporal redundancies, enables some methods to achieve compression ratios as low as 15–25% of the original volume. Although multi-bin processing requires longer encoding (2.7 to 4.3 s) and (0.6 to 3.5 s), the substantial reduction in data volume represents a significant benefit for applications such as autonomous driving, where both storage and transmission bandwidth are critical. Furthermore, the option to choose between Axis and L2 error metrics provides flexibility, with the L2 mode often yielding a modest gain in fidelity for isotropic point distributions. Importantly, across all methods and error settings, the maximum reconstruction error remains below the prescribed threshold T, ensuring that the geometric fidelity of the point clouds is consistently maintained.
This comprehensive analysis of CR, encoding/decoding times, reconstruction error, Chamfer Distance, and Occupancy IoU, evaluated across both low-error and high-error regimes, provides detailed guidance on the trade-offs inherent in each method. Such insights are essential for selecting an appropriate compression strategy based on the specific requirements for storage efficiency and geometric fidelity in practical applications.
4.4. Cloud-Edge Application Analysis
In a cloud-edge cooperative framework, the efficiency of onboard compression is vital not only for reducing storage and transmission bandwidth but also for meeting real-time processing demands. Our runtime evaluations were conducted on a 13th Gen Intel® Core™ i7-13700K (Intel, Santa Clara, CA, USA) system using single-threaded execution (without GPU acceleration). Under these conditions, even the more sophisticated methods (such as the EB-HC-3D variants) exhibit performance that is encouraging for potential real-time applications.
We provide detailed profiling of compression and decompression runtime on a single-threaded Intel Core i7-13700K system. To illustrate, the lossless Huffman baseline compresses individual bin files in roughly 128 ms on average, while its decompression process takes around 353 ms. In comparison, the bounded-error methods require slightly longer processing times. For single-bin scenarios, the EB-HC method typically records an of approximately 442 ms and a decoding time of about 187 ms, whereas the extended EB-HC-3D approach shows near 525 ms and decoding times around 399 ms. These results illustrate how file size and error threshold affect runtime and demonstrate that parallelization or GPU acceleration can further reduce the computational overhead.
When we extend our experiments to multi-bin processing (where 10 consecutive bin files are handled together), the overall is approximately 4.1 s for the EB-HC method and 3.1 s for the EB-HC-3D method. Although these aggregate times for 10 bins do not directly yield per-bin averages, they indicate that even under more demanding multi-bin scenarios, the processing durations remain within a range that suggests practical feasibility. It should be emphasized that these figures stem from our current, unoptimized, single-threaded implementation. There is significant potential for improvement through further algorithmic enhancements and code optimization, which could further diminish the computational overhead and better align the processing times with the strict real-time requirements of in-vehicle systems.
In conclusion, our current single-threaded implementation demonstrates that for individual bin files varies from approximately 128 ms to 525 ms, while multi-bin experiments yield total on the order of a few seconds. Although these processing times are not yet fully optimized for all real-time applications, the results are promising. With additional refinements and code optimizations, it is anticipated that the computational overhead can be further reduced, thereby meeting the real-time operational requirements essential for autonomous driving systems, where seamless coordination between onboard and cloud-based components is paramount.
Source link
Ray-I Chang www.mdpi.com
