TRiGS: Temporal Rigid-Body Motion for Scalable 4D Gaussian Splatting¶

Conference: ECCV 2026
Paper: ECCV 2026
Project Page: TRiGS project page
Area: 3D Vision
Keywords: 4D Gaussian Splatting, rigid-body motion modeling, SE(3) exponential map, dynamic scene reconstruction, long-sequence scalability

TL;DR¶

TRiGS models each Gaussian primitive's motion as a continuous rigid-body trajectory in se(3) — a coupled exponential map yields rotation and translation jointly, a quadratic Bézier residual inside the visibility window captures nonlinearity, and a per-primitive local anchor serves as an independent center of rotation — reaching the best rendering quality on the 600/900/1200-frame SelfCap sequences and on N3V under a constant budget of 0.5M primitives and 160 MB.

Background & Motivation¶

Reconstructing dynamic scenes from multi-view video underpins VR/AR and free-viewpoint rendering. After 3D Gaussian Splatting made static scenes both real-time and high-fidelity, its 4D extensions quickly split into two lines: implicit deformation fields (Deformable-3DGS, DASH, LocalDyGS) that describe per-frame deformation with a canonical space plus a neural field, and explicit approaches (4DGS, STGS, Ex-4DGS, up to FTGS) that optimize 4D primitives directly or parameterize motion with explicit functions. The explicit line currently performs best on short clips, at the cost of granting Gaussians extreme temporal freedom: primitives may appear and disappear at arbitrary times, and local motion is commonly approximated by piecewise linear velocity plus a very short temporal opacity window.

The trouble lies precisely in that freedom. Real trajectories are curved, and a linear assumption can never follow curvature: over time the linear extrapolation of a primitive drifts away from the true geometry, and the model can only mask the growing spatial mismatch by repeatedly deleting, splitting, and regenerating primitives. The paper calls this temporal fragmentation: the object loses its long-term temporal identity (the same piece of geometry is carried by entirely different primitives at adjacent moments) and the primitive count is forced to keep growing. Two consequences follow — memory balloons with sequence length (FTGS doubles its primitive count from 600 to 1200 frames and its footprint grows from 490 MB to 977 MB; GIFStream reaches 2825 MB), and quality degrades with length (FTGS drops from 26.23 to 25.41 PSNR). The deeper cause is that these methods optimize rotation and translation as two independent parameter sets; under a rendering objective the two can compensate for each other, producing a continuum of near-equivalent solutions, so the motion decomposition becomes entangled and the error drifts over time. On top of that, all primitives share a single global center of rotation, which cannot express a scene where several parts rotate independently.

This paper's angle is: instead of letting primitives move "freely" frame by frame and paying for the errors with more primitives, constrain the motion to be a continuous, geometrically self-consistent rigid-body trajectory. Core idea: perform a hierarchical parameterization in the se(3) Lie algebra (a learnable base term plus a quadratic Bézier residual inside the visibility window), map it through the exponential map into a coupled SE(3) transform, and apply it about each primitive's own local anchor; combined with motion-guided relocation under a fixed budget, a small number of primitives can follow complex nonlinear motion over long horizons.

Method¶

Overall Architecture¶

The input is a calibrated multi-view dynamic video; the output is a time-varying scene representation supporting novel-view synthesis. The scene is a set of 3D Gaussian primitives, each with a canonical mean \(\mu_i\), covariance \(\Sigma_i\), opacity \(\alpha_i\), plus two temporal parameters — a central time \(\mu_{t,i}\) and a temporal scale \(s_{t,i}\) — which together define a Gaussian-shaped temporal visibility that confines the primitive's active interval around its central time. At any continuous query time \(t\), the mean and covariance are produced by the motion model and then rasterized following the 3DGS pipeline.

The pipeline in short: initialize canonical Gaussians from a RoMa dense-matching point cloud → parameterize motion as se(3) coefficients → refine them nonlinearly with a quadratic Bézier residual inside the visibility window → map to a coupled SE(3) transform and apply it about the local anchor → splat-render under photometric/SSIM supervision plus motion regularizers; during training, every 100 iterations a motion-guided relocation moves capacity from redundant low-opacity primitives to regions with complex motion, all within a fixed primitive budget.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["RoMa point-cloud init<br/>+ canonical Gaussians"] --> B["Coupled rigid-body motion<br/>se(3) exponential map"]
    B --> C["Hierarchical Bézier residual<br/>smooth refinement in window"]
    C --> D["Local anchor-centered deform<br/>anchor projection gauge fixing"]
    D --> E["Splatting render<br/>photometric + SSIM supervision"]
    E -->|every 100 iterations| F["Motion-guided relocation<br/>fixed-budget reallocation"]
    F --> B

Key Designs¶

1. Coupled rigid-body motion parameterization: rotation and translation decided by one exponential map

The most direct way to write a single Gaussian's position as rigid motion is \(\mu_i(t)=R_i(t)\mu_i+p_i(t)\), but optimizing \(R_i(t)\) and \(p_i(t)\) as two unrelated parameter sets is ill-conditioned — under the rendering loss rotation and translation can compensate for each other, so an entire continuum of near-equivalent solutions exists, the optimization becomes entangled, and the error accumulates as drift. TRiGS therefore optimizes not on SE(3) but on its Lie algebra se(3), using a time-conditioned coefficient \(\zeta_i(t)=(\omega_i(t),\nu_i(t))\); the relative "log-parameter" from the central time to \(t\) is taken as \(\zeta_i(t)\Delta t\) and the exponential map restores rotation and translation in one shot:

\[\mathbf{T}_i(\mu_{t,i}\to t)=\exp\!\big(\hat{\mathbf u}_i(t)\big)=\begin{bmatrix}\mathbf R_i(t)&\mathbf p_i(t)\\ \mathbf 0&1\end{bmatrix},\qquad \mathbf u_i(t)=\zeta_i(t)\,\Delta t,\quad \Delta t=t-\mu_{t,i}\]

Here \(\hat{\cdot}\) is the standard wedge operator in se(3). Once expanded, the rotation part follows from \(\phi_i(t)=\omega_i(t)\Delta t\) via Rodrigues' formula, and the translation is not a free parameter but is determined by the SO(3) left Jacobian: \(\mathbf p_i(t)=J(\phi_i(t))\,\upsilon_i(t)\) with \(\upsilon_i(t)=\nu_i(t)\Delta t\). This buys two things. First, at \(\Delta t=0\) we have \(\mathbf u_i=0\), so \(\mathbf T_i(\mu_{t,i})=\mathbf I\) holds by construction — every primitive returns exactly to its canonical pose at its own central time, the trajectory cannot drift relative to that moment, and no disentanglement-specific loss is needed. Second, translation is no longer independent but is "whatever displacement remains after the rotation axis acts," which is exactly the geometry of rigid motion; in the ablation, Naive SE(3) (still a global origin, with rotation and translation optimized independently) is the worst configuration of all, empirically confirming that this coupling is not an optional engineering detail.

2. Hierarchical Bézier residual decomposition: describing curvature only where the primitive is actually supervised

A continuous se(3) coefficient is still an algebraic helix if it is a single constant twist, so it cannot express genuine nonlinear acceleration and deceleration. TRiGS decomposes \(\zeta_i(t)\) into a learnable base term \(\zeta_i^{\mathrm{base}}\) and a time-varying residual \(\zeta_i^{\mathrm{res}}(\tau)\) represented by a quadratic Bézier curve: the base carries the dominant overall motion trend and the Bézier curve applies a smooth fine-grained correction on top. One easily overlooked but critical design choice is that the addition happens in the Lie algebra rather than at the transform level — se(3) is a vector space, so the sum of two coefficients is still a valid se(3) element and its exponential map is still a strict rigid transform; had the residual been composed multiplicatively in SE(3), the residual itself would have to be a rigid transform and expressiveness would shrink instead.

The residual's domain is deliberately narrowed to the primitive's effective temporal window \(W_i=[\mu_{t,i}-2s_{t,i},\ \mu_{t,i}+2s_{t,i}]\). The reason comes from the temporal opacity \(\gamma_i(t)=\exp\!\big(-(t-\mu_{t,i})^2/(2s_{t,i}^2)\big)\), which decays rapidly with distance so a primitive receives essentially no gradient outside the window. Letting the model extrapolate freely in weakly supervised regions only produces drift, so global time is mapped to a normalized coordinate \(\tau\in[0,1]\) inside the window and clamped, and the residual is defined over \(\tau\):

\[\zeta_i^{\mathrm{res}}(\tau)=(1-\tau)^2\zeta_i^{(0)}+2(1-\tau)\tau\,\zeta_i^{(1)}+\tau^2\zeta_i^{(2)},\qquad \zeta_i(t)=\zeta_i^{\mathrm{base}}+\zeta_i^{\mathrm{res}}(\tau)\]

where \(\zeta_i^{\mathrm{base}},\zeta_i^{(0)},\zeta_i^{(1)},\zeta_i^{(2)}\in\mathfrak{se}(3)\) are all learnable, with rotation and translation components parameterized together — this is what separates it from "put a spline on translation only": the Linear + Bézier configuration in the ablation applies nonlinear curves to unconstrained translation alone and improves PSNR only from 24.83 to 25.10, far short of the Full model that places curvature inside se(3), showing that nonlinear trajectories alone cannot substitute for geometric consistency.

3. Local anchor-centered deformation: a per-primitive center of rotation with disambiguating gauge fixing

Applying the SE(3) transform directly as \(\mu_i(t)=R_i(t)\mu_i+p_i(t)\) implicitly assumes that all primitives rotate about the same center, whereas real dynamic scenes contain parts (limbs, wheels, objects being swung) that each have their own center of rotation. TRiGS therefore gives every primitive a learnable local anchor \(a_i\in\mathbb R^3\) and performs the transform about it: \(\mu_i(t)=R_i(t)\,(\mu_i-a_{i,\perp}(t))+a_{i,\perp}(t)+p_{i,\parallel}(t)\).

The anchor itself is not uniquely identifiable, however — the same deformation admits infinitely many \((a_i,p_i(t))\) explanations, which introduces a second kind of ambiguity. The authors remove it with one step of gauge fixing: since \((I-R_i(t))\bar\omega_i(t)=0\) (rotating about one's own axis leaves the axis direction unchanged), the component of the anchor along the rotation axis lies in the null space of this transform and is unobservable from translation. The anchor is thus projected onto the plane orthogonal to the rotation axis, \(a_{i,\perp}(t)=a_i-\langle a_i,\bar\omega_i(t)\rangle\bar\omega_i(t)\), and the translational part keeps only its component along the rotation axis, \(\upsilon_{i,\parallel}(t)=\langle\upsilon_i(t),\bar\omega_i(t)\rangle\bar\omega_i(t)\). After this step the decomposition of \(a_i\) and \(p_i\) is unique and the optimization no longer oscillates between equivalent solutions — in the ablation, removing gauge fixing costs the most of all optimization components (PSNR 26.05 → 25.15), showing the ambiguity is not merely theoretical but directly destabilizes the translational component. The covariance is rotated only, \(\Sigma_i(t)=R_i(t)\,\Sigma_i\,R_i(t)^\top\), so the orientation follows the rigid body while the shape is unchanged; the closed-form SE(3) exponential map, the gauge-fixing derivation, and small-angle numerical stabilization are deferred to the supplementary material.

4. Motion-guided relocation: moving capacity to where it is needed under a fixed budget

In standard 3DGS, error is removed by gradient-driven densification that keeps splitting primitives — and that growth in primitive count is exactly what collapses on long sequences. TRiGS goes the other way: standard densification is disabled for the whole training run, the primitive count is locked at 0.50M, and a periodic relocation strategy redistributes capacity within that constant budget. Every \(N=100\) iterations, primitives are split by opacity into a redundant set below the threshold \(\tau_\alpha=0.005\), \(\mathcal I=\{i\mid\sigma(\alpha_i)<\tau_\alpha\}\), and an active set \(\mathcal A\); a source primitive is then sampled from the active set with weight \(q_i\propto s_i\) and cloned to replace one element of \(\mathcal I\), so the replaced primitive exits and the total count is unchanged. The sampling weight combines a primitive's opacity with motion-difficulty cues (the equation is garbled in the cached text and the concrete definition lives in the supplementary material — ⚠️ refer to the original paper). The effect is to push capacity proactively toward regions with complex motion and large rendering error rather than waiting for gradients to spawn new primitives: this is precisely why the method covers 1200 frames with 0.5M primitives, and the direct source of its constant memory.

Loss & Training¶

The objective adds motion regularizers on top of the 3DGS rendering loss:

\[\mathcal L=\lambda_{img}\mathcal L_{img}+\lambda_{ssim}\mathcal L_{ssim}+\lambda_{reg}\mathcal L_{reg}+\lambda_{motion}\mathcal L_{motion}+\lambda_{rigid}\mathcal L_{rigid}\]

where \(\mathcal L_{reg}\) follows FTGS in constraining primitive parameters. \(\mathcal L_{motion}=\|b_i\|_2^2\) penalizes the second difference of the quadratic Bézier control points, \(b_i=\zeta_i^{(0)}-2\zeta_i^{(1)}+\zeta_i^{(2)}\), i.e. the "acceleration" of the residual curve — computed for both rotation and translation components — to suppress abrupt bends in the trajectory and keep motion smooth in time inside the window. \(\mathcal L_{rigid}\) encourages spatially coherent motion: over k-nearest neighbors in canonical space (\(K=3\)), an appearance affinity \(K_{ij}\) built from the primitives' DC spherical-harmonic colors \(c_i\) acts as a soft weight aligning the neighbors' base motion, so motion is smooth within a region while discontinuities at object boundaries are preserved (avoiding incorrect coupling across objects). Hyper-parameters are \(\lambda_{reg}=0.01\), \(\lambda_{motion}=10^{-4}\), \(\lambda_{rigid}=1.0\), \(\lambda_c=50\); training uses Adam for 30k iterations with the same settings as 3DGS; the point cloud is initialized with RoMa; all experiments run on a single RTX 4090.

Key Experimental Results¶

Main Results¶

On SelfCap, the original sequences are edited into 600/900/1200-frame versions to test long-horizon stability and scalability (Table 1; the reproduced FTGS is marked *):

Sequence length	Metric	TRiGS	FTGS*	LocalDyGS	4DGS	STGS
600 frames	PSNR↑ / SSIM↑ / LPIPS↓	26.67 / 0.937 / 0.113	26.23 / 0.913 / 0.121	25.49 / 0.858 / 0.240	24.30 / 0.860 / 0.227	24.17 / 0.844 / 0.161
900 frames	PSNR↑ / SSIM↑ / LPIPS↓	26.32 / 0.916 / 0.120	25.86 / 0.898 / 0.132	23.51 / 0.838 / 0.280	23.48 / 0.851 / 0.240	23.01 / 0.864 / 0.136
1200 frames	PSNR↑ / SSIM↑ / LPIPS↓	26.05 / 0.904 / 0.099	25.41 / 0.871 / 0.146	24.24 / 0.884 / 0.116	23.28 / 0.851 / 0.233	25.34 / 0.734 / 0.100

It also leads on the standard-length N3V benchmark (Table 2), where † marks the original paper's self-reported numbers and * marks this paper's reproduction:

Method	PSNR↑	DSSIM₁↓	DSSIM₂↓	LPIPS↓
FTGS†	32.97	0.028	0.014	0.043
FTGS*	32.80	0.021	—	0.040
LocalDyGS	32.28	0.028	0.014	0.043
Swift4D	32.23	—	0.014	0.043
DASH	32.22	—	—	—
Ex4DGS	32.11	0.030	0.015	0.048
STGS	32.05	0.026	0.014	0.044
4DGS	32.01	—	0.014	0.055
TRiGS	33.36	0.019	0.010	0.031

Efficiency is the most convincing table in the paper (Table 3): across all three lengths TRiGS holds 0.5M primitives, 160 MB, and 110+ FPS, while baselines' primitive counts and memory grow monotonically with the sequence.

Method	600 frames (FPS / primitives / memory)	900 frames	1200 frames
GIFStream	94 / 6.47M / 1586 MB	98 / 8.85M / 2169 MB	102 / 11.53M / 2825 MB
4DGS	43 / 2.51M / 4665 MB	43 / 2.70M / 5021 MB	44 / 2.70M / 5015 MB
STGS	90 / 1.31M / 190 MB	83 / 2.01M / 291 MB	90 / 2.45M / 355 MB
FTGS*	113 / 2M / 490 MB	110 / 3M / 733 MB	106 / 4M / 977 MB
TRiGS	116 / 0.5M / 160 MB	111 / 0.5M / 160 MB	120 / 0.5M / 160 MB

Ablation Study¶

The core-component ablation is run on the 1200-frame sequence (Table 4). One caveat matters here: Full TRiGS is strictly locked at 0.50M primitives with no standard densification because of its relocation strategy, while the ablated baseline configurations were deliberately allowed gradient-based densification — the point is to measure the upper-bound capability of each motion model, since forcing them to 0.50M would make them collapse outright.

Configuration	Trajectory	Anchor	Base Param.	PSNR↑	SSIM↑	LPIPS↓	#Gaussians	Memory
Baseline	Linear	None	R³	24.83	0.865	0.162	2.10M	512 MB
Naive SE(3)	Rigid Body	Origin	SO(3)×R³	23.95	0.842	0.198	2.85M	694 MB
Local SE(3)	Rigid Body	Local	se(3)	25.52	0.891	0.125	0.60M	185 MB
Linear + Bézier	Non-linear	None	R³	25.10	0.873	0.145	1.85M	450 MB
Full TRiGS	Non-linear	Local	se(3)	26.05	0.904	0.099	0.50M	160 MB

The optimization-component ablation is likewise on the 1200-frame sequence (Table 5):

Configuration	PSNR↑	SSIM↑	LPIPS↓	Note
w/o Gauge Fixing	25.15	0.880	0.134	largest drop (−0.90) without anchor gauge fixing
w/o Rigid Reg.	25.48	0.885	0.128	neighbor motions lose alignment, slight surface tearing
w/o Motion Smoothness	25.66	0.892	0.115	jittery, temporally inconsistent trajectories
w/o Motion-guided Relocation	25.80	0.897	0.108	redundant primitives cannot be recycled, lower capacity
Full TRiGS	26.05	0.904	0.099	full model

Key Findings¶

Gauge fixing is the single most valuable design: removing it costs 0.90 PSNR (26.05 → 25.15), more than any regularizer. The reason is already planted in the method — the anchor's axis-parallel component sits in the null space of \((I-R)\), so leaving it ambiguous keeps the translational component structurally unstable; this is an optimization-landscape pathology, not a lack of modeling capacity.
Independent rotation/translation parameterization is actively harmful, not merely suboptimal: Naive SE(3) (global origin plus decoupled SO(3)×R³ optimization) reaches the lowest 23.95 PSNR of the entire table, even below the pure linear baseline (24.83). This directly supports the core claim — geometric constraints require coupled parameterization at the same time; adding rotation without coupling only introduces more drift-prone degrees of freedom.
Quality and scale need not be tied for explicit models: even after Naive SE(3) is allowed to split up to 2.85M primitives and the Baseline to 2.10M, neither reaches TRiGS at 0.50M (26.05). Brute-force capacity scaling cannot fix trajectory error — extra primitives merely mask structural misalignment at 3-4x the memory.
The slope of degradation with length is more telling than the absolute number: from 600 to 1200 frames, FTGS loses 0.82 PSNR (26.23 → 25.41) and doubles its memory, whereas TRiGS loses only 0.62 (26.67 → 26.05) with constant memory. Baselines show ghosting, blur, and structural degradation in fast-moving regions (limbs, wheels), while TRiGS keeps sharp detail in the same places.
The gain holds across lengths: on N3V, which is only ~300 frames, TRiGS still leads at 33.36 PSNR / 0.031 LPIPS, indicating the method does not win by some long-sequence-specific trade-off — higher per-primitive motion capacity helps at every length.
A comparison caveat worth noting: FTGS's official code is unavailable, so the FTGS* entries in Tables 1 and 3 come from the authors' reproduction. The reproduction roughly matches the original N3V report (32.80 vs. the self-reported 32.97, slightly lower); how much that gap amplifies at 1200 frames is never quantified separately, so the long-sequence comparison retains residual uncertainty.

Highlights & Insights¶

Decoupling motion capacity from primitive count: the mainstream move is to make primitives freer (arbitrary appearance/disappearance, short lifetimes, piecewise linear motion) and add primitives when problems appear; TRiGS does the opposite — thicken the motion model, pin the primitive budget, then push that budget toward hard regions via relocation. This "add constraints, cut resources" pattern transfers to any resource-constrained temporal representation.
Add in the vector space, evaluate on the group: defining both the base term and the Bézier residual in se(3), summing them, and passing the sum through a single exponential map is the paper's most elegant step — it gains the freedom to superpose motion sources without breaking rigidity. Composing multiplicatively in SE(3) instead would force the residual to be a rigid transform and weaken expressiveness.
Using visibility to delimit the parameterization: temporal opacity was originally just a rendering visibility weight; here it is reused as the criterion for "over which interval this primitive is actually supervised," which then becomes the Bézier residual's domain and clamp boundary. Aligning a parameter's active region with the actual support of the gradient is a general remedy against drift in weakly supervised zones, portable to any representation with a temporal or spatial window.
Gauge fixing to kill null-space ambiguity: the identity \((I-R)\bar\omega=0\) turns "the anchor's axis-parallel component is unobservable" into a degree of freedom that can be removed analytically, at zero cost and with the largest payoff. Any decomposition of the "center of rotation plus translation" kind with an unidentifiable direction (relative pose in two views, skeletal joint-center estimation) can reuse the same projection-based disambiguation.

Limitations & Future Work¶

The rigid-body assumption is a hard constraint for non-rigid deformation: the covariance is only rotated, \(\Sigma(t)=R\Sigma R^\top\), so primitives cannot stretch, shear, or change scale, and the mean can only follow a rigid trajectory. Cloth, fluids, smoke, and soft-body compression can only be "patched" by many primitives each moving rigidly — exactly the path the paper set out to avoid. The paper states geometrically consistent rigid motion as a premise and does not discuss topology change (tearing, newly appearing surfaces).
Dependence on dense-matching point-cloud initialization: all experiments initialize from a RoMa point cloud and emphasize using the same cloud for fair comparison. There is no sensitivity analysis of how initialization quality affects long sequences, nor of behavior in scenes where reliable dense matching is unavailable (weak texture, specularity).
The evaluated long sequences are edited, not native: the 600/900/1200-frame versions are constructed by editing the original SelfCap videos rather than being natively captured long videos. The effect of this construction on motion statistics and trajectory continuity is not discussed, so behavior on genuine long videos (with cuts or large camera motion) remains unknown.
Training cost is missing: the paper reports inference FPS and memory but no wall-clock training time or per-GPU cost on the RTX 4090. Since each primitive additionally optimizes an anchor, an se(3) base term, and three Bézier control points, a training-cost comparison against 3DGS/FTGS is data readers will want.
The relocation sampling weight is opaque: the sampling probability \(q_i\propto s_i\) depends on "normalized difficulty cues" whose definition lives in the supplementary material (the equation is garbled in the cached text), yet relocation contributes measurably in the ablation (−0.25 PSNR). Ablations over different difficulty cues or relocation periods are not shown in the main paper.
Possible improvements: replacing \(J(\phi)\upsilon\) with an affine exponential map that allows scale/shear (i.e. permitting symmetric deformation degrees of freedom) could cover non-rigid cases while keeping the "continuous, few primitives" advantage; folding the window length \(s_{t,i}\) into relocation decisions (currently relocation only redistributes primitives, not their temporal coverage) might further reduce gaps in the middle of long sequences.

vs FTGS (FreeTimeGS): FTGS is the most direct baseline and comparison object — it uses linear translational velocity plus a short temporal opacity window so that primitives can appear anytime and anywhere, maximizing temporal freedom on top of 3DGS. TRiGS keeps its temporal visibility formulation and part of its regularizers but replaces the motion model \(\mu_i+v_i(t-\mu_{t,i})\) with a full hierarchical SE(3) trajectory. TRiGS is better on short sequences and its advantage widens on long ones (the quality gap grows from 0.44 to 0.64 PSNR from 600 to 1200 frames), with a quarter to an eighth of the primitives.
vs 4DGS / STGS / Ex-4DGS: these use 4D voxel-plane decomposition, spatiotemporal features, or fully explicit primitive motion parameterization respectively; they share independently optimized motion parameters without geometric coupling constraints, so primitives and memory swell together on long sequences (4DGS holds roughly 5 GB steadily on SelfCap). TRiGS differs not by swapping a module but by writing "motion must be geometrically self-consistent" into the parameterization as a prior.
vs implicit deformation fields (Deformable-3DGS / DASH / LocalDyGS): these describe deformation with a canonical space plus a neural field and have no explicit notion of temporal identity, so deformation error accumulates over long horizons and drift must be suppressed by tuning regularizers and initialization; LocalDyGS splits the scene into several local spaces, a notion related to TRiGS's local anchors, but its locality comes from spatial partitioning rather than from the motion model itself.
vs Shape of Motion (spline motion prior): that work reconstructs 4D from a single video with adaptive splines and likewise emphasizes continuous motion; the difference is that TRiGS grounds continuity in SE(3) rigid-body structure and targets scalability on multi-view long sequences. Note that Shape of Motion appears only in the citations and related work here — it is not in any comparison table, so no relative performance should be inferred (⚠️ the original paper does not run this experiment).

Rating¶

Novelty: ⭐⭐⭐⭐ Combining the se(3) exponential map, a hierarchical Bézier residual inside the Lie algebra, and local-anchor gauge fixing into one coherent motion parameterization; each ingredient has ablation support. The individual techniques (exponential map, Bézier, anchors) are not new — the contribution is the unifying "geometric coupling" view.
Experimental Thoroughness: ⭐⭐⭐⭐ Longitudinal and cross-method comparisons on three SelfCap lengths plus N3V, four ablation groups (core components and optimization terms separated), and an efficiency table; points off for constructing the long sequences by editing the source videos, the strongest baseline being available only as a self-reproduction, and training cost going unreported.
Writing Quality: ⭐⭐⭐⭐ The motivation chain (temporal fragmentation → primitive proliferation → memory blow-up) is clear, and the ablations echo the theoretical analysis in Sec. 3; some equations are typographically broken (notably the relocation sampling weight), requiring the supplementary material.
Value: ⭐⭐⭐⭐ On the practical problem of memory-constrained long-video 4D reconstruction, it offers a low-cost motion module that can be swapped in directly, and the constant 160 MB / 1200 frames / 110+ FPS overhead is persuasive; the biggest uncertainty is how much of the real world the rigid-body prior covers.