Silicon23/3d-box-trajectory-smoothing

Track B — 3D Box Trajectory Smoothing Dataset (CA-1M derivative)

Paired noisy ↔ Kalman ↔ ground-truth 3D bounding-box trajectories for training lightweight, box-trajectory-only temporal smoothers. Each row is one tracked object's per-frame 3D box across a short video clip, in camera coordinates. No images or depth are included — this dataset is the box math only.

It is the training data for Track B of an open-vocabulary 3D video object tracker: a small bidirectional transformer that denoises a per-frame 3D-box trajectory. (Track A = classical Kalman/RTS smoother; Track C = image-grounded WildDet3D refiner.) Collaborators can train their own Track B variants directly on this dataset.

How it was produced

A generalized open-vocab 3D tracking pipeline was run on CA-1M / CubifyAnything (Apple's indoor RGB-D dataset; static objects, moving camera, with GT 3D boxes):

Step	Output
1	Per-frame depth + camera intrinsics/extrinsics (RADIO-ViPE)
2	Per-frame 2D segmentation tracklet (SAM3, text-prompted)
3	Per-frame object mesh (SAM 3D Objects)
4	Per-keyframe noisy 3D box (FoundationPose) — the noisy_* fields
5 / A	Classical Kalman/RTS smoother — the kalman_* fields

The clean target (gt_*) is CA-1M's own per-frame 3D box (wide/instances.json), matched to each tracked object by its stable UUID.

This release: 9,002 trajectories across 1,588 videos / ~488K frames (~5–6 trackable objects/video, ~24–30 measured keyframes and ~50–60 timeline frames per trajectory). A trajectory is included only when all three sources are available on disk — Step-4 noisy, Step-5 Kalman, and extracted CA-1M GT frames; 316 of the 9,318 Kalman trajectories are excluded because their CA-1M raw frames were not extracted (so no GT target exists for them). See dataset_meta.json for the exact counts of the staged build.

One row = one (video, object) trajectory

All per-frame arrays share a single canonical timeline of length T = the clip-range frames where this object has CA-1M GT.

Field	Shape	Meaning
video_id, object_id	str	CA-1M video id; object UUID
category, caption	str	CA-1M class + free-text caption
num_frames	int	T (timeline length)
num_keyframes	int	genuine Step-4 measurements (measured_mask.sum())
step1_index	[T]	index into the Step-1 arrays / source frames
timestamps_ns	[T]	real frame timestamp (nanoseconds) — use for time PE
measured_mask	[T] bool	True at genuine Step-4 keyframes (else densified)
noisy_center/_dims/_R	[T,3],[T,3],[T,3,3]	Step-4 box (input prior)
kalman_center/_dims/_R	[T,3],[T,3],[T,3,3]	Step-5 Kalman box (prior/baseline)
kalman_valid	[T] bool	Step-5 covers this frame
gt_center/_dims/_R	[T,3],[T,3],[T,3,3]	CA-1M GT box (target)
box_2d_proj	[T,4]	GT 2D box xyxy (px) — for geo-prompted / image variants
intrinsics	[T,3,3]	per-frame camera K (px)
extrinsics_cam_to_world	[T,4,4]	camera→world pose (Step-1 estimate)

center = box center (m); dims = FULL extents (m, not half); R = box-local→camera rotation.

Coordinate conventions (read before training)

• Camera frame throughout, OpenCV axes: x-right, y-down, z-forward (a box in front of the camera has center[2] > 0). The trained smoother operates in camera frame by design — on CA-1M's static scenes the world-frame trajectory is near-constant and degenerate, so a world-frame model learns nothing. Do not feed extrinsics to the trajectory model (it enables a world-frame shortcut); they are provided for optional world-frame output/visualization only.
• dims = full extents (corner reconstruction error 0.0 with full, not half).
• Rotation storage = lossless 3×3 matrix R (box-local→camera). The model consumes the continuous 6-D rotation of Zhou et al. (CVPR'19). Convention (must match across producers/consumers): the 6-D is the first two rows of R flattened; decode by row Gram-Schmidt with the third row = cross product.

  def matrix_to_rot6d(R):                 # [...,3,3] -> [...,6]
      return R[..., :2, :].reshape(*R.shape[:-2], 6)
  def rot6d_to_matrix(r6):                # [...,6] -> [...,3,3]
      a1, a2 = r6[..., 0:3], r6[..., 3:6]
      b1 = a1 / np.linalg.norm(a1, -1, keepdims=True)
      a2 = a2 - (b1*a2).sum(-1, keepdims=True)*b1
      b2 = a2 / np.linalg.norm(a2, -1, keepdims=True)
      return np.stack([b1, b2, np.cross(b1, b2)], -2)
  

  The model's 12-D box vector is box_repr = [center(3), log_dims(3), rot_6d(6)].
• extrinsics_cam_to_world maps camera→world (matches CA-1M's gt/RT.json direction). These are RADIO-ViPE estimates (Step 1), not CA-1M GT poses. Invert for world→cam.

Suggested train/val split — BY VIDEO

Split by video, never by object: objects in one video share the camera trajectory and scene, so object-level splitting leaks. A reproducible canonical val split (~6% of videos, seed 0) ships as val_video_ids.json:

import json, numpy as np
from datasets import load_from_disk
ds = load_from_disk("track_b_hf_dataset").with_format("numpy")
val = set(json.load(open("track_b_hf_dataset/val_video_ids.json"))["val_video_ids"])
is_val = np.array([v in val for v in ds["video_id"]])
train_ds, val_ds = ds.select(np.where(~is_val)[0]), ds.select(np.where(is_val)[0])

Which prior to train on — Step-4 noisy vs Step-5 Kalman

Both are included. The smoother can take either as its input prior:

• noisy_* (Step-4 FoundationPose): rawer, jittery — the original design choice; the model learns to denoise from scratch.
• kalman_* (Step-5 Kalman/RTS): a stronger, already-smoothed prior — the model learns a smaller residual on top.

Train both and compare; in this project they are run as an ablation (no hardcoded default). Whichever you feed, the target is always gt_*, and the Kalman box also serves as a non-learned baseline to beat at eval.

Usage

A standalone example (numpy + datasets only) is shipped as hf_dataset_example.py. The reference Track B model, loss, and trainer live in the trackb/ package (torch).

A minimal denoising objective (camera frame), matching the reference trainer: L1 on center, L1 on log(dims), and a symmetry-aware geodesic rotation loss (min over the 180° box-flip group, so GT annotation flips on near-symmetric objects aren't learned as jitter). Smoothness lives in the target, not in an acceleration/jerk regularizer.

License & attribution

This is a derivative of Apple's CA-1M / CubifyAnything dataset; the GT boxes, categories, and captions originate there. Respect the upstream CA-1M license and terms for any redistribution or publication. The pipeline-produced fields (noisy_*, kalman_*, the timeline assembly) are derived artifacts. Shared privately with project collaborators. If you intend to publish or redistribute, review CA-1M's license terms first.