Update app.py

app.py

@@ -16,9 +16,10 @@ BALL_DIAMETER = 0.073  # meters (approx. cricket ball diameter)
 FRAME_RATE = 20  # Input video frame rate
 SLOW_MOTION_FACTOR = 3  # Adjusted for 20 FPS
 CONF_THRESHOLD = 0.25  # Confidence threshold for detection
-IMPACT_ZONE_Y = 0.85  # Fraction of frame height for impact zone
-PITCH_ZONE_Y = 0.75  # Fraction of frame height for pitch zone
+PITCH_ZONE_Y = 0.9  # Fraction of frame height for pitch zone (near stumps base)
+IMPACT_ZONE_Y = 0.8  # Fraction of frame height for impact zone (near batsman)
 IMPACT_DELTA_Y = 50  # Pixels for detecting sudden y-position change
+STUMPS_HEIGHT = 0.711  # meters (height of stumps)
 
 def process_video(video_path):
     if not os.path.exists(video_path):
@@ -26,7 +27,7 @@ def process_video(video_path):
     cap = cv2.VideoCapture(video_path)
     frames = []
     ball_positions = []
-    detection_frames = []  # Track frames with exactly one detection
+    detection_frames = []
     debug_log = []
 
     frame_count = 0
@@ -37,11 +38,11 @@ def process_video(video_path):
         frame_count += 1
         frames.append(frame.copy())
         results = model.predict(frame, conf=CONF_THRESHOLD)
-        detections = [det for det in results[0].boxes if det.cls == 0]  # Class 0 is cricketBall
-        if len(detections) == 1:  # Only consider frames with exactly one detection
+        detections = [det for det in results[0].boxes if det.cls == 0]
+        if len(detections) == 1:
             x1, y1, x2, y2 = detections[0].xyxy[0].cpu().numpy()
             ball_positions.append([(x1 + x2) / 2, (y1 + y2) / 2])
-            detection_frames.append(frame_count - 1)  # 0-based index
+            detection_frames.append(frame_count - 1)
             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}: {len(detections)} ball detections")
@@ -59,12 +60,10 @@ def estimate_trajectory(ball_positions, detection_frames, frames):
         return None, None, None, None, None, None, "Error: Fewer than 2 valid single-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.array(detection_frames) / FRAME_RATE
 
-    # Pitch point: first valid detection or when y exceeds PITCH_ZONE_Y
     pitch_idx = 0
     for i, y in enumerate(y_coords):
         if y > frame_height * PITCH_ZONE_Y:
@@ -73,10 +72,9 @@ def estimate_trajectory(ball_positions, detection_frames, frames):
     pitch_point = ball_positions[pitch_idx]
     pitch_frame = detection_frames[pitch_idx]
 
-    # Impact point: sudden y-change or y exceeds IMPACT_ZONE_Y
     impact_idx = None
     for i in range(1, len(y_coords)):
-        if (y_coords[i] > frame_height * IMPACT_ZONE_Y or
+        if (y_coords[i] > frame_height * IMPACT_ZONE_Y and
             abs(y_coords[i] - y_coords[i-1]) > IMPACT_DELTA_Y):
             impact_idx = i
             break
@@ -85,7 +83,6 @@ def estimate_trajectory(ball_positions, detection_frames, frames):
     impact_point = ball_positions[impact_idx]
     impact_frame = detection_frames[impact_idx]
 
-    # Use only detected positions for trajectory
     x_coords = x_coords[:impact_idx + 1]
     y_coords = y_coords[:impact_idx + 1]
     times = times[:impact_idx + 1]
@@ -96,10 +93,8 @@ def estimate_trajectory(ball_positions, detection_frames, frames):
     except Exception as e:
         return None, None, None, None, None, None, f"Error in trajectory interpolation: {str(e)}"
 
-    # Trajectory for visualization (detected frames only)
     vis_trajectory = list(zip(x_coords, y_coords))
 
-    # Full trajectory for LBW (includes projection)
     t_full = np.linspace(times[0], times[-1] + 0.5, len(times) + 10)
     x_full = fx(t_full)
     y_full = fy(t_full)
@@ -120,55 +115,81 @@ def lbw_decision(ball_positions, full_trajectory, frames, pitch_point, impact_po
     stumps_x = frame_width / 2
     stumps_y = frame_height * 0.9
     stumps_width_pixels = frame_width * (STUMPS_WIDTH / 3.0)
+    batsman_area_y = frame_height * 0.8  # Approximate batsman leg area
 
     pitch_x, pitch_y = pitch_point
     impact_x, impact_y = impact_point
 
-    # Check pitching point
-    if pitch_x < stumps_x - stumps_width_pixels / 2 or pitch_x > stumps_x + stumps_width_pixels / 2:
+    # LBW Conditions
+    in_line_threshold = stumps_width_pixels / 2
+    if pitch_x < stumps_x - in_line_threshold or pitch_x > stumps_x + in_line_threshold:
         return f"Not Out (Pitched outside line at x: {pitch_x:.1f}, y: {pitch_y:.1f})", full_trajectory, pitch_point, impact_point
 
-    # Check 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})", full_trajectory, pitch_point, impact_point
+    if impact_y < batsman_area_y or impact_x < stumps_x - in_line_threshold or impact_x > stumps_x + in_line_threshold:
+        return f"Not Out (Impact outside line or above batsman at x: {impact_x:.1f}, y: {impact_y:.1f})", full_trajectory, pitch_point, impact_point
 
-    # Check trajectory hitting stumps
+    hit_stumps = False
     for x, y in full_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})", full_trajectory, pitch_point, impact_point
+        if (abs(x - stumps_x) < in_line_threshold and
+            abs(y - stumps_y) < frame_height * 0.1):
+            hit_stumps = True
+            break
+
+    if hit_stumps:
+        # Check if clipping (Umpire's Call)
+        if abs(x - stumps_x) < in_line_threshold * 0.1:  # Arbitrary small margin for clipping
+            return f"Umpire's Call - Not Out (Ball clips stumps, Pitch at x: {pitch_x:.1f}, y: {pitch_y:.1f}, Impact at x: {impact_x:.1f}, y: {impact_y:.1f})", full_trajectory, pitch_point, impact_point
+        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})", full_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})", full_trajectory, pitch_point, impact_point
 
 def generate_slow_motion(frames, vis_trajectory, pitch_point, pitch_frame, impact_point, impact_frame, detection_frames, output_path):
     if not frames:
         return 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)
+    stumps_height_pixels = frame_height * (STUMPS_HEIGHT / 3.0)
 
     fourcc = cv2.VideoWriter_fourcc(*'mp4v')
     out = cv2.VideoWriter(output_path, fourcc, FRAME_RATE / SLOW_MOTION_FACTOR, (frame_width, frame_height))
 
-    # Prepare trajectory points for visualization
     trajectory_points = np.array(vis_trajectory, dtype=np.int32).reshape((-1, 1, 2))
 
     for i, frame in enumerate(frames):
-        # Draw trajectory (blue line) only for detected frames
+        # Draw stumps (three white vertical lines)
+        stump_positions = [
+            (stumps_x - stumps_width_pixels / 2, stumps_y),
+            (stumps_x, stumps_y),
+            (stumps_x + stumps_width_pixels / 2, stumps_y)
+        ]
+        for x, y in stump_positions:
+            cv2.line(frame, (int(x), int(y)), (int(x), int(y - stumps_height_pixels)), (255, 255, 255), 2)
+
+        # Draw crease line (striker to non-striker)
+        cv2.line(frame, (0, int(stumps_y)), (frame_width, int(stumps_y)), (255, 255, 0), 2)  # Yellow line
+
         if i in detection_frames and trajectory_points.size > 0:
             idx = detection_frames.index(i) + 1
             if idx <= len(trajectory_points):
                 cv2.polylines(frame, [trajectory_points[:idx]], False, (255, 0, 0), 2)
 
-        # Draw pitch point (red circle) only in pitch frame
         if pitch_point and i == pitch_frame:
             x, y = pitch_point
-            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)
+            cv2.circle(frame, (int(x), int(y)), 8, (0, 255, 0), -1)  # Green for pitch
+            cv2.putText(frame, "Pitching Factor", (int(x) + 10, int(y) - 10),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
 
-        # Draw impact point (yellow circle) only in impact frame
         if impact_point and i == impact_frame:
             x, y = impact_point
-            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)
+            cv2.circle(frame, (int(x), int(y)), 8, (0, 0, 255), -1)  # Red for impact
+            cv2.putText(frame, "Impact Factor", (int(x) + 10, int(y) + 20),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
+
+        # Wicket factor (show at impact frame if hitting stumps)
+        if impact_point and i == impact_frame and "Out" in lbw_decision(ball_positions, full_trajectory, frames, pitch_point, impact_point)[0]:
+            cv2.putText(frame, "Wicket Factor", (int(stumps_x) - 50, int(stumps_y) - 20),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 165, 255), 2)  # Orange
 
         for _ in range(SLOW_MOTION_FACTOR):
             out.write(frame)
@@ -194,10 +215,10 @@ iface = gr.Interface(
     inputs=gr.Video(label="Upload Video Clip"),
     outputs=[
         gr.Textbox(label="DRS Decision and Debug Log"),
-        gr.Video(label="Very Slow-Motion Replay with Ball Detection (Green), Trajectory (Blue Line), Pitch Point (Red), Impact Point (Yellow)")
+        gr.Video(label="Very Slow-Motion Replay with Pitching Factor (Green), Impact Factor (Red), Wicket Factor (Orange), Stumps (White), Crease (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 slow-motion replay showing ball detection (green boxes), trajectory (blue line), pitch point (red circle), and impact point (yellow circle)."
+    description="Upload a video clip of a cricket delivery to get an LBW decision and slow-motion replay showing pitching factor (green circle), impact factor (red circle), wicket factor (orange text), stumps (white lines), and crease line (yellow line)."
 )
 
 if __name__ == "__main__":