Temporal Dynamic Anchor Updater

• Temporal Dynamic Anchor Updater is a family of mechanisms that adapt anchor entities to maintain temporal coherence and manage deformation, emergence, and drift.
• It encompasses diverse strategies across mesh compression, dynamic Gaussian splatting, video segmentation, and federated learning using Kalman filtering, learned deformations, and query-based methods.
• These approaches jointly optimize temporal support, update rules, and connectivity preservation to achieve state-of-the-art performance in compression, rendering, and segmentation.

Searching arXiv for the cited papers to ground the article in current preprints. Searching arXiv for ([2510.22646](/papers/2510.22646)), ([2505.08196](/papers/2505.08196)), ([2501.03714](/papers/2501.03714)), ([2404.00086](/papers/2404.00086)), ([2408.06437](/papers/2408.06437)), ([2412.18355](/papers/2412.18355)), ([2512.09270](/papers/2512.09270)), and ([2012.10860](/papers/2012.10860)). Temporal Dynamic Anchor Updater denotes a class of mechanisms that update anchor entities over time so that temporal coherence, deformation, emergence and disappearance, or feature-space drift can be handled within a structured representation. In the cited literature, anchors take several forms: mesh vertices with reused connectivity in time-varying mesh compression, sparse canonical points that drive dynamic Gaussian primitives, appearance-conditioned query tokens in video segmentation, action proposals in online temporal localization, virtual anchor positions in spatio-temporal point-cloud convolution, and trainable vectors mixed with frozen features in federated continual learning (Huang et al., 26 Oct 2025, Huang et al., 13 May 2025, Kwak et al., 7 Jan 2025, Zhou et al., 2024, Reza et al., 2024, Wang et al., 2020, Yu et al., 2024, Kwak et al., 10 Dec 2025). Across these settings, the updater is not a single algorithm but a family of temporal adaptation rules built around anchors as compact, structured carriers of state.

1. Domain scope and anchor semantics

The term spans multiple technical lineages. In TVMC, the updater is explicitly identified with the multi-stage anchor mesh generation pipeline: an initial anchor mesh is created by fast topology alignment, then corrected by Kalman-filter motion estimation, and finally refined by Quadric Error Metrics while preserving the connectivity of the decoded reference base mesh (Huang et al., 26 Oct 2025). In dynamic Gaussian splatting, the same phrase is used for learned anchor deformation and refinement, but the anchors are sparse canonical points or key-frame anchor sets rather than mesh vertices (Kwak et al., 7 Jan 2025, Huang et al., 13 May 2025, Kwak et al., 10 Dec 2025).

In query-based video models, the anchor is a query token. DVIS-DAQ dynamically generates emergence and disappearance anchor queries from candidate-object features and tracked-object momentum features, rather than relying on a static background query (Zhou et al., 2024). HAT uses learnable anchor queries for temporal proposals, then refines them by cross-attending to history compressed from a long-term feature buffer (Reza et al., 2024). FedTA moves the notion further into feature space: a trainable Tail Anchor is mixed with a frozen ViT output feature after a nearest-key lookup, so the “update” is a displacement in representation space rather than in geometry (Yu et al., 2024).

A concise comparison is given below.

Work	Anchor entity	Temporal update rule
TVMC	Reference-base-mesh vertices	Octree matching, Kalman fusion, QEM refinement
MoDec-GS / ADC-GS / MoRel	Sparse anchors or key-frame anchors	Learned deformation, interval adjustment, grow/prune, bidirectional blending
DVIS-DAQ / HAT	Query anchors	Appearance-conditioned generation or history-conditioned refinement
FedTA	Tail Anchor vector	Nearest-key selection and additive mixing
ASTA3DConv	Virtual anchors around core points	Fixed anchor layout with changing spatio-temporal neighborhoods

A useful boundary case is ASTA3DConv. Its method is anchor-based and spatio-temporal, but the virtual anchors do not explicitly move from frame to frame; each anchor remains centered on its core point at its own timestamp, and what changes is the set of neighboring raw points gathered across frames (Wang et al., 2020). This clarifies that temporal anchoring can arise either from explicit anchor updates or from time-varying aggregation around fixed anchors.

2. TVMC and multi-stage anchor mesh generation

In "TVMC: Time-Varying Mesh Compression via Multi-Stage Anchor Mesh Generation" (Huang et al., 26 Oct 2025), the updater is a deterministic three-stage procedure operating on a decoded reference base mesh $B_{t-1}$ and the new input mesh $M_t$. The initial anchor mesh is obtained by fast topology alignment. An octree is built over the vertices of $M_t$, and for each vertex $V_{B_{t-1}^i}$ a nearest-neighbor query finds its counterpart $V_{M_t^i}$. The correspondence objective is written as

$$\arg \min_{\{V_{M_t^i}\}} \sum_i \|V_{B_{t-1}^i}-V_{M_t^i}\|_2,$$

subject to copying the connectivity of $B_{t-1}$ onto the matched vertices. The complexity is stated as $O(N\log N)$ for octree construction plus one $O(\log N)$ nearest-neighbor search per reference vertex, for a total of approximately $O(N\log N)$, compared with Hungarian matching at $M_t$0 (Huang et al., 26 Oct 2025).

The coarse anchor mesh is then produced by a Kalman filter-based motion estimation module. Each vertex motion vector $M_t$1 is treated as the hidden state $M_t$2 under a constant-velocity model with identity dynamics, $M_t$3, and identity measurement matrix, $M_t$4, with zero-mean Gaussian process and measurement noise of covariances $M_t$5 and $M_t$6. The standard Kalman prediction and update equations are used:

$M_t$7

$M_t$8

$M_t$9

Operationally, the predicted motion $M_t$0 and the measured motion $M_t$1 from local neighbor averaging are fused into

$M_t$2

after which the vertex is displaced and a local nearest-neighbor search in $M_t$3 locks in the coarse anchor position $M_t$4 (Huang et al., 26 Oct 2025).

The fine anchor mesh is obtained by Quadric Error Metric refinement. For each vertex,

$M_t$5

where $M_t$6 are incident-face plane equations. For an edge $M_t$7,

$M_t$8

and the local relocation minimizes

$M_t$9

The procedure evaluates incident edges, collapses the edge with minimal cost, replaces the vertex by the optimal $V_{B_{t-1}^i}$0, updates adjacency and quadrics, and repeats once per anchor vertex or until the maximum cost reduction falls below $V_{B_{t-1}^i}$1 (Huang et al., 26 Oct 2025).

Within the hierarchical compression scheme, inter-frame motion vectors

$V_{B_{t-1}^i}$2

are entropy-encoded by arithmetic coding, while residual displacements between a subdivided fine anchor mesh and the input mesh are adaptively quantized as

$V_{B_{t-1}^i}$3

The residuals are then packed as video frames, such as HEVC or VVC, for the final bitstream. TVMC reports that standard MPEG dynamic mesh sequences show state-of-the-art compression performance and a BD-rate gain of $V_{B_{t-1}^i}$4 over V-DMC while preserving high reconstruction quality (Huang et al., 26 Oct 2025).

A central property of this updater is that connectivity is guaranteed by construction. The initial topology-alignment step reuses the entire connectivity of $V_{B_{t-1}^i}$5, and neither the Kalman-filter stage nor the QEM stage changes vertex-to-face adjacency; only vertex positions move. Temporal fidelity is evaluated by D1 and D2 PSNR, with the stated claim that no graph-edit distortions creep in because graph connectivity is reused exactly (Huang et al., 26 Oct 2025).

3. Learned anchor deformation in dynamic Gaussian representations

Dynamic Gaussian methods adopt learned temporal anchor updates, but they differ in whether the update acts on anchor attributes, anchor population, temporal support, or bidirectional blending.

MoDec-GS introduces Global-to-Local Motion Decomposition. Each static anchor $V_{B_{t-1}^i}$6 has position $V_{B_{t-1}^i}$7, learnable offset $V_{B_{t-1}^i}$8, local context feature $V_{B_{t-1}^i}$9, and scale vector $V_{M_t^i}$0. Over a temporal segment $V_{M_t^i}$1 with canonical time $V_{M_t^i}$2, a multi-resolution 4D feature grid $V_{M_t^i}$3 is queried and decoded into deformation deltas

$V_{M_t^i}$4

Two scalar gates, $V_{M_t^i}$5 and $V_{M_t^i}$6, separate global motion from local attribute deformation. With the binarized global mask $V_{M_t^i}$7 and the smooth local mask $V_{M_t^i}$8, the deformed anchor variables become

$V_{M_t^i}$9

$$\arg \min_{\{V_{M_t^i}\}} \sum_i \|V_{B_{t-1}^i}-V_{M_t^i}\|_2,$$0

Temporal Interval Adjustment then learns non-uniform segment boundaries. It accumulates positional gradient norms $$\arg \min_{\{V_{M_t^i}\}} \sum_i \|V_{B_{t-1}^i}-V_{M_t^i}\|_2,$$1 per segment, computes segment means $$\arg \min_{\{V_{M_t^i}\}} \sum_i \|V_{B_{t-1}^i}-V_{M_t^i}\|_2,$$2, global mean $$\arg \min_{\{V_{M_t^i}\}} \sum_i \|V_{B_{t-1}^i}-V_{M_t^i}\|_2,$$3, and standard deviation $$\arg \min_{\{V_{M_t^i}\}} \sum_i \|V_{B_{t-1}^i}-V_{M_t^i}\|_2,$$4, and shrinks intervals whose mean exceeds $$\arg \min_{\{V_{M_t^i}\}} \sum_i \|V_{B_{t-1}^i}-V_{M_t^i}\|_2,$$5 by stepping boundaries with $$\arg \min_{\{V_{M_t^i}\}} \sum_i \|V_{B_{t-1}^i}-V_{M_t^i}\|_2,$$6 (Kwak et al., 7 Jan 2025). The reported result is an average $$\arg \min_{\{V_{M_t^i}\}} \sum_i \|V_{B_{t-1}^i}-V_{M_t^i}\|_2,$$7 reduction in model size over state-of-the-art methods, with storage in the $$\arg \min_{\{V_{M_t^i}\}} \sum_i \|V_{B_{t-1}^i}-V_{M_t^i}\|_2,$$8-$$\arg \min_{\{V_{M_t^i}\}} \sum_i \|V_{B_{t-1}^i}-V_{M_t^i}\|_2,$$9 MB range while maintaining or improving rendering quality (Kwak et al., 7 Jan 2025).

ADC-GS uses an anchor-based structure in canonical space, where each anchor spawns $B_{t-1}$0 neural Gaussians and temporal significance controls anchor refinement. The per-Gaussian accumulated significance is

$B_{t-1}$1

with $B_{t-1}$2 defined by the $B_{t-1}$3-blending contribution over covered pixels. If $B_{t-1}$4, the primitive is promoted to a new anchor; if the time-average opacity of all primitives under an anchor falls below $B_{t-1}$5, the anchor is discarded. Deformation itself is hierarchical: a coarse MLP $B_{t-1}$6 predicts anchor-level changes $B_{t-1}$7 from $B_{t-1}$8, and a fine MLP $B_{t-1}$9 predicts local opacity and color refinements from $O(N\log N)$0 (Huang et al., 13 May 2025). Compression is coupled to a rate-distortion objective

$O(N\log N)$1

The paper reports rendering-speed gains of $O(N\log N)$2 over per-Gaussian deformation approaches, and on HyperNeRF gives an ablation in which temporal anchor refinement changes PSNR from $O(N\log N)$3 to $O(N\log N)$4, SSIM from $O(N\log N)$5 to $O(N\log N)$6, FPS from $O(N\log N)$7 to $O(N\log N)$8, and size from approximately $O(N\log N)$9 MB to approximately $O(\log N)$0 MB (Huang et al., 13 May 2025).

MoRel addresses long-range 4D motion by progressively constructing locally canonical anchor spaces at key-frame indices $O(\log N)$1. Each key-frame anchor set $O(\log N)$2 inherits level labels from a trained global anchor set and is paired with a bidirectional deformation field

$O(\log N)$3

After learning these deformation fields, adjacent key-frame anchors are blended by learnable opacity control

$O(\log N)$4

which yields blended opacity and color from forward and backward deformations. Feature-variance-guided Hierarchical Densification assigns anchor levels by feature variance and uses level-weighted gradient statistics

$O(\log N)$5

to determine growth and pruning (Kwak et al., 10 Dec 2025). The stated consequences are bounded memory, because at most two KfAs and their deformation fields are loaded at once, and flicker-free rendering, because chunk-boundary transitions are blended rather than switched abruptly (Kwak et al., 10 Dec 2025).

Taken together, these Gaussian methods show three distinct updater functions: changing anchor attributes, changing anchor count, and changing temporal responsibility. A plausible implication is that dynamic anchors become most effective when temporal support, deformation granularity, and representational cost are optimized jointly rather than in isolation.

4. Query-conditioned and history-conditioned anchor updates

In video segmentation, DVIS-DAQ replaces static background-anchor queries with Dynamic Anchor Queries generated from object-specific features. For frame $O(\log N)$6, a candidate-object appearance feature is extracted by

$O(\log N)$7

For emergence, each of the top-$O(\log N)$8 candidates receives a query whose query-feature embedding is a shared learnable vector and whose positional embedding is the candidate appearance:

$O(\log N)$9

For disappearance, each tracked object maintains a momentum-weighted appearance feature

$O(N\log N)$0

with

$O(N\log N)$1

and the disappearance query uses this momentum feature as positional embedding plus the initial segmenter query with maximal cosine similarity as feature embedding (Zhou et al., 2024). Tracker 1 processes Continuously Tracked Queries plus emergence DAQs; Tracker 2 processes disappearance DAQs plus a small set of learnable background queries, with SoftMax along the query dimension to avoid duplicate disappearance assignments. During training, Emergence and Disappearance Simulation drops subsets of CTQ and $O(N\log N)$2 so that rare transitions are explicitly learned. The paper states that DAQ alone slightly degrades AP, but DAQ combined with EDS lifts AP by $O(N\log N)$3 on OVIS (Zhou et al., 2024).

HAT applies a related logic to online temporal action localization, but the update is driven by cross-attention to long-term history. The frame queue is split into a history block $O(N\log N)$4 and a short-term window $O(N\log N)$5. Learnable history tokens $O(N\log N)$6 are decoded over $O(N\log N)$7 to produce compressed history $O(N\log N)$8, a lightweight anticipation head predicts window-level action presence from $O(N\log N)$9, and the compressed history is refined against the current short-term context to yield

$M_t$00

In parallel, learnable anchor queries $M_t$01 are decoded over the encoded short-term window to form initial anchor features $M_t$02. These are then refined by attending to $M_t$03:

$M_t$04

The resulting anchor set is classified and regressed into online proposals (Reza et al., 2024). The training loss combines Adaptive Focal Loss for classification, $M_t$05 losses for end-offset and log-length-ratio regression, and an auxiliary anticipation loss:

$M_t$06

Reported gains over OAT are $M_t$07 on EGTEA, $M_t$08 on EPIC-Kitchen-100, $M_t$09 on THUMOS’14, and $M_t$10 on MUSES (Reza et al., 2024).

Both systems shorten a transition that would otherwise be difficult to learn. In DVIS-DAQ the transition is from background to a newly emerged object or from tracked object to background; in HAT it is from short-term anchor evidence to temporally contextualized action proposals. This suggests a shared updater principle: anchor refinement is easiest when the anchor is initialized close to the target state, either by appearance pooling or by history-aware decoding.

5. Feature-space anchor updates in federated continual learning

FedTA uses a Temporal Dynamic Anchor Updater in a non-geometric setting. Its Tail Anchor mechanism mixes a trainable anchor with a frozen ViT output feature to adjust the feature’s position in the embedding space. Given a frozen feature $M_t$11, trainable anchors $M_t$12, and anchor keys $M_t$13, the selected anchor index is obtained by nearest-key lookup under cosine distance:

$M_t$14

The simplest released implementation performs additive mixing,

$M_t$15

while a more general interpolation

$M_t$16

is also described (Yu et al., 2024).

Training is divided into Input Enhancement and Tail Anchor Learning. Input Enhancement prepends selected enhancement blocks to the raw patch embedding sequence and minimizes

$M_t$17

Tail Anchor Learning then optimizes anchored features with a task head by the loss

$M_t$18

where the contrastive term aligns the anchored feature to the current global prototype $M_t$19 of class $M_t$20 (Yu et al., 2024). After local training, each client computes a local class prototype

$M_t$21

and the server performs Selective Input Knowledge Fusion using a surrogate dataset and Best Global Prototype Selection using pairwise cosine-distance matrices over local prototypes (Yu et al., 2024).

The paper’s interpretation is explicit: freezing the ViT avoids parameter-forgetting, while mixing in a learned anchor offset pulls each sample’s feature back toward a common prototype region, counteracting drift caused by new tasks or non-IID client data. Here the updater therefore acts as a temporal correction operator on feature geometry rather than as a deformation field or a query generator (Yu et al., 2024).

6. Shared design patterns, evaluation criteria, and recurrent misconceptions

Several design patterns recur despite the diversity of application domains. One pattern is hierarchical updating. TVMC uses initial, coarse, and fine anchor meshes; MoDec-GS uses Global Anchor Deformation followed by Local Gaussian Deformation and Temporal Interval Adjustment; ADC-GS uses coarse anchor deformation and fine primitive refinement; MoRel separates global-anchor training, key-frame anchor construction, progressive windowed deformation, and inter-frame blending (Huang et al., 26 Oct 2025, Kwak et al., 7 Jan 2025, Huang et al., 13 May 2025, Kwak et al., 10 Dec 2025). Another pattern is gradient-guided temporal adaptation: TIA uses positional gradient norms to shrink hard temporal segments, ADC-GS uses significance-weighted pixel-space gradients to grow anchors, and MoRel uses accumulated deformation gradients modulated by level-dependent schedules for densification (Kwak et al., 7 Jan 2025, Huang et al., 13 May 2025, Kwak et al., 10 Dec 2025).

A second shared trait is that “anchor updating” does not imply topological change. TVMC states that neither the coarse Kalman-filter step nor the QEM refinement step changes vertex-to-face adjacency; connectivity is preserved exactly (Huang et al., 26 Oct 2025). ASTA3DConv makes the complementary point that its virtual anchors do not explicitly move from frame to frame at all; the temporal effect comes from changing neighborhoods and spatio-temporal attention weights, with $M_t$22 anchors arranged as a regular tetrahedron around each core point (Wang et al., 2020). A common misconception is therefore that a temporal anchor updater must explicitly move anchors or edit connectivity. The cited methods show both moving-anchor and fixed-anchor variants.

Evaluation is correspondingly heterogeneous. TVMC uses D1 and D2 PSNR and reports a BD-rate gain of $M_t$23 over V-DMC (Huang et al., 26 Oct 2025). MoDec-GS reports an average $M_t$24 reduction in model size while maintaining or improving rendering quality (Kwak et al., 7 Jan 2025). ADC-GS reports rendering-speed gains of $M_t$25 over per-Gaussian deformation approaches and, on HyperNeRF, a configuration around $M_t$26 MB at approximately $M_t$27 FPS with PSNR around $M_t$28 and SSIM around $M_t$29 (Huang et al., 13 May 2025). DVIS-DAQ reports a new SOTA on five mainstream video segmentation benchmarks and a $M_t$30 AP gain on OVIS when EDS is used (Zhou et al., 2024). HAT improves average mAP on all four listed OnTAL datasets, with the largest gains on procedural egocentric streams (Reza et al., 2024). ASTA3DConv reports $M_t$31 on MSRAction3D versus $M_t$32 without attention and $M_t$33 for MeteorNet, and on Synthia semantic segmentation reports $M_t$34 versus $M_t$35 without attention and $M_t$36 for MeteorNet (Wang et al., 2020).

A further misconception is that dynamic anchors alone suffice without auxiliary constraints or simulations. DVIS-DAQ explicitly observes that DAQ alone slightly degrades AP and requires Emergence and Disappearance Simulation to unlock its benefit (Zhou et al., 2024). HAT couples anchor refinement to an anticipation head and adaptive focal training (Reza et al., 2024). ADC-GS couples anchor refinement to a rate-distortion Lagrangian (Huang et al., 13 May 2025). FedTA couples anchor selection to prototype alignment and server-side prototype selection (Yu et al., 2024). This suggests that temporal anchor updating is most often embedded inside a larger optimization scaffold that constrains when, where, and how anchor updates are allowed to matter.