BitRIC: Efficient Neural Compression of LiDAR Range Images via Hierarchical Bitplanes

Conference: ECCV2026
Paper: Official Page · PDF
Area: Autonomous Driving / LiDAR Data Compression
Keywords: Range images, hierarchical bitplanes, entropy coding, probability estimation, residual refinement

TL;DR

BitRIC decomposes integer range images into binary planes ordered from most to least significant, entropy-codes them using shared context and three-stage probability estimation, and compensates for truncated low bits through one-step residual refinement, achieving D1 BD-BR of −61.73% against JPEG2000 and lossless coding at 6.05 Bpp on WOD while retaining strong downstream detection accuracy.

Background & Motivation

Native LiDAR measurements need not be unordered point sets: scanning angles provide row and column indices, and each grid location stores the radial distance along a laser beam. Conventional point-cloud compression first projects range images into three dimensions and then organizes points using octrees or sparse structures, adding representation and computation costs. Some methods subsequently project points back into spherical coordinates, creating a range-to-point-to-range round trip. Preserving the regular sensor grid allows standard two-dimensional operations, but ordinary image codecs are not tailored to nonuniform range distributions and sharp depth discontinuities at object boundaries.

Existing neural range-image codecs make different compromises. VAE-based methods offer good throughput but can lose fine geometry; pixel-wise autoregression and recurrent residual prediction improve compression but impose long decoding sequences; implicit neural representations require fitting a network for each frame, making encoding expensive. This paper changes the prediction unit: instead of predicting an entire distance value at once or scanning every pixel sequentially, it first establishes the high bits and progressively codes the remaining information.

The recovered high bits can therefore tell an entropy model what the next bit probably is, while also telling a reconstruction module what omitted low bits might contribute. Core idea: use hierarchical bitplanes to build progressively recoverable geometric context, assign exact transmission to probability estimation, and assign approximate recovery after truncation to one-step residual refinement, supporting lossy and lossless compression within one framework.

Method

Overall Architecture

The input is a preprocessed nonnegative integer range image; the outputs are a compressed bitstream and the reconstructed range image at the receiver. Conversion into a point cloud for detection comes afterward. Hierarchical bitplanes separate each distance into binary significance levels, the shared contextual backbone reads the partial reconstruction, and three-stage probability estimation, or PEM, drives arithmetic coding. Lossless mode transmits every plane; lossy mode transmits only a prefix and invokes one-step residual refinement, or ORM, to predict the continuous residual contributed by the omitted suffix.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    Input["Integer range image"] --> Planes["Hierarchical bitplanes"]
    Planes --> Backbone["Shared contextual<br/>backbone"]
    Backbone --> PEM["Three-stage probability<br/>estimation: PEM"]
    PEM --> Stream["Arithmetic encoding and decoding<br/>Recover transmitted planes"]
    Stream -->|Transmit the next plane| Backbone
    Stream -->|Lossy truncation| ORM["One-step residual<br/>refinement: ORM"]
    Backbone -->|Shared features| ORM
    Stream -->|All planes received| Output["Reconstructed range image"]
    ORM --> Output

Here, losslessness refers to the integer range image entering the codec, not automatically to every original measurement or an arbitrary point-cloud processing chain. Range clipping, millimeter quantization, and the SemanticKITTI projection into pseudo range images happen before coding. Recovering three-dimensional coordinates also requires calibration and motion information. The paper regards auxiliary metadata as small, but that does not mean it need not be transmitted or shared.

Key Designs

1. Hierarchical bitplanes: replace large-valued prediction with binary problems ordered by precision

Let the original image be \(I_N\), with each pixel represented by an \(N\)-bit integer. \(X_1\) is the most significant plane and \(X_N\) the least significant. High bits contribute larger changes to distance, while low bits supply finer numerical precision and may contain sensor noise. This hierarchy is primarily one of numerical significance, not a guarantee that each plane corresponds to a separate spatial frequency band. Invalid returns are represented as zeros in the input, and exact recovery of every bitplane also recovers those zeros exactly.

Equation (1) is damaged in the cached text. The following restatement uses the binary-digit definition and explicitly includes the modulo operation needed to produce binary values; it expands the definition rather than introducing another learned component:

\[ X_n(i,j)=\left\lfloor\frac{I_N(i,j)}{2^{N-n}}\right\rfloor\bmod 2, \qquad I_N(i,j)=\sum_{n=1}^{N}X_n(i,j)2^{N-n}. \]

The recovered prefix can be combined with its original weights into a partial range image \(I_{n-1}\). This representation preserves all preceding bits, so the model does not have to stack the historical planes explicitly. An encoder and decoder holding the same partial reconstruction can compute consistent probabilities for the next plane. The paper's cross-plane factorization is:

\[ p(X_1,\ldots,X_N)=p(X_1)\prod_{n=2}^{N}p(X_n\mid I_{n-1}), \qquad I_{n-1}=\sum_{k=1}^{n-1}X_k2^{N-k}. \]

This remains an autoregressive model, but its main sequential dependency runs along bit depth rather than making every image pixel wait in sequence. The first plane still needs a coding prior; the main paper does not specify its implementation, so it should not be assumed to be free or to use a fixed uniform distribution.

2. Shared contextual backbone: turn range values, scan positions, and horizontal neighborhoods into reusable geometric priors

The partial reconstruction first passes through a learned lookup table that maps discrete range values into continuous features. Row and column embeddings are repeated to the appropriate spatial dimensions and concatenated with these features, allowing the model to learn scan-dependent statistics. Lower beams, for example, more often encounter nearby ground, a positional cue that range values alone may not capture. The cached text is inconsistent about azimuth/elevation symbols and tensor-axis names, so this note describes the verified row/column mechanism without fixing a questionable axis assignment.

Because range images are much wider than they are tall, the Horizontal Spatial-to-Channel Module, HSCM, folds adjacent \(1\times r\) locations into channels and aggregates them with a \(1\times1\) convolution and ReLU6. The default is \(r=4\): reducing spatial width makes subsequent convolutions cheaper, while the rearrangement itself does not discard three locations as ordinary subsampling would. The subsequent channel compression is learned, however, so the entire module should not be described as information-preserving. The narrowed features enter a U-Net with skip connections, and its output is concatenated with its input to form context shared by PEM and ORM. This supplies both local boundaries and broader spatial structure rather than just coarse depth values.

3. Three-stage probability estimation: exchange a few sequential steps for within-plane correlation

Predicting every pixel of a plane solely from earlier planes misses dependencies within the current plane, whereas updating probabilities one pixel at a time sacrifices throughput. PEM compromises through horizontal groups: it predicts group 1 first, uses its known symbols to predict group 3, then combines groups 1 and 3 to predict groups 2 and 4 together. Each step produces a map of Bernoulli probabilities that the target symbol is 1. Arithmetic coding compresses the actual symbols under these probabilities; predictions are not substituted for the symbols themselves.

Training and encoding can access the true preceding-group symbols, while decoding must use the corresponding symbols already recovered from the bitstream. These conditions must match to avoid probability inconsistencies. The main text mistakenly calls groups 2 and 4 the remaining odd columns; this note follows their group indices and treats them as even positions. Three stages refers to group prediction within each target plane, not three neural-network calls for an entire scan: the process still advances through the bitplanes.

4. One-step residual refinement: regress the omitted numerical suffix instead of predicting every low bit

Lossy mode uses \(M<N\) to transmit only the highest \(M\) planes, excluding the remaining bits from the stream. ORM treats their weighted sum as a residual target, normalizes it to \([0,1]\), and regresses it from shared features using convolutional layers. At the receiver, the prediction is denormalized to the original integer scale and used to refine the coarse reconstruction. Unlike generating the low planes individually, this module is called only once at the stopping level; the paper reports an average extra decoding cost of 2 ms.

This cannot recover the true values of information that was never transmitted: it exploits statistical regularities and therefore belongs only to the lossy path. Its benefit is that the same transmitted prefix can reconstruct vehicle contours and fine structure more accurately than zero-filling, without spending bandwidth on every low bit. The main paper delegates exact residual normalization, network configuration, and decoding details to supplementary material that is not present in this cache. Consequently, this note does not invent a scaling denominator, rounding rule, or invalid-pixel handling policy for lossy reconstruction.

A Worked Example

This is an arithmetic illustration of the bitplane mechanism, not a reported test sample. Suppose a pixel uses 8 bits and has value 173, represented as 10101101. Transmitting only the first 4 bits, 1010, and merging them with their original positional weights yields a coarse value of 160 and an omitted numerical residual of 13.

When coding these high bits, PEM considers the partial range image and previously recovered column groups rather than treating the pixel in isolation. Transmitting all 8 bits recovers 173 exactly. Stopping after 4 bits instead asks ORM to estimate a residual from spatial context and refine 160. The true residual is 13, but there is no basis for claiming that the network necessarily predicts 13. The example also separates two roles: omitting low bits changes recoverable precision, while probability modeling changes how many bits are required to convey the selected planes.

Loss & Training

Training jointly minimizes cross-entropy rate across bitplanes and mean squared error for normalized residuals. The following writes the main paper's rate term using the conditional models described above: \(p_n\) includes the applicable context, with a prior for the first plane.

\[ \mathcal L=R+D, \qquad R=\sum_{n=1}^{N}\mathbb E[-\log_2 p_n(X_n)], \qquad D=\sum_{n=1}^{N}\operatorname{MSE}(X_n^{\mathrm{res}},\hat X_n^{\mathrm{res}}). \]

The paper omits a conventional rate-distortion weight \(\lambda\) and instead controls operating rate and precision through the transmitted plane count \(M\). Training distortion is range-residual MSE, whereas evaluation measures D1, D2, and CD in three-dimensional point-cloud space. Detection labels are not used to train the compressor.

The implementation uses Python 3.10, PyTorch 2.1, and Adam for 70,000 steps, with an initial learning rate of \(5\times10^{-4}\) and batch size 1. Below 1 Bpp, the rate-distortion experiments also horizontally downsample the input by factors of 2 or 4. This input downsampling differs from HSCM's internal feature folding and should not be confused with the same information-preserving rearrangement.

Key Experimental Results

Main Results

WOD uses 798 training sequences and 202 validation sequences. Its native range images have resolution \(64\times2650\); only first returns are used, clipped to a maximum of 75 m and quantized to 1 mm. SemanticKITTI uses sequences 00–10 for the training/validation split, reserving 08 for validation. Point clouds are projected into \(64\times2048\) pseudo range images, clipped to 70 m, and likewise quantized to 1 mm.

Rate is measured in bits per point, Bpp. D1 PSNR measures point-to-point error, D2 PSNR measures point-to-plane error, and higher is better for both. CD denotes Chamfer distance between point sets, with lower being better and meters used in the figures. The paper fixes the PSNR peak value at 59.70. In the following selection from Table 1, the D1/D2 columns are BD-BR percentages against JPEG2000, not PSNR: negative values indicate average rate savings at comparable quality.

Method	WOD D1 BD-BR	WOD D2 BD-BR	WOD Lossless Bpp	SemanticKITTI D1 BD-BR	SemanticKITTI D2 BD-BR	SemanticKITTI Lossless Bpp
JPEG2000	0.00%	0.00%	13.44	0.00%	0.00%	16.16
G-PCC	−44.90%	−44.74%	21.48	−59.32%	−58.79%	20.84
RENO	−47.30%	−47.14%	19.42	−61.12%	−60.61%	18.73
RPCC	−39.79%	−39.78%	N/A	−47.65%	−47.75%	N/A
BitRIC	−61.73%	−61.52%	6.05	−69.92%	−70.82%	8.43

The paper reports lossless savings against JPEG2000 of 54.99% and 47.83%, respectively. The displayed Bpp values are rounded, so recomputing percentages from them can produce small rounding differences. G-PCC and RENO take point clouds, while the other methods use range images; their lossless targets and representation costs are not identical. These Bpp values should not be interpreted as compression ratios for the same original byte stream.

In Table 2, BitRIC takes 0.071/0.087 s per frame for lossy encoding/decoding and 0.144/0.175 s for lossless encoding/decoding. The workstation has a Xeon Platinum 8352V and an RTX 4090, and lossy runtimes are averaged across tested rate-distortion points. The paper's throughput above 10 fps applies to individual stages. Serial encoding followed by decoding for the same frame sums to 0.158 s before communication and projection, so an end-to-end latency below 0.1 s is not established.

For CenterPoint detection on WOD at approximately 2 Bpp, pedestrian Level 1 category AP is 65.67, versus 67.77 for raw data and 58.95 for RPCC. BitRIC trails raw data by 2.10 percentage points and exceeds RPCC by 6.72 points. Although the main text calls this value mAP, Figure 6 presents pedestrian category AP; it should not be described as the overall mean across three categories.

Ablation Study

All results below use WOD, with JPEG2000 still serving as the BD-BR anchor. Table 3 reports parameters and FLOPs for the per-bitplane computation configuration, not the total work required to traverse every plane in a frame.

Contextual Backbone Configuration	D1 BD-BR	D2 BD-BR	Parameters	FLOPs
Without range embedding	−16.26%	−21.03%	1.76M	27.78G
Without positional embedding	−60.37%	−60.21%	4.42M	27.78G
Without horizontal folding	−61.43%	−61.33%	5.93M	144.55G
Without U-Net aggregation	−45.06%	−46.39%	2.92M	9.90G
Full backbone	−61.73%	−61.52%	4.42M	27.78G

Table 5 examines how many probability-estimation stages are needed within a bitplane:

PEM Stages	D1 BD-BR	D2 BD-BR	Parameters	FLOPs
1	−24.27%	−25.12%	4.26M	21.55G
2	−50.25%	−50.33%	4.34M	24.66G
3	−61.73%	−61.52%	4.42M	27.78G
4	−61.90%	−61.68%	4.52M	31.64G

ORM evidence comes from specific samples in Figure 7 rather than validation-set averages. At the same 2.528 Bpp, adding ORM raises D1 PSNR from 68.96 to 71.58 dB and reduces CD from 0.062 to 0.042 m. At 0.916 Bpp, D1 rises from 55.19 to 57.52 dB and CD falls from 0.249 to 0.145 m. These examples support terminal residual refinement under an unchanged bitstream, but their gains should not be presented as dataset-wide averages.

Key Findings

• Range embedding supplies the essential information: removing it reduces D1 BD-BR savings from 61.73% to 16.26%. Position alone cannot replace the recovered range context.
• Horizontal folding primarily addresses computation: without it, cost is 144.55G rather than 27.78G, while rate-distortion performance remains similar. Table 4 reports D1 BD-BR of −54.83% at \(r=8\), showing that further width reduction is not free.
• Three stages is an evidence-based choice: moving from 1 to 3 stages helps substantially, but moving from 3 to 4 improves D1 by only another 0.17 percentage points while increasing FLOPs from 27.78G to 31.64G.
• A WOD-trained model evaluated zero-shot on SemanticKITTI achieves D1 BD-BR of −56.93%, compared with −69.92% for in-domain training. This supports some cross-dataset transfer but leaves a clear domain gap. The zero-shot paragraph omits the minus sign on its in-domain reference; this note follows Table 1.

Highlights & Insights

• Exact transmission and approximate recovery share context but have different responsibilities. Errors in PEM's probabilities increase coding length without directly changing correctly decoded symbols; ORM prediction errors affect distortion. This distinction explains how one model can serve both lossless and lossy modes.
• Parallelism comes from rearranging dependencies, not eliminating them. Cross-plane ordering retains precision hierarchy, three within-plane groups retain neighboring information, and other positions can remain parallel. The idea may transfer to other integer sensor data, but their bit statistics and spatial structure need separate validation.
• Native sampling geometry can determine network structure. Horizontal folding works here because rotating LiDAR samples much more densely horizontally than vertically, not because it is a universally superior downsampling trick. Sensors with different scan patterns should not inherit the same folding direction without testing.

Limitations & Future Work

• Author-acknowledged weakness at low rates. Below 1 Bpp, BitRIC is less competitive than voxel approaches such as G-PCC and RENO. Octree spatial partitioning naturally reduces point counts, whereas this method also relies on additional input downsampling to help reach that regime.
• Author-acknowledged lossless latency. Lossless decoding at 0.175 s per frame does not reach 10 Hz, and desktop RTX 4090 measurements do not establish embedded automotive performance. Quantization and temporal redundancy are proposed future directions, not implemented capabilities.
• Reproducibility boundary identified in this note. The cache contains the main paper without supplementary architecture and residual-decoding specifications, and no code link is confirmed. The main text does not fully specify the first-plane prior, handling of widths not divisible by the folding ratio, or adaptation of positional embeddings across resolutions.
• Evaluation boundary identified in this note. The demonstrated downstream task is WOD CenterPoint detection, not tracking, segmentation, extreme-weather perception, or higher-frequency scanning. Full joint-rate analysis for multiple returns, intensity, and auxiliary metadata is also absent.
• Directions worth testing. Target-preserving input downsampling, temporal probability context, and hardware-friendly entropy decoding are plausible extensions. They should be evaluated with rate, reconstruction quality, and full-pipeline latency together, not just neural-network FLOPs.

Related Work & Insights

• Versus JPEG2000, RPCC, and RCPCC: JPEG2000 is a general image codec, while the latter methods exploit specialized geometric rules for range images. BitRIC instead learns conditional bitplane probabilities. Its advantage concerns rate and geometry in medium-to-high-fidelity regimes, not universally faster execution than traditional codecs on every platform.
• Versus RIDDLE and recurrent residual models: Those approaches use pixel-wise or recurrent prediction; BitRIC organizes sequential work across bitplanes and a small number of column groups. This provides a more parallel-friendly dependency structure, but the main results table does not contain a direct numerical comparison with RIDDLE.
• Versus G-PCC and RENO: They model three-dimensional point-cloud structure and benefit from spatial simplification at low rates; BitRIC exploits the native range grid more directly. The appropriate representation depends on how data originates and how much geometry the application must preserve.
• Versus implicit representations such as NERi: Fitting and transmitting network parameters per frame has a different encoding-cost structure from directly predicting probability maps. For a continuous LiDAR stream, whether encoding requires per-frame optimization can matter as much as coding efficiency.

Rating

• Novelty: 4/5. Bitplanes, entropy models, and U-Nets are established components, but their integration with three-stage probability estimation and one-step refinement is well tailored to range images.
• Experimental Thoroughness: 4/5. Two datasets, lossy/lossless coding, detection, complexity, module ablations, and zero-shot transfer are covered, but embedded end-to-end evaluation is missing.
• Writing Quality: 4/5. The main argument and ablations are clear; axis names, odd/even wording, and metric naming require care, while important implementation details rely on supplementary material.
• Value: 4/5. The method has practical potential for medium-to-high-fidelity LiDAR streams, with explicit limits at extreme low rates and real-time lossless deployment.