| |
| """Detect candidate blue-screen intervals in endoscopy videos. |
| |
| The detector ignores the black border around the circular endoscopic view, |
| samples sparsely, and reports only candidate intervals. It never modifies the |
| input video. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import json |
| from pathlib import Path |
|
|
| import cv2 |
| import numpy as np |
|
|
|
|
| def circular_roi(frame: np.ndarray, black_threshold: int = 18) -> np.ndarray: |
| gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) |
| mask = (gray > black_threshold).astype(np.uint8) * 255 |
| mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, np.ones((15, 15), np.uint8)) |
| n, labels, stats, _ = cv2.connectedComponentsWithStats(mask) |
| if n > 1: |
| idx = 1 + int(np.argmax(stats[1:, cv2.CC_STAT_AREA])) |
| x, y, w, h, area = stats[idx] |
| if area > frame.shape[0] * frame.shape[1] * 0.05: |
| cx, cy = x + w / 2, y + h / 2 |
| radius = 0.5 * min(w, h) * 1.02 |
| yy, xx = np.ogrid[:frame.shape[0], :frame.shape[1]] |
| return ((xx - cx) ** 2 + (yy - cy) ** 2 <= radius ** 2).astype(np.uint8) |
| |
| yy, xx = np.ogrid[:frame.shape[0], :frame.shape[1]] |
| cx, cy = frame.shape[1] / 2, frame.shape[0] / 2 |
| rx, ry = frame.shape[1] * 0.47, frame.shape[0] * 0.47 |
| return (((xx - cx) / rx) ** 2 + ((yy - cy) / ry) ** 2 <= 1).astype(np.uint8) |
|
|
|
|
| def frame_score(frame: np.ndarray, roi: np.ndarray, size: int = 160) -> dict[str, float]: |
| small = cv2.resize(frame, (size, size), interpolation=cv2.INTER_AREA) |
| mask = cv2.resize(roi, (size, size), interpolation=cv2.INTER_NEAREST).astype(bool) |
| hsv = cv2.cvtColor(small, cv2.COLOR_BGR2HSV) |
| h, s, v = hsv[..., 0], hsv[..., 1], hsv[..., 2] |
| valid = mask & (v > 18) |
| if not np.any(valid): |
| return {"blue_ratio": 0.0, "texture": 0.0, "mean_hue": 0.0, "valid_ratio": 0.0} |
| blue = valid & (h >= 88) & (h <= 140) & (s >= 55) & (v >= 35) |
| gray = cv2.cvtColor(small, cv2.COLOR_BGR2GRAY) |
| texture = float(cv2.Laplacian(gray, cv2.CV_64F).var()) |
| return {"blue_ratio": float(blue.sum() / valid.sum()), |
| "texture": texture, "mean_hue": float(np.mean(h[valid])), |
| "valid_ratio": float(valid.sum() / mask.sum())} |
|
|
|
|
| def detect(args: argparse.Namespace) -> dict: |
| cap = cv2.VideoCapture(str(args.video)) |
| if not cap.isOpened(): |
| raise RuntimeError(f"cannot open video: {args.video}") |
| fps = cap.get(cv2.CAP_PROP_FPS) or 25.0 |
| frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0) |
| width, height = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) |
| duration = frame_count / fps if frame_count else None |
| cap.set(cv2.CAP_PROP_POS_FRAMES, 0) |
| ok, first = cap.read() |
| if not ok: |
| raise RuntimeError("cannot decode first frame") |
| roi = circular_roi(first) |
| step = max(1, int(round(args.sample_seconds * fps))) |
| samples = [] |
| for frame_idx in range(0, frame_count, step): |
| cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx) |
| ok, frame = cap.read() |
| if not ok: |
| continue |
| score = frame_score(frame, roi) |
| score.update(frame_index=frame_idx, time_seconds=frame_idx / fps) |
| score["blue_like"] = bool(score["blue_ratio"] >= args.blue_ratio and score["texture"] <= args.max_texture) |
| samples.append(score) |
| cap.release() |
|
|
| intervals = [] |
| start = None |
| for item in samples + [{"blue_like": False, "time_seconds": (duration or 0.0)}]: |
| if item["blue_like"] and start is None: |
| start = item["time_seconds"] |
| if not item["blue_like"] and start is not None: |
| end = item["time_seconds"] |
| if end - start >= args.min_seconds: |
| intervals.append({"start_seconds": round(start, 3), "end_seconds": round(end, 3), "duration_seconds": round(end-start, 3)}) |
| start = None |
| return {"video": str(args.video), "fps": fps, "frame_count": frame_count, |
| "width": width, "height": height, "duration_seconds": duration, |
| "sampling_seconds": args.sample_seconds, "blue_ratio_threshold": args.blue_ratio, |
| "max_texture": args.max_texture, "min_interval_seconds": args.min_seconds, |
| "intervals": intervals, "sample_count": len(samples), "samples": samples} |
|
|
|
|
| def main() -> None: |
| p = argparse.ArgumentParser() |
| p.add_argument("video", type=Path) |
| p.add_argument("--output-dir", type=Path, required=True) |
| p.add_argument("--sample-seconds", type=float, default=2.0) |
| p.add_argument("--blue-ratio", type=float, default=0.55) |
| p.add_argument("--max-texture", type=float, default=180.0) |
| p.add_argument("--min-seconds", type=float, default=6.0) |
| args = p.parse_args() |
| args.output_dir.mkdir(parents=True, exist_ok=True) |
| result = detect(args) |
| stem = args.video.stem.replace(" ", "_") |
| (args.output_dir / f"{stem}.json").write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8") |
| with (args.output_dir / f"{stem}_intervals.csv").open("w", newline="", encoding="utf-8") as f: |
| w = csv.DictWriter(f, fieldnames=["start_seconds", "end_seconds", "duration_seconds"]) |
| w.writeheader(); w.writerows(result["intervals"]) |
| print(json.dumps({k: result[k] for k in ("video", "duration_seconds", "sample_count", "intervals")}, ensure_ascii=False, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
