Release OmniLife360 dataset benchmark

.gitattributes

@@ -0,0 +1,6 @@
+*.tar.zst filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.mp4 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

README.md

@@ -0,0 +1,118 @@
+---
+pretty_name: "OmniLife360"
+license: cc-by-nc-4.0
+tags:
+  - 3d
+  - video
+  - computer-vision
+  - benchmark
+  - panoramic
+  - 360-panorama
+  - reconstruction
+  - gaussian-splatting
+---
+
+# OmniLife360
+
+OmniLife360 is a benchmark for 3D reconstruction from in-the-wild 360-degree captures. This repository provides source links, benchmark metadata, COLMAP/SfM reconstruction results, and helper scripts for frame preparation and panorama SfM reproduction.
+
+The benchmark contains 2,407 panoramic sequences, totaling about 66 hours, with 1,937 training sequences and 470 testing sequences across 64 scene categories and 31 action classes. The metadata includes 2,177 publicly linked web-video sequences and 230 author-captured sequences that are not publicly linked.
+
+## Repository Contents
+
+```text
+metadata/train_test_split_with_links.json
+sfm/omnilife360_colmap_sfm_results.tar.zst
+scripts/prepare_frames_from_metadata.py
+scripts/run_panorama_sfm_from_frames.sh
+```
+
+`metadata/train_test_split_with_links.json` is the main benchmark index. It stores the official split, source links where available, temporal segments, scene/action labels, captions, and basic media metadata.
+
+`sfm/omnilife360_colmap_sfm_results.tar.zst` contains COLMAP/SfM reconstruction outputs organized by the same split/scene/sequence structure. The archive includes reconstruction files under `colmap_nonoverlap/sparse/`.
+
+The `scripts/` directory contains helpers for preparing frames from public source links and reproducing the panorama SfM directory layout.
+
+## Metadata Fields
+
+Each sequence is identified by the full path `<split>/<scene>/<clip_id>`. A small number of `clip_id` values appear in more than one scene or split, so the full path should be used as the unique key.
+
+Important fields include:
+
+- `source_video_id`: normalized source identifier.
+- `source_url`: public source URL for web videos; `null` for author-captured sequences.
+- `source_url_status`: `inferred_from_video_id` or `author_team_capture_not_publicly_linked`.
+- `start_sec`, `end_sec`, `duration`: temporal segment definition, where `duration = end_sec - start_sec`.
+- `scene`, `action`, `area`: benchmark labels.
+- `resolution`, `frame_rate`: source media properties.
+- `caption`: sequence-level caption.
+
+## Frame Preparation
+
+For public web videos, users can download the source video from `source_url` and extract the benchmark segment defined by `start_sec` and `end_sec`. Our preprocessing samples panoramic frames at 1 FPS, resizes them to `1920x960`, and stores them as:
+
+```text
+<data_root>/<split>/<scene>/<clip_id>/images/%04d.jpg
+```
+
+To prepare frames for all publicly linked sequences:
+
+```bash
+python scripts/prepare_frames_from_metadata.py \
+  --metadata metadata/train_test_split_with_links.json \
+  --output-root <data_root> \
+  --download-root <download_cache> \
+  --split all
+```
+
+Author-captured sequences with `source_url: null` are skipped by this script.
+
+## Panorama SfM
+
+The released SfM models were produced from the extracted panoramic frames using COLMAP's panorama pipeline with non-overlapping perspective rendering. To reproduce the same directory layout, set `PANO_SCRIPT` to COLMAP's `python/examples/panorama_sfm.py` and run:
+
+```bash
+DATA_ROOT=<data_root> \
+PANO_SCRIPT=<path_to_colmap>/python/examples/panorama_sfm.py \
+GPU_IDS="0" \
+bash scripts/run_panorama_sfm_from_frames.sh
+```
+
+This writes results under:
+
+```text
+<data_root>/<split>/<scene>/<clip_id>/colmap_nonoverlap/
+```
+
+Image names inside the COLMAP sparse models follow the rendered layout `colmap_nonoverlap/images/pano_camera*/%04d.jpg`. Public web videos may become unavailable or may be transcoded by hosting platforms over time, so exact frame-level reproduction is best-effort.
+
+## Responsible Use And Takedown
+
+OmniLife360 was constructed from publicly accessible 360-degree videos from the web, together with a small number of panoramic sequences captured by the author team. Candidate videos were manually reviewed and screened for privacy risks. Videos containing sensitive, private, harmful, inappropriate, or otherwise privacy-risky content were excluded. Author-captured sequences were reviewed under the same criteria before inclusion.
+
+We do not annotate personal identities, usernames, demographic attributes, or other personally identifiable information. The benchmark is intended for academic evaluation of 360-degree 3D reconstruction methods, not for identifying, analyzing, or profiling individuals.
+
+Please use the dataset responsibly and avoid privacy-invasive applications such as person re-identification, face recognition, biometric identification, surveillance, profiling, individual tracking, targeting individuals, or attempts to recover uploader/platform identities.
+
+For dataset questions or requests to remove links or associated metadata, contact:
+
+`zonglinzhao@hust.edu.cn`
+
+Please include, when available, your name, contact email, relationship to the content, relevant source URL or sequence ID, and the reason for the request.
+
+## Citation
+
+If you use OmniLife360, please cite:
+
+```bibtex
+@inproceedings{omnilife360_2026,
+  title     = {OmniLife360: A Benchmark for 3D Reconstruction from In-the-Wild 360-Degree Captures},
+  author    = {OmniLife360 Authors},
+  booktitle = {European Conference on Computer Vision (ECCV)},
+  year      = {2026}
+}
+```
+
+## License
+
+OmniLife360 is released under the Creative Commons Attribution-NonCommercial 4.0 International license (`CC BY-NC 4.0`).

scripts/prepare_frames_from_metadata.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""Download public source videos and extract OmniLife360 panoramic frames.
+
+The script reads metadata/train_test_split_with_links.json and writes frames to:
+
+    <output_root>/<split>/<scene>/<clip_id>/images/%04d.jpg
+
+Only entries with a non-null source_url are processed. Author-captured sequences
+are intentionally skipped because they are not publicly linked in this release.
+"""
+
+import argparse
+import json
+import re
+import subprocess
+from pathlib import Path
+from typing import Dict, Iterator, List, Optional, Tuple
+
+
+VIDEO_EXTENSIONS = {".mp4", ".mkv", ".webm", ".mov", ".m4v"}
+
+
+def iter_entries(metadata: Dict, split_filter: str) -> Iterator[Tuple[str, str, str, Dict]]:
+    for split, scenes in metadata.items():
+        if split_filter != "all" and split != split_filter:
+            continue
+        for scene, clips in scenes.items():
+            for clip_id, info in clips.items():
+                yield split, scene, clip_id, info
+
+
+def safe_stem(value: str) -> str:
+    return re.sub(r"[^A-Za-z0-9_.-]+", "_", value).strip("_") or "source_video"
+
+
+def find_downloaded_video(download_dir: Path, source_id: str) -> Optional[Path]:
+    stem = safe_stem(source_id)
+    candidates: List[Path] = []
+    for path in download_dir.glob(f"{stem}.*"):
+        if path.suffix.lower() in VIDEO_EXTENSIONS and path.is_file():
+            candidates.append(path)
+    if not candidates:
+        return None
+    candidates.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+    return candidates[0]
+
+
+def run(cmd: List[str], dry_run: bool) -> None:
+    print("+", " ".join(cmd))
+    if not dry_run:
+        subprocess.run(cmd, check=True)
+
+
+def download_video(
+    source_url: str,
+    source_id: str,
+    download_dir: Path,
+    ytdlp_format: str,
+    dry_run: bool,
+) -> Path:
+    existing = find_downloaded_video(download_dir, source_id)
+    if existing is not None:
+        return existing
+
+    download_dir.mkdir(parents=True, exist_ok=True)
+    out_template = str(download_dir / f"{safe_stem(source_id)}.%(ext)s")
+    cmd = [
+        "yt-dlp",
+        "-f",
+        ytdlp_format,
+        "--merge-output-format",
+        "mp4",
+        "-o",
+        out_template,
+        source_url,
+    ]
+    run(cmd, dry_run)
+
+    if dry_run:
+        return download_dir / f"{safe_stem(source_id)}.mp4"
+
+    downloaded = find_downloaded_video(download_dir, source_id)
+    if downloaded is None:
+        raise FileNotFoundError(f"yt-dlp finished but no video was found for {source_id}")
+    return downloaded
+
+
+def extract_frames(
+    video_path: Path,
+    out_dir: Path,
+    start_sec: float,
+    end_sec: float,
+    fps: float,
+    width: int,
+    height: int,
+    quality: int,
+    overwrite: bool,
+    dry_run: bool,
+) -> int:
+    image_dir = out_dir / "images"
+    existing = sorted(image_dir.glob("*.jpg")) if image_dir.is_dir() else []
+    if existing and not overwrite:
+        print(f"[skip] existing frames: {image_dir}")
+        return len(existing)
+
+    image_dir.mkdir(parents=True, exist_ok=True)
+    if overwrite:
+        for path in image_dir.glob("*.jpg"):
+            if not dry_run:
+                path.unlink()
+
+    cmd = [
+        "ffmpeg",
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-y",
+        "-nostdin",
+        "-i",
+        str(video_path),
+        "-ss",
+        f"{start_sec:.6f}",
+        "-to",
+        f"{end_sec:.6f}",
+        "-vf",
+        f"fps={fps},scale={width}:{height}:flags=lanczos",
+        "-q:v",
+        str(quality),
+        str(image_dir / "%04d.jpg"),
+    ]
+    run(cmd, dry_run)
+
+    if dry_run:
+        return 0
+    return len(list(image_dir.glob("*.jpg")))
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Prepare OmniLife360 panoramic frames from public source URLs."
+    )
+    parser.add_argument(
+        "--metadata",
+        default="metadata/train_test_split_with_links.json",
+        help="Path to train_test_split_with_links.json.",
+    )
+    parser.add_argument(
+        "--output-root",
+        required=True,
+        help="Directory where <split>/<scene>/<clip_id>/images will be written.",
+    )
+    parser.add_argument(
+        "--download-root",
+        required=True,
+        help="Directory where downloaded source videos will be cached.",
+    )
+    parser.add_argument("--split", choices=["train", "test", "all"], default="all")
+    parser.add_argument("--fps", type=float, default=1.0)
+    parser.add_argument("--width", type=int, default=1920)
+    parser.add_argument("--height", type=int, default=960)
+    parser.add_argument("--jpeg-quality", type=int, default=2)
+    parser.add_argument(
+        "--ytdlp-format",
+        default="bestvideo+bestaudio/best",
+        help="Format selector passed to yt-dlp.",
+    )
+    parser.add_argument("--overwrite", action="store_true")
+    parser.add_argument("--max-items", type=int, default=0)
+    parser.add_argument("--dry-run", action="store_true")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    metadata = json.loads(Path(args.metadata).read_text(encoding="utf-8"))
+    output_root = Path(args.output_root)
+    download_root = Path(args.download_root)
+
+    processed = 0
+    skipped = 0
+    failed = 0
+
+    for split, scene, clip_id, info in iter_entries(metadata, args.split):
+        source_url = info.get("source_url")
+        if not source_url:
+            skipped += 1
+            continue
+
+        if args.max_items and processed >= args.max_items:
+            break
+
+        source_id = info.get("source_video_id") or info.get("video_id") or clip_id
+        start_sec = float(info.get("start_sec", 0.0))
+        end_sec = float(info.get("end_sec", 0.0))
+        if end_sec <= start_sec:
+            print(f"[skip] invalid time window: {split}/{scene}/{clip_id}")
+            skipped += 1
+            continue
+
+        out_dir = output_root / split / scene / clip_id
+        try:
+            video_path = download_video(
+                source_url=source_url,
+                source_id=source_id,
+                download_dir=download_root,
+                ytdlp_format=args.ytdlp_format,
+                dry_run=args.dry_run,
+            )
+            n = extract_frames(
+                video_path=video_path,
+                out_dir=out_dir,
+                start_sec=start_sec,
+                end_sec=end_sec,
+                fps=args.fps,
+                width=args.width,
+                height=args.height,
+                quality=args.jpeg_quality,
+                overwrite=args.overwrite,
+                dry_run=args.dry_run,
+            )
+            print(f"[ok] {split}/{scene}/{clip_id} frames={n}")
+            processed += 1
+        except Exception as exc:
+            print(f"[fail] {split}/{scene}/{clip_id}: {exc}")
+            failed += 1
+
+    print(f"done: processed={processed} skipped={skipped} failed={failed}")
+    if failed:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

scripts/run_panorama_sfm_from_frames.sh

@@ -0,0 +1,157 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Run COLMAP's panorama_sfm.py on frames prepared as:
+#   DATA_ROOT/<split>/<scene>/<clip_id>/images/%04d.jpg
+#
+# Required:
+#   DATA_ROOT    Root containing train/test scene folders.
+#   PANO_SCRIPT  Path to COLMAP's python/examples/panorama_sfm.py.
+#
+# Optional:
+#   OUT_ROOT            Output root. Defaults to DATA_ROOT.
+#   GPU_IDS             Space-separated GPU ids. Defaults to "0".
+#   MATCHER             COLMAP matcher. Defaults to "sequential".
+#   PANO_RENDER_TYPE    Defaults to "non-overlapping".
+#   SPLIT_FILTER        train | test | all. Defaults to all.
+#   MIN_IMAGES          Minimum panoramic frames per sequence. Defaults to 2.
+
+DATA_ROOT="${DATA_ROOT:-}"
+OUT_ROOT="${OUT_ROOT:-$DATA_ROOT}"
+PANO_SCRIPT="${PANO_SCRIPT:-}"
+GPU_IDS="${GPU_IDS:-0}"
+MATCHER="${MATCHER:-sequential}"
+PANO_RENDER_TYPE="${PANO_RENDER_TYPE:-non-overlapping}"
+SPLIT_FILTER="${SPLIT_FILTER:-all}"
+MIN_IMAGES="${MIN_IMAGES:-2}"
+MASTER_LOG="$OUT_ROOT/panorama_sfm.log"
+
+if [[ -z "$DATA_ROOT" ]]; then
+  echo "[ERROR] DATA_ROOT is required"
+  exit 1
+fi
+
+if [[ -z "$PANO_SCRIPT" || ! -f "$PANO_SCRIPT" ]]; then
+  echo "[ERROR] PANO_SCRIPT must point to COLMAP's panorama_sfm.py"
+  exit 1
+fi
+
+if [[ "$SPLIT_FILTER" != "train" && "$SPLIT_FILTER" != "test" && "$SPLIT_FILTER" != "all" ]]; then
+  echo "[ERROR] SPLIT_FILTER must be train, test, or all"
+  exit 1
+fi
+
+mkdir -p "$OUT_ROOT"
+IFS=' ' read -r -a GPU_ID_LIST <<< "$GPU_IDS"
+declare -A GPU_PIDS
+
+has_complete_sparse() {
+  local out_dir="$1"
+  [[ -f "$out_dir/sparse/0/cameras.bin" && -f "$out_dir/sparse/0/images.bin" && -f "$out_dir/sparse/0/points3D.bin" ]]
+}
+
+wait_for_free_gpu() {
+  while true; do
+    for gpu in "${GPU_ID_LIST[@]}"; do
+      local pid="${GPU_PIDS[$gpu]-}"
+      if [[ -z "$pid" ]] || ! kill -0 "$pid" 2>/dev/null; then
+        GPU_PIDS[$gpu]=""
+        echo "$gpu"
+        return 0
+      fi
+    done
+    sleep 3
+  done
+}
+
+start_colmap_job() {
+  local gpu="$1"
+  local img_dir="$2"
+  local out_dir="$3"
+  local desc="$4"
+
+  mkdir -p "$out_dir"
+  echo "[INFO] COLMAP start GPU=$gpu $desc" | tee -a "$MASTER_LOG"
+  (
+    set +e
+    export CUDA_VISIBLE_DEVICES="$gpu"
+    python "$PANO_SCRIPT" \
+      --input_image_path "$img_dir" \
+      --output_path "$out_dir" \
+      --matcher "$MATCHER" \
+      --pano_render_type "$PANO_RENDER_TYPE" \
+      > "$out_dir/run.log" 2>&1
+    status=$?
+    if [[ "$status" -ne 0 ]]; then
+      echo "[WARN] COLMAP failed status=$status $out_dir" >> "$MASTER_LOG"
+    else
+      echo "[INFO] COLMAP done $out_dir" >> "$MASTER_LOG"
+    fi
+  ) &
+  GPU_PIDS["$gpu"]=$!
+}
+
+LIST_TSV="$OUT_ROOT/panorama_sfm_list.tsv"
+
+python - <<'PY' "$DATA_ROOT" "$LIST_TSV" "$SPLIT_FILTER"
+import os
+import sys
+
+data_root, out_path, split_filter = sys.argv[1:4]
+splits = ("train", "test") if split_filter == "all" else (split_filter,)
+rows = []
+
+for split in splits:
+    split_dir = os.path.join(data_root, split)
+    if not os.path.isdir(split_dir):
+        continue
+    for scene in sorted(os.listdir(split_dir)):
+        scene_dir = os.path.join(split_dir, scene)
+        if not os.path.isdir(scene_dir):
+            continue
+        for clip_id in sorted(os.listdir(scene_dir)):
+            clip_dir = os.path.join(scene_dir, clip_id)
+            img_dir = os.path.join(clip_dir, "images")
+            if os.path.isdir(img_dir):
+                rows.append((split, scene, clip_id, img_dir))
+
+os.makedirs(os.path.dirname(out_path), exist_ok=True)
+with open(out_path, "w", encoding="utf-8") as f:
+    for row in rows:
+        f.write("\t".join(row) + "\n")
+PY
+
+echo "[INFO] DATA_ROOT=$DATA_ROOT" | tee -a "$MASTER_LOG"
+echo "[INFO] OUT_ROOT=$OUT_ROOT" | tee -a "$MASTER_LOG"
+echo "[INFO] PANO_SCRIPT=$PANO_SCRIPT" | tee -a "$MASTER_LOG"
+echo "[INFO] GPU_IDS=$GPU_IDS MATCHER=$MATCHER PANO_RENDER_TYPE=$PANO_RENDER_TYPE SPLIT_FILTER=$SPLIT_FILTER" | tee -a "$MASTER_LOG"
+
+exec 3< "$LIST_TSV"
+while IFS=$'\t' read -r split scene clip_id img_dir <&3; do
+  [[ -z "$split" ]] && continue
+
+  img_count=$(find "$img_dir" -maxdepth 1 -type f \( -iname '*.jpg' -o -iname '*.jpeg' -o -iname '*.png' \) | wc -l | tr -d ' ')
+  if [[ "$img_count" -lt "$MIN_IMAGES" ]]; then
+    echo "[WARN] too few images count=$img_count $img_dir" | tee -a "$MASTER_LOG"
+    continue
+  fi
+
+  out_dir="$OUT_ROOT/$split/$scene/$clip_id/colmap_nonoverlap"
+  if has_complete_sparse "$out_dir"; then
+    echo "[INFO] skip existing $out_dir" | tee -a "$MASTER_LOG"
+    continue
+  fi
+
+  gpu=$(wait_for_free_gpu)
+  start_colmap_job "$gpu" "$img_dir" "$out_dir" "$split/$scene/$clip_id images=$img_count"
+done
+exec 3<&-
+
+for gpu in "${GPU_ID_LIST[@]}"; do
+  pid="${GPU_PIDS[$gpu]-}"
+  if [[ -n "$pid" ]]; then
+    wait "$pid" || true
+  fi
+done
+
+echo "[INFO] done $(date '+%F %T')" | tee -a "$MASTER_LOG"

sfm/omnilife360_colmap_sfm_results.tar.zst

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