4D Scene Intelligence

4D Gaussian Splatting Storage

Gaussian Splatting represents 3D scenes as millions of oriented, colored ellipsoids. VectorScaleDB stores each Gaussian as a 13-dimensional state vector, making scenes queryable with the same temporal-semantic primitives used for any other entity type.

What is 4DGS

3D Gaussians extended through time

3D Gaussian Splatting (3DGS) reconstructs photorealistic scenes from photographs by fitting millions of 3D Gaussians — each defined by position (xyz), covariance (scale + rotation), opacity, and color (spherical harmonics). 4DGS adds the time dimension: each Gaussian can move, deform, appear, or disappear over time. VectorScaleDB is the storage engine purpose-built for this data.

Position: 3 floats (x, y, z)
Scale: 3 floats (sx, sy, sz)
Rotation: 4 floats (quaternion)
Opacity: 1 float
Color: spherical harmonics (stored separately)
Timestamp: nanosecond-precision temporal binding

13-Dim State Vector

Compact, queryable representation

Each Gaussian is encoded as a compact 13-dimensional state vector capturing position, scale, rotation, opacity, and color — optimized for temporal-semantic indexing. This representation is compact enough for efficient storage and indexing, while preserving all geometric and appearance properties needed for rendering and spatial queries.

13-dim vector fits naturally into the temporal-semantic index
Spatial KNN queries find nearby Gaussians
Cosine similarity detects appearance changes
Compression engine groups stable Gaussians into segments

Static / Dynamic / Transient Classification

Not all Gaussians behave the same way. VectorScaleDB automatically classifies each Gaussian based on its temporal behavior, enabling differentiated storage, compression, and query strategies.

Static

Unchanging scene elements

Buildings, terrain, permanent fixtures. These Gaussians show near-zero drift across time snapshots. Stored once with extreme compression ratios (10,000x+) since their state vectors are constant. Queried via spatial index only.

Dynamic

Moving or changing elements

Vehicles, people, machinery. These Gaussians exhibit meaningful state changes across snapshots. Stored with the standard compression pipeline, creating segments at regime boundaries. Full temporal-semantic queries apply.

Transient

Ephemeral artifacts

Lighting effects, reflections, reconstruction noise. These Gaussians appear in only one or a few snapshots. Identified by low temporal persistence scores and optionally filtered from storage and queries to reduce noise.

Scene Differencing Across Time

Compare two snapshots of the same scene and get a structured diff of what changed — not just pixel differences, but semantically meaningful spatial changes.

Spatial Diff

What moved, appeared, or disappeared

Scene differencing compares Gaussians between two timestamps using spatial proximity and state-vector similarity. The result is a structured changeset:

Added: Gaussians present in T2 but not T1
Removed: Gaussians present in T1 but not T2
Moved: Matched Gaussians with position delta above threshold
Modified: Matched Gaussians with appearance changes
Unchanged: Count of stable Gaussians (not returned by default)

Applications

From construction monitoring to security

Scene differencing powers a wide range of use cases where understanding spatial change over time is critical:

Construction progress tracking (daily/weekly diffs)
Perimeter security (detecting unauthorized changes)
Inventory management (warehouse shelf diffs)
Environmental monitoring (erosion, vegetation change)
Forensic analysis (crime scene temporal reconstruction)

LOD Streaming

Deliver scene data at the right fidelity for the client's viewport and bandwidth, from coarse overviews to full-resolution detail.

Level of Detail

Progressive scene delivery

VectorScaleDB organizes Gaussians into LOD tiers based on their visual contribution (opacity-weighted scale). Clients request a LOD level and receive only the Gaussians needed for that fidelity, reducing bandwidth by 10-100x for distant or overview views.

LOD 0: Coarse overview (largest, most opaque Gaussians)
LOD 1-3: Progressive detail refinement
LOD max: Full-resolution scene
Viewport-aware culling reduces transmitted Gaussians further

Streaming

Real-time progressive loading

The LOD streaming endpoint supports both request-response and server-sent events (SSE) for progressive loading. Clients can request a coarse view immediately, then progressively refine as bandwidth allows, providing an instant "hero view" while detail loads in the background.

SSE for progressive refinement
Delta-only updates for subsequent LOD levels
Configurable quality targets per LOD tier
Bandwidth-adaptive tier selection

Anchor-Relative Storage & Native Ingestion

Spatial consistency across time snapshots and direct ingestion from industry-standard formats.

Spatial Consistency

Anchor-relative offset storage

Real-world scene captures rarely have perfectly aligned coordinate systems between sessions. VectorScaleDB stores Gaussian positions as offsets from user-defined anchor points (GPS coordinates, survey markers, or fixed scene elements). This ensures that scene diffs and temporal queries produce accurate results even when raw capture coordinates drift.

Anchor points defined per scene or per capture session
Automatic coordinate transformation on ingestion
Multiple anchor systems for large-area scenes
Sub-centimeter alignment accuracy with surveyed anchors

Ingestion

SPZ and glTF native support

VectorScaleDB ingests Gaussian Splatting data directly from industry formats without external preprocessing:

SPZ: Niantic's compressed splat format — parsed and indexed directly
glTF: Khronos standard 3D format with Gaussian extensions
PLY: Point cloud format commonly used in 3DGS toolchains
Automatic entity classification during ingestion
Spherical harmonics stored with configurable band count

Technical Detail

Querying scene differences

Use the scene diff endpoint to compare two temporal snapshots of a scene and retrieve a structured changeset of what moved, appeared, or disappeared in the environment.

# Python: Query scene diff between two timestamps
import vectorscaledb

client = vectorscaledb.Client("https://api.vectorscaledb.com")

# Compare yesterday's scan to today's scan
diff = client.gaussian.scene_diff(
    scene_id="warehouse-floor-b",
    timestamp_a="2026-03-08T06:00:00Z",
    timestamp_b="2026-03-09T06:00:00Z",
    position_threshold=0.05,   # 5cm movement threshold
    appearance_threshold=0.1, # cosine distance for appearance
    include_unchanged=False,
    classification_filter=["dynamic", "static"]  # exclude transient
)

print(f"Scene: {diff.scene_id}")
print(f"Gaussians compared: {diff.total_compared:,}")
print(f"Added:    {len(diff.added):,}")
print(f"Removed:  {len(diff.removed):,}")
print(f"Moved:    {len(diff.moved):,}")
print(f"Modified: {len(diff.modified):,}")
print(f"Latency:  {diff.latency_ms}ms")

# Inspect moved Gaussians (e.g., forklift repositioned pallets)
for change in diff.moved[:5]:
    print(f"  Gaussian {change.gaussian_id}:")
    print(f"    From: ({change.position_a.x:.2f}, {change.position_a.y:.2f}, {change.position_a.z:.2f})")
    print(f"    To:   ({change.position_b.x:.2f}, {change.position_b.y:.2f}, {change.position_b.z:.2f})")
    print(f"    Delta: {change.distance:.3f}m")

# Example output:
# Scene: warehouse-floor-b
# Gaussians compared: 2,847,312
# Added:    1,204
# Removed:  887
# Moved:    3,412
# Modified: 892
# Latency:  142ms