Datasets:

UARK-NED3
/

BubbleID-Flow

from __future__ import annotations

import argparse
import re
from pathlib import Path

import cv2
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import torch
from detectron2 import model_zoo
from detectron2.config import get_cfg
from detectron2.engine import DefaultPredictor

from bubbleid_flow.paths import iter_images
from bubbleid_flow.preprocess import crop_array, parse_roi
from bubbleid_flow.thermal_windows import (
    choose_operating_window,
    infer_time_gap_threshold,
    max_internal_gap_s,
    split_contiguous_windows,
)
from bubbleid_flow.vapor_fraction import (
    DEFAULT_ACTIVE_COLUMN_THRESHOLD,
    active_length_threshold_sweep,
    projected_mask_metrics,
    threshold_label,
)


def main() -> None:
    parser = argparse.ArgumentParser(
        description="Create a first multimodal thermal/acoustic/image summary for one test case."
    )
    parser.add_argument("--case-label", required=True, help="Case label such as 15gs_20C.")
    parser.add_argument("--image-root", required=True, help="Root containing image state folders.")
    parser.add_argument("--thermal-workbook", required=True, help="Reduced thermal workbook.")
    parser.add_argument("--thermal-input-workbook", required=True, help="Workbook containing voltage.")
    parser.add_argument("--ae-hit-file", required=True, help="EasyAE HIT text file.")
    parser.add_argument("--weights", required=True, help="Detectron2 Mask R-CNN weights.")
    parser.add_argument("--output-dir", required=True)
    parser.add_argument("--roi", default="0,485,1024,70")
    parser.add_argument("--frames-per-state", type=int, default=12)
    parser.add_argument("--bins", type=int, default=64)
    parser.add_argument("--score-threshold", type=float, default=0.30)
    parser.add_argument(
        "--detections-per-image",
        type=int,
        default=None,
        help="Optional Detectron2 TEST.DETECTIONS_PER_IMAGE override.",
    )
    parser.add_argument("--active-column-threshold", type=float, default=DEFAULT_ACTIVE_COLUMN_THRESHOLD)
    parser.add_argument(
        "--active-column-sensitivity-thresholds",
        default="0.025,0.05,0.075",
        help=(
            "Comma-separated projected-vapor column thresholds used to audit "
            "active-length sensitivity. Include --active-column-threshold in this list."
        ),
    )
    parser.add_argument("--voltage-tolerance", type=float, default=0.75)
    parser.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
    args = parser.parse_args()

    output_dir = Path(args.output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)
    overlay_dir = output_dir / "representative_overlays"
    overlay_dir.mkdir(parents=True, exist_ok=True)

    states = discover_states(Path(args.image_root))
    predictor = DefaultPredictor(
        _build_cfg(args.weights, args.score_threshold, args.device, args.detections_per_image)
    )
    image_summary, frame_metrics = summarize_image_states(
        states=states,
        predictor=predictor,
        roi=parse_roi(args.roi),
        frames_per_state=args.frames_per_state,
        active_column_threshold=args.active_column_threshold,
        active_column_sensitivity_thresholds=parse_thresholds(
            args.active_column_sensitivity_thresholds,
            required_threshold=args.active_column_threshold,
        ),
        overlay_dir=overlay_dir,
    )
    thermal_summary = summarize_thermal_states(
        states=states,
        thermal_workbook=Path(args.thermal_workbook),
        thermal_input_workbook=Path(args.thermal_input_workbook),
        voltage_tolerance=args.voltage_tolerance,
    )
    ae_summary = summarize_ae_by_thermal_windows(
        hit_file=Path(args.ae_hit_file),
        thermal_windows=thermal_summary[
            ["state_label", "time_start_s", "time_end_s"]
        ].dropna(),
    )

    summary = (
        image_summary.merge(thermal_summary, on=["state_label", "state_voltage"], how="outer")
        .merge(ae_summary, on="state_label", how="left")
        .sort_values("state_voltage", na_position="last")
    )

    summary_path = output_dir / f"{args.case_label}_multimodal_state_summary.csv"
    frame_metrics_path = output_dir / f"{args.case_label}_image_frame_metrics.csv"
    figure_path = output_dir / f"{args.case_label}_integrated_baseline_panel.png"
    image_summary_path = output_dir / f"{args.case_label}_image_state_summary.csv"

    summary.to_csv(summary_path, index=False)
    frame_metrics.to_csv(frame_metrics_path, index=False)
    image_summary.to_csv(image_summary_path, index=False)
    plot_integrated_panel(
        case_label=args.case_label,
        summary=summary,
        figure_path=figure_path,
        thermal_workbook=Path(args.thermal_workbook),
        overlay_dir=overlay_dir,
    )

    print(f"Wrote {summary_path}")
    print(f"Wrote {frame_metrics_path}")
    print(f"Wrote {figure_path}")


def discover_states(image_root: Path) -> list[dict]:
    states = []
    for path in sorted([p for p in image_root.iterdir() if p.is_dir()], key=lambda p: parse_state_voltage(p.name)):
        voltage = parse_state_voltage(path.name)
        if voltage is None:
            continue
        states.append({"state_label": path.name, "state_voltage": voltage, "path": path})
    return states


def parse_state_voltage(label: str) -> float | None:
    match = re.search(r"\d+(?:\.\d+)?", label)
    return float(match.group(0)) if match else None


def parse_thresholds(text: str, *, required_threshold: float | None = None) -> list[float]:
    thresholds = []
    for item in text.split(","):
        item = item.strip()
        if not item:
            continue
        threshold = float(item)
        if not 0 <= threshold <= 1:
            raise ValueError("active-column sensitivity thresholds must be between 0 and 1")
        thresholds.append(threshold)
    if required_threshold is not None and not any(
        abs(threshold - required_threshold) < 1e-12 for threshold in thresholds
    ):
        thresholds.append(required_threshold)
    return sorted(set(thresholds))


def sample_evenly(paths: list[Path], count: int) -> list[Path]:
    if count <= 0 or len(paths) <= count:
        return paths
    indices = np.linspace(0, len(paths) - 1, count, dtype=int)
    return [paths[int(index)] for index in indices]


def summarize_image_states(
    states: list[dict],
    predictor: DefaultPredictor,
    roi: tuple[int, int, int, int],
    frames_per_state: int,
    active_column_threshold: float,
    active_column_sensitivity_thresholds: list[float],
    overlay_dir: Path,
) -> tuple[pd.DataFrame, pd.DataFrame]:
    rows = []
    frame_rows = []
    for state in states:
        available_image_paths = iter_images(state["path"])
        image_paths = sample_evenly(available_image_paths, frames_per_state)
        representative_index = len(image_paths) // 2 if image_paths else -1
        sample_fraction = (
            len(image_paths) / len(available_image_paths) if available_image_paths else np.nan
        )
        for frame_index, image_path in enumerate(image_paths):
            image = cv2.imread(str(image_path), cv2.IMREAD_COLOR)
            if image is None:
                raise ValueError(f"Could not read image: {image_path}")
            cropped = crop_array(image, roi)
            combined = predict_combined_mask(predictor, cropped)
            metrics = projected_mask_metrics(
                combined,
                active_column_threshold=active_column_threshold,
            )
            sensitivity_metrics = active_length_threshold_sweep(
                combined,
                active_column_sensitivity_thresholds,
            )
            frame_rows.append(
                {
                    "state_label": state["state_label"],
                    "state_voltage": state["state_voltage"],
                    "frame_name": image_path.name,
                    "available_frames_in_state": len(available_image_paths),
                    "frames_requested_per_state": frames_per_state,
                    "sample_fraction": sample_fraction,
                    "active_column_threshold": active_column_threshold,
                    **metrics,
                    **sensitivity_metrics,
                }
            )
            if frame_index == representative_index:
                overlay_path = overlay_dir / f"{safe_name(state['state_label'])}_{image_path.stem}_overlay.png"
                cv2.imwrite(str(overlay_path), overlay_combined_mask(cropped, combined))

    frame_metrics = pd.DataFrame(frame_rows)
    grouped = frame_metrics.groupby(["state_label", "state_voltage"], as_index=False)
    aggregations = {
        "image_frames": ("frame_name", "count"),
        "available_frames_in_state": ("available_frames_in_state", "first"),
        "frames_requested_per_state": ("frames_requested_per_state", "first"),
        "sample_fraction": ("sample_fraction", "first"),
        "active_column_threshold": ("active_column_threshold", "first"),
        "vapor_area_fraction_mean": ("vapor_area_fraction", "mean"),
        "vapor_area_fraction_std": ("vapor_area_fraction", "std"),
        "active_length_fraction_mean": ("active_length_fraction", "mean"),
        "vapor_front_x_px_mean": ("vapor_front_x_px", "mean"),
    }
    for threshold in active_column_sensitivity_thresholds:
        column = f"active_length_fraction_thr_{threshold_label(threshold)}"
        if column in frame_metrics.columns:
            aggregations[f"{column}_mean"] = (column, "mean")
    if "active_length_threshold_sensitivity_range" in frame_metrics.columns:
        aggregations["active_length_threshold_sensitivity_range_mean"] = (
            "active_length_threshold_sensitivity_range",
            "mean",
        )
    if "active_length_thresholds_evaluated" in frame_metrics.columns:
        aggregations["active_length_thresholds_evaluated"] = (
            "active_length_thresholds_evaluated",
            "first",
        )
    summary = grouped.agg(**aggregations)
    return summary, frame_metrics


def predict_combined_mask(predictor: DefaultPredictor, image: np.ndarray) -> np.ndarray:
    outputs = predictor(image)
    instances = outputs["instances"].to("cpu")
    masks = instances.pred_masks.numpy() if instances.has("pred_masks") else np.empty((0, *image.shape[:2]))
    return np.any(masks, axis=0).astype(np.uint8) * 255 if len(masks) else np.zeros(image.shape[:2], dtype=np.uint8)


def summarize_thermal_states(
    states: list[dict],

    thermal_workbook: Path,

    thermal_input_workbook: Path,

    voltage_tolerance: float,

) -> pd.DataFrame:
    thermal = pd.read_excel(thermal_workbook)
    thermal_input = pd.read_excel(thermal_input_workbook)
    combined = thermal.copy()

    voltage_col = find_column(thermal_input, ["Voltage"])
    time_col = find_column(combined, ["Time [s]"])
    power_col = find_column(combined, ["Power"])
    heat_flux_col = find_column(combined, ["Heat Flux"])
    mass_flow_col = find_column(combined, ["Mass Flow Rate"])
    velocity_col = find_column(combined, ["Fluid Velocity"])
    inlet_subcool_col = find_column(combined, ["Inlet Subcooling"])
    pin_col = find_column(combined, ["Inlet Pressure"])
    pout_col = find_column(combined, ["Outlet Pressure"])
    tin_col = find_column(combined, ["Inlet Temperature"])
    tout_col = find_column(combined, ["Outlet Temperature"])
    wall_temperature_cols = [
        col for col in combined.columns if str(col).startswith("Temperature at x")
    ]
    htc_cols = [col for col in combined.columns if "Heat Transfer Coefficient" in str(col)]
    quality_cols = [col for col in combined.columns if str(col).startswith("Quality at x")]

    combined["_abs_voltage"] = thermal_input[voltage_col].abs().to_numpy()
    gap_threshold_s = infer_time_gap_threshold(combined, time_col)
    rows = []
    previous_window_end_s: float | None = None
    for state in states:
        target = state["state_voltage"]
        candidate_rows = combined[(combined["_abs_voltage"] - target).abs() <= voltage_tolerance]
        if candidate_rows.empty:
            rows.append(
                {
                    "state_label": state["state_label"],
                    "state_voltage": target,
                    "thermal_rows": 0,
                    "thermal_candidate_rows": 0,
                    "thermal_window_blocks": 0,
                    "thermal_window_selection": "no_voltage_matched_rows",
                    "thermal_window_gap_threshold_s": gap_threshold_s,
                }
            )
            continue
        windows = split_contiguous_windows(
            candidate_rows,
            time_col,
            max_gap_s=gap_threshold_s,
        )
        selection = choose_operating_window(
            windows,
            time_col,
            previous_end_s=previous_window_end_s,
            gap_threshold_s=gap_threshold_s,
        )
        selected = selection.data
        previous_window_end_s = float(selected[time_col].max())
        heat_flux = selected[heat_flux_col]
        if "W/m²" in heat_flux_col or "W/m2" in heat_flux_col:
            heat_flux_w_cm2 = heat_flux / 10_000.0
        else:
            heat_flux_w_cm2 = heat_flux
        rows.append(
            {
                "state_label": state["state_label"],
                "state_voltage": target,
                "thermal_rows": len(selected),
                "thermal_candidate_rows": len(candidate_rows),
                "thermal_window_blocks": selection.block_count,
                "thermal_window_block_index": selection.block_index,
                "thermal_window_selection": selection.reason,
                "thermal_window_gap_threshold_s": selection.gap_threshold_s,
                "thermal_window_duration_s": float(selected[time_col].max() - selected[time_col].min()),
                "thermal_window_max_internal_gap_s": max_internal_gap_s(selected, time_col),
                "time_start_s": float(selected[time_col].min()),
                "time_end_s": float(selected[time_col].max()),
                "voltage_mean_v": float(selected["_abs_voltage"].mean()),
                "power_mean_w": float(selected[power_col].mean()),
                "power_std_w": float(selected[power_col].std(ddof=1)),
                "heat_flux_mean_w_cm2": float(heat_flux_w_cm2.mean()),
                "heat_flux_std_w_cm2": float(heat_flux_w_cm2.std(ddof=1)),
                "mass_flow_mean_kg_s": float(selected[mass_flow_col].mean()),
                "mass_flow_std_kg_s": float(selected[mass_flow_col].std(ddof=1)),
                "fluid_velocity_mean_m_s": float(selected[velocity_col].mean()),
                "inlet_subcooling_mean_c": float(selected[inlet_subcool_col].mean()),
                "pressure_drop_mean_kpa": float((selected[pin_col] - selected[pout_col]).mean()),
                "inlet_temperature_mean_c": float(selected[tin_col].mean()),
                "outlet_temperature_mean_c": float(selected[tout_col].mean()),
                "wall_temperature_mean_c": (
                    float(selected[wall_temperature_cols].mean(axis=1).mean())
                    if wall_temperature_cols
                    else np.nan
                ),
                "wall_temperature_std_c": (
                    float(selected[wall_temperature_cols].mean(axis=1).std(ddof=1))
                    if wall_temperature_cols
                    else np.nan
                ),
                "htc_mean_w_m2k": float(selected[htc_cols].mean(axis=1).mean()) if htc_cols else np.nan,
                "quality_x7_mean": float(selected[quality_cols[-1]].mean()) if quality_cols else np.nan,
            }
        )
    return pd.DataFrame(rows)


def summarize_ae_by_thermal_windows(hit_file: Path, thermal_windows: pd.DataFrame) -> pd.DataFrame:
    hits = read_hit_file(hit_file)
    time_col = "SSSSSSSS.mmmuuun"
    rows = []
    for row in thermal_windows.itertuples(index=False):
        duration = max(float(row.time_end_s - row.time_start_s), 1e-9)
        selected = hits[(hits[time_col] >= row.time_start_s) & (hits[time_col] <= row.time_end_s)]
        ch1 = selected[selected["CH"] == 1]
        ch2 = selected[selected["CH"] == 2]
        rows.append(
            {
                "state_label": row.state_label,
                "ae_hits": len(selected),
                "ae_hit_rate_hz": float(len(selected) / duration),
                "ae_abs_energy_rate": float(selected["ABS-ENERGY"].sum() / duration) if len(selected) else 0.0,
                "ae_amp_mean_db": float(selected["AMP"].mean()) if len(selected) else np.nan,
                "ae_ch1_hit_rate_hz": float(len(ch1) / duration),
                "ae_ch2_hit_rate_hz": float(len(ch2) / duration),
            }
        )
    return pd.DataFrame(rows)


def read_hit_file(hit_file: Path) -> pd.DataFrame:
    with hit_file.open("r", encoding="latin1") as handle:
        lines = handle.readlines()
    header_idx = next(
        index for index, line in enumerate(lines) if line.strip().startswith("ID") and "SSSS" in line
    )
    columns = lines[header_idx].split()
    sig_idx = columns.index("SIG")
    columns = columns[:sig_idx] + ["SIG-STRENGTH"] + columns[sig_idx + 2 :]
    return pd.read_csv(
        hit_file,
        sep=r"\s+",
        names=columns,
        skiprows=header_idx + 1,
        engine="python",
    )


def find_column(data: pd.DataFrame, fragments: list[str]) -> str:
    for column in data.columns:
        text = str(column)
        if all(fragment in text for fragment in fragments):
            return column
    raise KeyError(f"Could not find column containing {fragments}")


def plot_integrated_panel(

    case_label: str,

    summary: pd.DataFrame,

    figure_path: Path,

    thermal_workbook: Path,

    overlay_dir: Path,

) -> None:
    thermal = pd.read_excel(thermal_workbook)
    time_col = find_column(thermal, ["Time [s]"])
    heat_flux_col = find_column(thermal, ["Heat Flux"])
    heat_flux = thermal[heat_flux_col]
    if "W/m²" in heat_flux_col or "W/m2" in heat_flux_col:
        heat_flux = heat_flux / 10_000.0

    fig = plt.figure(figsize=(13, 8), constrained_layout=True)
    gs = fig.add_gridspec(2, 2)
    ax0 = fig.add_subplot(gs[0, 0])
    ax1 = fig.add_subplot(gs[0, 1])
    ax2 = fig.add_subplot(gs[1, 0])
    ax3 = fig.add_subplot(gs[1, 1])

    ax0.plot(thermal[time_col], heat_flux, color="#333333", linewidth=1.5)
    ax0.set_title(f"{case_label}: thermal forcing")
    ax0.set_xlabel("Test-relative time (s)")
    ax0.set_ylabel("Heat flux (W/cm$^2$)")
    ax0.grid(True, alpha=0.3)

    ax1.errorbar(
        summary["state_voltage"],
        summary["vapor_area_fraction_mean"],
        yerr=summary["vapor_area_fraction_std"].fillna(0),
        marker="o",
        color="#1664a2",
        linewidth=1.8,
        capsize=3,
    )
    ax1.set_title("Image-derived vapor coverage")
    ax1.set_xlabel("Applied voltage state (V)")
    ax1.set_ylabel("Projected vapor area fraction")
    ax1.grid(True, alpha=0.3)

    ax2.plot(
        summary["state_voltage"],
        summary["htc_mean_w_m2k"],
        marker="s",
        color="#8c2d04",
        linewidth=1.8,
        label="Mean HTC",
    )
    ax2b = ax2.twinx()
    ax2b.plot(
        summary["state_voltage"],
        summary["heat_flux_mean_w_cm2"],
        marker="^",
        color="#2ca25f",
        linewidth=1.8,
        label="Heat flux",
    )
    ax2.set_title("Thermal state summary")
    ax2.set_xlabel("Applied voltage state (V)")
    ax2.set_ylabel("Mean HTC (W/m$^2$ K)")
    ax2b.set_ylabel("Heat flux (W/cm$^2$)")
    ax2.grid(True, alpha=0.3)

    ax3.plot(
        summary["state_voltage"],
        summary["ae_hit_rate_hz"],
        marker="o",
        color="#6a51a3",
        linewidth=1.8,
        label="AE hit rate",
    )
    ax3b = ax3.twinx()
    ax3b.plot(
        summary["state_voltage"],
        summary["ae_abs_energy_rate"],
        marker="D",
        color="#d95f0e",
        linewidth=1.8,
        label="AE abs. energy rate",
    )
    ax3.set_title("AE activity, provisional time alignment")
    ax3.set_xlabel("Applied voltage state (V)")
    ax3.set_ylabel("Hit rate (Hz)")
    ax3b.set_ylabel("Abs. energy rate")
    ax3.grid(True, alpha=0.3)

    fig.suptitle(
        "First integrated BubbleID-Flow multimodal panel: image, thermal, and acoustic metrics",
        fontsize=14,
    )
    fig.savefig(figure_path, dpi=220)
    plt.close(fig)

    contact_sheet_path = figure_path.with_name(f"{case_label}_representative_overlay_sheet.png")
    make_overlay_sheet(overlay_dir, contact_sheet_path)


def make_overlay_sheet(overlay_dir: Path, output_path: Path) -> None:
    from PIL import Image, ImageDraw, ImageFont

    paths = sorted(overlay_dir.glob("*.png"))
    if not paths:
        return
    cell_w, cell_h = 360, 50
    cols = 3
    rows = int(np.ceil(len(paths) / cols))
    label_h = 20
    sheet = Image.new("RGB", (cols * cell_w, rows * (cell_h + label_h)), "white")
    draw = ImageDraw.Draw(sheet)
    try:
        font = ImageFont.truetype("arial.ttf", 12)
    except Exception:
        font = ImageFont.load_default()
    for index, path in enumerate(paths):
        row, col = divmod(index, cols)
        x = col * cell_w
        y = row * (cell_h + label_h)
        draw.text((x + 4, y + 3), path.name.split("_192.")[0], fill=(0, 0, 0), font=font)
        image = Image.open(path).convert("RGB").resize((cell_w, cell_h))
        sheet.paste(image, (x, y + label_h))
    sheet.save(output_path)


def overlay_combined_mask(image: np.ndarray, mask: np.ndarray) -> np.ndarray:
    overlay = image.copy()
    red = np.zeros_like(image)
    red[:, :, 2] = 255
    mask_bool = mask > 0
    overlay[mask_bool] = cv2.addWeighted(image, 0.55, red, 0.45, 0)[mask_bool]
    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    cv2.drawContours(overlay, contours, -1, (0, 255, 0), 1)
    return overlay


def safe_name(value: str) -> str:
    return re.sub(r"[^A-Za-z0-9_.-]+", "_", value)


def _build_cfg(weights: str, score_threshold: float, device: str, detections_per_image: int | None):
    cfg = get_cfg()
    cfg.merge_from_file(
        model_zoo.get_config_file("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml")
    )
    cfg.MODEL.WEIGHTS = weights
    cfg.MODEL.DEVICE = device
    cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1
    cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = score_threshold
    cfg.MODEL.ANCHOR_GENERATOR.SIZES = [[8], [16], [32], [64], [128]]
    cfg.INPUT.MIN_SIZE_TEST = 640
    cfg.INPUT.MAX_SIZE_TEST = 900
    if detections_per_image is not None:
        if detections_per_image <= 0:
            raise ValueError("detections_per_image must be positive")
        cfg.TEST.DETECTIONS_PER_IMAGE = detections_per_image
    return cfg


if __name__ == "__main__":
    main()