ECCV 2026 3D Vision generalizable neural surface reconstruction sparse volumetric representation occupancy prediction volume rendering sparse-view reconstruction

Generalizable Neural Reconstruction of High-Fidelity Surfaces via Sparse Volumetric Representations¶

Conference: ECCV 2026
Paper: ECCV
Area: 3D Vision
Keywords: generalizable neural surface reconstruction, sparse volumetric representation, occupancy prediction, volume rendering, sparse-view reconstruction

TL;DR¶

SVRecon replaces the expensive dense feature volume in generalizable neural surface reconstruction with a nested two-stage design — low-resolution occupancy prediction followed by a high-resolution sparse feature volume — pushing feed-forward reconstruction from 128³ to 512³ within 32GB of VRAM and delivering the smoothest, most normal-consistent surfaces on sparse-view DTU.

Background & Motivation¶

Neural implicit representations such as NeRF, NeuS, VolSDF, and Neuralangelo have lifted multi-view reconstruction to a new level by optimizing a signed distance function against a volume rendering loss on posed images, and the 3D Gaussian Splatting family (2DGS, Gaussian Opacity Fields) follows the same paradigm. This paradigm carries an unavoidable cost: every new set of views requires re-running the whole optimization from scratch, which is slow and highly sensitive to the number of views — accuracy degrades noticeably as views become scarce. Generalizable neural surface reconstruction (GNSR) exists precisely to remove that cost: methods such as VolRecon, ReTR, C2F2NeuS, and UFORecon are pretrained on a large corpus of scenes and then produce a scene representation for a novel scene in a single feed-forward pass, with no per-scene optimization whatsoever. They share one technical route — a network predicts a dense 3D feature volume directly from input images, and volume rendering and regression are performed on top of it.

The problem lies precisely in the word "dense". The memory footprint of a dense feature volume grows cubically with resolution, while reconstruction fidelity depends heavily on the sampling resolution. Measured under identical settings of batch size 1 and 1024 sampled rays per image at training time, VolRecon and ReTR can only reach 128³, SparseNeuS barely manages 192³, and anything beyond that immediately exhausts a 32GB GPU. Generalizable methods thus trade away optimization time only to inherit a resolution ceiling — and a resolution ceiling is a detail ceiling.

Sparsity looks like the natural answer: surfaces are sets of measure zero in 3D space, the voxels that actually contain surface are only a few percent of all voxels, and the overwhelming majority of the volume is empty. But sparsifying the representation destroys the entire set of dense assumptions that volume rendering relies on — ray sampling assumes uniform samples along the ray, feature querying assumes that any continuous coordinate can be trilinearly interpolated from a regular grid, and feature aggregation assumes neighboring voxels sit at fixed offsets. Existing attempts at sparsification (SparseNeuS, SuRF) work around this by first inferring sparsity through a cumbersome pre-rendering process and then re-densifying the feature volume in the final fine-rendering stage, handing back exactly the memory that sparsification saved. The real tension is that high resolution demands sparsity, yet a sparse representation cannot be plugged into an existing dense rendering pipeline — so one has to pick one of the two.

This paper's angle is to move sparsification earlier and make it real. Since "does this voxel contain surface" is itself a binary classification problem solvable from image features, the method predicts it feed-forward on a cheap 128³ dense grid, then subdivides only the voxels judged occupied, lifting the resolution to 512³ and computing high-dimensional features only there, and finally rewrites ray sampling, feature querying, and volume rendering one by one for this irregular representation. Core idea: a nested two-stage structure — low-resolution occupancy prediction followed by supersampling inside occupied voxels — that turns the memory cost of generalizable reconstruction from cubic in resolution into approximately proportional to surface area, pushing feed-forward surface reconstruction to 512³ on an ordinary 32GB GPU.

Method¶

Overall Architecture¶

The input is M posed images; the output is a color and a depth per ray, and the final surface is obtained by TSDF fusion and Marching Cubes over the predicted depth maps — the paper does not regress an SDF field, nor a mesh directly; the sparse voxels are merely the intermediate representation carrying features, while the geometry comes from depth. The core move is replacing the scene representation function \(F\) of a standard GNSR with a two-stage sparse representation \(S\). Stage one voxelizes the scene at \(K=128\), constructs a per-voxel feature by projecting each voxel center into the views, and predicts an occupancy probability with a 3D U-Net, yielding a sparse occupancy field that keeps only about 1.9% of the voxels. Stage two subdivides each occupied coarse voxel into \(s\times s\times s\) sub-cells (\(s=4\) in the paper, i.e. an overall 512³ resolution), computes high-dimensional features only on these sub-cells, and aggregates them with a sparse 3D U-Net to obtain the sparse scene representation \(S\). Sparse volume rendering then intersects rays with occupied voxels only and samples solely within the resulting ray fragments, uses a precomputed lookup table to map any continuous query point into the corresponding mini-volume for trilinear interpolation, and finally aggregates per-ray sample features with a Transformer to regress color and depth. The authors explicitly reject octrees: a variable-resolution structure would complicate volume rendering further with no obvious gain — a single-scale occupancy field plus purpose-built sparse operators is enough.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["Multi-view images + camera poses"] --> B["Occupancy prediction network<br/>predict surface voxels on a 128³ grid"]
    B --> C["Supersampled sparse feature volume<br/>occupied voxels subdivided 4×4×4 to 512³"]
    C --> D["Sparse volume rendering<br/>sparse sampling + lookup-table interpolation + attention aggregation"]
    D --> E["Per-ray depth / color<br/>TSDF fusion + Marching Cubes to a mesh"]

Key Designs¶

1. Occupancy prediction network: a single feed-forward classification that discards 98% of empty voxels up front

The first stage answers "which voxels may contain surface", and it must be answered at low resolution, because it determines the cost of every subsequent high-resolution computation. Given a scene bounding box voxelized at \(K=128\), each voxel center \(\mathbf{x}\) is projected into the \(M\) views via their projection matrices, FPN features are retrieved by bilinear interpolation, and the multi-view features are reduced to per-channel mean and variance, concatenated into the raw voxel feature:

\[\mathbf{V}(\mathbf{x}) = \operatorname{MeanVar}\big(\{\mathbf{f}_{I_i}(\pi_i(\mathbf{x}))\}_{i=1}^{M}\big)\]

The mean-variance concatenation rather than plain mean pooling matters because the variance channels explicitly encode cross-view agreement: a voxel genuinely on a surface should see similar features across views, hence low variance, whereas regions that are occluded or in the background exhibit large disagreement and thus high variance. Stacking all voxel features into a dense volume \(\mathbf{V}_d\) and passing it through a 3D U-Net \(\Psi\) with a linear regression head \(U\) yields the per-voxel occupancy prediction \(\mathbf{O}\).

The construction of the supervision signal contains an easily overlooked detail: the authors do not use the scene's own ground-truth point cloud to label occupancy, but instead merge the ground-truth depth maps of the input views into a point cloud. The reason is that the raw point cloud contains points that are occluded in the input views and therefore impossible to predict from those images; treating them as positives only forces the network to fit unobservable information and needlessly depresses recall. Because empty voxels dominate overwhelmingly, training minimizes a focal loss with \(\gamma=2\) to counteract the extreme class imbalance:

\[\mathcal{L}_{fc} = -\sum_{i,j,k} (1-p_{ijk})^{\gamma}\log(p_{ijk})\]

At inference the method makes a deliberately aggressive trade-off: the threshold is set as low as \(\tau=0.1\) (far below 0.5), and the predicted occupied voxels are further dilated with a cubic \(3\times3\times3\) kernel. The rationale is that the two error types have completely asymmetric costs — missing a true surface voxel loses that geometry permanently with no way for the second stage to recover it, whereas retaining an empty voxel merely costs a little extra memory. The measurements confirm the trade: 96.8% average recall at the price of 23.0% precision, i.e. three quarters of the retained voxels are false, yet they still amount to only 1.89% of all voxels.

2. Supersampled sparse feature volume: lifting resolution to 512³ only inside occupied voxels

Having obtained the low-resolution occupancy field \(\tilde{\mathbf{O}}\in\mathbb{R}^{K^3}\), the method constructs no high-resolution dense grid at all. Instead, each coarse voxel judged occupied receives an \(s\times s\times s\) regular grid of samples inside it, raising the resolution from \(K^3\) to \((sK)^3\), while empty voxels are skipped entirely and produce neither storage nor computation. With \(s=4\) and \(K=128\) this gives 512³, while the number of voxels actually participating remains the ~1.9% from the coarse grid. Each subdivided sub-cell reuses exactly the same feature construction as stage one (multi-view projection plus mean-variance), forming an \(s\times s\times s\) feature block that the authors call a mini-volume; stacking the mini-volumes of all occupied voxels gives the raw sparse feature volume \(\mathbf{V}_s\in\mathbb{R}^{N\times C\times s^3}\), with \(N\) the number of occupied voxels.

What makes this representation usable is its data structure choice: the sparse volume is organized as a collection of non-overlapping small regular blocks, not as a general sparse tensor. This seemingly plain convention underpins every sparse operator that follows — it preserves the property that the interior of a block is a regular cube, so in-block querying is always standard trilinear interpolation and all irregularity is quarantined at the index level between blocks. Feature aggregation uses the SparseUNet from the sparse convolution library torchsparse, which propagates information only among occupied voxels and produces the final sparse scene representation \(S = \Psi_{sp}(\mathbf{V}_s)\). The payoff is direct: memory scales approximately with surface area instead of the cube of resolution, so the same 32GB GPU can carry a sampling resolution two orders of magnitude higher.

3. Sparse volume rendering: rewriting ray sampling and feature querying for an irregular representation

The renderer must answer two questions that are taken for granted on a dense grid but awkward on a sparse volume: where to sample along a ray, and where to fetch features at an arbitrary continuous coordinate. The first is solved by sparse ray sampling: since only samples inside occupied voxels are meaningful, the algorithm first intersects the ray with all occupied voxels and confines sampling to the ray fragments formed by those intersections, rather than scattering samples uniformly along the whole ray as dense methods do. This wastes no sampling budget in empty regions and lets the same number of rays cover more of the regions that matter.

The second is solved by a lookup table. Sparse volumes are laid out irregularly in memory, so direct coordinate-indexed access is hopeless; the method precomputes a dense lookup table \(H\in\mathbb{R}^{K^3}\) mapping each coarse voxel index to the memory slot of its mini-volume. To query a continuous point \(\mathbf{x}\), the algorithm finds the 8 corner points enclosing it (in the global \(512^3\) coordinate frame), decomposes each corner's coordinates into a coarse voxel index on the \(128^3\) grid plus a local offset at \(s^3\) scale, retrieves all 8 corner features in one shot via \(S[H[v^{o}], v^{l}, :]\), and performs standard trilinear interpolation over them to obtain \(\mathbf{f}_{vol}\). The lookup table decouples irregular sparse storage from regular interpolation: the former is compressed into a single \(O(1)\) table lookup, while the latter fully retains the mature dense-grid procedure.

The sample features are finally concatenated into \(\mathbf{f}^{r}_i = \mathrm{cat}(\mathbf{f}_{vol}, \mathbf{f}_{proj}, \beta)\), where \(\mathbf{f}_{proj}\) is the Transformer-aggregated projection feature across views and \(\beta\) is a positional encoding. The rendering function follows the attention-based volume rendering of ReTR: a learnable token \(\mathbf{f}^{tok}\) serves as query, each sample feature along the ray serves as key and value, the attention weights are scaled dot products normalized by softmax, and both color and depth are weighted sums over the samples.

⚠️ Equation (10) of the original paper is heavily corrupted in the cached PDF extraction (the subscripts of the color and depth expressions are mixed together). The description above restores it from the paper's prose; refer to the original for the exact subscript correspondence.

A Worked Example¶

Suppose a scene bounding box is voxelized at 128³ and one coarse voxel genuinely contains surface, while most others are empty.

Occupancy prediction: the voxel center is projected into 3 input views (the test setting) to fetch FPN features, which are reduced to a 32-dimensional vector by per-channel mean and variance; the 3D U-Net returns, say, an occupancy probability of 0.7, above the threshold 0.1, and after a 3×3×3 dilation the voxel joins the occupied set.
Supersampling: the voxel is cut into 4×4×4 = 64 sub-cells, lifting the global resolution from 128³ to 512³. Only these 64 sub-cells have features computed; on average only about 1.9% of voxels enter this step.
Feature aggregation: the 64 sub-cells enter torchsparse's SparseUNet as a mini-volume (4×4×4×C), features propagate only among occupied voxels, and the sparse scene representation \(S\) is output.
Sampling and querying: a ray is first intersected with occupied voxels and samples are placed only inside one ray fragment. A sample point \(\mathbf{x}\) lands in the voxel above; the algorithm converts its 8 surrounding corners from 512³ coordinates into "128³ voxel index + 4³ in-voxel local offset", retrieves the 8 corner features through the lookup table \(H\), and trilinearly interpolates them to obtain \(\mathbf{f}_{vol}\).
Regression and meshing: \(\mathbf{f}_{vol}\) is concatenated with the point's projection feature and positional encoding, sent into the rendering Transformer, aggregated by attention over the learnable token, and an MLP regresses the color and depth of this ray. Once the predicted depth maps of all 15 DTU test scenes go through TSDF fusion and Marching Cubes, the meshes used to compute Chamfer Distance and Normal Consistency are obtained.

Loss & Training¶

The occupancy head and the rendering network are trained separately. The occupancy head uses the focal loss above (\(\gamma=2\)) with labels derived from the point cloud merged out of the input views' ground-truth depth maps; at inference it applies the \(\tau=0.1\) threshold plus 3×3×3 dilation, explicitly prioritizing recall. The rendering part follows the standard supervision of generalizable NeRFs: an L1 loss on predicted versus ground-truth color plus an L1 loss on predicted versus ground-truth depth, combined with a weight coefficient \(\alpha\), where only rays with valid ground-truth depth contribute to the depth term. Training uses M=4 views at 640×512 and testing uses M=3 views at 800×600; the volumetric feature channel count is \(C_f = 32\), and the model is trained for 16 epochs with Adam at a learning rate of \(10^{-4}\).

Memory is both the central constraint and the central evidence of this design: in stage two, training takes about 30GB with batch size 1, 1024 sampled rays, and 32 feature channels, dropping to about 12GB at inference. The authors note that stage one can be run entirely separately beforehand at little cost, so the memory budget is effectively left to the high-resolution sparse feature volume — which also explains why 512³ is close to the ceiling of this configuration.

Key Experimental Results¶

Main Results¶

Sparse-view surface reconstruction on DTU (15 test scenes, 3 input views each; Chamfer Distance in the official unit). VolRecon, ReTR, and UFORecon are reproduced with their released code, and the remaining numbers are taken from the respective papers:

Method	Category	Chamfer Distance ↓ (mean)	Normal Consistency ↑ (AUC@15°)
COLMAP	Multi-view stereo	1.52	–
TransMVSNet	Multi-view stereo	1.35	9.2
VolSDF	Per-scene optimization	3.41	–
NeuS	Per-scene optimization	4.00	–
SparseCraft	Per-scene optimization	1.04	19.1
PixelNeRF	Generalizable rendering	6.18	–
IBRNet	Generalizable rendering	2.32	–
MVSNeRF	Generalizable rendering	2.09	11.4
SparseNeuS	Generalizable surface reconstruction	1.96	12.1
VolRecon	Generalizable surface reconstruction	1.38	8.4
ReTR	Generalizable surface reconstruction	1.17	16.3
C2F2NeuS	Generalizable surface reconstruction	1.11	–
SuRF	Generalizable surface reconstruction	1.05	18.9
UFORecon	Generalizable surface reconstruction	1.00	11.8
SVRecon (Ours)	Generalizable surface reconstruction	1.00	21.0

Cross-dataset generalization (jointly trained on DTU + BlendedMVS, evaluated on 10 unseen scenes from Co3D, metric is AUC at threshold 0.05, higher is better):

Method	[email protected] over 10 Co3D scenes (mean)
MVSFormer++	0.60
SVRecon (Ours)	0.72

In addition, the resolution each method can sustain at training time (32GB of VRAM, batch size 1, 1024 rays): SparseNeuS handles 128³ and 192³, VolRecon and ReTR only 128³, while this paper handles 128³/192³/256³/512³.

Ablation Study¶

On DTU, using the same occupancy predictions and varying the stage-two settings (Chamfer Distance, lower is better):

Config	CD ↓ (mean)	Note
Resolution @ 128³ (1× supersampling)	1.27	0.27 worse than the full model
Resolution @ 256³ (2× supersampling)	1.04	0.04 worse than the full model
Number of views @ 5	0.96	more views, better than the full model
Number of views @ 4	0.99	on par with 3 views
Base feature channels @ 16	1.15	0.15 worse than 32 channels
Full model (512³ / 3 views / 32 channels)	1.00	—

Key Findings¶

Resolution is the single biggest lever, but its returns diminish. Going from 128³ to 256³ drops Chamfer Distance from 1.27 to 1.04 (about 18% better), whereas 256³ to 512³ improves it by only another 0.04. The shape of this curve explains why earlier generalizable methods at 128³ generally fail to produce smooth surfaces — they sit just before the steepest part of the curve.
Chamfer Distance alone is misleading. This paper and UFORecon tie exactly on CD (both 1.00), yet the normal consistency gap is large (21.0 versus 11.8), and the qualitative figures show clearly rougher UFORecon surfaces. CD is insensitive to local geometry and point density, so judging by it alone rates a visibly worse surface as equal; the paper therefore adopts Normal Consistency (angular differences between closest vertices of meshes reconstructed by TSDF + Marching Cubes, summarized as the percentage AUC up to 15°) as a co-primary metric, on which it beats every competitor including the per-scene optimized SparseCraft.
Against the closest baseline, ReTR, the method wins on every metric and every scene (CD 1.17→1.00, NC 16.3→21.0). Since ReTR is precisely the basis of this paper's rendering component, the gains must come from the sparse high-resolution representation itself rather than from a different rendering loss or training strategy.
More input views help, but modestly. Going from 3 to 4 views changes almost nothing (1.00→0.99), and only 4→5 views brings it down to 0.96. The method sees only 4 views during training yet works with both 3 and 5, which the mean-variance feature construction makes natural since it is agnostic to the number of views.
Feature channel count trades against memory; cutting to 16 channels costs 0.15 CD, indicating that the capacity of the 3D features has not saturated at this level, though the authors stop at 32 to free memory for resolution.
The cost structure of occupancy prediction is clear: 96.8% average recall (geometry is essentially preserved) at only 23.0% precision, retaining about 1.89% of voxels — 4.2 times the ideal space occupation of 0.45%. The misses come mostly from the textureless table in the scenes, a region that is hard to reconstruct and does not participate in the standard evaluation. In other words, the extra 4× space buys the property of "almost never dropping a surface", which is a good deal for a geometry-completeness-oriented task.

Highlights & Insights¶

Separating cheap resolution from expensive resolution: occupancy prediction runs at 128³, where network capacity and compute are cheap and the stage can even be run offline beforehand, while high resolution is spent only where it is needed. This "decide on a coarse grid, expand on a fine grid only where the decision is positive" split transfers to any task where high resolution is expensive but most of the space is empty — sparse voxel object detection, large-scale point cloud completion, city-scale reconstruction.
Trading data structure for algorithmic complexity: organizing the sparse volume as a collection of regular small blocks plus one dense lookup table, rather than a general sparse tensor, is the cleverest move in the paper. It decouples irregular sparse storage from regular trilinear interpolation — after a single \(O(1)\) table lookup, in-block interpolation fully reuses the mature dense-grid procedure. That is far less effort than designing a fresh interpolation operator for sparsity, and much easier to get right.
The asymmetry between the two stages makes an aggressive threshold the correct choice: a false negative in occupancy is unrecoverable while a false positive only wastes memory, so \(\tau=0.1\) with dilation is mathematically the right inference policy. Making this cost asymmetry explicit beats tuning against a default 0.5 threshold, and most two-stage pipelines deserve such an analysis.
Normal Consistency is an indispensable second metric for sparse-view reconstruction: tying on CD while differing nearly twofold on NC is itself a reusable evaluation lesson — any reconstruction method selling surface smoothness should report normal-based metrics, or CD will grade a rough but point-wise close result as top-tier.

Limitations & Future Work¶

The primary limitation acknowledged by the authors is a strong dependence on occupancy prediction accuracy: if the occupancy grid is wrong, no amount of downstream resolution can recover it, and the geometry is directly incomplete or incorrect. In the experiments the occupancy network fails on large textureless regions and thin structures, because the 2D image features themselves are unreliable there and the entire 3D representation is built from 2D features. The authors believe stronger image feature representations would mitigate this.
Generalization is bounded by the training data distribution: although the method outperforms MVSFormer++ (trained on the same data) on unseen Co3D and even works on non-object-centric scenes from BlendedMVS, performance degrades when input views come from distant viewpoints. More diverse training data is the suggested remedy.
Backgrounds are not modeled: since the sparse representation covers only occupied voxels, novel view synthesis results have no background and rendering is limited to the object. This restricts direct applicability to unbounded scenes, and the authors list generalizing to realistic unbounded scenes with an arbitrary number of views as future work.
A limitation I noticed: 512³ is a memory ceiling, not a method ceiling. The ablation shows performance still improves with each step up in resolution (with diminishing returns), and the authors state explicitly that they cannot go higher only because of memory. Meanwhile the occupancy head reaches just 23% precision, meaning 77% of retained voxels are false and stage two pays 4.2 times the ideal space cost for them — the occupancy head has even more headroom than stage-two resolution, and improving it translates directly into affordable higher resolution.
Concrete improvement directions: replace single-scale occupancy prediction with a coarse-to-fine multi-scale scheme to reduce the false negatives that dilation currently has to cover for; fine-tune the occupancy head with the reconstruction loss back-propagated from stage two, so that "which voxels are worth keeping" is optimized for reconstruction quality rather than binary classification accuracy; and, on the engineering side, introduce tiled rendering or more memory-efficient sparse operators to push the 512³ ceiling further.

vs ReTR: ReTR is methodologically the closest baseline and this paper directly adopts its rendering function (attention-based volume rendering). The difference is that ReTR renders on a 128³ dense feature volume, whereas this paper replaces it with a 512³ sparse volume via occupancy prediction plus supersampling. The result is that this paper beats ReTR on every metric and every scene (CD 1.17→1.00, NC 16.3→21.0), which confirms the gains come from the representation rather than the rendering formulation.
vs SparseNeuS / SuRF: both also aim to bring sparsity into GNSR, but along a different route — they first infer sparsity through a cumbersome pre-rendering process, and they still use a densified feature volume in the final fine-rendering stage, handing back most of the memory that sparsification saved. Their resolution therefore stays low (SparseNeuS up to 192³). This paper derives sparsity from a single feed-forward occupancy prediction and stays sparse all the way from construction to rendering.
vs UFORecon: the two tie exactly on Chamfer Distance (both 1.00), but UFORecon's surfaces are visibly rougher, with normal consistency of only 11.8 against this paper's 21.0. This is a textbook case of one metric failing to separate two methods: UFORecon improves the feature representation while this paper attacks sampling resolution, and only a smoothness-aware metric can tell them apart.
vs C2F2NeuS: C2F2NeuS uses cascade cost frustum fusion to combine high fidelity with generalizability, reaching CD 1.11 with NC not reported in this paper's table; this paper is better on CD (1.00) and sustains a far higher resolution ceiling.
vs MVSFormer++: the main competitor for cross-dataset generalization, also feed-forward and trained on the same datasets. This paper wins on Co3D with 0.72 versus 0.60 [email protected]. Note that the two are not the same task — MVSFormer++ outputs depth maps and does no rendering, so the comparison concerns downstream geometry quality and is affected by each method's depth post-processing.
vs per-scene optimization methods (NeuS / VolSDF / SparseCraft): NeuS and VolSDF optimize each scene independently and reach CD of 4.00 and 3.41 respectively, far behind this paper under sparse views. SparseCraft uses stereopsis-cue regularization to push CD to 1.04 and NC to 19.1, the strongest of the per-scene optimized methods, yet this paper still surpasses it on NC (21.0) while requiring no per-scene optimization at all — exactly what the generalizable route sets out to demonstrate.

Rating¶

Novelty: ⭐⭐⭐⭐ Sparse representations are not new in themselves (SparseNeuS and SuRF both tried), but the "feed-forward occupancy prediction + supersampling inside occupied voxels + purpose-built sparse operators" route is cleaner and is the first to genuinely cash in the resolution dividend up to 512³.
Experimental Thoroughness: ⭐⭐⭐⭐ On DTU it reports both CD and NC, diagnoses occupancy precision and space occupation, evaluates cross-dataset generalization on Co3D, and ablates resolution, view count, and channel count; what is missing is a memory/runtime comparison curve against the sparse baselines and any sensitivity analysis of the dilation kernel size or the threshold \(\tau\).
Writing Quality: ⭐⭐⭐⭐ The two-stage structure and the motivation for this particular form of sparsity are explained clearly, and the trade-offs (recall first, no octree) are all justified; the formulas are densely typeset in the PDF, however, and some are corrupted after extraction, so details need the original to confirm.
Value: ⭐⭐⭐⭐ A reproducible 512³ feed-forward reconstruction on a single 32GB GPU, plus a reusable set of sparse rendering operators and the "decide coarse, expand fine" design pattern, make this a clear reference point for future high-resolution generalizable reconstruction work.