| |
| """Per-video metadata for stratified / per-video evaluation (library + report). |
| |
| Joins the three per-video sources into one table keyed by video_id |
| (RipBench-NNN / RipBench-NR-NNN) and exposes image_basename -> video_id: |
| * NeurIPS_2026/video_metadata.csv class, split (s1.3), n_frames_sampled, |
| source_provenance, license (filled by |
| eval/dataset_accounting.py) |
| * NeurIPS_2026/RipBench_video_annotation_data.csv viewpoint, primary visual signature, |
| camera motion (expert-recorded) |
| * Videos/RipBench_video_metadata.csv native width/height/fps/frame_count |
| (ffprobe export of the source videos) |
| Resolution buckets follow the posted stratified analysis: <720p / 720p / 1080p / >=1440p |
| on the SHORT side of the native frame (portrait videos bucket by their width). |
| |
| Running the module prints the stratum sizes per split (sanity check). |
| """ |
| import csv |
| import os |
| import re |
|
|
| REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) |
| VIDEO_META_CSV = os.path.join(REPO_ROOT, "NeurIPS_2026", "video_metadata.csv") |
| ANNOTATION_CSV = os.path.join(REPO_ROOT, "NeurIPS_2026", "RipBench_video_annotation_data.csv") |
| TECH_CSV = os.path.join(REPO_ROOT, "NeurIPS_2026", "RipBench_video_technical_metadata.csv") |
|
|
| VIEWPOINTS = ("aerial_bird's eye", "aerial_tilted", "elevated_beachfront", "water_level_beachfront") |
| VIEWPOINT_LABEL = {"aerial_bird's eye": "Bird's eye", "aerial_tilted": "Aerial tilted", |
| "elevated_beachfront": "Elevated", "water_level_beachfront": "Water-level"} |
| SIGNATURES = ("dark_gap", "breaking_wave_gap", "sediment_plume", "foam_plume", |
| "turbulent_band", "boundary_associated", "none") |
| RES_BUCKETS = ("<720p", "720p", "1080p", ">=1440p") |
|
|
| VIDEO_RE = re.compile(r"^(RipBench-(?:NR-)?\d+)_\d+\.\w+$") |
|
|
|
|
| def video_id_of(image_name): |
| """'RipBench-012_00345.jpg' -> 'RipBench-012' (basename or path accepted).""" |
| m = VIDEO_RE.match(os.path.basename(image_name)) |
| return m.group(1) if m else None |
|
|
|
|
| def res_bucket(width, height): |
| short = min(int(width), int(height)) |
| if short < 720: |
| return "<720p" |
| if short < 1080: |
| return "720p" |
| if short < 1440: |
| return "1080p" |
| return ">=1440p" |
|
|
|
|
| def load(): |
| """{video_id: dict} with keys class, split, n_frames_sampled, source_provenance, |
| license, viewpoint, signature, camera_motion, width, height, fps, frame_count, |
| duration_s, res_bucket.""" |
| meta = {} |
| with open(VIDEO_META_CSV) as f: |
| for r in csv.DictReader(f): |
| meta[r["video_id"]] = { |
| "class": r["class"], "split": r["split"], |
| "n_frames_sampled": int(r["n_frames_sampled"]), |
| "source_provenance": r.get("source_provenance", ""), |
| "license": r.get("license", ""), "notes": r.get("notes", ""), |
| } |
| with open(ANNOTATION_CSV) as f: |
| for r in csv.DictReader(f): |
| v = r["Rip name"] |
| if v not in meta: |
| continue |
| meta[v].update({ |
| "viewpoint": r["Viewpoint"].strip(), |
| "signature": r["Visual signature (primary)"].strip(), |
| "camera_motion": r["Camera motion type"].strip(), |
| "rip_present": r["Rip present"].strip() == "yes", |
| }) |
| with open(TECH_CSV) as f: |
| for r in csv.DictReader(f): |
| m = re.match(r"^(RipBench-(?:NR-)?\d{3})", r["file_name"]) |
| v = m.group(1) if m else None |
| if v not in meta: |
| continue |
| w, h = int(r["width"]), int(r["height"]) |
| meta[v].update({"width": w, "height": h, "fps": float(r["fps"]), |
| "frame_count": int(r["frame_count"]), |
| "duration_s": float(r["duration_seconds"]), |
| "res_bucket": res_bucket(w, h)}) |
| missing = [v for v, d in meta.items() if "viewpoint" not in d or "width" not in d] |
| assert not missing, f"metadata join incomplete for {missing[:5]}" |
| return meta |
|
|
|
|
| def videos_in(meta, split, rip_only=False): |
| return sorted(v for v, d in meta.items() |
| if d["split"] == split and (not rip_only or d["class"] == "rips")) |
|
|
|
|
| def main(): |
| meta = load() |
| print(f"{len(meta)} videos") |
| for split in ("train", "val", "test"): |
| vids = videos_in(meta, split) |
| print(f"\n[{split}] {len(vids)} videos " |
| f"({sum(meta[v]['class'] == 'rips' for v in vids)} rip)") |
| for key, order in (("viewpoint", VIEWPOINTS), ("signature", SIGNATURES), |
| ("res_bucket", RES_BUCKETS)): |
| counts = {k: [0, 0] for k in order} |
| for v in vids: |
| k = meta[v][key] |
| counts.setdefault(k, [0, 0])[0 if meta[v]["class"] == "rips" else 1] += 1 |
| print(f" {key:11s}: " + ", ".join(f"{k} {a}/{b}" for k, (a, b) in counts.items() |
| if a + b)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
