Evaluation Visualization

plt.rcParams.update({
    "font.family": "sans-serif",
    "font.size": 11,
    "axes.titlesize": 13,
    "axes.facecolor": "#FAFAFA",
    "axes.grid": True,
    "grid.alpha": 0.3,
    "grid.linestyle": "--",
    "axes.spines.top": False,
    "axes.spines.right": False,
})

def plot_error_vs_offset(df: pd.DataFrame, output_dir: str):
    offsets = sorted(df["true_offset_ms"].unique())
    x = np.arange(len(offsets))
    width = 0.35
    
    for i, method in enumerate(("audio", "visual")):
        mdf = df[df["method_type"] == method]
        maes = []
        for off in offsets:
            subset = mdf[mdf["true_offset_ms"] == off]
            maes.append(subset["absolute_error_ms"].mean() if not subset.empty else 0)
        ax.bar(x + (i - 0.5) * width, maes, width, label=method.capitalize(), color=COLORS[method])

def plot_confidence_vs_error(df: pd.DataFrame, output_dir: str):
    for method in ("audio", "visual"):
        ax.scatter(mdf["confidence_score"], mdf["absolute_error_ms"], 
                   label=method.capitalize(), color=COLORS[method], alpha=0.6)
        
        # Regression line
        z = np.polyfit(confs, errors, 1)
        p = np.poly1d(z)
        ax.plot(xs, p(xs), "--", color=COLORS[method], alpha=0.7)
        
        # Annotate Pearson r
        r = np.corrcoef(confs, errors)[0, 1]
        ax.annotate(f"{method}: r={r:.3f}", ...)

def plot_audio_video_diff_histogram(df: pd.DataFrame, output_dir: str):
    diffs = np.abs(audio_df.loc[common].values - visual_df.loc[common].values)
    
    ax.hist(diffs, bins=20, color="#7E57C2", alpha=0.85)
    ax.axvline(np.mean(diffs), color="#D32F2F", linestyle="--", 
               label=f"Mean = {np.mean(diffs):.1f} ms")
    ax.axvline(np.median(diffs), color="#388E3C", linestyle="--",
               label=f"Median = {np.median(diffs):.1f} ms")

def plot_runtime_comparison(df: pd.DataFrame, output_dir: str):
    methods = []
    means = []
    stds = []
    
    for method in ("audio", "visual"):
        methods.append(method.capitalize())
        means.append(mdf["runtime_seconds"].mean())
        stds.append(mdf["runtime_seconds"].std())
    
    ax.bar(methods, means, yerr=stds, color=colors, capsize=5)

def plot_error_distribution(df: pd.DataFrame, output_dir: str):
    # Boxplots for audio and visual at each offset
    bp_audio = ax.boxplot(audio_data, positions=positions - box_width / 2, 
                          patch_artist=True, showfliers=False)
    bp_visual = ax.boxplot(visual_data, positions=positions + box_width / 2,
                           patch_artist=True, showfliers=False)
    
    # Overlay scatter points with jitter
    for i, off in enumerate(offsets):
        jitter = np.random.default_rng(42).uniform(-0.06, 0.06, size=len(a))
        ax.scatter(np.full_like(a, i - box_width / 2) + jitter, a, ...)

def plot_resource_usage(df: pd.DataFrame, output_dir: str):
    fig, (ax_cpu, ax_mem) = plt.subplots(1, 2, figsize=FIGSIZE_WIDE)
    
    for ax, col, ylabel, title, fmt in [
        (ax_cpu, "peak_cpu_percent", "Peak CPU (%)", ..., "{:.1f}%"),
        (ax_mem, "peak_memory_mb", "Peak Memory (MB)", ..., "{:.0f} MB"),
    ]:
        ax.bar(methods, means, yerr=stds, color=colors, capsize=5)

def plot_motion_before_after(df, output_dir, diagnostics_dir):
    # Load motion signals from diagnostics .npz files
    data = np.load(npz_path)
    original = data["original"]
    synthetic = data["synthetic"]
    est_offset_ms = float(data["estimated_offset_ms"])
    
    # "After" = shift synthetic backwards by estimated offset
    shift_sec = est_offset_ms / 1000.0
    t_synth_aligned = t_synth - shift_sec
    
    # Plot before (raw) and after (aligned)
    ax_before.plot(t_orig, original, label="Original")
    ax_before.plot(t_synth, synthetic, label="Synthetic (raw)")
    
    ax_after.plot(t_orig, original, label="Original")
    ax_after.plot(t_synth_aligned, synthetic, label="Synthetic (aligned)")

def plot_sync_timelines(df, output_dir):
    # Original bar (always starts at 0)
    ax.barh(y_orig, vid_len, left=0, color="#78909C", label="Original")
    
    # Synthetic bar (shifted by true offset)
    synth_start = true_offset_sec
    ax.barh(y_synth, vid_len, left=synth_start, color="#B0BEC5", label="Synthetic")
    
    # Arrow for true offset
    ax.annotate("", xy=(synth_start, y), xytext=(0, y), 
                arrowprops=dict(arrowstyle="->", color="#D32F2F"))
    
    # Arrows for estimated offsets (audio & visual)
    for method, est_sec in method_ests.items():
        ax.annotate("", xy=(est_sec, y), xytext=(0, y),
                    arrowprops=dict(arrowstyle="->", color=COLORS[method], linestyle="--"))

COLORS = {"audio": "#2196F3", "visual": "#FF9800"}

DPI = 300  # Increase to 600 for higher resolution

FIGSIZE_WIDE = (10, 5)    # Width, height in inches
FIGSIZE_SQUARE = (7, 6)

def generate_plots(results_csv, plots_dir):
    # ... setup ...
    
    plot_error_vs_offset(df, plots_dir)
    plot_confidence_vs_error(df, plots_dir)
    # plot_audio_video_diff_histogram(df, plots_dir)  # Disabled
    plot_runtime_comparison(df, plots_dir)
    # ...