Chart: cumulative patch count over time, codec vs uniform

Replaces the two side-by-side bar panels with a single overlaid step
chart so the contrast is immediate.

X = time (s)
Y = cumulative count of selected patches
Indigo (solid) = codec saliency, rises in steps at each sampled
frame by however many patches that frame contributed.
Cyan (dashed) = uniform-sampling baseline at the same budget,
stays flat between its evenly-spaced uniform frames
and jumps by grid_size on each.
Dotted gray line at y = total patches budget for reference; the
codec curve hits it (== budget), the uniform curve typically falls
short because budget rarely divides evenly into grid_size.
Light dashed verticals show the GOP group boundaries.

Section header retitled 'Cumulative patches over time' with a short
legend in the subtitle explaining the two curves.

app.py

@@ -581,19 +581,16 @@ def make_charts(
     groups: List[Tuple[int, int]] = None,
     gop_label: str = "global",
 ):
-    """Two side-by-side panels comparing codec selection vs uniform sampling.
+    """One overlaid step chart: cumulative patches selected vs time, for
+    the codec saliency curve and a uniform-sampling baseline at the same
+    total budget.
 
-    Both panels share x = time (seconds), y = number of patches selected at
-    that timestamp. Same total patch budget on both sides — only the
-    *allocation* differs.
-
-      Left  (codec):    patches go where saliency wants them — often spiky
-                        and concentrated on a few moments.
-      Right (uniform):  the same budget is spent on full frames sampled
-                        evenly in time; every uniform frame contributes the
-                        full grid's worth of patches.
-    """
-    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(9.2, 3.2), constrained_layout=True)
+    X = time (s)
+    Y = cumulative count of selected patches
+    Both curves end near the budget (codec: == total selected; uniform:
+    n_uniform_frames × grid_size, ≤ budget). The codec curve rises in
+    bursts where saliency is high; uniform rises in equal steps."""
+    fig, ax = plt.subplots(figsize=(9.2, 3.6), constrained_layout=True)
 
     fps_safe = float(fps) if fps and fps > 0 else 25.0
     if grids:
@@ -605,70 +602,85 @@ def make_charts(
         (max(frame_ids) / fps_safe) if frame_ids else 1.0
     )
 
-    # ─── Left: codec selection over time ─────────────────────────────────
+    # ─── Build step curves ──────────────────────────────────────────────
+    def _step(xs, cum):
+        """Return (xx, yy) for a left-continuous step plot through (xs, cum)."""
+        if not xs:
+            return [0.0, duration], [0.0, 0.0]
+        xx, yy = [0.0], [0.0]
+        prev = 0.0
+        for x, c in zip(xs, cum):
+            xx.extend([x, x]); yy.extend([prev, c])
+            prev = c
+        xx.append(duration); yy.append(prev)
+        return xx, yy
+
     times = [fid / fps_safe for fid in frame_ids]
     counts = [int(m.sum()) for m in masks]
-    if not times:
-        times, counts = [0.0], [0]
-    bar_w = max(duration / max(1, len(times)) * 0.55, 0.04)
-    ax1.bar(
-        times, counts, width=bar_w,
-        color="#4f46e5", alpha=0.88,
-        edgecolor="#312e81", linewidth=0.4,
+    codec_cum = list(np.cumsum(counts)) if counts else []
+    codec_total = int(codec_cum[-1]) if codec_cum else 0
+    xx_c, yy_c = _step(times, codec_cum)
+
+    n_uniform = max(1, int(total_patches_budget // max(1, grid_size)))
+    uni_times = (
+        [duration * 0.5] if n_uniform == 1
+        else list(np.linspace(0.0, duration, n_uniform))
     )
-    total_selected = sum(counts)
-    n_groups = len(groups) if groups else 1
-    gop_str = (
-        gop_label if gop_label in ("global", "dynamic") else f"GOP={gop_label}"
+    uni_cum = list(np.cumsum([grid_size] * n_uniform))
+    uni_total = int(uni_cum[-1]) if uni_cum else 0
+    xx_u, yy_u = _step(uni_times, uni_cum)
+
+    # ─── Plot ───────────────────────────────────────────────────────────
+    ax.fill_between(xx_c, yy_c, step=None, alpha=0.12, color="#4f46e5")
+    ax.plot(
+        xx_c, yy_c,
+        color="#4f46e5", linewidth=2.2,
+        label=f"Codec · {saliency_signal}  ({codec_total:,} patches)",
     )
-    ax1.set_title(
-        f"Codec selection · {saliency_signal} · {gop_str} "
-        f"({n_groups} groups) · {total_selected} patches",
-        fontsize=10, color="#1e293b",
+    ax.fill_between(xx_u, yy_u, step=None, alpha=0.10, color="#06b6d4")
+    ax.plot(
+        xx_u, yy_u,
+        color="#06b6d4", linewidth=2.2, linestyle="--",
+        label=f"Uniform baseline  ({uni_total:,} patches)",
     )
-    ax1.set_xlabel("time (s)", fontsize=9)
-    ax1.set_ylabel("# patches selected", fontsize=9)
-    ax1.set_xlim(-duration * 0.02, duration * 1.02)
-    ax1.tick_params(axis="both", labelsize=8)
-    ax1.grid(True, alpha=0.25, linestyle="--", axis="y")
-    ax1.spines[["top", "right"]].set_visible(False)
-
-    # Group boundary lines (skip if there's just one big group).
+
+    # Budget reference line
+    budget = int(total_patches_budget)
+    ax.axhline(budget, color="#94a3b8", linestyle=":", linewidth=1.1, alpha=0.85)
+    ax.text(
+        duration * 0.995, budget * 1.015,
+        f"budget {budget:,}", color="#475569",
+        fontsize=8.5, va="bottom", ha="right",
+    )
+
+    # Group boundaries
     if groups and len(groups) > 1 and times:
         for (_, end_idx) in groups[:-1]:
             if end_idx + 1 < len(times):
                 bx = (times[end_idx] + times[end_idx + 1]) / 2.0
             else:
-                bx = times[end_idx] + bar_w
-            ax1.axvline(
-                bx, color="#94a3b8", linestyle=(0, (4, 3)),
-                alpha=0.55, linewidth=0.9,
+                bx = times[end_idx]
+            ax.axvline(
+                bx, color="#cbd5e1", linestyle=(0, (3, 3)),
+                alpha=0.55, linewidth=0.8,
             )
 
-    # ─── Right: uniform-sampling baseline at the same budget ────────────
-    n_uniform = max(1, int(total_patches_budget // max(1, grid_size)))
-    uniform_times = (
-        [duration * 0.5] if n_uniform == 1
-        else list(np.linspace(0.0, duration, n_uniform))
-    )
-    uniform_counts = [grid_size] * n_uniform
-    bar_w_u = max(duration / max(1, n_uniform) * 0.55, 0.04)
-    ax2.bar(
-        uniform_times, uniform_counts, width=bar_w_u,
-        color="#06b6d4", alpha=0.88,
-        edgecolor="#0e7490", linewidth=0.4,
-    )
-    ax2.set_title(
-        f"Uniform baseline · {n_uniform} frames × {grid_size} patches "
-        f"= {n_uniform * grid_size}",
-        fontsize=10, color="#1e293b",
+    n_groups = len(groups) if groups else 1
+    gop_str = gop_label if gop_label in ("global", "dynamic") else f"GOP={gop_label}"
+    ax.set_title(
+        f"Cumulative patches selected over time · {saliency_signal} · "
+        f"{gop_str} ({n_groups} groups)",
+        fontsize=11, color="#1e293b",
     )
-    ax2.set_xlabel("time (s)", fontsize=9)
-    ax2.set_ylabel("# patches per uniform frame", fontsize=9)
-    ax2.set_xlim(-duration * 0.02, duration * 1.02)
-    ax2.tick_params(axis="both", labelsize=8)
-    ax2.grid(True, alpha=0.25, linestyle="--", axis="y")
-    ax2.spines[["top", "right"]].set_visible(False)
+    ax.set_xlabel("time (s)", fontsize=9.5)
+    ax.set_ylabel("# patches selected (cumulative)", fontsize=9.5)
+    ax.set_xlim(-duration * 0.02, duration * 1.02)
+    ymax = max(budget, codec_total, uni_total) * 1.08 + 1
+    ax.set_ylim(0, ymax)
+    ax.tick_params(axis="both", labelsize=8.5)
+    ax.grid(True, alpha=0.25, linestyle="--", axis="y")
+    ax.spines[["top", "right"]].set_visible(False)
+    ax.legend(loc="upper left", fontsize=9, frameon=False)
 
     fig.patch.set_facecolor("white")
     return fig
@@ -1371,14 +1383,13 @@ with gr.Blocks(**_BLOCK_KW) as demo:
                 )
 
             with gr.Group(elem_classes="ovc-card ovc-card-primary"):
-                gr.Markdown("### Codec selection vs uniform baseline")
+                gr.Markdown("### Cumulative patches over time")
                 gr.Markdown(
-                    "<small>Same total patch budget on both sides. "
-                    "<b>Left</b>: where the codec saliency actually placed "
-                    "patches (often spiky, concentrated on important moments). "
-                    "<b>Right</b>: how a naive uniform frame sampler would "
-                    "spend the same budget — spread evenly in time, every "
-                    "patch in the chosen frames kept.</small>"
+                    "<small>Same total patch budget. <b>Indigo</b>: codec "
+                    "saliency cumulative count — rises in bursts on high-"
+                    "energy moments. <b>Cyan (dashed)</b>: uniform sampling "
+                    "baseline — equal-height steps at evenly-spaced times. "
+                    "Both end near the dotted <b>budget</b> reference line.</small>"
                 )
                 chart_out = gr.Plot(label="", show_label=False)