| """Create a side-by-side raw and Mask R-CNN segmentation showcase video.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| from pathlib import Path |
|
|
| import cv2 |
| import numpy as np |
| import torch |
| from detectron2 import model_zoo |
| from detectron2.config import get_cfg |
| from detectron2.engine import DefaultPredictor |
|
|
|
|
| CASE_SPECS = ( |
| ("5gs_22C", "45", "5 g/s | inlet subcooling 22 deg C | 45 V"), |
| ("10gs_22C", "45V", "10 g/s | inlet subcooling 22 deg C | 45 V"), |
| ("15gs_20C", "45", "15 g/s | inlet subcooling 20 deg C | 45 V"), |
| ("25gs_20C", "45", "25 g/s | inlet subcooling 20 deg C | 45 V"), |
| ) |
|
|
| ROI_X = 0 |
| ROI_Y = 485 |
| ROI_WIDTH = 1024 |
| ROI_HEIGHT = 70 |
| DISPLAY_Y0 = 360 |
| DISPLAY_Y1 = 680 |
| MINIMAL_DISPLAY_Y0 = 430 |
| MINIMAL_DISPLAY_Y1 = 590 |
| FRAME_SIZE = (1920, 720) |
| PANEL_SIZE = (880, 275) |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--dataset-root", required=True, type=Path) |
| parser.add_argument("--weights", required=True, type=Path) |
| parser.add_argument("--output", required=True, type=Path) |
| parser.add_argument("--frames-per-case", type=int, default=20) |
| parser.add_argument("--fps", type=float, default=5.0) |
| parser.add_argument("--minimal-stacked", action="store_true") |
| parser.add_argument("--score-threshold", type=float, default=0.30) |
| parser.add_argument("--detections-per-image", type=int, default=300) |
| parser.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu") |
| return parser.parse_args() |
|
|
|
|
| def build_predictor(args: argparse.Namespace) -> DefaultPredictor: |
| cfg = get_cfg() |
| cfg.merge_from_file( |
| model_zoo.get_config_file("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml") |
| ) |
| cfg.MODEL.WEIGHTS = str(args.weights) |
| cfg.MODEL.DEVICE = args.device |
| cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1 |
| cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = args.score_threshold |
| cfg.MODEL.ANCHOR_GENERATOR.SIZES = [[8], [16], [32], [64], [128]] |
| cfg.INPUT.MIN_SIZE_TEST = 640 |
| cfg.INPUT.MAX_SIZE_TEST = 900 |
| cfg.TEST.DETECTIONS_PER_IMAGE = args.detections_per_image |
| return DefaultPredictor(cfg) |
|
|
|
|
| def select_frames(image_dir: Path, count: int) -> list[Path]: |
| images = sorted(image_dir.glob("*.bmp")) |
| if len(images) < count: |
| raise ValueError(f"{image_dir} has {len(images)} BMP files; need {count}.") |
| indices = np.linspace(0, len(images) - 1, count, dtype=int) |
| return [images[index] for index in indices] |
|
|
|
|
| def union_mask(predictor: DefaultPredictor, roi: np.ndarray) -> np.ndarray: |
| outputs = predictor(roi) |
| masks = outputs["instances"].pred_masks.to("cpu").numpy() |
| if len(masks) == 0: |
| return np.zeros(roi.shape[:2], dtype=np.uint8) |
| return np.any(masks, axis=0).astype(np.uint8) * 255 |
|
|
|
|
| def make_overlay(roi: np.ndarray, mask: np.ndarray) -> np.ndarray: |
| overlay = roi.copy() |
| red = np.zeros_like(roi) |
| red[:, :, 2] = 255 |
| selected = mask.astype(bool) |
| overlay[selected] = cv2.addWeighted(roi, 0.48, red, 0.52, 0)[selected] |
| contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) |
| cv2.drawContours(overlay, contours, -1, (70, 235, 110), 1) |
| return overlay |
|
|
|
|
| def draw_text(image: np.ndarray, text: str, position: tuple[int, int], scale: float, color: tuple[int, int, int]) -> None: |
| cv2.putText(image, text, position, cv2.FONT_HERSHEY_SIMPLEX, scale, color, 2, cv2.LINE_AA) |
|
|
|
|
| def compose_frame( |
| raw: np.ndarray, |
| overlay: np.ndarray, |
| case_text: str, |
| progress: str, |
| display_fps: float, |
| ) -> np.ndarray: |
| canvas = np.full((FRAME_SIZE[1], FRAME_SIZE[0], 3), (20, 24, 30), dtype=np.uint8) |
| draw_text(canvas, "BubbleID-Flow: Raw Optical Image and Mask R-CNN Segmentation", (55, 55), 0.92, (245, 245, 245)) |
| draw_text(canvas, case_text, (55, 105), 0.70, (185, 215, 235)) |
| draw_text(canvas, progress, (1420, 105), 0.55, (190, 190, 190)) |
|
|
| raw_panel = cv2.resize(raw, PANEL_SIZE, interpolation=cv2.INTER_AREA) |
| overlay_panel = cv2.resize(overlay, PANEL_SIZE, interpolation=cv2.INTER_AREA) |
| left_x, right_x, top_y = 70, 970, 180 |
| canvas[top_y : top_y + PANEL_SIZE[1], left_x : left_x + PANEL_SIZE[0]] = raw_panel |
| canvas[top_y : top_y + PANEL_SIZE[1], right_x : right_x + PANEL_SIZE[0]] = overlay_panel |
| cv2.rectangle(canvas, (left_x, top_y), (left_x + PANEL_SIZE[0], top_y + PANEL_SIZE[1]), (220, 220, 220), 2) |
| cv2.rectangle(canvas, (right_x, top_y), (right_x + PANEL_SIZE[0], top_y + PANEL_SIZE[1]), (220, 220, 220), 2) |
| draw_text(canvas, "RAW OPTICAL IMAGE", (left_x, top_y - 20), 0.66, (245, 245, 245)) |
| draw_text(canvas, "UNION-MASK OVERLAY", (right_x, top_y - 20), 0.66, (245, 245, 245)) |
| draw_text(canvas, "Red: predicted vapor region | Green: union-mask boundary", (55, 540), 0.62, (230, 155, 155)) |
| draw_text(canvas, f"Display uses uniformly sampled frames at {display_fps:g} fps; source acquisition rate: 3000 frames/s.", (55, 595), 0.52, (190, 190, 190)) |
| draw_text(canvas, "Metric: image-plane vapor area fraction, not volumetric void fraction.", (55, 635), 0.52, (190, 190, 190)) |
| return canvas |
|
|
|
|
| def compose_minimal_stacked(raw: np.ndarray, overlay: np.ndarray) -> np.ndarray: |
| canvas = np.zeros((FRAME_SIZE[1], FRAME_SIZE[0], 3), dtype=np.uint8) |
| panel_size = (1600, 250) |
| raw_panel = cv2.resize(raw, panel_size, interpolation=cv2.INTER_AREA) |
| overlay_panel = cv2.resize(overlay, panel_size, interpolation=cv2.INTER_AREA) |
| left_x, top_y, bottom_y = 160, 70, 400 |
| canvas[top_y : top_y + panel_size[1], left_x : left_x + panel_size[0]] = raw_panel |
| canvas[bottom_y : bottom_y + panel_size[1], left_x : left_x + panel_size[0]] = overlay_panel |
| draw_text(canvas, "RAW", (left_x, 45), 0.70, (245, 245, 245)) |
| draw_text(canvas, "SEGMENTED", (left_x, 375), 0.70, (245, 245, 245)) |
| return canvas |
|
|
|
|
| def sha256(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as stream: |
| for chunk in iter(lambda: stream.read(1024 * 1024), b""): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| if args.frames_per_case <= 0 or args.fps <= 0: |
| raise ValueError("frames-per-case and fps must be positive") |
| image_root = args.dataset_root / "MultimodalData" / "Images" |
| if not image_root.is_dir(): |
| raise FileNotFoundError(f"Expected image root: {image_root}") |
| if not args.weights.is_file(): |
| raise FileNotFoundError(f"Weights not found: {args.weights}") |
|
|
| args.output.parent.mkdir(parents=True, exist_ok=True) |
| predictor = build_predictor(args) |
| fourcc = cv2.VideoWriter_fourcc(*"mp4v") |
| writer = cv2.VideoWriter(str(args.output), fourcc, args.fps, FRAME_SIZE) |
| if not writer.isOpened(): |
| raise RuntimeError(f"Could not open video writer for {args.output}") |
|
|
| selected: dict[str, list[str]] = {} |
| try: |
| total_frames = len(CASE_SPECS) * args.frames_per_case |
| frame_number = 0 |
| for case_id, state_id, label in CASE_SPECS: |
| source_files = select_frames(image_root / case_id / state_id, args.frames_per_case) |
| selected[case_id] = [path.name for path in source_files] |
| for image_path in source_files: |
| image = cv2.imread(str(image_path), cv2.IMREAD_COLOR) |
| if image is None or image.shape[:2] != (1024, 1024): |
| raise ValueError(f"Expected a 1024 x 1024 readable image: {image_path}") |
| roi = image[ROI_Y : ROI_Y + ROI_HEIGHT, ROI_X : ROI_X + ROI_WIDTH] |
| mask = union_mask(predictor, roi) |
| if args.minimal_stacked: |
| display_y0, display_y1 = MINIMAL_DISPLAY_Y0, MINIMAL_DISPLAY_Y1 |
| else: |
| display_y0, display_y1 = DISPLAY_Y0, DISPLAY_Y1 |
| display_raw = image[display_y0:display_y1, :] |
| display_overlay = display_raw.copy() |
| y0 = ROI_Y - display_y0 |
| display_overlay[y0 : y0 + ROI_HEIGHT, :] = make_overlay(roi, mask) |
| frame_number += 1 |
| if args.minimal_stacked: |
| writer.write(compose_minimal_stacked(display_raw, display_overlay)) |
| else: |
| writer.write( |
| compose_frame( |
| display_raw, |
| display_overlay, |
| label, |
| f"Frame {frame_number}/{total_frames}", |
| args.fps, |
| ) |
| ) |
| finally: |
| writer.release() |
|
|
| manifest = { |
| "dataset_root": str(args.dataset_root), |
| "weights": str(args.weights), |
| "weights_sha256": sha256(args.weights), |
| "output": str(args.output), |
| "duration_seconds": len(CASE_SPECS) * args.frames_per_case / args.fps, |
| "fps": args.fps, |
| "frames_per_case": args.frames_per_case, |
| "score_threshold": args.score_threshold, |
| "detections_per_image": args.detections_per_image, |
| "roi_xywh": [ROI_X, ROI_Y, ROI_WIDTH, ROI_HEIGHT], |
| "display_crop_y": [ |
| MINIMAL_DISPLAY_Y0 if args.minimal_stacked else DISPLAY_Y0, |
| MINIMAL_DISPLAY_Y1 if args.minimal_stacked else DISPLAY_Y1, |
| ], |
| "minimal_stacked": args.minimal_stacked, |
| "case_order": [spec[0] for spec in CASE_SPECS], |
| "selected_frames": selected, |
| } |
| manifest_path = args.output.with_suffix(".json") |
| manifest_path.write_text(json.dumps(manifest, indent=2), encoding="utf-8") |
| print(f"Wrote {args.output}") |
| print(f"Wrote {manifest_path}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
