Add goal crossbar annotation workflow

app.py

@@ -51,12 +51,14 @@ YOLO_IOU_THRESHOLD = 0.02
 PLAYER_TARGET_NAME = "person"
 PLAYER_OBJECT_ID = 2
 BALL_OBJECT_ID = 1
-OBJECT_CHOICES = [
-    ("Ball", BALL_OBJECT_ID),
-    ("Player", PLAYER_OBJECT_ID),
-]
-OBJECT_LABELS = [label for label, _ in OBJECT_CHOICES]
-OBJECT_LABEL_TO_ID = {label: obj_id for label, obj_id in OBJECT_CHOICES}
+GOAL_MODE_IDLE = "idle"
+GOAL_MODE_PLACING_FIRST = "placing_first"
+GOAL_MODE_PLACING_SECOND = "placing_second"
+GOAL_MODE_EDITING = "editing"
+GOAL_HANDLE_RADIUS_PX = 8
+GOAL_HANDLE_HIT_RADIUS_PX = 28
+GOAL_LINE_COLOR = (255, 214, 64)
+GOAL_HANDLE_FILL = (10, 10, 10)
 
 
 def get_yolo_model(model_filename: str = YOLO_DEFAULT_MODEL) -> YOLO:
@@ -174,21 +176,282 @@ def _compute_sam_window_from_kick(state: AppState, kick_frame: int | None) -> tu
     total_frames = state.num_frames
     if total_frames == 0:
         return 0, 0
+    fps = state.video_fps if state.video_fps and state.video_fps > 0 else 25.0
+    target_window_frames = max(1, int(round(fps * 4.0)))
+    half_window = target_window_frames // 2
     if kick_frame is None:
         start_idx = 0
-        end_idx = total_frames
     else:
-        fps = state.video_fps if state.video_fps and state.video_fps > 0 else 25.0
-        target_window_frames = max(1, int(round(fps * 4.0)))
-        half_window = target_window_frames // 2
         start_idx = max(0, int(kick_frame) - half_window)
-        end_idx = min(total_frames, start_idx + target_window_frames)
-        if end_idx <= start_idx:
-            end_idx = min(total_frames, start_idx + 1)
+    end_idx = min(total_frames, start_idx + target_window_frames)
+    if end_idx <= start_idx:
+        end_idx = min(total_frames, start_idx + 1)
     state.sam_window = (start_idx, end_idx)
     return start_idx, end_idx
 
 
+def _goal_frame_dims(state: AppState, frame_idx: int | None = None) -> tuple[int, int]:
+    if state is None or not state.video_frames:
+        return 1, 1
+    idx = 0 if frame_idx is None else int(np.clip(frame_idx, 0, len(state.video_frames) - 1))
+    frame = state.video_frames[idx]
+    return frame.size
+
+
+def _goal_norm_from_xy(state: AppState, frame_idx: int, x: int, y: int) -> tuple[float, float]:
+    width, height = _goal_frame_dims(state, frame_idx)
+    if width <= 0:
+        width = 1
+    if height <= 0:
+        height = 1
+    return (
+        float(np.clip(x / width, 0.0, 1.0)),
+        float(np.clip(y / height, 0.0, 1.0)),
+    )
+
+
+def _goal_xy_from_norm(state: AppState, frame_idx: int, pt: tuple[float, float]) -> tuple[int, int]:
+    width, height = _goal_frame_dims(state, frame_idx)
+    return (
+        int(round(float(pt[0]) * width)),
+        int(round(float(pt[1]) * height)),
+    )
+
+
+def _goal_points_for_drawing(state: AppState) -> list[tuple[float, float]]:
+    if state is None:
+        return []
+    if state.goal_mode in {GOAL_MODE_PLACING_FIRST, GOAL_MODE_PLACING_SECOND, GOAL_MODE_EDITING}:
+        return state.goal_points_norm
+    if state.goal_points_norm:
+        return state.goal_points_norm
+    return state.goal_confirmed_points_norm
+
+
+def _goal_clear_preview_cache(state: AppState) -> None:
+    if state is None:
+        return
+    state.composited_frames.clear()
+
+
+def _goal_has_confirmed(state: AppState) -> bool:
+    return isinstance(state, AppState) and len(state.goal_confirmed_points_norm) == 2
+
+
+def _goal_set_status(state: AppState, text: str) -> None:
+    if state is None:
+        return
+    state.goal_status_text = text
+
+
+def _goal_status_text(state: AppState) -> str:
+    if state is None:
+        return "Goal crossbar unavailable."
+    if state.goal_status_text:
+        return state.goal_status_text
+    if _goal_has_confirmed(state):
+        return "Goal crossbar confirmed. Click Start Mapping to adjust."
+    return "Goal crossbar inactive."
+
+
+def _goal_button_updates(state: AppState) -> tuple[Any, Any, Any, Any, Any]:
+    if state is None:
+        return (
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(value="Goal crossbar unavailable.", visible=True),
+        )
+    start_enabled = state.goal_mode == GOAL_MODE_IDLE
+    confirm_enabled = len(state.goal_points_norm) == 2 and state.goal_mode in {
+        GOAL_MODE_PLACING_SECOND,
+        GOAL_MODE_EDITING,
+    }
+    clear_enabled = bool(state.goal_points_norm or state.goal_confirmed_points_norm)
+    back_enabled = bool(state.goal_prev_confirmed_points_norm)
+    status_update = gr.update(value=_goal_status_text(state), visible=True)
+    return (
+        gr.update(interactive=start_enabled),
+        gr.update(interactive=confirm_enabled),
+        gr.update(interactive=clear_enabled),
+        gr.update(interactive=back_enabled),
+        status_update,
+    )
+
+
+def _goal_handle_hit_index(state: AppState, frame_idx: int, x: int, y: int) -> int | None:
+    points = state.goal_points_norm
+    if state is None or len(points) == 0:
+        return None
+    width, height = _goal_frame_dims(state, frame_idx)
+    max_dist = GOAL_HANDLE_HIT_RADIUS_PX
+    for idx, pt in enumerate(points):
+        px, py = _goal_xy_from_norm(state, frame_idx, pt)
+        dist = math.hypot(px - x, py - y)
+        if dist <= max_dist:
+            return idx
+    return None
+
+
+def _goal_current_frame_idx(state: AppState) -> int:
+    if state is None or state.num_frames == 0:
+        return 0
+    idx = int(getattr(state, "current_frame_idx", 0))
+    return int(np.clip(idx, 0, state.num_frames - 1))
+
+
+def _goal_output_tuple(state: AppState, preview_img: Image.Image | None = None) -> tuple[Image.Image, Any, Any, Any, Any, Any]:
+    if state is None:
+        return (preview_img, *(gr.update(interactive=False) for _ in range(4)), gr.update(value="Goal crossbar unavailable.", visible=True))
+    idx = _goal_current_frame_idx(state)
+    if preview_img is None:
+        preview_img = update_frame_display(state, idx)
+    return (preview_img, *_goal_button_updates(state))
+
+
+def _goal_start_mapping(state: AppState) -> tuple[Image.Image, Any, Any, Any, Any, Any]:
+    if state is None or not state.video_frames:
+        raise gr.Error("Load a video first, then map the goal crossbar.")
+    state.goal_prev_confirmed_points_norm = list(state.goal_confirmed_points_norm)
+    state.goal_points_norm = []
+    state.goal_mode = GOAL_MODE_PLACING_FIRST
+    state.goal_dragging_idx = None
+    _goal_set_status(state, "Click the left goalpost to start the crossbar.")
+    _goal_clear_preview_cache(state)
+    return _goal_output_tuple(state)
+
+
+def _goal_confirm_mapping(state: AppState) -> tuple[Image.Image, Any, Any, Any, Any, Any]:
+    if state is None:
+        return (None, *_goal_button_updates(state))
+    if len(state.goal_points_norm) != 2:
+        _goal_set_status(state, "Select both goal corners before confirming.")
+        return _goal_output_tuple(state)
+    state.goal_confirmed_points_norm = list(state.goal_points_norm)
+    state.goal_mode = GOAL_MODE_IDLE
+    state.goal_dragging_idx = None
+    _goal_set_status(state, "Goal crossbar saved. Click Start Mapping to adjust again.")
+    _goal_clear_preview_cache(state)
+    return _goal_output_tuple(state)
+
+
+def _goal_clear_mapping(state: AppState) -> tuple[Image.Image, Any, Any, Any, Any, Any]:
+    if state is None:
+        return (None, *_goal_button_updates(state))
+    state.goal_points_norm = []
+    state.goal_confirmed_points_norm = []
+    state.goal_prev_confirmed_points_norm = []
+    state.goal_mode = GOAL_MODE_IDLE
+    state.goal_dragging_idx = None
+    _goal_set_status(state, "Goal crossbar cleared.")
+    _goal_clear_preview_cache(state)
+    return _goal_output_tuple(state)
+
+
+def _goal_back_mapping(state: AppState) -> tuple[Image.Image, Any, Any, Any, Any, Any]:
+    if state is None:
+        return (None, *_goal_button_updates(state))
+    if not state.goal_prev_confirmed_points_norm:
+        _goal_set_status(state, "No previous goal crossbar to restore.")
+        return _goal_output_tuple(state)
+    state.goal_confirmed_points_norm = list(state.goal_prev_confirmed_points_norm)
+    state.goal_points_norm = list(state.goal_prev_confirmed_points_norm)
+    state.goal_prev_confirmed_points_norm = []
+    state.goal_mode = GOAL_MODE_IDLE
+    state.goal_dragging_idx = None
+    _goal_set_status(state, "Restored the previous goal crossbar.")
+    _goal_clear_preview_cache(state)
+    return _goal_output_tuple(state)
+
+
+def _goal_process_preview_click(
+    state: AppState,
+    frame_idx: int,
+    evt: gr.SelectData | None,
+) -> tuple[Image.Image | None, bool]:
+    if state is None or state.goal_mode == GOAL_MODE_IDLE:
+        return None, False
+    x = y = None
+    if evt is not None:
+        try:
+            if hasattr(evt, "index") and isinstance(evt.index, (list, tuple)) and len(evt.index) == 2:
+                x, y = int(evt.index[0]), int(evt.index[1])
+            elif hasattr(evt, "value") and isinstance(evt.value, dict):
+                data = evt.value
+                if "x" in data and "y" in data:
+                    x, y = int(data["x"]), int(data["y"])
+        except Exception:
+            x = y = None
+    if x is None or y is None:
+        _goal_set_status(state, "Could not read click coordinates. Please try again.")
+        return _goal_output_tuple(state)[0], True
+
+    norm_pt = _goal_norm_from_xy(state, frame_idx, x, y)
+    points = state.goal_points_norm
+
+    if state.goal_mode == GOAL_MODE_PLACING_FIRST:
+        state.goal_points_norm = [norm_pt]
+        state.goal_mode = GOAL_MODE_PLACING_SECOND
+        _goal_set_status(state, "Click the right goalpost to finish the crossbar.")
+    elif state.goal_mode == GOAL_MODE_PLACING_SECOND:
+        handle_idx = _goal_handle_hit_index(state, frame_idx, x, y)
+        if handle_idx is not None and handle_idx < len(points):
+            state.goal_points_norm[handle_idx] = norm_pt
+            _goal_set_status(state, "Adjusted the first corner. Click the other post.")
+        else:
+            if len(points) == 0:
+                state.goal_points_norm = [norm_pt]
+                _goal_set_status(state, "Click the next goalpost to finish the crossbar.")
+            elif len(points) == 1:
+                state.goal_points_norm.append(norm_pt)
+                state.goal_mode = GOAL_MODE_EDITING
+                _goal_set_status(state, "Adjust handles if needed, then Confirm.")
+            else:
+                state.goal_points_norm[1] = norm_pt
+                state.goal_mode = GOAL_MODE_EDITING
+                _goal_set_status(state, "Adjust handles if needed, then Confirm.")
+    elif state.goal_mode == GOAL_MODE_EDITING:
+        handle_idx = _goal_handle_hit_index(state, frame_idx, x, y)
+        if handle_idx is None and len(points) == 2:
+            # fall back to whichever endpoint is closest to click
+            px0, py0 = _goal_xy_from_norm(state, frame_idx, points[0])
+            px1, py1 = _goal_xy_from_norm(state, frame_idx, points[1])
+            dist0 = math.hypot(px0 - x, py0 - y)
+            dist1 = math.hypot(px1 - x, py1 - y)
+            handle_idx = 0 if dist0 <= dist1 else 1
+        if handle_idx is not None and handle_idx < len(points):
+            state.goal_points_norm[handle_idx] = norm_pt
+            _goal_set_status(state, "Handle moved. Press Confirm to save.")
+    state.goal_points_norm = state.goal_points_norm[:2]
+    _goal_clear_preview_cache(state)
+    preview_img = update_frame_display(state, frame_idx)
+    return preview_img, True
+
+
+def _draw_goal_overlay(state: AppState, frame_idx: int, image: Image.Image) -> None:
+    if state is None or image is None:
+        return
+    points = _goal_points_for_drawing(state)
+    if not points:
+        return
+    draw = ImageDraw.Draw(image)
+    px_points = [_goal_xy_from_norm(state, frame_idx, pt) for pt in points[:2]]
+    if len(px_points) >= 2:
+        draw.line(
+            [px_points[0], px_points[1]],
+            fill=GOAL_LINE_COLOR,
+            width=4,
+        )
+    handle_radius = max(4, GOAL_HANDLE_RADIUS_PX)
+    for cx, cy in px_points:
+        bbox = [
+            (cx - handle_radius, cy - handle_radius),
+            (cx + handle_radius, cy + handle_radius),
+        ]
+        draw.ellipse(bbox, outline=GOAL_LINE_COLOR, fill=GOAL_HANDLE_FILL, width=2)
+
+
 def _perform_yolo_ball_tracking(state: AppState, progress: gr.Progress | None = None) -> None:
     if state is None or state.num_frames == 0:
         raise gr.Error("Load a video first, then track with YOLO.")
@@ -595,6 +858,12 @@ class AppState:
         self.is_sam_tracked: bool = False
         self.is_player_detected: bool = False
         self.is_player_propagated: bool = False
+        self.goal_mode: str = GOAL_MODE_IDLE
+        self.goal_points_norm: list[tuple[float, float]] = []
+        self.goal_confirmed_points_norm: list[tuple[float, float]] = []
+        self.goal_prev_confirmed_points_norm: list[tuple[float, float]] = []
+        self.goal_status_text: str = "Goal crossbar inactive."
+        self.goal_dragging_idx: int | None = None
 
     def __repr__(self):
         return f"AppState(video_frames={self.video_frames}, inference_session={self.inference_session is not None}, model={self.model is not None}, processor={self.processor is not None}, device={self.device}, dtype={self.dtype}, video_fps={self.video_fps}, masks_by_frame={self.masks_by_frame}, color_by_obj={self.color_by_obj}, clicks_by_frame_obj={self.clicks_by_frame_obj}, boxes_by_frame_obj={self.boxes_by_frame_obj}, composited_frames={self.composited_frames}, current_frame_idx={self.current_frame_idx}, current_obj_id={self.current_obj_id}, current_label={self.current_label}, current_clear_old={self.current_clear_old}, current_prompt_type={self.current_prompt_type}, pending_box_start={self.pending_box_start}, pending_box_start_frame_idx={self.pending_box_start_frame_idx}, pending_box_start_obj_id={self.pending_box_start_obj_id}, is_switching_model={self.is_switching_model}, model_repo_key={self.model_repo_key}, model_repo_id={self.model_repo_id}, session_repo_id={self.session_repo_id})"
@@ -693,6 +962,18 @@ def init_video_session(GLOBAL_STATE: gr.State, video: str | dict) -> tuple[AppSt
     GLOBAL_STATE.impact_debug_speed_kmh = []
     GLOBAL_STATE.impact_debug_speed_threshold_px = None
     GLOBAL_STATE.impact_meters_per_px = None
+    GLOBAL_STATE.goal_mode = GOAL_MODE_IDLE
+    GLOBAL_STATE.goal_points_norm = []
+    GLOBAL_STATE.goal_confirmed_points_norm = []
+    GLOBAL_STATE.goal_prev_confirmed_points_norm = []
+    GLOBAL_STATE.goal_status_text = "Goal crossbar inactive."
+    GLOBAL_STATE.goal_dragging_idx = None
+    GLOBAL_STATE.goal_mode = GOAL_MODE_IDLE
+    GLOBAL_STATE.goal_points_norm = []
+    GLOBAL_STATE.goal_confirmed_points_norm = []
+    GLOBAL_STATE.goal_prev_confirmed_points_norm = []
+    GLOBAL_STATE.goal_status_text = "Goal crossbar inactive."
+    GLOBAL_STATE.goal_dragging_idx = None
     GLOBAL_STATE.yolo_ball_centers = {}
     GLOBAL_STATE.yolo_ball_boxes = {}
     GLOBAL_STATE.yolo_ball_conf = {}
@@ -1094,6 +1375,8 @@ 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))
 
+    _draw_goal_overlay(state, frame_idx, out_img)
+
     # 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:
@@ -2138,7 +2421,7 @@ def _player_has_masks(state: AppState) -> bool:
 
 def _button_updates(state: AppState) -> tuple[Any, Any, Any]:
     yolo_ready = isinstance(state, AppState) and state.yolo_kick_frame is not None
-    propagate_main_enabled = _ball_has_masks(state)
+    propagate_main_enabled = _ball_has_masks(state) or yolo_ready
     detect_player_enabled = yolo_ready
     propagate_player_enabled = _player_has_masks(state)
     sam_tracked = isinstance(state, AppState) and getattr(state, "is_sam_tracked", False)
@@ -2167,7 +2450,7 @@ def _ball_button_updates(state: AppState) -> tuple[Any, Any]:
 
 
 def _ui_status_updates(state: AppState) -> tuple[Any, ...]:
-    return _kick_button_updates(state) + _ball_button_updates(state)
+    return _kick_button_updates(state) + _ball_button_updates(state) + _goal_button_updates(state)
 
 
 def _recompute_motion_metrics(state: AppState, target_obj_id: int = 1):
@@ -2584,15 +2867,29 @@ def _on_image_click_with_updates(
     img: Image.Image | np.ndarray,
     state: AppState,
     frame_idx: int,
-    obj_choice: str,
+    obj_id: int,
     label: str,
     clear_old: bool,
     evt: gr.SelectData,
 ):
-    obj_id = OBJECT_LABEL_TO_ID.get(obj_choice, state.current_obj_id)
-    preview_img = on_image_click(img, state, frame_idx, obj_id, label, clear_old, evt)
+    frame_idx = int(frame_idx)
+    handled_preview = None
+    handled = False
+    if state is not None and state.goal_mode != GOAL_MODE_IDLE:
+        handled_preview, handled = _goal_process_preview_click(state, frame_idx, evt)
+    if handled and handled_preview is not None:
+        preview_img = handled_preview
+    else:
+        preview_img = on_image_click(img, state, frame_idx, obj_id, label, clear_old, evt)
     propagate_main_update, detect_btn_update, propagate_player_update = _button_updates(state)
-    return preview_img, propagate_main_update, detect_btn_update, propagate_player_update
+    status_updates = _ui_status_updates(state)
+    return (
+        preview_img,
+        propagate_main_update,
+        detect_btn_update,
+        propagate_player_update,
+        *status_updates,
+    )
 
 
 @spaces.GPU()
@@ -3143,33 +3440,49 @@ BUTTON_TOOLTIPS = {
         "After a player mask exists, SAM2 propagates it within the same kick-centric window. This keeps athlete and ball masks "
         "time-synced, enabling combined overlays, exports, and analytics comparing foot position to ball contact."
     ),
-    "chart-yolo": (
-        "Visualizes YOLO’s raw measurements per frame. The green curve is estimated ball speed derived from YOLO detections, "
-        "while the purple vertical markers show frames where acceleration spikes past adaptive thresholds (potential kicks). "
-        "The dotted baselines track average motion and the magenta area plot reflects detection area/brightness—sudden drops "
-        "often indicate the ball leaving the foot. Use this chart to confirm the automatic kick pick or to spot earlier peaks."
+    "btn-goal-start": (
+        "Enters goal mapping mode so you can click the two crossbar corners. After the first click a handle appears; the second "
+        "click closes the bar and exposes draggable anchors before you confirm."
+    ),
+    "btn-goal-confirm": (
+        "Locks the currently placed crossbar across the entire video. The line and handles stay visible on every frame and can "
+        "be re-edited later by tapping Map Goal again."
     ),
-    "chart-sam": (
-        "Summarizes SAM2’s refined window. The blue line is the filtered ball speed after segmentation smoothing, the orange "
-        "line represents the Kalman innovation (how surprising each measurement is), and the magenta curve shows distance "
-        "from the starting point. Vertical guides mark the current kick frame and any manually tagged impact. Inspect this "
-        "plot to see whether SAM2 agrees with YOLO about the kick and to gauge how long the ball stays above the minimum "
-        "impact speed before fading."
+    "btn-goal-clear": (
+        "Removes the current crossbar (and any in-progress points) so you can restart the goal alignment workflow from scratch."
+    ),
+    "btn-goal-back": (
+        "Restores the previously confirmed crossbar if the latest edits missed the mark. Useful when you want to compare two "
+        "placements without re-clicking both corners."
     ),
 }
 
-def _section_info_markdown(section_label: str, entries: list[tuple[str, str]]) -> str:
-    chunks = [f"### {section_label}"]
-    for label, key in entries:
-        desc = BUTTON_TOOLTIPS.get(key, "")
-        chunks.append(f"**{label}**\n{desc}")
-    return "\n\n".join(chunks)
-
-with gr.Blocks(
-    title="SAM2 Video (Transformers) - Interactive Segmentation",
-    theme=theme,
-    css=CUSTOM_CSS,
-) as demo:
+
+def _build_tooltip_script() -> str:
+    data = json.dumps(BUTTON_TOOLTIPS)
+    return f"""
+<script>
+const KT_TOOLTIPS = {data};
+function applyKTTitles() {{
+  Object.entries(KT_TOOLTIPS).forEach(([id, text]) => {{
+    const el = document.getElementById(id);
+    if (el && !el.dataset.ktTooltip) {{
+      el.dataset.ktTooltip = "1";
+      el.setAttribute("title", text);
+    }}
+  }});
+}}
+const observer = new MutationObserver(() => applyKTTitles());
+observer.observe(document.body, {{ childList: true, subtree: true }});
+document.addEventListener("DOMContentLoaded", applyKTTitles);
+applyKTTitles();
+</script>
+"""
+
+
+TOOLTIP_SCRIPT = _build_tooltip_script()
+
+with gr.Blocks(title="SAM2 Video (Transformers) - Interactive Segmentation", theme=theme, css=CUSTOM_CSS) as demo:
     GLOBAL_STATE = gr.State(AppState())
 
     gr.Markdown(
@@ -3217,17 +3530,7 @@ with gr.Blocks(
             )
             ckpt_progress = gr.Markdown(visible=False)
             load_status = gr.Markdown(visible=True)
-            with gr.Row():
-                reset_btn = gr.Button("Reset Session", variant="secondary", elem_id="btn-reset-session")
-            with gr.Accordion("Session reset · details", open=False):
-                gr.Markdown(
-                    _section_info_markdown(
-                        "Reset workflow",
-                        [
-                            ("Reset Session", "btn-reset-session"),
-                        ],
-                    )
-                )
+            reset_btn = gr.Button("Reset Session", variant="secondary", elem_id="btn-reset-session")
         with gr.Column(scale=1):
             gr.Markdown("**Preview**")
             preview = gr.Image(
@@ -3255,31 +3558,31 @@ with gr.Blocks(
                         with gr.Row(elem_classes=["model-status"]):
                             manual_kick_btn = gr.Button("⚽: N/A", interactive=False)
                             manual_impact_btn = gr.Button("🚩: N/A", interactive=False)
-                    with gr.Accordion("Tap & prompt settings", open=True):
-                        object_selector = gr.Radio(
-                            label="Tap target",
-                            choices=OBJECT_LABELS,
-                            value=OBJECT_LABELS[0],
-                            info="Future clicks on the preview will be assigned to this object.",
-                        )
-                        with gr.Row():
-                            label_radio = gr.Radio(
-                                choices=["positive", "negative"],
-                                value="positive",
-                                label="Point label",
+                        with gr.Row(elem_classes=["model-actions"]):
+                            goal_start_btn = gr.Button(
+                                "Map Goal",
+                                variant="secondary",
+                                elem_id="btn-goal-start",
+                            )
+                            goal_confirm_btn = gr.Button(
+                                "Confirm",
+                                variant="primary",
+                                interactive=False,
+                                elem_id="btn-goal-confirm",
+                            )
+                            goal_clear_btn = gr.Button(
+                                "Clear",
+                                variant="secondary",
+                                interactive=False,
+                                elem_id="btn-goal-clear",
                             )
-                            clear_old_chk = gr.Checkbox(value=False, label="Clear old inputs for this object")
-                        prompt_type = gr.Radio(choices=["Points", "Boxes"], value="Points", label="Prompt type")
-                    with gr.Accordion("Manual controls · details", open=False):
-                        gr.Markdown(
-                            _section_info_markdown(
-                                "Manual controls",
-                                [
-                                    ("⚽ Mark Kick", "btn-mark-kick"),
-                                    ("🚩 Mark Impact", "btn-mark-impact"),
-                                ],
+                            goal_back_btn = gr.Button(
+                                "Back",
+                                variant="secondary",
+                                interactive=False,
+                                elem_id="btn-goal-back",
                             )
-                        )
+                        goal_status = gr.Markdown("Goal crossbar inactive.", elem_id="goal-status-text")
                 with gr.Column(elem_classes=["model-section"]):
                     with gr.Row(elem_classes=["model-row"]):
                         gr.Markdown("YOLO13", elem_classes=["model-label"])
@@ -3296,18 +3599,6 @@ with gr.Blocks(
                             yolo_kick_btn = gr.Button("⚽: N/A", interactive=False)
                             yolo_impact_btn = gr.Button("🚩: N/A", interactive=False)
                     yolo_plot = gr.Plot(label="YOLO kick diagnostics", show_label=True)
-                    with gr.Accordion("YOLO13 workflow · details", open=False):
-                        gr.Markdown(
-                            _section_info_markdown(
-                                "YOLO13 workflow",
-                                [
-                                    ("Detect Ball", "btn-detect-ball"),
-                                    ("Track Ball", "btn-track-ball-yolo"),
-                                    ("Detect Player", "btn-detect-player"),
-                                ],
-                            )
-                        )
-                        gr.Markdown(f"#### YOLO kick diagnostics chart\n{BUTTON_TOOLTIPS['chart-yolo']}")
                 with gr.Column(elem_classes=["model-section"]):
                     with gr.Row(elem_classes=["model-row"]):
                         gr.Markdown("SAM2", elem_classes=["model-label"])
@@ -3325,17 +3616,7 @@ with gr.Blocks(
                             sam_kick_btn = gr.Button("⚽: N/A", interactive=False)
                             sam_impact_btn = gr.Button("🚩: N/A", interactive=False)
                     kick_plot = gr.Plot(label="Kick & impact diagnostics", show_label=True)
-                    with gr.Accordion("SAM2 tracking · details", open=False):
-                        gr.Markdown(
-                            _section_info_markdown(
-                                "SAM2 tracking",
-                                [
-                                    ("Track Ball", "btn-track-ball-sam"),
-                                    ("Track Player", "btn-track-player-sam"),
-                                ],
-                            )
-                        )
-                        gr.Markdown(f"#### Kick & impact diagnostics chart\n{BUTTON_TOOLTIPS['chart-sam']}")
+                gr.HTML(value=TOOLTIP_SCRIPT, visible=False)
             with gr.Row():
                 min_impact_speed_slider = gr.Slider(
                     label="Min impact speed (km/h)",
@@ -3356,6 +3637,11 @@ with gr.Blocks(
             ball_status = gr.Markdown(visible=False)
             propagate_status = gr.Markdown(visible=True)
             impact_status = gr.Markdown("Impact frame: not computed", visible=False)
+            with gr.Row():
+                obj_id_inp = gr.Number(value=1, precision=0, label="Object ID", scale=0)
+                label_radio = gr.Radio(choices=["positive", "negative"], value="positive", label="Point label")
+                clear_old_chk = gr.Checkbox(value=False, label="Clear old inputs for this object")
+                prompt_type = gr.Radio(choices=["Points", "Boxes"], value="Points", label="Prompt type")
     # Wire events
     def _on_video_change(GLOBAL_STATE: gr.State, video):
         GLOBAL_STATE, min_idx, max_idx, first_frame, status = init_video_session(GLOBAL_STATE, video)
@@ -3373,10 +3659,6 @@ with gr.Blocks(
             propagate_main_update,
             detect_btn_update,
             propagate_player_update,
-            gr.update(value=OBJECT_LABELS[0]),
-            gr.update(value="positive", visible=True, interactive=True),
-            gr.update(value=False, interactive=True),
-            gr.update(value="Points"),
         )
 
     video_in.change(
@@ -3398,13 +3680,14 @@ with gr.Blocks(
             manual_impact_btn,
             detect_ball_btn,
             track_ball_yolo_btn,
+            goal_start_btn,
+            goal_confirm_btn,
+            goal_clear_btn,
+            goal_back_btn,
+            goal_status,
             propagate_btn,
             detect_player_btn,
             propagate_player_btn,
-            object_selector,
-            label_radio,
-            clear_old_chk,
-            prompt_type,
         ],
         show_progress=True,
     )
@@ -3434,13 +3717,14 @@ with gr.Blocks(
                 manual_impact_btn,
                 detect_ball_btn,
                 track_ball_yolo_btn,
+                goal_start_btn,
+                goal_confirm_btn,
+                goal_clear_btn,
+                goal_back_btn,
+                goal_status,
                 propagate_btn,
                 detect_player_btn,
                 propagate_player_btn,
-            object_selector,
-            label_radio,
-            clear_old_chk,
-            prompt_type,
             ],
             label="Examples",
             cache_examples=False,
@@ -3732,6 +4016,11 @@ with gr.Blocks(
             manual_impact_btn,
             detect_ball_btn,
             track_ball_yolo_btn,
+            goal_start_btn,
+            goal_confirm_btn,
+            goal_clear_btn,
+            goal_back_btn,
+            goal_status,
         ],
     )
     mark_impact_btn.click(
@@ -3753,15 +4042,20 @@ with gr.Blocks(
             manual_impact_btn,
             detect_ball_btn,
             track_ball_yolo_btn,
+            goal_start_btn,
+            goal_confirm_btn,
+            goal_clear_btn,
+            goal_back_btn,
+            goal_status,
         ],
     )
 
-    def _sync_object_choice(s: AppState, choice: str):
-        if s is not None and choice in OBJECT_LABEL_TO_ID:
-            s.current_obj_id = OBJECT_LABEL_TO_ID[choice]
+    def _sync_obj_id(s: AppState, oid):
+        if s is not None and oid is not None:
+            s.current_obj_id = int(oid)
         return gr.update()
 
-    object_selector.change(_sync_object_choice, inputs=[GLOBAL_STATE, object_selector], outputs=[])
+    obj_id_inp.change(_sync_obj_id, inputs=[GLOBAL_STATE, obj_id_inp], outputs=[])
 
     def _sync_label(s: AppState, lab: str):
         if s is not None and lab is not None:
@@ -3830,7 +4124,7 @@ with gr.Blocks(
 
     def _auto_detect_ball(
         state_in: AppState,
-        obj_choice: str,
+        obj_id,
         label_value: str,
         clear_old_value: bool,
     ):
@@ -3862,8 +4156,7 @@ with gr.Blocks(
         frame_width, frame_height = frame.size
         x_center = max(0, min(frame_width - 1, int(x_center)))
         y_center = max(0, min(frame_height - 1, int(y_center)))
-        obj_id_int = OBJECT_LABEL_TO_ID.get(obj_choice, state_in.current_obj_id)
-        state_in.current_obj_id = obj_id_int
+        obj_id_int = int(obj_id) if obj_id is not None else state_in.current_obj_id
         label_str = label_value if label_value else state_in.current_label
         clear_old_flag = bool(clear_old_value)
 
@@ -3902,7 +4195,7 @@ with gr.Blocks(
 
     detect_ball_btn.click(
         _auto_detect_ball,
-        inputs=[GLOBAL_STATE, object_selector, label_radio, clear_old_chk],
+        inputs=[GLOBAL_STATE, obj_id_inp, label_radio, clear_old_chk],
         outputs=[
             preview,
             ball_status,
@@ -3919,6 +4212,11 @@ with gr.Blocks(
             manual_impact_btn,
             detect_ball_btn,
             track_ball_yolo_btn,
+            goal_start_btn,
+            goal_confirm_btn,
+            goal_clear_btn,
+            goal_back_btn,
+            goal_status,
         ],
     )
 
@@ -3977,6 +4275,11 @@ with gr.Blocks(
             manual_impact_btn,
             detect_ball_btn,
             track_ball_yolo_btn,
+            goal_start_btn,
+            goal_confirm_btn,
+            goal_clear_btn,
+            goal_back_btn,
+            goal_status,
         ],
     )
 
@@ -4017,10 +4320,6 @@ with gr.Blocks(
         def _result(preview_img, status_text):
             propagate_main_update, detect_btn_update, propagate_player_update = _button_updates(state_in)
             status_updates = _ui_status_updates(state_in)
-            selected_label = next(
-                (label for label, oid in OBJECT_CHOICES if oid == state_in.current_obj_id),
-                OBJECT_LABELS[0],
-            )
             return (
                 preview_img,
                 gr.update(value=status_text, visible=True),
@@ -4029,7 +4328,7 @@ with gr.Blocks(
                 propagate_main_update,
                 detect_btn_update,
                 propagate_player_update,
-                gr.update(value=selected_label),
+                gr.update(),
                 _impact_status_update(state_in),
                 *status_updates,
             )
@@ -4102,10 +4401,7 @@ with gr.Blocks(
         status_text = (
             f"{_format_kick_status(state_in)} | ✅ Player auto-detected on frame {frame_idx} (conf={conf:.2f})"
         )
-        preview_img = update_frame_display(state_in, frame_idx)
-        # Force mask overlay refresh now that the player has been stamped.
-        state_in.composited_frames.pop(frame_idx, None)
-        return _result(preview_img, status_text)
+        return _result(update_frame_display(state_in, frame_idx), status_text)
 
     detect_player_btn.click(
         _auto_detect_player,
@@ -4118,7 +4414,7 @@ with gr.Blocks(
             propagate_btn,
             detect_player_btn,
             propagate_player_btn,
-            object_selector,
+            obj_id_inp,
             impact_status,
             yolo_kick_btn,
             yolo_impact_btn,
@@ -4128,6 +4424,11 @@ with gr.Blocks(
             manual_impact_btn,
             detect_ball_btn,
             track_ball_yolo_btn,
+            goal_start_btn,
+            goal_confirm_btn,
+            goal_clear_btn,
+            goal_back_btn,
+            goal_status,
         ],
     )
 
@@ -4298,14 +4599,61 @@ with gr.Blocks(
             manual_impact_btn,
             detect_ball_btn,
             track_ball_yolo_btn,
+            goal_start_btn,
+            goal_confirm_btn,
+            goal_clear_btn,
+            goal_back_btn,
+            goal_status,
         ],
     )
 
     # Image click to add a point and run forward on that frame
     preview.select(
         _on_image_click_with_updates,
-        [preview, GLOBAL_STATE, frame_slider, object_selector, label_radio, clear_old_chk],
-        [preview, propagate_btn, detect_player_btn, propagate_player_btn],
+        [preview, GLOBAL_STATE, frame_slider, obj_id_inp, label_radio, clear_old_chk],
+        [
+            preview,
+            propagate_btn,
+            detect_player_btn,
+            propagate_player_btn,
+            yolo_kick_btn,
+            yolo_impact_btn,
+            sam_kick_btn,
+            sam_impact_btn,
+            manual_kick_btn,
+            manual_impact_btn,
+            detect_ball_btn,
+            track_ball_yolo_btn,
+            goal_start_btn,
+            goal_confirm_btn,
+            goal_clear_btn,
+            goal_back_btn,
+            goal_status,
+        ],
+    )
+
+    goal_start_btn.click(
+        _goal_start_mapping,
+        inputs=[GLOBAL_STATE],
+        outputs=[preview, goal_start_btn, goal_confirm_btn, goal_clear_btn, goal_back_btn, goal_status],
+    )
+
+    goal_confirm_btn.click(
+        _goal_confirm_mapping,
+        inputs=[GLOBAL_STATE],
+        outputs=[preview, goal_start_btn, goal_confirm_btn, goal_clear_btn, goal_back_btn, goal_status],
+    )
+
+    goal_clear_btn.click(
+        _goal_clear_mapping,
+        inputs=[GLOBAL_STATE],
+        outputs=[preview, goal_start_btn, goal_confirm_btn, goal_clear_btn, goal_back_btn, goal_status],
+    )
+
+    goal_back_btn.click(
+        _goal_back_mapping,
+        inputs=[GLOBAL_STATE],
+        outputs=[preview, goal_start_btn, goal_confirm_btn, goal_clear_btn, goal_back_btn, goal_status],
     )
 
     # Playback via MP4 rendering only
@@ -4386,6 +4734,11 @@ with gr.Blocks(
             manual_impact_btn,
             detect_ball_btn,
             track_ball_yolo_btn,
+            goal_start_btn,
+            goal_confirm_btn,
+            goal_clear_btn,
+            goal_back_btn,
+            goal_status,
         ],
     )
 
@@ -4413,6 +4766,11 @@ with gr.Blocks(
             manual_impact_btn,
             detect_ball_btn,
             track_ball_yolo_btn,
+            goal_start_btn,
+            goal_confirm_btn,
+            goal_clear_btn,
+            goal_back_btn,
+            goal_status,
         ],
     )
 

tooltips.js

@@ -1,38 +0,0 @@
-(() => {
-  function getTooltipMap() {
-    const el = document.getElementById("kt-tooltips-data");
-    if (!el) {
-      return {};
-    }
-    try {
-      return JSON.parse(el.getAttribute("data-tooltips") || "{}");
-    } catch (err) {
-      console.warn("KickTrimmer tooltip JSON parse error", err);
-      return {};
-    }
-  }
-
-  function applyTooltips() {
-    const map = getTooltipMap();
-    Object.entries(map).forEach(([id, text]) => {
-      const target = document.getElementById(id);
-      if (target && !target.dataset.ktTooltip) {
-        target.dataset.ktTooltip = "1";
-        target.setAttribute("title", text);
-      }
-    });
-  }
-
-  function initObserver() {
-    applyTooltips();
-    const observer = new MutationObserver(() => applyTooltips());
-    observer.observe(document.body, { childList: true, subtree: true });
-  }
-
-  if (document.readyState === "loading") {
-    document.addEventListener("DOMContentLoaded", initObserver);
-  } else {
-    initObserver();
-  }
-})();
-