Paper deep dive
FPSGen: Flexible Point Cloud Scene Generation with BEV-Supported Transport Flows
Wenzhe He, Meng Wang, JiaWei Qian, Jinfeng Xu, Ying Liu, Ruihui Li
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 92%
Last extracted: 8/4/2026, 10:55:22 AM
Summary
FPSGen is a unified framework for flexible point cloud scene generation that addresses train-inference mismatches in existing methods by using a Bird's-Eye-View (BEV) supported point source construction and a teacher-student approximate optimal transport scheme. It enables both unconditional and cue-conditioned (LiDAR, vehicle, road) generation with high efficiency.
Entities (8)
Relation Signals (7)
FPSGen → evaluatedon → KITTI-360
confidence 95% · On KITTI-360 unconditional generation, it also achieves the best Coverage (COV)
FPSGen → evaluatedon → SemanticKITTI
confidence 95% · Extensive experiments show that FPSGen achieves state-of-the-art JSD and voxel IoU performance on SemanticKITTI completion
FPSGen → uses → BEV Prior
confidence 95% · FPSGen first predicts a bird’s-eye-view (BEV) prior with density, height, and mask channels
FPSGen → uses → Optimal Transport
confidence 92% · A teacher-student approximate optimal transport scheme then uses teacher-predicted endpoints
FPSGen → achievesmetric → Coverage (COV)
confidence 90% · it also achieves the best Coverage (COV)
FPSGen → achievesmetric → JSD
confidence 90% · FPSGen achieves state-of-the-art JSD
FPSGen → supportsinput → LiDAR
confidence 90% · covering road, vehicle, LiDAR, and mixed-cue inputs
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Existing point-based generative methods for outdoor scenes primarily focus on LiDAR-conditioned completion. During training, noisy point clouds are constructed by perturbing complete ground-truth scenes, whereas during inference, they are initialized by adding noise to duplicated partial scans. This train-inference mismatch inherits the sparsity and visibility bias of partial scans, leading to sparse distant regions and incomplete geometry in occluded areas. Moreover, the reliance on partial scans restricts generation when LiDAR observations are unavailable or replaced by layout cues. We present FPSGen, a flexible framework that constructs point sources independently of partial scans. FPSGen first predicts a bird's-eye-view (BEV) prior with density, height, and mask channels from the active cues. The density map is then sampled to form a BEV-supported point source, enabling both unconditional and conditioned initialization. A teacher-student approximate optimal transport scheme then uses teacher-predicted endpoints to learn a velocity field that induces straighter transport paths. By integrating BEV point source construction with path-straightening transport, FPSGen provides a unified framework for unconditional and flexible cue-conditioned scene generation. Extensive experiments show that FPSGen achieves state-of-the-art JSD and voxel IoU performance on SemanticKITTI completion while maintaining strong performance with a single point transport step. On KITTI-360 unconditional generation, it also achieves the best Coverage (COV) among the compared methods.
Tags
Links
- Source: https://arxiv.org/abs/2607.26645v1
- Canonical: https://arxiv.org/abs/2607.26645v1
Trouble viewing inline? Open PDF directly →
Full Text
153,197 characters extracted from source content.
Expand or collapse full text
FPSGen: Flexible Point Cloud Scene Generation with BEV-Supported Transport Flows Wenzhe He1, Meng Wang1, JiaWei Qian1, Jinfeng Xu1, Ying Liu2, Ruihui Li1 Abstract Existing point-based generative methods for outdoor scenes primarily focus on LiDAR-conditioned completion. During training, noisy point clouds are constructed by perturbing complete ground-truth scenes, whereas during inference, they are initialized by adding noise to duplicated partial scans. This train-inference mismatch inherits the sparsity and visibility bias of partial scans, leading to sparse distant regions and incomplete geometry in occluded areas. Moreover, the reliance on partial scans restricts generation when LiDAR observations are unavailable or replaced by layout cues. We present FPSGen, a flexible framework that constructs point sources independently of partial scans. FPSGen first predicts a bird’s-eye-view (BEV) prior with density, height, and mask channels from the active cues. The density map is then sampled to form a BEV-supported point source, enabling both unconditional and conditioned initialization. A teacher-student approximate optimal transport scheme then uses teacher-predicted endpoints to learn a velocity field that induces straighter transport paths. By integrating BEV point source construction with path-straightening transport, FPSGen provides a unified framework for unconditional and flexible cue-conditioned scene generation. Extensive experiments show that FPSGen achieves state-of-the-art JSD and voxel IoU performance on SemanticKITTI completion while maintaining strong performance with a single point transport step. On KITTI-360 unconditional generation, it also achieves the best Coverage (COV) among the compared methods. Introduction Figure 1: Partial scan source mismatch in point diffusion methods for completion and the FPSGen solution. Existing models often train from perturbed complete scenes but infer from duplicated partial LiDAR scans. FPSGen instead applies the same bird’s eye view (BEV) source sampler to ground truth priors during training and generated priors during inference. Large-scale 3D scene generation is important for autonomous driving simulation, data augmentation, and rare-scene analysis. Existing methods for scene-level generation commonly rely on structured grid-based representations (Liu et al. 2024; Lee et al. 2024a; Nunes et al. 2026). Although these representations facilitate structured scene modeling, spatial discretization may lose geometric details and incur substantial memory costs at high resolutions. Point clouds instead preserve continuous 3D coordinates and naturally exploit the spatial sparsity of outdoor scenes. However, generating large-scale point cloud scenes remains challenging because outdoor environments span large spatial extents and contain substantially more points than individual objects. Consequently, most point-based generative methods (Wu et al. 2023; Meng et al. 2025; Zhu et al. 2025) focus on single-object generation, while scene-level point cloud generation remains relatively underexplored. Existing point-based generative methods for outdoor LiDAR scenes primarily focus on LiDAR-conditioned completion. Given a partial scan, methods such as LiDiff (Nunes et al. 2024), LiDPM (Martyniuk et al. 2025), and ScoreLiDAR (Zhang et al. 2025) recover complete scenes through iterative point denoising. These approaches are based on point diffusion and completion methods that generate or reconstruct point sets through denoising and geometric refinement (Luo and Hu 2021; Zhou et al. 2021; Zeng et al. 2022; Lyu et al. 2021; Li et al. 2024). Although LiDPM further discusses unconditional generation, it still requires a predefined noise template for point initialization during the generation process. As illustrated in Fig. 1, existing completion methods construct noisy point clouds by perturbing complete ground-truth scenes during training, whereas inference initializes them by adding noise to duplicated partial scans (Nunes et al. 2024; Martyniuk et al. 2025; Zhang et al. 2025). This train–inference mismatch is further compounded by the sparsity and visibility bias inherited from partial scans, resulting in sparse distant regions and incomplete geometry in occluded areas. Moreover, dependence on partial scans limits generation when LiDAR observations are unavailable or replaced by layout cues. Although a generic Gaussian source avoids such dependence, it provides little scene-specific spatial support over large outdoor environments. The central challenge is therefore to construct an informative point source that covers plausible scene geometry while supporting both unconditional and flexible cue-conditioned generation. We present FPSGen, a flexible framework that constructs point sources independently of partial scans. FPSGen first predicts a bird’s-eye-view (BEV) prior containing density, height, and mask channels from the active cues, and samples the density map to form a BEV-supported point source for both unconditional and conditioned initialization. The complete BEV prior further provides structured scene context for subsequent point transport. However, an informative source alone does not guarantee efficient transport, as independent source–target pairing may induce complex trajectories requiring many integration steps. FPSGen therefore introduces a teacher-student approximate optimal transport scheme, in which the teacher predicts source-indexed clean endpoints that guide the student to learn a velocity field with straighter transport paths. This design avoids explicitly solving a scene-scale optimal transport plan while enabling accurate, high-quality generation with few point transport steps. By integrating BEV source construction with path-straightening transport, FPSGen provides a unified framework for unconditional and flexible cue-conditioned scene generation. The main contributions are as follows: • We introduce a unified framework for unconditional and flexible cue-conditioned point cloud scene generation, covering road, vehicle, LiDAR, and mixed-cue inputs. • We propose a BEV prior generator and density-weighted sampler that construct point sources without duplicating partial scans. • We develop a teacher-student approximate optimal transport scheme that promotes straighter transport paths without explicit scene-scale matching. • Extensive experiments on SemanticKITTI and KITTI-360 demonstrate superior performance across completion and unconditional generation, together with strong accuracy under single-step point transport. Related Work Scene completion. Scene completion reconstructs unobserved geometry from partial measurements. Structured approaches predict occupancy-based or Gaussian scene representations from depth, LiDAR, or camera inputs (Song et al. 2017; Li et al. 2023b; Huang et al. 2024b, a). Point-based methods instead recover unordered point sets through coarse-to-fine decoding, transformer-based reconstruction (Yuan et al. 2018; Yu et al. 2021; Xiang et al. 2021; Zhou et al. 2026). At the scale of outdoor LiDAR scenes, LiDiff and LiDPM apply point diffusion to LiDAR scene completion (Nunes et al. 2024; Martyniuk et al. 2025). ScoreLiDAR and Distillation-DPO further accelerate diffusion-based completion through distillation and preference-aligned optimization (Zhang et al. 2025; Zhao et al. 2026). These methods remain observation-dependent because a partial LiDAR scan is required to define the condition and construct the initial point set. Scene generation. Large-scale 3D scene generation aims to synthesize coherent geometry and semantics beyond isolated objects. SemCity models outdoor semantic scenes in triplane space (Lee et al. 2024a), while Pyramid Diffusion generates fine-grained scenes through a coarse-to-fine hierarchy of discrete diffusion models (Liu et al. 2024). UniScene adopts semantic occupancy as a unified representation for driving scene generation (Li et al. 2025a), and its scaled-up extension further captures the spatial expansion and temporal evolution of 4D scenes (Li et al. 2025b). For unbounded world generation, WorldGrow extends structured latent blocks through context-aware inpainting (Li et al. 2026), whereas WorldFlow3D transports volumetric distributions from coarse structure to detailed geometry and appearance (Joshi et al. 2026). These methods primarily operate on triplane, occupancy, or latent volumetric representations. In point space, LiDPM explores unconditional scene generation but still relies on a predefined noise template for initialization (Martyniuk et al. 2025). Direct generation of large-scale unordered point sets under flexible input cues therefore remains underexplored. Flow matching. Flow matching trains continuous normalizing flows by regressing time-dependent vector fields along prescribed probability paths (Lipman et al. 2022). Rectified flow and optimal transport conditional flow matching improve source-target coupling and encourage straighter transport paths (Liu et al. 2022; Tong et al. 2023). LiFlow introduces flow matching for point-based LiDAR scene completion and constructs consistent training and inference sources from the observed scan (Matteazzi and Tutsch 2026). However, its source point set still depends on a LiDAR observation, leaving observation-independent source construction for layout-conditioned and unconditional point generation unresolved. Method Symbol Meaning l,gtP^l,P^gt Sparse LiDAR condition and complete training point cloud CmC_m Active condition tuple after masking LiDAR, vehicle, and road cues B0,B1B_0,B_1 Initial Gaussian noise and ground-truth BEV target, respectively B¯,B B, B Ground-truth BEV prior during training and generated BEV prior ℛR BEV source sampler 0,0initP_0,P_0^init BEV-supported point source during training and inference 1†,^P _1, P teacher-estimated source-indexed clean endpoint and inferred point cloud vϕ,vψv_φ,v_ψ BEV velocity field and point velocity field τ,tτ,t BEV-flow time and point-flow time KB,KPK_B,K_P Numbers of BEV-flow and point-flow Euler steps Table 1: Main notation used in the method. Problem Formulation and Overview FPSGen decomposes 3D scene generation into BEV support construction and point transport. The BEV stage predicts the spatial distribution of scene points from the active cues, while the point stage transports samples from this support toward complete scene geometry. This formulation replaces duplicated partial-scan initialization with a flexible BEV-supported point source. We adopt conditional flow matching as the shared framework for both stages (Lipman et al. 2022). Given paired source and target endpoints z0z_0 and z1z_1 under condition c, we define the linear interpolation path and target velocity as zt=(1−t)z0+tz1,ut=z1−z0,z_t=(1-t)z_0+tz_1, u_t=z_1-z_0, (1) where t∼(0,1)t (0,1), with U denoting the uniform distribution. A conditional velocity network vθ(zt,t,c)v_θ(z_t,t,c) is trained to approximate the target velocity through ℒCFM=z0,z1,t,c[‖vθ(zt,t,c)−ut‖22].L_CFM=E_z_0,z_1,t,c [ \|v_θ(z_t,t,c)-u_t \|_2^2 ]. (2) At inference, samples are transported from t=0t=0 to t=1t=1 by integrating the learned ordinary differential equation: dztdt=vθ(zt,t,c), dz_tdt=v_θ(z_t,t,c), (3) which is numerically solved using Euler updates. This formulation is instantiated for both BEV generation and point transport in FPSGen, where z denotes either the BEV prior B or the point cloud P. The main notation used throughout the method is summarized in Table 1. For BEV flow training, random noise is paired with the ground-truth BEV prior, while inference transports noise toward a generated BEV prior. For point flow training, a BEV-supported point source is paired with a source-indexed clean endpoint predicted by the teacher, and the student learns the corresponding velocity field. At inference, a point source sampled from the generated BEV prior is transported toward the final scene. Let l=pili=1NlP^l=\p_i^l\_i=1^N_l denote an optional sparse LiDAR observation, and let gt=pigti=1NP^gt=\p_i^gt\_i=1^N denote the complete target point cloud available during training. We encode lP^l as the LiDAR condition clc_l, while the other optional cues are the vehicle mask cvc_v and road mask crc_r. Binary variables ml,mv,mr∈0,1m_l,m_v,m_r∈\0,1\ indicate whether each cue is active. The active conditions are collected as Cm=(mlcl,mvcv,mrcr).C_m=(m_lc_l,\;m_vc_v,\;m_rc_r). (4) During training, both the BEV flow and point flow uniformly sample all eight condition combinations. Inactive cues are replaced with zero tensors before being fed into the networks. The overall objective is to learn a conditional generator ∼pθ(∣Cm),P p_θ(P C_m), (5) such that completion, layout-conditioned generation, mixed-condition generation, and unconditional generation are handled by a single framework. FPSGen realizes this distribution through a two-stage sampling process: B^∼pϕ(B^∣Cm), B p_φ( B C_m), (6) 0init=ℛ(B^;N,Σ), _0^init=R( B;N, ), ∼pψ(∣0init,B^,Cm). p_ψ\! (P _0^init, B,C_m ). Here, pϕp_φ generates the BEV prior B B, ℛR samples a BEV-supported point source from its density channel, and pψp_ψ performs point-level transport. The source contains N points, and Σ denotes the covariance of the coordinate perturbation. After marginalizing the stochastic BEV prior and source sampling, these components jointly define pθ(∣Cm)p_θ(P C_m). We refer to ℛR as the BEV source sampler. Figure 2 summarizes the complete pipeline. During training, the complete point cloud is converted into the ground-truth BEV prior B¯ B. The BEV source sampler constructs the corresponding point source 0P_0, and the teacher maps it to a source-indexed clean endpoint 1†P _1, which supervises the student point flow. During inference, the BEV flow first generates B B, after which ℛR constructs 0initP_0^init, and the student integrates the point velocity field from t=0t=0 to t=1t=1. The same BEV source sampler is used during training and inference, although inference quality depends on the generated prior B B. Detailed architectures, layout-mask construction, and training schedules are provided in the supplementary material. Figure 2: FPSGen training and inference pipeline. Optional cues CmC_m, including LiDAR, vehicle, and road conditions, drive the BEV flow from noise B0B_0 to a density, height, and mask prior. The BEV source sampler converts the density channel into a BEV-supported point source 0P_0, while the complete BEV prior is provided to the point flow as context. During training, the ground-truth prior B¯ B supplies source support, and the teacher estimates the clean endpoint 1†P _1. During inference, the generated prior B B and optional cues guide the student point flow to produce the final scene P. Flexible Condition BEV Flow Prior The BEV prior fuses the LiDAR condition, vehicle mask, and road mask in a common spatial grid. It supplies coarse scene support before unordered points are instantiated. We define a projection operator Φ to map the complete ground-truth point cloud gtP^gt into a structured BEV target B1=Φ(gt)=[D,H,M]∈ℝ3×h×w,B_1= (P^gt)=[D,H,M] ^3× h× w, (7) where D, H, and M denote normalized density, maximum height, and occupancy mask channels. We use log density, maximum height, and binary occupancy normalization to map the BEV target to the [−1,1][-1,1] range. The exact construction is given in the supplementary material. The BEV flow uses Gaussian noise B0∼(0,I)B_0 (0,I) and the linear path Bτ=(1−τ)B0+τB1,uB=B1−B0.B_τ=(1-τ)B_0+τ B_1,\;u_B=B_1-B_0. (8) During training, we sample an active condition tuple CmC_m with the same uniform condition mask protocol. The BEV velocity network predicts u^B=vϕ(Bτ,τ,Cm), u_B=v_φ(B_τ,τ,C_m), (9) and is trained with ℒBEV=EB0,B1,τ,Cm[‖u^B−uB‖22].L_BEV=E_B_0,B_1,τ,C_m [ \| u_B-u_B \|_2^2 ]. (10) Both training-time condition dropout and inference-time available cues are represented by the same tuple CmC_m. To convert a BEV prior into a point source, we define the BEV source sampler ℛR using the density channel. Since D is stored in the normalized BEV scale, we first convert it back to a nonnegative density score, where nmaxn_ is the density clipping constant. ρD(q)=exp(D(q)+12log(1+nmax))−1. _D(q)= \! ( D(q)+12 (1+n_ ) )-1. (11) Given B=[D,H,M]B=[D,H,M], the BEV cell sampling weight is wD(q)=max(ρD(q),0)+εw∑q′(max(ρD(q′),0)+εw).w_D(q)= ( _D(q),0)+ _w _q ( ( _D(q ),0)+ _w). (12) Here εw>0 _w>0 is a small numerical stabilizer. We independently sample N=180,000N=180,000 cells with replacement according to the weights wDw_D, where Cat(wD)Cat(w_D) denotes the categorical distribution over all BEV cells parameterized by wDw_D. Each sampled cell is mapped to a zero-height metric point and perturbed with Gaussian coordinate noise. qi∼Cat(wD),pib=(x(qi),y(qi),0), q_i (w_D),\;p_i^b=(x(q_i),y(q_i),0), (13) ℛ(B;N,Σ)=pib+ϵii=1N,ϵi∼(0,Σ). (B;N, )=\p_i^b+ _i\_i=1^N,\; _i (0, ). In our implementation, the BEV grid covers [−50,50]m×[−50,50]m[-50,50]\,m×[-50,50]\,m with 256×256256× 256 cells. The sampled cell centers x(qi)x(q_i) and y(qi)y(q_i) are converted to metric coordinates when constructing ℛR. The resulting metric point source is subsequently processed by the point flow, which is conditioned on the complete BEV prior B=[D,H,M]B=[D,H,M] with channel values normalized to [−1,1][-1,1]. Thus, D determines the spatial distribution of the source points, while all three channels provide structured BEV context to the point flow. Teacher Transport Mapping Once BEV-supported point source is available, the point stage must map noisy point source to a detailed scene. The BEV-supported point source follows the global road and object layout, but it does not provide reliable point-wise correspondences to gtP^gt. Direct optimal transport (OT) matching between the noisy point source and gtP^gt is computationally expensive at scene scale. We therefore use a learned teacher to approximate the source-to-target matching. Let B¯=[D¯,H¯,M¯] B=[ D, H, M] denote the ground-truth BEV prior used during point-stage training. In our implementation, B¯=B1=Φ(gt) B=B_1= (P^gt). Applying the BEV source sampler in Eq. (13) to this training-time prior yields the noisy source endpoint 0=ℛ(B¯;N,Σ).P_0=R( B;N, ). (14) Given the noisy source 0P_0 and the complete target gtP^gt, the teacher predicts a pointwise displacement toward a clean endpoint: 1†=0+Γη(0,gt),P _1=P_0+ _η(P_0,P^gt), (15) where Γη _η is the teacher network and 1†P _1 is the teacher-estimated clean endpoint. Since the source point order is preserved by the residual mapping, 1†P _1 provides a source-indexed clean endpoint for student training. The teacher is trained using set-level geometric supervision: ℒT=gt,0[CD(1†,gt)+λrepℒrep].L_T=E_P^gt,P_0 [CD (P _1,P^gt )+ _repL_rep ]. (16) Here, the Chamfer distance aligns the predicted endpoint with the complete scene, while the repulsion term discourages locally collapsed point clusters: ℒrep=1N∑i=1Nmax(0,rrep−‖pi†−pν(i)†‖2),L_rep= 1N _i=1^N \! (0,\,r_rep- \|p_i -p_ν(i) \|_2 ), (17) where pi†∈1†p_i _1 , ν(i)ν(i) denotes the nearest-neighbor index of pi†p_i in 1†∖pi†P_1 \p_i \, and rrepr_rep is the repulsion radius. We refer to (0,1†)(P_0,P _1) as the teacher pair. The student is trained on the BEV-supported point source and its teacher-estimated, source-indexed clean endpoint, avoiding an explicit scene-scale OT plan. Approximate-OT Point Flow The teacher-estimated mapping provides a scalable target for point transport. The source-to-target displacement used to train the student is uP=1†−0=Γη(0,gt).u_P=P _1-P_0= _η(P_0,P^gt). (18) We refer to this construction as Approx OT because the teacher provides an amortized, source-indexed clean endpoint for the BEV-supported point source without explicitly solving optimal transport or superset optimal transport at the 180,000180,000-point scene scale. Approx OT therefore denotes a learned surrogate for scene-scale matching rather than an exact optimal transport solution. For each training scene, the teacher pair (0,1†)(P_0,P _1) defines the endpoints of the point transport path. We treat 0P_0 as the source endpoint at t=0t=0 and 1†P _1 as the clean endpoint at t=1t=1. We sample t∼(0,1)t (0,1) and construct t=(1−t)0+t1†,uP=1†−0.P_t=(1-t)P_0+tP _1, u_P=P _1-P_0. (19) Given tP_t, B¯ B, and CmC_m, the student predicts u^P=vψ(t,t,B¯,Cm). u_P=v_ψ(P_t,t, B,C_m). (20) Using the same condition-tuple sampling strategy as in the BEV stage, the point transport objective is ℒPoint=gt,0,t,Cm[‖u^P−uP‖22].L_Point=E_P^gt,P_0,t,C_m [ \| u_P-u_P \|_2^2 ]. (21) This objective aligns the student velocity with the source-to-target displacement induced by the teacher-estimated mapping. The same condition tuple CmC_m is used by both the BEV prior model and the point transport model. Unified Inference Inference uses the same BEV-to-point structure as training, but removes all inputs that require complete scene supervision. The teacher is discarded, and the ground-truth BEV prior B¯ B is replaced by a generated BEV prior B B. We use τ for BEV flow time and t for point transport time. For compactness, let vϕmv_φ^m and vϕ0v_φ^0 denote vϕ(Bτ,τ,Cm)v_φ(B_τ,τ,C_m) and vϕ(Bτ,τ,C∅)v_φ(B_τ,τ,C_ ), and let vψmv_ψ^m and vψ0v_ψ^0 denote vψ(t,t,B^,Cm)v_ψ(P_t,t, B,C_m) and vψ(t,t,B^,C∅)v_ψ(P_t,t, B,C_ ). Classifier-free guidance is applied to both flow fields as vϕcfg=vϕ0+sB(vϕm−vϕ0),vψcfg=vψ0+sP(vψm−vψ0). array[]lv_φ^cfg=v_φ^0+s_B(v_φ^m-v_φ^0),\\ v_ψ^cfg=v_ψ^0+s_P(v_ψ^m-v_ψ^0). array (22) Here sBs_B and sPs_P are the BEV and point guidance scales. In the Euler updates below, each guided field is evaluated at the current state and time. The BEV flow starts from Gaussian noise and evolves forward to a BEV prior. Bτ0∼(0,I),dBτdτ=vϕcfg,B^=Bτ=1.B_ _0 (0,I),\; dB_τdτ=v_φ^cfg,\; B=B_τ=1. (23) With KBK_B forward Euler steps, 0=τ0<τ1<⋯<τKB=10= _0< _1<·s< _K_B=1, Bτℓ+1=Bτℓ+(τℓ+1−τℓ)vϕcfg,B^=BτKB.B_ _ +1=B_ _ +( _ +1- _ )v_φ^cfg,\; B=B_ _K_B. (24) The generated BEV prior B B is then converted into a BEV-supported point source 0initP_0^init for the point flow. 0init=ℛ(B^;N,Σ).P_0^init=R( B;N, ). (25) Let 0=t0<t1<⋯<tKP=10=t_0<t_1<·s<t_K_P=1. Starting from 0initP_0^init, the point flow transports the source toward the generated scene. t0=0init,dtdt=vψcfg,^=tKP.P_t_0=P_0^init,\; dP_tdt=v_ψ^cfg,\; P=P_t_K_P. (26) The point Euler updates are tk+1=tk+(tk+1−tk)vψcfg.P_t_k+1=P_t_k+(t_k+1-t_k)v_ψ^cfg. (27) Thus every conditioning setting follows a single forward inference chain. CmC_m drives the BEV flow to B B, ℛR samples 0initP_0^init, and the student point flow produces P as the generated point cloud scene. Experiments Method CD ↓ JSD3DJSD_3D ↓ JSDBEVJSD_BEV ↓ IoU@0.5m0.5\,m ↑ IoU@0.2m0.2\,m ↑ IoU@0.1m0.1\,m ↑ LMSCNet 0.641 – 0.431 30.83 12.09 3.65 LODE 1.029 – 0.451 33.81 16.39 5.00 MID 0.503 – 0.470 31.58 22.72 13.14 PVD 1.256 – 0.498 15.91 3.97 0.60 LiDiff 0.434 0.564 0.444 31.47 16.79 4.67 LiDPM 0.446 0.532 0.440 34.09 19.45 6.27 ScoreLiDAR 0.406 – 0.425 – – – Distillation-DPO 0.414 – 0.419 – – – LiFlow 0.309 – 0.416 31.60 13.10 3.80 FPSGen (LiDAR) 0.316 0.492 0.329 44.15 32.26 18.26 FPSGen (LiDAR + road) 0.291 0.488 0.315 44.43 32.35 18.38 FPSGen (LiDAR + vehicle) 0.307 0.488 0.325 44.71 32.77 18.53 FPSGen (all conditions) 0.288 0.485 0.313 44.87 32.71 18.49 Table 2: LiDAR-conditioned completion on SemanticKITTI sequence 08. Results for other methods follow the published completion protocol. Condition Method COV-CD ↑ MMD-CD ↓ 1-NNA-CD COV-EMD ↑ MMD-EMD ↓ 1-NNA-EMD Unconditional LiDiff 39.73 8.96 87.64 43.54 5.99 83.75 Unconditional LiDPM 40.68 7.42 73.57 39.35 5.92 81.84 Unconditional SemCity 7.98 26.86 99.05 10.84 8.95 98.00 Unconditional FPSGen 41.25 7.48 75.29 44.30 5.85 77.09 Vehicle mask FPSGen 46.77 7.09 72.34 46.39 5.72 72.81 Road mask FPSGen 63.12 5.59 51.24 57.98 5.26 57.51 Road + vehicle FPSGen 65.21 5.43 47.72 60.27 5.15 56.08 Table 3: Distributional generation quality on KITTI-360. COV and 1-NNA are percentages, and 1-NNA is best when closer to 50%50\%. Tasks, Datasets, and Metrics We evaluate FPSGen on LiDAR-conditioned completion and flexible conditional scene generation. LiDAR is treated as a strong geometric condition for completion, while unconditional, road mask, and vehicle mask settings test generation from weak or absent conditions. All FPSGen components are trained once on SemanticKITTI sequences 00–07 and 09–10 (Behley et al. 2019). We evaluate the resulting model on SemanticKITTI sequence 08 and KITTI-360 sequence 00 (Liao et al. 2022) without retraining. Sequence 08 provides held-out SemanticKITTI evaluation, while KITTI-360 measures transfer to a different dataset. Complete scenes are prepared from aggregated scans following prior LiDAR completion work (Nunes et al. 2024). Semantic labels are used only to derive road and vehicle masks. Completion uses Chamfer distance (CD), 3D and BEV Jensen-Shannon divergence (JSD3DJSD_3D and JSDBEVJSD_BEV), and voxel intersection over union (IoU) at 0.5m0.5\,m, 0.2m0.2\,m, and 0.1m0.1\,m (Akmal Butt and Maragos 1998; Menéndez et al. 1997). Generation uses coverage (COV), minimum matching distance (MMD), and 1-nearest-neighbor accuracy (1-NNA) under CD and Earth Mover’s Distance (EMD) (Achlioptas et al. 2018; Rubner et al. 2000). Detailed metric definitions are provided in the supplementary material. Baselines and Main Results We compare FPSGen with representative voxel-, point-, and diffusion-based completion methods (Roldao et al. 2020; Li et al. 2023a; Vizzo et al. 2022; Zhou et al. 2021; Nunes et al. 2024; Martyniuk et al. 2025; Zhang et al. 2025; Zhao et al. 2026; Matteazzi and Tutsch 2026), and with LiDiff, LiDPM, and SemCity for generation (Nunes et al. 2024; Martyniuk et al. 2025; Lee et al. 2024b). We also evaluate all completion methods using the same sparse scans generated by LiDM (Ran et al. 2024). With LiDAR alone, LiFlow achieves the lowest CD of 0.309, while FPSGen obtains a comparable CD of 0.316 and the best JSD3DJSD_3D, JSDBEVJSD_BEV, and IoU results in Table 2. As further shown in Table 6, scan-repeated initialization favors CD, whereas the BEV source improves distribution alignment and supports LiDAR-free generation. Adding road and vehicle cues further reduces CD to 0.288 and JSDBEVJSD_BEV to 0.313. Without retraining on KITTI-360, FPSGen achieves the best unconditional EMD-based results in Table 3. Road and vehicle cues further raise COV-CD from 41.25 to 65.21 and bring 1-NNA closer to 50%50\%. In the LiDM diagnostic, FPSGen raises COV-EMD from 2.85 to 30.80 and reduces MMD-EMD from 13.232 to 6.400, while Distillation-DPO retains the lowest MMD-CD. Figure 3: Qualitative LiDAR-conditioned completion comparison on SemanticKITTI sequence 08. From left to right, the panels show the input LiDAR scan, ground truth, LiDiff, LiDPM, ScoreLiDAR, Distillation-DPO, and FPSGen. Method COV-CD ↑ MMD-CD ↓ 1-NNA-CD COV-EMD ↑ MMD-EMD ↓ 1-NNA-EMD LiDM + LiDiff 23.57 9.816 95.15 2.85 13.518 99.90 LiDM + LiDPM 23.76 9.868 94.77 2.85 13.616 99.90 LiDM + ScoreLiDAR 23.38 8.013 94.20 2.28 13.366 99.90 LiDM + Distillation-DPO 24.33 7.905 93.54 2.47 13.232 99.90 LiDM + FPSGen 28.33 8.689 87.26 30.80 6.400 85.17 Table 4: KITTI-360 LiDM seeded generation diagnostic. LiDM first generates sparse LiDAR scans, and each method completes them into full point clouds. COV and 1-NNA are percentages, and 1-NNA is best when closer to 50%50\%. Variant CD ↓ JSD3DJSD_3D ↓ JSDBEVJSD_BEV ↓ w/o density D 0.3821 0.5653 0.3451 w/o height H 0.3693 0.5510 0.3315 w/o mask M 0.3163 0.4930 0.3302 Full D+H+MD+H+M 0.3161 0.4924 0.3292 Table 5: BEV prior component ablation. Source CD JSD3DJSD_3D JSDBEVJSD_BEV BEV source sampler 0.3161 0.4924 0.3292 Gaussian 0.3337 0.6299 0.4138 LiDAR-derived 0.2562 0.5114 0.3449 Table 6: Point-source initialization ablation with KP=32K_P=32 point-flow steps. Lower is better for all metrics. Ablation Study We ablate BEV prior components and point source initialization. Further transport and scalability studies are provided in the supplementary material. BEV prior components. Density and height are the main support variables in Table 5. Removing them raises CD from 0.3161 to 0.3821 and 0.3693, respectively, showing their importance for accurate spatial support, whereas removing the mask has only a minor effect. Source initialization. As shown in Table 6, Gaussian initialization degrades all metrics. LiDAR-derived initialization achieves the lowest CD but yields worse JSD scores and requires a partial LiDAR scan as input. In contrast, the BEV source sampler provides better distribution alignment without scan-dependent initialization. Qualitative Analysis and Inference Efficiency Figure 3 further illustrates the role of the source distribution. LiDiff, LiDPM, ScoreLiDAR, and Distillation-DPO construct their initial distributions by perturbing the observed LiDAR scan, so their completions tend to recover regions already supported by visible scan points while leaving heavily occluded areas underfilled. FPSGen first builds a BEV-supported point source over the scene layout, which gives the point flow broader support to transport and better matches the intended completion objective. Additional generation visualizations are included in the supplementary material. Method KBK_B KPK_P CD ↓ Time ↓ Mem. ↓ LiDiff – 50 0.434 33.75 6.18 LiDPM – 20 0.446 20.92 5.53 ScoreLiDAR – 8 0.406 7.73 6.07 Distillation-DPO – 8 0.414 5.81 6.07 FPSGen 10 1 0.321 0.95 4.05 FPSGen 10 32 0.316 15.57 4.04 Table 7: Single GPU inference runtime on SemanticKITTI sequence 08. Time is seconds per scene, and memory is peak reserved GPU memory in GB. Table 7 reports per-scene inference runtime under the same experimental environment. Here KBK_B and KPK_P denote BEV-flow and point-flow steps. With KB=10K_B=10 and only one point flow step, FPSGen reaches CD 0.321 in 0.95 seconds. Increasing KPK_P to 32 reduces CD by 0.005 while remaining faster than LiDiff and LiDPM and using less peak memory. These results demonstrate that the proposed Approx OT construction enables fast scene generation with a single point flow step. The supplementary material provides runtime sweeps over different KBK_B and KPK_P settings. Conclusion We presented FPSGen, a flexible point cloud scene generator with BEV-supported transport. FPSGen replaces partial scan-dependent initialization with a staged BEV-to-point process. A BEV flow predicts density, height, and mask priors, after which the BEV source sampler constructs a supported point source and a teacher-student point flow transports it into complete scene geometry. This design improves LiDAR-conditioned completion while supporting unconditional and layout-conditioned generation within one framework. The SemanticKITTI-trained model transfers to KITTI-360 without retraining, showing that BEV support bridges structured scene layouts and unordered point clouds. FPSGen still depends on complete point cloud supervision and BEV prior quality, while focusing on single-frame scenes. Future work will explore temporal generation, richer controllable layouts, and broader sensor-aware sampling. Additional Experimental Results SemanticKITTI Generation Comparison Method COV-CD ↑ MMD-CD ↓ 1-NNA-CD COV-EMD ↑ MMD-EMD ↓ 1-NNA-EMD LiDiff 39.71 9.596 98.41 44.36 6.594 93.26 LiDPM 42.65 6.476 87.62 43.63 6.194 88.73 SemCity 14.71 17.795 98.04 16.91 8.083 96.45 FPSGen 41.67 6.517 79.04 45.59 6.132 79.53 Table 8: Distributional generation quality on SemanticKITTI sequence 08 under a matched LiDAR free protocol. COV and 1-NNA are percentages, and 1-NNA is best when closer to 50%50\%. Table 8 reports the in-domain SemanticKITTI (Behley et al. 2019) generation comparison against LiDiff (Nunes et al. 2024), LiDPM (Martyniuk et al. 2025), and SemCity (Lee et al. 2024b). FPSGen achieves the best EMD side metrics and the 1-NNA-CD value closest to the ideal two sample level, while LiDPM remains slightly lower on MMD-CD. KITTI-360 Completion Comparison Table 9 provides a KITTI-360 (Liao et al. 2022) LiDAR-conditioned completion comparison using the same completion metrics as the SemanticKITTI comparison. The published baselines include LMSCNet (Roldao et al. 2020), LODE (Li et al. 2023a), MID (Vizzo et al. 2022), LiDiff (Nunes et al. 2024), ScoreLiDAR (Zhang et al. 2025), and Distillation-DPO (Zhao et al. 2026). FPSGen is evaluated under the LiDAR-only condition. For Distillation-DPO, we report the few-step student result and include only the metrics provided in its published KITTI-360 comparison. Method CD ↓ JSD3DJSD_3D ↓ JSDBEVJSD_BEV ↓ IoU@0.5m0.5\,m ↑ IoU@0.2m0.2\,m ↑ IoU@0.1m0.1\,m ↑ LMSCNet 0.979 – 0.496 26.17 9.21 2.88 LODE 1.565 – 0.483 33.06 15.24 4.68 MID 0.637 – 0.476 33.05 21.32 11.30 LiDiff 0.564 – 0.459 33.23 17.55 4.88 ScoreLiDAR 0.472 – 0.444 – – – Distillation-DPO 0.533 – 0.434 – – – FPSGen 0.313 0.494 0.337 42.09 31.67 18.66 Table 9: KITTI-360 LiDAR conditioned completion comparison. Lower is better for CD, JSD3DJSD_3D, and JSDBEVJSD_BEV. Higher is better for IoU. FPSGen is not optimized solely for completion, yet it improves every directly comparable KITTI-360 metric, including CD, JSD3DJSD_3D, JSDBEVJSD_BEV, and all three voxel IoU resolutions. FPSGen also reports JSD3D=0.494JSD_3D=0.494, although this metric is unavailable for the published baselines and is therefore not used for a best method claim. These results support the claim that BEV-supported point transport preserves scene-level occupancy structure while remaining compatible with non-LiDAR generation modes. Condition Ablations Table 10 reports the SemanticKITTI (Behley et al. 2019) LiDAR-conditioned completion ablation under different active condition tuples Cm=(mlcl,mvcv,mrcr)C_m=(m_lc_l,m_vc_v,m_rc_r). We keep the LiDAR cue active for completion because it is the primary condition that defines the completion task, and then evaluate road and vehicle masks as auxiliary layout cues. Condition CD ↓ DCD ↓ JSD3DJSD_3D ↓ JSDBEVJSD_BEV ↓ IoU@0.5m0.5\,m ↑ IoU@0.2m0.2\,m ↑ IoU@0.1m0.1\,m ↑ LiDAR 0.316 0.588 0.492 0.329 44.15 32.26 18.26 LiDAR + road 0.291 0.585 0.488 0.315 44.43 32.35 18.38 LiDAR + vehicle 0.307 0.584 0.488 0.325 44.71 32.77 18.53 All conditions 0.288 0.583 0.485 0.313 44.87 32.71 18.49 Table 10: Completion condition ablation on SemanticKITTI. The ablation shows that additional layout cues remain beneficial even when LiDAR observations are available. Among individual auxiliary cues, the road mask provides the largest improvement in BEV distributional alignment, reducing JSDBEVJSD_BEV from 0.329 to 0.315, while the vehicle mask improves local occupancy overlap. Combining all conditions gives the best CD, DCD, JSD3DJSD_3D, JSDBEVJSD_BEV, and IoU at 0.5m0.5\,m. The small trade-off between IoU at 0.2m0.2\,m and 0.1m0.1\,m suggests that road and vehicle cues mainly improve scene-level support while fine local overlap remains sensitive to point-level geometry. Table 11 reports LiDAR-free generation under road, vehicle, and joint road+vehicle conditions. Here ml=0m_l=0 because generation is intended to test weak condition synthesis rather than sparse scan completion. We use the fixed generation subsets defined in the dataset protocol. SemanticKITTI (Behley et al. 2019) is sampled every 10 frames and KITTI-360 (Liao et al. 2022) every 20 frames. Dataset Condition COV-CD ↑ MMD-CD ↓ 1-NNA-CD COV-EMD ↑ MMD-EMD ↓ 1-NNA-EMD SemanticKITTI Road 60.78 5.968 49.51 53.92 5.960 54.41 SemanticKITTI Vehicle 40.20 8.425 73.77 45.59 6.656 68.38 SemanticKITTI Road + vehicle 58.33 5.858 48.77 54.41 5.929 55.64 KITTI-360 Road 63.12 5.585 51.24 57.98 5.259 57.51 KITTI-360 Vehicle 46.77 7.086 72.34 46.39 5.721 72.81 KITTI-360 Road + vehicle 65.21 5.433 47.72 60.27 5.150 56.08 Table 11: Generation condition ablation. COV and 1-NNA are percentages. 1-NNA is best when closer to 50%50\%. Road conditioning is the strongest single layout cue because it constrains the global drivable support and therefore strongly reduces distributional ambiguity. Vehicle masks alone are more local. They guide object placement, but leave the global road structure less constrained, resulting in lower coverage and higher 1-NNA. Combining road and vehicle cues generally provides the most balanced behavior. On KITTI-360, the joint condition improves COV-CD from 63.12 to 65.21 and MMD-CD from 5.585 to 5.433 compared with road alone. On SemanticKITTI, the road-only and joint settings are close. The road-only condition is closest to the ideal CD side 1-NNA, while the joint condition gives the best CD side MMD. Independent Transport Diagnostic We also consider an intentionally weaker point-level pairing, denoted as independent transport. This diagnostic uses the same BEV source sampler ℛR as FPSGen, but removes the teacher-estimated clean endpoint matching. Let 0=p0,ii=1NP_0=\p_0,i\_i=1^N be the BEV-supported point source and let gt=pigti=1NP^gt=\p^gt_i\_i=1^N be the complete target point cloud in its stored point order. The independent transport path is formed by directly pairing these two unordered sets by index. tind=(1−t)0+tgt,uPind=gt−0.P^ind_t=(1-t)P_0+tP^gt, u^ind_P=P^gt-P_0. (28) Unlike the Approx OT teacher pair (0,1†)(P_0,P _1), this construction does not estimate a source-indexed clean endpoint. Since raw point clouds are unordered, the index wise target pigtp^gt_i is generally unrelated to the BEV anchor that produced p0,ip_0,i. The resulting velocity field therefore contains many long range and crossing motions, even though the source marginal itself remains BEV-supported. This diagnostic is different from the β-hybrid perturbation below. Hybrid coupling keeps the teacher-estimated clean endpoint unchanged and only mixes the local perturbation around each sampled BEV anchor. It weakens the source-to-endpoint coupling while preserving the BEV-supported point source marginal. Independent transport instead replaces the teacher-estimated clean endpoint with the original unordered target point set, thereby discarding the teacher’s local source-to-target relation. In our experiments this variant performs poorly, which supports the need for a source-indexed teacher mapping rather than a globally independent point set pairing. KPK_P CD ↓ DCD ↓ JSD3DJSD_3D ↓ JSDBEVJSD_BEV ↓ IoU@0.5m0.5\,m ↑ IoU@0.2m0.2\,m ↑ IoU@0.1m0.1\,m ↑ 1 5.728 0.966 0.798 0.754 4.30 3.38 2.41 2 1.925 0.855 0.722 0.576 14.81 9.59 4.99 4 0.795 0.814 0.701 0.465 18.64 10.95 5.24 8 0.623 0.804 0.695 0.422 19.70 11.32 5.38 16 0.623 0.814 0.702 0.420 19.10 10.82 5.21 32 0.659 0.831 0.712 0.437 17.68 9.83 4.85 50 0.680 0.838 0.717 0.447 16.94 9.37 4.70 Table 12: Independent transport diagnostic for SemanticKITTI completion. Lower is better for CD, DCD, JSD3DJSD_3D, and JSDBEVJSD_BEV. Higher is better for IoU. The full diagnostic shows a large gap between independent transport and the teacher-estimated pairing. Increasing KPK_P improves the independent transport variant from the degenerate one-step result, but it saturates around KP=8K_P=8 to 1616 and remains much worse than the Approx OT teacher-estimated coupling used by FPSGen. This is consistent with the intuition that index-wise pairing between unordered point sets creates unnecessarily long-range and crossing transport trajectories. More Euler steps can reduce discretization error, but they cannot recover the missing source-indexed endpoint relation. We also compare independent transport against BEV-local hybrid couplings at KP=50K_P=50 point-flow steps in Table 13. Within the BEV-local family, the hybrid perturbation coefficient β weakens the locally teacher-estimated coupling while preserving the BEV-supported point source marginal. The independent row is substantially worse than all BEV-local rows, showing that the source-indexed teacher endpoint is important for stable point transport. Among the BEV local variants, β=0β=0 gives the strongest distributional support metrics, while small nonzero perturbations can slightly improve point-level CD. Coupling β CD ↓ JSD3DJSD_3D ↓ JSDBEVJSD_BEV ↓ Independent – 0.6804 0.7165 0.4475 BEV local 0.00 0.3162 0.4922 0.3287 BEV local 0.01 0.3166 0.4928 0.3289 BEV local 0.05 0.3156 0.4925 0.3303 BEV local 0.20 0.3151 0.4923 0.3306 BEV local 1.00 0.3155 0.4928 0.3312 Table 13: Point-stage source-to-target coupling ablation on SemanticKITTI with KP=50K_P=50. Sinkhorn Approx OT Scalability Diagnostic Not-So-Optimal Transport Flows for 3D Point Cloud Generation studies an OT approximation motivated by the law of large numbers, where a much larger offline candidate set is sampled and the final point set is then drawn from it (Hui et al. 2025). In their object-scale setting, the final point cloud has 20482048 points while the offline pool contains 100,000100,000 candidates, giving a ratio of about 48.8×48.8×. We evaluate the same idea with a Sinkhorn-based approximation in our large scene setting using every 100th frame of SemanticKITTI sequence 08. Since our target point cloud contains 180,000180,000 points, we measure candidate pools up to 1.81.8 million points, corresponding to a 10×10× pool. The analogous 50×50× setting would require about 9.09.0 million candidates per scene. Method Ratio Points Time ↓ Disp. ↓ CD ↓ DCD ↓ Teacher-estimated clean endpoint – 180,000180,000 0.31 1.231 0.143 0.468 Sinkhorn Approx OT 1×1× 180,000180,000 27.57 1.851 0.146 0.374 Sinkhorn Approx OT 2×2× 360,000360,000 62.04 1.856 0.151 0.417 Sinkhorn Approx OT 4×4× 720,000720,000 161.10 1.850 0.153 0.435 Sinkhorn Approx OT 6×6× 1,080,0001,080,000 309.05 1.832 0.153 0.440 Sinkhorn Approx OT 10×10× 1,800,0001,800,000 762.97 1.815 0.154 0.445 Table 14: Sinkhorn Approx OT scalability diagnostic on SemanticKITTI sequence 08, averaged over scans sampled every 100 frames. Time is seconds per scene. Disp. is the mean transport displacement. CD denotes cdpcd_p. Ratio and points describe the Sinkhorn candidate pool size relative to the 180,000180,000 point target scene. Figure 4: Scaling behavior of the Sinkhorn Approx OT diagnostic. The teacher estimated clean endpoint is shown as a horizontal reference because it is measured only at the 180,000180,000 point scene scale and does not vary with the candidate pool ratio. Runtime grows rapidly with the candidate pool size, while the random candidate sampling protocol used by the large pool approximation slightly worsens CD and DCD in this scene scale setting. Table 14 and Figure 4 show that the Sinkhorn approximation is difficult to use as an online scene-scale pairing module. Even at the native 180,000180,000 point scale, the measured runtime is 27.5727.57 seconds per scene, about 89×89× slower than the amortized teacher-estimated clean endpoint construction. It also achieves CD comparable to the teacher-estimated endpoint construction rather than a clear geometric improvement, although the 1×1× Sinkhorn setting gives lower DCD. As the candidate pool grows from 1×1× to 10×10×, the runtime increases from 27.5727.57 to 762.97762.97 seconds. Meanwhile, the random sampling strategy used in the large candidate-pool approximation introduces additional sampling variation, and the measured CD and DCD become slightly worse rather than improving with more candidates. The offline candidate pool strategy is also impractical at SemanticKITTI scale. The measured 10×10× case already takes 762.97762.97 seconds, or 12.7212.72 minutes, for a single scene. The SemanticKITTI training split contains 19,13019,130 samples, so precomputing such approximate OT pairings would require roughly 4,0544,054 hours under the same measured setup. A 50×50× pool would require about 9.09.0 million candidates per scene and would further increase this cost. This is disproportionate for a pairing step and motivates our teacher-based Approx OT design, which amortizes the scene-scale correspondence problem while avoiding explicit Sinkhorn matching over millions of candidate points. Marginal Preservation of Hybrid Coupling We briefly justify the hybrid perturbation used in the β-ablation. Endpoint coupling choices are central in flow matching and conditional flow matching (Lipman et al. 2022; Tong et al. 2023). Hybrid and deliberately non-optimal source target couplings have recently been studied for point cloud flow models, where relaxing an exact OT coupling can make the learned transport easier to model (Hui et al. 2025). Our setting differs because the source is not sampled directly from an unconditional Gaussian. FPSGen first samples BEV grid anchors according to the normalized density channel D, and then adds coordinate noise. Thus, β is used here as a controlled diagnostic for weakening the local teacher-estimated coupling while preserving the BEV-supported point source marginal. For completeness, we restate the source distribution used in this analysis. Given a BEV prior B=[D,H,M]B=[D,H,M], the normalized density value D(q)∈[−1,1]D(q)∈[-1,1] at BEV cell q is converted to a nonnegative score ρD(q)=exp(D(q)+12log(1+nmax))−1, _D(q)= \! ( D(q)+12 (1+n_ ) )-1, (29) where nmaxn_ is the density clipping constant. Using the same BEV source sampler notation, the cell sampling probability is wD(q)=max(ρD(q),0)+εw∑q′(max(ρD(q′),0)+εw).w_D(q)= ( _D(q),0)+ _w _q ( ( _D(q ),0)+ _w). (30) Here εw>0 _w>0 is a small numerical stabilizer. A source point is obtained by sampling qi∼Cat(wD)q_i (w_D), mapping the cell to its zero-height metric anchor ai=pb(qi)=(x(qi),y(qi),0)a_i=p^b(q_i)=(x(q_i),y(q_i),0), and adding Gaussian perturbation ζi∼(0,Σ) _i (0, ), so that p0,i=ai+ζip_0,i=a_i+ _i. The covariance Σ is the coordinate noise covariance used by the BEV source sampler ℛR. For hybrid coupling, we keep the same sampled anchor and replace the perturbation by p~0,i(β)=ai+ζ~i(β),ζ~i(β)=1−βζi+βϵi, p_0,i^(β)=a_i+ ζ_i^(β), ζ_i^(β)= 1-β\, _i+ β\, _i, (31) where ϵi∼(0,Σ) _i (0, ) is an independent Gaussian perturbation and β∈[0,1]β∈[0,1]. Conditioned on the anchor aia_i, the mixed perturbation remains Gaussian. E[ζ~i(β)]=0,Cov[ζ~i(β)]=(1−β)Σ+βΣ=Σ. array[]lE[ ζ_i^(β)]=0,\\ Cov[ ζ_i^(β)]=(1-β) +β = . array (32) Therefore p~0,i(β)∣qi∼(ai,Σ) p_0,i^(β) q_i (a_i, ). Marginalizing over the density-sampled BEV cell gives pβ(x∣B)=∑qwD(q)(x;pb(q),Σ),p_β(x B)= _qw_D(q)\,N\! (x;p^b(q), ), (33) which is exactly the single-point marginal of the BEV-supported point source construction. Since the sampled cells and perturbations are independent across points, the same conclusion holds for the full point set under the product construction conditioned on B. It remains to verify that the clean-endpoint marginal is unchanged. Let Y=1†Y=P _1 denote the teacher-estimated clean endpoint paired with the original BEV-supported point source, and let A and Z collect the sampled anchors and original perturbations. The hybrid source ~0 P_0 is sampled from a conditional transition pβ(~0∣A,Z)p_β( P_0 A,Z) that integrates to one. Hence ∫pβ(~0,Y∣B¯,gt)~0=∫p(Y,A,Z∣B¯,gt)⋅[∫pβ(~0∣A,Z)~0]dAdZ=p(Y∣B¯,gt). array[]l p_β( P_0,Y B,P^gt)\,d P_0\\ = p(Y,A,Z B,P^gt)\\ · [ p_β( P_0 A,Z)d P_0 ]dA\,dZ\\ =p(Y B,P^gt). array (34) Thus, the hybrid perturbation changes the coupling between the BEV-supported point source and the teacher-estimated clean endpoint, while preserving the clean-endpoint marginal. The source remains the same BEV density mixture defined by wDw_D, and the target remains the same teacher-estimated clean endpoint distribution. The coefficient β therefore provides a controlled way to move from the teacher-aligned perturbation toward a less coupled perturbation while keeping the training marginals fixed. Hybrid Coupling Results Figure 5: Discrete trajectory curvature proxy per point along point transport paths for different β values under the generated BEV prior B B and the full condition state mlmvmr=111m_lm_vm_r=111. Curves are averaged over the 408 SemanticKITTI sequence 08 samples obtained by taking every 10th frame. Each trajectory uses 100 uniform integration steps, and each value is assigned to the midpoint between two adjacent recorded times. Figure 6: Jacobian Frobenius norm along point transport paths for different β values under the generated BEV prior B B and the full condition state mlmvmr=111m_lm_vm_r=111. Curves are averaged over the 408 SemanticKITTI sequence 08 samples obtained by taking every 10th frame, using 100 uniform integration steps and 4 Rademacher probes at each recorded state. Shaded regions show the measured variation across samples. We further analyze the point flow matching paths induced by different hybrid perturbation coefficients β∈0.0,0.01,0.05,0.2,1.0β∈\0.0,0.01,0.05,0.2,1.0\. This experiment complements the non-optimal coupling perspective of (Hui et al. 2025). Instead of assuming that a less coupled path is always preferable, we test how much coupling should be retained when the source already follows BEV scene support. We evaluate the fixed subset of 408 samples obtained by taking every 10th frame of SemanticKITTI sequence 08. For every sample, the point flow receives the generated BEV prior B B and the full condition state ml=mv=mr=1m_l=m_v=m_r=1, so Cm=(cl,cv,cr)C_m=(c_l,c_v,c_r). Each trajectory uses 100 uniform integration steps from the BEV-supported source endpoint t=0t=0 to the teacher-estimated clean endpoint t=1t=1. At every recorded state, we reevaluate the student velocity while keeping B B and CmC_m fixed. The Jacobian estimate uses Kprobe=4K_probe=4 independently sampled Rademacher probes and differentiates only with respect to the point cloud state. Let tit_i and ti+1t_i+1 be two adjacent recorded times, and let vi=vψ(ti,ti,B^,Cm)v_i=v_ψ(P_t_i,t_i, B,C_m) denote the predicted point velocity. Because the trajectory uses a uniform 100-step discretization, we use the squared finite difference of adjacent velocities as a discrete trajectory curvature proxy per point. κipoint=1N‖vi+1−vi‖F2. _i^point= 1N \|v_i+1-v_i \|_F^2. (35) Here N is the number of points and κipoint _i^point is plotted at the midpoint (ti+ti+1)/2(t_i+t_i+1)/2 in Figure 5. This finite-difference quantity measures velocity variation under the fixed uniform discretization. It is a trajectory curvature proxy rather than a parameterization-invariant geometric curvature. Let vec(⋅)vec(·) stack all point coordinates into a vector in ℝ3NR^3N. We also estimate the Jacobian of the vectorized point velocity field with respect to the vectorized point cloud state, Jt=∂vec(vψ(t,t,B^,Cm))∂vec(t).J_t= ∂\,vec (v_ψ(P_t,t, B,C_m) )∂\,vec(P_t). (36) Following the Hutchinson estimator (Hutchinson 1989), we use KprobeK_probe independent Rademacher probes zk∈−1,+13Nz_k∈\-1,+1\^3N and define ℓk(t)=zk⊤vec(vψ(t,t,B^,Cm)). _k(t)=z_k vec (v_ψ(P_t,t, B,C_m) ). (37) Automatic differentiation with respect to vec(t)vec(P_t) gives ∇vec(t)ℓk(t)=Jt⊤zk _vec(P_t) _k(t)=J_t z_k. The Jacobian Frobenius norm used in Figure 6 is then estimated by ‖J^t‖F=[1Kprobe∑k=1Kprobe‖∇vec(t)ℓk(t)‖22]1/2.\| J_t\|_F= [ 1K_probe _k=1^K_probe \| _vec(P_t) _k(t) \|_2^2 ]^1/2. (38) Figure 5 shows that β=0.0β=0.0 has a larger curvature proxy than the other locally perturbed variants before approximately t=0.8t=0.8. Near the clean endpoint, the values for β=0.01β=0.01, β=0.05β=0.05, and β=0.2β=0.2 become close to that of β=0.0β=0.0. The fully independent perturbation β=1.0β=1.0, however, increases sharply near t=1t=1. This indicates that making the source perturbation too independent creates a terminal segment with rapidly changing velocity, even though its early trajectory has smaller velocity variation. Figure 6 provides a complementary view of vector field complexity. The β=0.0β=0.0 field has the largest Jacobian Frobenius norm at the beginning of point transport, namely near t=0t=0, and decreases overall along the path. A high initial Jacobian means that the learned velocity is sensitive to small changes in the BEV supported point source. For an Euler update with interval Δt t, let δi _i denote a small state error and let eie_i denote the local velocity prediction error. Their first-order propagation is δi+1≈(I+ΔtJti)δi+Δtei. _i+1≈(I+ tJ_t_i) _i+ te_i. (39) A large Jacobian can therefore amplify an existing state error, while the additive term accumulates local velocity error across updates. This sensitivity-based explanation is consistent with the KP=2,4,8K_P=2,4,8 samplers in Table 21 underperforming the one-step endpoint update, although the Jacobian norm alone does not establish causality. The KP=16K_P=16 sampler recovers performance comparable to the one-step setting. The KP=32K_P=32 and KP=50K_P=50 samplers better resolve the path and improve CD and JSD3DJSD_3D, while the one-step setting retains the best JSDBEVJSD_BEV. The β=1.0β=1.0 Jacobian curve follows the opposite pattern. It is low near the source but grows rapidly near the endpoint, matching the terminal increase of the curvature proxy in Figure 5. The intermediate β values reduce the initial Jacobian relative to β=0.0β=0.0, but they do not improve the final completion metrics consistently. Thus, in our BEV-supported scene setting, weakening the local teacher-estimated coupling can smooth part of the trajectory, yet it also introduces less favorable endpoint behavior or weaker scene support. This supports the use of the most strongly coupled local construction, especially when one step or sufficiently resolved integration is used. Figure 7: Completion quality heatmaps over β and point-flow steps KPK_P. Panels (a)–(c) show CD, JSD3DJSD_3D, and JSDBEVJSD_BEV. Panels (d)–(f) show voxel IoU at 0.5m0.5\,m, 0.2m0.2\,m, and 0.1m0.1\,m. Several β values become competitive with enough point flow steps, while β=0.0β=0.0 provides an unusually strong one step result and recovers when the sampler uses larger KPK_P. Figure 7 summarizes the corresponding completion quality across β and point-flow step counts KPK_P. Panels (a)–(c) report CD, JSD3DJSD_3D, and JSDBEVJSD_BEV. Panels (d)–(f) report voxel IoU at 0.5m0.5\,m, 0.2m0.2\,m, and 0.1m0.1\,m. The heatmaps show that different β values can converge to competitive final completion quality when the point sampler is sufficiently resolved. Nevertheless, β=0.0β=0.0 is distinctive because it achieves a strong one-step result while also recovering at larger KPK_P. For this SemanticKITTI completion setting, the most coupled Approx OT variant performs better overall than deliberately independent transport. The BEV density prior already places source points near plausible scene support, so preserving the local teacher-estimated pairing reduces unnecessary long-range motion and gives a simpler one-step source-to-endpoint mapping. Endpoint CD Dynamics Figure 8: Endpoint CD estimated from free point flow states under the generated BEV prior B B, the full condition state mlmvmr=111m_lm_vm_r=111, and β=0.0β=0.0. At each recorded state, the remaining interval is directly extrapolated with the local point velocity, and the resulting endpoint is compared with the fixed teacher-estimated clean endpoint 1†P _1. The curves show an early increase in teacher endpoint error followed by recovery when the trajectory is resolved with enough point-flow steps. We analyze why a small number of point-flow steps can perform worse than either a direct one step update or a more finely resolved trajectory. This diagnostic uses the same fixed subset of 408 SemanticKITTI sequence 08 samples obtained by taking every 10th frame. As in the preceding path analysis, the point flow receives the generated BEV prior B B and the full condition state ml=mv=mr=1m_l=m_v=m_r=1, so Cm=(cl,cv,cr)C_m=(c_l,c_v,c_r). For each point step count KP∈2,4,8,16,32,50K_P∈\2,4,8,16,32,50\, let tfreeP^free_t denote a state reached by free Euler integration from the same BEV-supported point source. The teacher-estimated clean endpoint 1†P _1 associated with that source pair is held fixed as the reference. At every recorded state, we use the local velocity to directly predict the remaining displacement to the endpoint, ~1free(t)=tfree+(1−t)vψcfg(tfree,t,B^,Cm). array[]l P^free_1(t)=P^free_t+(1-t)\\[1.0pt] v^cfg_ψ (P^free_t,t, B,C_m ). array (40) We then measure the permutation-invariant endpoint error against the teacher estimated clean endpoint, EendCD(t)=CD(~1free(t),1†).E_end^CD(t)=CD ( P^free_1(t),P _1 ). (41) This quantity evaluates how accurately the vector field at the current free state recovers the endpoint assigned by the teacher-estimated pairing. It neither measures the geometric distance between the intermediate state and the transport path nor directly replaces the final CD to gtP^gt reported in the task evaluation. Figure 8 shows that all trajectories begin from the same one-step endpoint estimate, with CD to 1†P _1 close to 0.3190.319. For KP=4,8,16,32,50K_P=4,8,16,32,50, this teacher-endpoint error first increases and reaches approximately 0.3380.338 near t=0.2t=0.2 to 0.250.25. The early free states therefore imply less accurate direct recovery of the paired teacher endpoint than the original source state. After this transient growth, the curves decrease as integration proceeds. The KP=2K_P=2 and KP=4K_P=4 samplers provide too few evaluations through this correction region, and their final recorded states remain above the common source estimate. The KP=8K_P=8 trajectory only partially recovers. At KP=16K_P=16, endpoint CD falls below the one-step estimate, while KP=32K_P=32 and KP=50K_P=50 continue through the correction phase and reach the lowest errors. Their increasingly similar curves also indicate that the trajectory becomes better resolved as KPK_P grows. The source-side Jacobian behavior in Figure 6 is consistent with this two-phase pattern. The large Jacobian near t=0t=0 indicates that the predicted velocity is locally sensitive to changes in the initial point state, which can make the first few free updates enter a region with higher teacher-endpoint error. The subsequent decrease in endpoint CD provides direct set-level evidence that the learned field progressively recovers the teacher assigned endpoint rather than remaining uniformly unstable. This relationship should be interpreted as complementary evidence rather than a causal conclusion from the Jacobian alone. Overall, the diagnostic explains the non-monotonic step ablation as an interaction between an initially sensitive region and the number of updates available to complete the later trajectory correction. Runtime and Memory Benchmark Table 15 reports the single-GPU inference benchmark used in the scalability discussion. All methods are evaluated on SemanticKITTI (Behley et al. 2019) sequence 08 with the same 50m50m range, after 5 warmup samples and over 20 measured samples. The benchmark records wall clock inference time per scene and peak reserved GPU memory on a single RTX 3090 GPU. FPSGen runs the BEV flow and the student point flow at inference, so we report the two step counts separately. The other methods use a single point-stage sampler. The teacher network is used only during training. Method KBK_B KPK_P CD ↓ Inference Params (M) Time (s) ↓ Mem. (GB) ↓ LiDiff – 50 0.434 32.67 33.75 6.18 LiDPM – 20 0.446 32.67 20.92 5.53 ScoreLiDAR – 8 0.406 32.67 7.73 6.07 Distillation-DPO – 8 0.414 32.67 5.81 6.07 FPSGen 10 1 0.321 28.55 0.95 4.05 FPSGen 10 32 0.316 28.55 15.57 4.04 Table 15: Runtime and memory benchmark on SemanticKITTI sequence 08. Time is wall clock seconds per scene averaged over 20 measured samples after 5 warmup samples. Inference parameters are reported in millions, and memory is peak reserved GPU memory. FPSGen with KB=10K_B=10 and KP=1K_P=1 already obtains a CD close to the KP=32K_P=32 setting at substantially lower runtime. FPSGen is faster than LiDiff (Nunes et al. 2024) and LiDPM (Martyniuk et al. 2025) under the measured KB=10,KP=32K_B=10,K_P=32 setting, while also using less peak reserved memory. ScoreLiDAR (Zhang et al. 2025) and Distillation-DPO (Zhao et al. 2026) are faster in this benchmark because they use KP=8K_P=8, whereas FPSGen uses KB=10,KP=32K_B=10,K_P=32. The memory comparison is nevertheless favorable to FPSGen, with measured peak reserved GPU memory of about 4.044.04 GB compared with 5.535.53–6.186.18 GB for the completion baselines. Figure 9: Separate FPSGen runtime sweep over BEV-flow steps KBK_B and point flow steps KPK_P. Each cell reports average wall clock seconds per scene on one RTX 3090. We additionally measure FPSGen under different BEV-flow and point-flow step counts in a separate sweep. Figure 9 reports the average runtime per scene for this FPSGen-only evaluation. Runtime grows almost linearly with KPK_P, while increasing KBK_B adds a smaller but visible overhead. Across all tested FPSGen settings, peak reserved GPU memory ranges from 3.533.53 GB to 4.144.14 GB. Generation Results with DCD Table 16 supplements the main generation tables with DCD-based distributional metrics (Wu et al. 2021). DCD highlights whether a generated scene matches not only the nearest-neighbor geometry but also the density allocation of the reference point clouds. Dataset Protocol Method COV-DCD ↑ MMD-DCD ↓ 1-NNA-DCD SemanticKITTI Unconditional LiDiff 13.24 0.916 100.00 SemanticKITTI Unconditional LiDPM 16.91 0.825 99.88 SemanticKITTI Unconditional SemCity 19.36 0.816 99.63 SemanticKITTI Unconditional FPSGen 24.75 0.765 87.87 KITTI-360 Unconditional LiDiff 19.39 0.823 99.62 KITTI-360 Unconditional LiDPM 31.56 0.773 80.61 KITTI-360 Unconditional SemCity 16.16 0.816 99.71 KITTI-360 Unconditional FPSGen 24.90 0.764 73.76 KITTI-360 LiDM-seeded ScoreLiDAR 18.82 0.834 98.95 KITTI-360 LiDM seeded Distillation-DPO 16.73 0.835 99.14 KITTI-360 LiDM seeded LiDiff 17.49 0.846 99.71 KITTI-360 LiDM seeded LiDPM 18.44 0.846 99.71 KITTI-360 LiDM seeded FPSGen 30.04 0.781 85.93 Table 16: Additional generation metrics using DCD. COV and 1-NNA are percentages. 1-NNA is best when closer to 50%50\%. On SemanticKITTI (Behley et al. 2019), FPSGen improves all DCD-side metrics over LiDiff (Nunes et al. 2024), LiDPM (Martyniuk et al. 2025), and SemCity (Lee et al. 2024b), consistent with the CD/EMD trends in Table 8. On KITTI-360 (Liao et al. 2022), LiDPM obtains higher DCD coverage in the unconditional setting, while FPSGen obtains the best DCD MMD and the 1-NNA value closest to the ideal 50%50\%. SemCity is less competitive after converting its structured semantic output to voxel-center point clouds under this evaluation protocol. This representation mismatch should be considered when interpreting point-level distances, especially on KITTI-360 transfer. Under the KITTI-360 LiDM seeded protocol, FPSGen improves DCD coverage, DCD MMD, and DCD 1-NNA over the available completion baselines, indicating that the BEV-supported point transport better preserves balanced scene density after LiDM sparse scan seeding. We use LiDM (Ran et al. 2024) as an established scene level LiDAR generation baseline. Its sparse scan output provides a common input for testing how different completion pipelines expand generated observations into full scenes. Initialization Noise and DCD Table 17 reports the completion-side diagnostic for different initialization modes. The BEV source sampler denotes samples drawn from ℛ(B¯;N,Σ)R( B;N, ) as defined in the main paper. The LiDAR-derived initialization reduces CD because it starts from a scan-like support that is already close to the target surface. However, its DCD (Wu et al. 2021) is consistently worse than the BEV source sampler at matched step counts, showing that lower CD does not necessarily imply better density allocation. This supports our use of DCD as a complementary diagnostic. The BEV source sampler better preserves balanced scene density, while the LiDAR-derived initialization can concentrate points excessively around scan like structures. Init. KPK_P CD ↓ DCD ↓ JSD3DJSD_3D ↓ JSDBEVJSD_BEV ↓ BEV source sampler 1 0.3209 0.5933 0.4925 0.3272 LiDAR-derived 1 0.2699 0.6375 0.5144 0.3442 Gaussian 1 0.4899 0.7736 0.6360 0.4407 BEV source sampler 8 0.3213 0.6001 0.5006 0.3320 LiDAR-derived 8 0.2561 0.6343 0.5098 0.3444 Gaussian 8 0.3607 0.7807 0.6407 0.4240 BEV source sampler 32 0.3162 0.5878 0.4924 0.3292 LiDAR-derived 32 0.2562 0.6353 0.5114 0.3449 Gaussian 32 0.3337 0.7651 0.6299 0.4138 Table 17: Initialization noise diagnostic for SemanticKITTI completion. Lower is better for CD, DCD, JSD3DJSD_3D, and JSDBEVJSD_BEV. Generation BEV Flow Step Ablation Table 18 reports the generation side ablation of BEV flow sampling steps KBK_B while keeping the point flow step count fixed at KP=32K_P=32. This experiment is different from the completion side BEV step diagnostic in Table 20. Here the entire LiDAR-free generation pipeline is evaluated with distributional metrics (Achlioptas et al. 2018; Yang et al. 2019) on the fixed generation subsets. Dataset KBK_B COV-CD ↑ MMD-CD ↓ 1-NNA-CD COV-EMD ↑ MMD-EMD ↓ 1-NNA-EMD SemanticKITTI 10 19.61 7.637 87.50 19.85 7.694 92.03 SemanticKITTI 30 36.52 6.834 83.95 38.24 6.364 82.60 SemanticKITTI 50 41.67 6.517 79.04 45.59 6.132 79.53 KITTI-360 10 17.68 8.806 81.27 15.02 6.998 91.25 KITTI-360 30 35.17 7.850 76.71 37.64 6.045 80.13 KITTI-360 50 41.25 7.480 75.29 44.30 5.847 77.09 Table 18: Generation ablation over BEV flow steps KBK_B with KP=32K_P=32. COV and 1-NNA are percentages. 1-NNA is best when closer to 50%50\%. Increasing KBK_B from 10 to 50 consistently improves generation quality on both datasets. The effect is especially visible in coverage and 1-NNA, suggesting that the BEV prior needs enough integration steps to form a reliable global scene support before point level transport. On KITTI-360, COV-CD increases from 17.68 to 41.25 and 1-NNA-EMD improves from 91.25 to 77.09. On SemanticKITTI, COV-CD increases from 19.61 to 41.67 and 1-NNA-EMD improves from 92.03 to 79.53. Generation Point Flow Step Ablation Table 19 reports the SemanticKITTI (Behley et al. 2019) generation-side point-flow step ablation using the same COV, MMD, and 1-NNA protocol (Achlioptas et al. 2018; Yang et al. 2019). In this experiment, the BEV-flow step count is fixed at KB=50K_B=50, and only the point flow integration steps KPK_P are varied in 1,4,16,32,50\1,4,16,32,50\. This isolates how much multi-step point transport is needed after the BEV prior has already formed the global scene support. Dataset KPK_P COV-CD ↑ MMD-CD ↓ 1-NNA-CD COV-EMD ↑ MMD-EMD ↓ 1-NNA-EMD SemanticKITTI 1 41.42 6.587 80.88 45.59 6.132 80.02 SemanticKITTI 4 41.42 6.595 80.51 45.59 6.134 80.15 SemanticKITTI 16 41.67 6.529 79.29 45.59 6.131 79.53 SemanticKITTI 32 41.67 6.517 79.04 45.59 6.132 79.53 SemanticKITTI 50 41.67 6.512 79.17 45.59 6.132 79.53 Table 19: Generation ablation over point flow steps KPK_P with KB=50K_B=50 on SemanticKITTI. COV and 1-NNA are percentages. 1-NNA is best when closer to 50%50\%. This ablation complements Table 18. The BEV step ablation studies whether the global support prior is sufficiently sampled, whereas the point-step ablation studies whether the point velocity field benefits from finer integration after the source points are already initialized from the generated BEV prior. Most coverage metrics saturate early once the BEV prior is fixed at 50 steps, while MMD-CD changes only slightly and reaches its lowest value at KP=50K_P=50. This suggests that the BEV stage dominates global support formation, and additional point flow steps mainly improve distributional alignment rather than changing the covered support. Completion BEV Flow Step Ablation Table 20 studies the number of BEV-flow steps KBK_B while keeping the point-flow step count fixed at KP=32K_P=32. With one BEV step, CD, DCD, and JSD3DJSD_3D are substantially worse than at larger step counts. Increasing KBK_B to 5–10 sharply improves these metrics. Further increasing KBK_B to 25 or 50 yields only marginal changes. We therefore use a moderate BEV step count in the default configuration to balance generation quality and sampling cost. KBK_B CD ↓ DCD ↓ JSD3DJSD_3D ↓ JSDBEVJSD_BEV ↓ 1 0.4397 0.6694 0.5966 0.3319 5 0.3159 0.5889 0.4941 0.3264 10 0.3162 0.5878 0.4924 0.3292 25 0.3196 0.5887 0.4931 0.3329 50 0.3219 0.5897 0.4941 0.3344 Table 20: SemanticKITTI completion ablation over BEV flow steps with KP=32K_P=32. Lower is better. Completion Point Flow Step Ablation KPK_P CD ↓ JSD3DJSD_3D ↓ JSDBEVJSD_BEV ↓ 1 0.3207 0.4929 0.3275 2 0.3263 0.5039 0.3316 4 0.3271 0.5090 0.3336 8 0.3209 0.5009 0.3320 16 0.3172 0.4945 0.3303 32 0.3161 0.4924 0.3292 50 0.3162 0.4922 0.3287 Table 21: SemanticKITTI completion ablation over point flow steps under the default Approx OT teacher estimated coupling. Lower is better. Table 21 reports the completion-side point flow step ablation for the default Approx OT teacher-estimated coupling. The one step sampler is already strong because the BEV-supported point source and teacher-estimated clean endpoint define a simple local endpoint map. More point steps are not monotonically better at small counts, but 16–50 steps recover stable CD and JSD values as the sampler better resolves the full transport path. Implementation Details To support reproducibility, we will release the training code, evaluation scripts, and configuration files upon acceptance. Dataset Processing Training split. FPSGen is trained once on SemanticKITTI (Behley et al. 2019) sequences 00–07 and 09–10, following the split used by prior LiDAR completion work such as LiDiff and LiDPM (Nunes et al. 2024; Martyniuk et al. 2025). This training split contains 19,13019,130 samples. The BEV flow, teacher, and student point flow are all trained on this split, and the same trained model is used for SemanticKITTI completion, SemanticKITTI generation, and cross-dataset evaluation on KITTI-360 (Liao et al. 2022). No component is retrained on sequence 08 or KITTI-360. Completion evaluation. SemanticKITTI sequence 08 contains 4,0714,071 test samples (Behley et al. 2019). For LiDAR conditioned completion, the raw LiDAR scan is the sparse input, and the complete target is prepared by aggregating neighboring scans into a dense scene under the same completion protocol as prior LiDAR completion work (Nunes et al. 2024; Martyniuk et al. 2025). To make the comparison with LiDiff and related completion baselines fair, we keep the same range cropping, coordinate convention, and evaluation preparation as the LiDiff setting. The full completion comparison evaluates all frames in sequence 08. The KITTI-360 validation set contains 10,51510,515 samples (Liao et al. 2022), and we use it as a cross-dataset evaluation setting under the same metric definitions. For completion ablations on SemanticKITTI and KITTI-360, we evaluate one frame every 10 frames. Adjacent LiDAR scans in driving sequences are highly similar, and the 10 frame interval provides a representative estimate while reducing repeated evaluation on near-duplicate scans. Generation evaluation. Evaluation is performed on fixed held-out subsets to avoid adjacent frame redundancy. On SemanticKITTI (Behley et al. 2019) sequence 08, we select one frame every 10 frames, yielding 408 reference samples. We use this subset for the in-domain generation comparison and the SemanticKITTI generation ablations. On KITTI-360 (Liao et al. 2022), we select one frame every 20 frames, yielding 526 reference samples, and use this as the cross-dataset generation evaluation. All generation metrics use the same spatial range and evaluation configuration. For the LiDiff and LiDPM unconditional diagnostics, we set the condition state to empty and replace their partial-scan repetition source with a LiDAR-free BEV Gaussian source. Their trained denoisers and point sampling schedules remain unchanged. The SemanticKITTI generation comparison uses these matched LiDAR-free logs together with FPSGen and the SemCity baseline processed as described below. The KITTI-360 comparison uses the corresponding formal KITTI-360 logs under the same protocol. In the KITTI-360 LiDM seeded diagnostic, LiDM (Ran et al. 2024) first generates sparse LiDAR scans, and completion baselines complete these scans into full point clouds over the same 526 frame KITTI-360 subset. SemCity baseline processing. For SemCity (Lee et al. 2024b), we follow its triplane autoencoder and diffusion training pipeline. The autoencoder is trained first, triplane features are extracted with the last numerically stable checkpoint, and the diffusion model is then trained on the saved triplane representation. SemCity natively generates a local semantic occupancy scene of approximately 51.2m×51.2m51.2m× 51.2m, corresponding to a 256×256×32256× 256× 32 voxel grid with 0.2m0.2m voxel size. To match our 100m×100m100m× 100m evaluation region, we first generate a seed scene, expand it to about 102.4m×102.4m102.4m× 102.4m using the model’s outpainting capability in multiple directions, and then center-crop the result to 100m×100m100m× 100m. The final sample keeps only voxels inside a radius of 50m50m around the scene origin. We convert SemCity semantic occupancy outputs to point clouds by using voxel centers. The horizontal voxel size is 0.2m0.2m. For the vertical coordinate, directly using the raw voxel index gives a poor alignment with SemanticKITTI style point clouds, so we apply a vertical offset and use z=0.2iz−2.0z=0.2\,i_z-2.0, where izi_z is the vertical voxel index. This substantially improves the generated z distribution, although the final point cloud metrics remain weak. Since SemCity outputs voxel-center point clouds while the references are raw LiDAR point clouds, CD, EMD, DCD, and related point metrics can be harsher than semantic occupancy quality alone would suggest. KITTI-360 results should be interpreted as cross-dataset transfer, because SemCity is primarily designed for SemanticKITTI style scenes. Condition protocol. We separate conditions by their strength and intended task. The sparse LiDAR scan is a strong geometric condition because it directly anchors observed surfaces and is therefore used for completion and completion side ablations. Road and vehicle masks are weaker layout conditions because they constrain scene support, drivable regions, and object locations, but do not specify complete 3D geometry. We therefore use them to evaluate flexible generation without LiDAR. During BEV flow and point flow training, each sample independently draws one of the eight possible mask states with equal probability, i.e., each LiDAR/vehicle/road combination has probability 12.5%12.5\%. Any inactive condition is replaced by a zero tensor. In the notation Cm=(mlcl,mvcv,mrcr)C_m=(m_lc_l,m_vc_v,m_rc_r), completion ablations compare LiDAR-active settings with or without auxiliary layout cues, while generation ablations evaluate LiDAR-free settings with road, vehicle, or joint layout cues. This protocol avoids conflating LiDAR conditioned completion with LiDAR free scene synthesis while ensuring that both networks see unconditional, layout-only, LiDAR-only, and mixed condition cases during training. (ml,mv,mr)∼Unif(0,13).(m_l,m_v,m_r) \! (\0,1\^3 ). (42) Layout mask construction. The layout conditions cvc_v and crc_r are derived from ground-truth semantic labels and are used only as coarse BEV constraints. For each scene, we first select points whose semantic labels belong to the target layout group, discard their z-coordinates, and project their xyxy-coordinates onto the same 256×256256× 256 BEV grid used by the BEV flow. A grid cell is marked as occupied for a layout channel if at least one selected point falls into that cell; otherwise, it is set to zero. This gives a multi-channel binary layout tensor clayout∈0,1C×256×256c_layout∈\0,1\^C× 256× 256, where the default channels correspond to vehicle and road/ground. ck(q)=[∃i:ℓi∈k,Π(xi,yi)=q],k∈v,r.c_k(q)=I\! [∃ i: _i _k,\; (x_i,y_i)=q ], k∈\v,r\. (43) Here, [⋅]I[·] denotes the indicator function, which equals 11 when the condition inside the brackets is true and 0 otherwise. The variable ℓi _i is the semantic label of point i, kY_k is the label set for layout class k, and Π maps metric xyxy-coordinates within a 50m50\,m radius of the scene origin to a BEV cell q. For SemanticKITTI (Behley et al. 2019), the vehicle channel includes moving and static vehicle-related labels, while the road/ground channel includes road, other ground, sidewalk, and parking labels. For KITTI-360 (Liao et al. 2022), the vehicle channel includes car, truck, bus, caravan, trailer, and train labels, while the road/ground channel includes road, sidewalk, and parking. During network input preparation, inactive layout channels are replaced by zeros according to the sampled mask variables, while active layout masks are linearly mapped to the same [−1,1][-1,1] range as the BEV target channels. Guidance scales. We apply classifier-free guidance (CFG) (Ho and Salimans 2022) to both flow stages. For all non-empty condition settings, including LiDAR-conditioned completion, layout conditioned generation, and mixed condition generation, we use scales sB=sP=2s_B=s_P=2 for the BEV flow and point flow. For unconditional generation, both scales are set to 0, so sampling follows the unconditional branch without amplifying a nonexistent conditioning signal. Integration step notation. Throughout the paper, KBK_B and KPK_P denote the number of forward Euler steps used by the BEV flow and point flow, respectively. This stage-specific notation avoids ambiguity in the ablation and runtime comparisons. BEV target normalization. For BEV flow training, each complete point cloud is rasterized into density, maximum-height, and occupancy mask channels, following the common use of BEV representations for autonomous driving perception (Lang et al. 2019). Density is computed by counting points in each BEV cell and applying log normalization after clipping by the maximum density. The height channel stores the maximum z value in each occupied cell, rather than the mean height. Empty cells are assigned height −1-1, and the occupancy mask is mapped from 0,1\0,1\ to −1,1\-1,1\. Consequently, all three BEV target channels are in the [−1,1][-1,1] range used by flow matching. During sampling with the BEV source sampler ℛR, sampled grid cells are converted back to physical xyxy coordinates in meters, while the BEV tensor provided to the point flow remains in the normalized [−1,1][-1,1] scale. For a BEV cell q, let n(q)n(q) be its point count, zmax(q)z (q) be its maximum height, and m(q)=[n(q)>0]m(q)=1[n(q)>0] be its occupancy indicator. With density clipping constant nmaxn_ , minimum height zminz_ , and height range Δz z, the target channels are D(q) D(q) =2log(1+minn(q),nmax)log(1+nmax)−1, =2 \! (1+ \n(q),n_ \ ) (1+n_ )-1, (44) H(q) H(q) =m(q)(2zmax(q)−zminΔz−1)−(1−m(q)), =m(q) (2 z (q)-z_ z-1 )- (1-m(q) ), M(q) M(q) =2m(q)−1. =2m(q)-1. Network Details Figure 10: Architecture of the BEV flow model. (a) The condition fusion block converts LiDAR and layout inputs into multi-scale BEV condition features. (b) The ResBlock used in the U-Net is a stage-level conditional block that first fuses the scale-matched condition feature by channel concatenation and 1×11× 1 projection, then applies time-conditioned residual convolutional updates. (c) The BEV flow pipeline stacks these conditional ResBlocks with downsampling, upsampling, skip connections, and spatial AdaLN transformer blocks to predict the BEV velocity field. Both network stages are implemented as conditional flow matching models, following the simulation-free velocity regression formulation of flow matching and rectified flows (Lipman et al. 2022; Liu et al. 2022). Architecturally, the BEV flow follows the image generation practice of combining convolutional U-Nets, time-conditioned residual blocks, and attention-based bottlenecks (Ronneberger et al. 2015; Ho et al. 2020; Vaswani et al. 2017; Peebles and Xie 2023). Unlike latent diffusion models that first compress images into a learned VAE latent space (Rombach et al. 2022), our BEV representation is a low-resolution 256×256256× 256 tensor with density, height, and mask channels. We therefore generate directly in BEV pixel space without introducing an additional learned reconstruction objective. BEV flow model. The main paper defines the BEV flow objective and its role in the two-stage sampler. Here we specify the implementation used to predict u^B=vϕ(Bτ,τ,Cm) u_B=v_φ(B_τ,τ,C_m). In this expression, BτB_τ is the intermediate BEV state at flow time τ, and vϕv_φ is the BEV velocity network. The network receives the active condition tuple CmC_m, builds multi-scale BEV condition features, and predicts the velocity field of the density, height, and occupancy-mask channels. Fig. 10 summarizes the BEV flow model. We use three components, including a condition fusion block that builds multi-scale BEV features, a time-conditioned convolutional U-Net that preserves local spatial detail, and an adaptive Layer Normalization (AdaLN) transformer bottleneck that models long-range interaction across road and object regions. The condition fusion block first maps the optional LiDAR condition into a 256×256256× 256 pseudo-image with a Mini-PointPillar encoder, inspired by the BEV pillar representation used in PointPillars (Lang et al. 2019). The encoder uses EdgeConv style k-nearest neighbor (kNN) aggregation (Wang et al. 2019) with k=16k=16 local neighbors and outputs a 32-channel BEV feature aligned with the layout masks. The masks ml,mv,mrm_l,m_v,m_r are applied before this fusion. At training time each mask triplet is sampled with probability 12.5%12.5\%, and inactive branches are replaced by zeros. Therefore the same BEV architecture learns unconditional, LiDAR-only, layout-only, and mixed-condition priors without changing its input interface. eij=[pj−pi,pi],j∈k(i),ℓi=maxj∈k(i)MLPe(eij),ai=[pi,pi−p¯qi,(xi,yi)−g(qi),ℓi],ui=PFN(ai),Epc(l)q,c=maxi:qi=qui,c. gatherede_ij=[p_j-p_i,p_i], j _k(i),\\ _i= _j _k(i)MLP_e(e_ij),\\ a_i= [p_i,\;p_i- p_q_i,\;(x_i,y_i)-g(q_i),\; _i ],\\ u_i=PFN(a_i),\\ E_pc(P^l)_q,c= _i:q_i=qu_i,c. gathered (45) Here pi=(xi,yi,zi)p_i=(x_i,y_i,z_i) is a LiDAR point, k(i)N_k(i) is its k-nearest neighbor set, eije_ij is an edge feature, and ℓi _i is the local geometry feature obtained by max pooling over neighboring features. The grid index qiq_i is obtained by projecting (xi,yi)(x_i,y_i) onto the BEV grid, p¯qi p_q_i is the mean point in the same pillar, and g(qi)g(q_i) is the metric center of that BEV cell. The augmented point feature aia_i combines absolute coordinates, pillar-relative offsets, cell-center offsets, and kNN geometry. A point feature network (PFN) maps aia_i to uiu_i, and dynamic max scatter over points in each grid cell forms the LiDAR BEV feature Epc(l)E_pc(P^l). This Mini-PointPillar encoder keeps the projection lightweight while preserving local 3D neighborhood information that would be lost by simple point counting. The LiDAR BEV feature is then concatenated with the active layout channels and passed through a four-level convolutional encoder. We denote its outputs by F1,…,F4F_1,…,F_4, corresponding to the c1,…,c4c_1,…,c_4 features in Fig. 10. F0=concat(mlEpc(l),mvcv,mrcr),Fi=CNNi(Fi−1),CNNi(x)=Conv3×3(SiLU(GN(hi))),hi=Conv3×3si(x). gatheredF_0=concat\! (m_lE_pc(P^l),m_vc_v,m_rc_r ),\\ F_i=CNN_i(F_i-1),\\ CNN_i(x)=Conv_3× 3\! (SiLU\! (GN(h_i) ) ),\\ h_i=Conv_3× 3^s_i(x). gathered (46) Here F0F_0 is the concatenated condition map, FiF_i is the i-th multi-scale condition feature, EpcE_pc denotes the Mini-PointPillar encoder, hih_i is an intermediate feature inside the convolutional neural network (CNN) block, s1=1s_1=1, and si=2s_i=2 for i>1i>1. ConvConv, GNGN, and SiLUSiLU denote convolution, Group Normalization, and the SiLU activation function. When LiDAR is unavailable, the LiDAR branch is inactive according to CmC_m, and the condition encoder uses the available layout channels. The feature hierarchy has channel widths [32,64,128,256][32,64,128,256] and resolutions 2562,1282,642,256^2,128^2,64^2, and 32232^2. This hierarchy matches the different spatial roles of the conditions. Road masks provide global drivable support, vehicle masks provide localized object priors, and LiDAR features provide measured geometric anchors. The flow time τ is encoded before being injected into the residual and transformer blocks. We use a sinusoidal embedding with frequencies on the standard 1000010000 based log scale, following the positional encoding convention used in transformer models (Vaswani et al. 2017), after scaling τ to the training time interval. γ(τ)=[sin(1000τωk),cos(1000τωk)]k=0127,ωk=exp(−klog10000127),τemb=W2SiLU(W1γ(τ)). gatheredγ(τ)= [ (1000τ _k), (1000τ _k) ]_k=0^127,\\ _k= \! (- k 10000127 ),\\ _emb=W_2\,SiLU\! (W_1γ(τ) ). gathered (47) Here γ(τ)γ(τ) is the sinusoidal time embedding, ωk _k is the k-th frequency, and W1,W2W_1,W_2 are learned linear projections. The projected 256-dimensional vector τemb _emb is the shared temporal code used by all BEV residual blocks and the AdaLN transformer bottleneck. The BEV velocity predictor is a U-Net style encoder–decoder (Ronneberger et al. 2015). The noisy BEV state BτB_τ is first projected by an input convolution. In Fig. 10, each ResBlock denotes a stage-level conditional residual block. It contains a condition fusion layer and two time-conditioned residual updates. Let FuseiFuse_i denote the condition fusion layer at scale i. It concatenates the current U-Net feature h with the scale-matched condition feature FiF_i along the channel dimension, then projects the concatenated feature back to the U-Net feature width. Fusei(h,Fi)=SiLU(Conv1×1(concat(h,Fi))),Fuse_i(h,F_i)=SiLU\! (Conv_1× 1\! (concat(h,F_i) ) ), (48) The fused feature is then processed by time-conditioned residual units. For a feature map x, each residual unit is implemented as h1=Conv1(SiLU(GN(x))),h2=h1+Wτ(τemb),Res(x,τemb)=Conv2(SiLU(GN(h2)))+Shortcut(x). gatheredh_1=Conv_1\! (SiLU(GN(x)) ),\\ h_2=h_1+W_τ( _emb),\\ Res(x, _emb)=Conv_2\! (SiLU(GN(h_2)) )+Shortcut(x). gathered (49) Here WτW_τ is a learned linear projection from the time embedding to the block width, and ShortcutShortcut is either the identity mapping or a 1×11× 1 convolution when the channel width changes. Thus, a stage-level ResBlock in the figure can be written compactly as ri,1=Resi,1(Fusei(h,Fi),τemb),ri,2=Resi,2(ri,1,τemb). gatheredr_i,1=Res_i,1\! (Fuse_i(h,F_i), _emb ),\\ r_i,2=Res_i,2\! (r_i,1, _emb ). gathered (50) The encoder uses channel widths [32,64,128,256][32,64,128,256]. Both ri,1r_i,1 and ri,2r_i,2 are stored as down to up skip features at the same resolution. During decoding, the feature at the corresponding resolution is concatenated with these stored skip features before the two residual updates. h~i,1=concat(hi↑,ri,2),r~i,1=Resi,1↑(Fusei(h~i,1,Fi),τemb),h~i,2=concat(r~i,1,ri,1),r~i,2=Resi,2↑(h~i,2,τemb). gathered h_i,1=concat(h_i ,r_i,2),\\ r_i,1=Res_i,1 \! (Fuse_i( h_i,1,F_i), _emb ),\\ h_i,2=concat( r_i,1,r_i,1),\\ r_i,2=Res_i,2 \! ( h_i,2, _emb ). gathered (51) Here hi↑h_i is the decoder feature at the matching resolution, and r~i,2 r_i,2 is followed by nearest neighbor upsampling and a convolution except at the final resolution. This explicitly links the downsampling and upsampling paths and preserves local BEV detail while the bottleneck handles long range interaction. At the 32×3232× 32 bottleneck, we add a learned 2D positional embedding and apply eight spatial AdaLN transformer blocks. This design follows the transformer attention mechanism (Vaswani et al. 2017) and the AdaLN style conditioning used in diffusion transformers (Peebles and Xie 2023), while keeping the surrounding encoder–decoder convolutional structure for local BEV detail. Let z be the flattened bottleneck feature with size Nb×Lb×CbN_b× L_b× C_b, where NbN_b, LbL_b, and CbC_b denote batch size, spatial token length, and channel width. Let zcz_c be the flattened condition feature from F4F_4. A time multilayer perceptron (MLP) predicts adaptive Layer Normalization (LN) parameters and residual gates. (δa,αa,ga,δm,αm,gm)=chunk(WdSiLU(τemb)).( _a, _a,g_a, _m, _m,g_m)=chunk\! (W_d\,SiLU( _emb) ). (52) Here WdW_d is a learned linear projection, chunkchunk splits its output into six equal width vectors, δ, α, and g denote shift, scale, and gate parameters, and the subscripts a and m correspond to the attention and MLP branches. Each AdaLN transformer block then performs multi-head self-attention (MSA), multi-head cross-attention (MCA), and an MLP update. z~a=LN(z)(1+αa)+δa,z′=z+gaMSA(z~a),z′=z′+MCA(LN(z′),zc,zc),z~m=LN(z′)(1+αm)+δm,zout=z′+gmMLP(z~m). gathered z_a=LN(z)(1+ _a)+ _a,\\ z =z+g_a\,MSA( z_a),\\ z =z +MCA\! (LN(z ),z_c,z_c ),\\ z_m=LN(z )(1+ _m)+ _m,\\ z_out=z +g_m\,MLP( z_m). gathered (53) In Eq. (53), z~a z_a and z~m z_m are the modulated attention and MLP inputs, and z′z , z′z , and zoutz_out denote the intermediate and output token features. We use eight attention heads and a four-times expansion ratio in the MLP. The AdaLN parameters make the bottleneck explicitly time-dependent, while cross-attention keeps the long range BEV reasoning anchored to the condition hierarchy. At the model interface, the BEV velocity predictor uses the variables defined for the BEV flow. u^B=vϕ(Bτ,τ,Cm). u_B=v_φ\! (B_τ,τ,C_m ). (54) The internal features F1,…,F4F_1,…,F_4 are not additional external conditions. They are implementation-level representations of CmC_m used by the condition fusion layers and AdaLN transformer blocks. The final convolutional head predicts the BEV velocity field, which is integrated to obtain the generated BEV prior B B. Point flow network. The main paper defines the point flow with the training-time BEV prior B¯ B and the inference-time generated BEV prior B B. This subsection gives the deployed sparse U-Net and condition modulation details. We use a sparse point backbone similar in spirit to the completion networks used by LiDiff, LiDPM, and ScoreLiDAR (Nunes et al. 2024; Martyniuk et al. 2025; Zhang et al. 2025), and extend it with BEV and layout aware modulation so that the same point flow can operate under LiDAR, layout, mixed, and unconditional settings. The backbone is an instance-normalized sparse 3D U-Net. Sparse convolution is used because outdoor driving scenes are mostly empty in 3D, making dense volumetric convolution inefficient. This follows the sparse convolutional design commonly used for large-scale 3D point scenes (Choy et al. 2019). The input point state tP_t is voxelized into a sparse tensor S0S_0, then processed by a sparse convolutional stem. S0=Stem(t).S_0=Stem(P_t). (55) The encoder has four downsampling stages, and the decoder has four transposed convolution upsampling stages with skip connections. We use sparse residual blocks with instance normalization in both directions. For an encoder level l, with the stage-wise gate wlw_l defined below, the sparse feature update is S~l=Sl⊙wl,Sl+1=Downl(S~l). gathered S_l=S_l w_l,\\ S_l+1=Down_l( S_l). gathered (56) For the decoder, the upsampled sparse feature is concatenated with the encoder feature at the matching resolution. Y~l=Yl⊙wl↑,Yl−1↑=Upl(Y~l),Yl−1=Resl↑(Yl−1↑⊕Sl−1). gathered Y_l=Y_l w_l ,\\ Y_l-1 =Up_l( Y_l),\\ Y_l-1=Res_l \! (Y_l-1 S_l-1 ). gathered (57) Here SlS_l and YlY_l are encoder and decoder sparse tensors, wl↑w_l is the decoder-side gate at level l, ⊙ denotes channel-wise multiplication on sparse features, and ⊕ denotes sparse tensor concatenation at matching coordinates. The channel layout is a reduced-width variant of the LiDiff/LiDPM sparse U-Net family (Nunes et al. 2024; Martyniuk et al. 2025). While the original completion backbones commonly use [32,32,64,128,256,256,128,96,96][32,32,64,128,256,256,128,96,96], our student point flow uses [16,16,32,64,128,64,64,48,48][16,16,32,64,128,64,64,48,48]. Thus the widest bottleneck is reduced from 256 to 128 channels and the decoder/output feature widths are also narrowed. This reduction is important because the student is evaluated repeatedly under different condition modes and sampling steps. A lighter sparse backbone keeps flexible generation practical while preserving the same encoder–decoder topology. The final multilayer perceptron (MLP) head maps 48→32→348→ 32→ 3 to predict a 3D velocity. The main architectural difference from a LiDAR completion sparse denoiser is the stage-wise condition modulation. This modulation is driven by three condition streams, namely a sparse point anchor encoder, a BEV support encoder, and a layout mask encoder. The point anchor encoder processes the active sparse point condition. In LiDAR conditioned modes, the anchor is the sparse LiDAR scan. In LiDAR-free modes, the LiDAR branch is zeroed by the mask. During teacher training, the teacher uses the clean target point cloud to construct the teacher-estimated endpoint pairing, as described below. The student anchor encoder is a reduced width instance-normalized sparse encoder. S0a=Stem(a),Si+1a=Encia(Sia),i=0,…,3,Sa=S4a. gatheredS^a_0=Stem(P^a),\\ S^a_i+1=Enc^a_i(S^a_i), i=0,…,3,\\ S^a=S^a_4. gathered (58) Here aP^a is the active sparse point anchor after mask application, StemStem contains two sparse convolutions with instance-normalization and ReLU activations, and each EnciaEnc^a_i contains a stride 2 sparse convolution block followed by two instance normalized residual blocks. The encoder uses the same reduced channel sequence [16,16,32,64,128][16,16,32,64,128] as the point flow encoder, so the anchor representation is lightweight but spatially aligned with the sparse U-Net. For compact implementation notation, let B⋆=B¯B_ = B during student training and B⋆=B^B_ = B during inference. This alias is used only in this implementation description, and it refers to the ground truth BEV prior or the generated BEV prior defined in the main paper. We encode the density, height, and mask BEV tensor and the layout mask tensor with two lightweight feature pyramid encoders. GB=EB(B⋆),GM=EM([mvcv,mrcr]). gatheredG^B=E_B(B_ ),\\ G^M=E_M([m_vc_v,m_rc_r]). gathered (59) Both EBE_B and EME_M are convolutional feature pyramid encoders with strides (1,2,2,2)(1,2,2,2). The main BEV stream GBG^B has 64 channels and carries density, height, and occupancy information. The mask stream GMG^M has 16 channels and carries road and vehicle layout cues. Each encoder first builds bottom-up features and then uses lateral 1×11× 1 projections with top down upsample add fusion. XB=B⋆,XM=[mvcv,mrcr],C0s=ConvStage0s(Xs),Cis=ConvStageis(Ci−1s),i∈1,2,3,Q3s=Lat3s(C3s),Qis=Smoothis(Latis(Cis)+Up(Qi+1s)),i∈2,1,0,s∈B,M. gatheredX^B=B_ , X^M=[m_vc_v,m_rc_r],\\ C_0^s=ConvStage_0^s(X^s),\\ C_i^s=ConvStage_i^s(C_i-1^s), i∈\1,2,3\,\\ Q_3^s=Lat_3^s(C_3^s),\\ Q_i^s=Smooth_i^s\! (Lat_i^s(C_i^s)+Up(Q_i+1^s) ),\\ i∈\2,1,0\, s∈\B,M\. gathered (60) Here XsX^s is the input tensor of stream s, CisC_i^s is its bottom-up feature, QisQ_i^s is the corresponding top-down feature, LatisLat_i^s is a lateral 1×11× 1 projection, and UpUp denotes bilinear upsampling. The deployed point flow uses the full-resolution outputs GB=Q0BG^B=Q_0^B and GM=Q0MG^M=Q_0^M. At every sparse U-Net stage, these shared maps are sampled at the current sparse coordinates. To avoid overloading the layout projection operator Π , we denote this sparse-aligned BEV sampling operation by Πsp(Sl,G) _sp(S_l,G). Then blB=ProjlB(Πsp(Sl,GB)),blM=ProjlM(Πsp(Sl,GM)). gatheredb_l^B=Proj_l^B\! ( _sp(S_l,G^B) ),\\ b_l^M=Proj_l^M\! ( _sp(S_l,G^M) ). gathered (61) Here ProjlBProj_l^B and ProjlMProj_l^M are level-specific linear projections. The operator Πsp _sp converts sparse voxel coordinates back to metric xyxy locations and indexes the corresponding BEV cell, so the BEV condition is spatially aligned with the active sparse support instead of being pooled into a global vector. The point flow also uses a time embedding and a matched sparse anchor feature. It uses the same sinusoidal construction as the BEV flow with a separate 48-dimensional code that matches the sparse U-Net feature scale. The code is projected independently at each level. γP(t)=[sin(1000tωkP),cos(1000tωkP)]k=023,ωkP=exp(−klog1000023),elt=Tl(γP(t)). gathered _P(t)= [ (1000t _k^P), (1000t _k^P) ]_k=0^23,\\ _k^P= \! (- k 1000023 ),\\ e_l^t=T_l( _P(t)). gathered (62) Here γP(t) _P(t) is the 48-dimensional point flow time code, ωkP _k^P is its k-th frequency, and TlT_l is the learned projection at sparse U-Net level l. The matched anchor feature ala_l is obtained by nearest neighbor matching between the current sparse coordinates and the sparse point anchor feature SaS^a. al=Al(Match(Sl,Sa)).a_l=A_l\! (Match(S_l,S^a) ). (63) Here SaS^a denotes the sparse anchor tensor used by the point network, MatchMatch returns the nearest anchor feature for each active sparse coordinate, and AlA_l is a level-specific projection. The stage-wise gate is then predicted from four aligned signals, namely the matched sparse anchor, the transport time, the BEV support feature, and the layout feature. wl=Wl([al,elt,blB,blM]),S~l=Sl⊙wl. gatheredw_l=W_l\! ([a_l,e_l^t,b_l^B,b_l^M] ),\\ S_l=S_l w_l. gathered (64) Here WlW_l is the level-specific gating network. The same modulation form is applied at the four encoder levels and the four decoder levels. This gives every sparse convolutional stage access to condition information at the correct spatial support and temporal position. In compact form, the point velocity predictor is u^P=vψ(t,t,B⋆,Cm),u^P=Head(SparseUNetψ(t;wll)). gathered u_P=v_ψ(P_t,t,B_ ,C_m),\\ u_P=Head\! (SparseUNet_ψ(P_t;\w_l\_l) ). gathered (65) This formulation makes the role of the point flow complementary to the BEV flow. The sparse U-Net and its skip connections preserve local 3D geometry, the BEV streams provide global support and layout alignment, and the time embedding specifies the current location along the flow path. We use the instance-normalized variant because the point network sees heterogeneous condition mixtures within training batches. Instance normalization is less sensitive to batch composition than batch normalization in this setting. This is an implementation choice for flexible condition generation rather than a limitation of LiDiff or ScoreLiDAR, which remain strong LiDAR completion architectures. Teacher network. The teacher network is used only during training to construct the source-to-target supervision for the student point flow. Architecturally, it follows a LiDiff-style sparse network (Nunes et al. 2024) but removes the diffusion time encoding branch. Because the teacher is not used at inference, we keep it as a higher capacity full width sparse network, while the deployed student uses the reduced width point flow described above. Given a noisy source point set and a complete target scene, the teacher estimates a direct displacement toward the target. In teacher training, the complete point cloud is provided as the sparse anchor input rather than a partial scan. Let 0P_0 denote the noisy BEV-supported point source and gtP^gt the complete target point cloud. Following the notation used throughout the paper, the teacher predicts a displacement field toward the clean endpoint. 1†=0+Γη(0,gt).P _1=P_0+ _η\! (P_0,P^gt ). (66) Here Γη _η is the teacher displacement network with parameters η. The target side anchor gtP^gt gives the teacher direct access to the destination geometry, so the teacher learns an approximate source-to-target correspondence rather than a completion model conditioned on a sparse observation. Using the same notation, the teacher objective is Chamfer distance plus a local repulsion term on the teacher-estimated clean endpoint 1†P _1. ℒT=EB¯,gt,0[CD(1†,gt)+λrepℒrep]. array[]lL_T=E_ B,P^gt,P_0\\[1.0pt] [CD(P _1,P^gt)+ _repL_rep ]. array (67) The local repulsion term is applied to the teacher-estimated clean endpoint. ℒrep=1N∑i=1Nmax(0,rrep−‖pi†−pν(i)†‖2).L_rep= 1N _i=1^N \! (0,\,r_rep- \|p_i -p_ν(i) \|_2 ). (68) Here pi†∈1†p_i _1, ν(i)ν(i) is the nearest neighbor index of pi†p_i within 1†∖pi†P _1 \p_i \, rrep=0.2mr_rep=0.2\,m is the repulsion radius, and λrep=0.5 _rep=0.5 is the loss weight. We also monitor a displacement excess diagnostic that compares the predicted displacement magnitude with the nearest target distance, but the teacher objective used for the reported model combines CD with the repulsion regularizer. After training, the teacher is not used at inference. It only provides the endpoint displacement or paired target direction used to train the time-dependent student velocity field. Training Schedule FPSGen is trained in three stages that match the factorized generation pipeline. We first train the BEV flow for 500 epochs to learn the density, height, and mask prior under the sampled condition tuple CmC_m. We then train the teacher transport network for 5 epochs, using the ground truth BEV prior B¯ B and the complete scene gtP^gt to produce source-to-target training pairs. Finally, we train the student point flow for 10 epochs on these teacher-estimated pairs. This staged schedule separates global BEV support learning, correspondence construction, and time-dependent point transport so that each component is optimized with its own objective. Stage Epochs Batch Optimizer and schedule BEV flow 500 8 AdamW, 10−410^-4, warmup+cosine Teacher 5 2 Adam, 10−310^-3, ExpLR γ=0.8γ=0.8 Student 10 2 Adam, 10−410^-4, ExpLR γ=0.8γ=0.8 Table 22: Optimization settings for the three training stages. For the BEV flow, we use AdamW with betas (0.9,0.999)(0.9,0.999), weight decay 10−410^-4, and an initial learning rate of 10−410^-4. The learning rate is updated every optimization step, with a linear warmup for the first 1000 steps followed by cosine decay. For the teacher and student point networks, we use Adam with betas (0.9,0.999)(0.9,0.999). The teacher uses learning rate 10−310^-3 and is trained for 5 epochs. The student uses learning rate 10−410^-4, sets max_epoch=10max\_epoch=10, and is trained for 10 epochs. Both point networks use an exponential learning rate scheduler with multiplicative factor γ=0.8γ=0.8 applied once per epoch. Hardware and timing. All training experiments are conducted on two NVIDIA RTX 3090 GPUs. Testing and metric computation are run on a single RTX 3090 GPU for all methods and ablations. For timing related measurements, we keep the evaluation machine otherwise idle and disable unrelated user programs, so the reported runtime numbers are measured under a consistent single GPU environment. Evaluation Metrics This section specifies the metrics used in the completion and generation experiments. The completion metrics follow recent LiDAR scene completion evaluations (Nunes et al. 2024; Martyniuk et al. 2025; Zhang et al. 2025; Zhao et al. 2026). The generation metrics follow point cloud distributional evaluation with matched generated and reference sets (Achlioptas et al. 2018; Yang et al. 2019). Completion Metrics Chamfer Distance. Given a predicted complete point cloud †=pi†i=1NpredP =\p_i \_i=1^N_pred and a ground-truth complete point cloud gt=pjgtj=1NgtP^gt=\p_j^gt\_j=1^N_gt, Chamfer Distance (CD) (Akmal Butt and Maragos 1998; Achlioptas et al. 2018) measures their bidirectional nearest-neighbor discrepancy: CD(†,gt) (P ,P^gt) =1Npred∑i=1Npredmin1≤j≤Ngt‖pi†−pjgt‖2 = 1N_pred _i=1^N_pred _1≤ j≤ N_gt \|p_i -p_j^gt \|_2 (69) +1Ngt∑j=1Ngtmin1≤i≤Npred‖pjgt−pi†‖2. + 1N_gt _j=1^N_gt _1≤ i≤ N_pred \|p_j^gt-p_i \|_2. Lower CD indicates better point-level geometric alignment. For completion evaluation, †P denotes the completed scene, while gtP^gt denotes the aggregated ground-truth complete scene. Density-aware Chamfer Distance. CD can be dominated by nearest neighbor proximity and may under-penalize uneven point density. We therefore also report Density-aware Chamfer Distance (DCD) (Wu et al. 2021) in the supplementary diagnostics. For two point sets X=xii=1NXX=\x_i\_i=1^N_X and Y=yjj=1NYY=\y_j\_j=1^N_Y, let πXY(i) _XY(i) =argminj‖xi−yj‖22, = *arg\,min_j \|x_i-y_j \|_2^2, (70) πYX(j) _YX(j) =argmini‖yj−xi‖22. = *arg\,min_i \|y_j-x_i \|_2^2. be nearest neighbor assignments from X to Y and from Y to X, respectively. Let diX→Y=‖xi−yπXY(i)‖22d_i^X→ Y=\|x_i-y_ _XY(i)\|_2^2 and djY→X=‖yj−xπYX(j)‖22d_j^Y→ X=\|y_j-x_ _YX(j)\|_2^2. Define the assignment counts cjY c_j^Y =|i∣πXY(i)=j|, = |\i _XY(i)=j\ |, (71) ciX c_i^X =|j∣πYX(j)=i|. = |\j _YX(j)=i\ |. With exponent λ=1λ=1, numerical stabilizer εdcd=10−6 _dcd=10^-6, and size factors γX→Y=NY/NX _X→ Y=N_Y/N_X and γY→X=NX/NY _Y→ X=N_X/N_Y, the density weights are wiX→Y w_i^X→ Y =γX→Y(cπXY(i)Y)λ+εdcd, = _X→ Y(c_ _XY(i)^Y)^λ+ _dcd, (72) wjY→X w_j^Y→ X =γY→X(cπYX(j)X)λ+εdcd. = _Y→ X(c_ _YX(j)^X)^λ+ _dcd. The DCD with scale α is DCDα(X,Y)=12[1NX∑i(1−e−αdiX→YwiX→Y)+1NY∑j(1−e−αdjY→XwjY→X)]. array[]lDCD_α(X,Y)= 12 [ 1N_X _i (1-e^-α d_i^X→ Yw_i^X→ Y )\\ + 1N_Y _j (1-e^-α d_j^Y→ Xw_j^Y→ X ) ]. array (73) Lower DCD indicates better joint agreement in geometry and density. We use α=1α=1 for all reported DCD evaluations, matching the evaluation implementation. 3D and BEV Jensen-Shannon Divergence. Jensen-Shannon Divergence (JSD) measures the discrepancy between occupancy distributions (Menéndez et al. 1997). For JSD3DJSD_3D, predicted and ground truth scenes are voxelized in 3D and aggregated into normalized occupancy histograms. For JSDBEVJSD_BEV, points are projected to the ground plane before constructing BEV occupancy histograms. For normalized histograms p and q, JSD(p,q)=12KL(p∥m)+12KL(q∥m),m=12(p+q). array[]lJSD(p,q)= 12KL(p\,\|\,m)+ 12KL(q\,\|\,m), m= 12(p+q). array (74) Here KLKL denotes Kullback–Leibler divergence. Lower JSD indicates better spatial distribution matching. Voxel IoU. Voxel intersection over union (IoU) is commonly used for evaluating occupancy prediction and LiDAR scene completion (Roldao et al. 2020; Nunes et al. 2024; Martyniuk et al. 2025). We compute voxel IoU at resolutions r∈0.5,0.2,0.1mr∈\0.5,0.2,0.1\\,m. Let Vr(^)V_r( P) and Vr(gt)V_r(P^gt) denote the occupied voxel sets obtained by voxelizing the prediction and ground truth at resolution r, respectively. Then, IoUr=|Vr(^)∩Vr(gt)||Vr(^)∪Vr(gt)|.IoU_r= |V_r( P)∩ V_r(P^gt)||V_r( P)∪ V_r(P^gt)|. (75) Following OPUS (Wang et al. 2024), we apply 3D morphological closing, implemented as max-pool dilation followed by erosion, to each occupancy grid before computing IoU. Specifically, we use kernel sizes 1,3,5\1,3,5\ for voxel sizes 0.5,0.2,0.1m\0.5,0.2,0.1\\,m, respectively. Thus, no morphological operation is applied at 0.5m0.5\,m. Larger IoU indicates better spatial overlap. Voxel IoU at 0.5m0.5\,m emphasizes scene-level coverage, whereas voxel IoU at 0.1m0.1\,m is more sensitive to fine-grained geometric alignment. Generation Metrics For generation evaluation, let =Xii=1NsetG=\X_i\_i=1^N_set and =Yjj=1NsetT=\Y_j\_j=1^N_set denote the generated and reference point-cloud sets, respectively. Each XiX_i or YjY_j is a point cloud in ℝ3R^3. Before computing pairwise distances, all generated and reference scenes are processed using identical sampling and coordinate-normalization procedures to obtain the same fixed point budget NpointN_point, such that |Xi|=|Yj|=Npoint|X_i|=|Y_j|=N_point. We use d(⋅,⋅)d(·,·) to denote a distance between two point clouds, instantiated by Chamfer Distance (CD), Earth Mover’s Distance (EMD), or Density-aware Chamfer Distance (DCD). Following the standard point-cloud generation evaluation protocol, we report Coverage (COV) and Minimum Matching Distance (MMD) (Achlioptas et al. 2018), together with 1-nearest neighbor accuracy (1-NNA) (Yang et al. 2019). All methods are evaluated using the same generated-set size, reference set, point-cloud preprocessing, accelerated CD implementation, and approximate EMD solver. Earth Mover’s Distance. For two equal-cardinality point clouds X=xii=1NpointX=\x_i\_i=1^N_point and Y=yjj=1NpointY=\y_j\_j=1^N_point, the normalized Earth Mover’s Distance is theoretically defined as the minimum average transportation cost over all bijective correspondences (Rubner et al. 2000; Achlioptas et al. 2018): EMD(X,Y)=minφ∈Bij(X,Y)1Npoint∑x∈X‖x−φ(x)‖2,EMD(X,Y)= _ (X,Y) 1N_point _x∈ X \|x- (x) \|_2, (76) where Bij(X,Y)Bij(X,Y) denotes the set of all bijections from X to Y, and ∥⋅∥2\|·\|_2 denotes the Euclidean norm. In practice, we approximate the optimal correspondence using a GPU-accelerated soft matching solver. To improve numerical consistency, the input coordinates are first divided by a fixed normalization range RmaxR_ : x~i=xiRmax,y~j=yjRmax. x_i= x_iR_ , y_j= y_jR_ . (77) The approximate matching solver produces a nonnegative soft matching matrix ^=[m^ij]∈ℝNpoint×Npoint M=[ m_ij] ^N_point× N_point, where m^ij m_ij denotes the matching weight assigned between x~i x_i and y~j y_j. The total matching cost returned by the solver is MatchCost(X~,Y~)=∑i=1Npoint∑j=1Npointm^ij‖x~i−y~j‖2.MatchCost ( X, Y )= _i=1^N_point _j=1^N_point m_ij \| x_i- y_j \|_2. (78) Accordingly, the approximate normalized EMD reported in our experiments is computed as EMD^(X,Y) EMD(X,Y) =RmaxNpointMatchCost(X~,Y~) = R_ N_pointMatchCost ( X, Y ) =RmaxNpoint∑i=1Npoint∑j=1Npointm^ij‖x~i−y~j‖2 = R_ N_point _i=1^N_point _j=1^N_point m_ij \| x_i- y_j \|_2 =1Npoint∑i=1Npoint∑j=1Npointm^ij‖xi−yj‖2. = 1N_point _i=1^N_point _j=1^N_point m_ij \|x_i-y_j \|_2. (79) We set Rmax=50R_ =50 in all experiments. Multiplication by RmaxR_ restores the matching cost to the original coordinate scale, while division by NpointN_point yields the average matching cost per point. Lower EMD indicates a smaller average transportation distance between the two point clouds and therefore better globally matched geometry. The same approximate matching solver and solver settings are used for all evaluated methods. Coverage. Coverage (COV) measures the fraction of reference point clouds that are selected as the nearest neighbor of at least one generated point cloud (Achlioptas et al. 2018). For each generated point cloud X∈X , we define its nearest reference point cloud under distance d as NNd(X;)∈argminY∈d(X,Y),N_d(X;T)∈ _Y d(X,Y), (80) where ties, if any, are resolved using a fixed deterministic rule. Coverage is then computed as COVd(,)=|NNd(X;):X∈|||.COV_d(G,T)= | \N_d(X;T)\,:\,X \ ||T|. (81) The set operation in the numerator removes repeated selections, so a reference point cloud selected by multiple generated samples is counted only once. Higher COV indicates that the generated set covers a larger fraction of the reference set and generally reflects greater generation diversity. However, COV alone does not measure the geometric quality of the corresponding nearest-neighbor matches. When reported as a percentage, the value in Eq. (81) is multiplied by 100100. Minimum Matching Distance. Minimum Matching Distance (MMD) measures how closely the reference point clouds are approximated by the generated set (Achlioptas et al. 2018). For each reference point cloud, it finds the nearest generated point cloud and then averages the corresponding distances: MMDd(,)=1||∑Y∈minX∈d(Y,X).MMD_d(G,T)= 1|T| _Y _X d(Y,X). (82) Lower MMD indicates that samples in the reference set are more closely approximated by samples in the generated set. Since the matching is performed from the reference set to the generated set, generated samples that are not selected as the nearest neighbor of any reference sample are not directly penalized by MMD. Here, MMD refers to Minimum Matching Distance rather than Maximum Mean Discrepancy. 1-Nearest Neighbor Accuracy. The 1-nearest neighbor accuracy (1-NNA) is a classifier-based two-sample test commonly used for point-cloud generation evaluation (Yang et al. 2019). It measures whether generated and reference point clouds can be distinguished according to their local neighborhoods. Let =⊔S=G denote the labeled disjoint union of the generated and reference sets, where ⊔ preserves the source label of each sample. We define the binary source label as y(Z)=0,Z∈,1,Z∈.y(Z)= cases0,&Z ,\\ 1,&Z . cases (83) For each point cloud Z∈Z , its leave-one-out nearest neighbor is defined as NNd(Z):=argminZ′∈∖Zd(Z,Z′).N_d(Z):= Z \Z\ \,d(Z,Z ). (84) The predicted label of Z is given by the source label of its nearest neighbor. The 1-NNA score is then computed as 1-NNAd(,)=1||+||∑Z∈[y(Z)=y(NNd(Z))].1 -NNA_d(G,T)= 1|G|+|T| _Z I\! [y(Z)=y\! (N_d(Z) ) ]. (85) Here, [⋅]I[·] denotes the indicator function, which equals 11 when the condition inside the brackets is true and 0 otherwise. Because the generated and reference sets are balanced, ||=||=Nset|G|=|T|=N_set, a 1-NNA score close to 50%50\% indicates that generated and reference samples are difficult to distinguish. In contrast, a score substantially above 50%50\%, approaching 100%100\%, indicates a larger distributional discrepancy. Therefore, a score closer to 50%50\% is preferred. Additional Qualitative Comparisons This section collects additional qualitative comparisons under matched camera, range, point size, and color settings. The visualizations complement CD (Achlioptas et al. 2018), DCD (Wu et al. 2021), JSD (Menéndez et al. 1997), and IoU (Roldao et al. 2020; Nunes et al. 2024) by exposing the geometric alignment, point density, and scene support patterns that contribute to these aggregate metrics. Flow Matching Trajectory Visualization Figure 11 provides a qualitative demonstration of the two flow matching stages (Lipman et al. 2022; Liu et al. 2022) in FPSGen. The upper panel shows the BEV flow trajectory from the noisy state Bτ=0B_τ=0 to the generated BEV prior B B. The lower panel shows the point flow trajectory from the inference source 0init=ℛ(B^;N,Σ)P_0^init=R( B;N, ) to the generated point cloud P. This visualization complements the architecture and quantitative ablations by showing that FPSGen first builds scene-level support in BEV space and then forms detailed geometry through point-level transport. Figure 11: Flow matching trajectory visualization. Panel (a), BEV Flow Trajectory, illustrates transport from Bτ=0B_τ=0 to the generated BEV prior B B. Panel (b), Point Flow Trajectory, illustrates the subsequent transport from 0initP_0^init to the generated point cloud P. Flexible-Condition FPSGen Visualizations FPSGen supports all eight combinations of LiDAR, vehicle, and road conditions through the active condition tuple Cm=(mlcl,mvcv,mrcr)C_m=(m_lc_l,m_vc_v,m_rc_r). We denote a condition code by the binary triplet mlmvmrm_lm_vm_r, where the first digit indicates whether the LiDAR condition is active, the second digit indicates the vehicle mask, and the third digit indicates the road mask. Table 23 summarizes the resulting condition settings. Code LiDAR Vehicle Road Setting 000 – – – Unconditional 001 – – Yes Road only 010 – Yes – Vehicle only 011 – Yes Yes Layout only 100 Yes – – LiDAR only 101 Yes – Yes LiDAR + road 110 Yes Yes – LiDAR + vehicle 111 Yes Yes Yes All conditions Table 23: Condition code convention for flexible FPSGen visualization. The three digits in mlmvmrm_lm_vm_r correspond to LiDAR, vehicle, and road conditions. Figures 12 and 13 show representative flexible condition generation results on KITTI-360 (Liao et al. 2022). The LiDAR-free cases 000000, 001001, 010010, and 011011 illustrate flexible generation from weak or absent conditions. The LiDAR-active cases 100100, 101101, 110110, and 111111 show how the same model transitions back to completion-like behavior when a strong geometric condition is available. Road masks mainly constrain global drivable support, vehicle masks localize object regions, and LiDAR anchors observed geometry. Figure 12: Flexible condition FPSGen visualization on KITTI-360 (Liao et al. 2022), part I. Each panel corresponds to one condition code mlmvmrm_lm_vm_r, where the digits denote LiDAR, vehicle, and road conditions. The comparison shows how weak layout cues guide scene-level generation even without a LiDAR input. Figure 13: Flexible condition FPSGen visualization on KITTI-360 (Liao et al. 2022), part I. Adding LiDAR changes the task from weakly conditioned generation toward completion, while road and vehicle masks provide complementary layout control over drivable regions and object placement. A Toy Example of Layout Control Figure 14: A toy example of vehicle layout control. The upper row shows (a) FPSGen Vehicle Layout, where the vehicle-only condition 010010 forms the six letters “FPSGEN.” The lower row shows (b) FPSGen Generated Point Cloud. The generated scenes preserve the prescribed letter-level support while synthesizing three dimensional road surfaces, objects, and vertical geometry without LiDAR or road cues. We construct an artificial vehicle layout in which occupied regions form the six letters “FPSGEN.” This example uses the vehicle only condition code 010010, equivalently Cm=(0,cv,0)C_m=(0,c_v,0), without LiDAR or road cues. Unlike the dataset-derived layouts above, this text-shaped mask deliberately departs from typical road scene configurations and therefore serves as a qualitative stress test of spatial controllability. Figure 14 shows that the generated point clouds retain recognizable letter silhouettes, including curved boundaries, diagonal strokes. At the same time, the outputs are not flat copies of the binary masks. FPSGen expands the two-dimensional layouts into three-dimensional scenes containing road-like surfaces, object clusters, and vertical structures. The result indicates that the vehicle cue can influence global scene support rather than only local object placement, while the learned BEV and point priors supply plausible geometry around the imposed arrangement. This toy example is intended as a controllability demonstration rather than a text generation benchmark or evidence of exact mask reconstruction. Completion Visualizations Figure 15 compares the input LiDAR scan, the ground truth, and available completion outputs from LiDiff (Nunes et al. 2024), LiDPM (Martyniuk et al. 2025), ScoreLiDAR (Zhang et al. 2025), Distillation-DPO (Zhao et al. 2026), and FPSGen. The matched renderings expose whether each method recovers distant occluded regions, preserves road-level support, and avoids concentrating completed points around the observed scan. Figure 15: Additional LiDAR-conditioned completion visualization on SemanticKITTI (Behley et al. 2019) sequence 08. The comparison uses the same viewpoint and rendering setup as the SemanticKITTI completion visualization in the paper and further illustrates how different source constructions affect occluded scene recovery and global point support. LiDM-Seeded Visualizations We further visualize the LiDM seeded generation diagnostic in Figure 16. In this protocol, LiDM (Ran et al. 2024) first generates a sparse LiDAR scan, and each completion pipeline then converts this sparse scan into a complete scene. We use LiDM as an established scene level LiDAR generation baseline whose sparse output provides a common stress test for completion-based generation pipelines. The visual comparison separates the LiDM generated input from the ability of each completion pipeline to expand that input into a complete point cloud. The comparison includes available outputs from completion baselines and FPSGen under the same rendering setup. Figure 16: LiDM (Ran et al. 2024) seeded generation pipeline visualization. LiDM provides the sparse generated scan, while different completion pipelines expand the same sparse input into complete point clouds. The comparison highlights whether the completion stage preserves global scene support instead of only densifying the local observed structure. Limitations and Future Work Temporal consistency and condition scope. FPSGen improves flexible-condition LiDAR scene generation by combining BEV-level support generation with point-level transport, but several limitations remain. Our current evaluation focuses on static scene geometry. Dynamic temporal consistency across generated sequences is not explicitly modeled, so extending the framework from independent frames to temporally coherent driving clips is an important direction. Although FPSGen supports multiple condition types, the current experiments mainly use LiDAR, vehicle masks, and road masks. Richer map elements, object-level controls, text prompts, and multi-agent traffic constraints would make the generator more useful for simulation and data augmentation. BEV anisotropy. The BEV representation is especially well matched to autonomous driving scenes, where the spatial extent is dominated by the horizontal ground plane and the vertical range is comparatively limited (Lang et al. 2019). This anisotropic structure makes BEV support generation efficient and provides a useful inductive bias for road layouts, object placement, and LiDAR point allocation. However, the same factorization can become restrictive in scenes with richer vertical structure, such as indoor environments, multi-level buildings, or other settings where the z axis variation is comparable to the horizontal extent. Extending FPSGen to such domains may require volumetric, multiplane, or adaptive 3D support representations rather than a single BEV prior with density, height, and mask channels. Approx OT characterization. Our Approx OT construction currently uses a teacher network as a practical amortized surrogate for large-scale scene matching, in contrast to explicit or large-pool OT approximations for point cloud flow models (Hui et al. 2025). This avoids explicit OT over hundreds of thousands of points, but the teacher-estimated coupling is still only an approximation and its optimality is not deeply characterized. A more systematic study of teacher matching quality, error propagation from teacher-estimated clean endpoints to student flow fields, and stronger correspondence objectives could further clarify when the learned coupling is reliable. Point flow scalability. The point flow stage still relies on sparse convolutional processing (Choy et al. 2019) and nearest neighbor matching between BEV and sparse coordinates. This is effective for scene-scale point clouds, but it can be computationally expensive when scaling to denser targets or longer-range sensors. Future work could explore hierarchical tokenization, adaptive point budgets, or streaming generation to reduce sampling cost. Downstream utility. While DCD (Wu et al. 2021) and occupancy-based metrics reveal important density and support differences, they do not fully measure downstream utility. A natural next step is to evaluate generated scenes by training or stress testing perception models, where controllable rare case generation may be more important than marginal improvements in geometric distances. References P. Achlioptas, O. Diamanti, I. Mitliagkas, and L. Guibas (2018) Learning representations and generative models for 3d point clouds. In Proceedings of the 35th International Conference on Machine Learning, p. 40–49. Cited by: Tasks, Datasets, and Metrics, Generation BEV Flow Step Ablation, Generation Point Flow Step Ablation, Completion Metrics, Generation Metrics, Generation Metrics, Generation Metrics, Generation Metrics, Evaluation Metrics, Additional Qualitative Comparisons. M. Akmal Butt and P. Maragos (1998) Optimum design of chamfer distance transforms. IEEE Transactions on Image Processing 7 (10), p. 1477–1484. External Links: Document Cited by: Tasks, Datasets, and Metrics, Completion Metrics. J. Behley, M. Garbade, A. Milioto, J. Quenzel, S. Behnke, C. Stachniss, and J. Gall (2019) SemanticKITTI: a dataset for semantic scene understanding of LiDAR sequences. In Proceedings of the IEEE/CVF International Conference on Computer Vision, External Links: Link Cited by: Tasks, Datasets, and Metrics, SemanticKITTI Generation Comparison, Generation Results with DCD, Generation Point Flow Step Ablation, Condition Ablations, Condition Ablations, Runtime and Memory Benchmark, Dataset Processing, Dataset Processing, Dataset Processing, Dataset Processing, Figure 15. C. Choy, J. Gwak, and S. Savarese (2019) 4D spatio-temporal convnets: minkowski convolutional neural networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 3075–3084. Cited by: Limitations and Future Work, Network Details. J. Ho, A. Jain, and P. Abbeel (2020) Denoising diffusion probabilistic models. Advances in Neural Information Processing Systems 33, p. 6840–6851. Cited by: Network Details. J. Ho and T. Salimans (2022) Classifier-free diffusion guidance. arXiv preprint arXiv:2207.12598. External Links: Link Cited by: Dataset Processing. Y. Huang, A. Thammatadatrakoon, W. Zheng, Y. Zhang, D. Du, and J. Lu (2024a) GaussianFormer-2: probabilistic gaussian superposition for efficient 3d occupancy prediction. arXiv preprint arXiv:2412.04384. Cited by: Related Work. Y. Huang, W. Zheng, Y. Zhang, J. Zhou, and J. Lu (2024b) GaussianFormer: scene as gaussians for vision-based 3d semantic occupancy prediction. arXiv preprint arXiv:2405.17429. Cited by: Related Work. K. Hui, C. Liu, X. Zeng, C. Fu, and A. Vahdat (2025) Not-so-optimal transport flows for 3d point cloud generation. arXiv preprint arXiv:2502.12456. External Links: Link Cited by: Limitations and Future Work, Sinkhorn Approx OT Scalability Diagnostic, Marginal Preservation of Hybrid Coupling, Hybrid Coupling Results. M. F. Hutchinson (1989) A stochastic estimator of the trace of the influence matrix for laplacian smoothing splines. Communications in Statistics—Simulation and Computation 18 (3), p. 1059–1076. External Links: Document Cited by: Hybrid Coupling Results. A. Joshi, J. Ost, and F. Heide (2026) WorldFlow3D: flowing through 3d distributions for unbounded world generation. External Links: 2603.29089, Link Cited by: Related Work. A. H. Lang, S. Vora, H. Caesar, L. Zhou, J. Yang, and O. Beijbom (2019) PointPillars: fast encoders for object detection from point clouds. In 2019 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), Vol. , p. 12689–12697. External Links: Document Cited by: Limitations and Future Work, Dataset Processing, Network Details. J. Lee, S. Lee, C. Jo, W. Im, J. Seon, and S. Yoon (2024a) SemCity: semantic scene generation with triplane diffusion. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, Cited by: Introduction, Related Work. J. Lee, S. Lee, C. Jo, W. Im, J. Seon, and S. Yoon (2024b) SemCity: semantic scene generation with triplane diffusion. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 28337–28347. External Links: Link Cited by: Baselines and Main Results, SemanticKITTI Generation Comparison, Generation Results with DCD, Dataset Processing. B. Li, J. Guo, H. Liu, Y. Zou, Y. Ding, X. Chen, H. Zhu, F. Tan, C. Zhang, T. Wang, S. Zhou, L. Zhang, X. Qi, H. Zhao, M. Yang, W. Zeng, and X. Jin (2025a) UniScene: unified occupancy-centric driving scene generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 11971–11981. Cited by: Related Work. B. Li, X. Jin, H. Zhu, H. Liu, R. Li, J. Guo, K. Cai, C. Ma, Y. Jin, H. Zhao, X. Yang, and W. Zeng (2025b) Scaling up occupancy-centric driving scene generation: dataset and method. arXiv preprint arXiv:2510.22973. Cited by: Related Work. P. Li, R. Zhao, Y. Shi, H. Zhao, J. Yuan, G. Zhou, and Y. Zhang (2023a) LODE: locally conditioned eikonal implicit scene completion from sparse lidar. In ICRA, Cited by: Baselines and Main Results, KITTI-360 Completion Comparison. S. Li, C. Yang, J. Fang, T. Yi, J. Lu, J. Cen, L. Xie, W. Shen, and Q. Tian (2026) WorldGrow: generating infinite 3d world. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 40, p. 6433–6441. External Links: Document Cited by: Related Work. Y. Li, C. Madarasingha, and K. Thilakarathna (2024) DiffPMAE: diffusion masked autoencoders for point cloud reconstruction. In ECCV, External Links: Link Cited by: Introduction. Y. Li, Z. Yu, C. Choy, C. Xiao, J. M. Alvarez, S. Fidler, C. Feng, and A. Anandkumar (2023b) VoxFormer: sparse voxel transformer for camera-based 3d semantic scene completion. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), Cited by: Related Work. Y. Liao, J. Xie, and A. Geiger (2022) KITTI-360: a novel dataset and benchmarks for urban scene understanding in 2d and 3d. T-PAMI. Cited by: Tasks, Datasets, and Metrics, Generation Results with DCD, KITTI-360 Completion Comparison, Condition Ablations, Dataset Processing, Dataset Processing, Dataset Processing, Dataset Processing, Figure 12, Figure 13, Flexible-Condition FPSGen Visualizations. Y. Lipman, R. T. Q. Chen, H. Ben-Hamu, M. Nickel, and M. Le (2022) Flow matching for generative modeling. arXiv preprint arXiv:2210.02747. Cited by: Related Work, Problem Formulation and Overview, Marginal Preservation of Hybrid Coupling, Network Details, Flow Matching Trajectory Visualization. X. Liu, C. Gong, and Q. Liu (2022) Flow straight and fast: learning to generate and transfer data with rectified flow. arXiv preprint arXiv:2209.03003. Cited by: Related Work, Network Details, Flow Matching Trajectory Visualization. Y. Liu, X. Li, X. Li, L. Qi, C. Li, and M. Yang (2024) Pyramid diffusion for fine 3d large scene generation. In Computer Vision – ECCV 2024: 18th European Conference, Milan, Italy, September 29–October 4, 2024, Proceedings, Part LXIX, Berlin, Heidelberg, p. 71–87. External Links: ISBN 978-3-031-72889-1, Link, Document Cited by: Introduction, Related Work. S. Luo and W. Hu (2021) Diffusion probabilistic models for 3d point cloud generation. In CVPR, Cited by: Introduction. Z. Lyu, Z. Kong, X. Xu, L. Pan, and D. Lin (2021) A conditional point diffusion-refinement paradigm for 3d point cloud completion. ArXiv abs/2112.03530. External Links: Link Cited by: Introduction. T. Martyniuk, G. Puy, A. Boulch, R. Marlet, and R. de Charette (2025) LiDPM: rethinking point diffusion for lidar scene completion. In 2025 IEEE Intelligent Vehicles Symposium (IV), Cited by: Introduction, Introduction, Related Work, Related Work, Baselines and Main Results, SemanticKITTI Generation Comparison, Generation Results with DCD, Runtime and Memory Benchmark, Dataset Processing, Dataset Processing, Network Details, Network Details, Completion Metrics, Evaluation Metrics, Completion Visualizations. A. Matteazzi and D. Tutsch (2026) LiFlow: flow matching for 3d lidar scene completion. arXiv preprint arXiv:2602.02232. Cited by: Related Work, Baselines and Main Results. M.L. Menéndez, J.A. Pardo, L. Pardo, and M.C. Pardo (1997) The jensen-shannon divergence. Journal of the Franklin Institute 334 (2), p. 307–318. External Links: ISSN 0016-0032, Document, Link Cited by: Tasks, Datasets, and Metrics, Completion Metrics, Additional Qualitative Comparisons. Z. Meng, Q. Wang, Z. Dou, Z. Song, Z. Zhou, I. King, and P. Zhao (2025) PointNSP: autoregressive 3d point cloud generation with next-scale level-of-detail prediction. External Links: 2503.08594, Link Cited by: Introduction. L. Nunes, R. Marcuzzi, J. Behley, and C. Stachniss (2026) Towards generating realistic 3d semantic training data for autonomous driving. External Links: 2503.21449, Link Cited by: Introduction. L. Nunes, R. Marcuzzi, B. Mersch, J. Behley, and C. Stachniss (2024) Scaling diffusion models to real-world 3d lidar scene completion. In CVPR, Cited by: Introduction, Introduction, Related Work, Tasks, Datasets, and Metrics, Baselines and Main Results, SemanticKITTI Generation Comparison, Generation Results with DCD, KITTI-360 Completion Comparison, Runtime and Memory Benchmark, Dataset Processing, Dataset Processing, Network Details, Network Details, Network Details, Completion Metrics, Evaluation Metrics, Completion Visualizations, Additional Qualitative Comparisons. W. Peebles and S. Xie (2023) Scalable diffusion models with transformers. In Proceedings of the IEEE/CVF International Conference on Computer Vision, p. 4195–4205. Cited by: Network Details, Network Details. H. Ran, V. Guizilini, and Y. Wang (2024) Towards realistic scene generation with lidar diffusion models. In 2024 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), Vol. , p. 14738–14748. External Links: Document Cited by: Baselines and Main Results, Generation Results with DCD, Dataset Processing, Figure 16, LiDM-Seeded Visualizations. L. Roldao, R. de Charette, and A. Verroust-Blondet (2020) Lmscnet: lightweight multiscale 3d semantic completion. In 3DV, Cited by: Baselines and Main Results, KITTI-360 Completion Comparison, Completion Metrics, Additional Qualitative Comparisons. R. Rombach, A. Blattmann, D. Lorenz, P. Esser, and B. Ommer (2022) High-resolution image synthesis with latent diffusion models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 10684–10695. Cited by: Network Details. O. Ronneberger, P. Fischer, and T. Brox (2015) U-Net: convolutional networks for biomedical image segmentation. In Medical Image Computing and Computer-Assisted Intervention, p. 234–241. Cited by: Network Details, Network Details. Y. Rubner, C. Tomasi, and L. J. Guibas (2000) The earth mover’s distance as a metric for image retrieval. International Journal of Computer Vision 40 (2), p. 99–121. External Links: Document Cited by: Tasks, Datasets, and Metrics, Generation Metrics. S. Song, F. Yu, A. Zeng, A. X. Chang, M. Savva, and T. Funkhouser (2017) Semantic scene completion from a single depth image. In CVPR, p. 1746–1754. Cited by: Related Work. A. Tong, K. Fatras, N. Malkin, G. Huguet, Y. Zhang, J. Rector-Brooks, G. Wolf, and Y. Bengio (2023) Improving and generalizing flow-based generative models with minibatch optimal transport. arXiv preprint arXiv:2302.00482. Cited by: Related Work, Marginal Preservation of Hybrid Coupling. A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin (2017) Attention is all you need. In Advances in Neural Information Processing Systems, Vol. 30. Cited by: Network Details, Network Details, Network Details. I. Vizzo, B. Mersch, R. Marcuzzi, L. Wiesmann, J. Behley, and C. Stachniss (2022) Make it dense: self-supervised geometric scan completion of sparse 3D lidar scans in large outdoor environments. RA-L. Cited by: Baselines and Main Results, KITTI-360 Completion Comparison. J. Wang, Z. Liu, Q. Meng, L. Yan, K. Wang, J. Yang, W. Liu, Q. Hou, and M. Cheng (2024) OPUS: occupancy prediction using a sparse set. In Advances in Neural Information Processing Systems, A. Globerson, L. Mackey, D. Belgrave, A. Fan, U. Paquet, J. Tomczak, and C. Zhang (Eds.), Vol. 37, p. 119861–119885. External Links: Document, Link Cited by: Completion Metrics. Y. Wang, Y. Sun, Z. Liu, S. E. Sarma, M. M. Bronstein, and J. M. Solomon (2019) Dynamic graph cnn for learning on point clouds. ACM TOG 38 (5), p. 1–12. Cited by: Network Details. L. Wu, D. Wang, C. Gong, X. Liu, Y. Xiong, R. Ranjan, R. Krishnamoorthi, V. Chandra, and Q. Liu (2023) Fast point cloud generation with straight flows. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), p. 9445–9454. Cited by: Introduction. T. Wu, L. Pan, J. Zhang, T. Wang, Z. Liu, and D. Lin (2021) Density-aware chamfer distance as a comprehensive metric for point cloud completion. arXiv preprint arXiv:2111.12702. External Links: Link Cited by: Limitations and Future Work, Generation Results with DCD, Initialization Noise and DCD, Completion Metrics, Additional Qualitative Comparisons. P. Xiang, X. Wen, Y. Liu, Y. Cao, P. Wan, W. Zheng, and Z. Han (2021) Snowflake point deconvolution for point cloud completion and generation with skip-transformer. In ICCV, p. 5499–5509. Cited by: Related Work. G. Yang, X. Huang, Z. Hao, M. Liu, S. Belongie, and B. Hariharan (2019) PointFlow: 3d point cloud generation with continuous normalizing flows. In Proceedings of the IEEE/CVF International Conference on Computer Vision, p. 4541–4550. Cited by: Generation BEV Flow Step Ablation, Generation Point Flow Step Ablation, Generation Metrics, Generation Metrics, Evaluation Metrics. X. Yu, Y. Rao, Z. Wang, Z. Liu, J. Lu, and J. Zhou (2021) PoinTr: diverse point cloud completion with geometry-aware transformers. In ICCV, p. 12498–12507. Cited by: Related Work. W. Yuan, T. Khot, D. Held, C. Mertz, and M. Hebert (2018) PCN: point completion network. In 2018 International Conference on 3D Vision (3DV), p. 728–737. Cited by: Related Work. X. Zeng, A. Vahdat, F. Williams, Z. Gojcic, O. Litany, S. Fidler, and K. Kreis (2022) LION: latent point diffusion models for 3d shape generation. External Links: 2210.06978, Link Cited by: Introduction. S. Zhang, A. Zhao, L. Yang, Z. Li, C. Meng, H. Xu, T. Chen, A. Wei, P. P. Gu, and L. Sun (2025) Distilling diffusion models to efficient 3d LiDAR scene completion. In Proceedings of the IEEE/CVF International Conference on Computer Vision, p. 5007–5016. Cited by: Introduction, Introduction, Related Work, Baselines and Main Results, KITTI-360 Completion Comparison, Runtime and Memory Benchmark, Network Details, Evaluation Metrics, Completion Visualizations. A. Zhao, S. Zhang, Z. Li, L. Yang, P. Chen, J. Wu, H. Xu, A. Wei, P. P. Gu, and L. Sun (2026) Diffusion distillation with direct preference optimization for efficient 3d LiDAR scene completion. Proceedings of the AAAI Conference on Artificial Intelligence 40 (15), p. 13070–13078. External Links: Document, Link Cited by: Related Work, Baselines and Main Results, KITTI-360 Completion Comparison, Runtime and Memory Benchmark, Evaluation Metrics, Completion Visualizations. L. Zhou, Y. Du, and J. Wu (2021) 3d shape generation and completion through point-voxel diffusion. In ICCV, Cited by: Introduction, Baselines and Main Results. Z. Zhou, J. Liang, J. Liang, Z. Du, and C. Fang (2026) Semantic guided part relation-aware network for point cloud completion. In Proceedings of the AAAI Conference on Artificial Intelligence (AAAI), Vol. 40, Singapore, p. 13871–13879. Cited by: Related Work. D. Zhu, Y. Di, S. Gavranovic, and S. Ilic (2025) SeaLion: semantic part-aware latent point diffusion models for 3d generation. In Proceedings of the Computer Vision and Pattern Recognition Conference, p. 11789–11798. Cited by: Introduction.