Efficient LiDAR Reflectance Compression via Scanning Serialization

We sincerely appreciate your insightful comments and constructive suggestions. Thank you for recognizing this paper provides substantial guidance for future research with reasonable writing and sufficient experimental evidence. Below, we provide detailed responses in the hope of addressing your concerns.

1. Clearer Comparative Experiments for Downstream Detection Task

1. The visualizations and quantitative results in our manuscript show that simply removing reflectance data (setting values to 0) in pre-trained models leads to significant performance degradation. As suggested, expanded comparisons now include SECOND and PointRCNN (see table below), showing detection accuracies for cars/pedestrians/cyclists at multiple AP levels ("w/o R" = reflectance set to 0).

2. We retrained the detection models from scratch without reflectance. The table below shows the performance of reflectance-ablated (*) models, where performance degradation is reduced but persists (and is non-trivial).

3. To more adequately reflect the role of reflectance, we revised our original wording from "It is crucial in downstream tasks..." to "It is widely used in downstream tasks...". All results will be detailed in the revised manuscript and supplementary.

Finally, we respectfully emphasize that the core contribution of this work lies in the development of a high-performance real-time reflectance compressor. The extensive utilization of reflectance in downstream tasks provides substantial validation for the significance of our work.

2. Lossless Reflectance Compression vs. Quantization-Induced Precision Loss

We respectfully clarify that all comparisons were conducted in lossless mode, consistent with other lossless compression works (such as G-PCC and Unicorn).

Although distinct coordinates may project to identical (u,v) pairs, these pairs only serve as auxiliary priors. The original 3D coordinates are preserved for each point through decoding the geometry bitstream (which aligns with G-PCC’s separate lossless geometry/attribute pipeline). Therefore, even though points may be mapped to the same (u,v) pair, they remain distinct points in 3D space, and we can clearly differentiate them based on their geomtry coordinates.

Below we show an example. Consider two points in a point cloud, $p_1$=(3.12, 8.65, 0.50, 80) and $p_2$=(3.13, 8.63, 0.50, 82), where each point is represented as ($x$, $y$, $z$, $reflectance$). After coordinate transformation (in Eq. 3) and quantization (in Eq. 4), both points are mapped to the same (u,v) pair (712, 58). However, this spatial projection does not compromise the integrity of reflectance values. Specifically:

• The encoder utilizes statistical patterns from the (712, 58) pair to optimize entropy coding for both values (80 and 82).

• The decoder reconstructs reflectance values (80 and 82) by resolving the entropy-coded symbols using the same (u,v)-derived priors and the lossless geometry data.

In short, SerLiC uses (u,v) as contextual priors for entropy coding while retaining raw reflectances. Please refer to the Python-style serialization code in our response to reviewer #Kwag for more details.

3. Additional Explanation on Bit Rate Points and Lossy Compression

Although different quantizations can adjust bitrates in lossless models, this approach differs fundamentally from lossy compression.

We tested the quantization-driven lossy compression (suggested by the reviewer) against G-PCC, with RD curves available in this anonymous website. It is observed that although SerLiC is designed for lossless compression, it remarkably outperforms lossy methods in the high bitrate range. Moreover, SerLiC operates in real-time, much faster than these lossy methods. Extending SerLiC to lossy compression is our future work.

1. Deeper Analysis of SerLiC’s Limitations

We appreciate your insightful observations and are pleased to provide a comprehensive response below.

1.1 Adaptability to Non-Rotational LiDAR Systems.

Non-rotational LiDAR's scanning also follows a specific order, and SerLiC maintains strong compatibility. To validate this, we have conducted additional experiments using the non-rotational InnovizQC dataset from MPEG. The dataset visualization is available in this anonymous website. The compression results presented below demonstrate SerLiC's robust generalizability for non-rotational LiDAR systems.

1.2 Performance Under Highly Variable Point Cloud Densities.

We provide detailed performance across distinct scenarios in the table below. Results show that SerLiC consistently outperforms G-PCC in all scenes. Relatively, SerLiC performs better in City and Campus scenes than in Residential and Road scenes. This occurs due to dense roadside vegetation interfering with sensor-recorded reflectance characteristics and increasing compression difficulty. We will add these results to the supplementary to demonstrate the method's applicability across diverse real-world scenarios.

2. Pseudocode for the Serialization Process

The following Python-style code demonstrates the serialization of LiDAR point clouds. The function takes a point cloud of shape (N, 4) as input and outputs a list of point sequences, where each sequence corresponds to a specific laser emitter and represents an ordered point set scanned by that laser.

def scan_order_serialization(points, L=64, W=1024, pitch_up=3.0, pitch_down=-24.0):
    """
    Params:
        points (torch.Tensor): Input point cloud of shape (N, 4), with columns (x, y, z, reflectance);
        L (int): Number of lasers (vertical resolution);
        W (int): Horizontal resolution;
        pitch_up (float): Maximum elevation angle;
        pitch_down (float): Minimum elevation angle;
    Returns:
        list[torch.Tensor]: List of point sequences. Each sequence corresponds to a laser beam, sorted by horizontal angle.
    """
    # Separate coordinates and reflectance values
    coords, refl = points[:, :3], points[:, 3:4]

    # Coordinate mapping (This step involves using Eq. 3 and 4 
    # from the manuscript to calculate rho, v, and u)
    rho, v, u = coords_mapping(coords, L, W, pitch_up, pitch_down)

    # Concatenate (rho, v, u) as auxiliary data
    points = torch.cat([rho, v, u, coords, refl], axis=-1)

    # Process each laser
    seq_list = []
    for laser_idx in range(1, L+1):
        # Mask to filter points in the current laser
        mask = (v == laser_idx).view(-1)
        seq = points[mask]

        # Sort points by horizontal index (u) to simulate spin order
        spin_order = torch.argsort(u[mask].view(-1))
        seq = seq[spin_order]
        seq_list.append(seq)
    return seq_list

Our serialization approach transforms 3D LiDAR point clouds into 1D sequences for efficient modeling. Our serialization focuses on intra-frame organization, preserving each LiDAR frame's spatial structure losslessly. Temporal order is maintained by the system’s sequential storage/transmission of frames. For example, points from a moving car in frame $t$ retain their spatial layout after serialization; their temporal continuity across frames $t$, $t+1$, etc., is ensured by the ordered bitstream arrangement, unaffected by intra-frame encoding. This decoupling guarantees both spatial fidelity and temporal coherence.

We will open-source our code to ensure transparency and reproducibility for the community.

3. Comparison of Mamba Network and Transformer

Specifically, the autoregressive coding employed in SerLiC is similar to the next token prediction in natural language processing (NLP). Autoregressive models are widely recognized for their exceptional contextual modeling capabilities, but their practical application is constrained by the high complexity. While Attention is also an alternative option for sequential modeling, our findings in Supplementary section C.2 show that Mamba exhibits significantly lower complexity-by several orders of magnitude-compared to attention-based architecture. This conclusion aligns with prior works [1]. Mamba’s linear complexity and dual-parallel strategy enable real-time processing of LiDAR reflectance compression. This is the key reason for our choice of Mamba.

[1] Albert Gu, et al. "Mamba: Linear-Time Sequence Modeling with Selective State Spaces." Arxiv, 2023.

We sincerely appreciate your thoughtful feedback. Thank you for recognizing the highly admirable compression benefit presented in our study and acknowledging its potential to be influential to future researchers and impactful to this field. We highly value this opportunity to address your concerns.

1. Relation Between LiDAR Point Cloud Compression, LiDAR Reflectance Compression, and 3D Perception Task

LiDAR point cloud compression reduces data volume from 3D LiDAR scans, which consist of spatial coordinates (geometry) and reflectance values (attributes), each requiring distinct compression methods:

• LiDAR geometry compression encodes coordinates into a compact bitstream.
• LiDAR reflectance compression is dedicated to optimizing attribute data into another bitstream, using geometry as conditional prior.

The divergent statistical properties of geometric and reflectance data have historically motivated their independent compression solutions. This paper focuses on the LiDAR reflectance compression, significantly improving compression efficiency for reflectance data.

Existing research predominantly advances LiDAR reflectance compression through technical refinements, while overlooking a fundamental systems-level inquiry: "Is reflectance compression necessary, and how does it impact downstream tasks?" We first address this gap through task-driven analysis, as illustrated in the introduction section and supplementary. Our evidence confirms that reflectance data significantly influences perception performance, thereby validating its compression and transmission necessity. Having established this critical premise, we subsequently propose the coding paradigm. Our contribution not only advances compression technology but also formally links reflectance fidelity to perception needs.

2. Logical Relation Between LiDAR Reflectance Compression and Mamba Architecture

We sincerely thank the reviewer for the constructive feedback. We would like to clarify that in the compression domain, efficiency and performance are equally critical considerations. Specifically, the autoregressive coding employed in SerLiC is similar to the next token prediction in natural language processing (NLP). Autoregressive models are widely recognized for their exceptional contextual modeling capabilities [1][2], but their practical application has been constrained by the high computational complexity. While Mamba is not the only option for sequential modeling, our findings in Supplementary section C.2 demonstrate that Mamba exhibits much lower complexity-by several orders of magnitude-compared to attention-based architectures under equivalent layer stacking and channel dimensions. By combining Mamba’s linear complexity with our proposed dual-parallel strategy, SerLiC achieves real-time processing capabilities. This is the key reason for our choice of Mamba.

3. Quantitative Experiments for the Importance of the LiDAR Reflectance

Following the reviewer's suggestion, we have conducted additional experiments using another two classical models (SECOND and PointRCNN), with the experimental results presented in the table below ("w/o R" denotes the performance of the complete removal of reflectance information).

Nonetheless, we respectfully clarify that the core contribution of our work lies in the development of a high-performance real-time reflectance compressor. The extensive utilization of reflectance in downstream tasks provides substantial validation for the significance of our work.

4. Compression Using Serialization Methods in Point Transformer v3

While Point Transformer v3 (PTv3) is designed for perception tasks and its shift-based patch interaction isn’t directly applicable to compression, its serialization method offers an alternative to our scan-order approach. Following the reviewer's suggestion, We conduct experiments in SemanticKITTI. Results show that Hilbert Curve (3.74 Bpp) and Z-order Curve (3.70 Bpp) underperform our scan-order serialization (3.64 Bpp), confirming the efficacy of our method. The detail table is available in this anonymous website.

[1] David Minnen, et al. "Joint Autoregressive and Hierarchical Priors for Learned Image Compression." NeurIPS, 2018.
[2] Chunyang Fu, et al. "OctAttention: Octree-based large-scale contexts model for point cloud compression." AAAI, 2022.