Decouple cumulative chart baseline from preview resize

app.py

@@ -623,6 +623,7 @@ def make_charts(
     codec_frame_ids: List[int],
     uniform_frame_ids: List[int],
     uniform_requested_frames: int,
+    uniform_full_frame_patches: int,
     fps: float,
     total_duration_sec: float,
     total_patches_budget: int,
@@ -637,7 +638,7 @@ def make_charts(
     Y = cumulative count of selected patches
     The codec curve rises in bursts where saliency is high; the uniform
     baseline rises in equal steps because every sampled full frame
-    contributes one complete patch grid."""
+    contributes `patch_size^2` patches."""
     fig, ax = plt.subplots(figsize=(9.2, 3.6), constrained_layout=True)
 
     fps_safe = float(fps) if fps and fps > 0 else 25.0
@@ -672,11 +673,12 @@ def make_charts(
 
     # Uniform baseline: evenly sample COMPLETE frames from the same time
     # window, no codec saliency involved. Each sampled frame contributes a
-    # whole patch grid.
+    # fixed `patch_size^2` patch cost, independent of visualization resize.
     budget_int = int(total_patches_budget)
     requested_uniform = max(0, int(uniform_requested_frames))
+    full_frame_patches = max(1, int(uniform_full_frame_patches))
     n_uniform = len(uniform_frame_ids)
-    uni_per_step = [grid_size for _ in uniform_frame_ids]
+    uni_per_step = [full_frame_patches for _ in uniform_frame_ids]
     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 = [fid / fps_safe for fid in uniform_frame_ids]
@@ -700,7 +702,7 @@ def make_charts(
             if requested_uniform != n_uniform else f"{n_uniform} frames"
         )
         uni_lbl = (
-            f"Uniform full frames  ({frame_part} · {grid_size}/frame · "
+            f"Uniform full frames  ({frame_part} · {full_frame_patches}/frame · "
             f"{uni_total:,} total"
             + (f" · {unused:,} budget unused" if unused else "")
             + ")"
@@ -708,7 +710,7 @@ def make_charts(
     else:
         uni_lbl = (
             f"Uniform full frames  (0/{requested_uniform} frames fit budget "
-            f"{budget_int:,}; need {grid_size} patches/frame)"
+            f"{budget_int:,}; need {full_frame_patches} patches/frame)"
         )
 
     ax.fill_between(xx_c, yy_c, step=None, alpha=0.12, color="#4f46e5")
@@ -887,16 +889,17 @@ def process(
 
     hb, wb = grids[0].shape
     grid_size = int(grids[0].shape[0] * grids[0].shape[1]) if grids else 0
+    uniform_full_frame_patches = int(patch_size) * int(patch_size)
     # Uniform full-frame sampling baseline: evenly sample complete frames
     # from the same time window, independent of codec saliency.
     requested_budget = int(total_patches)
     uniform_requested_frames = len(fids)
     uniform_frame_count = min(
         uniform_requested_frames,
-        requested_budget // max(1, grid_size),
+        requested_budget // max(1, uniform_full_frame_patches),
     )
     uniform_frame_ids = sample_window_frame_ids(f_start, f_end, uniform_frame_count)
-    uniform_total = int(len(uniform_frame_ids) * grid_size)
+    uniform_total = int(len(uniform_frame_ids) * uniform_full_frame_patches)
     info = {
         "input": meta,
         "params": {
@@ -933,7 +936,7 @@ def process(
             "mode": "uniform_full_frame_sampling",
             "requested_frames": int(uniform_requested_frames),
             "frames": int(len(uniform_frame_ids)),
-            "patches_per_frame": int(grid_size),
+            "patches_per_frame": int(uniform_full_frame_patches),
             "frame_ids": [int(x) for x in uniform_frame_ids],
             "requested_budget": requested_budget,
             "unused_budget": int(max(0, requested_budget - uniform_total)),
@@ -942,12 +945,14 @@ def process(
                 "Uniformly sample complete frames from the same time window. "
                 f"The baseline targets the same sampled-frame count as codec "
                 f"({uniform_requested_frames}), but each full frame costs "
-                f"{grid_size} patches, so only {len(uniform_frame_ids)} full "
+                f"{uniform_full_frame_patches} patches (= patch_size^2), so "
+                f"only {len(uniform_frame_ids)} full "
                 "frames may fit inside the requested budget."
             ),
         },
         "resized_frame_size": f"{tw}x{th}",
         "patch_grid_per_frame": f"{hb}x{wb} = {hb * wb} patches",
+        "uniform_full_frame_patch_cost": int(uniform_full_frame_patches),
         "actual_selected_total": int(actual_selected),
         "total_selected_patches_incl_i_frames": int(n_selected),
         "canvases": [
@@ -973,6 +978,7 @@ def process(
     duration_sec = (total / fps) if fps > 0 else 0.0
     chart_fig = make_charts(
         grids, masks, fids, uniform_frame_ids, uniform_requested_frames,
+        uniform_full_frame_patches,
         fps, duration_sec,
         int(total_patches), saliency_signal,
         groups=groups, gop_label=gop_resolved,
@@ -1398,8 +1404,9 @@ with gr.Blocks(**_BLOCK_KW) as demo:
                     label="Total patches budget (whole video)",
                     info="The single budget shared across the whole video. "
                     "The uniform full-frame baseline will fit as many "
-                    "complete frames as this budget allows; the codec path "
-                    "spends the same budget on saliency-selected patches.",
+                    "complete frames as this budget allows, where one full "
+                    "frame costs patch_size^2 patches; the codec path spends "
+                    "the same budget on saliency-selected patches.",
                 )
                 patch_size = gr.Radio(
                     PATCH_CHOICES, value=14, label="Patch size (px)",
@@ -1484,8 +1491,10 @@ with gr.Blocks(**_BLOCK_KW) as demo:
                     "in bursts. <b>Cyan (dashed)</b>: uniform full-frame "
                     "sampling — evenly samples complete frames from the same "
                     "time window, targeting the same sampled-frame count as "
-                    "codec when the budget allows. Each step is one full "
-                    "patch grid. The dotted line marks the requested budget.</small>"
+                    "codec when the budget allows. Each step costs "
+                    "<b>patch_size^2</b> patches, regardless of the preview "
+                    "frame resolution. The dotted line marks the requested "
+                    "budget.</small>"
                 )
                 chart_out = gr.Plot(label="", show_label=False)