Added OF-ITW download logic

README.md

@@ -75,6 +75,8 @@ The repository is organized as follows:
 - `videos/metadata.csv` - OF-Syn video-level metadata (12,000 videos)
 - `data_files/omnifall-synthetic_av1.tar` - OF-Syn video archive (12,000 AV1-encoded MP4s)
 - `data_files/syn_frame_wise_labels.tar.zst` - OF-Syn frame-wise HDF5 labels
+- `data_files/oops_video_mapping.csv` - Mapping from OOPS original filenames to OF-ItW sanitized names
+- `prepare_oops_videos.py` - Script to extract OOPS videos for OF-ItW (streams from source, no 45GB download needed)
 
 ### Label Format
 
@@ -142,6 +144,8 @@ All configurations are defined in the `omnifall.py` dataset builder and loaded v
 ### OF-ItW Config
 - `of-itw`: OOPS-Fall in-the-wild genuine accidents
 
+OF-ItW supports optional video loading via `include_video=True` with `oops_video_dir` (see examples below). Videos are not hosted here due to licensing; run `prepare_oops_videos.py` to download them from the [original OOPS source](https://oops.cs.columbia.edu/data/).
+
 ### OF-Syn Configs
 - `of-syn`: Fixed randomized 80/10/10 split
 - `of-syn-cross-age`: Cross-age split (train: adults, test: children/elderly)
@@ -208,7 +212,7 @@ syn_labels = load_dataset("simplexsigil2/omnifall", "labels-syn")["train"]
 
 ### Loading OF-Syn videos
 
-OF-Syn configs support `include_video=True` to download and include the video files (~9 GB).
+OF-Syn configs support `include_video=True` to download and include the video files (~9 GB download and disk space).
 By default, videos are returned as decoded `Video()` objects. Set `decode_video=False` to get file paths instead.
 
 ```python
@@ -226,13 +230,38 @@ ds = load_dataset("simplexsigil2/omnifall", "of-syn",
 sample = ds["train"][0]
 print(sample["video"])  # "/path/to/cached/fall/fall_ch_001.mp4"
 
-# Cross-domain with video: train/val have videos, test (itw) has None
+# Cross-domain with video: train/val (syn) and test (itw) both have videos
 ds = load_dataset("simplexsigil2/omnifall", "of-syn-itw",
-                  include_video=True, decode_video=False, trust_remote_code=True)
-print(ds["train"][0]["video"])  # path to video
-print(ds["test"][0]["video"])   # None (OOPS videos not hosted)
+                  include_video=True, decode_video=False,
+                  oops_video_dir="/path/to/oops_prepared",
+                  trust_remote_code=True)
+print(ds["train"][0]["video"])  # syn video path (auto-downloaded)
+print(ds["test"][0]["video"])   # itw video path (from oops_video_dir)
 ```
 
+### Loading OF-ItW (OOPS) videos
+
+OOPS videos are not hosted in this repository due to licensing. To load OF-ItW with videos, first prepare the OOPS videos using the included script:
+
+```bash
+# Step 1: Prepare OOPS videos (~45GB streamed from source, ~2.6GB disk space)
+python prepare_oops_videos.py --output_dir /path/to/oops_prepared
+```
+
+```python
+# Step 2: Load OF-ItW with videos
+from datasets import load_dataset
+
+ds = load_dataset("simplexsigil2/omnifall", "of-itw",
+                  include_video=True, decode_video=False,
+                  oops_video_dir="/path/to/oops_prepared",
+                  trust_remote_code=True)
+sample = ds["train"][0]
+print(sample["video"])  # "/path/to/oops_prepared/falls/BestFailsofWeek2July2016_FailArmy9.mp4"
+```
+
+The preparation script streams the full [OOPS dataset](https://oops.cs.columbia.edu/data/) archive (~45GB download) from the original source and extracts only the 818 videos used in OF-ItW. The archive is streamed and never written to disk, so only ~2.6GB of disk space is needed for the extracted videos. If you already have the OOPS archive downloaded locally, pass it with `--oops_archive /path/to/video_and_anns.tar.gz`.
+
 ## Label definitions
 
 In this section we provide additional information about the labelling process to provide as much transparency as possible.

omnifall.py

@@ -9,6 +9,7 @@ All components share a 16-class activity taxonomy. Staged datasets use classes 0
 while OF-ItW and OF-Syn use the full 0-15 range.
 """
 
+import os
 import warnings
 import pandas as pd
 import datasets
@@ -211,9 +212,14 @@ class OmniFallConfig(BuilderConfig):
         test_split_type: For cross-domain configs, overrides split_type for test.
         paths_only: If True, only return video paths (no label merging).
         framewise: If True, load frame-wise labels from HDF5 (OF-Syn only).
-        include_video: If True, download and include video files (OF-Syn only).
+        include_video: If True, download and include video files.
+            For OF-Syn configs, videos are downloaded from the HF repo.
+            For OF-ItW configs, requires oops_video_dir to be set.
         decode_video: If True (default), use Video() feature for auto-decoding.
             If False, return absolute file path as string.
+        oops_video_dir: Path to directory containing prepared OOPS videos
+            (produced by prepare_oops_videos.py). Required when loading
+            OF-ItW configs with include_video=True.
         deprecated_alias_for: If set, this config is a deprecated alias.
     """
 
@@ -229,6 +235,7 @@ class OmniFallConfig(BuilderConfig):
         framewise=False,
         include_video=False,
         decode_video=True,
+        oops_video_dir=None,
         deprecated_alias_for=None,
         **kwargs,
     ):
@@ -243,6 +250,7 @@ class OmniFallConfig(BuilderConfig):
         self.framewise = framewise
         self.include_video = include_video
         self.decode_video = decode_video
+        self.oops_video_dir = oops_video_dir
         self.deprecated_alias_for = deprecated_alias_for
 
     @property
@@ -439,6 +447,7 @@ for _old_name, _new_name in _DEPRECATED_ALIASES.items():
             framewise=_target.framewise,
             include_video=_target.include_video,
             decode_video=_target.decode_video,
+            oops_video_dir=_target.oops_video_dir,
             deprecated_alias_for=_new_name,
         )
     )
@@ -587,6 +596,25 @@ class OmniFall(GeneratorBasedBuilder):
         """Return list of split CSV paths for all 8 staged datasets."""
         return [f"splits/{split_type}/{ds}/{split_name}.csv" for ds in _STAGED_DATASETS]
 
+    def _resolve_oops_video_dir(self, cfg):
+        """Resolve the OOPS video directory for OF-ItW configs."""
+        if not cfg.include_video:
+            return None
+        if not cfg.oops_video_dir:
+            raise ValueError(
+                "OF-ItW video loading requires oops_video_dir. "
+                "Run prepare_oops_videos.py first, then pass the output path:\n"
+                "  load_dataset(..., include_video=True, "
+                'oops_video_dir="/path/to/oops_prepared")'
+            )
+        video_dir = os.path.abspath(cfg.oops_video_dir)
+        if not os.path.isdir(video_dir):
+            raise FileNotFoundError(
+                f"oops_video_dir does not exist: {video_dir}\n"
+                "Run prepare_oops_videos.py to prepare OOPS videos first."
+            )
+        return video_dir
+
     def _make_split_merge_generators(self, split_files_per_split, label_files,
                                      dl_manager, video_dir=None):
         """Helper to create train/val/test SplitGenerators for split_merge mode.
@@ -627,10 +655,12 @@ class OmniFall(GeneratorBasedBuilder):
     def _itw_splits(self, cfg, dl_manager):
         """OF-ItW: OOPS-Fall (CS=CV identical)."""
         st = cfg.split_type
+        video_dir = self._resolve_oops_video_dir(cfg)
         return self._make_split_merge_generators(
             {sn: [f"splits/{st}/OOPS/{sn}.csv"] for sn in ("train", "val", "test")},
             [_ITW_LABEL_FILE],
             dl_manager,
+            video_dir=video_dir,
         )
 
     def _aggregate_splits(self, cfg, dl_manager):
@@ -731,10 +761,14 @@ class OmniFall(GeneratorBasedBuilder):
         train_st = cfg.split_type
         test_st = cfg.test_split_type or "cs"
 
-        # Download video archive if requested and train source is syn
-        video_dir = None
+        # Resolve video directories for each source
+        train_video_dir = None
         if cfg.include_video and cfg.train_source == "syn":
-            video_dir = dl_manager.download_and_extract(_SYN_VIDEO_ARCHIVE)
+            train_video_dir = dl_manager.download_and_extract(_SYN_VIDEO_ARCHIVE)
+
+        test_video_dir = None
+        if cfg.include_video and cfg.test_source == "itw":
+            test_video_dir = self._resolve_oops_video_dir(cfg)
 
         # Determine train/val files and labels
         if cfg.train_source == "staged":
@@ -771,7 +805,7 @@ class OmniFall(GeneratorBasedBuilder):
                     "mode": "split_merge",
                     "split_files": dl_manager.download(train_split_files["train"]),
                     "label_files": resolved_train_labels,
-                    "video_dir": video_dir,
+                    "video_dir": train_video_dir,
                 },
             ),
             SplitGenerator(
@@ -780,7 +814,7 @@ class OmniFall(GeneratorBasedBuilder):
                     "mode": "split_merge",
                     "split_files": dl_manager.download(train_split_files["val"]),
                     "label_files": resolved_train_labels,
-                    "video_dir": video_dir,
+                    "video_dir": train_video_dir,
                 },
             ),
             SplitGenerator(
@@ -789,7 +823,7 @@ class OmniFall(GeneratorBasedBuilder):
                     "mode": "split_merge",
                     "split_files": resolved_test_splits,
                     "label_files": resolved_test_labels,
-                    "video_dir": None,  # test source (itw) has no hosted videos
+                    "video_dir": test_video_dir,
                 },
             ),
         ]
@@ -828,8 +862,6 @@ class OmniFall(GeneratorBasedBuilder):
 
     def _gen_split_merge(self, split_files, label_files, video_dir=None):
         """Load split paths, merge with labels, yield examples."""
-        import os
-
         split_dfs = [pd.read_csv(sf) for sf in split_files]
         split_df = pd.concat(split_dfs, ignore_index=True)
 

prepare_oops_videos.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""Prepare OOPS videos for OF-ItW (OmniFall In-the-Wild).
+
+Streams the OOPS dataset archive and extracts only the 818 videos used in
+OF-ItW, renamed to match the OF-ItW path convention. By default, the archive
+is streamed directly from the OOPS website (~45GB) without writing it to disk.
+Only the output videos (~2.6GB) are saved.
+
+Usage:
+    # Stream from the web (no local archive needed):
+    python prepare_oops_videos.py --output_dir /path/to/oops_prepared
+
+    # Use an already-downloaded archive:
+    python prepare_oops_videos.py --output_dir /path/to/oops_prepared \
+        --oops_archive /path/to/video_and_anns.tar.gz
+
+    # Then load with the dataset builder:
+    ds = load_dataset("simplexsigil2/omnifall", "of-itw",
+                      include_video=True,
+                      oops_video_dir="/path/to/oops_prepared",
+                      trust_remote_code=True)
+"""
+
+import argparse
+import csv
+import os
+import subprocess
+import tarfile
+
+OOPS_URL = "https://oops.cs.columbia.edu/data/video_and_anns.tar.gz"
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+MAPPING_FILE = os.path.join(SCRIPT_DIR, "data_files", "oops_video_mapping.csv")
+
+
+def load_mapping():
+    """Load the OOPS-to-ITW filename mapping from the repo."""
+    if not os.path.exists(MAPPING_FILE):
+        raise FileNotFoundError(
+            f"Mapping file not found: {MAPPING_FILE}\n"
+            "Make sure you run this script from the OmniFall dataset directory."
+        )
+    mapping = {}
+    with open(MAPPING_FILE) as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            mapping[row["oops_path"]] = row["itw_path"]
+    return mapping
+
+
+def _to_stdout_cmd(source, member):
+    """Build command to extract a single tar member to stdout."""
+    if source.startswith("http://") or source.startswith("https://"):
+        return f'curl -sL "{source}" | tar -xzf - --to-stdout "{member}"', True
+    elif source.endswith(".tar.gz") or source.endswith(".tgz"):
+        return ["tar", "-xzf", source, "--to-stdout", member], False
+    else:
+        return ["tar", "-xf", source, "--to-stdout", member], False
+
+
+def extract_videos(source, mapping, output_dir):
+    """Stream through the OOPS archive and extract matching videos.
+
+    The archive has a nested structure: the outer tar contains
+    oops_dataset/video.tar.gz, which contains the actual video files.
+    We pipe the inner tar.gz to stdout and selectively extract only
+    the 818 videos in our mapping.
+    """
+    total = len(mapping)
+    print(f"Extracting {total} videos from OOPS archive...")
+    if source.startswith("http"):
+        print("(Streaming ~45GB from web, no local disk space needed)")
+        print("(This may take 30-60 minutes depending on connection speed)")
+    else:
+        print("(Reading from local archive)")
+
+    os.makedirs(os.path.join(output_dir, "falls"), exist_ok=True)
+
+    found = 0
+    remaining = set(mapping.keys())
+
+    cmd, use_shell = _to_stdout_cmd(source, "oops_dataset/video.tar.gz")
+    proc = subprocess.Popen(
+        cmd, shell=use_shell, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+    )
+
+    try:
+        with tarfile.open(fileobj=proc.stdout, mode="r|gz") as tar:
+            for member in tar:
+                if not remaining:
+                    break
+                if member.name in remaining:
+                    itw_path = mapping[member.name]
+                    out_path = os.path.join(output_dir, itw_path)
+
+                    f = tar.extractfile(member)
+                    if f is not None:
+                        with open(out_path, "wb") as out_f:
+                            while True:
+                                chunk = f.read(1024 * 1024)
+                                if not chunk:
+                                    break
+                                out_f.write(chunk)
+                        f.close()
+                        found += 1
+                        remaining.discard(member.name)
+                        if found % 50 == 0:
+                            print(f"  Extracted {found}/{total} videos...")
+    finally:
+        proc.stdout.close()
+        proc.wait()
+
+    print(f"Extracted {found}/{total} videos.")
+    if remaining:
+        print(f"WARNING: {len(remaining)} videos not found in archive:")
+        for p in sorted(remaining)[:10]:
+            print(f"  {p}")
+        if len(remaining) > 10:
+            print(f"  ... and {len(remaining) - 10} more")
+    return found
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Prepare OOPS videos for OF-ItW.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+    parser.add_argument(
+        "--output_dir", required=True,
+        help="Directory to place the prepared videos (will contain falls/*.mp4).",
+    )
+    parser.add_argument(
+        "--oops_archive", default=None,
+        help="Path to already-downloaded video_and_anns.tar.gz (or .tar). "
+             "If not provided, streams directly from the OOPS website.",
+    )
+    args = parser.parse_args()
+
+    output_dir = os.path.abspath(args.output_dir)
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Load the pre-computed mapping from the repo
+    print("Loading OOPS-to-ITW video mapping...")
+    mapping = load_mapping()
+    print(f"  {len(mapping)} videos to extract.")
+
+    # Determine source
+    if args.oops_archive:
+        source = os.path.abspath(args.oops_archive)
+        if not os.path.exists(source):
+            raise FileNotFoundError(f"Archive not found: {source}")
+        print(f"Source: {source}")
+    else:
+        source = OOPS_URL
+        print(f"Source: {source}")
+
+    # Single streaming pass
+    found = extract_videos(source, mapping, output_dir)
+
+    # Summary
+    print()
+    print("=" * 60)
+    print("Preparation complete!")
+    print(f"  Output directory: {output_dir}")
+    print(f"  Videos extracted: {found}/{len(mapping)}")
+    print()
+    print("To load OF-ItW with videos:")
+    print()
+    print("  from datasets import load_dataset")
+    print(f'  ds = load_dataset("simplexsigil2/omnifall", "of-itw",')
+    print(f'                    include_video=True,')
+    print(f'                    oops_video_dir="{output_dir}",')
+    print(f'                    trust_remote_code=True)')
+
+
+if __name__ == "__main__":
+    main()