Add files using upload-large-folder tool

README.md

@@ -0,0 +1,89 @@
+---
+pretty_name: RoboTrack Real v3
+tags:
+  - video
+  - robotics
+  - computer-vision
+  - point-tracking
+configs:
+  - config_name: default
+    data_files:
+      - split: train
+        path:
+          - train/metadata.parquet
+          - train/*/video.mp4
+          - train/*/point_track_vis.mp4
+    drop_labels: true
+---
+
+# RoboTrack Real v3
+
+RoboTrack Real v3 is an evaluation dataset of 318 real-world video clips with
+sparse 2D point trajectories and visibility annotations. Each example includes
+the original RGB video, a rendered visualization of its point tracks, and the
+underlying NumPy annotation archive.
+
+## Dataset Viewer
+
+The viewer exposes two playable video columns:
+
+- `raw`: the original RGB clip (`raw_file_name` in `metadata.parquet`)
+- `visualization`: the RGB clip with colored, numbered tracks and one second of
+  visibility-aware trajectory history (`visualization_file_name`)
+
+The remaining columns provide clip dimensions, timing, annotation statistics,
+and optional `review_status` and `review_notes` fields for annotator review.
+
+## Layout
+
+```text
+train/
+  metadata.parquet
+  <clip_id>/
+    video.mp4
+    point_track_vis.mp4
+    point_tracks.npz
+scripts/
+  visualize_robotrack_dataset.py
+```
+
+All media files are stored directly in this repository; there are no symbolic
+links. Videos are H.264 with matching frame counts and timing between the raw
+and visualization versions.
+
+## Annotation format
+
+Each `point_tracks.npz` contains:
+
+- `trajs_2d`: `float32` array shaped `(T, N, 2)` containing pixel coordinates
+  in `(x, y)` order
+- `visibility`: `float32` array shaped `(T, N)`, where values greater than `0.5`
+  are visible
+- `query_frames`: `int32` array shaped `(N,)` containing the query frame for
+  each track
+
+Here, `T` is the number of video frames and `N` is the number of annotated
+tracks. Invisible coordinates are stored as `(0, 0)`.
+
+## Frame rates
+
+- 174 clips at 15 FPS
+- 1 clip at 20 FPS
+- 143 clips at 30 FPS
+
+Forty-five clips whose containers incorrectly reported 60 FPS were retimed to
+15 FPS without dropping frames. Their H.264 streams were copied without lossy
+re-encoding, and the visualization videos use the same corrected timing.
+
+## Loading
+
+```python
+from datasets import load_dataset
+
+dataset = load_dataset("<namespace>/robotrack-real-v3", split="train")
+example = dataset[0]
+print(example["clip_id"], example["num_tracks"])
+```
+
+The NPZ path for each example is available in `annotation_path`. The included
+renderer can recreate the point-track videos if needed.

scripts/visualize_robotrack_dataset.py

@@ -0,0 +1,585 @@
+#!/usr/bin/env python3
+"""Render RoboTrack point annotations on top of their source videos.
+
+Expected layout:
+
+    DATASET_ROOT/
+      clip_id/
+        video.mp4
+        point_tracks.npz
+
+Each NPZ must contain:
+
+    trajs_2d:     (frames, tracks, 2) pixel coordinates
+    visibility:   (frames, tracks) visibility scores
+    query_frames: (tracks,) first/query frame for each track
+
+The default output is ``point_track_vis.mp4`` in each clip directory. Existing
+outputs are skipped unless ``--overwrite`` is supplied, so interrupted runs can
+be resumed safely.
+"""
+
+from __future__ import annotations
+
+import argparse
+import colorsys
+import os
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+
+import cv2
+import numpy as np
+
+
+DEFAULT_FFMPEG_CANDIDATES = (
+    "/gpfs/projects/raivn/yunbos/.conda/envs/cotracker-perception/bin/ffmpeg",
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("dataset_root", type=Path, help="RoboTrack dataset directory")
+    parser.add_argument("--video-name", default="video.mp4")
+    parser.add_argument("--tracks-name", default="point_tracks.npz")
+    parser.add_argument("--output-name", default="point_track_vis.mp4")
+    parser.add_argument(
+        "--trail-seconds",
+        type=float,
+        default=1.0,
+        help="Length of the visible motion trail (default: 1.0)",
+    )
+    parser.add_argument(
+        "--visibility-threshold",
+        type=float,
+        default=0.5,
+        help="Scores above this value are drawn as visible (default: 0.5)",
+    )
+    parser.add_argument(
+        "--crf",
+        type=int,
+        default=20,
+        help="H.264 quality: lower is better/larger (default: 20)",
+    )
+    parser.add_argument(
+        "--preset",
+        default="veryfast",
+        help="libx264 encoding preset (default: veryfast)",
+    )
+    parser.add_argument(
+        "--workers",
+        type=int,
+        default=min(4, os.cpu_count() or 1),
+        help="Parallel clips to render (default: up to 4)",
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        help="Render only the first N clips (useful for testing)",
+    )
+    parser.add_argument("--overwrite", action="store_true")
+    parser.add_argument(
+        "--ffmpeg",
+        type=Path,
+        help="Path to ffmpeg; otherwise resolve it automatically",
+    )
+    return parser.parse_args()
+
+
+def find_ffmpeg(explicit_path: Path | None) -> str:
+    if explicit_path is not None:
+        if not explicit_path.is_file():
+            raise FileNotFoundError(f"ffmpeg does not exist: {explicit_path}")
+        return str(explicit_path.resolve())
+
+    on_path = shutil.which("ffmpeg")
+    if on_path:
+        return on_path
+
+    for candidate in DEFAULT_FFMPEG_CANDIDATES:
+        if Path(candidate).is_file():
+            return candidate
+
+    raise FileNotFoundError("Could not find ffmpeg; pass its path with --ffmpeg")
+
+
+def track_colors(count: int) -> list[tuple[int, int, int]]:
+    """Return visually separated, stable BGR colors."""
+    colors = []
+    golden_ratio = 0.618033988749895
+    for index in range(count):
+        hue = (0.07 + index * golden_ratio) % 1.0
+        red, green, blue = colorsys.hsv_to_rgb(hue, 0.88, 1.0)
+        colors.append((round(blue * 255), round(green * 255), round(red * 255)))
+    return colors
+
+
+def validate_tracks(
+    npz_path: Path,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    with np.load(npz_path) as data:
+        required = {"trajs_2d", "visibility", "query_frames"}
+        missing = required.difference(data.files)
+        if missing:
+            raise ValueError(f"missing NPZ arrays: {', '.join(sorted(missing))}")
+        trajectories = np.asarray(data["trajs_2d"], dtype=np.float32)
+        visibility = np.asarray(data["visibility"], dtype=np.float32)
+        query_frames = np.asarray(data["query_frames"], dtype=np.int64)
+
+    if trajectories.ndim != 3 or trajectories.shape[-1] != 2:
+        raise ValueError(f"trajs_2d must have shape (T, N, 2), got {trajectories.shape}")
+    if visibility.shape != trajectories.shape[:2]:
+        raise ValueError(
+            f"visibility shape {visibility.shape} does not match {trajectories.shape[:2]}"
+        )
+    if query_frames.shape != (trajectories.shape[1],):
+        raise ValueError(
+            f"query_frames shape {query_frames.shape} does not match "
+            f"({trajectories.shape[1]},)"
+        )
+    if np.any(query_frames < 0) or np.any(query_frames >= trajectories.shape[0]):
+        raise ValueError("query_frames contains an index outside the video")
+    return trajectories, visibility, query_frames
+
+
+def visible_segments(
+    points: np.ndarray, visible: np.ndarray
+) -> list[np.ndarray]:
+    """Split a short trajectory window into contiguous visible polylines."""
+    segments: list[np.ndarray] = []
+    start = None
+    for index, is_visible in enumerate(visible):
+        if is_visible and np.isfinite(points[index]).all():
+            if start is None:
+                start = index
+        elif start is not None:
+            if index - start >= 2:
+                segments.append(points[start:index])
+            start = None
+    if start is not None and len(points) - start >= 2:
+        segments.append(points[start:])
+    return segments
+
+
+def outlined_text(
+    frame: np.ndarray,
+    text: str,
+    origin: tuple[int, int],
+    font_scale: float,
+    color: tuple[int, int, int],
+    thickness: int,
+) -> None:
+    cv2.putText(
+        frame,
+        text,
+        origin,
+        cv2.FONT_HERSHEY_SIMPLEX,
+        font_scale,
+        (0, 0, 0),
+        thickness + 3,
+        cv2.LINE_AA,
+    )
+    cv2.putText(
+        frame,
+        text,
+        origin,
+        cv2.FONT_HERSHEY_SIMPLEX,
+        font_scale,
+        color,
+        thickness,
+        cv2.LINE_AA,
+    )
+
+
+def fit_text_to_width(
+    text: str,
+    max_width: int,
+    font_scale: float,
+    thickness: int,
+) -> str:
+    """Elide the middle of text while preserving its identifying suffix."""
+    def width(candidate: str) -> int:
+        size, _ = cv2.getTextSize(
+            candidate, cv2.FONT_HERSHEY_SIMPLEX, font_scale, thickness
+        )
+        return size[0]
+
+    if width(text) <= max_width:
+        return text
+    for keep in range(len(text) - 1, 5, -1):
+        prefix_length = (keep + 1) // 2
+        suffix_length = keep // 2
+        candidate = f"{text[:prefix_length]}...{text[-suffix_length:]}"
+        if width(candidate) <= max_width:
+            return candidate
+    return "..."
+
+
+def draw_overlay(
+    frame: np.ndarray,
+    frame_index: int,
+    trajectories: np.ndarray,
+    visibility: np.ndarray,
+    query_frames: np.ndarray,
+    colors: list[tuple[int, int, int]],
+    trail_frames: int,
+    visibility_threshold: float,
+    clip_id: str,
+) -> np.ndarray:
+    height, width = frame.shape[:2]
+    num_frames, num_tracks = trajectories.shape[:2]
+    visible_now = visibility[frame_index] > visibility_threshold
+    visible_now &= query_frames <= frame_index
+
+    point_radius = max(4, round(min(width, height) / 120))
+    point_outline = max(2, round(point_radius / 3))
+    trail_width = max(2, round(point_radius / 2))
+    font_scale = min(1.0, max(0.5, min(width, height) / 900))
+    font_thickness = max(1, round(font_scale * 2))
+
+    trail_layer = frame.copy()
+    first_trail_frame = max(0, frame_index - trail_frames)
+    for track_index in range(num_tracks):
+        first = max(first_trail_frame, int(query_frames[track_index]))
+        points = trajectories[first : frame_index + 1, track_index]
+        visible = visibility[first : frame_index + 1, track_index] > visibility_threshold
+        for segment in visible_segments(points, visible):
+            rounded = np.rint(segment).astype(np.int32).reshape((-1, 1, 2))
+            cv2.polylines(
+                trail_layer,
+                [rounded],
+                isClosed=False,
+                color=colors[track_index],
+                thickness=trail_width,
+                lineType=cv2.LINE_AA,
+            )
+    cv2.addWeighted(trail_layer, 0.72, frame, 0.28, 0.0, dst=frame)
+
+    for track_index in range(num_tracks):
+        if not visible_now[track_index]:
+            continue
+        point = trajectories[frame_index, track_index]
+        if not np.isfinite(point).all():
+            continue
+        x, y = np.rint(point).astype(int)
+        # Coordinates just outside the image can occur in hand-authored tracks.
+        # Clipping keeps the renderer robust while still placing a marker at the edge.
+        x = int(np.clip(x, 0, width - 1))
+        y = int(np.clip(y, 0, height - 1))
+
+        if frame_index == int(query_frames[track_index]):
+            cv2.circle(
+                frame,
+                (x, y),
+                point_radius + point_outline + 3,
+                (255, 255, 255),
+                point_outline,
+                cv2.LINE_AA,
+            )
+        cv2.circle(
+            frame,
+            (x, y),
+            point_radius + point_outline,
+            (0, 0, 0),
+            -1,
+            cv2.LINE_AA,
+        )
+        cv2.circle(
+            frame,
+            (x, y),
+            point_radius,
+            colors[track_index],
+            -1,
+            cv2.LINE_AA,
+        )
+        label_x = min(width - 1, x + point_radius + 4)
+        label_y = int(np.clip(y - point_radius - 2, 14, height - 2))
+        outlined_text(
+            frame,
+            str(track_index),
+            (label_x, label_y),
+            font_scale * 0.78,
+            colors[track_index],
+            font_thickness,
+        )
+
+    active_count = int(np.count_nonzero(query_frames <= frame_index))
+    clip_line = fit_text_to_width(
+        f"clip: {clip_id}", width - 20, font_scale, font_thickness
+    )
+    stats_line = (
+        f"frame {frame_index + 1}/{num_frames}   "
+        f"visible {int(np.count_nonzero(visible_now))}/{active_count}   "
+        f"tracks {num_tracks}"
+    )
+    clip_size, baseline = cv2.getTextSize(
+        clip_line, cv2.FONT_HERSHEY_SIMPLEX, font_scale, font_thickness
+    )
+    stats_size, _ = cv2.getTextSize(
+        stats_line, cv2.FONT_HERSHEY_SIMPLEX, font_scale, font_thickness
+    )
+    line_gap = max(5, round(font_scale * 6))
+    header_height = clip_size[1] + stats_size[1] + baseline + line_gap + 18
+    header_width = min(width, max(clip_size[0], stats_size[0]) + 20)
+    header_layer = frame.copy()
+    cv2.rectangle(header_layer, (0, 0), (header_width, header_height), (0, 0, 0), -1)
+    cv2.addWeighted(header_layer, 0.62, frame, 0.38, 0.0, dst=frame)
+    cv2.putText(
+        frame,
+        clip_line,
+        (10, clip_size[1] + 7),
+        cv2.FONT_HERSHEY_SIMPLEX,
+        font_scale,
+        (255, 255, 255),
+        font_thickness,
+        cv2.LINE_AA,
+    )
+    cv2.putText(
+        frame,
+        stats_line,
+        (10, clip_size[1] + line_gap + stats_size[1] + 7),
+        cv2.FONT_HERSHEY_SIMPLEX,
+        font_scale,
+        (255, 255, 255),
+        font_thickness,
+        cv2.LINE_AA,
+    )
+    return frame
+
+
+def render_clip(
+    clip_dir_string: str,
+    video_name: str,
+    tracks_name: str,
+    output_name: str,
+    trail_seconds: float,
+    visibility_threshold: float,
+    crf: int,
+    preset: str,
+    ffmpeg: str,
+    overwrite: bool,
+) -> tuple[str, str, str]:
+    clip_dir = Path(clip_dir_string)
+    video_path = clip_dir / video_name
+    tracks_path = clip_dir / tracks_name
+    output_path = clip_dir / output_name
+    clip_id = clip_dir.name
+
+    if output_path.exists() and not overwrite:
+        return clip_id, "skipped", "already exists"
+
+    trajectories, visibility, query_frames = validate_tracks(tracks_path)
+    capture = cv2.VideoCapture(str(video_path))
+    if not capture.isOpened():
+        raise RuntimeError(f"could not open video: {video_path}")
+
+    width = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps = float(capture.get(cv2.CAP_PROP_FPS))
+    reported_frames = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))
+    if width <= 0 or height <= 0 or fps <= 0:
+        capture.release()
+        raise ValueError(f"invalid video metadata: {width}x{height} at {fps} fps")
+    if reported_frames > 0 and reported_frames != trajectories.shape[0]:
+        capture.release()
+        raise ValueError(
+            f"video reports {reported_frames} frames but tracks have "
+            f"{trajectories.shape[0]}"
+        )
+
+    temporary_path = output_path.with_name(
+        f".{output_path.stem}.tmp-{os.getpid()}{output_path.suffix}"
+    )
+    command = [
+        ffmpeg,
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-y",
+        "-f",
+        "rawvideo",
+        "-pixel_format",
+        "bgr24",
+        "-video_size",
+        f"{width}x{height}",
+        "-framerate",
+        f"{fps:.8f}",
+        "-i",
+        "-",
+        "-an",
+        "-vf",
+        "pad=ceil(iw/2)*2:ceil(ih/2)*2",
+        "-c:v",
+        "libx264",
+        "-preset",
+        preset,
+        "-crf",
+        str(crf),
+        "-pix_fmt",
+        "yuv420p",
+        "-movflags",
+        "+faststart",
+        str(temporary_path),
+    ]
+
+    encoder = subprocess.Popen(
+        command,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.PIPE,
+    )
+    frames_written = 0
+    colors = track_colors(trajectories.shape[1])
+    trail_frames = max(0, round(trail_seconds * fps))
+    failure: Exception | None = None
+    try:
+        assert encoder.stdin is not None
+        for frame_index in range(trajectories.shape[0]):
+            ok, frame = capture.read()
+            if not ok:
+                raise RuntimeError(
+                    f"video ended after {frames_written}/{trajectories.shape[0]} frames"
+                )
+            draw_overlay(
+                frame,
+                frame_index,
+                trajectories,
+                visibility,
+                query_frames,
+                colors,
+                trail_frames,
+                visibility_threshold,
+                clip_id,
+            )
+            encoder.stdin.write(frame.tobytes())
+            frames_written += 1
+    except Exception as error:
+        failure = error
+    finally:
+        capture.release()
+        if encoder.stdin is not None:
+            try:
+                encoder.stdin.close()
+            except BrokenPipeError:
+                pass
+
+    assert encoder.stderr is not None
+    encoder_error = encoder.stderr.read().decode("utf-8", errors="replace").strip()
+    return_code = encoder.wait()
+    if failure is not None or return_code != 0:
+        temporary_path.unlink(missing_ok=True)
+        details = str(failure) if failure is not None else ""
+        if encoder_error:
+            details = f"{details}; ffmpeg: {encoder_error}".strip("; ")
+        raise RuntimeError(details or f"ffmpeg exited with status {return_code}")
+
+    if frames_written != trajectories.shape[0]:
+        temporary_path.unlink(missing_ok=True)
+        raise RuntimeError(
+            f"wrote {frames_written} frames, expected {trajectories.shape[0]}"
+        )
+    os.replace(temporary_path, output_path)
+    return clip_id, "rendered", f"{frames_written} frames"
+
+
+def main() -> int:
+    args = parse_args()
+    dataset_root = args.dataset_root.resolve()
+    if not dataset_root.is_dir():
+        print(f"error: dataset root does not exist: {dataset_root}", file=sys.stderr)
+        return 2
+    if args.workers < 1:
+        print("error: --workers must be at least 1", file=sys.stderr)
+        return 2
+    if args.trail_seconds < 0:
+        print("error: --trail-seconds cannot be negative", file=sys.stderr)
+        return 2
+    if not 0 <= args.crf <= 51:
+        print("error: --crf must be between 0 and 51", file=sys.stderr)
+        return 2
+
+    try:
+        ffmpeg = find_ffmpeg(args.ffmpeg)
+    except FileNotFoundError as error:
+        print(f"error: {error}", file=sys.stderr)
+        return 2
+
+    clip_dirs = sorted(
+        path
+        for path in dataset_root.iterdir()
+        if path.is_dir()
+        and (path / args.video_name).is_file()
+        and (path / args.tracks_name).is_file()
+    )
+    if args.limit is not None:
+        if args.limit < 0:
+            print("error: --limit cannot be negative", file=sys.stderr)
+            return 2
+        clip_dirs = clip_dirs[: args.limit]
+    if not clip_dirs:
+        print("No matching clip directories found.")
+        return 0
+
+    print(
+        f"Rendering {len(clip_dirs)} clips from {dataset_root} with "
+        f"{args.workers} worker(s)",
+        flush=True,
+    )
+    print(f"ffmpeg: {ffmpeg}", flush=True)
+
+    rendered = 0
+    skipped = 0
+    failures: list[tuple[str, str]] = []
+    common_args = (
+        args.video_name,
+        args.tracks_name,
+        args.output_name,
+        args.trail_seconds,
+        args.visibility_threshold,
+        args.crf,
+        args.preset,
+        ffmpeg,
+        args.overwrite,
+    )
+    with ProcessPoolExecutor(max_workers=args.workers) as executor:
+        future_to_clip = {
+            executor.submit(render_clip, str(clip_dir), *common_args): clip_dir.name
+            for clip_dir in clip_dirs
+        }
+        for completed, future in enumerate(as_completed(future_to_clip), start=1):
+            clip_id = future_to_clip[future]
+            try:
+                _, status, detail = future.result()
+                if status == "rendered":
+                    rendered += 1
+                else:
+                    skipped += 1
+                print(
+                    f"[{completed:>3}/{len(clip_dirs)}] {status:8} {clip_id} "
+                    f"({detail})",
+                    flush=True,
+                )
+            except Exception as error:
+                failures.append((clip_id, str(error)))
+                print(
+                    f"[{completed:>3}/{len(clip_dirs)}] FAILED   {clip_id}: {error}",
+                    file=sys.stderr,
+                    flush=True,
+                )
+
+    print(
+        f"Done: {rendered} rendered, {skipped} skipped, {len(failures)} failed.",
+        flush=True,
+    )
+    if failures:
+        print("Failures:", file=sys.stderr)
+        for clip_id, error in failures:
+            print(f"  {clip_id}: {error}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

train/1_29838012/point_tracks.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e29c628d853945139b7e6b24ed494cd9a90e259c86d835e07e5a8e996bc80e88
+size 20714

train/2d8646d63a7b6154_23804457_seg0004/point_track_vis.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:956a62e91be6bf9559a2c4726cab718fce6c54f98d46ebc29d09ca153990ce3c
+size 1565247

train/2d8646d63a7b6154_23804457_seg0004/point_tracks.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38b4265f54b5e401e3cb242f334bc6d58692f7215c464d2d424f4dc614940a9e
+size 26034

train/2d8646d63a7b6154_23804457_seg0004/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a2b15265bef21d7093013d55fdfc047757771619258d87dde7051b732265c5a4
+size 1705522

train/2d8646d63a7b6154_23804457_seg0144/point_track_vis.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3e5c8012b81ad597a8976dea7a2809931742687e56c8e0edccbacb68f7c4c43f
+size 1937482

train/2d8646d63a7b6154_23804457_seg0144/point_tracks.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4fe70dcb5f3b49eef59050b4633d092a2a9e2a83849c71e95ab7d573b375cc2f
+size 11602

train/2d8646d63a7b6154_23804457_seg0144/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d6152b387f5857b61e2124f39f2e6e16b8149297b902b54f5306b0c1671046bf
+size 2083186

train/303f470e03136909_28834630_seg0048/point_track_vis.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7d1e25f78b3c8e6f7d47c291ebd657b8692c29da64997fa13d99096435773f26
+size 1991746

train/303f470e03136909_28834630_seg0048/point_tracks.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:72d38b2288a108fb2535c35ab48b23465c510b49a263f9d31a3261c9e4608dcb
+size 18818

train/303f470e03136909_28834630_seg0048/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5f253240f022bde9e820ae31c637dfcf2cc632acdd91db960b5bef3ea5adca7b
+size 1933711

train/303f470e03136909_28834630_seg0072/point_track_vis.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a14023b70fc4cec1d31883bd66afe7863ab7922e30f48ac22f20c1f918084476
+size 1845603

train/303f470e03136909_28834630_seg0072/point_tracks.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:30f0c6ffb62814cfcf331d3ca682c35e7e98469447ddd935daeda5c0a87daf75
+size 7994

train/303f470e03136909_28834630_seg0072/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff8651d180b8efe062564ea29722342e4b67c06166cbc5991b57db1fbafbcfea
+size 1883887

train/39965b22783c5193_13263313_seg0088/point_track_vis.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:030a044e96a8c3c81821f9d8329a905a88a4ac576d6386b86bf70bd7903a6e43
+size 2252098

train/39965b22783c5193_13263313_seg0088/point_tracks.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38c58ec2db8ff45919154d06032f0670832f184ffd1aae0694352358caee54cc
+size 24230

train/39965b22783c5193_13263313_seg0088/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:214ab8bc1bab74912751ad4ce9a5722871ef951ab1d6f5f03ab3e158258d0a80
+size 1699196

train/3_23404442/point_track_vis.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:98c543d285c91b16604815cb716d0d16dd6d39ec854762d37b560d9d2fd4e26a
+size 2283134

train/3_23404442/point_tracks.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a41814251f63aee10e59b8eb8c711bbbc7169edf6e3d4b11e046e56f0a99e30e
+size 6354

train/3_23404442/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3712225a521374df47b1c9b225e1565d69e3344a4d1eb30a401eb28bb779030f
+size 6395197

train/Fri_May_12_11_50_47_2023_recordings_MP4_ego/point_track_vis.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8b35edc0898c0266a8d132515a2e0f09c8ae72930324beb9a0c31ea4ef49598f
+size 2666858

train/Fri_May_12_11_50_47_2023_recordings_MP4_ego/point_tracks.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eb178be51bb19242fd4bf1c3a0cdca76efb83a3d0674741551b8c7b8e189c782
+size 6010

train/Fri_May_12_11_50_47_2023_recordings_MP4_ego/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c33e67af0a000c95e917746befb4e269c247b03e30db7ba32b2d087deda65f54
+size 3202519

train/Sun_Jun_11_15_09_35_2023_recordings_MP4_23897859/point_track_vis.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:122a33488654e39b9719ab24f3fc079b322e9c8b22b308c45a43e227d26fdbcc
+size 3557546

train/Sun_Jun_11_15_09_35_2023_recordings_MP4_23897859/point_tracks.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9575981f94cd50a340d60e5f1c59eb897e72b71101b107a64f9c3bea6726a241
+size 26778

train/Sun_Jun_11_15_09_35_2023_recordings_MP4_27904255/point_track_vis.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:455b5c059b6ded1c44fea061c9edecc4d93b62641fa73db119503ef46dd2e5a1
+size 3539950

train/Sun_Jun_11_15_09_35_2023_recordings_MP4_27904255/point_tracks.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:88d1a00eff1ae9abe7d11344ce4d6fd4be11bad0f09e2418c3139528ac745a24
+size 42378

train/Sun_Jun_11_15_09_35_2023_recordings_MP4_27904255/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad87be9a49c302660dd40a053db1525c100b4f82966fa41207d77abf5865fff7
+size 10086900

train/Tue_Feb_13_10_44_21_2024_recordings_MP4_14549178/point_track_vis.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da83cf03f5fcbe4fc1f8e7a5fb1156c66700f48a81477e84d13100f15309aea0
+size 3128203

train/Tue_Feb_13_10_44_21_2024_recordings_MP4_14549178/point_tracks.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c930b2a387d8ba54f22b1805e621fad26efc9f355a49cfcd424743f1c39334e
+size 2990

train/Tue_Feb_13_10_44_21_2024_recordings_MP4_14549178/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a48d0edf917b4ed1978d6cc3a8434022cb87d6f3522e8ec37331057ca45fc035
+size 5368314

train/Tue_Feb_13_10_49_35_2024_recordings_MP4_20252535/point_track_vis.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d5aa3367d49bbd2c5a14d6aac1d4bcf225120c51a53e974b16280063fb998c4b
+size 1547571

train/Tue_Feb_13_10_49_35_2024_recordings_MP4_20252535/point_tracks.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c441985fc8bbc37a3ebaaa9530954bf3df6953fe5ec0083bbaf53dd92eb74228
+size 8858

train/Tue_Feb_13_10_49_35_2024_recordings_MP4_20252535/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8342c97d22b7e657efa1f1057b6ccfbe13a4d2b926aeedbb6395547e8f54072e
+size 5204629

train/bimanual_yam_allenai_12012026-block2-1/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:77b59c3494c5dfe32485d338afaed0039b618eafb2739ba3e24fa95b8e5ae3e5
+size 1011437

train/human_aria_bimanual_2025-10-29-22-02-43-003000/point_tracks.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c1d141f48976088544bd8f677ea73ff2ec9de1091e2df300c967f3e684b5786c
+size 22402

train/metadata.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4c3318faf9ecffb671d5810cd8609000cfb851c0387deeb1ed48de42fbc22422
+size 21997

train/nus_cpr_42_3_Place_the_other_hand_on_top_of_the_first_ego/point_track_vis.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d684c483a3ea498be47433545b61d029254571b78d23214a34ea807ea776e2b
+size 1419642

train/nus_cpr_42_3_Place_the_other_hand_on_top_of_the_first_ego/point_tracks.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2d7abd8add4d2cff3818047faa722b09c48ef7fe212671cea44f42eb0ffd6895
+size 4202

train/nus_cpr_42_3_Place_the_other_hand_on_top_of_the_first_ego/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:80063699f8870f9410eda7195cc06ffb24b286f531c90ad08c3ac1089b52c3fd
+size 1133845

train/robotic_eva_bimanual_2026-04-29-19-10-18-459000/point_track_vis.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a61f984442827622242f05c3760db60f38a4435a77c3cc46734bc7625293f46a
+size 952890

train/robotic_eva_bimanual_2026-04-29-19-10-18-459000/point_tracks.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:192523aa9951b97e23a6401339043f0b3d8abe389bd7da96af980da2f9ee4f11
+size 15194

train/robotic_eva_bimanual_2026-04-29-19-10-18-459000/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:94c35c96b46b3bb9349d08672b1c0fab9cc89c50f38677e9b57c795d12143511
+size 2042465

train/so100_Loki0929_so100_lan/point_track_vis.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d92798e25837a193fc98771760c172cc7f7ba6489e53740535e778414923f59d
+size 982915

train/so100_Loki0929_so100_lan/point_tracks.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:24d3b1a07a0d1d5dd86280b71bdebb56c0638021eec95151253cf166e0bd0096
+size 58250

train/so100_Loki0929_so100_lan/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:938a9c0e8f49a20ec7e5c63eef05305af6ba9da467a9fcbff70c6effa5325258
+size 938405

train/upenn_0324_Piano_1_2_random_clip_exo/point_track_vis.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04f21d0060fa991137f62f32b5fba73a70f1ea5cc9a49863c5800beb86c11487
+size 3496252

train/upenn_0324_Piano_1_2_random_clip_exo/point_tracks.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:666b9375db0aede70358d9b0dae5fadbc2449a9058977f8637e37d896d17ca62
+size 15194

train/upenn_0324_Piano_1_2_random_clip_exo/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:12e3d8baa7e54c637ac14b7aaeef22f57ac44c1ee5cb398a996a343ea78446b3
+size 3576451