initialize odometry rosbag storage dataset

.gitattributes

@@ -0,0 +1,17 @@
+*.bag filter=lfs diff=lfs merge=lfs -text
+*.mcap filter=lfs diff=lfs merge=lfs -text
+*.db3 filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.pcd filter=lfs diff=lfs merge=lfs -text
+*.ply filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tar.gz filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,16 @@
+*.bag.active
+*.active
+*.tmp
+*.partial
+.cache/
+tmp/
+scratch/
+outputs_tmp/
+__pycache__/
+*.pyc
+.ipynb_checkpoints/
+.DS_Store
+*.log
+
+# Local source bags before import. Imported bags live under raw/sessions/.
+dataset/

Makefile

@@ -0,0 +1,18 @@
+.PHONY: init-lfs build-index validate scan-all
+
+init-lfs:
+	bash scripts/init_git_lfs.sh
+
+build-index:
+	python scripts/build_sessions_parquet.py --repo-root .
+	python scripts/build_topics_parquet.py --repo-root .
+
+validate:
+	python scripts/validate_dataset.py --repo-root .
+
+scan-all:
+	@for session_dir in raw/sessions/*; do \
+		if [ -d "$$session_dir" ]; then \
+			python scripts/scan_bag_topics.py --session-dir "$$session_dir" --write-metadata; \
+		fi; \
+	done

README.md

@@ -0,0 +1,210 @@
+---
+pretty_name: Odometry ROSBag Dataset
+license: other
+task_categories:
+  - robotics
+tags:
+  - rosbag
+  - odometry
+  - robotics
+  - imu
+  - lidar
+  - camera
+configs:
+  sessions:
+    - metadata/sessions.parquet
+  topics:
+    - metadata/topics.parquet
+---
+
+# Odometry ROSBag Dataset
+
+## 1. Dataset Overview
+
+This is the first version of a simple ROSBag storage dataset. It stores immutable raw ROSBag files and builds small Parquet index tables for fast discovery.
+
+Version 1 does not create `train`, `val`, or `test` splits. It does not export RGB images, depth images, infrared images, lidar point clouds, or training-ready frame folders.
+
+## 2. Repository Structure
+
+```text
+raw/sessions/<session_id>/bag.bag
+raw/sessions/<session_id>/bag.bag.sha256
+raw/sessions/<session_id>/metadata.yaml
+raw/sessions/<session_id>/topic_summary.yaml
+metadata/sessions.parquet
+metadata/topics.parquet
+calibration/robot_v1_template/
+quality/reports/
+scripts/
+examples/
+tests/
+```
+
+## 3. Raw ROSBag Policy
+
+Raw rosbag files are the source of truth. Treat them as immutable original data.
+
+Do not overwrite old bags. Do not edit old bags in place. Every new collection must become a new session under `raw/sessions/<session_id>/`.
+
+## 4. ROS Topics
+
+IMU:
+
+- `/mavros/imu/data`
+- `/mavros/imu/data_raw`
+- `/livox/imu`
+
+ToF:
+
+- `/nlink_tofsensem_cascade`
+
+LiDAR:
+
+- `/livox/lidar`
+
+Odometry:
+
+- `/fusion_odometry/current_point_odom`
+- `/fusion_odometry/lazy_point_odom`
+- `/ekf_quat/ekf_odom`
+
+Camera:
+
+- `/camera/color/image_raw`
+- `/camera/color/camera_info`
+- `/camera/depth/image_rect_raw`
+- `/camera/depth/camera_info`
+- `/camera/infra1/image_rect_raw`
+- `/camera/infra1/camera_info`
+- `/camera/infra2/image_rect_raw`
+- `/camera/infra2/camera_info`
+
+TF:
+
+- `/tf`
+- `/tf_static`
+
+## 5. Session Naming
+
+Input bags use:
+
+```text
+odom_dataset_YYYYMMDD_HHMMSS.bag
+```
+
+Session IDs use:
+
+```text
+YYYY-MM-DD_HHMMSS_odom_runXXX
+```
+
+Example:
+
+```text
+odom_dataset_20260513_024746.bag -> 2026-05-13_024746_odom_run001
+```
+
+## 6. Time Convention
+
+All timestamps in metadata and Parquet indexes use nanoseconds (`ns`).
+
+## 7. Calibration
+
+Calibration templates live under `calibration/robot_v1_template/`. They are placeholders for robot frame transforms and sensor intrinsics. Replace template values with measured calibration before using the data for quantitative work.
+
+## 8. Metadata Schema
+
+The schema is documented in `metadata/schema.md`. Per-session metadata lives in each session directory as `metadata.yaml`.
+
+## 9. Parquet Tables
+
+`metadata/sessions.parquet` indexes sessions.
+
+`metadata/topics.parquet` indexes per-topic statistics.
+
+Parquet is an index and fast lookup entry point. It is not a replacement for the raw ROSBag data.
+
+## 10. How to Import Existing Bags
+
+```bash
+python scripts/import_raw_bags.py --input-dir /path/to/my/bags --mode hardlink --repo-root .
+```
+
+Use `--dry-run` first to inspect the plan.
+
+## 11. How to Add a New Bag
+
+```bash
+python scripts/add_session.py \
+  --bag /path/to/odom_dataset_20260513_024746.bag \
+  --session-id 2026-05-13_024746_odom_run001 \
+  --calibration-id robot_v1_template \
+  --quality-status unchecked \
+  --mode hardlink \
+  --repo-root .
+```
+
+## 12. How to Scan Topics
+
+```bash
+python scripts/scan_bag_topics.py \
+  --session-dir raw/sessions/2026-05-13_024746_odom_run001 \
+  --write-metadata
+```
+
+To scan all sessions:
+
+```bash
+make scan-all
+```
+
+## 13. How to Validate the Dataset
+
+```bash
+python scripts/validate_dataset.py --repo-root .
+```
+
+## 14. How to Use with Git LFS
+
+```bash
+bash scripts/init_git_lfs.sh
+git add .gitattributes
+git commit -m "configure git lfs"
+```
+
+Large binary data such as `.bag` and `.parquet` files are tracked by Git LFS. YAML, Markdown, Python, shell scripts, and JSON stay as normal Git text files.
+
+## 15. How to Push to Hugging Face
+
+After import, scan, index build, and validation:
+
+```bash
+git add .
+git commit -m "initialize odometry rosbag storage dataset"
+git lfs ls-files
+git remote add origin <your-hugging-face-dataset-git-url>
+git push origin main
+```
+
+This repository never pushes automatically.
+
+## 16. Future Work
+
+Later versions may add `train/val/test`, `frames.parquet`, `odometry.parquet`, image export, and point cloud export.
+
+If images or point clouds are exported later, do not put hundreds of thousands of files into one directory. Shard them by session and by time or frame range.
+
+## 17. Known Limitations
+
+Version 1 only stores raw bags and metadata indexes. It does not decode sensor payloads into training data. Topic statistics require a sourced ROS environment because `rosbag` comes from ROS, not from `requirements.txt`.
+
+## 18. Citation
+
+```bibtex
+@dataset{odometry_rosbag_dataset,
+  title = {Odometry ROSBag Dataset},
+  year = {2026},
+  note = {Raw ROSBag storage dataset with metadata indexes}
+}
+```

calibration/robot_v1_template/README.md

@@ -0,0 +1,12 @@
+# robot_v1_template Calibration
+
+This directory is a calibration placeholder. Replace template values with measured robot calibration before quantitative use.
+
+Files:
+
+- `tf_static.yaml`: static frame tree template
+- `camera_color.yaml`: color camera intrinsics template
+- `camera_depth.yaml`: depth camera intrinsics template
+- `livox_to_base.yaml`: Livox lidar extrinsic template
+- `tof_to_base.yaml`: ToF sensor extrinsic template
+- `imu_to_base.yaml`: IMU extrinsic template

calibration/robot_v1_template/camera_color.yaml

@@ -0,0 +1,11 @@
+camera_name: camera_color
+frame_id: camera_color_optical_frame
+image_width: null
+image_height: null
+distortion_model: plumb_bob
+intrinsics:
+  fx: null
+  fy: null
+  cx: null
+  cy: null
+distortion_coefficients: []

calibration/robot_v1_template/camera_depth.yaml

@@ -0,0 +1,11 @@
+camera_name: camera_depth
+frame_id: camera_depth_optical_frame
+image_width: null
+image_height: null
+distortion_model: plumb_bob
+intrinsics:
+  fx: null
+  fy: null
+  cx: null
+  cy: null
+distortion_coefficients: []

calibration/robot_v1_template/imu_to_base.yaml

@@ -0,0 +1,5 @@
+sensor: imu
+parent_frame: base_link
+child_frame: imu_frame
+translation_xyz_m: [0.0, 0.0, 0.0]
+rotation_xyzw: [0.0, 0.0, 0.0, 1.0]

calibration/robot_v1_template/livox_to_base.yaml

@@ -0,0 +1,5 @@
+sensor: livox_lidar
+parent_frame: base_link
+child_frame: livox_frame
+translation_xyz_m: [0.0, 0.0, 0.0]
+rotation_xyzw: [0.0, 0.0, 0.0, 1.0]

calibration/robot_v1_template/tf_static.yaml

@@ -0,0 +1,6 @@
+calibration_id: robot_v1_template
+frames:
+  base_link:
+    parent: world
+    translation_xyz_m: [0.0, 0.0, 0.0]
+    rotation_xyzw: [0.0, 0.0, 0.0, 1.0]

calibration/robot_v1_template/tof_to_base.yaml

@@ -0,0 +1,5 @@
+sensor: tof
+parent_frame: base_link
+child_frame: tof_frame
+translation_xyz_m: [0.0, 0.0, 0.0]
+rotation_xyzw: [0.0, 0.0, 0.0, 1.0]

dataset.yaml

@@ -0,0 +1,37 @@
+dataset_name: odometry-rosbag-dataset
+schema_version: 0.1.0
+canonical_raw_format: rosbag1
+timestamp_unit: ns
+
+raw_layout:
+  sessions_dir: raw/sessions
+  session_bag_name: bag.bag
+  checksum_name: bag.bag.sha256
+  metadata_name: metadata.yaml
+  topic_summary_name: topic_summary.yaml
+
+default_topics:
+  rgb: /camera/color/image_raw
+  rgb_info: /camera/color/camera_info
+  depth: /camera/depth/image_rect_raw
+  depth_info: /camera/depth/camera_info
+  infra1: /camera/infra1/image_rect_raw
+  infra1_info: /camera/infra1/camera_info
+  infra2: /camera/infra2/image_rect_raw
+  infra2_info: /camera/infra2/camera_info
+  lidar: /livox/lidar
+  livox_imu: /livox/imu
+  mavros_imu: /mavros/imu/data
+  mavros_imu_raw: /mavros/imu/data_raw
+  tof: /nlink_tofsensem_cascade
+  odom_primary: /fusion_odometry/current_point_odom
+  odom_secondary: /fusion_odometry/lazy_point_odom
+  odom_ekf: /ekf_quat/ekf_odom
+  tf: /tf
+  tf_static: /tf_static
+
+quality_status:
+  - unchecked
+  - good
+  - usable
+  - bad

examples/import_all_bags.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+RAW_BAG_DIR="/path/to/folder/containing/bags"
+
+python scripts/import_raw_bags.py \
+  --input-dir "$RAW_BAG_DIR" \
+  --mode hardlink \
+  --repo-root .
+
+make scan-all
+make build-index
+make validate

examples/load_metadata.py

@@ -0,0 +1,7 @@
+import pandas as pd
+
+sessions = pd.read_parquet("metadata/sessions.parquet")
+topics = pd.read_parquet("metadata/topics.parquet")
+
+print(sessions.head())
+print(topics.head())

metadata/schema.md

@@ -0,0 +1,42 @@
+# Metadata Schema
+
+All timestamps use nanoseconds (`ns`). The first version stores indexes only. Raw ROSBag files remain the source of truth.
+
+## `metadata/sessions.parquet`
+
+| Column | Type | Description |
+| --- | --- | --- |
+| `session_id` | `string` | Session directory name. |
+| `bag_path` | `string` | Relative path to `bag.bag`. |
+| `sha256_path` | `string` | Relative path to `bag.bag.sha256`. |
+| `metadata_path` | `string` | Relative path to `metadata.yaml`. |
+| `duration_sec` | `float64` | Bag duration in seconds. |
+| `start_time_ns` | `int64` | Earliest message timestamp. |
+| `end_time_ns` | `int64` | Latest message timestamp. |
+| `num_messages` | `int64` | Total message count. |
+| `has_lidar` | `bool` | Session contains lidar data. |
+| `has_rgb` | `bool` | Session contains RGB camera data. |
+| `has_depth` | `bool` | Session contains depth camera data. |
+| `has_infra` | `bool` | Session contains infrared camera data. |
+| `has_tof` | `bool` | Session contains ToF data. |
+| `has_imu` | `bool` | Session contains IMU data. |
+| `has_odom` | `bool` | Session contains odometry data. |
+| `has_tf` | `bool` | Session contains TF data. |
+| `calibration_id` | `string` | Calibration directory ID. |
+| `quality_status` | `string` | One of `unchecked`, `good`, `usable`, `bad`. |
+| `source_filename` | `string` | Original bag filename. |
+| `import_mode` | `string` | Import mode: `hardlink`, `copy`, `symlink`, or `move`. |
+
+## `metadata/topics.parquet`
+
+| Column | Type | Description |
+| --- | --- | --- |
+| `session_id` | `string` | Session directory name. |
+| `bag_path` | `string` | Relative path to `bag.bag`. |
+| `topic` | `string` | ROS topic name. |
+| `msg_type` | `string` | ROS message type. |
+| `count` | `int64` | Message count for this topic. |
+| `hz_mean` | `float64` | Mean frequency estimated from timestamps. |
+| `timestamp_min_ns` | `int64` | Earliest topic timestamp. |
+| `timestamp_max_ns` | `int64` | Latest topic timestamp. |
+| `category` | `string` | Topic category. |

metadata/sensors.yaml

@@ -0,0 +1,25 @@
+topic_categories:
+  IMU:
+    - /mavros/imu/data
+    - /mavros/imu/data_raw
+    - /livox/imu
+  ToF:
+    - /nlink_tofsensem_cascade
+  LiDAR:
+    - /livox/lidar
+  Odometry:
+    - /fusion_odometry/current_point_odom
+    - /fusion_odometry/lazy_point_odom
+    - /ekf_quat/ekf_odom
+  Camera:
+    - /camera/color/image_raw
+    - /camera/color/camera_info
+    - /camera/depth/image_rect_raw
+    - /camera/depth/camera_info
+    - /camera/infra1/image_rect_raw
+    - /camera/infra1/camera_info
+    - /camera/infra2/image_rect_raw
+    - /camera/infra2/camera_info
+  TF:
+    - /tf
+    - /tf_static

metadata/sessions.parquet

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

metadata/topics.parquet

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

requirements.txt

@@ -0,0 +1,4 @@
+pyyaml
+pandas
+pyarrow
+tqdm

scripts/add_session.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import hashlib
+import os
+import shutil
+from pathlib import Path
+from typing import Literal
+
+import yaml
+
+ImportMode = Literal["hardlink", "copy", "symlink", "move"]
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def import_bag(source: Path, target: Path, mode: ImportMode) -> None:
+    target.parent.mkdir(parents=True, exist_ok=True)
+    if target.exists() or target.is_symlink():
+        raise FileExistsError(f"Target bag already exists: {target}")
+
+    if mode == "hardlink":
+        try:
+            os.link(source, target)
+        except OSError as exc:
+            raise RuntimeError(
+                f"Failed to create hardlink from {source} to {target}. "
+                "Use --mode copy, --mode symlink, or --mode move explicitly."
+            ) from exc
+    elif mode == "copy":
+        shutil.copy2(source, target)
+    elif mode == "symlink":
+        target.symlink_to(source.resolve())
+    elif mode == "move":
+        shutil.move(str(source), str(target))
+    else:
+        raise ValueError(f"Unsupported import mode: {mode}")
+
+
+def write_text_atomic(path: Path, text: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if path.exists():
+        raise FileExistsError(f"Refusing to overwrite existing file: {path}")
+    path.write_text(text, encoding="utf-8")
+
+
+def add_session(
+    bag: Path,
+    session_id: str,
+    calibration_id: str,
+    quality_status: str,
+    mode: ImportMode,
+    repo_root: Path,
+) -> Path:
+    if not bag.exists():
+        raise FileNotFoundError(f"Bag does not exist: {bag}")
+    if not bag.is_file():
+        raise ValueError(f"Bag path is not a file: {bag}")
+
+    session_dir = repo_root / "raw" / "sessions" / session_id
+    if session_dir.exists():
+        raise FileExistsError(f"Session already exists, refusing to overwrite: {session_dir}")
+
+    target_bag = session_dir / "bag.bag"
+    import_bag(bag, target_bag, mode)
+
+    digest = sha256_file(target_bag)
+    sha_path = session_dir / "bag.bag.sha256"
+    write_text_atomic(sha_path, f"{digest}  bag.bag\n")
+
+    metadata = {
+        "session_id": session_id,
+        "raw": {
+            "format": "rosbag1",
+            "file": "bag.bag",
+            "sha256_file": "bag.bag.sha256",
+            "ros_distro": os.environ.get("ROS_DISTRO"),
+        },
+        "source": {
+            "filename": bag.name,
+            "path": str(bag),
+            "import_mode": mode,
+        },
+        "platform": {},
+        "time": {
+            "duration_sec": None,
+            "start_time_ns": None,
+            "end_time_ns": None,
+            "num_messages": None,
+        },
+        "topics": [],
+        "calibration_id": calibration_id,
+        "quality": {
+            "status": quality_status,
+            "notes": "",
+        },
+    }
+    metadata_path = session_dir / "metadata.yaml"
+    write_text_atomic(metadata_path, yaml.safe_dump(metadata, sort_keys=False, allow_unicode=False))
+    return session_dir
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Add one ROSBag as an immutable raw session.")
+    parser.add_argument("--bag", required=True, type=Path)
+    parser.add_argument("--session-id", required=True)
+    parser.add_argument("--calibration-id", required=True)
+    parser.add_argument("--quality-status", required=True)
+    parser.add_argument("--mode", choices=["hardlink", "copy", "symlink", "move"], required=True)
+    parser.add_argument("--repo-root", default=Path("."), type=Path)
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    session_dir = add_session(
+        bag=args.bag,
+        session_id=args.session_id,
+        calibration_id=args.calibration_id,
+        quality_status=args.quality_status,
+        mode=args.mode,
+        repo_root=args.repo_root,
+    )
+    print(f"Added session: {session_dir}")
+
+
+if __name__ == "__main__":
+    main()

scripts/build_sessions_parquet.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import Any
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+import yaml
+
+SCHEMA = pa.schema(
+    [
+        ("session_id", pa.string()),
+        ("bag_path", pa.string()),
+        ("sha256_path", pa.string()),
+        ("metadata_path", pa.string()),
+        ("duration_sec", pa.float64()),
+        ("start_time_ns", pa.int64()),
+        ("end_time_ns", pa.int64()),
+        ("num_messages", pa.int64()),
+        ("has_lidar", pa.bool_()),
+        ("has_rgb", pa.bool_()),
+        ("has_depth", pa.bool_()),
+        ("has_infra", pa.bool_()),
+        ("has_tof", pa.bool_()),
+        ("has_imu", pa.bool_()),
+        ("has_odom", pa.bool_()),
+        ("has_tf", pa.bool_()),
+        ("calibration_id", pa.string()),
+        ("quality_status", pa.string()),
+        ("source_filename", pa.string()),
+        ("import_mode", pa.string()),
+    ]
+)
+
+
+def rel(path: Path, root: Path) -> str:
+    return path.relative_to(root).as_posix()
+
+
+def read_yaml(path: Path) -> dict[str, Any]:
+    return yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+
+
+def topics_from(session_dir: Path, metadata: dict[str, Any]) -> list[dict[str, Any]]:
+    summary_path = session_dir / "topic_summary.yaml"
+    if summary_path.exists():
+        summary = read_yaml(summary_path)
+        return list(summary.get("topics") or [])
+    return list(metadata.get("topics") or [])
+
+
+def has_topic(topics: list[dict[str, Any]], needle: str) -> bool:
+    return any(needle in str(item.get("topic", "")) for item in topics)
+
+
+def has_category(topics: list[dict[str, Any]], category: str) -> bool:
+    return any(str(item.get("category", "")).lower() == category for item in topics)
+
+
+def build_rows(repo_root: Path) -> list[dict[str, Any]]:
+    sessions_dir = repo_root / "raw" / "sessions"
+    rows: list[dict[str, Any]] = []
+    if not sessions_dir.exists():
+        return rows
+
+    for session_dir in sorted(path for path in sessions_dir.iterdir() if path.is_dir()):
+        metadata_path = session_dir / "metadata.yaml"
+        metadata = read_yaml(metadata_path) if metadata_path.exists() else {}
+        time = metadata.get("time") or {}
+        source = metadata.get("source") or {}
+        quality = metadata.get("quality") or {}
+        topics = topics_from(session_dir, metadata)
+        row = {
+            "session_id": session_dir.name,
+            "bag_path": rel(session_dir / "bag.bag", repo_root),
+            "sha256_path": rel(session_dir / "bag.bag.sha256", repo_root),
+            "metadata_path": rel(metadata_path, repo_root),
+            "duration_sec": time.get("duration_sec"),
+            "start_time_ns": time.get("start_time_ns"),
+            "end_time_ns": time.get("end_time_ns"),
+            "num_messages": time.get("num_messages"),
+            "has_lidar": has_category(topics, "lidar") or has_topic(topics, "/livox/lidar"),
+            "has_rgb": has_topic(topics, "/camera/color/image_raw"),
+            "has_depth": has_topic(topics, "/camera/depth/"),
+            "has_infra": has_topic(topics, "/camera/infra"),
+            "has_tof": has_category(topics, "tof") or has_topic(topics, "nlink"),
+            "has_imu": has_category(topics, "imu") or has_topic(topics, "imu"),
+            "has_odom": has_category(topics, "odometry") or has_topic(topics, "odom"),
+            "has_tf": has_category(topics, "tf") or has_topic(topics, "/tf"),
+            "calibration_id": metadata.get("calibration_id"),
+            "quality_status": quality.get("status"),
+            "source_filename": source.get("filename"),
+            "import_mode": source.get("import_mode"),
+        }
+        rows.append(row)
+    return rows
+
+
+def write_parquet(rows: list[dict[str, Any]], output: Path) -> None:
+    output.parent.mkdir(parents=True, exist_ok=True)
+    table = pa.Table.from_pylist(rows, schema=SCHEMA)
+    pq.write_table(table, output)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Build metadata/sessions.parquet.")
+    parser.add_argument("--repo-root", default=Path("."), type=Path)
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    repo_root = args.repo_root.resolve()
+    output = repo_root / "metadata" / "sessions.parquet"
+    rows = build_rows(repo_root)
+    write_parquet(rows, output)
+    print(f"Wrote {output} with {len(rows)} rows")
+
+
+if __name__ == "__main__":
+    main()

scripts/build_topics_parquet.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import warnings
+from pathlib import Path
+from typing import Any
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+import yaml
+
+SCHEMA = pa.schema(
+    [
+        ("session_id", pa.string()),
+        ("bag_path", pa.string()),
+        ("topic", pa.string()),
+        ("msg_type", pa.string()),
+        ("count", pa.int64()),
+        ("hz_mean", pa.float64()),
+        ("timestamp_min_ns", pa.int64()),
+        ("timestamp_max_ns", pa.int64()),
+        ("category", pa.string()),
+    ]
+)
+
+
+def rel(path: Path, root: Path) -> str:
+    return path.relative_to(root).as_posix()
+
+
+def read_yaml(path: Path) -> dict[str, Any]:
+    return yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+
+
+def build_rows(repo_root: Path) -> list[dict[str, Any]]:
+    sessions_dir = repo_root / "raw" / "sessions"
+    rows: list[dict[str, Any]] = []
+    if not sessions_dir.exists():
+        return rows
+
+    for session_dir in sorted(path for path in sessions_dir.iterdir() if path.is_dir()):
+        summary_path = session_dir / "topic_summary.yaml"
+        if not summary_path.exists():
+            warnings.warn(f"Missing topic summary, skipping: {summary_path}", stacklevel=2)
+            continue
+        summary = read_yaml(summary_path)
+        for item in summary.get("topics") or []:
+            rows.append(
+                {
+                    "session_id": session_dir.name,
+                    "bag_path": rel(session_dir / "bag.bag", repo_root),
+                    "topic": item.get("topic"),
+                    "msg_type": item.get("msg_type"),
+                    "count": item.get("count"),
+                    "hz_mean": item.get("hz_mean"),
+                    "timestamp_min_ns": item.get("timestamp_min_ns"),
+                    "timestamp_max_ns": item.get("timestamp_max_ns"),
+                    "category": item.get("category"),
+                }
+            )
+    return rows
+
+
+def write_parquet(rows: list[dict[str, Any]], output: Path) -> None:
+    output.parent.mkdir(parents=True, exist_ok=True)
+    table = pa.Table.from_pylist(rows, schema=SCHEMA)
+    pq.write_table(table, output)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Build metadata/topics.parquet.")
+    parser.add_argument("--repo-root", default=Path("."), type=Path)
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    repo_root = args.repo_root.resolve()
+    output = repo_root / "metadata" / "topics.parquet"
+    rows = build_rows(repo_root)
+    write_parquet(rows, output)
+    print(f"Wrote {output} with {len(rows)} rows")
+
+
+if __name__ == "__main__":
+    main()

scripts/import_raw_bags.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import re
+from datetime import datetime
+from pathlib import Path
+
+from add_session import add_session
+
+BAG_RE = re.compile(r"^odom_dataset_(\d{8})_(\d{6})\.bag$")
+
+
+def session_id_from_name(path: Path, run_index: int) -> str:
+    match = BAG_RE.match(path.name)
+    if not match:
+        raise ValueError(f"Unsupported bag filename: {path.name}")
+    day, clock = match.groups()
+    dt = datetime.strptime(day + clock, "%Y%m%d%H%M%S")
+    return f"{dt:%Y-%m-%d}_{clock}_odom_run{run_index:03d}"
+
+
+def find_bags(input_dir: Path) -> list[Path]:
+    if not input_dir.exists():
+        raise FileNotFoundError(f"Input directory does not exist: {input_dir}")
+    if not input_dir.is_dir():
+        raise ValueError(f"Input path is not a directory: {input_dir}")
+    return sorted(
+        [path for path in input_dir.iterdir() if path.is_file() and BAG_RE.match(path.name)],
+        key=lambda path: path.name,
+    )
+
+
+def print_plan(rows: list[tuple[Path, str, Path, str]]) -> None:
+    headers = ("source_path", "session_id", "target_path", "mode")
+    widths = [len(item) for item in headers]
+    for row in rows:
+        values = [str(row[0]), row[1], str(row[2]), row[3]]
+        widths = [max(width, len(value)) for width, value in zip(widths, values)]
+    print("  ".join(header.ljust(width) for header, width in zip(headers, widths)))
+    print("  ".join("-" * width for width in widths))
+    for row in rows:
+        values = [str(row[0]), row[1], str(row[2]), row[3]]
+        print("  ".join(value.ljust(width) for value, width in zip(values, widths)))
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Batch import odometry ROSBag files as raw sessions.")
+    parser.add_argument("--input-dir", required=True, type=Path)
+    parser.add_argument("--mode", default="hardlink", choices=["hardlink", "copy", "symlink", "move"])
+    parser.add_argument("--repo-root", default=Path("."), type=Path)
+    parser.add_argument("--calibration-id", default="robot_v1_template")
+    parser.add_argument("--quality-status", default="unchecked")
+    parser.add_argument("--dry-run", action="store_true")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    bags = find_bags(args.input_dir)
+    rows: list[tuple[Path, str, Path, str]] = []
+    for index, bag in enumerate(bags, start=1):
+        session_id = session_id_from_name(bag, index)
+        target = args.repo_root / "raw" / "sessions" / session_id / "bag.bag"
+        rows.append((bag, session_id, target, args.mode))
+
+    if not rows:
+        print(f"No matching bags found in {args.input_dir}")
+        return
+
+    if args.dry_run:
+        print_plan(rows)
+        return
+
+    for bag, session_id, _, _ in rows:
+        session_dir = add_session(
+            bag=bag,
+            session_id=session_id,
+            calibration_id=args.calibration_id,
+            quality_status=args.quality_status,
+            mode=args.mode,
+            repo_root=args.repo_root,
+        )
+        print(f"Imported {bag} -> {session_dir}")
+
+
+if __name__ == "__main__":
+    main()

scripts/init_git_lfs.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+git lfs install
+git lfs track "*.bag"
+git lfs track "*.mcap"
+git lfs track "*.db3"
+git lfs track "*.parquet"
+git lfs track "*.arrow"
+git lfs track "*.jpg"
+git lfs track "*.jpeg"
+git lfs track "*.png"
+git lfs track "*.tiff"
+git lfs track "*.mp4"
+git lfs track "*.npz"
+git lfs track "*.npy"
+git lfs track "*.pcd"
+git lfs track "*.ply"
+git lfs track "*.zst"
+git lfs track "*.tar"
+git lfs track "*.tar.gz"
+
+echo
+echo "Next:"
+echo "git add .gitattributes"
+echo "git commit -m \"configure git lfs\""

scripts/scan_bag_topics.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+def import_rosbag() -> Any:
+    try:
+        import rosbag  # type: ignore
+    except ImportError as exc:
+        raise ImportError(
+            "Failed to import rosbag. Please source your ROS environment first, for example:\n"
+            "source /opt/ros/noetic/setup.bash"
+        ) from exc
+    return rosbag
+
+
+def to_nsec(stamp: Any) -> int:
+    if hasattr(stamp, "to_nsec"):
+        return int(stamp.to_nsec())
+    return int(float(stamp) * 1_000_000_000)
+
+
+def category_for_topic(topic: str, msg_type: str) -> str:
+    lower = f"{topic} {msg_type}".lower()
+    if topic in {"/tf", "/tf_static"}:
+        return "tf"
+    if "imu" in lower:
+        return "imu"
+    if "tof" in lower or "nlink" in lower:
+        return "tof"
+    if "livox/lidar" in lower or "pointcloud" in lower:
+        return "lidar"
+    if "odom" in lower:
+        return "odometry"
+    if "camera" in lower:
+        return "camera"
+    return "other"
+
+
+def scan_session(session_dir: Path) -> dict[str, Any]:
+    rosbag = import_rosbag()
+    bag_path = session_dir / "bag.bag"
+    if not bag_path.exists():
+        raise FileNotFoundError(f"Missing bag: {bag_path}")
+
+    with rosbag.Bag(str(bag_path), "r") as bag:
+        info = bag.get_type_and_topic_info()
+        topic_types = {topic: item.msg_type for topic, item in info.topics.items()}
+        stats: dict[str, dict[str, Any]] = {
+            topic: {
+                "topic": topic,
+                "msg_type": msg_type,
+                "count": 0,
+                "timestamp_min_ns": None,
+                "timestamp_max_ns": None,
+                "hz_mean": 0.0,
+                "category": category_for_topic(topic, msg_type),
+            }
+            for topic, msg_type in topic_types.items()
+        }
+
+        for topic, _, stamp in bag.read_messages():
+            stamp_ns = to_nsec(stamp)
+            item = stats.setdefault(
+                topic,
+                {
+                    "topic": topic,
+                    "msg_type": topic_types.get(topic, ""),
+                    "count": 0,
+                    "timestamp_min_ns": None,
+                    "timestamp_max_ns": None,
+                    "hz_mean": 0.0,
+                    "category": category_for_topic(topic, topic_types.get(topic, "")),
+                },
+            )
+            item["count"] += 1
+            item["timestamp_min_ns"] = stamp_ns if item["timestamp_min_ns"] is None else min(item["timestamp_min_ns"], stamp_ns)
+            item["timestamp_max_ns"] = stamp_ns if item["timestamp_max_ns"] is None else max(item["timestamp_max_ns"], stamp_ns)
+
+    topics = sorted(stats.values(), key=lambda item: item["topic"])
+    total_messages = 0
+    start_time_ns: int | None = None
+    end_time_ns: int | None = None
+    for item in topics:
+        count = int(item["count"])
+        total_messages += count
+        min_ns = item["timestamp_min_ns"]
+        max_ns = item["timestamp_max_ns"]
+        if min_ns is not None:
+            start_time_ns = min_ns if start_time_ns is None else min(start_time_ns, min_ns)
+        if max_ns is not None:
+            end_time_ns = max_ns if end_time_ns is None else max(end_time_ns, max_ns)
+        if count > 1 and min_ns is not None and max_ns is not None and max_ns > min_ns:
+            item["hz_mean"] = float(count - 1) / ((max_ns - min_ns) / 1_000_000_000.0)
+
+    duration_sec = None
+    if start_time_ns is not None and end_time_ns is not None:
+        duration_sec = (end_time_ns - start_time_ns) / 1_000_000_000.0
+
+    return {
+        "session_id": session_dir.name,
+        "bag": "bag.bag",
+        "duration_sec": duration_sec,
+        "start_time_ns": start_time_ns,
+        "end_time_ns": end_time_ns,
+        "num_messages": total_messages,
+        "topics": topics,
+    }
+
+
+def update_metadata(session_dir: Path, summary: dict[str, Any]) -> None:
+    metadata_path = session_dir / "metadata.yaml"
+    if not metadata_path.exists():
+        raise FileNotFoundError(f"Missing metadata: {metadata_path}")
+    metadata = yaml.safe_load(metadata_path.read_text(encoding="utf-8")) or {}
+    metadata["time"] = {
+        "duration_sec": summary["duration_sec"],
+        "start_time_ns": summary["start_time_ns"],
+        "end_time_ns": summary["end_time_ns"],
+        "num_messages": summary["num_messages"],
+    }
+    metadata["topics"] = summary["topics"]
+    metadata_path.write_text(yaml.safe_dump(metadata, sort_keys=False, allow_unicode=False), encoding="utf-8")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Scan one session bag and write topic statistics.")
+    parser.add_argument("--session-dir", required=True, type=Path)
+    parser.add_argument("--write-metadata", action="store_true")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    summary = scan_session(args.session_dir)
+    summary_path = args.session_dir / "topic_summary.yaml"
+    summary_path.parent.mkdir(parents=True, exist_ok=True)
+    summary_path.write_text(yaml.safe_dump(summary, sort_keys=False, allow_unicode=False), encoding="utf-8")
+    if args.write_metadata:
+        update_metadata(args.session_dir, summary)
+    print(f"Wrote {summary_path}")
+
+
+if __name__ == "__main__":
+    main()

scripts/validate_dataset.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import hashlib
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def read_yaml(path: Path) -> dict[str, Any]:
+    return yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+
+
+def require(condition: bool, message: str, errors: list[str]) -> None:
+    if not condition:
+        errors.append(message)
+
+
+def expected_sha(path: Path) -> str:
+    text = path.read_text(encoding="utf-8").strip()
+    if not text:
+        raise ValueError(f"Empty sha256 file: {path}")
+    return text.split()[0]
+
+
+def validate_session(session_dir: Path, repo_root: Path, errors: list[str]) -> None:
+    bag_path = session_dir / "bag.bag"
+    sha_path = session_dir / "bag.bag.sha256"
+    metadata_path = session_dir / "metadata.yaml"
+
+    require(bag_path.exists(), f"Missing bag: {bag_path}", errors)
+    require(sha_path.exists(), f"Missing sha256: {sha_path}", errors)
+    require(metadata_path.exists(), f"Missing metadata: {metadata_path}", errors)
+    if not (bag_path.exists() and sha_path.exists() and metadata_path.exists()):
+        return
+
+    actual = sha256_file(bag_path)
+    expected = expected_sha(sha_path)
+    require(actual == expected, f"SHA256 mismatch: {bag_path}", errors)
+
+    metadata = read_yaml(metadata_path)
+    require(metadata.get("session_id") == session_dir.name, f"session_id mismatch: {metadata_path}", errors)
+    calibration_id = metadata.get("calibration_id")
+    require(bool(calibration_id), f"Missing calibration_id: {metadata_path}", errors)
+    if calibration_id:
+        require((repo_root / "calibration" / calibration_id).exists(), f"Missing calibration: {calibration_id}", errors)
+
+
+def validate_gitattributes(path: Path, errors: list[str]) -> None:
+    require(path.exists(), "Missing .gitattributes", errors)
+    if not path.exists():
+        return
+    text = path.read_text(encoding="utf-8")
+    require("*.bag" in text, ".gitattributes does not track *.bag", errors)
+    require("*.parquet" in text, ".gitattributes does not track *.parquet", errors)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Validate dataset repository integrity.")
+    parser.add_argument("--repo-root", default=Path("."), type=Path)
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    repo_root = args.repo_root.resolve()
+    errors: list[str] = []
+
+    sessions_dir = repo_root / "raw" / "sessions"
+    require(sessions_dir.exists(), "Missing raw/sessions", errors)
+    require((repo_root / "metadata" / "sessions.parquet").exists(), "Missing metadata/sessions.parquet", errors)
+    require((repo_root / "metadata" / "topics.parquet").exists(), "Missing metadata/topics.parquet", errors)
+    validate_gitattributes(repo_root / ".gitattributes", errors)
+
+    session_dirs = sorted(path for path in sessions_dir.iterdir() if path.is_dir()) if sessions_dir.exists() else []
+    names = [path.name for path in session_dirs]
+    require(len(names) == len(set(names)), "Duplicate session directory names found", errors)
+
+    if not session_dirs:
+        print("No sessions found. Repository structure is valid for an empty first-version dataset.")
+
+    for session_dir in session_dirs:
+        validate_session(session_dir, repo_root, errors)
+
+    if errors:
+        for error in errors:
+            print(f"ERROR: {error}")
+        raise SystemExit(1)
+
+    print("Dataset validation passed.")
+
+
+if __name__ == "__main__":
+    main()

tests/test_paths.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+
+
+def test_key_paths_exist() -> None:
+    root = Path(__file__).resolve().parents[1]
+    assert (root / "raw" / "sessions").exists()
+    assert (root / "metadata").exists()
+    assert (root / "calibration" / "robot_v1_template").exists()
+    assert (root / ".gitattributes").exists()
+    assert (root / "dataset.yaml").exists()

tests/test_schema.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+
+import pandas as pd
+
+
+def test_schema_doc_exists() -> None:
+    root = Path(__file__).resolve().parents[1]
+    assert (root / "metadata" / "schema.md").exists()
+
+
+def test_existing_parquet_files_are_readable() -> None:
+    root = Path(__file__).resolve().parents[1]
+    for path in [root / "metadata" / "sessions.parquet", root / "metadata" / "topics.parquet"]:
+        if path.exists():
+            pd.read_parquet(path)