File size: 5,484 Bytes
ce16509 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 | #!/usr/bin/env python3
"""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)
# Conservative fallback for the known 16:9 endoscopy layout.
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()
|