Enhance ball rings with neon glow effect (additive blending)

app.py

@@ -790,6 +790,39 @@ def _speed_to_ring_color(speed_kmh: float) -> tuple[float, float, float]:
     return SPEED_COLOR_ABOVE_MAX
 
 
+def _median_smooth_radii(radii: list[float]) -> list[float]:
+    if not radii:
+        return []
+    if len(radii) < 3:
+        return radii[:]
+    smoothed: list[float] = []
+    n = len(radii)
+    for i in range(n):
+        window = radii[max(0, i - 1):min(n, i + 2)]
+        smoothed.append(float(statistics.median(window)))
+    return smoothed
+
+
+def _clamp_radii(radii: list[float], clamp_ratio: float = RING_RADIUS_CLAMP_RATIO) -> list[float]:
+    if not radii:
+        return []
+    clamped: list[float] = []
+    for i, value in enumerate(radii):
+        val = max(0.0, float(value))
+        if i == 0:
+            clamped.append(val)
+            continue
+        prev = clamped[-1]
+        min_allowed = prev * (1.0 - clamp_ratio)
+        max_allowed = prev * (1.0 + clamp_ratio)
+        if prev <= FX_EPS:
+            min_allowed = 0.0
+            max_allowed = val
+        val = min(max(val, min_allowed), max_allowed)
+        clamped.append(val)
+    return clamped
+
+
 def _angle_between(v1: tuple[float, float], v2: tuple[float, float]) -> float:
     x1, y1 = v1
     x2, y2 = v2
@@ -824,6 +857,7 @@ SPEED_COLOR_STOPS = [
     (130.0, (255 / 255.0, 77 / 255.0, 109 / 255.0)), # Strong Pink
 ]
 SPEED_COLOR_ABOVE_MAX = (255 / 255.0, 162 / 255.0, 0 / 255.0)  # Neon Orange
+RING_RADIUS_CLAMP_RATIO = 0.2  # ±20%
 
 
 def _maybe_upscale_for_display(image: Image.Image) -> Image.Image:
@@ -1252,6 +1286,8 @@ def _build_ball_ring_mask(
     if start_idx >= end_idx:
         return None
 
+    ring_entries: list[tuple[int, tuple[int, int], float, np.ndarray, float]] = []
+    canvas_shape: tuple[int, int] | None = None
     ring_presence: np.ndarray | None = None
     ring_color_map: np.ndarray | None = None
     fps = state.video_fps if state.video_fps and state.video_fps > 0 else 25.0
@@ -1275,9 +1311,9 @@ def _build_ball_ring_mask(
         mask_np = np.clip(mask_np, 0.0, 1.0)
         if mask_np.max() <= FX_EPS:
             continue
-        if ring_presence is None:
-            ring_presence = np.zeros_like(mask_np, dtype=np.float32)
-        if ring_presence.shape != mask_np.shape:
+        if canvas_shape is None:
+            canvas_shape = mask_np.shape
+        if canvas_shape != mask_np.shape:
             continue
         centroid = _compute_mask_centroid(mask_np)
         if centroid is None:
@@ -1304,50 +1340,53 @@ def _build_ball_ring_mask(
         speed_kmh = max(0.0, (distance_m / time_s) * 3.6)
         color_vec = np.array(_speed_to_ring_color(speed_kmh), dtype=np.float32)
 
-        if ring_color_map is None:
-            h, w = mask_np.shape
-            ring_color_map = np.zeros((h, w, 3), dtype=np.float32)
+        ring_entries.append((idx, center, radius, color_vec, thick_val))
+
+    if not ring_entries or canvas_shape is None:
+        return None
+
+    raw_radii = [entry[2] for entry in ring_entries]
+    smoothed = _median_smooth_radii(raw_radii)
+    smoothed = _clamp_radii(smoothed)
+
+    h, w = canvas_shape
+    ring_presence = np.zeros((h, w), dtype=np.float32)
+    ring_color_map = np.zeros((h, w, 3), dtype=np.float32)
+
+    feather_val = getattr(state, "fx_ring_feather", BALL_RING_FEATHER_SIGMA)
+    gamma_val = getattr(state, "fx_ring_gamma", BALL_RING_INTENSITY_GAMMA)
+
+    for (entry, smooth_radius) in zip(ring_entries, smoothed):
+        _, center, _, color_vec, thick_val = entry
+        radius_val = max(1.0, smooth_radius)
+        radius_int = max(1, int(round(radius_val)))
+
+        ring_local = np.zeros((h, w), dtype=np.float32)
 
-        ring_local = np.zeros_like(mask_np, dtype=np.float32)
-        
-        # Multi-pass drawing for neon effect: Glow -> Mid -> Core
-        # 1. Outer Glow
         t_glow = max(1, int(round(thick_val * 4.0)))
         cv2.circle(ring_local, center, radius_int, 0.3, thickness=t_glow)
-        
-        # 2. Inner Glow
+
         t_mid = max(1, int(round(thick_val * 2.0)))
         cv2.circle(ring_local, center, radius_int, 0.6, thickness=t_mid)
 
-        # 3. Core (Sharp)
         t_core = max(1, int(round(thick_val)))
         cv2.circle(ring_local, center, radius_int, 1.0, thickness=t_core)
 
-        feather_val = getattr(state, "fx_ring_feather", BALL_RING_FEATHER_SIGMA)
         ring_local = cv2.GaussianBlur(ring_local, (0, 0), sigmaX=feather_val, sigmaY=feather_val)
         if ring_local.max() <= FX_EPS:
             continue
 
-        gamma_val = getattr(state, "fx_ring_gamma", BALL_RING_INTENSITY_GAMMA)
         if abs(gamma_val - 1.0) > 1e-6:
             ring_local = np.power(np.clip(ring_local, 0.0, 1.0), gamma_val)
 
         ring_local = np.clip(ring_local, 0.0, 1.0)
-
         ring_presence = np.maximum(ring_presence, ring_local)
         ring_color_map += ring_local[..., None] * color_vec
 
-    if (
-        ring_presence is None
-        or ring_color_map is None
-        or ring_presence.max() <= FX_EPS
-    ):
+    if ring_presence.max() <= FX_EPS or ring_color_map.max() <= FX_EPS:
         return None
 
-    ring_color_map = np.clip(ring_color_map, 0.0, 1.0)
-    ring_presence = np.clip(ring_presence, 0.0, 1.0)
-
-    return ring_presence, ring_color_map
+    return np.clip(ring_presence, 0.0, 1.0), np.clip(ring_color_map, 0.0, 1.0)
 
 
 def _ensure_color_for_obj(state: AppState, obj_id: int):