LiFlow: Flow Matching for 3D LiDAR Scene Completion¶

Conference: ECCV2026
Authors: Andrea Matteazzi, Dietmar Tutsch
Paper: ECCV Paper
Code: https://github.com/matteandre/LiFlow
Area: Autonomous Driving
Keywords: LiDAR, scene completion, flow matching, nearest neighbor correspondence, Chamfer distance

TL;DR¶

LiFlow transports a locally perturbed single LiDAR scan toward a complete scene, using nearest neighbor flow matching for motion supervision and Chamfer distance matching for coverage, achieving low geometric error with few integration steps while remaining weaker on fine-grained occupancy.

Background & Motivation¶

An automotive LiDAR sensor only observes surfaces reached by its beams; duplicating measured points cannot recover occluded structures or sparsely sampled distant regions. Scene completion is therefore more than point cloud densification: the model must increase the point count and infer geometry that the original scan does not sufficiently observe. Voxel methods are limited by their output grid resolution, whereas point-level generation can directly change three-dimensional coordinates and retain finer surface structure. LiDiff and LiDPM already apply diffusion models at scene scale, but generating an entire outdoor scene from global Gaussian noise is difficult.

To retain spatial structure, LiDiff locally perturbs complete scenes during training, while LiDPM starts reverse generation at an intermediate diffusion time. Their training starting states still depend on complete scenes, however, whereas deployment only provides an incomplete scan and requires a surrogate starting state. This is not occasional missing conditioning information: the initial point cloud distributions differ between training and inference. Replacing the solver with a faster one cannot remove that mismatch; the model can still start moving points from spatial arrangements poorly represented during training.

Flow matching can connect a data-dependent source distribution directly to a target distribution without requiring scene-independent Gaussian noise as the source. However, a scan and a complete scene are unordered point sets, so subtracting their arrays does not establish meaningful motion: each source point first needs a destination. LiFlow uses nearest neighbors to provide learnable local directions and set-level coverage supervision to reduce the tendency of multiple sources to converge on the same target. Core Idea: construct the training starting state from the scan genuinely available at deployment, and address both initial-distribution consistency and point correspondence within flow matching instead of approximating the starting state at inference time.

Method¶

Overall Architecture¶

The input is a single scan \(P\), and the output is a completed point cloud, not semantic classes, detection boxes, or class-labeled occupancy voxels. Training additionally requires the corresponding complete scene \(G\), constructed by pose-aligning multiple scans and removing moving objects to obtain a supervision map. The pipeline comprises scan initialization, nearest neighbor flow matching, Chamfer distance matching, and conditional integration and refinement; the two loss-related designs use complete scenes only during training. Inference retains the same scan initialization and the learned conditional vector field, followed by repeated integration and an optional existing refinement network.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400, 'subGraphTitleMargin': {'top': 8, 'bottom': 16}}}}%%
flowchart TD
    Input["Single scan P"] --> Init["Scan initialization"]
    subgraph Training["Training only"]
        NFM["Nearest neighbor<br/>flow matching"] --> CDM["Chamfer distance<br/>matching"]
    end
    Init -->|Training starting state| NFM
    Target["Complete scene G"] -->|Neighbor supervision| NFM
    Target -->|Coverage supervision| CDM
    Init -->|Inference starting state| Solve["Conditional integration<br/>and refinement"]
    CDM -.->|Jointly train the vector field| Solve
    Input -->|Scan condition| Solve
    Solve --> Output["Completed point cloud"]

The training branch represents dependencies in supervision computation, not a nearest neighbor search followed by Chamfer distance optimization at inference time. The complete scene \(G\) does not enter the network during inference, and nearest neighbor targets are not additional test-time answers. The vector field uses MinkUNet with an internal quantization resolution of 0.05 m, but its prediction target remains point-level coordinate motion. Thus, point-level completion does not mean that computation never uses voxelization; internal encoding and output representation must be distinguished.

Key Designs¶

1. Scan initialization: make the training starting state constructible at deployment

The method samples \(N=18{,}000\) scan points and repeats them \(K=10\) times to obtain \(M=180{,}000\) points. An independent standard Gaussian coordinate offset is added to each repeated point, producing the source point cloud \(x_0\). Repetition supplies the required output point count, while independent perturbations break identical coordinates so that copies can move in different directions. The resulting starting state retains the scan's spatial layout instead of relying on unstructured noise spread across the entire scene. Crucially, training and inference use the same construction, without using the complete scene to generate training source points.

Consistency refers to the construction rule and available information, not to identical noise samples across runs. The training target contains \(180{,}000\) points sampled without replacement from the complete scene; equal point counts do not establish one-to-one correspondence. Directly pairing randomly ordered targets with sources could pull neighboring source points toward widely separated structures. Initialization therefore addresses deployability, while the subsequent correspondence determines whether velocity supervision has a meaningful local geometric interpretation.

2. Nearest neighbor flow matching: establish learnable velocity supervision through local correspondence

Nearest Neighbor Flow Matching (NFM) assigns each source point its nearest point in the complete target under Euclidean distance. That neighbor becomes its endpoint, and straight-line interpolation between the two constructs the training state at a randomly sampled time. The network receives this state, the time, and the scan condition, and learns the displacement vector from the source to its assigned endpoint. This turns motion from a scan toward a complete scene into supervised vector-field regression rather than a test-time choice of an approximate diffusion noise level.

The following unified notation summarizes the straight-line mechanism described in the prose; it is not a verbatim transcription of the cached equations with missing operators:

\[ q_i=\operatorname{NN}(x_{0,i},G),\qquad x_{t,i}=(1-t)x_{0,i}+tq_i,\qquad v_i=q_i-x_{0,i}. \]

Here, \(q_i\) is the neighbor assigned during training, \(v_i\) is the velocity target, and \(t\) is sampled uniformly from \([0,1]\). NFM trains the network with squared error between predicted and target velocities without requiring a full integration trajectory for every training example. The authors relate this straight data-dependent path to optimal transport, but the implementation does not solve a global one-to-one scene-level point assignment. Multiple source points may select the same endpoint: short local travel distances do not guarantee coverage of every part of the complete scene.

3. Chamfer distance matching: make local motion account for global coverage

Fitting nearest neighbor displacement alone can concentrate generated points near existing observations while leaving other target regions uncovered. Chamfer Distance Matching (CDM) adds supervision through a bidirectional point-set distance to address this behavior. Equation (12) describes target-distance supervision around an endpoint estimate formed from the source plus the predicted displacement; it does not back-propagate through every step of a complete inference trajectory. The aim is to constrain the outcome implied by the predicted displacement, not merely its agreement with a preassigned nearest neighbor. Operators are missing from that cached equation, so this note explains the mechanism without presenting a repaired expression as the authors' exact formula.

The bidirectional Chamfer distance first measures how far each generated point lies from the nearest target surface, then measures how far each target point lies from the generated set. The first direction discourages points away from real surfaces; the second penalizes target regions with no nearby generated points. The training definition sums the separate means of these two sets of squared nearest neighbor distances, unlike a one-sided surface-deviation penalty. However, even a small bidirectional distance does not ensure that each target has only one corresponding source, so CDM is not a strict bijection constraint. It improves coverage without eliminating many-to-one matching, explaining why low CD and high-resolution voxel IoU need not improve together.

4. Conditional integration and refinement: turn supervised velocities into a usable dense point cloud

Inference starts from the same \(x_0\) construction and applies Euler integration from \(t=0\) to \(t=1\) using the network's velocity predictions at the current point cloud and time. The default is 10 steps with step size \(h=0.1\); each update re-estimates the velocity rather than repeatedly applying one initially predicted displacement. Classifier-free guidance supplies scan conditioning with default guidance weight \(w=6.0\). It combines conditional and unconditional predictions to strengthen scan conditioning, but the paper does not prove that it enforces hard geometric consistency.

After generation, the optional LiDiff refinement network predicts \(\kappa=6\) offsets per point to produce denser local geometry. The base output has \(180{,}000\) points, and refinement produces \(1{,}080{,}000\) points, calculated from the paper's parameters. This refiner uses the official implementation and weights already trained on SemanticKITTI; it is not a separately novel LiFlow component. The \(\dagger\) marker identifies refinement-enabled results, so their improvements should not be attributed entirely to the flow-matching model itself.

A Worked Example¶

Consider a road scan within the 50 m evaluation range, where a distant car has few returns and an adjacent occluded region lacks dense surface observations. Repetition and independent noise turn \(18{,}000\) sampled observations into \(180{,}000\) initial particles, but this alone does not reconstruct the car. During training, the complete map supplies neighbor directions, while bidirectional distance discourages endpoint estimates from clustering only around the visible corner of the vehicle. At test time, there is no complete map: MinkUNet infers missing surfaces from the current particles and original scan over 10 updates. The optional refiner then expands each generated point into 6 local points to add density and detail. This is an illustrative walkthrough of the method, not an instance-level detection success reported by the paper.

Loss & Training¶

The total objective adds weighted NFM and CDM losses, with defaults \(\lambda_{\mathrm{NFM}}=1\) and \(\lambda_{\mathrm{CDM}}=0.1\). These weights control velocity and set-coverage supervision, not the relative number of inference stages. Training drops the scan condition with probability \(p=0.1\), enabling the same network to provide the unconditional prediction required for classifier-free guidance. The backbone follows LiDPM's MinkUNet variant, replacing LiDiff's Batch Normalization layers with Instance Normalization. Training uses Adam, batch size 4, 20 epochs, and exponential moving average (EMA) with decay \(\alpha=0.9999\). Training and inference use an NVIDIA A100 80 GB GPU; the available main text does not specify a learning rate, so a conventional value should not be assumed.

Key Experimental Results¶

Main Results¶

Training uses SemanticKITTI sequences 00–07 and 09–10, validation uses sequence 08, and cross-environment evaluation uses Apollo Columbia Park sequence 00. Apollo uses the same sensor in a different environment and does not train LiFlow, establishing cross-environment transfer rather than cross-sensor generalization. Both datasets use a 50 m scan range, with complete scenes obtained by aggregating scans and removing moving objects. Lower CD is better; JSD compares distributions after voxelization at 0.5 m and bird's-eye-view projection, with lower values preferred. Voxel IoU compares occupied sets at grid resolutions of 0.5, 0.2, and 0.1 m; higher is better, and it is not semantic class mIoU. The source tables label JSD in meters even though divergence is not a length; the tables below preserve values without repeating that unit. CD units follow the source tables rather than an inferred implementation of the damaged formulas.

Selected SemanticKITTI validation results from source Table 1, page 9. LiDiff, LiDPM, and LiFlow use 50, 20, and 10 generation steps, respectively.

Method	CD (source: m)	JSD	IoU 0.5 m (%)	IoU 0.2 m (%)	IoU 0.1 m (%)
LiDiff†	0.375	0.416	32.4	23.0	13.4
LiDPM†	0.377	0.403	36.6	25.8	14.9
LiFlow	0.309	0.416	31.6	13.1	3.8
LiFlow†	0.228	0.367	37.2	25.1	12.9

LiFlow† leads on CD and coarse-grid IoU, but its 0.1 m IoU is below LiDPM†, so it does not lead on every metric. The difference between base LiFlow and LiFlow† also shows that refinement substantially changes final density and occupancy.

Selected Apollo step-count analysis from source Table 2, page 11. All rows use refinement; times are the paper's reported per-frame inference times.

Method	Steps	CD (source: m)	JSD	IoU 0.1 m (%)	Time (s/frame)
LiDiff†	10	0.350	0.343	6.7	7.5
LiDPM†	20	0.406	0.400	12.7	12.4
LiFlow†	5	0.277	0.346	11.0	4.8
LiFlow†	10	0.282	0.350	11.1	7.4
LiFlow†	50	0.286	0.352	10.6	28.9

Five-step LiFlow† already achieves low CD, and increasing to 50 steps does not improve it; this supports few-step generation, not the claim that more steps are always better. In the same table, 10-step LiDiff† has JSD 0.343, below the 0.346 of five-step LiFlow†, so cross-environment gains are not universal across metrics either.

Ablation Study¶

Selected loss-weight ablation from source Table 3, page 12, on Apollo sequence 00. All rows use refinement and are interpreted under the default 10-step setting.

Config	NFM weight	CDM weight	CD (source: m)	JSD	IoU 0.5 m (%)	IoU 0.1 m (%)
NFM only†	1	0	0.325	0.356	34.8	10.6
CDM only†	0	1	0.323	0.397	25.3	6.7
Equal weights†	1	1	0.285	0.364	31.4	10.0
Default weights†	1	0.1	0.282	0.350	32.9	11.1

The default combination exceeds CDM only† by 4.4 percentage points on 0.1 m IoU, but falls below NFM only† by 1.9 percentage points on 0.5 m IoU. The evidence for complementary supervision is therefore a better trade-off across metrics, not monotonic improvement of every metric from each loss term.

Key Findings¶

Table 4, page 13, shows that replacing BN with IN in the refined model reduces CD from 0.340 to 0.282 and raises 0.1 m IoU from 7.0% to 11.1%.
In the same table, unrefined JSD changes from 0.397 with BN to 0.406 with IN; this is an exception to the prose claim of improvement across all metrics, so the numerical table takes precedence.
Speed benefits mainly come from needing fewer steps for good quality: Table 2 reports 28.9 s for 50-step LiFlow†, which is not faster than 27.2 s for 50-step LiDPM†.

Highlights & Insights¶

The training starting state is treated as a modeling decision rather than a sampling detail. This perspective can expose training dependencies on information unavailable at deployment in other inverse problems.
Nearest neighbor supervision provides local directions, while bidirectional set distance adds coverage pressure. They address where points should move and which regions remain unreached, making their roles clearer than a generic extra reconstruction loss.
Reporting both CD and multiscale occupancy exposes the distinction between surface agreement and spatial coverage. Selecting only one metric could hide gaps caused by point clustering.

Limitations & Future Work¶

The authors explicitly acknowledge the absence of one-to-one constraints in NFM; CDM only mitigates this issue, and fine-grid occupancy remains below some baselines.
Reader interpretation: local capacity constraints or approximate transport matching could reduce shared targets, but their scene-scale computational cost must be evaluated alongside quality.
Evaluation ground truth removes moving objects, and there are no downstream detection, navigation, or semantic segmentation gains reported, so improved dynamic driving safety cannot be claimed directly.
Apollo only tests environmental changes with the same sensor; robustness to different beam counts, weather, sensor noise, and severe occlusion requires separate validation.
Even five-step generation with refinement takes 4.8 s/frame on an A100; faster inference is relative to these generative baselines, not evidence of real-time driving latency.
Several cached equations are damaged, so this note retains only mechanism summaries supported by the prose; implementation code was not checked, and unreported exact loss details or learning rates are not inferred.

vs LiDiff: both retain local spatial structure around scans, but LiFlow derives training starting states directly from incomplete scans; its final refiner is inherited from LiDiff.
vs LiDPM: LiDPM improves point-level completion through an intermediate diffusion state, whereas LiFlow includes initial-distribution consistency and correspondence in training instead of further adjusting the reverse diffusion starting time.
vs PUFM: the paper describes PUFM's EMD pre-alignment for single-object upsampling; LiFlow targets multi-object outdoor scenes using nearest neighbors and CDM, which should not be equated with globally optimal assignment.
Research direction: jointly measuring source-point counts assigned to target regions and fine-grid occupancy could locate failures in matching, generation, or refinement; this is a reader proposal, not an experiment completed in the paper.

Rating¶

Novelty: 4/5. Combining deployable source distributions with scene-scale flow matching is a clear contribution, although nearest neighbors and Chamfer distance are established operators.
Experimental Thoroughness: 4/5. Includes in-domain, cross-environment, step-count, loss, and normalization experiments, but lacks dynamic-scene and downstream-task validation.
Writing Quality: 4/5. The distribution-mismatch motivation is clear; some universal claims and the JSD unit require careful reading against the tables.
Value: 4/5. Offers a practical few-step strategy for point-level scene completion, while real-time deployment and reliable fine-grained occupancy remain unresolved.