#!/usr/bin/env python3 """Sample synchronized RGB/IR frame pairs. Each RGB frame is paired with the IR frame nearest to ``rgb_time + ir_offset``. Matches farther than ``--max-gap`` seconds are omitted. Usage: python scripts/sample_dataset.py \ --out-root ./Data --start 300 --step 300 """ import argparse import csv import logging import math import os import sys import tempfile from pathlib import Path import cv2 FIELDS = [ "pair_id", "unit", "rgb_video", "ir_video", "ir_offset", "sample_index", "rgb_frame", "rgb_time_s", "ir_frame", "ir_time_s", "t_ir_target_s", "nearest_gap_s", "rgb_path", "ir_path", "ir_ok", ] log = logging.getLogger("sample_dataset") def open_video(path, kind): cap = cv2.VideoCapture(str(path)) if not cap.isOpened(): raise RuntimeError(f"cannot open {kind} video: {path}") return cap def write_png(path, frame): if not cv2.imwrite(str(path), frame): raise RuntimeError(f"cannot write PNG: {path}") def read_ir(cap, path, index, expected, previous_time=None): ok, frame = cap.read() if not ok: if expected > 0 and index < expected: raise RuntimeError(f"IR decode ended at frame {index}: {path}") return None if expected > 0 and index >= expected: raise RuntimeError(f"IR decoded more than {expected} reported frames: {path}") timestamp = cap.get(cv2.CAP_PROP_POS_MSEC) / 1000.0 if not math.isfinite(timestamp): raise RuntimeError(f"non-finite IR timestamp at frame {index}: {path}") if previous_time is not None and timestamp <= previous_time: raise RuntimeError(f"unordered IR timestamp at frame {index}: {path}") return index, frame, timestamp def sample_pair(pair, output, unit_dirs, start, step, max_gap): pair_id, unit = pair["pair_id"], pair["unit"] rgb_path = unit_dirs[unit] / pair["rgb_video"] ir_path = unit_dirs[unit] / pair["ir_video"] rgb_dir, ir_dir = output / "rgb", output / "ir" rgb_dir.mkdir(parents=True) ir_dir.mkdir() rows = [] rgb = open_video(rgb_path, "RGB") try: ir = open_video(ir_path, "IR") try: frame_count = int(rgb.get(cv2.CAP_PROP_FRAME_COUNT)) ir_count = int(ir.get(cv2.CAP_PROP_FRAME_COUNT)) next_ir_index = 0 current = read_ir(ir, ir_path, next_ir_index, ir_count) if current is None: raise RuntimeError(f"IR video decoded no frames: {ir_path}") next_ir_index += 1 previous = None previous_target = None for index in range(start, frame_count, step): if not rgb.set(cv2.CAP_PROP_POS_FRAMES, index): raise RuntimeError(f"cannot seek {rgb_path} to frame {index}") ok, rgb_frame = rgb.read() if not ok: raise RuntimeError(f"cannot read {rgb_path} at frame {index}") rgb_time = rgb.get(cv2.CAP_PROP_POS_MSEC) / 1000.0 if not math.isfinite(rgb_time): raise RuntimeError(f"non-finite RGB timestamp: {rgb_path}, frame {index}") target = rgb_time + pair["ir_offset"] if previous_target is not None and target < previous_target: raise RuntimeError(f"RGB timestamps moved backwards: {rgb_path}") previous_target = target while current is not None and current[2] <= target: previous = current current = read_ir( ir, ir_path, next_ir_index, ir_count, previous[2] ) next_ir_index += 1 if previous is None: continue if current is None: if target > previous[2]: break nearest = previous else: nearest = ( current if current[2] - target < target - previous[2] else previous ) ir_index, ir_frame, ir_time = nearest gap = abs(target - ir_time) if gap > max_gap: continue name = f"f{index:05d}.png" write_png(rgb_dir / name, rgb_frame) write_png(ir_dir / name, ir_frame) rows.append({ "pair_id": pair_id, "unit": unit, "rgb_video": pair["rgb_video"], "ir_video": pair["ir_video"], "ir_offset": pair["ir_offset"], "sample_index": index, "rgb_frame": index, "rgb_time_s": round(rgb_time, 4), "ir_frame": ir_index, "ir_time_s": round(ir_time, 4), "t_ir_target_s": round(target, 4), "nearest_gap_s": round(gap, 4), "rgb_path": (Path(unit) / pair_id / "rgb" / name).as_posix(), "ir_path": (Path(unit) / pair_id / "ir" / name).as_posix(), "ir_ok": True, }) finally: ir.release() finally: rgb.release() log.info("%s: sampled %d frame pairs", pair_id, len(rows)) return rows def load_pairs(sync_csv, unit_dirs): with sync_csv.open(newline="") as file: reader = csv.DictReader(file) required = {"pair_id", "unit", "rgb_video", "ir_video", "ir_offset"} if not reader.fieldnames or not required.issubset(reader.fieldnames): raise RuntimeError(f"invalid sync.csv header: {sync_csv}") source = list(reader) pairs, seen = [], set() for row in source: pair = {key: (row[key] or "").strip() for key in required - {"ir_offset"}} pair_id = pair["pair_id"] if not pair_id or Path(pair_id).name != pair_id: raise RuntimeError(f"unsafe pair_id: {pair_id!r}") if pair_id in seen: raise RuntimeError(f"duplicate pair_id: {pair_id}") if pair["unit"] not in unit_dirs: raise RuntimeError(f"unknown unit for {pair_id}: {pair['unit']!r}") offset = row["ir_offset"].strip() if offset.upper() == "N/A": log.info("%s: skipped because IR offset is N/A", pair_id) continue try: pair["ir_offset"] = float(offset) except ValueError as error: raise RuntimeError(f"invalid IR offset for {pair_id}") from error if not math.isfinite(pair["ir_offset"]): raise RuntimeError(f"non-finite IR offset for {pair_id}") for key in ("rgb_video", "ir_video"): path = unit_dirs[pair["unit"]] / pair[key] if not path.is_file(): raise RuntimeError(f"missing input for {pair_id}: {path}") seen.add(pair_id) pairs.append(pair) return pairs def write_manifest(path, rows): with path.open("w", newline="") as file: writer = csv.DictWriter(file, fieldnames=FIELDS) writer.writeheader() writer.writerows(rows) file.flush() os.fsync(file.fileno()) def commit(stage, pairs, out_root): """Install staged RGB/IR directories, rolling them back if commit fails.""" installed = [] out_root.mkdir(parents=True, exist_ok=True) try: for pair in pairs: relative = Path(pair["unit"]) / pair["pair_id"] for kind in ("rgb", "ir"): source = stage / "new" / relative / kind target = out_root / relative / kind backup = stage / "old" / relative / kind target.parent.mkdir(parents=True, exist_ok=True) backup.parent.mkdir(parents=True, exist_ok=True) had_old = target.exists() if had_old: if target.is_symlink() or not target.is_dir(): raise RuntimeError(f"unexpected output path: {target}") target.rename(backup) try: source.rename(target) except Exception: if had_old: backup.rename(target) raise installed.append((source, target, backup, had_old)) os.replace(stage / "samples.csv", out_root / "samples.csv") except Exception: for source, target, backup, had_old in reversed(installed): source.parent.mkdir(parents=True, exist_ok=True) target.rename(source) if had_old: backup.rename(target) raise def parse_args(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument( "--raw-root", type=Path, default=Path("RawVideos"), help="root directory containing the raw unit imagery", ) parser.add_argument( "--sync-csv", type=Path, default=Path("sync.csv"), help="CSV describing synchronized RGB/IR video pairs", ) parser.add_argument( "--out-root", type=Path, default=Path("Data"), help="destination directory for sampled frames and samples.csv", ) parser.add_argument( "--start", type=int, default=300, help="zero-based index of the first RGB frame to sample (default: 300)", ) parser.add_argument( "--step", type=int, default=300, help="number of RGB frames between samples (default: 300)", ) parser.add_argument( "--max-gap", type=float, default=10.0, help="maximum allowed RGB/IR timestamp gap in seconds (default: 10.0)", ) args = parser.parse_args() if args.start < 0: parser.error("--start must be non-negative") if args.step <= 0: parser.error("--step must be positive") if not math.isfinite(args.max_gap) or args.max_gap < 0: parser.error("--max-gap must be a finite, non-negative number") return args def main(): args = parse_args() unit_dirs = { "Canopy": args.raw_root / "Livingston Place 18 19 20 March 2026" / "Canopy Unit 18 March 2026" / "DCIM" / "100MEDIA", "Graminoid": args.raw_root / "Livingston Place 18 19 20 March 2026" / "Graminoid Unit 20 March 2026" / "DCIM" / "100MEDIA", } pairs = load_pairs(args.sync_csv, unit_dirs) if not pairs: raise RuntimeError("sync.csv contains no pairs") args.out_root.parent.mkdir(parents=True, exist_ok=True) with tempfile.TemporaryDirectory( prefix=".sample-dataset-", dir=args.out_root.parent, ignore_cleanup_errors=True, ) as temporary: stage = Path(temporary) rows = [] for pair in pairs: output = stage / "new" / pair["unit"] / pair["pair_id"] rows.extend( sample_pair( pair, output, unit_dirs, args.start, args.step, args.max_gap ) ) write_manifest(stage / "samples.csv", rows) commit(stage, pairs, args.out_root) log.info("complete: %d pairs, %d samples", len(pairs), len(rows)) if __name__ == "__main__": logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") try: main() except Exception as error: log.error("%s", error) sys.exit(1)