四个机位颜色都不一样：多机位色彩统一的匹配与批量应用

1. 选参考机位（主机位，或者画质/曝光最好的那个）
      ↓
2. 找"可比对的帧"：两个机位拍到同一内容的时刻
      ↓（怎么找？用第 45 篇的音频对齐拿到时间偏移，再抽同一时刻的帧）
3. 计算从"待匹配"到"参考"的颜色映射
      ↓
4. 把这个映射应用到整段素材
      ↓
5. 验证 + 人工微调

def get_comparable_frames(ref_video, other_video, offset, count=5):
    """用已知的同步偏移，抽同一时刻的若干帧。"""
    import subprocess
    frames_ref, frames_oth = [], []
    duration = probe_duration(ref_video)
    for i in range(count):
        t = duration * (i + 1) / (count + 1)
        frames_ref.append(extract_frame(ref_video, t))
        frames_oth.append(extract_frame(other_video, t + offset))
    return frames_ref, frames_oth


def extract_frame(video, t):
    cmd = ['ffmpeg', '-v', 'error', '-ss', f'{t:.3f}', '-i', video,
           '-frames:v', '1', '-f', 'rawvideo', '-pix_fmt', 'bgr24', '-']
    p = subprocess.run(cmd, capture_output=True, check=True)
    h, w = probe_size(video)
    return np.frombuffer(p.stdout, np.uint8).reshape(h, w, 3)

import cv2
import numpy as np


def match_channel(src_ch, ref_ch):
    """单通道直方图匹配，返回映射表。"""
    src_hist = cv2.calcHist([src_ch], [0], None, [256], [0, 256]).flatten()
    ref_hist = cv2.calcHist([ref_ch], [0], None, [256], [0, 256]).flatten()
    src_cdf = np.cumsum(src_hist) / (src_hist.sum() + 1e-9)
    ref_cdf = np.cumsum(ref_hist) / (ref_hist.sum() + 1e-9)
    # 对每个 src 值，找 ref_cdf 中最接近 src_cdf 的位置
    lut = np.interp(src_cdf, ref_cdf, np.arange(256))
    return np.clip(lut, 0, 255).astype(np.uint8)


def match_histogram_rgb(src, ref):
    """RGB 逐通道匹配（简单但可能产生色偏）。"""
    out = np.zeros_like(src)
    for c in range(3):
        lut = match_channel(src[:, :, c], ref[:, :, c])
        out[:, :, c] = cv2.LUT(src[:, :, c], lut)
    return out

def match_histogram_lab(src, ref):
    """在 Lab 空间匹配：亮度做直方图匹配，色彩做均值/方差校正（更自然）。"""
    src_lab = cv2.cvtColor(src, cv2.COLOR_BGR2Lab)
    ref_lab = cv2.cvtColor(ref, cv2.COLOR_BGR2Lab)

    out = src_lab.copy()
    # 1. 亮度通道：直方图匹配（细节多，效果好）
    lut = match_channel(src_lab[:, :, 0], ref_lab[:, :, 0])
    out[:, :, 0] = cv2.LUT(src_lab[:, :, 0], lut)

    # 2. 色彩通道：只做均值和标准差的线性校正（避免逐通道拉伸导致的色偏）
    for c in (1, 2):
        s = src_lab[:, :, c].astype(np.float32)
        r = ref_lab[:, :, c].astype(np.float32)
        s_mean, s_std = s.mean(), s.std() + 1e-6
        r_mean, r_std = r.mean(), r.std() + 1e-6
        out[:, :, c] = np.clip((s - s_mean) * (r_std / s_std) + r_mean, 0, 255)

    return cv2.cvtColor(out.astype(np.uint8), cv2.COLOR_Lab2BGR)

1. 每个机位拍一段色卡（几秒就够）
      ↓
2. 从画面里定位色卡（检测色卡的矩形区域）
      ↓
3. 读出 24 个色块的实际像素值
      ↓
4. 和色卡的标准值对比，拟合出校正（白平衡增益 + 3×3 色彩矩阵 + gamma）
      ↓
5. 应用到该机位的所有素材

def white_balance_from_gray_card(frame, card_region):
    """用色卡的灰色块算白平衡增益（灰度块的 R=G=B）。"""
    x, y, w, h = card_region
    patch = frame[y:y + h, x:x + w].astype(np.float32)
    r, g, b = patch[:, :, 2].mean(), patch[:, :, 1].mean(), patch[:, :, 0].mean()
    # 目标：让 R=G=B（以 G 为基准）
    gain_r, gain_b = g / (r + 1e-6), g / (b + 1e-6)
    return float(gain_r), float(gain_b)


def apply_gains(frame, gain_r, gain_b):
    out = frame.astype(np.float32).copy()
    out[:, :, 2] = np.clip(out[:, :, 2] * gain_r, 0, 255)
    out[:, :, 0] = np.clip(out[:, :, 0] * gain_b, 0, 255)
    return out.astype(np.uint8)

# 色阶（黑白场）
-vf "colorlevels=rimin=0.02:gimin=0.02:bimin=0.02:rimax=0.98:gimax=0.98:bimax=0.98"
# 白平衡（按通道调整暗部/中间调/亮部）
-vf "colorbalance=rs=0.02:gs=0:bs=-0.02"
# 饱和度/对比度
-vf "eq=contrast=1.03:saturation=1.05:brightness=0.01"

def build_lut_from_transform(transform_fn, size=33):
    """transform_fn: 接受 (r,g,b) 返回 (r,g,b)（0~1 范围）。生成 .cube 文件内容。"""
    lines = [f'LUT_3D_SIZE {size}', 'DOMAIN_MIN 0.0 0.0 0.0', 'DOMAIN_MAX 1.0 1.0 1.0', '']
    for b in range(size):
        for g in range(size):
            for r in range(size):
                rr, gg, bb = r / (size - 1), g / (size - 1), b / (size - 1)
                orr, ogg, obb = transform_fn(rr, gg, bb)
                lines.append(f'{orr:.6f} {ogg:.6f} {obb:.6f}')
    return '\n'.join(lines) + '\n'

ffmpeg -i cam2.mp4 -vf "lut3d=file=match_cam2.cube:interp=tetrahedral" \
  -c:v libx265 -crf 20 -preset slow cam2_matched.mp4

def side_by_side(frames, labels, out):
    """把各机位同一时刻的帧并排，中间加分隔线。"""
    hs = [cv2.resize(f, (480, 270)) for f in frames]
    canvas = np.hstack(hs)
    cv2.imwrite(out, canvas)

ffmpeg -i matched.mp4 -vf "waveform=m=1,scale=512:256" -frames:v 1 wf.png
ffmpeg -i matched.mp4 -vf "vectorscope=m=color,scale=256:256" -frames:v 1 vs.png

def color_distance(a, b):
    """在 Lab 空间算平均色差（简化版 ΔE）。"""
    la = cv2.cvtColor(a, cv2.COLOR_BGR2Lab).astype(np.float32)
    lb = cv2.cvtColor(b, cv2.COLOR_BGR2Lab).astype(np.float32)
    return float(np.sqrt(((la - lb) ** 2).sum(axis=2)).mean())