SurfaceSplat: Hybrid Sparse-View 3D Reconstruction

• SurfaceSplat is a hybrid sparse-view reconstruction framework that combines SDF representation with 3D Gaussian Splatting for stable geometry and detailed renderings.
• It initializes a coarse mesh via SDF, which guides the 3D Gaussian Splatting process and undergoes cyclic refinement through novel view augmentation.
• Empirical evaluations show that SurfaceSplat significantly improves reconstruction metrics like F1 score, Chamfer distance, and PSNR compared to baseline methods.

SurfaceSplat is a hybrid sparse-view reconstruction framework that combines a signed distance function (SDF) representation with 3D Gaussian Splatting (3DGS) to produce both a watertight mesh and photorealistic novel-view renderings from images with known camera poses. Its central coupling is bidirectional: an SDF-based stage supplies coarse, globally coherent geometry that stabilizes 3DGS initialization, and a 3DGS stage renders additional views that are then used to refine the SDF and recover finer detail (Gao et al., 21 Jul 2025).

1. Problem formulation and design rationale

SurfaceSplat addresses sparse-view 3D surface reconstruction and novel view synthesis in a regime where supervision is limited and uneven. The method is motivated by the complementary failure modes of two major families of neural reconstruction methods. SDF-based methods such as NeuS, Voxurf, and MonoSDF tend to produce globally coherent geometry and reasonable meshes, but under sparse views they become over-smooth and lose fine structures in both geometry and appearance. 3DGS-based methods such as 3DGS, GOF, and 2DGS usually preserve local detail and texture more effectively, but with sparse initialization they often yield fragmented geometry, floaters, and incomplete global structure (Gao et al., 21 Jul 2025).

The framework therefore separates the roles of the two representations. SurfaceSplat uses an SDF to capture coarse geometry and constrain 3DGS, then uses 3DGS as a high-quality view synthesizer to expand the image set available to the SDF. On MobileBrick, this division aligns with the empirical pattern that Voxurf provides better mesh quality while GOF and 3DGS provide better rendering quality; SurfaceSplat is designed to combine those strengths rather than replace one representation with the other (Gao et al., 21 Jul 2025).

The method assumes sparse RGB images and known camera poses, and targets two outputs simultaneously: a high-quality, watertight 3D mesh and photorealistic renderings from arbitrary viewpoints. That dual target is important, because the framework is not only a rendering system and not only a meshing pipeline; it is explicitly structured around mutual improvement between geometry-first and appearance-first representations (Gao et al., 21 Jul 2025).

2. Representational components

The SDF side is built on Voxurf, itself based on NeuS. For a ray $r(t)=o+tv$, sampled at points $p_i=o+t_i v$, SurfaceSplat uses the NeuS-style rendering formulation

$$\hat{C}(r)=\sum_{i=1}^{N} T_i \alpha_i c_i,\qquad T_i=\prod_{j=1}^{i-1}(1-\alpha_j),$$

with opacity

$$\alpha_i=\max\left(\frac{\Phi_s(f(p(t_i))) - \Phi_s(f(p(t_{i+1})))}{\Phi_s(f(p(t_i)))},0\right),$$

where $f(x)$ is the SDF and

$\Phi_s(x)=(1+e^{-sx})^{-1}.$

The coarse SDF stage uses a voxel grid $\boldsymbol{V}^{(\mathrm{sdf})}$ at resolution $96^3$, while the fine stage increases the grid to $256^3$ (Gao et al., 21 Jul 2025).

The coarse SDF objective augments Voxurf’s reconstruction and regularization terms with a normal consistency term. The coarse loss is

$$\mathcal{L}= \mathcal{L}_{\text{recon}} +\mathcal{L}_{TV}\left(\boldsymbol{V}^{(\mathrm{sdf})}\right) +\mathcal{L}_{\text{smooth}}\left(\nabla \boldsymbol{V}^{(\mathrm{sdf})}\right),$$

and SurfaceSplat adds

$p_i=o+t_i v$0

where $p_i=o+t_i v$1 is predicted by Metric3D and $p_i=o+t_i v$2 is rendered from the SDF. This addition is used specifically to suppress floaters and stabilize the coarse mesh under sparse-view supervision (Gao et al., 21 Jul 2025).

The 3DGS side uses the standard Gaussian formulation with mean position, covariance, opacity, and color features. SurfaceSplat writes the Gaussian density as

$p_i=o+t_i v$3

with covariance stabilized as

$p_i=o+t_i v$4

where $p_i=o+t_i v$5 and $p_i=o+t_i v$6 is diagonal. Rendering follows the standard splat projection and alpha compositing used in 3DGS (Gao et al., 21 Jul 2025).

3. SDF-to-3DGS geometry transfer

The first directional coupling is from SDF to 3DGS. SurfaceSplat begins with a coarse SDF reconstruction, extracts a mesh with Marching Cubes, cleans that mesh, samples reliable foreground surface points from it, and uses those points to initialize the Gaussian representation (Gao et al., 21 Jul 2025).

Mesh cleaning is performed by connected-component clustering on triangle faces. If $p_i=o+t_i v$7 denotes the face set of component $p_i=o+t_i v$8, the method identifies the largest component by

$p_i=o+t_i v$9

removes all other faces, and retains the cleaned mesh

$$\hat{C}(r)=\sum_{i=1}^{N} T_i \alpha_i c_i,\qquad T_i=\prod_{j=1}^{i-1}(1-\alpha_j),$$0

This step targets floater suppression before any Gaussian initialization occurs (Gao et al., 21 Jul 2025).

Foreground points are not sampled uniformly from the mesh. Instead, SurfaceSplat projects the cleaned mesh into each training camera, obtains depth maps, samples valid depth pixels, and back-projects them into 3D: $$\hat{C}(r)=\sum_{i=1}^{N} T_i \alpha_i c_i,\qquad T_i=\prod_{j=1}^{i-1}(1-\alpha_j),$$1 Each sampled point is assigned the color of its source pixel. The method reports about 5k sampled points per view and about 50k total foreground points, which are then combined with COLMAP sparse points for the background (Gao et al., 21 Jul 2025).

This initialization replaces the usual COLMAP-only 3DGS seed with a denser and more globally coherent geometry prior. Gaussian optimization then proceeds for 7k iterations, with densification starting at 500 iterations and applied every 100 iterations, and with opacity reset at 3k iterations (Gao et al., 21 Jul 2025). On MobileBrick, the effect is measurable: foreground PSNR improves from 19.13 for COLMAP-only initialization, to 19.88 with mesh cleaning, and to 20.45 when normal loss and mesh cleaning are both used in the SDF stage (Gao et al., 21 Jul 2025).

4. 3DGS-to-SDF view augmentation and cyclic refinement

The second directional coupling runs from 3DGS back to the SDF. Once initialized from SDF-derived surface points, the Gaussian model is trained on the original sparse views and then used to render additional images from expanded camera poses (Gao et al., 21 Jul 2025).

Pose expansion is implemented in two ways. One is camera-position perturbation: $$\hat{C}(r)=\sum_{i=1}^{N} T_i \alpha_i c_i,\qquad T_i=\prod_{j=1}^{i-1}(1-\alpha_j),$$2 with orientation still directed toward the object center. The preferred strategy is cubic-spline interpolation over the original camera positions and rotations, producing smoother trajectories and slightly better reconstruction (Gao et al., 21 Jul 2025). The rendered novel views are denoted

$$\hat{C}(r)=\sum_{i=1}^{N} T_i \alpha_i c_i,\qquad T_i=\prod_{j=1}^{i-1}(1-\alpha_j),$$3

and are appended to the original image set for the fine SDF stage (Gao et al., 21 Jul 2025).

The fine SDF stage raises the voxel resolution to $$\hat{C}(r)=\sum_{i=1}^{N} T_i \alpha_i c_i,\qquad T_i=\prod_{j=1}^{i-1}(1-\alpha_j),$$4 and uses Voxurf’s dual color network, with geometry and color modules consuming both the original images and the newly rendered 3DGS images. The fine-stage supervision therefore covers more viewpoints than the sparse original set, which alleviates the under-constrained detail recovery that affects SDF methods under sparse input (Gao et al., 21 Jul 2025).

SurfaceSplat also formalizes a cyclic optimization scheme. If $$\hat{C}(r)=\sum_{i=1}^{N} T_i \alpha_i c_i,\qquad T_i=\prod_{j=1}^{i-1}(1-\alpha_j),$$5 is the current coarse mesh, $$\hat{C}(r)=\sum_{i=1}^{N} T_i \alpha_i c_i,\qquad T_i=\prod_{j=1}^{i-1}(1-\alpha_j),$$6 denotes the 3DGS training-and-rendering operator, and $$\hat{C}(r)=\sum_{i=1}^{N} T_i \alpha_i c_i,\qquad T_i=\prod_{j=1}^{i-1}(1-\alpha_j),$$7 denotes SDF optimization, then

$$\hat{C}(r)=\sum_{i=1}^{N} T_i \alpha_i c_i,\qquad T_i=\prod_{j=1}^{i-1}(1-\alpha_j),$$8

One cycle provides most of the reported gain, while two cycles yield a smaller additional improvement (Gao et al., 21 Jul 2025).

5. Empirical performance and operating profile

On MobileBrick with 10 input views, SurfaceSplat improves both reconstruction and rendering relative to SDF-only and 3DGS-only baselines. Voxurf reports $$\hat{C}(r)=\sum_{i=1}^{N} T_i \alpha_i c_i,\qquad T_i=\prod_{j=1}^{i-1}(1-\alpha_j),$$9 F1 and $$\alpha_i=\max\left(\frac{\Phi_s(f(p(t_i))) - \Phi_s(f(p(t_{i+1})))}{\Phi_s(f(p(t_i)))},0\right),$$0 CD with PSNR $$\alpha_i=\max\left(\frac{\Phi_s(f(p(t_i))) - \Phi_s(f(p(t_{i+1})))}{\Phi_s(f(p(t_i)))},0\right),$$1 and PSNR-F $$\alpha_i=\max\left(\frac{\Phi_s(f(p(t_i))) - \Phi_s(f(p(t_{i+1})))}{\Phi_s(f(p(t_i)))},0\right),$$2; a GOF-like 3DGS baseline reports $$\alpha_i=\max\left(\frac{\Phi_s(f(p(t_i))) - \Phi_s(f(p(t_{i+1})))}{\Phi_s(f(p(t_i)))},0\right),$$3 F1 and $$\alpha_i=\max\left(\frac{\Phi_s(f(p(t_i))) - \Phi_s(f(p(t_{i+1})))}{\Phi_s(f(p(t_i)))},0\right),$$4 CD with PSNR $$\alpha_i=\max\left(\frac{\Phi_s(f(p(t_i))) - \Phi_s(f(p(t_{i+1})))}{\Phi_s(f(p(t_i)))},0\right),$$5 and PSNR-F $$\alpha_i=\max\left(\frac{\Phi_s(f(p(t_i))) - \Phi_s(f(p(t_{i+1})))}{\Phi_s(f(p(t_i)))},0\right),$$6; SurfaceSplat reports $$\alpha_i=\max\left(\frac{\Phi_s(f(p(t_i))) - \Phi_s(f(p(t_{i+1})))}{\Phi_s(f(p(t_i)))},0\right),$$7 F1 and $$\alpha_i=\max\left(\frac{\Phi_s(f(p(t_i))) - \Phi_s(f(p(t_{i+1})))}{\Phi_s(f(p(t_i)))},0\right),$$8 CD with PSNR $$\alpha_i=\max\left(\frac{\Phi_s(f(p(t_i))) - \Phi_s(f(p(t_{i+1})))}{\Phi_s(f(p(t_i)))},0\right),$$9 and PSNR-F $f(x)$0. A two-cycle variant reaches $f(x)$1 F1, $f(x)$2 CD, $f(x)$3 PSNR, and $f(x)$4 PSNR-F (Gao et al., 21 Jul 2025).

On DTU with 5 views, SurfaceSplat reports a mean Chamfer distance of $f(x)$5 mm, compared with $f(x)$6 for Voxurf, $f(x)$7 for MonoSDF, $f(x)$8 for 2DGS, $f(x)$9 for GOF with TSDF, $\Phi_s(x)=(1+e^{-sx})^{-1}.$0 for GOF with Gaussian extraction, and $\Phi_s(x)=(1+e^{-sx})^{-1}.$1 for GSDF-10 (Gao et al., 21 Jul 2025). In the appendix-reported 3-view setting, a SparseCraft-based instantiation reaches $\Phi_s(x)=(1+e^{-sx})^{-1}.$2 mm mean CD (Gao et al., 21 Jul 2025).

The timing profile reflects the staged design. On MobileBrick with 10 views, the coarse SDF stage at $\Phi_s(x)=(1+e^{-sx})^{-1}.$3 and 10k iterations takes about 15 minutes, 3DGS training at 7k iterations takes about 5 minutes, novel-view rendering for 10 poses takes about 30 seconds, and the fine SDF stage at $\Phi_s(x)=(1+e^{-sx})^{-1}.$4 and 20k iterations takes about 40 minutes. One full cycle is therefore about 1 hour (Gao et al., 21 Jul 2025).

These results support the intended division of labor. The SDF stage contributes geometry coherence and watertight meshing, while the Gaussian stage contributes high-frequency appearance and view expansion. The ablation numbers indicate that neither representation alone matches the coupled system on both surface and rendering metrics (Gao et al., 21 Jul 2025).

6. Limitations and operational scope

SurfaceSplat is currently implemented with Voxurf on the SDF side and standard 3DGS on the Gaussian side, and the reported experiments focus on object-level scenes rather than large indoor or outdoor environments (Gao et al., 21 Jul 2025). The method also assumes known camera poses throughout.

Performance still degrades in extremely sparse settings such as 2-view input. The framework improves sparse-view reconstruction, but it does not remove the need for viewpoint diversity altogether (Gao et al., 21 Jul 2025). It also incurs the cost of maintaining two separate representations and multiple training stages, which keeps runtime practical for object-centric scenes but makes the method more involved than a single-field optimization.

The reported future directions are correspondingly targeted: extending the framework to other SDF methods such as MonoSDF, SparseCraft, and Neuralangelo; extending it to other Gaussian formulations such as Mip-Splatting and structured Gaussians; scaling to larger and more complex scenes; and exploring stronger mutual constraints such as direct depth or normal consistency between the SDF and Gaussian representations, or joint optimization in place of the current staged pipeline (Gao et al., 21 Jul 2025).

7. Position within surface-oriented splatting literature

SurfaceSplat belongs to a broader line of work that uses splats as explicit surface elements rather than purely volumetric radiance carriers. Its most direct conceptual neighbor is SplatSDF, which also combines 3DGS and neural SDFs; however, SplatSDF fuses Gaussian information into the SDF at the architecture level during training and discards 3DGS at inference, whereas SurfaceSplat uses the SDF to initialize 3DGS and uses 3DGS to augment SDF supervision with new views (Li et al., 2024, Gao et al., 21 Jul 2025).

Within planar or surfel-style Gaussian methods, 3D Gabor Splatting keeps 2DGS geometry but replaces uniform per-splat color with a Gabor-noise color model for high-frequency surface textures, so that each primitive can encode spatially varying texture over its footprint (Watanabe et al., 15 Apr 2025). SparseSurf uses flattened Gaussians with stereo geometry-texture alignment and pseudo-feature geometry consistency to improve sparse-view surface reconstruction and novel-view rendering (Gu et al., 18 Nov 2025). SparSplat regresses 2DGS surface elements in a generalizable feed-forward MVS pipeline and uses TSDF fusion over rendered depths for sparse-view surface reconstruction (Jena et al., 4 May 2025). SurfelSplat also predicts pixel-aligned 2D Gaussian surfels in feed-forward form, but introduces Nyquist-guided low-pass surfel adaptation and cross-view feature aggregation so that the geometry of those surfels is accurate enough for surface extraction (Dai et al., 9 Apr 2026). SurfSplat, in turn, uses 2DGS primitives together with a surface continuity prior and forced alpha blending to obtain coherent geometry in feed-forward sparse-view reconstruction, with High-Resolution Rendering Consistency as an evaluation metric (He et al., 2 Feb 2026).

Other branches of the same surface-oriented trend broaden the primitive model or task setting. A mixed-primitive Gaussian framework combines Gaussian ellipses, Gaussian lines, and Gaussian triangles for surface reconstruction (Qu et al., 15 Jul 2025). Large-scale outdoor surface reconstruction with planar Gaussians, appearance decoupling, transient masking, and TSDF fusion has been studied for UAV scenes (Chen et al., 21 Jun 2025). TranSplat uses diffusion-predicted surface embeddings to guide Gaussian splatting for transparent-object depth completion and manipulation (Kim et al., 11 Feb 2025). SpLap treats surface-aligned splats as surface patches whose intersections define a surface-aware graph, then applies Laplacian deformation directly to Gaussian splats without a mesh or cage proxy (Kim et al., 24 Nov 2025).

In that broader context, SurfaceSplat is distinctive in how it connects two already strong but differently biased representations. It does not merely regularize Gaussian geometry with an SDF prior and does not merely use Gaussian-rendered depth as a post-process for meshing. Instead, it couples SDF and 3DGS through initialization and data augmentation: coarse SDF geometry improves Gaussian optimization, and Gaussian novel-view rendering improves SDF refinement under sparse supervision (Gao et al., 21 Jul 2025).