One-Step, Any-Density Point Clouds of Full Human Heads

Most 3D face models stop at the hairline. Hair, ears and the back of the skull get painted onto a smooth mask, flattened, or dropped, so heads look wrong from the side and from behind. These non-skin parts are hard to model for three reasons. They have awkward shapes: hair detaches from the scalp, ears fold over themselves, and a ray from the head's centre can cross the surface several times. They also need far more detail in some places than in others, and they are ambiguous, since a front-facing scan says little about what the hair looks like at the back.

A generative model of point clouds (a 3D shape stored as an unordered set of surface points) fits these conditions, because it can sample several plausible backs of the head rather than averaging them into a blob. Today, though, such models force a trade. Either the number of points is fixed at training time, or sampling runs a slow iterative solver.

We propose a two-level generator that removes both constraints. The top level compresses a head into a small set of latent tokens and generates them in one network evaluation. The bottom level is a decoder that moves any number of random 3D points onto the surface, also in one evaluation per point, with all points processed in parallel. Both levels use MeanFlow. This is a way of training a flow model to predict the average velocity over a time interval, so it can jump from noise to data in a single step. The question we most want to answer is empirical: when the step budget is small, is the damage to hair and ears done by the shape-level prior or by the point-level decoder? The answer determines where a deployed system should spend its few steps.

Core Claim

The claim has two parts. The first is that the right architecture for fast, resolution-free full-head completion is a MeanFlow prior over latent tokens paired with a point-level MeanFlow decoder. This avoids the slow continuous-normalizing-flow decoders used by earlier any-density models, and it avoids the spherical-harmonic machinery that assumes star-shaped objects. The second is that global Chamfer distance hides exactly the failures this field cares about. A region-partitioned evaluation over face skin, hair, ears, neck and posterior cranium will show that one-step errors concentrate in non-skin regions and come mainly from the decoder level. If that holds, giving the decoder two or three steps while keeping the prior at one step should recover most of the non-skin fidelity at little extra latency.

The closest work sits on each side of this design. FrePolad combines three pieces: a point-voxel encoder, a continuous-normalizing-flow decoder that samples 512 to over 100,000 points in roughly constant time (about 6.4 seconds), and a multi-step latent diffusion prior. Its frequency weighting relies on spherical harmonics, which assume star-shaped objects that hair and ears violate. It was tested only on ShapeNet objects. We keep its central idea, a decoder that samples points from a continuous distribution. We replace the iterative decoder and the multi-step prior with one-step MeanFlow maps, and we drop the spherical parameterization entirely.

3D MeanFlow shows that a permutation-equivariant MeanFlow on raw coordinates runs one-step generation and completion in about 5 ms. It works at a fixed point count, needs a Chamfer regularizer against global drift, and reports a loss of unconditional diversity at one step. We move that transport into a latent space and add a resolution-free decoder.

MeanFlow Transformers with Representation Autoencoders shows two things for 2D images: latent MeanFlow works, and once the generator takes one step, the decoder can consume up to 73% of generation time. That finding is the reason our decoder must also be one-step. We reuse its finite-difference approximation of the time derivative and its mid-training initialization. MeanFlow itself comes from Mean Flows for One-step Generative Modeling. It trains a network $u(z_t, r, t)$ to match the average velocity over the interval $[r, t]$ through the identity

$$u(z_t, r, t) = v(z_t, t) - (t - r)\,\frac{d}{dt}u(z_t, r, t),$$

where $z_t$ is the noisy sample at time $t$ and $v$ is the ordinary instantaneous flow-matching velocity. Setting $r=0$ and $t=1$ gives a one-step generator.

Research Program

Encoder. A permutation-invariant point transformer maps a scan of any density to $K$ latent tokens. Each token is anchored at a learned 3D location, so local detail such as an ear or a ponytail has a token that owns it. A single global vector would not give local structure that kind of home.

Point-level decoder. The decoder is a small conditional network $g_\theta(x, r, t \mid Z)$. Here $x \in \mathbb{R}^3$ is one point, $Z$ is the token set, and the network cross-attends from the point to nearby tokens. It is trained with the MeanFlow objective on pairs. Each pair couples a Gaussian sample $x_0$ with a point $x_1$ drawn from the ground-truth surface of the same head. The decoder therefore learns a distribution over surface points rather than a fixed set of point positions. Two consequences follow. Points are conditionally independent given $Z$, so any number $N$ of them can be generated in one parallel pass. And the decoder treats a point cloud as samples from a surface distribution, the same probabilistic view that PointFlow argued avoids the clumping produced by Chamfer-trained regressors.

Density. Because hair and ear surfaces are thin and small, we reweight the training sample of $x_1$ towards high-curvature and low-density regions. This replaces FrePolad's spherical-harmonic weighting with a scheme that works for shapes that are not star-shaped.

Prior. The prior is a transformer MeanFlow model over the $K$ tokens. It is conditioned on tokens from a partial observation, a front-facing depth scan of the kind a Kinect produces, and it samples the full head's tokens in one step. Unconditional generation is a secondary setting.

Data. Full-head scans with hair are scarce. We plan to pool three sources, assuming the corpora are obtainable: the i3DMM scans with hair and headwear from i3DMM, H3DS, and the Headspace capped-head scans used by the Liverpool–York Head Model. Headspace supplies cranial shape variation without hair. The completion task gets its training pairs by rendering many partial views of each scan.

Region labels. For evaluation we fit FLAME or LYHM to each ground-truth scan. Points near the fitted face region are labelled skin. Points on the template's ear vertices are labelled ear. Points farther than a threshold outside the fitted skull are labelled hair. The remaining back-of-skull surface is labelled posterior cranium.

Analysis. The main analysis is a grid over step budgets: one, two, or four steps for the prior, crossed with one, two, or four steps for the decoder. We report region-partitioned error and wall-clock latency at $N$ of 2k, 16k, and 100k points.

Baselines

Naive references. There are two. The first returns the partial input unchanged, which shows how much of the head is missing. The second fits FLAME or LYHM to the partial scan and samples points on the fitted mesh. That is the classical pipeline, with its bald or truncated cranium. It defines the floor for non-skin regions, and it should look reasonable on skin.

3D MeanFlow on raw coordinates. This is the strongest competitor on latency. We train it on the same head completion pairs at a fixed $N$ of 2k and 16k points, with its Chamfer consistency regularizer, the same number of GPU-hours, and the same hyperparameter-search budget as our model. Its paper reports about 5 ms per shape at one step, measured on ShapeNet and not on heads. We will re-measure it on our hardware. Beating it means lower hair- and ear-region error and better coverage of multiple plausible completions at matched latency for 16k points. We must also stay within a small multiple of its latency when we generate 100k points, a density it cannot produce without retraining.

FrePolad. This is the strongest any-density competitor. We train it on the same data with its default latent diffusion schedule, and again with a shortened schedule so that its prior budget matches ours. Its paper reports about 6.4 seconds to generate 100k points and says it matches or beats LION and PVD on 1-NNA. The file gives no exact 1-NNA value (no reported result found on Lacuna for FrePolad's numeric 1-NNA). Beating it means comparable or better region-partitioned fidelity at more than two orders of magnitude lower latency.

i3DMM-style implicit model. This covers the implicit-surface route. We fit its latent codes to the partial scan and extract points by sampling the surface. Its paper reports a full-head symmetric Chamfer distance of 3.31 mm on its own dataset, against 7.83 mm for FLAME. That is a fitting result on its own subjects, so we treat it as a reference scale rather than a directly comparable number.

ROME. ROME is an image-based method, so it gets its own track. We give it the colour image behind the partial scan. It reports a Chamfer distance of 12.6 on H3DS against 15.1 for H3D-Net (ROME results). Our comparison there is region-partitioned on H3DS, where we expect ROME to lose on ears (which it excludes) and on detached hair.

Ablation of the key ingredient. This ablation keeps our encoder, tokens and prior fixed and swaps only the decoder. The alternatives are a deterministic folding- or hypernetwork-style map from a ball to the surface, trained with Chamfer loss as in HyperCloud, and a continuous-normalizing-flow decoder as in FrePolad. A second ablation swaps our density reweighting for uniform surface sampling.

Why not just…?

Why not just use a deterministic one-pass surface map, like HyperCloud, as the decoder? This is the most serious threat. Such a map already produces any number of points in one pass, and the file gives no evidence that it fails on heads. The argument against it is indirect. PointFlow reports that Chamfer-trained regressors clump points and blur them, which is exactly what thin hair would suffer. The decoder ablation settles the question directly. If the Chamfer-trained map matches our point-level MeanFlow decoder on hair- and ear-region error and on point uniformity, we will adopt it. The contribution then reduces to the latent MeanFlow prior plus the region-level diagnosis, and we will say so.

Why not just run 3D MeanFlow at a large fixed point count? It is fast and conditions well. But every change of density means retraining, the cost of its point-set network grows with $N$, and its authors report reduced diversity at one step. That last point matters here because the back of the head is genuinely ambiguous. The matched-latency comparison at 16k points, together with coverage of several held-out plausible completions, will show whether moving to latent space actually helps. If it does not, a raw-coordinate model is the better choice.

Why not just take FrePolad and cut its sampling steps? Its decoder is a continuous normalizing flow solved as an ODE, so the roughly 6.4 seconds is largely decoder time. Shortening the latent schedule cannot remove that cost, which is the same decoder bottleneck MF-RAE identified in 2D. Its spherical frequency weighting also assumes star-shaped objects. The step-matched FrePolad run and a per-stage latency breakdown will make both costs visible.

Why not just fit a morphable model and add displacements? ROME does essentially this. It reports that its sphere-like mesh topology cannot represent hair that separates from the head, and it excludes ears. Our naive mesh-fit baseline and the ROME track measure how much this matters in the hair and ear regions.

Proposed Experiments and Decisive Checks

Main benchmark. The benchmark is full-head completion from synthetic front-facing partial scans on held-out subjects from the i3DMM scans and H3DS, with a real-sensor check on Biwi Kinect depth frames. For Biwi, the file reports only relative error reductions for Deep 3D Portrait, so no absolute baseline number is found on Lacuna. Metrics are symmetric Chamfer distance and F-score at a 1 mm and a 2 mm threshold, each reported per region. We also report coverage and minimum matching distance across 10 samples per input to measure diversity of completions, plus wall-clock latency split across encoder, prior and decoder. To check that nothing is lost on standard objects, we also run ShapeNet Airplane, Chair and Car unconditional generation with 1-NNA and coverage against FrePolad and 3D MeanFlow.

First decisive check. Does global Chamfer distance rank methods differently from hair-and-ear error? If it does not, the evaluation claim fails.

Second decisive check. In the step-budget grid, does most of the non-skin gain between the all-one-step and all-four-step settings come from extra decoder steps rather than extra prior steps? A clear yes supports spending the budget asymmetrically. A no means the ambiguity lives at the shape level, and the few extra steps should go to the prior.

Third decisive check. Is our decoder's latency at 100k points within an order of magnitude of 3D MeanFlow's 5 ms figure while beating it in the hair and ear regions? If not, the claim of speed and density together does not hold for heads, and we will report that rather than a headline number.