first commit

.gitattributes

@@ -57,3 +57,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+dataset/* filter=lfs diff=lfs merge=lfs -text
+dataset/** filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,216 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml

README.md

@@ -1,3 +1,35 @@
----
-license: mit
----
+# Spatial Everyday Activities
+[[Website]](https://spatial-ai.com/) [[Data Explorer]](https://spatial-ai.com/explorer)
+
+Spatial Everyday Activities (SEA) is an egocentric dataset designed for training robotic foundation models. It comprises approximately 10,000 hours of egocentric data collected by computer vision experts across a diverse range of locations in the US and EU.
+
+SEA-small is a 100GB open-source subset of the full SEA dataset.
+
+info@spatial-ai.com
+
+![image](assets/teaser.gif)
+
+## Run the code
+
+Setup an isolated environment
+```bash
+conda create -n sea python=3.12
+conda activate sea
+```
+
+Install dependencies and download SEA-small
+```bash
+pip install rerun-sdk
+git clone https://huggingface.co/datasets/spatial-ai/sea-small
+cd sea-small
+```
+
+Install the project requirements
+```bash
+pip install -e .
+```
+
+Run the example viewer
+```bash
+python -m sea_scenes
+```

pyproject.toml

@@ -0,0 +1,17 @@
+[project]
+name = "sea_scenes"
+version = "0.1.0"
+# requires-python = "<3.13"
+readme = "README.md"
+dependencies = [
+  "numpy",
+  "opencv-python",
+  "rerun-sdk",
+]
+
+[project.scripts]
+sea_scenes = "sea_scenes.__main__:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

sea_scenes/__main__.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import rerun as rr
+import rerun.blueprint as rrb
+
+from rerun.blueprint import archetypes as rrba
+from rerun.blueprint.components import BackgroundKind
+
+from .loaders import load_frames, load_depth, load_trajectory, load_body_data, load_hand_data
+
+DESCRIPTION = """
+# SEA Scenes
+This example visualizes the [SEA dataset](https://huggingface.co/datasets/spatial-ai/sea-small) using Rerun.
+
+Spatial Everyday Activities (SEA) is an egocentric dataset designed for training robotic foundation models.
+It comprises approximately 10,000 hours of egocentric data collected by computer vision experts across a diverse range of locations in the US and EU.
+""".strip()
+
+Color = tuple[float, float, float, float]
+
+SEQUENCE_ROOT = Path("./dataset")
+AVAILABLE_SEQUENCES = [s.name for s in SEQUENCE_ROOT.iterdir() if s.is_dir()]
+
+CAMERA_LEFT_ENTITY_PATH = "world/camera_left"
+CAMERA_RIGHT_ENTITY_PATH = "world/camera_right"
+TRAJECTORY_LEFT_ENTITY_PATH = "world/trajectory_left"
+TRAJECTORY_RIGHT_ENTITY_PATH = "world/trajectory_right"
+BODY_ENTITY_PATH = "world/body"
+HAND_LEFT_ENTITY_PATH = "world/hand_left"
+HAND_RIGHT_ENTITY_PATH = "world/hand_right"
+
+BODY_CONNECTIONS = [
+    (6, 14), (14, 15), (15, 16), (16, 17),  # Left arm
+    (6, 9), (9, 10), (10, 11), (11, 12),  # Right arm
+    (2, 3), (3, 4), (4, 5), (5, 6), (6, 7),  # Spine
+]
+
+HAND_CONNECTIONS = [
+    (1, 2), (2, 3), (3, 4), (4, 5),  # Thumb
+    (1, 6), (6, 7), (7, 8), (8, 9), (9, 10),  # Index
+    (1, 11), (11, 12), (12, 13), (13, 14), (14, 15),  # Middle finger
+    (1, 16), (16, 17), (17, 18), (18, 19), (19, 20),  # Ring finger
+    (1, 21), (21, 22), (22, 23), (23, 24), (24, 25),  # Little finger
+]
+
+def log_camera(
+    intrinsics: np.ndarray,
+    translation: np.ndarray,
+    rotation_xyzw: np.ndarray,
+    entity_id: str,
+) -> None:
+    """Log a pinhole camera and its transform."""
+    w, h, fx, fy, cx, cy = intrinsics
+    intrinsic = np.array([[fx, 0.0, cx], [0.0, fy, cy], [0.0, 0.0, 1.0]], dtype=np.float32)
+
+    rr.log(
+        entity_id,
+        rr.Transform3D(
+            translation=translation,
+            rotation=rr.Quaternion(xyzw=rotation_xyzw),
+        ),
+    )
+    rr.log(
+        entity_id,
+        rr.Pinhole(
+            image_from_camera=intrinsic,
+            resolution=[int(w), int(h)],
+            camera_xyz=rr.ViewCoordinates.LEFT_HAND_Y_UP,
+            image_plane_distance=2e-1,
+        ),
+    )
+
+
+def log_trajectory(
+    positions: list[list[float]],
+    entity_id: str,
+    color: Color = (1.0, 1.0, 1.0, 1.0),
+    radii: float = 0.0025,
+) -> None:
+    """Log a simple 3D trajectory as a line strip."""
+    strips = np.array(positions, dtype=np.float32)
+
+    rr.log(
+        entity_id,
+        rr.LineStrips3D(
+            strips=[strips],
+            colors=[color],
+            radii=[radii],
+        ),
+    )
+
+
+def log_keypoints(
+    keypoints: list[Any],
+    connections: list[tuple[int, int]],
+    entity_id: str,
+    color: Color = (1.0, 1.0, 1.0, 1.0),
+    radii: float = 0.0075,
+) -> None:
+    """Log a set of 3D keypoints as point primitives and connections."""
+    if not keypoints:
+        return
+
+    positions = np.array([[keypoint.position.x, keypoint.position.y, keypoint.position.z] 
+        for keypoint in keypoints], dtype=np.float32)
+
+    rr.log(
+        f"{entity_id}/keypoints",
+        rr.Points3D(
+            positions=positions,
+            colors=[color],
+            radii=radii,
+        ),
+    )
+
+    strips = np.array([[positions[connection[0]], positions[connection[1]]] 
+        for connection in connections], dtype=np.float32)
+
+    rr.log(
+        f"{entity_id}/connections",
+        rr.LineStrips3D(
+            strips=strips,
+            colors=[color],
+            radii=[radii * 0.25],
+        ),
+    )
+
+
+def log_sea(sequence_path: Path) -> None:
+    """
+    Logs SEA sequence data using Rerun.
+
+    Args:
+    ----
+    sequence_path (Path):
+        The path to the SEA recording.
+
+    Returns
+    -------
+    None
+
+    """
+
+    left_frames_path = sequence_path / "stereo" / "left_frames.dat"
+    right_frames_path = sequence_path / "stereo" / "right_frames.dat"
+    depth_path = sequence_path / "depth"
+    left_intrinsics_path = sequence_path / "stereo" / "left_intrinsics.txt"
+    right_intrinsics_path = sequence_path / "stereo" / "right_intrinsics.txt"
+    left_trajectory_path = sequence_path / "stereo" / "left_trajectory.bin"
+    right_trajectory_path = sequence_path / "stereo" / "right_trajectory.bin"
+    body_data_path = sequence_path / "body_data.bin"
+    hand_data_path = sequence_path / "hand_data.bin"
+
+    # Load frames
+    left_frames = load_frames(left_frames_path)
+    right_frames = load_frames(right_frames_path)
+
+    # Load depth
+    depth_frames = load_depth(depth_path)
+
+    # Load intrinsics
+    left_intrinsics = np.loadtxt(left_intrinsics_path)
+    right_intrinsics = np.loadtxt(right_intrinsics_path)
+
+    # Load trajectories
+    left_trajectory = load_trajectory(left_trajectory_path)
+    right_trajectory = load_trajectory(right_trajectory_path)
+
+    # Load body and hand data
+    body_data = load_body_data(body_data_path)
+    hand_data= load_hand_data(hand_data_path)
+
+    # World coordinate system
+    rr.log("world", rr.ViewCoordinates.LEFT_HAND_Y_UP, static=True)
+
+    # Log left and right images
+    for timestamp, image in left_frames:
+        rr.set_time("time", timestamp=timestamp * 1e-3)
+        rr.log(f"{CAMERA_LEFT_ENTITY_PATH}/bgr", rr.Image(image, color_model="BGR"))
+
+    for timestamp, image in right_frames:
+        rr.set_time("time", timestamp=timestamp * 1e-3)
+        rr.log(f"{CAMERA_RIGHT_ENTITY_PATH}/bgr", rr.Image(image, color_model="BGR"))
+
+    # Log depth
+    for timestamp, depth in depth_frames:
+        rr.set_time("time", timestamp=timestamp * 1e-3)
+        rr.log(f"{CAMERA_LEFT_ENTITY_PATH}/depth",
+            rr.DepthImage(depth, meter=1.0, colormap="viridis", depth_range=(0.0, 1.0)),
+        )
+
+    # Log left camera poses and trajectory
+    cumulative_xyz: list[list[float]] = []
+    for timestamp, pos, quat in left_trajectory:
+        rr.set_time("time", timestamp=timestamp * 1e-3)
+        log_camera(left_intrinsics, pos, quat, CAMERA_LEFT_ENTITY_PATH)
+
+        cumulative_xyz.append(pos.tolist())
+        log_trajectory(cumulative_xyz, TRAJECTORY_LEFT_ENTITY_PATH, color=(1.0, 1.0, 0.0, 1.0))
+
+    for timestamp, keypoints in body_data:
+        rr.set_time("time", timestamp=timestamp * 1e-3)
+        log_keypoints(keypoints, BODY_CONNECTIONS, BODY_ENTITY_PATH, color=(0.8, 0.0, 1.0, 1.0))
+
+    for timestamp, left_keypoints, right_keypoints in hand_data:
+        rr.set_time("time", timestamp=timestamp * 1e-3)
+        log_keypoints(left_keypoints, HAND_CONNECTIONS, HAND_LEFT_ENTITY_PATH, color=(0.3, 0.0, 0.4, 1.0))
+        log_keypoints(right_keypoints, HAND_CONNECTIONS, HAND_RIGHT_ENTITY_PATH, color=(0.3, 0.0, 0.4, 1.0))
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=DESCRIPTION)
+    parser.add_argument(
+        "--sequence",
+        type=str,
+        choices=AVAILABLE_SEQUENCES,
+        default="0aeb0c00-ef9c-4325-b005-53ace076b641",
+        help="Sequence ID of the SEA dataset",
+    )
+    rr.script_add_args(parser)
+    args = parser.parse_args()
+
+    blueprint = rrb.Horizontal(
+        rrb.Spatial3DView(
+            name="3D", 
+            origin="world",
+            background=rrba.Background(
+                kind=BackgroundKind.SolidColor,
+                color=[0, 0, 0, 255],
+            )
+        ),
+        rrb.Vertical(
+            rrb.Spatial2DView(
+                name="Left",
+                origin=CAMERA_LEFT_ENTITY_PATH,
+                contents=["$origin/bgr"],
+            ),
+            rrb.Spatial2DView(
+                name="Right",
+                origin=CAMERA_RIGHT_ENTITY_PATH,
+                contents=["$origin/bgr"],
+            ),
+            rrb.Spatial2DView(
+                name="Depth",
+                origin=CAMERA_LEFT_ENTITY_PATH,
+                contents=["$origin/depth"],
+            ),
+            name="2D",
+        ),
+    )
+
+    rr.script_setup(args, "sea_scenes")
+    rr.send_blueprint(blueprint)
+
+    log_sea(SEQUENCE_ROOT / args.sequence)
+
+    rr.script_teardown(args)
+
+
+if __name__ == "__main__":
+    main()

sea_scenes/loaders.py

@@ -0,0 +1,167 @@
+from pathlib import Path
+from typing import Any, List, Tuple
+import struct
+
+import numpy as np
+import cv2
+
+from .types import Vector3, Quaternion, Keypoint
+
+
+def load_frames(frames_path: Path) -> List[Tuple[int, np.ndarray]]:
+    """Load encoded frames from a SEA stereo .dat file."""
+    frames: List[Tuple[int, np.ndarray]] = []
+
+    header_size = 8 + 8 + 4
+
+    with open(frames_path, "rb") as f:
+        while True:
+            header = f.read(header_size)
+            if len(header) < header_size:
+                break
+
+            frame_timestamp, frame_index, frame_size = struct.unpack(">qqi", header)
+            frame_bytes = f.read(frame_size)
+
+            if len(frame_bytes) != frame_size:
+                raise EOFError("Unexpected EOF while reading frame data")
+
+            frame_array = np.frombuffer(frame_bytes, dtype=np.uint8)
+            frame = cv2.imdecode(frame_array, cv2.IMREAD_COLOR)
+            if frame is not None:
+                frames.append((frame_timestamp, frame))
+
+    return frames
+
+
+def load_depth(depth_dir: Path) -> list[tuple[int, np.ndarray]]:
+    """Load depth from .npy files: <timestamp>_depth_meter.npy."""
+    depth_frames: list[tuple[int, np.ndarray]] = []
+
+    for path in sorted(depth_dir.glob("*_depth_meter.npy")):
+        timestamp = int(path.stem.split("_")[0])
+
+        depth = np.load(path).astype(np.float32)
+        depth_frames.append((timestamp, depth))
+
+    return depth_frames
+
+
+def load_trajectory(trajectory_path: Path) -> List[Tuple[int, np.ndarray, np.ndarray]]:
+    """Load camera trajectory from SEA binary trajectory file."""
+    trajectory: List[Tuple[int, np.ndarray, np.ndarray]] = []
+
+    trajectory_buffer_size = 8 + 7 * 4
+
+    with open(trajectory_path, "rb") as f:
+        while True:
+            trajectory_buffer = f.read(trajectory_buffer_size)
+            if len(trajectory_buffer) < trajectory_buffer_size:
+                break
+
+            timestamp = struct.unpack("<q", trajectory_buffer[:8])[0]
+            pos_x, pos_y, pos_z, quat_x, quat_y, quat_z, quat_w = struct.unpack("<7f", trajectory_buffer[8:])
+
+            pos = np.array([pos_x, pos_y, pos_z], dtype=np.float32)
+            quat = np.array([quat_x, quat_y, quat_z, quat_w], dtype=np.float32)
+
+            trajectory.append((timestamp, pos, quat))
+
+    return trajectory
+
+
+def load_body_data(body_data_path: Path) -> List[Any]:
+    """Load body tracking data from SEA binary body_data file."""
+    body_frames: List[Any] = []
+
+    header_size = 8 + 4
+
+    with open(body_data_path, "rb") as f:
+        while True:
+            header = f.read(header_size)
+            if len(header) < header_size:
+                break
+
+            timestamp, keypoint_count = struct.unpack("<qi", header)
+            keypoints = _read_keypoints(f, keypoint_count)[:70]
+
+            body_frames.append(
+                (
+                    timestamp,
+                    keypoints
+                )
+            )
+
+    return body_frames
+
+
+def load_hand_data(hand_data_path: Path) -> List[Any]:
+    """Load hand tracking data from SEA binary hand_data file."""
+    hand_frames: List[Any] = []
+
+    timestamp_buffer_size = 8
+    left_count_buffer_size = 4
+    right_count_buffer_size = 4
+
+    with open(hand_data_path, "rb") as f:
+        while True:
+            timestamp_buffer = f.read(timestamp_buffer_size)
+            if len(timestamp_buffer) < timestamp_buffer_size:
+                break
+            timestamp = struct.unpack("<q", timestamp_buffer)[0]
+
+            left_count_buffer = f.read(left_count_buffer_size)
+            if len(left_count_buffer) < left_count_buffer_size:
+                break
+            left_count = struct.unpack("<i", left_count_buffer)[0]
+            left_keypoints = _read_keypoints(f, left_count)
+
+            right_count_buffer = f.read(right_count_buffer_size)
+            if len(right_count_buffer) < right_count_buffer_size:
+                break
+            right_count = struct.unpack("<i", right_count_buffer)[0]
+            right_keypoints = _read_keypoints(f, right_count)
+
+            hand_frames.append(
+                (
+                    timestamp,
+                    left_keypoints if left_keypoints else None,
+                    right_keypoints if right_keypoints else None,
+                )
+            )
+
+    return hand_frames
+
+
+def _read_keypoints(f: Any, keypoint_count: int) -> List[Keypoint]:
+    if keypoint_count <= 0:
+        return []
+
+    floats_per_keypoint = 7
+    total_float_count = keypoint_count * floats_per_keypoint
+    bytes_per_float = 4
+    expected_byte_count = total_float_count * bytes_per_float
+
+    raw_bytes = f.read(expected_byte_count)
+
+    if len(raw_bytes) != expected_byte_count:
+        raise EOFError("Unexpected EOF while reading keypoint data")
+
+    float_values = struct.unpack("<" + "f" * total_float_count, raw_bytes)
+
+    keypoints: List[Keypoint] = []
+
+    for keypoint_index in range(keypoint_count):
+        base_index = keypoint_index * floats_per_keypoint
+        pos_x, pos_y, pos_z, quat_x, quat_y, quat_z, quat_w = float_values[
+            base_index : base_index + floats_per_keypoint
+        ]
+
+        keypoints.append(
+            Keypoint(
+                position=Vector3(pos_x, pos_y, pos_z),
+                rotation=Quaternion(quat_x, quat_y, quat_z, quat_w),
+            )
+        )
+
+    return keypoints

sea_scenes/types.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Vector3:
+    x: float
+    y: float
+    z: float
+
+
+@dataclass
+class Quaternion:
+    x: float
+    y: float
+    z: float
+    w: float
+
+
+@dataclass
+class Keypoint:
+    position: Vector3
+    rotation: Quaternion