acceptodds
Under review as a conference paper at ICLR 2027

ELiCv2: Real-Time Temporal LiDAR Geometry Compression on Embedded GPUs

Abstract

Improving learned LiDAR compression increasingly relies on heavier inference, making it harder to meet the constraints of real-time embedded systems. We present ELiCv2, which removes two sources of redundant computation in progressive coding. Its discrete entropy interface selects a precomputed integer CDF instead of materializing one from a per-voxel distribution, while its occupancy-driven kernel-map builder derives finer-level sparse-convolution kernel-maps directly from the decoded hierarchy, eliminating coordinate-based neighbor search. ELiCv2 reinvests the recovered computation budget in lightweight ego-motion-aware temporal conditioning that gathers local occupancy context from the aligned previous reconstruction. On four LiDAR datasets and an NVIDIA Jetson Thor, ELiCv2 achieves a mean BD-rate reduction of 30.97% over G-PCC with channel width C=32 while sustaining the 20Hz nuScenes capture rate. Increasing the channel width to C=64 improves the mean reduction to 35.22%. Code will be released upon publication.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
Learned LiDAR Compression, Discrete Entropy Modeling, Sparse Convolution, Temporal Context Modeling

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_qECAOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

ELiCv2 extends ELiC for LiDAR geometry compression on embedded hardware. It combines selection of precomputed CDF tables, hierarchical sparse-convolution kernel-map construction, and temporal conditioning using an ego-motion-aligned reference frame. Experiments on four datasets report improved compression–latency trade-offs.

Critical strengths

The reported deployment gains are useful. On Jetson Thor, C=32C=32 inter encodes and decodes 16-bit nuScenes frames in 34.8 and 40.3 ms, respectively, substantially faster than ELiCv1. Temporal conditioning also improves compression over the corresponding intra models across all four datasets.

Critical weaknesses

The methodological advance over related work is insufficiently established. The entropy interface shares the central design of Learning Switchable Priors, §§III-A–B: jointly learning a finite distribution set and an index predictor, then selecting precomputed CDF tables for entropy coding. That work also includes two-dimensional distribution indexing. ELiCv2 differs in its categorical codebook with row/column parameters and low-rank interactions, and its row/column selector trained with Gumbel–Softmax. However, comparison against per-voxel CDF construction in Table 4 does not establish the benefit of these specific choices over existing learned-table designs.

ELiCv2's kernel-map construction is closely related to the neighborhood lookup procedure in Zhou et al. (2011), §III-C: both use lookup tables to identify the relevant parent neighbor and child octant, deriving child-level neighborhoods from parent-level neighborhoods. ELiCv2 applies this mechanism to sparse-convolution kernel maps. The paper should distinguish this application from the established neighborhood propagation algorithm when stating its contribution.

The overall speedup needs a matched runtime breakdown and end-to-end ablations. At 16 bits, Table 3 shows a mean encoding-time reduction of 84.90 ms from ELiCv1 to ELiCv2 C=32C=32 intra. Tables 4 and 5 report mean savings of 44.23 ms for the entropy interface (arithmetic coding to indexed rANS) and 3.28 ms for kernel-map construction, respectively. These component savings are substantially smaller than the overall reduction. A breakdown on identical test frames and controlled end-to-end ablations are needed to establish where the additional acceleration comes from.

For Ford, the paper uses KISS-ICP to estimate inter-frame transforms but does not state whether this computation is included in encoding latency.

Questions for authors
  1. What substantive advance do the learned categorical codebook and its row/column selector provide beyond established CDF-table selection?
  2. Consider providing a breakdown of encoding and decoding times for ELiCv1 and ELiCv2 C=32C=32 intra. An end-to-end comparison of the proposed and hash-based kernel-map builders, with all other components fixed, would help isolate this optimization's contribution. Please also clarify whether the reported encoding time on Ford includes KISS-ICP pose estimation.
8 comments
AuthorsOpenReview ↗

W1 + Q1 — the distinction from Learning Switchable Priors, and the measured selector ablation

The review states four weaknesses and two questions, and the second question bundles three requests. We number the weaknesses W1–W4 in the order given and answer them across four separately posted comments: this one covers W1 + Q1 (advance over established table selection), a second covers W2 + Q2(b) (Zhou et al., and the end-to-end comparison of the two kernel-map builders), a third W3 + Q2(a) (matched runtime breakdown), and a fourth W4 + Q2(c) (whether Ford's encoding time includes KISS-ICP), closing with a summary.

W1. We thank the reviewer for identifying Learning Switchable Priors as the closest prior work to our entropy interface. The revision cites and discusses it. The reviewer's characterization is accurate, including two-dimensional indexing. We claim neither joint learning of a finite distribution set nor factorized indexing as novel. Our contribution concerns the categorical occupancy model stored in the tables and the context-to-table decision used to select it. The comparison below concerns its selector in Sections III-A and III-B.

Design choiceLearning Switchable PriorsELiCv2
Stored distributionsLearned Gaussian, GGM, or GMM priorsLearned categorical PMFs over 16 occupancy symbols
Context-network outputContinuous index coordinate(s), one per axisCandidate-score vectors, one per axis
Candidate scoresDerived from distance to integer index coordinatesLearned directly for each row/column candidate
Hard selectionClip and round each coordinateArgmax on each score vector

Switchable predicts index coordinates, not per-symbol density parameters, so the distinction is not whether tables are learned, but how the distributions and selection scores are parameterized.

Each coding stage represents four octants by one of 16 occupancy symbols — bit patterns, not ordered magnitudes, whose numerical order defines no natural Gaussian location-scale model. Our entries learn probabilities over occupancy patterns without a prescribed Gaussian, GGM or GMM form — "categorical" does not mean parameter-free. A rounded-coordinate selector could address a categorical codebook: argmax is our design choice, not a necessity of the alphabet. The selector emits two T-way vectors and forms k = T*i + j from their argmax indices, so at T = 32, 64 logits address 1,024 tables rather than a flat 1,024-way output. Bank and selector are both learned with the backbone, training uses Gumbel-Softmax and inference uses hard selection.

Stable selection, not just speed. With a shared integer-CDF bank a single table mismatch desynchronizes the remaining bitstream, so what matters is what each selector's native output must preserve. A rounded coordinate must stay nearer its own bin than any boundary. Our score vectors need only keep the winner on each axis — neither exact logit values nor the full ranking — so a common shift or positive scaling within a head leaves argmax unchanged, and an encoder-side top-two margin greater than 2*epsilon preserves the winner when each decoder logit differs by at most epsilon. Our argument concerns these different output representations and invariances, not a guarantee that argmax is universally more robust or that the codec is platform-independent.

Q1, the measured ablation. It is an ablation of a Switchable-inspired coordinate selector under our categorical-codebook training objective, not a reproduction of Learning Switchable Priors. Three deviations matter and we report all three: we use squared rather than absolute distance to the integer positions, the candidate weights multiply our categorical log-PMFs rather than weighting per-candidate rates as in that paper's Eqs. 2–3, and the per-axis sharpness is a learnable parameter rather than their annealed temperature treatment. Everything else is held fixed — codebook, backbone, data and schedule. nuScenes, C=32 intra, three seeds, each trained to 199,500 steps. Eight identical test frames, means over the three seeds:

varianttraining surrogaterate under hard selectiongap
ours (argmax over per-candidate scores)11.20511.195−0.010
Switchable-inspired coordinate selector11.50146.210+34.709

Its gap is +28.8 to +40.3 across seeds and does not close with training: +18.8 at 12k steps, +34.7 at convergence. On our codebook and objective the training surrogate does not predict the deployed operation for a coordinate selector, and does for ours.

AuthorsOpenReview ↗

W2 + Q2(b) — the distinction from Zhou et al. §III-C, and the two kernel-map builders compared

W2. We agree with the reviewer and will cite Zhou et al. (2011), Section III-C. The parent-neighbor and child-octant lookup relation is established prior work, and our construction uses that geometric relation. We do not claim the neighborhood recurrence or its LUT realization as novel. The contribution we claim is its occupancy-driven realization as a sparse-convolution kernel-map update within progressive entropy decoding.

The distinction we would draw is the availability of the hierarchy. Zhou et al. construct octree neighborhoods on the GPU from an input point set, so the whole tree is in hand and the neighborhood relations at every level can be materialized before the surface reconstruction that consumes them begins. Our decoder has no such input: the finer-level topology exists only in the bitstream and is revealed one level at a time by entropy decoding, so the kernel map for level ℓ+1 cannot be built until the occupancy symbols at level ℓ have been decoded. Topology recovery, kernel-map propagation and entropy decoding are causally interleaved:

K(ℓ) -> neural CDF-index prediction -> entropy-decode occupancy(ℓ)
     -> child support and K(ℓ+1)    -> next prediction

This is a difference of setting, not of capability — the coupling between progressive entropy decoding and kernel-map state does not arise when the hierarchy is given up front, so there was no reason for prior work to build for it. Equally, it is not optional for us, and we are not claiming that neighborhood propagation in general requires a completed octree. Our construction instantiates the recurrence in the codec's active-feature index space: a prefix sum of child counts and the child's occupied-octant rank assign each active child a contiguous index, a parent-map lookup and an occupancy test identify each target child, and the same indexing rule gives its feature-row address, populating the next kernel map in the convolution's offset order with -1 for absent neighbors. Appendix D specifies the indexing and derives equivalence to coordinate-based construction.

Q2(b). We have now run the controlled end-to-end comparison. We substituted torchsparse's coordinate-hashing builder (build_kernel_map, mode='hashmap') for our propagation at every level, on both the encode and the decode side, with nothing else changed. 30 test frames per dataset, posQ = 4, min-of-3, on an A100 — a host GPU, not the Jetson of Table 5, so these absolute times must not be substituted into the Jetson table of Table 3. The swap is exactly controlled and we can show it rather than assert it: the two builders produce identical kernel maps, so the bitstreams are byte-identical in 120 of 120 frames and the decoded voxel sets agree in 120 of 120. The rate is unchanged by construction, so the differences below are the end-to-end effect of swapping the builder.

DatasetVoxelsEncode: ours → hashingΔDecode: ours → hashingΔ
nuScenes29,56418.44 → 20.17+1.7323.72 → 25.53+1.81
SemanticKITTI125,52236.82 → 38.99+2.1845.68 → 47.85+2.16
Ford77,85831.72 → 33.62+1.9038.86 → 41.09+2.23
V2X-Seq56,42428.61 → 30.76+2.1535.81 → 38.16+2.34
Mean+1.99+2.13

We also ran the same swap on Jetson Thor, the platform Table 5 was taken on, with the same controls — the seed map at octree level ℓ=2 is identical in both variants, so only child-level derivation differs, and the bitstreams are byte-identical in 120 of 120 frames there as well. Encode, ms/frame:

Datasetours → hashingΔ
nuScenes43.06 → 45.48+2.42
SemanticKITTI113.04 → 117.30+4.26
Ford85.59 → 89.44+3.85
V2X-Seq76.64 → 80.06+3.42
Mean+3.49

The mechanism returns 1.75× more time on the embedded device than on the host — 3.49 ms against 1.99 ms — on a frame that is itself 2.75× more expensive. Against a fixed real-time budget that is the direction that matters: the absolute saving grows precisely on the device that sits near the deadline, where the A100 has ample headroom. As a fraction of frame time the term is smaller on Thor (4.4% against 6.9%), because the whole frame grows faster than this one stage does. The swap is also not an explanation for the 37.4 ms residual in the published-table arithmetic, which is an order of magnitude larger than anything it moves. And it holds the convolution backend fixed: it measures how the map is derived, not how it is consumed.

AuthorsOpenReview ↗

W3 + Q2(a) — where the speedup comes from

The subtraction is correct, we reproduced it, and part of the answer is in that figure. From our logs at bit depth 16: ELiCv1 149.25 ms, ELiCv2 C=32 intra 64.36 ms, a difference of 84.89 ms — the reviewer's 84.90 ms up to rounding — against 44.23 ms in the submitted Table 4 and 3.28 ms in Table 5, leaving 37.4 ms unaccounted.

Why the three tables cannot sum. Table 5 times only bit depths 3 to leaf−1, excludes bit depth 2 from both columns, and runs the hashing baseline with its ImplicitGEMM bitmask and backward-map bookkeeping disabled — a deliberate lower bound, not an estimate. Table 4 is an ablation within ELiCv2. Neither was designed as a decomposition of the ELiCv1 → ELiCv2 difference.

The two published rows also did not share a measurement boundary, and we have now re-measured on one — encode and decode totals for both codecs, with the stage split reported for encoding. For fairness we aligned the voxelization of ELiCv1 and ELiCv2: it is performed once per frame, outside the timed region, and the identical voxel set is passed to both, so it is neither a confound in the input nor a term in either timer. Both codecs run in one process on Thor, on the same 30 frames per dataset, at the clock Table 3 uses. The timer covers every codec stage after that shared voxelized input — each codec's entropy coder runs inside it, and both emit real bitstreams whose sizes we record as the check that they do. Four-dataset means, bit depth 16, ms:

pyramid / expand Δbackbone + kernel-map Δentropy Δtotal Δspeedup
encode4.4025.2049.33 (62.5%)78.922.07–2.44×

The entropy interface is the largest term across the four datasets — 62.5% of the encode gap, from 47.3% on nuScenes to 70.1% on SemanticKITTI. ELiCv1 spends 23.2–78.7 ms per frame on the entropy stage against our 7.6–12.5 ms when encoding (3.0–6.3×). Decode totals are in Table 3. We do not split them, because the per-stage instrumentation perturbs the decoder by 8.5–16.2% of its own runtime.

Under this boundary the mean encode gap is 78.92 ms against the 84.90 ms the published rows imply. The two figures are not interchangeable — they differ in measured span and frame sample — and we do not apportion the difference, because this profile does not separate those causes. Table 3's bit-depth-16 rows are now reported on the boundary measured here, where the end-to-end encode difference is 79.9 ms. The Δ columns above come from the instrumented run and sum to 1.0 ms less.

The controlled entropy-interface ablation, also on Thor. The submitted Table 4 figures came from an earlier measurement setup, so the times below are not comparable to them. We replace them for attribution with a three-way experiment run under one setup. All three share one cached backbone pass, so only the entropy interface differs: (A) per-voxel continuous PMF with an arithmetic coder, (B) the identical preparation with rANS, isolating the coder, (C) ours, a predicted table index against a static integer CDF bank. Means over four datasets, ms:

Variantprepcodingtotal
A continuous PMF + arithmetic57.9914.1972.18
B continuous PMF + rANS57.296.3863.67
C table index + indexed rANS (ours)2.218.1010.31

The coder alone buys 1.13×, the interface alone 6.18×, both together 7.00×. The reason is the prep column: A → B leaves it untouched (57.99 → 57.29, as it must — the same per-voxel CDFs are built either way) while A → C collapses it to 2.21 ms. A and B differ by 6--7 bytes of output, confirming they code the same distribution with different coders. C's is 1.04% larger, the rate cost of the quantized bank, which the paper reports. No separate continuous head was needed: the model's own mixer composes a per-voxel PMF from the selector logits and the learned PMF tables, and A/B use that composition with deterministic softmax weights instead of top-1 selection.

What these establish. They localize where the time goes under one stated boundary. Isolating what each mechanism is worth is a separate experiment, and the three-way ablation above is that experiment. The kernel-map mechanism sits inside the backbone term and the builder swap we report under Q2(b) bounds it at 3.49 ms here, so that term is not mostly the kernel map. Neural prediction is excluded from all three ablation variants alike, so those are entropy-stage figures.

Reviewer_2jqPOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

Motivated by the challenge of meeting embedded system constraints under high inference costs, this paper proposes a LiDAR compression method that eliminates two sources of redundant computation in progressive coding, thereby freeing up computational resources. It further introduces a lightweight temporal conditioning module that gathers local occupancy context from the previous frame. The effectiveness of the proposed method is demonstrated across multiple LiDAR benchmark datasets and hardware platforms.

Critical strengths

1.The paper identifies two sources of avoidable computational overhead in the entropy-coding and sparse-processing stages of progressive coding. 2.The method replaces per-voxel CDF construction with direct selection of precomputed integer cumulative distribution functions (CDFs), while incorporating a lightweight temporal conditioning module.

Critical weaknesses
  1. The sources of the temporal coding gains require further analysis. In particular, how much do ego-motion alignment and local reference conditioning each contribute? A simple ablation study would help clarify their respective effects.
  2. Comparisons with existing learned inter-frame compression methods are insufficient. Beyond G-PCC inter, a quantitative comparison with recent relevant methods is needed to better assess the proposed method’s performance.
Questions for authors
  1. Do the reported runtimes include pose acquisition or estimation, as well as the associated preprocessing operations?
  2. Since ELiCv2 builds upon ELiCv1, why is the C=64 variant of ELiCv1 omitted from the comparisons? Including this variant would enable a fairer comparison at the same channel width.
6 comments
AuthorsOpenReview ↗

W1. How much do ego-motion alignment and reference conditioning each contribute?

Direct answer: we measured four coding variants on one frame set, so the columns can be differenced. Each mechanism's effect is measurable, but they do not add over a positive baseline, because the inter checkpoint without its reference codes worse than the dedicated intra model.

10 GOPs × 30 frames per dataset, posQ 4, C=32, real bytes over the posQ-1 voxel count, published checkpoints and protocol. The aggregate is over the 290 P-frames only. That matters: the GOP variants code frame 0 with the dedicated intra model, so an all-frames mean would fold an I-frame model swap into every difference. On P-frames the three inter variants all run the same checkpoint, differing only in what reference it is given. The first column is a separate intra model throughout:

Datasetintra modelinter, no referenceinter, identity poseinter, aligned
nuScenes10.49611.69410.2129.675
SemanticKITTI10.79011.14310.81410.472
Ford13.34314.04412.96612.716
V2X-Seq17.13018.12416.81616.816
Datasetreference conditioning (no-ref − aligned)of which alignment (identity − aligned)net gain vs intra (intra − aligned)inter-without-reference vs intra model
nuScenes2.0190.537 (27%)0.821+1.198
SemanticKITTI0.6710.342 (51%)0.318+0.353
Ford1.3280.250 (19%)0.627+0.701
V2X-Seq1.3080.000 (0%)0.314+0.994

The first two columns of the second table are the decomposition requested, and both compare the same checkpoint with and without a given reference. Alignment accounts for 19–51% of what reference conditioning delivers where the sensor moves.

The fourth column is why the two do not add to the net gain: the inter checkpoint run without a reference is worse than the dedicated intra model on all four datasets, so reference conditioning must first cover that gap. We label it a comparison between two checkpoints rather than a "backbone cost", since the two variants differ by training as well as by the reference path and this measurement does not separate those.

V2X-Seq is the control: a stationary roadside sensor whose relative transform is already the identity, so its alignment column is exactly 0.000 — the check that the ablation does what we claim. One cell runs against the trend: on SemanticKITTI a misaligned reference (10.814) is marginally worse than the intra model (10.790), so there the gate needs the alignment to pay for itself.

Limits. These are conditional ablations on a trained model, not an independent causal decomposition — the identity-pose variant is a model trained with alignment then given a misaligned reference, and we did not retrain — so the figures bound each mechanism's value to this model. This does not contradict Appendix F's statement that the gate can suppress uninformative context, which concerns variation within the training distribution rather than this distribution shift.

AuthorsOpenReview ↗

W2. Comparison with learned inter-frame methods

Direct answer: the submission had only G-PCC inter, and we agree that was insufficient. We have now measured Unicorn (TPAMI'25), the one learned LiDAR inter codec with released code that covers our datasets. Two conditions bound every Unicorn number below and we state them first: we trained it for 30 of the authors' 100 epochs, and we used conv blocks at every scale because the transformer configuration exhausts 80 GB. Both handicap it on rate.

Learned LiDAR inter-frame coding is a small field. To our knowledge five works apply:

WorkAvailabilityStatus here
Unicorn (TPAMI'25), dynamic geometryCode released Dec 2025Measured
Inter-LPCM (IEEE TIP 2026)Code releasedNot run — two orders of magnitude slower
MuSCLE (NeurIPS'20)No codeCannot run
Octree Temporal-Spatial Context (VCIP'23)PaywalledCannot compare
BIRD-PCC (ICASSP'23)Range-image representation of the same LiDAR scansNot run — a matched comparison needs a representation conversion step

What the handicaps let us claim is a rate–time trade-off. Frames verified identical by fingerprint, both codecs lossless on round-trip, five posQ values per dataset (Unicorn's protocol), one A100. The two samples differ and we state them separately: rate over 290 P-frames (10 GOPs), latency over 58 P-frames (2 GOPs), the latter run serially.

nuScenesSemanticKITTIFordV2X-SeqAll 20 points
Rate: cells we win5 / 52 / 55 / 55 / 517 / 20
Rate: mean change−9.83%−0.75%−11.71%−23.31%−11.40%
Encode speed-up (58 P-frames)62–87× across all four datasets
Decode speed-up (58 P-frames)53–73× across all four datasets
Decode within budget5 / 5 ours, 0 / 5 Unicorn5 / 5, 0 / 55 / 5, 0 / 55 / 5, 0 / 520 / 20 ours, 0 / 20 Unicorn

Judging real time on the slower direction, decoding, against the per-dataset budget (50 ms for nuScenes at 20 Hz, 100 ms for the other three at 10 Hz), we meet it at all 20 operating points and Unicorn at none, exceeding it by 13–22× even at its fastest, coarsest setting.

Both numbers describe the configuration we measured, and nothing more. Training length does not change inference cost, so the 30 epochs do not affect the latency column. The conv substitution does change the network, and since the transformer configuration did not fit in 80 GB we could not measure it, so we claim nothing about which is faster. The mean −11.40% is the result for this 30-epoch conv configuration, not a converged comparison and not a bound on the authors' configuration. We also lose on SemanticKITTI at the three coarsest settings (posQ 16, 32, 64) by +0.78%, +2.42% and +1.42%.

Inter-LPCM, the closest recent competitor, reports two configurations: the full model at 5.71 s encoding / 86.7 s decoding per frame, and a fast variant that substitutes a general-purpose CABAC at 5.23 s / 5.61 s. Its headline rates are −26.1% against G-PCC lossless octree on SemanticKITTI and −8.3% against PredGeom inter on Ford. We did not run it: even the fast variant is about two orders of magnitude slower per frame than the decode times in our table, so it sits on a different part of the trade-off than the real-time operating points this paper targets.

The revision reports the Unicorn comparison. The remaining four works are surveyed here.

AuthorsOpenReview ↗

Q1. Do the reported runtimes include pose acquisition or estimation?

No. Pose acquisition sits outside the timed region, and the revision states that boundary explicitly. The boundary is the same for all four datasets: SemanticKITTI and nuScenes poses ship with the datasets, V2X-Seq is a stationary roadside sensor whose relative transform is the identity, and Ford's poses are estimated once, offline, and read from a file. Nothing in the per-frame loop estimates a pose. What is inside the timed region, in every measurement we report, is the warp — applying the relative transform to the reference and removing duplicate coordinates. The decoder never estimates a pose either: the quantized relative transform travels in each P-frame header (nine plus three int64).

We have now timed the fully aligned pipeline on Thor, at the clock Table 3 uses, across the whole operating-point sweep and against the identity-pose configuration on the same frames. Ford C=32 inter encoding, ms/frame:

bd16bd15bd14bd13bd12
aligned − identity poses−0.48−0.06−0.44+0.02+0.08

Real poses cost no measurable time end to end. The noise floor is visible in the same run's intra columns, which are pose-independent by construction yet still differ by up to 0.69 ms between the two runs. Every inter Δ above is smaller.

Ford is the only dataset requiring estimation. KISS-ICP registers one Ford frame pair in 13.9 ms on the host, single-threaded (median 12.8, p90 19.3), on a moving segment of Ford_02. Added to the Table 3 figures, Ford still meets its 100 ms budget in both directions at bit depth 15 and coarser — 80.6 ms encode and 91.8 ms decode at bd15, falling to 48.1 and 51.5 at bd12. At bit depth 16 decoding reaches 103.0 ms. The excluded cost is of the order of 14 ms, not of the order of the frame budget.

Q2. Why is the C=64 variant of ELiCv1 omitted?

Direct answer: it was a reporting choice. We have now measured ELiCv1-Large, the paper's C=64 configuration, on the two datasets for which its weights were released — and it is ahead of our C=64 intra model on both.

Availability. The released C=64 configuration is ELiCv1_Large_K5.pt, confirmed as 64 channels from the convolution kernels (27, 64, 64) and 8.04 M parameters against 2.02 M for ELiCv1. Weights exist for SemanticKITTI and Ford, the two target datasets of that paper.

Result. Full test splits, 20,351 SemanticKITTI and 3,000 Ford frames, rates normalized by the posQ=1 voxel count as elsewhere in the paper, bpp:

DatasetConfigurationbd16bd15bd14bd13bd12
SemanticKITTIELiCv1 (published row)10.858.506.324.222.44
ELiCv1-Large10.1147.9305.9424.0072.360
Ours C=64 intra10.308.086.044.072.40
Ours C=64 inter9.957.755.753.842.23
FordELiCv1 (published row)13.3710.868.566.554.61
ELiCv1-Large12.32310.0758.0226.4314.823
Ours C=64 intra12.4410.068.096.444.72
Ours C=64 inter12.159.827.816.144.42

BD-rate against G-PCC intra, computed the same way as Table 2:

ConfigurationSemanticKITTIFord
ELiCv1−26.06%−23.72%
ELiCv1-Large−30.29%−27.12%
Ours C=64 intra−29.09%−27.03%
Ours C=64 inter−32.61%−29.73%

At matched width in intra mode ELiCv1-Large is ahead on both datasets — by 1.20 pp of BD-rate on SemanticKITTI and 0.09 pp on Ford, winning 8 of the 10 individual cells (all five on SemanticKITTI, three of five on Ford). Our C=64 inter model is ahead of ELiCv1-Large on both, by 2.32 and 2.61 pp, and on all 10 cells. Beating ELiCv1 on intra rate at matched capacity is not among our stated contributions, which are to remove two sources of avoidable computation and reinvest the recovered budget in temporal coding. What the recovered budget buys is the inter model, which is ahead at the same width. On latency, at the SemanticKITTI bd16 operating point the paper measures our C=32 inter model at 101.1 ms encoding against ELiCv1's 196.91 ms on the corrected boundary.

Limits. ELiCv1-Large was only ever trained for SemanticKITTI and Ford, the two datasets that paper targeted, so there is no nuScenes or V2X-Seq model to run: the four-dataset matched-width table cannot be completed from existing artifacts and Table 2's mean BD-rate cannot be recomputed at matched width.

Reviewer_jv1jOpenReview ↗
Rating
2(+1)
Confidence
4
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

This work proposes a PCC method for mobile devices, which utilizes PDF classification and kernel-map construction to enhance performance on terminal devices. It has some value for applications, but the overall technical approach is based on numerous existing works.

Critical strengths

Compared with the current research that only focuses on compression performance, this work pays more attention to the efficiency of compression. It can be deployed on mobile devices and has certain engineering value.

Critical weaknesses

However, apart from the engineering value, there are still some deficiencies in the technical approach of this work and some parts of the content in the paper.

  1. The novelty of the CDF classification approach is unclear. Similar ideas have been discussed in prior work, including [1] Zou, Song & Zhang, “The Devil Is in the Details: Window-based Attention for Image Compression,” CVPR 2022, and [2] Said, Pourreza & Le, “Optimized Learned Entropy Coding Parameters for Practical Neural-based Image and Video Compression,” 2023. CompressAI also implements precomputed CDF tables. The authors should clarify what their approach adds beyond these existing techniques.

  2. The kernel-map construction also appears related to previous work, particularly [3] Wang et al., “O-CNN: Octree-based Convolutional Neural Networks for 3D Shape Analysis,” SIGGRAPH 2017, and its associated implementation. The authors should explain the technical differences and identify their specific contribution.

  3. Reporting only aggregate BD-rate values is insufficient to assess the overall compression performance. The average may hide poor performance at some bit depths that is offset by stronger results at others. Please provide the underlying bitrate and distortion values at each bit depth, along with complete rate–distortion curves.

  4. In Table 4, the reported 4.3× and 5.0× speedups apply to the entropy-coding module after the shared network prediction, rather than to the entire codec. Please provide a runtime breakdown covering neural prediction, entropy preparation, data transfer, and entropy encoding and decoding, alongside the overall encoding and decoding times.

  5. The manuscript also needs proofreading. For example, several equation references contain the duplicated wording “Equation equation,” and the notation brefb_{\mathrm{ref}} in Fig. 4(c) is inconsistent with ℓref\ell_{\mathrm{ref}} in the main text.

Questions for authors

See critical weaknesses.

7 comments
AuthorsOpenReview ↗

W1. Novelty of the CDF classification approach

We accept the premise, and we accept that our positioning against prior work on entropy-coding tables was incomplete. Precomputed CDF tables and quantization of entropy-model parameters are established techniques, and we claim neither as new. What we claim is that the established one-dimensional scale-table construction does not directly extend to our categorical occupancy setting, and that the codec and the entropy model had to be designed together to replace it.

The alphabet is fixed by the pipeline. Each voxel's 8-bit occupancy is factorized into two sequential 4-bit symbols, so every coding step is a 16-way classification over occupancy patterns. These are bit patterns, not ordered magnitudes, 5 and 10 denote different occupied subsets, not different amplitudes, so their numerical order supplies no scale axis to discretize.

That removes the axis a scale table depends on. The issue is not that categorical occupancy distributions cannot be parameterized. It is that their nominal alphabet provides no natural one-dimensional scale axis, so the compact scale-table construction used for Gaussian latents does not directly apply. That construction works because mean-centering leaves one free parameter, and discretizing that one parameter yields a finite table set. An occupancy distribution over 16 nominal symbols is not unimodal in the symbol index and does not admit the same one-parameter reduction.

The parametric alternatives then trade against each other, as Zou et al. (CVPR 2022) observe. Their Section 2 notes that for a GMM-based entropy model "the adopted probability distribution function (PDF) and cumulative distribution function (CDF) have to be dynamically generated for every single element in encoding and decoding, thereby introducing much redundancy and making it time-consuming. In contrast, the SGM-based entropy model can build fixed PDF and CDF tables for entropy coding, which is less computationally expensive." Their Section 3.1 accordingly models each latent with a single Gaussian. A single Gaussian preserves a compact scale table but imposes an ordinal and unimodal structure the occupancy symbols do not have. A per-element mixture restores expressivity but reintroduces dynamic CDF construction unless its multidimensional parameters are quantized into a potentially prohibitive table.

Our design avoids that trade. Instead of evaluating a prescribed family at quantized parameters, we learn the categorical distributions themselves together with the selector that chooses one from context. The bank is converted once after training into integer CDFs shared by encoder and decoder, so coding is a table index and the table is fixed, while the stored distributions remain free to be multimodal. The selector emits two T-way score vectors and takes the table index from their argmax, so there is no predicted parameter to quantize. At T = 32, 64 logits address 1,024 tables.

ApproachWhat defines the stored distributions?Selection pipeline
CompressAI's GaussianConditionalGaussian family evaluated at preset scalescontext -> sigma -> scale-table lookup -> k -> CDF[k]
Said et al. (2022)Scale-family CDFs under an optimized reparameterizationcontext -> u -> uniform quantization -> k -> CDF[k]
ELiCv2Categorical PMFs learned jointly with the codeccontext -> row/column scores -> argmax per axis -> k -> CDF[k]

All three code against CDFs that are fixed during coding. The first two fix the family first and learn where to sample it. We learn what to store.

This is why we describe the contribution as a co-design rather than an entropy model dropped into an existing codec. The progressive octree decides the alphabet, 16 nominal symbols per step, and that alphabet removes the natural scale axis on which a one-dimensional quantized scale family relies. The entropy model in turn decides what the codec does at run time, because a fixed bank is what makes the per-voxel work one index rather than a constructed CDF. Neither half is novel in isolation and we do not claim either as such. The claim is the interface between them for progressive occupancy coding.

The revision cites Zou et al. alongside Said et al. and CompressAI, and revises the related work and our contribution statement to separate our interface contribution from established CDF precomputation and parameter quantization.

AuthorsOpenReview ↗

W2. Relation to O-CNN (kernel-map construction)

The revision cites O-CNN and clarifies both the relationship and our specific contribution. O-CNN is relevant prior work on octree convolution, and its public implementation also includes LUT-based parent-to-child neighborhood propagation. We therefore do not claim either octree convolution or LUT-based propagation itself as new. Our contribution is occupancy-driven kernel-map propagation coupled to progressive entropy decoding.

The key distinction is the availability of the octree. In O-CNN-style pipelines the complete octree is given as input, so neighbourhood relations at all levels can be materialised before any convolution begins. In our progressive decoder the finer-level topology exists only in the bitstream and is revealed level by level through entropy decoding, so the kernel map for level b+1 cannot be constructed until the occupancy symbols at level b have been decoded. Our propagation rule is designed for exactly that causal, bitstream-driven schedule: each newly decoded occupancy immediately yields the next kernel map that the subsequent entropy model requires. This is a difference of setting, not of capability. The coupling does not arise in offline octree convolution, so there was no reason for prior work to build for it, and equally it is not optional for us.

ELiCv2 decoder, each map produced inside the decode loop:

bitstream
  -> seed kernel-map K(2) for the coarsest level
  -> for b = 2..leaf:  K(b)               -> neural CDF-index prediction
                       prediction         -> entropy-decode occupancy(b)
                       occupancy(b), K(b) -> child support and K(b+1)
  -> decoded point cloud

The substantive claim is not that the propagation runs at a different time. It is what it produces. From the existing parent kernel map and the newly decoded occupancy alone, we build the child kernel map in the compact active-feature index space that sparse convolution consumes directly. Fixed octant-offset LUTs identify the neighboring parent and target child octant, occupancy-bit tests decide whether that child exists, and prefix sums and popcount give its contiguous active-feature index. The result is an input-feature index per (output voxel, kernel offset), with -1 for absent neighbors, the gather map itself. This is the construction Appendix D of the submission sets out ("Kernel-Map Reuse Derivation and Example"): the child index decomposition, the two offset lookup tables, the fill rule, and a worked example for one parent and its children.

The difference from O-CNN's released propagation is what each map is addressed by. O-CNN's neighbour array is addressed by parent block and octant slot: when a parent is split, all eight of its children are given a slot whether or not they exist. A convolution therefore cannot read feature rows straight out of that array, it first translates a voxel and kernel offset into a slot, looks that slot up to find the neighbour, and assembles the gathered values into a column buffer before the matrix multiply (octree_nn.cu::octree2col_kernel). Ours is addressed by the voxel itself. Each occupied voxel owns one row with one entry per kernel offset, holding the index of the feature row to read, or -1 where that neighbour does not exist. The convolution reads out[n] = sum_k feats[out_in_map[n,k]] * kernel[k] directly, with no translation step and no column buffer. O-CNN's array is the material from which gathers are derived. Ours is the gather itself. O-CNN's non-empty mode compacts the feature array, but the neighbour array stays in the padded space (ichild and child in octree2colP_kernel). For us the compacted layout is not a preference: the entropy coder emits exactly the occupied voxels, and nothing else exists to index, so there is no padded space to build in.

This is checkable rather than asserted. In a controlled builder swap we ran for this response, the maps our propagation produces are element-wise identical to the out_in_map that TorchSparse's coordinate-hashing builder returns, on every level of every frame. Table 5 measures this rule against the coordinate-hashing builder our codec would otherwise use (TorchSparse), and we name that baseline so the measurement is not misread as a comparison against O-CNN. Appendix D also derives the equivalence of this construction to coordinate-based connectivity under the same indexing convention. The contribution statement and the related work have been revised to make this scope explicit.

AuthorsOpenReview ↗

W3. Per-bit-depth values and rate-distortion curves

The complete data is now in the revised manuscript: Appendix K Tables 20--23 give rate and distortion at every bit depth for all 10 configurations on all four datasets, and Appendix K Figure 6 gives the corresponding rate-distortion curves. Appendix J Table 19 summarizes the mean rate reduction at each bit depth. That is 10 configurations x 4 datasets x 5 bit depths = 200 rate cells plus D1-PSNR. Recomputing Bjontegaard BD-rate from those values, a cubic fit of log-rate against D1-PSNR, reproduces all 36 published cells to within 0.01 percentage points. Two dataset blocks are printed here.

Table R1. Rate-distortion, excerpt of Appendix K Tables 20 and 22

The distortion row is D1-PSNR in dB. All remaining rows are rates in bpp, normalized by the posQ=1 voxel count. Bit depth b uses voxel edge 2^(18-b) mm. Test splits contain 52,423 nuScenes, 20,351 SemanticKITTI, 3,000 Ford, and 4,862 V2X-Seq frames. Ford is the equal-weight mean of two 1,500-frame sequences. TopNet* uses a 600-frame sample of each split, all other rate rows use the complete splits. Ford uses a 30,000 mm PSNR peak and the others 59.7 m, so absolute PSNR must not be compared across datasets.

nuScenes

Method / distortionbd16bd15bd14bd13bd12
D1-PSNR (dB)93.7788.1382.2276.2370.20
G-PCC (intra)16.0813.1010.307.525.34
G-PCC (inter)14.9311.959.206.574.48
TopNet*10.938.426.314.573.17
RENO12.8110.027.695.684.00
AnyPcc10.287.855.934.353.07
ELiCv110.968.586.584.873.46
Ours C=32 intra10.888.536.564.893.48
Ours C=32 inter9.987.675.774.192.86
Ours C=64 intra10.007.795.984.483.27
Ours C=64 inter9.106.945.213.822.69

Ford

Method / distortionbd16bd15bd14bd13bd12
D1-PSNR (dB)87.7982.1476.2170.2364.24
G-PCC (intra)17.0614.1611.368.655.96
G-PCC (inter)16.5313.6410.858.165.50
TopNet*12.9210.357.965.823.85
RENO15.4512.589.767.144.73
AnyPcc13.3710.578.085.964.02
ELiCv113.3710.868.566.554.61
Ours C=32 intra13.5510.988.646.514.47
Ours C=32 inter13.0910.608.246.124.11
Ours C=64 intra12.4410.068.096.444.72
Ours C=64 inter12.159.827.816.144.42

Table R2. Rate reduction against G-PCC intra (%)

Equal-weight mean over four datasets. Negative is better. Spread is the maximum minus minimum across bit depths, in percentage points. These are plain rate reductions, not BD-rate, which remains the primary metric.

Methodbd16bd15bd14bd13bd12spread
TopNet*-24.67-27.48-30.16-31.75-33.218.54 pp
RENO-13.12-15.25-17.34-18.73-19.456.32 pp
AnyPcc-27.23-30.74-33.67-35.01-35.197.96 pp
ELiCv1-24.89-26.97-28.47-28.30-26.813.58 pp
Ours C=32 intra-24.13-26.09-27.37-27.36-26.643.24 pp
Ours C=32 inter-27.06-29.39-31.42-32.43-33.186.12 pp
Ours C=64 intra-29.76-31.82-32.69-31.47-28.634.07 pp
Ours C=64 inter-32.36-34.80-36.27-35.83-34.313.91 pp

On the curves. Every evaluated codec codes the quantized grid losslessly, so at a given bit depth on a given frame all methods reconstruct the same voxel set and only rate differs. The D1-PSNR row is the full-split mean describing the nine configurations evaluated on it.

What the tables disclose, including where we trail. The relative ordering does change with bit depth. On nuScenes our C=32 intra model leads ELiCv1 at bit depths 16-14 and trails at 13 and 12. On the aggregate question, C=32 inter improves monotonically as the grid coarsens (-27.06% to -33.18%), while C=64 inter is not monotonic, peaking at -36.27% at bit depth 14 and easing to -34.31%. Neither collapses anywhere, and neither aggregate rests on one operating point. Against AnyPcc our C=64 inter model is behind in 7 of 20 cells, all at coarse bit depths and never on nuScenes: SemanticKITTI bd14 (+0.3%), and at bd13/bd12 SemanticKITTI (+1.3%, +1.8%), Ford (+3.0%, +10.0%) and V2X-Seq (+1.2%, +4.1%). Ford at coarse bit depth is also where our own extra capacity stops paying, C=64 inter trails C=32 inter there (4.42 vs 4.11 bpp at bd12).

Comments on the paper

1 comment
AuthorsOpenReview ↗

Global response to all reviewers

We thank the three reviewers for their detailed and actionable feedback. A common request was for matched measurements using the same frames, platform, and timing boundaries. We therefore conducted new controlled measurements rather than relying on previously reported values. A revised manuscript is uploaded with this response, with substantive additions and revisions marked in blue. Its table numbering matches the submitted paper's.

The new runtime measurements were made on NVIDIA Jetson Thor, the deployment target, at the clock the submitted Table 3 uses (120 W, CPU 2,601 / GPU 1,386 MHz pinned), 30 frames per dataset on all four, min-of-three. Training ablations, rate–distortion evaluations and the A100 runs follow the protocols stated beside them in the individual replies.

Why numbers differ

Reviewer qECA observed that Tables 3, 4 and 5 do not add up. They do not, and one span is the reason: the published ELiCv1 row timed voxelization inside it while the ELiCv2 row did not. We re-measured both codecs with that boundary made the same, and the published ELiCv2 timings reproduce to within 1.2%.

bd16, per datasetsubmittedone boundary
ELiCv1 → ELiCv2 intra encode speedup2.47× implied2.07–2.44×confirmed
decode speedupnot reported1.83–2.12×new
entropy interface, share of the encode gapnot isolated62.5%new
entropy stage, ELiCv1 : ELiCv2, encodenot isolated3.0–6.3×new

Correcting the boundary moves the nuScenes ratio from 2.47× to 2.32×, a 6% change, so the speedup the submitted tables imply stands. What the re-measurement adds is not a different ratio but an attribution: the entropy interface accounts for about two-thirds of the encode gap, localized by measurement rather than inferred from a total. We give decode totals but no decode stage split -- the per-stage instrumentation perturbs the decoder by 8.5--16.2% of its own runtime, which is too much to decompose it. The voxelization of ELiCv1 and ELiCv2 was aligned throughout: performed once per frame, outside the timed region, with the identical voxel set passed to both.

What was measured

Matched ELiCv1-vs-ELiCv2 encode and decode totals with an encoding-stage decomposition, both codecs in one process, the timer covering every stage after the shared voxelized input — each entropy coder runs inside it and both emit real bitstreams. A controlled entropy-interface ablation: the coder alone buys 1.13×, the interface alone 6.18×, both together 7.00×, as preparation falls from 57.99 ms to 2.21 ms. A controlled kernel-map builder swap, worth +1.99 ms encode on an A100 and +3.49 ms on Thor, reported only after both builders emitted byte-identical bitstreams in 120 of 120 frames. Aligned-pose end-to-end timing across the full operating-point sweep: real poses cost no measurable time, every difference below the run-to-run noise floor in the same tables. A three-seed selector ablation trained for 199,500 steps — in which our training surrogate predicts our deployed rate to within 0.012 bpp on every seed, while a coordinate-rounding selector on the same codebook leaves a gap of +34.7 bpp that does not close with training. And three additions: per-bit-depth rate and distortion, a learned inter-frame baseline (Unicorn), and ELiCv1 at matched width — the last two run, not cited.

What we concede

Zou et al. (CVPR 2022) is apt and our positioning was incomplete — their §2 motivates fixed CDF tables for a single-Gaussian entropy model against per-element construction, the same contrast our Table 4 draws. Fixed CDF tables are established prior art and we do not claim CDF precomputation as new, though that construction needs a one-parameter family, which occupancy PMFs are not. What we claim is the jointly learned categorical occupancy bank and its context-conditioned selection. We likewise do not claim the neighbourhood recurrence or its LUT realization as new (Zhou et al. §III-C, and O-CNN's released implementation propagates), only its occupancy-driven realization in the compact index space a sparse convolution consumes, inside progressive decoding. And the submitted Table 4's 4.3× / 5.0× concerned the entropy-processing stage after shared neural prediction, not the complete codec. The revision removes those figures and replaces them with the controlled entropy-stage comparison.

Every figure in the replies carries its conditions — dataset, frame count, operating point, repetitions and device. We will release the code upon publication, and are glad to run further measurements during discussion.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.