Skip to content

Fourier Splatting: Generalized Fourier encoded primitives for scalable radiance fields

Conference: ECCV 2026
Paper: ECCV
Area: 3D Vision
Keywords: Gaussian Splatting, planar primitives, Fourier boundary parameterization, level-of-detail (LoD), scalable representation

TL;DR

This paper replaces the fixed disc boundary of a planar surfel with a closed curve defined by a Fourier series that can be truncated at any time, so that a single trained model carries a continuously adjustable level of detail: simply transmitting fewer Fourier coefficients yields a lower-bitrate, lower-detail render without retraining or pruning, giving the best PSNR/SSIM among planar-primitive methods on Mip-NeRF 360.

Background & Motivation

Explicit-primitive splatting has become the dominant route to real-time novel view synthesis. 3DGS rasterizes millions of anisotropic Gaussians and swaps NeRF's per-ray volume integration for tile-level parallel rasterization, achieving high fidelity at interactive rates; but its primitive is a fixed-shape, smooth elliptical kernel with infinite support and an eternally smooth silhouette. A large body of follow-up work has focused on replacing that primitive: GES generalizes the radial falloff to an exponential family with a learnable shape parameter, Deformable Beta Splatting uses compact-support Beta kernels, 3D-HGS slices each Gaussian along a plane into half-kernels, DRK parameterizes the radial profile with learnable basis functions, 3D Convex Splatting uses smooth convex bodies, and Quadratic Gaussian Splatting bends a surfel from a flat disc into a paraboloid; the planar line (2DGS / Gaussian Surfels) flattens ellipsoids into oriented surfels, Triangle Splatting renders differentiable triangles outright, and BBSplat equips each billboard plane with a texture and an alpha mask. What all these designs share is that a primitive's expressiveness is decided by its architecture and is frozen once training ends — it can neither grow more complex nor become simpler afterwards.

Improving fidelity therefore leaves only one lever: more primitives. High-frequency detail is bought by proliferating primitives rather than by letting a primitive become more complex, and memory, rendering, and transmission bandwidth grow linearly with it. A parallel line of work attacks this with level-of-detail hierarchies: Octree-GS and LODGE maintain Gaussians at several LoD levels and prune or blend them by rendering distance, while LOD-GS embeds Gaussians in a triangle soup and downsamples them within each triangle. These methods do reduce bitrate and improve real-time performance, but the only scalable axis is the primitive count — simpler means deleting Gaussians and more complex means adding them, while each individual primitive never changes. That is the core tension this paper targets: fidelity is tied strictly to primitive count, and degradation comes at the price of dropping whole spatial regions — in the paper's qualitative figure, Octree-GS loses focal objects altogether when downscaled — whereas a primitive's own geometric complexity becomes non-adjustable the moment training finishes. Yet reducing a curve from six frequency components to one is the most natural way to lower precision in the first place.

This paper's angle is to build scalability into the primitive itself: instead of reducing how many primitives there are, it lowers how complex each primitive is. Core idea: parameterize the boundary of a planar surfel with a truncatable Fourier encoded descriptor, so that the number of retained frequency components \(K\) directly serves as a continuously adjustable level of detail; then use a straight-through estimator to extend gradients beyond the primitive boundary and use HYDRA to decompose multi-lobed primitives into simpler constituents inside the MCMC densification framework, so that these shapes can be optimized stably under a fixed primitive budget.

Method

Overall Architecture

The input is a set of multi-view images (with an SfM point cloud for initialization) and the output is a set of planar primitives that can be rasterized tile by tile. Each primitive keeps the 2DGS surfel form — tangent-plane center, orientation quaternion, opacity, spherical-harmonic color — and additionally carries two things: the amplitudes and phases that write its boundary as a Fourier series, and a sharpness \(\sigma_i\) that controls how hard or soft the falloff window is. Rendering still follows the 2DGS pipeline: each pixel ray is intersected with the surfel plane to obtain tangent-plane coordinates \((u_j, v_j)\), opacity is computed inside the tangent plane, and front-to-back compositing produces the image. What changes is that the "2D Gaussian falloff over a fixed disc" becomes a "power window inside a Fourier boundary," and that this hard boundary is given a smooth surrogate gradient that only takes effect in the backward pass. Training runs inside the MCMC densification framework (3DGS-MCMC), with HYDRA decomposing large, multi-lobed primitives into simpler children. After training the model holds \(K=6\) frequency components, and at deployment any number from 1 to 6 can be retained, so one model directly yields renders at different levels of detail.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["input: multi-view images<br/>+ SfM point cloud"] --> B["Fourier encoded primitive<br/>starts at K_active=1"]
    B --> C["power window forward + STE backward<br/>gradients beyond the boundary"]
    C --> D["HYDRA split + relocation<br/>MCMC densification keeps P(g)"]
    D -->|densify each round| C
    D -->|training done| E["truncate Fourier coefficients<br/>any LoD at runtime"]

How the boundary is defined. Inside the primitive's own tangent plane, the ray intersection point \((u_j,v_j)\) is converted to polar coordinates relative to the center: radial distance \(\rho_j\) and angle \(\theta_j\). The boundary radius is the modulus of a Fourier polynomial in the angle:

\[r_i(\theta)=R_i\left|\sum_{k=0}^{K-1}c_{i,k}\,e^{\mathrm{i}\,k\theta}\right|,\qquad c_{i,k}=\bar r_{i,k}\,e^{\mathrm{i}\phi_{i,k}}\]

Here \(R_i\) is the circumradius bounding the primitive's extent, and \(c_{i,k}\) is the \(k\)-th complex coefficient whose amplitude \(\bar r_{i,k}\) and phase \(\phi_{i,k}\) are both learnable. Note carefully where the Fourier encoding is attached: it is not NeRF-style positional encoding and not spherical harmonics over direction, but the radius function of the geometric boundary in tangent-plane polar coordinates — the shape itself is what gets encoded. The \(k=0\) term is the DC component that sets a uniform base radius, and each higher term contributes a \(k\)-fold angular variation. At \(K=1\) only the DC term remains and the boundary degenerates into a circle of radius \(R_i\bar r_{i,0}\), exactly recovering the standard disc primitive — 2DGS is the \(K=1\) special case of this work. That is also the physical meaning of "scalable" here: what scales is the primitive's own shape complexity / frequency detail, not the scene size or the primitive count.

Key Designs

1. Fourier encoded primitive: turning shape into an adjustable parameter via a normalized, truncatable boundary

The pain point is the one above: existing primitives freeze their shape after training. Rewriting the shape as a set of frequency components turns "how much detail do you want" into "how many components do you keep," a decision that can be made on the spot at inference time. One easily overlooked constraint is needed to make this polynomial well behaved: every frequency contributes its own share to the boundary radius, and without a bound the amplitudes could sum past the circumradius \(R_i\), letting the boundary overshoot the circumscribed circle. The paper enforces a squared-\(\ell_1\) normalization, defining each normalized amplitude as the raw amplitude squared divided by the sum of squared raw amplitudes, so that \(\sum_k \bar r_{i,k}=1\). Because every term is non-negative and they sum to one, the triangle inequality guarantees \(r_i(\theta)\le R_i\) for every angle. The constraint has a useful side effect: when high-frequency components are truncated, the remaining low-order amplitudes still satisfy the normalization (their sum is merely below one), so the image only becomes simpler and never suddenly shows overshoot artifacts — precisely the property that makes the "one model, many LoDs" story work.

One implicit limitation deserves an honest mention: \(r_i(\theta)\) is single-valued in the angle (a radial function), so this descriptor can only express closed regions that are star-shaped with respect to the primitive's center; it cannot represent outlines with holes or strong concavities. All the shape-diversity examples given in the paper are star-shaped curves such as petal-like and multi-lobed ones.

2. Power-window forward pass plus straight-through estimator backward pass: letting the boundary both shrink and expand

The forward renderer follows Triangle Splatting's power window but reformulates it in polar coordinates. The signed distance from a pixel to the boundary is simply \(\varphi_j=\rho_j-r_i(\theta_j)\), and pixels with \(\varphi_j\ge 0\) are discarded, which gives the primitive compact support — unlike the infinite support of a 3DGS Gaussian, and closer to the "surfel = surface" assumption. Per-pixel opacity is a power window of that distance: the normalized interior distance \((r_i(\theta_j)-\rho_j)/r_i(\theta_j)\) raised to the power \(\sigma_i\), multiplied by the primitive opacity \(o_i\). The window peaks at the center and reaches zero at the boundary, with \(\sigma_i\) controlling the decay profile — in the paper's illustration \(\sigma=0.001\) is nearly a hard edge and \(\sigma=8\) is a very soft transition — and since it is learnable, each primitive can choose adaptively between "hard edge hugging the geometry" and "soft kernel for anti-aliasing."

The problem lies in the backward pass. The hard clamp \(\max(0,\cdot)\) creates a zero-gradient dead zone outside the boundary: exterior pixels contribute exactly zero to the render, so the gradient with respect to the Fourier coefficients vanishes there as well. Since most of the gradient signal comes from interior pixels, the net effect is that the boundary keeps contracting, and to keep coverage large enough the optimization can only inflate the circumradius \(R_i\) — compensating by uniformly scaling the whole shape rather than letting the Fourier coefficients learn more complex geometry, which leaves primitives stuck near circular.

The fix is to decouple forward and backward with a straight-through estimator. The forward render is untouched and still governed by the hard window; in the backward pass the hard window is replaced by a smooth surrogate \(\tilde w\) with non-zero gradient on both sides of the boundary:

\[\tilde w(x)=\operatorname{sigmoid}(\beta x)\cdot\left(\frac{\operatorname{softplus}(\beta x)}{\beta}\right)^{\!\sigma_i}+\gamma\cdot\operatorname{sigmoid}(\beta x)\]

where \(x\) is the unclamped normalized distance (\(x>0\) inside, \(x<0\) outside) and \(\beta,\gamma\) are fixed hyper-parameters (\(\beta=3,\gamma=0.5\) in the paper). The first term smoothly approximates \(\max(0,x)^{\sigma_i}\) and matches the true forward window for interior points; the additive sigmoid term guarantees \(\partial\tilde w/\partial x\neq 0\) even when \(x<0\), so pixels just outside the boundary also deliver gradient to the Fourier coefficients. The boundary can therefore both shrink and expand during optimization, and the coefficients genuinely get a chance to learn complex shapes instead of relying on \(R_i\) to cover the extent. One routing detail: since exterior pixels contribute nothing in the forward pass, their STE gradient is restricted to the Fourier coefficients \(c_{i,k}\), while position and orientation gradients still come only from interior pixels — where the photometric loss is well defined.

3. HYDRA decomposition and surfel-friendly MCMC densification: placing these shapes correctly under a fixed budget

Training adopts the 3DGS-MCMC framework: SGD updates are interpreted as SGLD and primitives are samples from a target distribution \(P(g)\propto\exp(-\mathcal{L})\), so densification (adding, moving, killing primitives) is a deterministic state transition that must preserve \(P(g_{\text{new}})=P(g_{\text{old}})\). Porting this machinery to planar primitives requires two changes.

The first is dropping positional noise. 3DGS-MCMC injects SGLD noise into primitive positions, scaled by the 3D covariance and inversely by opacity, to encourage spatial exploration. For a planar surfel this noise pushes it out of its tangent plane — especially when it has not converged yet or sits in a high volumetric-frequency region — and since children inherit the parent's orientation, such a perturbation breaks the planarity constraint and invalidates \(P(g_{\text{new}})\). The paper therefore applies no positional noise at all, at the cost that under-reconstructed regions (where positional gradients are large) risk being undersampled between densification steps; HYDRA is what fills that gap.

The second is rederiving the relocation formula. When a dead primitive is relocated onto a live one and replaced by \(N\) co-located children, the rendered image must remain unchanged. Opacity has a kernel-independent closed form, \(o_{\text{new}}=1-(1-o)^{1/N}\); for the radius, the polar integral of the parent's power window in the tangent plane is equated to the composited integral of the \(N\) children. Expanding each child's transmittance with the binomial theorem and integrating term by term in polar coordinates replaces the Gaussian integral factor \((\sigma+1)(\sigma+2)\) with an alternating binomial sum:

\[R_{\text{new}}=R\sqrt{\frac{o}{(\sigma+1)(\sigma+2)\,D}},\qquad D=\sum_{i=1}^{N}\sum_{k=0}^{i-1}(-1)^k\binom{i-1}{k}\frac{o_{\text{new}}^{k+1}}{(\sigma(k+1)+1)(\sigma(k+1)+2)}\]

The death criterion combines three conditions: opacity below \(\tau_o\), maximum blending weight \(\max_j(\alpha_{i,j}T_{i,j})\) over recent views below \(\tau_I\), and observation in fewer than \(V_{\min}\) frames; newly created primitives get a one-epoch grace period. When adding primitives, candidates are sampled with weights alternating between opacity and inverse sharpness \(1/\sigma_i\) (the two correspond to different local convergence behaviors), and each sampled primitive produces two children via the \(N=2\) formulas: one at the sampled position and one offset within the tangent plane by \(\eta\epsilon,\ \epsilon\sim\mathcal{N}(0,I)\). This cloning noise is worth only 0.05 dB, but it spreads added primitives randomly across the surfel plane instead of piling them all along the same angular direction.

HYDRA (Hybrid Decomposition for Rendering-Aware Preservation) addresses exactly the gap left by removing positional noise: it first identifies high-gradient, under-reconstructed primitives through absolute gradient accumulation (the AbsGS recipe) and then handles two cases. Scale-preserving split targets small primitives: shrink the circumradius and place two symmetrically offset children in the tangent plane, again using the \(N=2\) mass-preserving formulas. Learned lobe decomposition targets large primitives that have already grown complex, multi-lobed boundaries — there a geometric split is insufficient, and the pieces it produces neither contain the original shape nor fit the local geometry. Instead, the boundary is sampled at \(M\) angles and the \(S\) deepest valleys are used as cut points, partitioning it into \(S\) angular segments; a pre-trained MLP \(f_\psi\) takes the parent's sharpness and coefficients plus the segment's center of mass \((r_M,\theta_M)\) and angular bounds \((\theta_{\min},\theta_{\max})\), and outputs the child's sharpness, amplitudes, phases, polar offset \((\Delta r,\Delta\theta)\), opacity, and circumradius. Children inherit color and orientation from the parent, the parent is removed, and the primitive count increases by \(S-1\). The decomposition itself is thus learned from data rather than prescribed by a fixed geometric rule, which is why it can handle multi-lobed cases that geometric splitting cannot.

Loss & Training

The total objective is the photometric loss (a weighted sum of \(\ell_1\) and D-SSIM) plus the depth distortion loss and normal consistency loss of 2DGS, which respectively suppress spread in the rendered depth distribution and pull each surfel's normal \(t_w\) toward the depth-derived surface normal. The implementation uses \(K=6\) frequencies and degree-3 spherical harmonics (48 coefficients); together with 3 center coordinates, 4 quaternion components, 1 opacity, 1 circumradius, 1 sharpness, and 12 Fourier parameters, this gives 70 parameters per primitive. The Fourier polynomial is evaluated with Horner's method: \(w=e^{\mathrm{i}\theta}=(\cos\theta,\sin\theta)\) is obtained directly from the tangent-plane coordinates as \(u_j/\rho_j\) and \(v_j/\rho_j\), avoiding all transcendental calls, and the recurrence runs from \(k=K-1\) downward in complex multiply-adds — \(K-1\) of them, roughly 8 operations per frequency — before taking the modulus to get \(r_i(\theta)\). A key scheduling choice is to activate only the lowest frequency component (\(K_{\text{active}}=1\)) at the start so that global structure stabilizes first, and to unfreeze the remaining frequency coefficients at iteration 600, so that low-frequency dominance does not obstruct the acquisition of fine textural detail. Truncation is the optimal form of degradation because the Fourier basis is orthogonal: the best \(L_2\) approximation of a \(K\)-term polynomial by its first \(K-1\) coefficients is obtained by simple truncation, with no adjustment needed for the remaining terms.

Key Experimental Results

Experiments run on Mip-NeRF 360 (5 outdoor + 4 indoor scenes) and Tanks and Temples (2 large-scale scenes) with PSNR, SSIM, and LPIPS, following the evaluation protocol of Triangle Splatting and quoting its published baseline numbers (other results are taken from Deformable Beta Splatting). The comparison covers implicit methods (Mip-NeRF 360, Zip-NeRF), volumetric primitives (3DGS, 3DGS-MCMC, DBS, 3DCS, Gabor Splatting, GES), and planar primitives (2DGS, Triangle Splatting, BBSplat).

Main Results

Method Mip-NeRF 360 Avg. PSNR↑ SSIM↑ LPIPS↓ T&T PSNR↑ SSIM↑ LPIPS↓
Mip-NeRF 360 (implicit) 27.35 0.792 0.237 22.22 0.759 0.257
Zip-NeRF (implicit) 28.42 0.826 0.189 – – –
3DGS (volumetric) 26.98 0.813 0.214 23.14 0.841 0.183
3DGS-MCMC (volumetric) 27.84 0.850 0.210 24.29 0.860 0.190
DBS (volumetric) 28.13 0.827 0.234 24.85 0.870 0.140
2DGS (planar) 26.84 0.804 0.252 23.13 0.831 0.212
BBSplat (planar) 26.49 0.778 0.236 25.12 0.868 0.172
Triangle Splatting (planar) 26.98 0.812 0.191 23.14 0.857 0.143
Ours (K=6) 27.65 0.824 0.193 24.15 0.868 0.137

Among planar primitives, this method achieves the best PSNR and SSIM on Mip-NeRF 360, improving 0.67 dB over Triangle Splatting and 0.81 dB over 2DGS, which shares the same surfel formulation. On Tanks and Temples it attains the best LPIPS of all baselines (0.137) while staying in the same band on PSNR and SSIM (tying BBSplat's 0.868 SSIM).

⚠️ One inconsistency between the text and the table is worth flagging: the paper states that it ranks first among planar methods on Mip-NeRF 360 "across all metrics," but the table gives Ours an average LPIPS of 0.193 versus Triangle Splatting's 0.191 (a 0.217 tie outdoors and 0.162 versus 0.160, a slight loss, indoors); the official table should be taken as authoritative. In addition, 3DGS-MCMC and DBS carry †/‡ markers, so their settings may not be exactly on the same footing as the other rows.

Ablation Study

Config PSNR↑ SSIM↑ LPIPS↓ Note
Full model 24.15 0.868 0.137 full model (Tanks and Temples)
w/o lobe decomposition (HYDRA) 23.93 0.847 0.141 −0.22 dB; naive geometric splitting cannot handle multi-lobed primitives
w/o STE 23.81 0.842 0.147 −0.34 dB, the largest drop; no gradient outside the boundary stalls optimization near circles
w/o cloning noise 24.10 0.845 0.138 −0.05 dB; less angular diversity in added primitives

Scalability / Compression Analysis

Matched primitive budget (Tanks and Temples, 960K primitives for both):

Method Primitives PSNR↑ SSIM↑ LPIPS↓ FPS VRAM Train
2DGS 960K 22.94 0.827 0.160 182 1.4 GB 12 min
Ours (K=6) 960K 23.79 0.853 0.156 135 2.08 GB 41 min

Compressed with the ISO V3C codec, resulting in independent bitstreams per primitive (same scene, varying number of retained frequencies \(K\)):

Retained frequencies K 1 2 3 4 5 6
Bytes/primitive 61.92 64.52 67.13 69.67 72.21 74.89
PSNR↑ 12.66 16.74 19.18 20.77 21.81 22.40
SSIM↑ 0.53 0.66 0.74 0.79 0.82 0.84
LPIPS↓ 0.45 0.35 0.27 0.22 0.19 0.17

Going from \(K=1\) to \(K=6\) costs only about 13 extra bytes per primitive yet lifts PSNR from 12.66 to 22.40 (⚠️ these are numbers under a compressed bitstream, a different footing from the uncompressed 24.15 dB — the two should not be compared directly). Truncating coefficients yields a per-primitive bitstream that naturally suits codecs which encode attributes independently, and it also makes progressive streaming straightforward. ⚠️ The paper's Fig. 7 and Fig. 8 additionally report speed and rate-distortion curves under truncation (\(K=1\) at roughly 22.44 dB / 112.4 FPS and \(K=6\) at 24.15 dB / 80.8 FPS, plus a rate-distortion comparison against Octree-GS); these numbers are read off the annotations in the figures and the original paper should be consulted.

Key Findings

  • STE is the single most critical ingredient: removing it costs 0.34 dB, the largest drop of the three ablations, and the failure mode is precise — with no gradient outside the boundary, primitives cannot grow to cover under-reconstructed regions and optimization stalls near circular shapes. Extending gradients out of a hard boundary is thus a prerequisite for training this primitive, not a refinement.
  • HYDRA's value concentrates on large primitives: removing lobe decomposition costs 0.22 dB. Naive geometric splitting cannot handle a large primitive that has already grown multiple lobes and can only cut it into wrongly shaped fragments, whereas an MLP that learns children per angular segment genuinely decomposes a complex shape into simple pieces that fit the local geometry.
  • Scalability is cheap but not free: truncating from \(K=6\) down to \(K=1\) buys only about 30% more FPS (80.8 → 112.4), showing that Fourier evaluation itself is inexpensive (the Horner recurrence costs about 8 operations per frequency). The more complex primitives are, however, more expensive overall: at a matched 960K budget, training grows from 2DGS's 12 minutes to 41 minutes, VRAM from 1.4 GB to 2.08 GB, and frame rate drops from 182 to 135 FPS (still real-time).
  • Degradation is gentler than pruning: unlike count-based methods such as Octree-GS, this method degrades by making every primitive simpler, so focal objects never vanish outright and quality degrades uniformly. This is the central qualitative selling point, but the quantitative evidence is currently limited to rate-distortion curves on 2 scenes from Tanks and Temples.

Highlights & Insights

  • Moving level of detail from the count axis to the shape axis: previous LoD schemes all add or delete primitives, whereas this work makes "how many frequency components are retained" a new scaling axis. Because the Fourier basis is orthogonal, truncation is by construction the best \(L_2\) approximation — a free, retraining-free form of degradation that is remarkably clean.
  • A well-matched use of the straight-through estimator: hard-boundary differentiable rendering (triangles, convexes, meshes) all suffer from vanishing gradients outside the boundary. Rather than softening the boundary (which forfeits the benefit of a hard edge), this work fabricates gradients outside it while leaving the forward render untouched, and additionally routes them — exterior pixels send gradients only to the shape coefficients, not to position or orientation. The trick transfers to any rasterizer with a hard cutoff.
  • HYDRA turns decomposition into something learned: finding valleys along the boundary and generating children per angular segment with an MLP is essentially learned adaptive subdivision, better able to match a parent primitive that has already evolved a complex shape than a fixed geometric rule. The idea transfers to mesh subdivision, point-cloud upsampling, and hierarchical construction of NeRF grids.
  • The role of squared-\(\ell_1\) normalization is made explicit: it both keeps the boundary from overshooting (geometric correctness) and keeps truncation valid (the precondition for scalability), acting as the screw that welds "parameterization" to "truncatability."

Limitations & Future Work

  • The limitation the authors acknowledge most directly is bitrate: the method prioritizes state-of-the-art fidelity for a given primitive budget rather than minimizing the bits needed to compress and transmit the representation. They propose integrating scale regularization to incentivize fewer, larger, more complex primitives, using the frequency expressiveness of high-\(K\) boundaries to replace dense distributions of simple surfels in order to lower bitrate.
  • Training cost is markedly higher (41 min vs 12 min and 2.08 GB vs 1.4 GB VRAM at a matched budget), and an extra MLP decomposer must be trained, making the pipeline considerably more involved than 2DGS.
  • The representation is confined to star-shaped regions: a single-valued \(r(\theta)\) cannot express outlines with holes or strong concavities. Multi-lobed decomposition alleviates but does not fundamentally solve this.
  • The scalability argument leans on the bandwidth/bitrate side; scalability in the sense of scene size is not directly validated — only 2 large scenes from Tanks and Temples are used, and there is no full quantitative comparison against hierarchical methods such as Octree-GS at matched bitrate (only rate-distortion curves).
  • A comparison worth running is to pit "truncate Fourier coefficients" against "prune the same fraction of primitives" under an identical bit budget; only then can the shape axis be shown to dominate the count axis.
  • Letting each primitive choose its retained frequency count based on viewing distance or importance (instead of a global truncation) would turn LoD into view-adaptive progressive streaming, a direction that could be combined with Octree-GS-style hierarchies and remains unexplored.
  • vs 2DGS: 2DGS supplies all the scaffolding this work inherits — surfel parameterization, ray-plane intersection, tile compositing, and the depth distortion and normal consistency losses — but its primitive is a 2D Gaussian over a fixed disc. This work replaces the disc with a Fourier boundary and the Gaussian falloff with a power window, degenerating exactly to 2DGS at \(K=1\), and raises PSNR from 22.94 to 23.79 at a matched budget. The difference can be summarized as: in 2DGS the shape is a constant, here it is a parameter.
  • vs Triangle Splatting: also hard-boundaried and also using a power window, but a triangle has only three fixed vertices and no truncatable level of detail. This work borrows its power window and parts of its training strategy (observation-count death criterion, alternating sampling) and gains 0.67 dB on the Mip-NeRF 360 average, at the cost of more expensive per-primitive evaluation and more parameters.
  • vs BBSplat / 3D Convex Splatting: BBSplat gives each billboard plane a texture and alpha mask, building variability of appearance into the primitive and achieving the best Tanks and Temples PSNR (25.12); 3DCS swaps hard edges for smooth convex bodies. This work builds variability into the geometric boundary instead and additionally offers truncatable LoD, a capability neither of them has.
  • vs 3DGS / 3DGS-MCMC (volumetric primitives): 3DGS ellipsoids have infinite support and fixed shape, while 3DGS-MCMC supplies this work's optimization framework but adds SGLD positional noise scaled by the 3D covariance, which does not suit surfels — hence the removal of that noise and the rederivation of the relocation formula for a power window. On aggregate results this method still trails the strongest volumetric methods (DBS at 28.13 and 3DGS-MCMC at 27.84 versus 27.65 dB); the paper's phrasing is that it is competitive with volumetric approaches and surpasses them in some categories, a caveat worth keeping in mind.
  • vs Octree-GS / LODGE / LOD-GS (hierarchical LoD): their scalability axis is primitive count and their degradation works by deletion and distance-based filtering; this work's axis is each primitive's own frequency detail and its degradation makes every primitive simpler, so no content disappears wholesale and the bitstream can be split per primitive, which plays better with codecs. The two are not mutually exclusive — the paper notes that combining these primitives with classical pruning is what yields a complete bandwidth-constrained solution.

Rating

  • Novelty: ⭐⭐⭐⭐ The "first inherently scalable primitive" framing holds up, and moving LoD from the count axis to the shape axis is a genuine change of perspective; the technical components (Fourier boundary, STE, MCMC relocation) are mostly combinations and adaptations of existing ideas.
  • Experimental Thoroughness: ⭐⭐⭐ Benchmarks and ablations are adequate, but the scalability side covers only 2 scenes and lacks a full quantitative comparison against pruning methods at matched bitrate, and the text contains one claim inconsistent with its own table.
  • Writing Quality: ⭐⭐⭐⭐ The motivation chain is clear and the derivations (especially the power-window integral for relocation) are reasonably complete; a few passages (how shape-based splats are cited, figure and table annotations) feel rough.
  • Value: ⭐⭐⭐⭐ It offers a new adjustable axis for bandwidth-constrained high-fidelity rendering that can be stacked on existing pruning and hierarchical schemes; the cost is higher training expense and implementation complexity, so in the short term it is most likely to enter existing splatting pipelines as an optional primitive extension.