Enhance ball rings with neon glow effect (additive blending)

app.py

@@ -782,21 +782,12 @@ def _speed_to_color(ratio: float) -> tuple[int, int, int]:
     return tuple(int(v) for v in blended)
 
 
-def _speed_range_color(speed_kmh: float) -> tuple[float, float, float]:
-    """Map a speed value (km/h) to the established 6-color palette, returning floats in [0,1]."""
-    if speed_kmh < 50:
-        color = (0, 191, 255)  # Electric Blue (covers <30 and 30-50)
-    elif speed_kmh < 70:
-        color = (92, 124, 250)  # Blue Violet
-    elif speed_kmh < 90:
-        color = (154, 77, 255)  # Intense Violet
-    elif speed_kmh < 110:
-        color = (214, 51, 132)  # Fuchsia
-    elif speed_kmh < 130:
-        color = (255, 77, 109)  # Strong Pink
-    else:
-        color = (255, 162, 0)  # Neon Orange
-    return tuple(channel / 255.0 for channel in color)
+def _speed_to_ring_color(speed_kmh: float) -> tuple[float, float, float]:
+    """Map a speed value (km/h) to the discrete palette used across the app."""
+    for threshold, color in SPEED_COLOR_STOPS:
+        if speed_kmh < threshold:
+            return color
+    return SPEED_COLOR_ABOVE_MAX
 
 
 def _angle_between(v1: tuple[float, float], v2: tuple[float, float]) -> float:
@@ -823,6 +814,17 @@ BALL_RING_THICKNESS_PX = 2.0  # Thinner rings
 BALL_RING_FEATHER_SIGMA = 1.0  # Less blurred
 BALL_RING_INTENSITY_GAMMA = 0.5  # Higher contrast (for < 1.0 gamma on mask values)
 
+# Speed range palette (mirrors iOS app)
+SPEED_COLOR_STOPS = [
+    (30.0, (0 / 255.0, 191 / 255.0, 255 / 255.0)),   # Electric Blue
+    (50.0, (0 / 255.0, 191 / 255.0, 255 / 255.0)),   # Electric Blue (same band)
+    (70.0, (92 / 255.0, 124 / 255.0, 250 / 255.0)),  # Blue Violet
+    (90.0, (154 / 255.0, 77 / 255.0, 255 / 255.0)),  # Intense Violet
+    (110.0, (214 / 255.0, 51 / 255.0, 132 / 255.0)), # Fuchsia
+    (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
+
 
 def _maybe_upscale_for_display(image: Image.Image) -> Image.Image:
     if image is None:
@@ -945,7 +947,7 @@ def compose_frame(state: AppState, frame_idx: int, remove_bg: bool = False) -> I
             focus_mask = np.maximum(focus_mask, mask_np)
 
     ghost_mask = _build_ball_trail_mask(state, frame_idx)
-    ring_layer = _build_ball_ring_layer(state, frame_idx)
+    ring_result = _build_ball_ring_mask(state, frame_idx)
 
     if len(masks) != 0:
         if remove_bg:
@@ -966,7 +968,7 @@ def compose_frame(state: AppState, frame_idx: int, remove_bg: bool = False) -> I
             out_img = Image.fromarray(result_np)
         else:
             overlay_masks = masks
-            if (ghost_mask is not None or ring_mask is not None) and BALL_OBJECT_ID in masks:
+            if (ghost_mask is not None or ring_result is not None) and BALL_OBJECT_ID in masks:
                 overlay_masks = {oid: mask for oid, mask in masks.items() if oid != BALL_OBJECT_ID}
             if overlay_masks:
                 out_img = overlay_masks_on_frame(out_img, overlay_masks, state.color_by_obj, alpha=0.65)
@@ -998,14 +1000,18 @@ def compose_frame(state: AppState, frame_idx: int, remove_bg: bool = False) -> I
                 base_np = focus_alpha * orig_np + (1.0 - focus_alpha) * base_np
             out_img = Image.fromarray(np.clip(base_np * 255.0, 0, 255).astype(np.uint8))
 
-    if ring_layer is not None:
-        ring_np = np.clip(ring_layer.astype(np.float32), 0.0, 1.0)
+    if ring_result is not None:
+        ring_presence, ring_color_map = ring_result
+        ring_presence = np.clip(ring_presence.astype(np.float32), 0.0, 1.0)
+        ring_color_map = np.clip(ring_color_map.astype(np.float32), 0.0, 1.0)
         if current_union_mask is not None:
-            ring_np = ring_np * np.clip(1.0 - current_union_mask, 0.0, 1.0)[..., None]
-        if ring_np.max() > FX_EPS:
+            mask_keep = np.clip(1.0 - current_union_mask, 0.0, 1.0)
+            ring_presence = ring_presence * mask_keep
+            ring_color_map = ring_color_map * mask_keep[..., None]
+        if ring_presence.max() > FX_EPS and ring_color_map.max() > FX_EPS:
             base_np = np.array(out_img).astype(np.float32) / 255.0
             alpha_val = getattr(state, "fx_ring_alpha", BALL_RING_ALPHA)
-            added_light = ring_np * alpha_val
+            added_light = np.clip(ring_color_map * alpha_val, 0.0, 1.0)
             base_np = np.clip(base_np + added_light, 0.0, 1.0)
 
             if focus_mask is not None:
@@ -1218,15 +1224,21 @@ def _build_ball_trail_mask(state: AppState, frame_idx: int) -> np.ndarray | None
     return trail_mask
 
 
-def _build_ball_ring_layer(state: AppState, frame_idx: int) -> np.ndarray | None:
+def _build_ball_ring_mask(
+    state: AppState, frame_idx: int
+) -> tuple[np.ndarray, np.ndarray] | None:
     if (
         state is None
         or not state.fx_ball_ring_enabled
         or state.masks_by_frame is None
     ):
         return None
-    kick_candidate = state.kick_frame if state.kick_frame is not None else state.kick_debug_kick_frame
-    if kick_candidate is None:
+
+    if state.kick_frame is not None:
+        kick_candidate = state.kick_frame
+    elif state.yolo_kick_frame is not None:
+        kick_candidate = state.yolo_kick_frame
+    else:
         return None
 
     start_idx = max(int(kick_candidate) + 1, int(frame_idx) + 1)
@@ -1240,7 +1252,10 @@ def _build_ball_ring_layer(state: AppState, frame_idx: int) -> np.ndarray | None
     if start_idx >= end_idx:
         return None
 
-    ring_layer: np.ndarray | 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
+    distance_m = state.goal_distance_m if state.goal_distance_m and state.goal_distance_m > 0 else 16.5
 
     # Iterate in REVERSE order so that later frames (further in time/distance) are drawn first,
     # and earlier frames (closer in time/distance) are drawn on top.
@@ -1260,10 +1275,9 @@ def _build_ball_ring_layer(state: AppState, frame_idx: int) -> np.ndarray | None
         mask_np = np.clip(mask_np, 0.0, 1.0)
         if mask_np.max() <= FX_EPS:
             continue
-        if ring_layer is None:
-            height, width = mask_np.shape
-            ring_layer = np.zeros((height, width, 3), dtype=np.float32)
-        if ring_layer.shape[:2] != mask_np.shape:
+        if ring_presence is None:
+            ring_presence = np.zeros_like(mask_np, dtype=np.float32)
+        if ring_presence.shape != mask_np.shape:
             continue
         centroid = _compute_mask_centroid(mask_np)
         if centroid is None:
@@ -1279,54 +1293,61 @@ def _build_ball_ring_layer(state: AppState, frame_idx: int) -> np.ndarray | None
         radius = float(max(radius_x, radius_y))
         if radius <= 1.5:
             continue
-        ring_mask = np.zeros_like(mask_np, dtype=np.float32)
         # Use dynamic parameters from state if available, else defaults
         thick_val = getattr(state, "fx_ring_thickness", BALL_RING_THICKNESS_PX)
-
+        
         center = (int(round(cx)), int(round(cy)))
         radius_int = max(1, int(round(radius)))
 
+        delta_frames = max(1, idx - int(kick_candidate))
+        time_s = max(delta_frames / fps, 1.0 / fps)
+        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_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_mask, center, radius_int, 0.3, thickness=t_glow)
-
+        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_mask, center, radius_int, 0.6, thickness=t_mid)
+        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_mask, center, radius_int, 1.0, thickness=t_core)
+        cv2.circle(ring_local, center, radius_int, 1.0, thickness=t_core)
 
-        # Soft blur to blend the stepped layers into a smooth gradient
         feather_val = getattr(state, "fx_ring_feather", BALL_RING_FEATHER_SIGMA)
-        ring_mask = cv2.GaussianBlur(ring_mask, (0, 0), sigmaX=feather_val, sigmaY=feather_val)
-        max_val = float(ring_mask.max())
-        if max_val <= FX_EPS:
+        ring_local = cv2.GaussianBlur(ring_local, (0, 0), sigmaX=feather_val, sigmaY=feather_val)
+        if ring_local.max() <= FX_EPS:
             continue
-        ring_mask = ring_mask / max_val
+
         gamma_val = getattr(state, "fx_ring_gamma", BALL_RING_INTENSITY_GAMMA)
         if abs(gamma_val - 1.0) > 1e-6:
-            ring_mask = np.power(np.clip(ring_mask, 0.0, 1.0), gamma_val)
-
-        # Hypothetical speed calculation
-        fps = state.video_fps if state.video_fps and state.video_fps > 1e-3 else 25.0
-        distance_m = state.goal_distance_m if state.goal_distance_m and state.goal_distance_m > 0 else 16.5
-        delta_frames = idx - int(kick_candidate)
-        if delta_frames <= 0:
-            delta_frames = 1
-        time_s = max(delta_frames / fps, 1.0 / fps)
-        speed_m_s = distance_m / time_s
-        speed_kmh = speed_m_s * 3.6
-        color_rgb = np.array(_speed_range_color(speed_kmh), dtype=np.float32)
+            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_layer = np.clip(ring_layer + ring_mask[..., None] * color_rgb, 0.0, 1.0)
+        ring_presence = np.maximum(ring_presence, ring_local)
+        ring_color_map += ring_local[..., None] * color_vec
 
-    if ring_layer is None or ring_layer.max() <= FX_EPS:
+    if (
+        ring_presence is None
+        or ring_color_map is None
+        or ring_presence.max() <= FX_EPS
+    ):
         return None
 
-    return np.clip(ring_layer, 0.0, 1.0)
+    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
 
 
 def _ensure_color_for_obj(state: AppState, obj_id: int):