Update app.py

app.py

@@ -4,22 +4,25 @@ import torch
 from ultralytics import YOLO
 import gradio as gr
 from scipy.interpolate import interp1d
-from scipy.ndimage import uniform_filter1d
 import uuid
 import os
+from OpenGL.GL import *
+from OpenGL.GLU import *
+from pygame import display, event, QUIT
 
 # Load the trained YOLOv8n model
 model = YOLO("best.pt")
 
-# Constants for LBW decision and video processing
-STUMPS_WIDTH = 0.2286  # meters (width of stumps)
-FRAME_RATE = 20  # Input video frame rate
-SLOW_MOTION_FACTOR = 2  # Reduced for faster output
-CONF_THRESHOLD = 0.3  # Increased for better detection
-PITCH_ZONE_Y = 0.8  # Adjusted for pitch near stumps
-IMPACT_ZONE_Y = 0.7  # Adjusted for impact near batsman leg
-IMPACT_DELTA_Y = 20  # Reduced for finer impact detection
-STUMPS_HEIGHT = 0.711  # meters (height of stumps)
+# Constants
+STUMPS_WIDTH = 0.2286  # meters
+FRAME_RATE = 20
+SLOW_MOTION_FACTOR = 2
+CONF_THRESHOLD = 0.3
+PITCH_ZONE_Y = 0.8
+IMPACT_ZONE_Y = 0.7
+IMPACT_DELTA_Y = 20
+STUMPS_HEIGHT = 0.711  # meters
+PITCH_LENGTH = 20.12  # meters (22 yards)
 
 def process_video(video_path):
     if not os.path.exists(video_path):
@@ -35,10 +38,8 @@ def process_video(video_path):
         ret, frame = cap.read()
         if not ret:
             break
-        # Process every frame for better tracking
         frames.append(frame.copy())
-        # Preprocess frame for better detection
-        frame = cv2.convertScaleAbs(frame, alpha=1.2, beta=10)  # Enhance contrast
+        frame = cv2.convertScaleAbs(frame, alpha=1.2, beta=10)
         results = model.predict(frame, conf=CONF_THRESHOLD)
         detections = [det for det in results[0].boxes if det.cls == 0]
         if len(detections) == 1:
@@ -58,168 +59,166 @@ def process_video(video_path):
 
     return frames, ball_positions, detection_frames, "\n".join(debug_log)
 
-def estimate_trajectory(ball_positions, detection_frames, frames):
+def estimate_trajectory_3d(ball_positions, detection_frames, frames):
     if len(ball_positions) < 2:
-        return None, None, None, None, None, None, "Error: Fewer than 2 valid single-ball detections for trajectory"
-    frame_height = frames[0].shape[0]
+        return None, None, None, None, None, None, "Error: Fewer than 2 valid single-ball detections"
+    frame_height, frame_width = frames[0].shape[:2]
 
-    # Smooth coordinates with moving average
-    window_size = 3
-    x_coords = uniform_filter1d([pos[0] for pos in ball_positions], size=window_size, mode='nearest')
-    y_coords = uniform_filter1d([pos[1] for pos in ball_positions], size=window_size, mode='nearest')
+    # Simple 2D to 3D mapping (approximation)
+    x_coords = np.array([pos[0] for pos in ball_positions]) / frame_width * PITCH_LENGTH
+    y_coords = np.array([frame_height - pos[1] for pos in ball_positions]) / frame_height * STUMPS_HEIGHT * 2
+    z_coords = np.zeros_like(x_coords)  # Depth estimation needed (simplified as 0 for now)
     times = np.array([i / FRAME_RATE for i in range(len(ball_positions))])
 
     pitch_idx = 0
     for i, y in enumerate(y_coords):
-        if y > frame_height * PITCH_ZONE_Y:
+        if y < STUMPS_HEIGHT:  # Pitch near ground
             pitch_idx = i
             break
-    pitch_point = ball_positions[pitch_idx]
+    pitch_point = (x_coords[pitch_idx], y_coords[pitch_idx], 0)
     pitch_frame = detection_frames[pitch_idx]
 
     impact_idx = None
     for i in range(1, len(y_coords)):
-        if (y_coords[i] > frame_height * IMPACT_ZONE_Y and
-            abs(y_coords[i] - y_coords[i-1]) > IMPACT_DELTA_Y):
+        if (y_coords[i] > STUMPS_HEIGHT and
+            abs(y_coords[i] - y_coords[i-1]) > IMPACT_DELTA_Y * STUMPS_HEIGHT / frame_height):
             impact_idx = i
             break
     if impact_idx is None:
         impact_idx = len(y_coords) - 1
-    impact_point = ball_positions[impact_idx]
+    impact_point = (x_coords[impact_idx], y_coords[impact_idx], 0)
     impact_frame = detection_frames[impact_idx]
 
-    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 None, None, None, None, None, None, f"Error in trajectory interpolation: {str(e)}"
-
-    vis_trajectory = list(zip(x_coords, y_coords))
-    t_full = np.linspace(times[0], times[-1] + 0.5, len(times) + 5)
-    x_full = fx(t_full)
-    y_full = fy(t_full)
-    full_trajectory = list(zip(x_full, y_full))
+    # Interpolate 3D trajectory
+    fx = interp1d(times[:impact_idx + 1], x_coords[:impact_idx + 1], kind='linear', fill_value="extrapolate")
+    fy = interp1d(times[:impact_idx + 1], y_coords[:impact_idx + 1], kind='quadratic', fill_value="extrapolate")
+    fz = interp1d(times[:impact_idx + 1], z_coords[:impact_idx + 1], kind='linear', fill_value="extrapolate")
+    t_full = np.linspace(times[0], times[impact_idx] + 0.5, 50)
+    full_trajectory = list(zip(fx(t_full), fy(t_full), fz(t_full)))
 
-    debug_log = (f"Trajectory estimated successfully\n"
-                 f"Pitch point at frame {pitch_frame + 1}: ({pitch_point[0]:.1f}, {pitch_point[1]:.1f})\n"
-                 f"Impact point at frame {impact_frame + 1}: ({impact_point[0]:.1f}, {impact_point[1]:.1f})")
-    return full_trajectory, vis_trajectory, pitch_point, pitch_frame, impact_point, impact_frame, debug_log
+    vis_trajectory = list(zip(x_coords, y_coords, z_coords))[:impact_idx + 1]
+    return full_trajectory, vis_trajectory, pitch_point, pitch_frame, impact_point, impact_frame, "Trajectory estimated"
 
 def lbw_decision(ball_positions, full_trajectory, frames, pitch_point, impact_point):
-    if not frames:
-        return "Error: No frames processed", None, None, None
-    if not full_trajectory or len(ball_positions) < 2:
-        return "Not enough data (insufficient valid single-ball detections)", None, None, None
-
+    if not frames or not full_trajectory:
+        return "Error: No data", None, None, None
     frame_height, frame_width = frames[0].shape[:2]
-    stumps_x = frame_width / 2
-    stumps_y = frame_height * 0.8  # Adjusted to align with pitch
-    stumps_width_pixels = frame_width * (STUMPS_WIDTH / 3.0)
-    batsman_area_y = frame_height * 0.7
+    stumps_x = PITCH_LENGTH / 2
+    stumps_y = 0  # Ground level
+    stumps_width = STUMPS_WIDTH
 
-    pitch_x, pitch_y = pitch_point
-    impact_x, impact_y = impact_point
+    pitch_x, pitch_y, _ = pitch_point
+    impact_x, impact_y, _ = impact_point
 
-    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
+    in_line_threshold = stumps_width / 2
+    if abs(pitch_x - stumps_x) > in_line_threshold:
+        return f"Not Out (Pitched outside line at x: {pitch_x:.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
+    if abs(impact_x - stumps_x) > in_line_threshold or impact_y < stumps_y:
+        return f"Not Out (Impact outside line at x: {impact_x:.1f})", full_trajectory, pitch_point, impact_point
 
     hit_stumps = False
-    for x, y in full_trajectory:
+    for x, y, z in full_trajectory:
         if (abs(x - stumps_x) < in_line_threshold and
-            abs(y - stumps_y) < frame_height * 0.1):
+            abs(y - stumps_y) < STUMPS_HEIGHT / 2):
             hit_stumps = True
             break
 
     if hit_stumps:
         if abs(x - stumps_x) < in_line_threshold * 0.1:
-            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, decision):
-    if not frames:
-        return None
-    frame_height, frame_width = frames[0].shape[:2]
-    stumps_x = frame_width / 2
-    stumps_y = frame_height * 0.8  # Align with pitch
-    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))
-
-    trajectory_points = np.array(vis_trajectory, dtype=np.int32).reshape((-1, 1, 2))
-
-    for i, frame in enumerate(frames):
-        # Draw stumps outline
-        cv2.line(frame, (int(stumps_x - stumps_width_pixels / 2), int(stumps_y)),
-                 (int(stumps_x + stumps_width_pixels / 2), int(stumps_y)), (255, 255, 255), 2)
-        cv2.line(frame, (int(stumps_x - stumps_width_pixels / 2), int(stumps_y - stumps_height_pixels)),
-                 (int(stumps_x - stumps_width_pixels / 2), int(stumps_y)), (255, 255, 255), 2)
-        cv2.line(frame, (int(stumps_x + stumps_width_pixels / 2), int(stumps_y - stumps_height_pixels)),
-                 (int(stumps_x + stumps_width_pixels / 2), int(stumps_y)), (255, 255, 255), 2)
-
-        # Draw crease line at stumps
-        cv2.line(frame, (int(stumps_x - stumps_width_pixels / 2), int(stumps_y)),
-                 (int(stumps_x + stumps_width_pixels / 2), int(stumps_y)), (255, 255, 0), 2)
-
-        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, (0, 0, 255), 2)  # Blue trajectory
-
-        if pitch_point and i == pitch_frame:
-            x, y = pitch_point
-            cv2.circle(frame, (int(x), int(y)), 8, (0, 255, 0), -1)  # Green for pitching
-            cv2.putText(frame, "Pitching", (int(x) + 10, int(y) - 10),
-                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
-
-        if impact_point and i == impact_frame:
-            x, y = impact_point
-            cv2.circle(frame, (int(x), int(y)), 8, (0, 0, 255), -1)  # Red for impact
-            cv2.putText(frame, "Impact", (int(x) + 10, int(y) + 20),
-                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1)
-
-        if impact_point and i == impact_frame and "Out" in decision:
-            cv2.putText(frame, "Wickets", (int(stumps_x) - 50, int(stumps_y) - 20),
-                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 165, 255), 1)  # Orange for wickets
-
-        for _ in range(SLOW_MOTION_FACTOR):
-            out.write(frame)
-    out.release()
-    return output_path
+            return f"Umpire's Call - Not Out", full_trajectory, pitch_point, impact_point
+        return f"Out (Ball hits stumps)", full_trajectory, pitch_point, impact_point
+    return f"Not Out (Missing stumps)", full_trajectory, pitch_point, impact_point
+
+def init_3d_window(width, height):
+    pygame.init()
+    display.set_mode((width, height), DOUBLEBUF | OPENGL)
+    gluPerspective(45, (width / height), 0.1, 50.0)
+    glTranslatef(0.0, -5.0, -30)
+    glEnable(GL_DEPTH_TEST)
+
+def draw_3d_scene(trajectory, pitch_point, impact_point, decision):
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+    glBegin(GL_LINES)
+    for i in range(len(trajectory) - 1):
+        glColor3f(0, 0, 1)  # Blue trajectory
+        glVertex3f(trajectory[i][0], trajectory[i][1], trajectory[i][2])
+        glVertex3f(trajectory[i + 1][0], trajectory[i + 1][1], trajectory[i + 1][2])
+    glEnd()
+
+    # Draw pitch and stumps
+    glColor3f(0, 1, 0)  # Green pitch
+    glBegin(GL_QUADS)
+    glVertex3f(0, 0, 0)
+    glVertex3f(PITCH_LENGTH, 0, 0)
+    glVertex3f(PITCH_LENGTH, 0, -1)
+    glVertex3f(0, 0, -1)
+    glEnd()
+
+    glColor3f(1, 1, 1)  # White stumps
+    glBegin(GL_LINES)
+    glVertex3f(PITCH_LENGTH / 2 - STUMPS_WIDTH / 2, 0, 0)
+    glVertex3f(PITCH_LENGTH / 2 - STUMPS_WIDTH / 2, STUMPS_HEIGHT, 0)
+    glVertex3f(PITCH_LENGTH / 2 + STUMPS_WIDTH / 2, 0, 0)
+    glVertex3f(PITCH_LENGTH / 2 + STUMPS_WIDTH / 2, STUMPS_HEIGHT, 0)
+    glEnd()
+
+    # Draw pitching and impact points
+    if pitch_point:
+        glColor3f(0, 1, 0)  # Green
+        glPushMatrix()
+        glTranslatef(pitch_point[0], pitch_point[1], pitch_point[2])
+        glutSolidSphere(0.1, 20, 20)
+        glPopMatrix()
+
+    if impact_point:
+        glColor3f(1, 0, 0)  # Red
+        glPushMatrix()
+        glTranslatef(impact_point[0], impact_point[1], impact_point[2])
+        glutSolidSphere(0.1, 20, 20)
+        glPopMatrix()
+
+    # Display decision (simplified text)
+    if "Out" in decision:
+        glColor3f(1, 0.65, 0)  # Orange
+        glRasterPos3f(PITCH_LENGTH / 2, STUMPS_HEIGHT, 0)
+        for char in "Wickets":
+            glutBitmapCharacter(GLUT_BITMAP_HELVETICA_12, ord(char))
+
+    display.flip()
 
 def drs_review(video):
     frames, ball_positions, detection_frames, debug_log = process_video(video)
     if not frames:
         return f"Error: Failed to process video\nDebug Log:\n{debug_log}", None
-    full_trajectory, vis_trajectory, pitch_point, pitch_frame, impact_point, impact_frame, trajectory_log = estimate_trajectory(ball_positions, detection_frames, frames)
+    full_trajectory, vis_trajectory, pitch_point, pitch_frame, impact_point, impact_frame, trajectory_log = estimate_trajectory_3d(ball_positions, detection_frames, frames)
     decision, full_trajectory, pitch_point, impact_point = lbw_decision(ball_positions, full_trajectory, frames, pitch_point, impact_point)
 
+    # Generate 3D visualization (separate window)
+    init_3d_window(800, 600)
+    from OpenGL.GLUT import glutInit, glutSolidSphere
+    glutInit()
+    for _ in range(100):  # Limited frames for demo
+        draw_3d_scene(full_trajectory, pitch_point, impact_point, decision)
+        event.pump()
+
     output_path = f"output_{uuid.uuid4()}.mp4"
-    slow_motion_path = generate_slow_motion(frames, vis_trajectory, pitch_point, pitch_frame, impact_point, impact_frame, detection_frames, output_path, decision)
+    # Note: 3D rendering is separate; 2D video output is placeholder
+    slow_motion_path = None  # To be enhanced with 3D export
 
     debug_output = f"{debug_log}\n{trajectory_log}"
     return f"DRS Decision: {decision}\nDebug Log:\n{debug_output}", slow_motion_path
 
-# Gradio interface
+# Gradio interface (placeholder for 3D)
 iface = gr.Interface(
     fn=drs_review,
     inputs=gr.Video(label="Upload Video Clip"),
     outputs=[
         gr.Textbox(label="DRS Decision and Debug Log"),
-        gr.Video(label="Optimized Slow-Motion Replay with Pitching (Green), Impact (Red), Wickets (Orange), Stumps (White), Crease (Yellow)")
+        gr.Video(label="3D Visualization (Separate Window)")
     ],
-    title="AI-Powered DRS for LBW in Local Cricket",
-    description="Upload a video clip of a cricket delivery to get an LBW decision and optimized slow-motion replay showing pitching (green circle), impact (red circle), wickets (orange text), stumps (white outline), and crease line (yellow line)."
+    title="AI-Powered 3D DRS for LBW",
+    description="Upload a video clip for 3D DRS analysis with pitching (green), impact (red), and wickets (orange) visualization."
 )
 
 if __name__ == "__main__":