| |
| """Coarse-to-fine frozen blue-screen detection for endoscopy videos. |
| |
| Stage 1 decodes each video sequentially and hashes one circular-ROI frame per |
| second. Stage 2 re-reads only candidate windows and locates exact repeated-frame |
| runs at native FPS. Inputs are read-only; all results go below --output-dir. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import hashlib |
| import json |
| import socket |
| import time |
| from datetime import datetime, timezone |
| from pathlib import Path |
|
|
| import cv2 |
| import numpy as np |
|
|
| VIDEO_SUFFIXES = {".avi", ".mp4", ".mov", ".mkv"} |
|
|
|
|
| def utc_now() -> str: |
| return datetime.now(timezone.utc).astimezone().isoformat() |
|
|
|
|
| def hhmmss(seconds: float) -> str: |
| ms = int(round(seconds * 1000)) |
| hours, rem = divmod(ms, 3_600_000) |
| minutes, rem = divmod(rem, 60_000) |
| secs, millis = divmod(rem, 1000) |
| return f"{hours:02d}:{minutes:02d}:{secs:02d}.{millis:03d}" |
|
|
|
|
| def roi_mask(height: int, width: int) -> np.ndarray: |
| yy, xx = np.ogrid[:height, :width] |
| return (((xx - width / 2) / (width * 0.47)) ** 2 + |
| ((yy - height / 2) / (height * 0.47)) ** 2 <= 1) |
|
|
|
|
| def frame_features(frame: np.ndarray, mask: np.ndarray, size: int) -> tuple[str, float]: |
| small = cv2.resize(frame, (size, size), interpolation=cv2.INTER_AREA) |
| small_mask = cv2.resize(mask.astype(np.uint8), (size, size), |
| interpolation=cv2.INTER_NEAREST).astype(bool) |
| pixels = small[small_mask] |
| digest = hashlib.md5(pixels.tobytes()).hexdigest() |
| hsv = cv2.cvtColor(small, cv2.COLOR_BGR2HSV) |
| h, s, v = hsv[..., 0], hsv[..., 1], hsv[..., 2] |
| valid = small_mask & (v > 18) |
| if not valid.any(): |
| return digest, 0.0 |
| blue = valid & (h >= 88) & (h <= 140) & (s >= 55) & (v >= 35) |
| return digest, float(blue.sum() / valid.sum()) |
|
|
|
|
| def coarse_scan(video: Path, sample_seconds: float, min_static_seconds: float, |
| blue_threshold: float, size: int) -> tuple[dict, list[dict]]: |
| cap = cv2.VideoCapture(str(video)) |
| if not cap.isOpened(): |
| raise RuntimeError("cannot open video") |
| fps = float(cap.get(cv2.CAP_PROP_FPS) or 0) |
| frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0) |
| width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH) or 0) |
| height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT) or 0) |
| if fps <= 0 or frame_count <= 0 or width <= 0 or height <= 0: |
| cap.release() |
| raise RuntimeError(f"invalid metadata fps={fps} frames={frame_count} size={width}x{height}") |
| mask = roi_mask(height, width) |
| step = max(1, int(round(fps * sample_seconds))) |
| samples: list[dict] = [] |
| frame_idx = 0 |
| next_sample = 0 |
| while True: |
| ok, frame = cap.read() |
| if not ok: |
| break |
| if frame_idx >= next_sample: |
| digest, ratio = frame_features(frame, mask, size) |
| samples.append({"frame": frame_idx, "time": frame_idx / fps, |
| "hash": digest, "blue_ratio": ratio}) |
| next_sample += step |
| frame_idx += 1 |
| cap.release() |
| if frame_idx < frame_count * 0.99: |
| raise RuntimeError(f"early decode stop decoded={frame_idx} metadata_frames={frame_count}") |
|
|
| min_samples = max(2, int(np.ceil(min_static_seconds / sample_seconds))) |
| candidates: list[dict] = [] |
| run_start = 0 |
| for i in range(1, len(samples) + 1): |
| if i == len(samples) or samples[i]["hash"] != samples[run_start]["hash"]: |
| chunk = samples[run_start:i] |
| mean_blue = float(np.mean([x["blue_ratio"] for x in chunk])) |
| if len(chunk) >= min_samples and mean_blue >= blue_threshold: |
| candidates.append({ |
| "start_seconds": chunk[0]["time"], |
| "end_seconds": chunk[-1]["time"] + sample_seconds, |
| "sample_count": len(chunk), |
| "mean_blue_ratio": mean_blue, |
| "hash": chunk[0]["hash"], |
| }) |
| run_start = i |
| metadata = {"fps": fps, "frame_count": frame_count, "width": width, |
| "height": height, "duration_seconds": frame_count / fps, |
| "decoded_frames": frame_idx, "coarse_samples": len(samples)} |
| return metadata, candidates |
|
|
|
|
| def refine_candidate(video: Path, metadata: dict, candidate: dict, pad_seconds: float, |
| min_static_seconds: float, blue_threshold: float, |
| size: int) -> list[dict]: |
| fps = metadata["fps"] |
| first = max(0, int(np.floor((candidate["start_seconds"] - pad_seconds) * fps))) |
| last = min(metadata["frame_count"] - 1, |
| int(np.ceil((candidate["end_seconds"] + pad_seconds) * fps))) |
| cap = cv2.VideoCapture(str(video)) |
| cap.set(cv2.CAP_PROP_POS_FRAMES, first) |
| mask = roi_mask(metadata["height"], metadata["width"]) |
| samples: list[dict] = [] |
| frame_idx = first |
| while frame_idx <= last: |
| ok, frame = cap.read() |
| if not ok: |
| break |
| digest, ratio = frame_features(frame, mask, size) |
| samples.append({"frame": frame_idx, "hash": digest, "blue_ratio": ratio}) |
| frame_idx += 1 |
| cap.release() |
|
|
| min_frames = max(2, int(np.ceil(min_static_seconds * fps))) |
| runs: list[dict] = [] |
| run_start = 0 |
| for i in range(1, len(samples) + 1): |
| if i == len(samples) or samples[i]["hash"] != samples[run_start]["hash"]: |
| chunk = samples[run_start:i] |
| mean_blue = float(np.mean([x["blue_ratio"] for x in chunk])) |
| if len(chunk) >= min_frames and mean_blue >= blue_threshold: |
| start_frame = chunk[0]["frame"] |
| end_frame = chunk[-1]["frame"] |
| runs.append({ |
| "start_frame": start_frame, |
| "end_frame": end_frame, |
| "start_seconds": start_frame / fps, |
| "end_seconds": (end_frame + 1) / fps, |
| "duration_seconds": len(chunk) / fps, |
| "start_time": hhmmss(start_frame / fps), |
| "end_time": hhmmss((end_frame + 1) / fps), |
| "frame_count": len(chunk), |
| "mean_blue_ratio": mean_blue, |
| "exact_repeated_hash": chunk[0]["hash"], |
| "confidence": "high", |
| }) |
| run_start = i |
| return runs |
|
|
|
|
| def merge_duplicate_runs(runs: list[dict]) -> list[dict]: |
| by_key: dict[tuple[int, int], dict] = {} |
| for run in runs: |
| by_key[(run["start_frame"], run["end_frame"])] = run |
| return sorted(by_key.values(), key=lambda x: x["start_frame"]) |
|
|
|
|
| def save_evidence(video: Path, intervals: list[dict], output_dir: Path, fps: float) -> None: |
| if not intervals: |
| return |
| output_dir.mkdir(parents=True, exist_ok=True) |
| cap = cv2.VideoCapture(str(video)) |
| for index, interval in enumerate(intervals, 1): |
| points = { |
| "before": max(0, interval["start_frame"] - 1), |
| "start": interval["start_frame"], |
| "end": interval["end_frame"], |
| "after": interval["end_frame"] + 1, |
| } |
| evidence = {} |
| for label, frame_idx in points.items(): |
| cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx) |
| ok, frame = cap.read() |
| if ok: |
| name = f"interval_{index:03d}_{label}_f{frame_idx}.jpg" |
| cv2.imwrite(str(output_dir / name), frame) |
| evidence[label] = str((output_dir / name).name) |
| interval["evidence_frames"] = evidence |
| cap.release() |
|
|
|
|
| def write_aggregate(output_dir: Path, records: list[dict], started_at: str, |
| elapsed: float, input_dir: Path, config: dict) -> None: |
| intervals = [] |
| for record in records: |
| for idx, interval in enumerate(record.get("intervals", []), 1): |
| intervals.append({"video_id": record["video_id"], |
| "video_path": record["video_path"], |
| "interval_index": idx, **interval}) |
| fields = ["video_id", "video_path", "interval_index", "start_frame", "end_frame", |
| "start_seconds", "end_seconds", "duration_seconds", "start_time", "end_time", |
| "frame_count", "mean_blue_ratio", "confidence", "exact_repeated_hash"] |
| with (output_dir / "intervals.csv").open("w", newline="", encoding="utf-8") as handle: |
| writer = csv.DictWriter(handle, fieldnames=fields, extrasaction="ignore") |
| writer.writeheader(); writer.writerows(intervals) |
| with (output_dir / "videos.jsonl").open("w", encoding="utf-8") as handle: |
| for record in records: |
| handle.write(json.dumps(record, ensure_ascii=False) + "\n") |
| summary = { |
| "status": "completed" if all(r["status"] == "completed" for r in records) else "failed", |
| "started_at": started_at, "finished_at": utc_now(), "elapsed_seconds": elapsed, |
| "host": socket.gethostname(), "input_dir": str(input_dir), "config": config, |
| "video_count": len(records), |
| "completed_video_count": sum(r["status"] == "completed" for r in records), |
| "failed_video_count": sum(r["status"] == "failed" for r in records), |
| "videos_with_blue_screen": sum(bool(r.get("intervals")) for r in records), |
| "interval_count": len(intervals), |
| "total_video_seconds": sum(r.get("duration_seconds", 0) for r in records), |
| "total_blue_screen_seconds": sum(x["duration_seconds"] for x in intervals), |
| } |
| (output_dir / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8") |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--input-dir", type=Path, required=True) |
| parser.add_argument("--output-dir", type=Path, required=True) |
| parser.add_argument("--sample-seconds", type=float, default=1.0) |
| parser.add_argument("--min-static-seconds", type=float, default=6.0) |
| parser.add_argument("--blue-ratio", type=float, default=0.45) |
| parser.add_argument("--pad-seconds", type=float, default=5.0) |
| parser.add_argument("--coarse-size", type=int, default=96) |
| parser.add_argument("--fine-size", type=int, default=160) |
| parser.add_argument("--resume", action="store_true") |
| args = parser.parse_args() |
| videos = sorted(p for p in args.input_dir.rglob("*") if p.suffix.lower() in VIDEO_SUFFIXES) |
| if not videos: |
| raise SystemExit("no videos found") |
| args.output_dir.mkdir(parents=True, exist_ok=True) |
| per_video_dir = args.output_dir / "per_video" |
| evidence_root = args.output_dir / "evidence" |
| per_video_dir.mkdir(exist_ok=True) |
| started_at = utc_now(); t0 = time.perf_counter() |
| config = {"sample_seconds": args.sample_seconds, |
| "min_static_seconds": args.min_static_seconds, |
| "blue_ratio": args.blue_ratio, "pad_seconds": args.pad_seconds, |
| "coarse_size": args.coarse_size, "fine_size": args.fine_size, |
| "definition": "exact repeated decoded ROI frames with blue ratio above threshold"} |
| records = [] |
| for number, video in enumerate(videos, 1): |
| video_id = video.stem.split(" ", 1)[0] |
| result_path = per_video_dir / f"{video_id}.json" |
| if args.resume and result_path.exists(): |
| records.append(json.loads(result_path.read_text(encoding="utf-8"))) |
| print(f"[{number}/{len(videos)}] resume {video.name}", flush=True) |
| continue |
| print(f"[{number}/{len(videos)}] start {video.name} {utc_now()}", flush=True) |
| item_t0 = time.perf_counter() |
| record = {"video_id": video_id, "video_path": str(video), "status": "failed", |
| "started_at": utc_now(), "intervals": []} |
| try: |
| metadata, candidates = coarse_scan(video, args.sample_seconds, |
| args.min_static_seconds, |
| args.blue_ratio, args.coarse_size) |
| fine_runs = [] |
| for candidate in candidates: |
| fine_runs.extend(refine_candidate(video, metadata, candidate, |
| args.pad_seconds, |
| args.min_static_seconds, |
| args.blue_ratio, args.fine_size)) |
| fine_runs = merge_duplicate_runs(fine_runs) |
| save_evidence(video, fine_runs, evidence_root / video_id, metadata["fps"]) |
| blue_seconds = sum(x["duration_seconds"] for x in fine_runs) |
| record.update(metadata) |
| record.update({"status": "completed", "coarse_candidate_count": len(candidates), |
| "interval_count": len(fine_runs), "blue_screen": bool(fine_runs), |
| "blue_screen_seconds": blue_seconds, |
| "blue_screen_ratio": blue_seconds / metadata["duration_seconds"], |
| "intervals": fine_runs}) |
| except Exception as exc: |
| record["error"] = f"{type(exc).__name__}: {exc}" |
| record["finished_at"] = utc_now() |
| record["elapsed_seconds"] = time.perf_counter() - item_t0 |
| result_path.write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding="utf-8") |
| records.append(record) |
| write_aggregate(args.output_dir, records, started_at, |
| time.perf_counter() - t0, args.input_dir, config) |
| print(f"[{number}/{len(videos)}] {record['status']} intervals={len(record['intervals'])} elapsed={record['elapsed_seconds']:.1f}s", flush=True) |
| write_aggregate(args.output_dir, records, started_at, |
| time.perf_counter() - t0, args.input_dir, config) |
| if any(r["status"] != "completed" for r in records): |
| raise SystemExit(2) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
