Uniform baseline: same N frames as codec, equal per-frame allocation

Before, uniform baseline sampled budget // grid_size *full* frames,
which often collapsed to 1 frame when the budget couldn't afford two
whole grids. The chart then looked lopsided — codec hit the budget
while uniform plateaued well below it.

Now both methods sample the same N frames at the same timestamps; the
patch budget is split equally per frame for the uniform side
(budget // N each, remainder distributed). Both curves end exactly at
the budget reference line, and the visual contrast becomes 'where the
patches go' (saliency-skewed vs equal-height steps) instead of 'how
many uniform frames fit'.

Chart : 16 paired step jumps; codec uneven, uniform flat-height.
JSON : 'uniform_baseline.frames' = sample_frames; 'patches_per_frame'
= budget // N (and the explanation text reflects the new
semantic).
Subtitle clarified.

app.py

@@ -621,13 +621,21 @@ def make_charts(
     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))
-    )
-    uni_cum = list(np.cumsum([grid_size] * n_uniform))
+    # Uniform baseline: same N frames as codec (at the same timestamps),
+    # but the patch budget is split equally across them. Both curves now
+    # reach the same budget — what differs is *which* patches each method
+    # picks within each frame (saliency vs equal-allocation).
+    n_uniform = len(times) if times else 1
+    budget_int = int(total_patches_budget)
+    if n_uniform > 0 and budget_int > 0:
+        base = budget_int // n_uniform
+        rem = budget_int - base * n_uniform
+        uni_per_step = [base + (1 if i < rem else 0) for i in range(n_uniform)]
+    else:
+        uni_per_step = []
+    uni_cum = list(np.cumsum(uni_per_step)) if uni_per_step else []
     uni_total = int(uni_cum[-1]) if uni_cum else 0
+    uni_times = times if times else [duration * 0.5]
     xx_u, yy_u = _step(uni_times, uni_cum)
 
     # ─── Plot ───────────────────────────────────────────────────────────
@@ -812,7 +820,12 @@ def process(
 
     hb, wb = grids[0].shape
     grid_size = int(grids[0].shape[0] * grids[0].shape[1]) if grids else 0
-    n_uniform = max(1, int(int(total_patches) // max(1, grid_size)))
+    # Uniform baseline samples the SAME number of frames as codec, evenly
+    # spaced in time; the budget is split equally across them.
+    n_uniform = max(1, len(fids))
+    uniform_per_frame = (
+        int(int(total_patches)) // n_uniform if n_uniform > 0 else 0
+    )
     info = {
         "input": meta,
         "params": {
@@ -845,12 +858,17 @@ def process(
         },
         "uniform_baseline": {
             "frames": int(n_uniform),
-            "patches_per_frame": int(grid_size),
-            "total_patches": int(n_uniform * grid_size),
+            "patches_per_frame": int(uniform_per_frame),
+            "total_patches": int(uniform_per_frame * n_uniform),
             "explanation": (
-                "Same patch budget spent on whole frames sampled uniformly in "
-                "time — every patch in those frames kept, vs codec's selective "
-                "concentration on high-saliency patches."
+                "Same N frames as codec, evenly spaced in time. The patch "
+                "budget is split equally per frame ({budget} ÷ {n} = "
+                "{per}); the codec, by contrast, concentrates the same "
+                "budget on high-saliency patches across those frames."
+            ).format(
+                budget=int(total_patches),
+                n=int(n_uniform),
+                per=int(uniform_per_frame),
             ),
         },
         "resized_frame_size": f"{tw}x{th}",
@@ -1385,11 +1403,13 @@ with gr.Blocks(**_BLOCK_KW) as demo:
             with gr.Group(elem_classes="ovc-card ovc-card-primary"):
                 gr.Markdown("### Cumulative patches over time")
                 gr.Markdown(
-                    "<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>"
+                    "<small>Same number of sampled frames and the same total "
+                    "patch budget for both methods. <b>Indigo</b>: codec "
+                    "saliency — rises in bursts where the frames carry more "
+                    "information. <b>Cyan (dashed)</b>: uniform baseline — "
+                    "the same budget split equally per frame, so each step "
+                    "has the same height. Both curves end exactly at the "
+                    "dotted <b>budget</b> reference line.</small>"
                 )
                 chart_out = gr.Plot(label="", show_label=False)