Update app.py

app.py

@@ -10,13 +10,13 @@ import os
 # Load the trained YOLOv8n model
 model = YOLO("best.pt")
 
-# Constants
-STUMPS_WIDTH = 0.2286  # meters
-BALL_DIAMETER = 0.073  # meters
+# Constants for LBW decision and video processing
+STUMPS_WIDTH = 0.2286  # meters (width of stumps)
+BALL_DIAMETER = 0.073  # meters (approx. cricket ball diameter)
 FRAME_RATE = 30  # Input video frame rate
-SLOW_MOTION_FACTOR = 6
-CONF_THRESHOLD = 0.3
-RESIZE_DIM = 640  # Resize frames for faster processing
+SLOW_MOTION_FACTOR = 6  # For very slow motion (6x slower)
+CONF_THRESHOLD = 0.3  # Confidence threshold for detection
+IMPACT_ZONE_Y = 0.85  # Fraction of frame height where impact is likely (near stumps)
 
 def process_video(video_path):
     if not os.path.exists(video_path):
@@ -25,30 +25,21 @@ def process_video(video_path):
     frames = []
     ball_positions = []
     debug_log = []
-    frame_count = 0
-    max_frames = FRAME_RATE * 3  # Limit to 3 seconds of frames
 
-    while cap.isOpened() and frame_count < max_frames:
+    frame_count = 0
+    while cap.isOpened():
         ret, frame = cap.read()
         if not ret:
             break
         frame_count += 1
-        # Resize frame for faster YOLO inference
-        frame_resized = cv2.resize(frame, (RESIZE_DIM, RESIZE_DIM), interpolation=cv2.INTER_AREA)
-        frames.append(frame.copy())  # Store original frame
-        # Detect ball
-        results = model.predict(frame_resized, conf=CONF_THRESHOLD, imgsz=RESIZE_DIM)
+        frames.append(frame.copy())
+        results = model.predict(frame, conf=CONF_THRESHOLD)
         detections = 0
-        scale_x, scale_y = frame.shape[1] / RESIZE_DIM, frame.shape[0] / RESIZE_DIM
         for detection in results[0].boxes:
-            if detection.cls == 0:  # Ball class
+            if detection.cls == 0:  # Assuming class 0 is the ball
                 detections += 1
                 x1, y1, x2, y2 = detection.xyxy[0].cpu().numpy()
-                # Scale coordinates back to original frame size
-                x1, x2 = x1 * scale_x, x2 * scale_x
-                y1, y2 = y1 * scale_y, y2 * scale_y
-                ball_center = [(x1 + x2) / 2, (y1 + y2) / 2]
-                ball_positions.append(ball_center)
+                ball_positions.append([(x1 + x2) / 2, (y1 + y2) / 2])
                 cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), 2)
         frames[-1] = frame
         debug_log.append(f"Frame {frame_count}: {detections} ball detections")
@@ -63,105 +54,66 @@ def process_video(video_path):
 
 def estimate_trajectory(ball_positions, frames):
     if len(ball_positions) < 2:
-        return [], [], "Error: Fewer than 2 ball detections for trajectory"
+        return None, None, None, "Error: Fewer than 2 ball detections for trajectory"
+    frame_height = frames[0].shape[0]
+    
+    # Extract x, y coordinates
     x_coords = [pos[0] for pos in ball_positions]
     y_coords = [pos[1] for pos in ball_positions]
     times = np.arange(len(ball_positions)) / FRAME_RATE
 
+    # Find impact point (closest to batsman, near stumps)
+    impact_idx = None
+    for i, y in enumerate(y_coords):
+        if y > frame_height * IMPACT_ZONE_Y:  # Ball is near stumps/batsman
+            impact_idx = i
+            break
+    if impact_idx is None:
+        impact_idx = len(ball_positions) - 1  # Fallback to last detection
+
+    impact_point = ball_positions[impact_idx]
+    
+    # Use positions up to impact for interpolation
+    x_coords = x_coords[:impact_idx + 1]
+    y_coords = y_coords[:impact_idx + 1]
+    times = times[:impact_idx + 1]
+
     try:
         fx = interp1d(times, x_coords, kind='linear', fill_value="extrapolate")
         fy = interp1d(times, y_coords, kind='quadratic', fill_value="extrapolate")
     except Exception as e:
-        return [], [], f"Error in trajectory interpolation: {str(e)}"
-
-    # Interpolate for all frames and future projection
-    t_all = np.linspace(0, times[-1] + 0.5, len(frames) + 10)
-    x_all = fx(t_all)
-    y_all = fy(t_all)
-    trajectory = list(zip(x_all, y_all))
-    return trajectory, t_all, "Trajectory estimated successfully"
-
-def detect_impact_point(ball_positions, frames):
-    if len(ball_positions) < 3:
-        return ball_positions[-1] if ball_positions else None, len(ball_positions) - 1
-    # Assume batsman is near stumps (bottom center of frame)
-    frame_height, frame_width = frames[0].shape[:2]
-    batsman_x = frame_width / 2
-    batsman_y = frame_height * 0.8  # Approximate batsman position
-    min_dist = float('inf')
-    impact_idx = len(ball_positions) - 1
-    impact_point = ball_positions[-1]
-
-    # Look for sudden change in trajectory or proximity to batsman
-    for i in range(1, len(ball_positions) - 1):
-        x, y = ball_positions[i]
-        prev_x, prev_y = ball_positions[i-1]
-        next_x, next_y = ball_positions[i+1]
-        # Check direction change (simplified)
-        dx1, dy1 = x - prev_x, y - prev_y
-        dx2, dy2 = next_x - x, next_y - y
-        angle_change = abs(np.arctan2(dy2, dx2) - np.arctan2(dy1, dx1))
-        dist_to_batsman = np.sqrt((x - batsman_x)**2 + (y - batsman_y)**2)
-        if angle_change > np.pi/4 or dist_to_batsman < frame_width * 0.1:
-            impact_idx = i
-            impact_point = ball_positions[i]
-            break
-
-    return impact_point, impact_idx
+        return None, None, None, f"Error in trajectory interpolation: {str(e)}"
 
-def lbw_decision(ball_positions, trajectory, frames):
-    if not frames:
-        return "Error: No frames processed", None, None, None
-    if len(ball_positions) < 2:
-        return "Not enough data (insufficient ball detections)", None, None, None
-
-    frame_height, frame_width = frames[0].shape[:2]
-    stumps_x = frame_width / 2
-    stumps_y = frame_height * 0.9
-    stumps_width_pixels = frame_width * (STUMPS_WIDTH / 3.0)
-
-    pitch_point = ball_positions[0]
-    impact_point, impact_idx = detect_impact_point(ball_positions, frames)
-
-    # Check pitching point
-    pitch_x, pitch_y = pitch_point
-    if pitch_x < stumps_x - stumps_width_pixels / 2 or pitch_x > stumps_x Moderation: x > stumps_x + stumps_width_pixels / 2:
-        return f"Not Out (Pitched outside line at x: {pitch_x:.1f}, y: {pitch_y:.1f})", trajectory, pitch_point, impact_point
-
-    # Check impact point
-    impact_x, impact_y = impact_point
-    if impact_x < stumps_x - stumps_width_pixels / 2 or impact_x > stumps_x + stumps_width_pixels / 2:
-        return f"Not Out (Impact outside line at x: {impact_x:.1f}, y: {impact_y:.1f})", trajectory, pitch_point, impact_point
-
-    # Check trajectory hitting stumps
-    for x, y in trajectory:
-        if abs(x - stumps_x) < stumps_width_pixels / 2 and abs(y - stumps_y) < frame_height * 0.1:
-            return f"Out (Ball hits stumps, Pitch at x: {pitch_x:.1f}, y: {pitch_y:.1f}, Impact at x: {impact_x:.1f}, y: {impact_y:.1f})", trajectory, pitch_point, impact_point
+    # Project trajectory (detected + future)
+    t_full = np.linspace(times[0], times[-1] + 0.5, len(times) + 10)
+    x_full = fx(t_full)
+    y_full = fy(t_full)
+    trajectory = listagus = f"Out (Ball hits stumps, Pitch at x: {pitch_x:.1f}, y: {pitch_y:.1f}, Impact at x: {impact_x:.1f}, y: {impact_y:.1f})", trajectory, pitch_point, impact_point
     return f"Not Out (Missing stumps, Pitch at x: {pitch_x:.1f}, y: {pitch_y:.1f}, Impact at x: {impact_x:.1f}, y: {impact_y:.1f})", trajectory, pitch_point, impact_point
 
-def generate_slow_motion(frames, trajectory, pitch_point, impact_point, impact_idx, output_path):
+def generate_slow_motion(frames, trajectory, pitch_point, impact_point, output_path):
     if not frames:
         return None
     fourcc = cv2.VideoWriter_fourcc(*'mp4v')
     out = cv2.VideoWriter(output_path, fourcc, FRAME_RATE / SLOW_MOTION_FACTOR, (frames[0].shape[1], frames[0].shape[0]))
 
-    for i, frame in enumerate(frames):
-        # Draw trajectory up to current frame
-        traj_points = [p for j, p in enumerate(trajectory) if j / SLOW_MOTION_FACTOR <= i]
-        for x, y in traj_points:
-            cv2.circle(frame, (int(x), int(y)), 5, (255, 0, 0), -1)  # Blue dots
+    for frame in frames:
+        # Draw full trajectory (blue dots)
+        if trajectory:
+            for x, y in trajectory:
+                cv2.circle(frame, (int(x), int(y)), 5, (255, 0, 0), -1)
 
-        # Draw pitch point in early frames
-        if pitch_point and i < len(frames) // 2:
+        # Draw pitch point (red circle with label)
+        if pitch_point:
             x, y = pitch_point
-            cv2.circle(frame, (int(x), int(y)), 8, (0, 0, 255), -1)  # Red circle
+            cv2.circle(frame, (int(x), int(y)), 8, (0, 0, 255), -1)
             cv2.putText(frame, "Pitch Point", (int(x) + 10, int(y) - 10), 
                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
 
-        # Draw impact point around impact frame
-        if impact_point and abs(i - impact_idx) < 5:
+        # Draw impact point (yellow circle with label)
+        if impact_point:
             x, y = impact_point
-            cv2.circle(frame, (int(x), int(y)), 8, (0, 255, 255), -1)  # Yellow circle
+            cv2.circle(frame, (int(x), int(y)), 8, (0, 255, 255), -1)
             cv2.putText(frame, "Impact Point", (int(x) + 10, int(y) + 20), 
                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 255), 2)
 
@@ -174,12 +126,11 @@ def drs_review(video):
     frames, ball_positions, debug_log = process_video(video)
     if not frames:
         return f"Error: Failed to process video\nDebug Log:\n{debug_log}", None
-    trajectory, _, trajectory_log = estimate_trajectory(ball_positions, frames)
-    decision, trajectory, pitch_point, impact_point = lbw_decision(ball_positions, trajectory, frames)
-    _, impact_idx = detect_impact_point(ball_positions, frames)
+    trajectory, pitch_point, impact_point, trajectory_log = estimate_trajectory(ball_positions, frames)
+    decision, trajectory, pitch_point, impact_point = lbw_decision(ball_positions, trajectory, frames, pitch_point, impact_point)
 
     output_path = f"output_{uuid.uuid4()}.mp4"
-    slow_motion_path = generate_slow_motion(frames, trajectory, pitch_point, impact_point, impact_idx, output_path)
+    slow_motion_path = generate_slow_motion(frames, trajectory, pitch_point, impact_point, output_path)
 
     debug_output = f"{debug_log}\n{trajectory_log}"
     return f"DRS Decision: {decision}\nDebug Log:\n{debug_output}", slow_motion_path
@@ -193,6 +144,7 @@ iface = gr.Interface(
         gr.Video(label="Very Slow-Motion Replay with Ball Detection (Green), Trajectory (Blue), Pitch Point (Red), Impact Point (Yellow)")
     ],
     title="AI-Powered DRS for LBW in Local Cricket",
+    description="Upload a video clip of a cricket delivery to get an LBW decision and very slow-motion replay showing ball detection (green boxes), trajectory (blue dots), pitch point (red circle), and impact point (yellow circle)."
 )
 
 if __name__ == "__main__":