Render ball rings as geometric circles

app.py

@@ -796,6 +796,7 @@ GHOST_TRAIL_COLOR = np.array([1.0, 0.0, 1.0], dtype=np.float32)
 GHOST_TRAIL_ALPHA = 0.55
 BALL_RING_COLOR = np.array([1.0, 0.0, 1.0], dtype=np.float32)
 BALL_RING_THICKNESS_PX = 2
+BALL_RING_COLOR_RGB = tuple(int(max(0, min(255, round(c * 255.0)))) for c in BALL_RING_COLOR.tolist())
 
 
 def _maybe_upscale_for_display(image: Image.Image) -> Image.Image:
@@ -897,9 +898,6 @@ def compose_frame(state: AppState, frame_idx: int, remove_bg: bool = False) -> I
     frame = state.video_frames[frame_idx]
     masks = state.masks_by_frame.get(frame_idx, {})
     ball_mask_raw = masks.get(BALL_OBJECT_ID)
-    ball_ring_mask: np.ndarray | None = None
-    if state.fx_ball_ring_enabled and ball_mask_raw is not None:
-        ball_ring_mask = _mask_to_ring(ball_mask_raw, BALL_RING_THICKNESS_PX)
     out_img: Image.Image | None = state.composited_frames.get(frame_idx)
     if out_img is None:
         out_img = frame
@@ -922,7 +920,12 @@ def compose_frame(state: AppState, frame_idx: int, remove_bg: bool = False) -> I
                 focus_mask = np.zeros_like(mask_np, dtype=np.float32)
             focus_mask = np.maximum(focus_mask, mask_np)
 
-    ghost_mask = _build_ball_trail_mask(state, frame_idx)
+    ghost_mask: np.ndarray | None = None
+    circle_trail: list[tuple[float, float, float]] = []
+    if state.fx_ball_ring_enabled:
+        circle_trail = _collect_ball_trail_circles(state, frame_idx)
+    else:
+        ghost_mask = _build_ball_trail_mask(state, frame_idx)
 
     if len(masks) != 0:
         if remove_bg:
@@ -958,26 +961,13 @@ def compose_frame(state: AppState, frame_idx: int, remove_bg: bool = False) -> I
                     base_np = (1.0 - alpha) * base_np + alpha * color
                     out_img = Image.fromarray(np.clip(base_np * 255.0, 0, 255).astype(np.uint8))
 
-    if state.fx_ball_ring_enabled and ball_ring_mask is not None and np.max(ball_ring_mask) > FX_EPS:
-        ring_mask = np.clip(ball_ring_mask, 0.0, 1.0)
-        if ring_mask.ndim == 3:
-            ring_mask = ring_mask.squeeze()
-        ring_pixels = ring_mask > FX_EPS
-        if np.any(ring_pixels):
-            base_np = np.array(out_img).astype(np.float32) / 255.0
-            base_np[ring_pixels] = BALL_RING_COLOR
-            out_img = Image.fromarray(np.clip(base_np * 255.0, 0, 255).astype(np.uint8))
-
     if ghost_mask is not None:
         ghost_np = np.clip(ghost_mask.astype(np.float32), 0.0, 1.0)
         if current_union_mask is not None:
             ghost_np = ghost_np * np.clip(1.0 - current_union_mask, 0.0, 1.0)
-        ghost_display = ghost_np
-        if state.fx_ball_ring_enabled:
-            ghost_display = _mask_to_ring(ghost_np, BALL_RING_THICKNESS_PX)
-        if ghost_display is not None and ghost_display.max() > FX_EPS:
+        if ghost_np.max() > FX_EPS:
             base_np = np.array(out_img).astype(np.float32) / 255.0
-            ghost_alpha = np.clip(ghost_display, 0.0, 1.0)[..., None] * GHOST_TRAIL_ALPHA
+            ghost_alpha = ghost_np[..., None] * GHOST_TRAIL_ALPHA
             base_np = (1.0 - ghost_alpha) * base_np + ghost_alpha * GHOST_TRAIL_COLOR
             if focus_mask is not None:
                 focus_alpha = np.clip(focus_mask, 0.0, 1.0)[..., None]
@@ -985,6 +975,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 state.fx_ball_ring_enabled and circle_trail:
+        draw = ImageDraw.Draw(out_img)
+        ring_width = max(1, int(round(BALL_RING_THICKNESS_PX)))
+        for cx, cy, radius in circle_trail:
+            if radius <= 1.0:
+                continue
+            left = cx - radius
+            top = cy - radius
+            right = cx + radius
+            bottom = cy + radius
+            draw.ellipse((left, top, right, bottom), outline=BALL_RING_COLOR_RGB, width=ring_width)
+
     # Draw crosses for conditioning frames only (frames with recorded clicks)
     clicks_map = state.clicks_by_frame_obj.get(frame_idx)
     if state.show_click_marks and clicks_map:
@@ -1173,6 +1175,57 @@ def _build_ball_trail_mask(state: AppState, frame_idx: int) -> np.ndarray | None
     return trail_mask
 
 
+def _collect_ball_trail_circles(state: AppState, frame_idx: int) -> list[tuple[float, float, float]]:
+    if (
+        state is None
+        or not state.fx_ghost_trail_enabled
+        or state.masks_by_frame is None
+    ):
+        return []
+    kick_candidate = state.kick_frame if state.kick_frame is not None else state.kick_debug_kick_frame
+    if kick_candidate is None:
+        return []
+
+    start_idx = max(int(kick_candidate) + 1, int(frame_idx) + 1)
+    end_idx = state.num_frames
+    if start_idx >= end_idx:
+        return []
+
+    circles: list[tuple[float, float, float]] = []
+    for idx in range(start_idx, end_idx):
+        frame_masks = state.masks_by_frame.get(idx)
+        if not frame_masks:
+            continue
+        mask = frame_masks.get(BALL_OBJECT_ID)
+        if mask is None:
+            continue
+        mask_np = np.array(mask, dtype=np.float32)
+        if mask_np.ndim == 3:
+            mask_np = mask_np.squeeze()
+        if mask_np.size == 0:
+            continue
+        mask_np = np.clip(mask_np, 0.0, 1.0)
+        if mask_np.max() <= FX_EPS:
+            continue
+        centroid = _compute_mask_centroid(mask_np)
+        if centroid is None:
+            continue
+        cx, cy = centroid
+        ys, xs = np.nonzero(mask_np > 0.05)
+        if xs.size == 0 or ys.size == 0:
+            continue
+        min_x, max_x = xs.min(), xs.max()
+        min_y, max_y = ys.min(), ys.max()
+        radius_x = (max_x - min_x + 1) / 2.0
+        radius_y = (max_y - min_y + 1) / 2.0
+        radius = float(max(radius_x, radius_y))
+        if radius <= 1.0:
+            continue
+        circles.append((float(cx), float(cy), radius))
+
+    return circles
+
+
 def _ensure_color_for_obj(state: AppState, obj_id: int):
     if obj_id not in state.color_by_obj:
         state.color_by_obj[obj_id] = pastel_color_for_object(obj_id)
@@ -1222,30 +1275,6 @@ def _apply_radial_falloff(mask: np.ndarray, strength: float = 1.0, solid_ratio:
     return np.clip(mask_np * falloff, 0.0, 1.0)
 
 
-def _mask_to_ring(mask: np.ndarray, thickness_px: int = BALL_RING_THICKNESS_PX) -> np.ndarray | None:
-    if mask is None:
-        return None
-    mask_np = np.array(mask, dtype=np.float32)
-    if mask_np.ndim == 3:
-        mask_np = mask_np.squeeze()
-    if mask_np.size == 0:
-        return None
-    mask_np = np.clip(mask_np, 0.0, 1.0)
-    if mask_np.max() <= FX_EPS:
-        return np.zeros_like(mask_np, dtype=np.float32)
-    binary = (mask_np > 0.05).astype(np.uint8)
-    thickness = max(1, int(round(thickness_px)))
-    kernel_size = thickness * 2 + 1
-    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (kernel_size, kernel_size))
-    dilated = cv2.dilate(binary, kernel)
-    eroded = cv2.erode(binary, kernel)
-    ring = cv2.subtract(dilated, eroded).astype(np.float32)
-    ring = np.clip(ring, 0.0, 1.0)
-    if np.max(ring) <= FX_EPS:
-        return np.zeros_like(mask_np, dtype=np.float32)
-    return ring
-
-
 def _update_centroids_for_frame(state: AppState, frame_idx: int):
     if state is None:
         return