removing dead code

src/detection/__init__.py

@@ -10,7 +10,7 @@ from .models import (
     TimeoutRegionConfig,
     TimeoutReading,
 )
-from .scorebug import DetectScoreBug, create_template_from_frame
+from .scorebug import DetectScoreBug
 from .timeouts import DetectTimeouts
 
 __all__ = [
@@ -20,7 +20,6 @@ __all__ = [
     "TimeoutReading",
     # Scorebug detection
     "DetectScoreBug",
-    "create_template_from_frame",
     # Timeout tracking
     "DetectTimeouts",
 ]

src/detection/scorebug.py

@@ -405,18 +405,3 @@ class DetectScoreBug:
             cv2.putText(vis_frame, text, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2)
 
         return vis_frame
-
-
-def create_template_from_frame(frame: np.ndarray[Any, Any], bbox: Tuple[int, int, int, int], output_path: str) -> None:
-    """
-    Extract a region from a frame to use as a template.
-
-    Args:
-        frame: Source frame
-        bbox: Bounding box (x, y, width, height)
-        output_path: Path to save the template image
-    """
-    x, y, w, h = bbox
-    template = frame[y : y + h, x : x + w]
-    cv2.imwrite(output_path, template)
-    logger.info("Created template: %s (size: %dx%d)", output_path, w, h)

src/detection/timeout_calibrator.py

@@ -228,52 +228,6 @@ def _validate_oval_pattern(ovals: List[OvalLocation]) -> bool:
     return True
 
 
-def check_oval_brightness(
-    frame: np.ndarray[Any, Any],
-    region_bbox: Tuple[int, int, int, int],
-    oval: OvalLocation,
-    brightness_threshold_ratio: float = 0.5,
-) -> Tuple[bool, float]:
-    """
-    Check if a specific oval is still bright (timeout available).
-
-    Args:
-        frame: Full video frame (BGR format)
-        region_bbox: Bounding box of the timeout region (x, y, width, height)
-        oval: OvalLocation to check
-        brightness_threshold_ratio: Ratio of baseline brightness below which oval is considered "dark"
-
-    Returns:
-        Tuple of (is_bright, current_brightness)
-        - is_bright: True if oval is still bright (timeout available), False if dark (used)
-        - current_brightness: Current mean brightness value
-    """
-    rx, ry, _, _ = region_bbox
-
-    # Calculate absolute position in frame
-    abs_x = rx + oval.x
-    abs_y = ry + oval.y
-
-    # Validate bounds
-    frame_h, frame_w = frame.shape[:2]
-    if abs_x < 0 or abs_y < 0 or abs_x + oval.width > frame_w or abs_y + oval.height > frame_h:
-        logger.warning("Oval position out of bounds")
-        return False, 0.0
-
-    # Extract the oval region
-    oval_roi = frame[abs_y : abs_y + oval.height, abs_x : abs_x + oval.width]
-
-    # Convert to grayscale and calculate mean brightness
-    gray = cv2.cvtColor(oval_roi, cv2.COLOR_BGR2GRAY)
-    current_brightness = float(np.mean(np.asarray(gray)))
-
-    # Compare to baseline
-    threshold = oval.baseline_brightness * brightness_threshold_ratio
-    is_bright = current_brightness >= threshold
-
-    return is_bright, current_brightness
-
-
 def visualize_calibration(
     frame: np.ndarray[Any, Any],
     calibrated_region: CalibratedTimeoutRegion,

src/readers/__init__.py

@@ -17,10 +17,7 @@ from .models import (
     TemplatePlayClockReading,
 )
 from .flags import FlagReader
-from .playclock import (
-    ReadPlayClock,
-    backfill_missing_readings,
-)
+from .playclock import ReadPlayClock
 
 
 class FlagConfig(Protocol):  # pylint: disable=too-few-public-methods
@@ -66,5 +63,4 @@ __all__ = [
     "create_flag_reader",
     # Play clock reading
     "ReadPlayClock",
-    "backfill_missing_readings",
 ]

src/readers/playclock.py

@@ -381,163 +381,3 @@ class ReadPlayClock:
         region = frame[y : y + h, x : x + w].copy()
 
         return self.read(region)
-
-
-# =============================================================================
-# Gap Interpolation
-# =============================================================================
-
-
-def _find_gap_extent(readings: List[PlayClockReading], start_idx: int) -> int:
-    """Find the end index of a gap starting at start_idx."""
-    gap_end = start_idx
-    while gap_end < len(readings) and (not readings[gap_end].detected or readings[gap_end].value is None):
-        gap_end += 1
-    return gap_end
-
-
-def _validate_gap_boundaries(readings: List[PlayClockReading], gap_start: int, gap_end: int, max_gap_seconds: int) -> Tuple[bool, int, int, int]:
-    """
-    Validate that a gap can be backfilled.
-
-    Returns:
-        Tuple of (is_valid, left_value, right_value, seconds_gap).
-        is_valid is False if gap cannot be backfilled.
-    """
-    # Check if we have valid readings on both sides
-    if gap_start == 0:
-        logger.debug("Gap at start of sequence (index 0), no left side for backfill")
-        return False, 0, 0, 0
-
-    if gap_end >= len(readings):
-        logger.debug("Gap at end of sequence (index %d), no right side for backfill", gap_start)
-        return False, 0, 0, 0
-
-    # Get the clock values on either side
-    left_value = readings[gap_start - 1].value
-    right_value = readings[gap_end].value
-
-    if left_value is None or right_value is None:
-        logger.debug("Adjacent values are None, cannot backfill")
-        return False, 0, 0, 0
-
-    # Left should be higher than right in a countdown
-    if left_value <= right_value:
-        logger.debug("Invalid countdown: left=%d not greater than right=%d", left_value, right_value)
-        return False, 0, 0, 0
-
-    seconds_gap = left_value - right_value - 1
-
-    # Check if gap in seconds is within our limit
-    if seconds_gap > max_gap_seconds:
-        logger.debug(
-            "Gap of %d seconds (left=%d, right=%d) exceeds max_gap_seconds=%d, skipping backfill",
-            seconds_gap,
-            left_value,
-            right_value,
-            max_gap_seconds,
-        )
-        return False, 0, 0, 0
-
-    return True, left_value, right_value, seconds_gap
-
-
-def _backfill_interpolate(result: List[PlayClockReading], gap_start: int, gap_frame_count: int, left_value: int, right_value: int) -> None:
-    """Backfill a gap using nearest value interpolation (no missing clock values)."""
-    logger.debug("No missing clock values between %d and %d, using nearest value interpolation", left_value, right_value)
-    for j in range(gap_frame_count):
-        # Use left value for first half, right value for second half
-        backfill_value = left_value if j < gap_frame_count / 2 else right_value
-        result[gap_start + j] = PlayClockReading(
-            detected=True,
-            value=backfill_value,
-            confidence=0.0,
-            raw_text=f"BACKFILLED_{backfill_value}",
-        )
-
-
-def _backfill_with_missing_values(result: List[PlayClockReading], gap_start: int, gap_end: int, left_value: int, right_value: int) -> None:
-    """Backfill a gap by distributing missing clock values across frames."""
-    gap_frame_count = gap_end - gap_start
-    missing_values = list(range(left_value - 1, right_value, -1))
-
-    logger.info(
-        "Backfilling gap: frames %d-%d, clock values %d to %d, missing values: %s",
-        gap_start,
-        gap_end - 1,
-        left_value,
-        right_value,
-        missing_values,
-    )
-
-    for j in range(gap_frame_count):
-        # Calculate which missing value this frame should have
-        position = j / gap_frame_count
-        value_index = min(int(position * len(missing_values)), len(missing_values) - 1)
-        backfill_value = missing_values[value_index]
-
-        result[gap_start + j] = PlayClockReading(
-            detected=True,
-            value=backfill_value,
-            confidence=0.0,
-            raw_text=f"BACKFILLED_{backfill_value}",
-        )
-        logger.debug("  Backfilled index %d with value %d", gap_start + j, backfill_value)
-
-
-def backfill_missing_readings(readings: List[PlayClockReading], max_gap_seconds: int = 3) -> List[PlayClockReading]:
-    """
-    Backfill missing play clock readings when there's a clear countdown sequence with gaps.
-
-    This function fills in missing readings when:
-    1. The gap in clock VALUES is 1-3 seconds (configurable via max_gap_seconds)
-    2. There's at least one valid reading on EACH side of the gap
-    3. The readings form a valid countdown sequence
-
-    Since the video may be sampled at higher than 1fps, each clock value may appear
-    multiple times. This function looks at the actual clock values, not frame indices.
-
-    Examples (showing clock values, with ? for undetected):
-        - [6, 6, 5, 5, ?, ?, 3, 3] → missing value is 4, backfill the gaps
-        - [10, 9, ?, ?, ?] → no backfill (no right side continuation)
-        - [6, 6, ?, ?, ?, ?, ?, 0, 0] → no backfill if gap > max_gap_seconds
-
-    Args:
-        readings: List of PlayClockReading objects (in chronological order)
-        max_gap_seconds: Maximum number of missing SECONDS to backfill (default: 3)
-
-    Returns:
-        New list with backfilled readings (original list is not modified)
-    """
-    if not readings:
-        return readings
-
-    result = list(readings)
-    i = 0
-
-    while i < len(result):
-        # Skip if this reading is valid
-        if result[i].detected and result[i].value is not None:
-            i += 1
-            continue
-
-        # Found a missing reading - find the extent of the gap
-        gap_start = i
-        gap_end = _find_gap_extent(result, i)
-        gap_frame_count = gap_end - gap_start
-
-        # Validate that we can backfill this gap
-        is_valid, left_value, right_value, seconds_gap = _validate_gap_boundaries(result, gap_start, gap_end, max_gap_seconds)
-        if not is_valid:
-            i = gap_end
-            continue
-
-        # Perform the backfill
-        if seconds_gap <= 0:
-            _backfill_interpolate(result, gap_start, gap_frame_count, left_value, right_value)
-        else:
-            _backfill_with_missing_values(result, gap_start, gap_end, left_value, right_value)
-
-        i = gap_end
-
-    return result

src/tracking/__init__.py

@@ -29,7 +29,6 @@ from .models import (
     NormalTrackerState,
     PlayEvent,
     PlayState,
-    PlayTrackingState,
     SpecialPlayHandoff,
     SpecialPlayPhase,
     SpecialTrackerState,
@@ -52,7 +51,6 @@ __all__ = [
     "NormalTrackerState",
     "PlayEvent",
     "PlayState",
-    "PlayTrackingState",
     "SpecialPlayHandoff",
     "SpecialPlayPhase",
     "SpecialTrackerState",

src/tracking/models.py

@@ -15,7 +15,6 @@ from typing import Optional, List, Tuple
 
 from pydantic import BaseModel, Field
 
-
 # =============================================================================
 # Utility Functions
 # =============================================================================
@@ -141,61 +140,8 @@ class ClockResetStats(BaseModel):
     special: int = Field(0, description="Class C: Special play (injury/punt/FG/XP)")
 
 
-class PlayTrackingState(BaseModel):
-    """Internal mutable state for play tracking.
-
-    Tracks the current detection state, detected plays, and all intermediate
-    tracking variables used during play boundary detection.
-    """
-
-    # Current detection state
-    state: PlayState = Field(PlayState.IDLE, description="Current state of the play detection state machine")
-    plays: List[PlayEvent] = Field(default_factory=list, description="List of all detected plays")
-
-    # Tracking counters and values
-    play_count: int = Field(0, description="Total number of plays detected so far")
-    last_clock_value: Optional[int] = Field(None, description="Last observed play clock value")
-    last_clock_timestamp: Optional[float] = Field(None, description="Timestamp of last clock reading")
-    clock_stable_count: int = Field(0, description="Number of consecutive frames with same clock value")
-
-    # Current play tracking
-    current_play_start_time: Optional[float] = Field(None, description="Start time of the current play being tracked")
-    current_play_start_method: Optional[str] = Field(None, description="Method used to detect current play start")
-    current_play_start_clock: Optional[int] = Field(None, description="Clock value when current play started")
-    last_scorebug_timestamp: Optional[float] = Field(None, description="Timestamp of last scorebug detection")
-    direct_end_time: Optional[float] = Field(None, description="Direct end time observation (for comparison)")
-    countdown_history: List[Tuple[float, int]] = Field(default_factory=list, description="List of (timestamp, clock_value) for countdown tracking")
-    first_40_timestamp: Optional[float] = Field(None, description="When we first saw 40 in current play (for turnover detection)")
-    current_play_clock_base: int = Field(40, description="Clock base for current play (40 for normal, 25 for special teams)")
-    current_play_type: str = Field("normal", description="Type of current play being tracked: 'normal' or 'special'")
-
-    # Timeout tracking for clock reset classification
-    last_home_timeouts: Optional[int] = Field(None, description="Last observed home team timeouts")
-    last_away_timeouts: Optional[int] = Field(None, description="Last observed away team timeouts")
-    last_timeout_confidence: float = Field(0.0, description="Confidence of last timeout reading")
-    clock_reset_stats: ClockResetStats = Field(default_factory=ClockResetStats, description="Statistics about clock reset classifications")
-
-    # Pending timeout resolution (for delayed timeout detection)
-    # When 40→25 detected, we store the "before" state and check again after delay
-    pending_timeout_check_time: Optional[float] = Field(None, description="Timestamp when we should resolve pending timeout check")
-    pending_timeout_transition_time: Optional[float] = Field(None, description="Timestamp when the 40→25 transition occurred")
-    timeout_home_at_40: Optional[int] = Field(None, description="Home timeouts when clock was at 40 (before 40→25)")
-    timeout_away_at_40: Optional[int] = Field(None, description="Away timeouts when clock was at 40 (before 40→25)")
-    timeout_conf_at_40: float = Field(0.0, description="Timeout confidence when clock was at 40")
-
-    # Pending abnormal drop timeout check (silent background check)
-    # When an "abnormal clock drop" is detected (40→25 in <2s), we reject the play but silently
-    # monitor for timeout indicator changes. If a timeout is detected within 4-10s, we retroactively create a timeout play.
-    pending_abnormal_drop_timestamp: Optional[float] = Field(None, description="When the 40→25 occurred for abnormal drop")
-    pending_abnormal_drop_check_start: Optional[float] = Field(None, description="When to start checking for timeout (4s after)")
-    pending_abnormal_drop_check_end: Optional[float] = Field(None, description="When to stop checking for timeout (10s after)")
-    pending_abnormal_drop_home_at_40: Optional[int] = Field(None, description="Home timeouts before the abnormal drop")
-    pending_abnormal_drop_away_at_40: Optional[int] = Field(None, description="Away timeouts before the abnormal drop")
-    pending_abnormal_drop_conf_at_40: float = Field(0.0, description="Confidence of timeout reading before abnormal drop")
-
-
 # =============================================================================
-# New state models for restructured tracker architecture
+# State models for restructured tracker architecture
 # =============================================================================
 
 

src/ui/__init__.py

@@ -22,7 +22,6 @@ from .sessions import (
 
 # Public API
 from .api import (
-    calibrate_timeout_region,
     extract_sample_frames_for_selection,
     get_video_path_from_user,
     print_banner,
@@ -47,7 +46,6 @@ __all__ = [
     "ScorebugSelectionSession",
     "TimeoutSelectionSession",
     # Public API
-    "calibrate_timeout_region",
     "extract_sample_frames_for_selection",
     "get_video_path_from_user",
     "print_banner",

src/ui/api.py

@@ -13,8 +13,6 @@ import cv2
 import numpy as np
 
 from video.frame_extractor import extract_sample_frames
-from detection.timeout_calibrator import calibrate_timeout_ovals, visualize_calibration
-from detection.models import CalibratedTimeoutRegion
 
 from .models import BBox
 from .sessions import FlagRegionSelectionSession, PlayClockSelectionSession, ScorebugSelectionSession, TimeoutSelectionSession
@@ -192,61 +190,6 @@ def select_flag_region(selected_frame: Tuple[float, np.ndarray[Any, Any]], score
     return bbox.to_tuple() if bbox else None
 
 
-def calibrate_timeout_region(
-    frame: np.ndarray[Any, Any],
-    region_bbox: Tuple[int, int, int, int],
-    team: str,
-    timestamp: float = 0.0,
-    show_visualization: bool = True,
-) -> Optional[CalibratedTimeoutRegion]:
-    """
-    Calibrate a timeout region by detecting oval positions.
-
-    This function should be called after region selection to find the precise
-    locations of the 3 timeout indicator ovals within the region.
-
-    Args:
-        frame: Video frame (BGR format) where all 3 timeouts should be visible.
-        region_bbox: Timeout region bounding box (x, y, width, height).
-        team: "home" or "away".
-        timestamp: Video timestamp for reference.
-        show_visualization: Whether to display the calibration result.
-
-    Returns:
-        CalibratedTimeoutRegion with discovered oval positions, or None if calibration failed.
-    """
-    logger.info("Calibrating %s timeout region at timestamp %.1fs", team, timestamp)
-
-    # Run calibration
-    calibrated = calibrate_timeout_ovals(frame, region_bbox, team, timestamp)
-
-    if calibrated is None:
-        logger.error("Calibration failed for %s timeout region", team)
-        return None
-
-    if len(calibrated.ovals) == 0:
-        logger.error("No ovals detected in %s timeout region", team)
-        return None
-
-    # Log results
-    logger.info("Calibrated %s timeout region: %d ovals found", team, len(calibrated.ovals))
-    for i, oval in enumerate(calibrated.ovals):
-        logger.info("  Oval %d: pos=(%d,%d) size=%dx%d brightness=%.1f", i + 1, oval.x, oval.y, oval.width, oval.height, oval.baseline_brightness)
-
-    # Show visualization if requested
-    if show_visualization:
-        vis_frame = visualize_calibration(frame, calibrated)
-        window_name = f"{team.upper()} Timeout Calibration"
-        cv2.namedWindow(window_name, cv2.WINDOW_NORMAL)
-        cv2.resizeWindow(window_name, 800, 600)
-        cv2.imshow(window_name, vis_frame)
-        print(f"\n{team.upper()} timeout calibration complete. Press any key to continue...")
-        cv2.waitKey(0)
-        cv2.destroyWindow(window_name)
-
-    return calibrated
-
-
 def get_video_path_from_user(project_root: Path) -> Optional[str]:
     """
     Prompt user to enter video file path.

src/utils/__init__.py

@@ -18,7 +18,6 @@ from .logging import (
     log_flag_plays,
     log_play_complete,
     log_play_created,
-    log_clock_transition,
 )
 
 __all__ = [
@@ -37,5 +36,4 @@ __all__ = [
     "log_flag_plays",
     "log_play_complete",
     "log_play_created",
-    "log_clock_transition",
 ]

src/utils/logging.py

@@ -99,36 +99,3 @@ def log_play_created(
             play.end_time,
             duration,
         )
-
-
-def log_clock_transition(
-    timestamp: float,
-    time_at_40: float,
-    action: str,
-    logger_instance: logging.Logger,
-    to_clock: int = 25,
-) -> None:
-    """
-    Log 40→25 clock transition events.
-
-    Replaces 5-6 line logging blocks like:
-        logger.info(
-            "40→25 transition at %.1fs (%.1fs at 40). Handing off for timeout check.",
-            timestamp, time_at_40,
-        )
-
-    Args:
-        timestamp: When the transition occurred
-        time_at_40: How long clock was at 40 before transitioning
-        action: Description of what's happening ("handoff for timeout check",
-                "mid-play, signaling handoff", etc.)
-        logger_instance: Logger to use for output
-        to_clock: Target clock value (default 25)
-    """
-    logger_instance.info(
-        "40→%d transition at %.1fs (%.1fs at 40). %s.",
-        to_clock,
-        timestamp,
-        time_at_40,
-        action,
-    )

src/video/__init__.py

@@ -1,6 +1,6 @@
 """Video processing modules for frame extraction and FFmpeg operations."""
 
-from .frame_extractor import extract_sample_frames, get_video_duration, get_video_fps
+from .frame_extractor import extract_sample_frames, get_video_duration
 from .frame_reader import ThreadedFrameReader
 from .ffmpeg_ops import (
     extract_clip_stream_copy,
@@ -13,7 +13,6 @@ from .ffmpeg_ops import (
 __all__ = [
     "extract_sample_frames",
     "get_video_duration",
-    "get_video_fps",
     "ThreadedFrameReader",
     "extract_clip_stream_copy",
     "extract_clip_reencode",

src/video/frame_extractor.py

@@ -15,28 +15,6 @@ import numpy as np
 logger = logging.getLogger(__name__)
 
 
-def get_video_fps(video_path: str) -> float:
-    """
-    Get the frames per second (FPS) of a video file.
-
-    Args:
-        video_path: Path to video file.
-
-    Returns:
-        FPS as a float.
-
-    Raises:
-        ValueError: If video cannot be opened.
-    """
-    cap = cv2.VideoCapture(video_path)
-    if not cap.isOpened():
-        raise ValueError(f"Could not open video: {video_path}")
-
-    fps = cap.get(cv2.CAP_PROP_FPS)
-    cap.release()
-    return fps
-
-
 def get_video_duration(video_path: str) -> Optional[float]:
     """
     Get duration of a video file using ffprobe.