Datasets:
Download scripts/sample_dataset.py from hotsightdataset/HotSight: direct link, hf CLI and curl.
- Browser
- Download file 11.4 kB
-
https://huggingface.co/datasets/hotsightdataset/HotSight/resolve/main/scripts/sample_dataset.py
- Command line
-
hf download hf://datasets/hotsightdataset/HotSight/scripts/sample_dataset.py
-
curl -L -o sample_dataset.py https://huggingface.co/datasets/hotsightdataset/HotSight/resolve/main/scripts/sample_dataset.py
11.4 kB
| #!/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) | |