pipeline_eval/vis.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
可视化 3 个 JSON（GT / Pred / Merged），分别叠加在原视频上导出 3 段视频。
- 输入 JSON 统一为二维数组：data[g][o] = RLE（COCO 压缩，counts 为字符串）
- 若 Pred/Merged 帧数 < 视频/GT 帧数，按 p = floor(g * P / G) 映射扩展到 G 帧
- 颜色对同一 JSON 内的 object 按索引固定；三个输出彼此独立
"""
import os
import json
import argparse
import numpy as np
import cv2
from typing import List, Dict, Any
from pycocotools import mask as maskUtils

RLE = Dict[str, Any]

# ------------------ 工具 ------------------
def ensure_counts_str(rle: RLE) -> RLE:
    """pycocotools 可能返回 bytes，这里统一成 str"""
    out = {"size":[int(rle["size"][0]), int(rle["size"][1])], "counts": rle["counts"]}
    if isinstance(out["counts"], bytes):
        out["counts"] = out["counts"].decode("ascii")
    return out

def decode_rle_to_bool(rle: RLE) -> np.ndarray:
    """COCO 压缩 RLE -> bool mask (H, W)"""
    R = {"size": rle["size"], "counts": rle["counts"]}
    m = maskUtils.decode(R)
    if m.ndim == 3:
        m = m[:, :, 0]
    return m.astype(bool)

def expand_to_G_frames(data_2d: List[List[RLE]], G: int) -> List[List[RLE]]:
    """
    将帧数为 P 的数据扩展到 G 帧（仅允许 P<=G）：pred 的第 p 帧映射给多个 gt 帧 g
    p = floor(g * P / G)
    """
    P = len(data_2d)
    assert P > 0, "输入 JSON 为空"
    assert P <= G, f"不支持 P({P}) > G({G}) 的情况"
    if P == G:
        return data_2d
    expanded = []
    for g in range(G):
        p = int(np.floor(g * P / G))
        if p >= P:
            p = P - 1
        expanded.append(data_2d[p])
    return expanded

def make_palette(n: int) -> List[tuple]:
    """
    生成 n 个 BGR 颜色；尽量区分度高且稳定。
    """
    base = [
        (31,119,180),(255,127,14),(44,160,44),(214,39,40),(148,103,189),
        (140,86,75),(227,119,194),(127,127,127),(188,189,34),(23,190,207),
        (174,199,232),(255,187,120),(152,223,138),(255,152,150),(197,176,213),
        (196,156,148),(247,182,210),(199,199,199),(219,219,141),(158,218,229),
    ]
    # 转为 BGR（上面是近似 RGB）
    base = [(b, g, r) for (r, g, b) in base]
    if n <= len(base):
        return base[:n]
    # 不够就循环
    out = []
    for i in range(n):
        out.append(base[i % len(base)])
    return out

def overlay_masks_bgr(img: np.ndarray, rles: List[dict], alpha: float = 0.5) -> np.ndarray:
    """
    只在 mask 区域内做 alpha 混合；非 mask 区域保持原图，不会越叠越暗。
    rles：一帧内的对象列表（顺序即对象 id），COCO 压缩 RLE
    """
    h, w = img.shape[:2]
    out = img.copy()
    palette = make_palette(len(rles))

    for idx, r in enumerate(rles):
        if r is None:
            continue
        r = ensure_counts_str(r)
        mask = decode_rle_to_bool(r)
        if mask.shape[:2] != (h, w):
            # 尺寸不一致就跳过该对象（避免无关区域被处理）
            continue

        color = np.array(palette[idx], dtype=np.uint8)  # BGR
        # 只在 mask 区域内做混合
        roi = out[mask]
        if roi.size == 0:
            continue
        blended = (roi.astype(np.float32) * (1.0 - alpha) + color.astype(np.float32) * alpha).astype(np.uint8)
        out[mask] = blended

    return out

# ------------------ 主可视化流程 ------------------
def visualize_one_json(
    video_path: str,
    data_2d: List[List[RLE]],
    out_path: str,
    alpha: float = 0.5,
    draw_text: bool = True,
    text_prefix: str = ""
):
    cap = cv2.VideoCapture(video_path)
    assert cap.isOpened(), f"无法打开视频：{video_path}"

    width  = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    fps    = cap.get(cv2.CAP_PROP_FPS)
    frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

    G_json = len(data_2d)
    assert G_json in (frame_count, ) or G_json == len(data_2d), \
        f"JSON 帧数({G_json}) 与视频帧数({frame_count}) 不一致，请先扩展/对齐"

    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
    vw = cv2.VideoWriter(out_path, fourcc, fps if fps > 0 else 25.0, (width, height))
    assert vw.isOpened(), f"无法创建输出视频：{out_path}"

    # 遍历视频帧
    g = 0
    while True:
        ret, frame = cap.read()
        if not ret:
            break
        if g >= G_json:
            # 如果 JSON 比视频短（理论不应发生），停止
            break

        rles = data_2d[g]
        vis = overlay_masks_bgr(frame, rles, alpha=alpha)

        if draw_text:
            txt = f"{text_prefix} frame {g:05d}"
            cv2.putText(vis, txt, (12, 28), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0,0,0), 3, cv2.LINE_AA)
            cv2.putText(vis, txt, (12, 28), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (255,255,255), 1, cv2.LINE_AA)

        vw.write(vis)
        g += 1

    vw.release()
    cap.release()

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--video", required=True, help="原始视频路径")
    ap.add_argument("--gt", required=True, help="GT JSON（二维 data[g][o]=RLE）")
    ap.add_argument("--pred", required=True, help="Pred JSON（二维 data[g][o]=RLE；可下采样）")
    ap.add_argument("--merged", required=True, help="Merged JSON（二维 data[g][o]=RLE；可能已对齐，也可能下采样）")
    ap.add_argument("--out_dir", required=True, help="输出目录")
    ap.add_argument("--alpha", type=float, default=0.5, help="掩码可视化透明度 [0,1]")
    args = ap.parse_args()

    os.makedirs(args.out_dir, exist_ok=True)

    # 读取视频信息
    cap0 = cv2.VideoCapture(args.video)
    assert cap0.isOpened(), f"无法打开视频：{args.video}"
    G_video = int(cap0.get(cv2.CAP_PROP_FRAME_COUNT))
    cap0.release()
    assert G_video > 0, "视频帧数为 0？"

    # 载入 JSON
    with open(args.gt, "r") as f:
        gt_2d = json.load(f)
    with open(args.pred, "r") as f:
        pred_2d = json.load(f)
    with open(args.merged, "r") as f:
        merged_2d = json.load(f)

    # 基本校验：二维 & 每帧对象数一致
    O_gt = len(gt_2d[0]); 
    for row in gt_2d: assert len(row) == O_gt, "GT 每帧对象数必须一致"
    O_pr = len(pred_2d[0]);
    for row in pred_2d: assert len(row) == O_pr, "Pred 每帧对象数必须一致"
    # merged 可能“每帧对象数不一致”（合并/筛选后数量变了），允许。

    # 对齐帧数：GT 必须与视频等长；Pred/Merged 若更短则扩展
    assert len(gt_2d) == G_video, f"GT 帧数({len(gt_2d)}) 必须等于视频帧数({G_video})"
    pred_vis = expand_to_G_frames(pred_2d, G_video)
    merged_vis = expand_to_G_frames(merged_2d, G_video) if len(merged_2d) < G_video else merged_2d
    if len(merged_vis) != G_video:
        raise AssertionError(f"Merged 帧数({len(merged_vis)}) 必须 <= 视频帧数({G_video})")

    # 输出路径
    base = os.path.splitext(os.path.basename(args.video))[0]
    out_gt     = os.path.join(args.out_dir, f"{base}_gt_vis.mp4")
    out_pred   = os.path.join(args.out_dir, f"{base}_pred_vis.mp4")
    out_merged = os.path.join(args.out_dir, f"{base}_merged_vis.mp4")

    # 分别可视化三个 JSON
    visualize_one_json(args.video, gt_2d,     out_gt,     alpha=args.alpha, text_prefix="GT")
    visualize_one_json(args.video, pred_vis,  out_pred,   alpha=args.alpha, text_prefix="PRED")
    visualize_one_json(args.video, merged_vis,out_merged, alpha=args.alpha, text_prefix="MERGED")

    print("Done:")
    print("  GT     ->", out_gt)
    print("  Pred   ->", out_pred)
    print("  Merged ->", out_merged)

if __name__ == "__main__":
    main()