Update app.py

app.py

@@ -1,290 +1,279 @@
 import cv2
 import numpy as np
+import torch
 from ultralytics import YOLO
-import mediapipe as mp
-from scipy.interpolate import interp1d
 import gradio as gr
+from scipy.interpolate import interp1d
 import plotly.graph_objects as go
+import uuid
 import os
-import logging
 
-# Setup logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+# Load the trained YOLOv8n model with optimizations
+model = YOLO("best.pt")
+model.to('cuda' if torch.cuda.is_available() else 'cpu')  # Use GPU if available
 
-# Initialize models
-ball_model = YOLO('best.pt')  # Load pre-trained YOLOv8 model
-mp_pose = mp.solutions.pose
-pose = mp_pose.Pose()
+# 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 = 20  # Input video frame rate
+SLOW_MOTION_FACTOR = 3  # For very slow motion (3x slower)
+CONF_THRESHOLD = 0.2  # Confidence threshold
+IMPACT_ZONE_Y = 0.85  # Fraction of frame height where impact is likely
+IMPACT_DELTA_Y = 50  # Pixels for detecting sudden y-position change
+PITCH_LENGTH = 20.12  # meters (standard cricket pitch length)
+STUMPS_HEIGHT = 0.71  # meters (stumps height)
+CAMERA_HEIGHT = 2.0  # meters (assumed camera height)
+CAMERA_DISTANCE = 10.0  # meters (assumed camera distance from pitch)
+MAX_POSITION_JUMP = 30  # Pixels, tightened for continuous trajectory
 
 def process_video(video_path):
-    logger.info("Starting video processing")
-    # Load video
+    if not os.path.exists(video_path):
+        return [], [], [], "Error: Video file not found"
     cap = cv2.VideoCapture(video_path)
-    if not cap.isOpened():
-        logger.error("Failed to open video file")
-        return None, "Error: Could not open video", None
-
+    # Get native video resolution
     frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
     frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    fps = int(cap.get(cv2.CAP_PROP_FPS))
-    frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-    if frame_count < 10:  # Ensure video has enough frames
-        logger.error("Video too short, requires at least 10 frames")
-        cap.release()
-        return None, "Error: Video too short", None
-
-    output_path = "replay.mp4"
-    output_video = cv2.VideoWriter(output_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (frame_width, frame_height))
-
-    ball_positions = []  # Store (frame_idx, x, y, confidence)
-    release_frame, pitch_frame, impact_frame = None, None, None
-    release_x, release_y = None, None
-    pitch_x, pitch_y = None, None
-    impact_x, impact_y = None, None
-    decision = "Not Out"
-
-    # Initialize Kalman Filter
-    kalman = cv2.KalmanFilter(4, 2)
-    kalman.measurementMatrix = np.array([[1, 0, 0, 0], [0, 1, 0, 0]], np.float32)
-    kalman.transitionMatrix = np.array([[1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0], [0, 0, 0, 1]], np.float32)
-    kalman.processNoiseCov = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]], np.float32) * 0.005
-    kalman.measurementNoiseCov = np.array([[1, 0], [0, 1]], np.float32) * 0.2
-    kalman.statePre = np.array([[frame_width/2], [frame_height/2], [0], [0]], np.float32)
-
     frames = []
-    frame_idx = 0
-    last_valid_pos = None
+    ball_positions = []
+    detection_frames = []
+    debug_log = []
 
+    frame_count = 0
     while cap.isOpened():
         ret, frame = cap.read()
         if not ret:
             break
+        frame_count += 1
         frames.append(frame.copy())
+        # Use native resolution for inference
+        results = model.predict(frame, conf=CONF_THRESHOLD, imgsz=(frame_height, frame_width), iou=0.5, max_det=1)
+        detections = 0
+        for detection in results[0].boxes:
+            if detection.cls == 0:  # Class 0 is the ball
+                detections += 1
+                if detections == 1:  # Only consider frames with exactly one detection
+                    x1, y1, x2, y2 = detection.xyxy[0].cpu().numpy()
+                    ball_positions.append([(x1 + x2) / 2, (y1 + y2) / 2])
+                    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}: {detections} ball detections")
+    cap.release()
 
-        # Ball detection
-        results = ball_model.predict(frame, verbose=False)
-        ball_detected = False
-        for result in results:
-            for box in result.boxes:
-                if result.names[int(box.cls)] == 'cricket_ball' and box.conf > 0.5:  # Lowered threshold
-                    x, y, w, h = box.xywh[0]
-                    if last_valid_pos is None or (
-                        abs(x - last_valid_pos[0]) < 100 and abs(y - last_valid_pos[1]) < 100
-                    ):
-                        measurement = np.array([[np.float32(x)], [np.float32(y)]])
-                        kalman.correct(measurement)
-                        ball_positions.append((frame_idx, x, y, box.conf))
-                        last_valid_pos = (x, y)
-                        ball_detected = True
-                        logger.info(f"Frame {frame_idx}: Detected ball at ({x:.2f}, {y:.2f}), conf={box.conf:.2f}")
-                    break
-            if ball_detected:
-                break
-
-        if not ball_detected:
-            prediction = kalman.predict()
-            x, y = prediction[0].item(), prediction[1].item()
-            if 0 <= x < frame_width and 0 <= y < frame_height:
-                ball_positions.append((frame_idx, x, y, 0.0))
-                logger.debug(f"Frame {frame_idx}: Predicted ball at ({x:.2f}, {y:.2f})")
-
-        # Pose detection
-        pose_results = pose.process(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
-        if pose_results.pose_landmarks:
-            try:
-                if frame_idx < 10 and release_frame is None:
-                    hand = pose_results.pose_landmarks.landmark[mp_pose.PoseLandmark.RIGHT_WRIST]
-                    if hand.visibility > 0.7:
-                        release_x, release_y = hand.x * frame_width, hand.y * frame_height
-                        release_frame = frame_idx
-                        logger.info(f"Release point detected at frame {frame_idx}: ({release_x:.2f}, {release_y:.2f})")
-
-                if ball_detected and impact_frame is None:
-                    for landmark in [mp_pose.PoseLandmark.LEFT_KNEE, mp_pose.PoseLandmark.RIGHT_KNEE]:
-                        knee = pose_results.pose_landmarks.landmark[landmark]
-                        if knee.visibility > 0.7:
-                            knee_x, knee_y = knee.x * frame_width, knee.y * frame_height
-                            if abs(knee_x - x) < 50 and abs(knee_y - y) < 50:
-                                impact_x, impact_y = x, y
-                                impact_frame = frame_idx
-                                logger.info(f"Impact point detected at frame {frame_idx}: ({impact_x:.2f}, {impact_y:.2f})")
-                                break
-            except Exception as e:
-                logger.error(f"Pose detection error: {str(e)}")
-
-        # Pitch point
-        if ball_detected and pitch_frame is None:
-            if y > frame_height * 0.8:
-                pitch_x, pitch_y = x, y
-                pitch_frame = frame_idx
-                logger.info(f"Pitch point detected at frame {frame_idx}: ({pitch_x:.2f}, {pitch_y:.2f})")
-
-        frame_idx += 1
+    if not ball_positions:
+        debug_log.append("No balls detected in any frame")
+    else:
+        debug_log.append(f"Total ball detections: {len(ball_positions)}")
+        debug_log.append(f"Video resolution: {frame_width}x{frame_height}")
 
-    cap.release()
+    return frames, ball_positions, detection_frames, "\n".join(debug_log)
+
+def pixel_to_3d(x, y, frame_height, frame_width):
+    """Convert 2D pixel coordinates to 3D real-world coordinates."""
+    x_norm = x / frame_width
+    y_norm = y / frame_height
+    x_3d = (x_norm - 0.5) * 3.0  # Center x at 0 (middle of pitch)
+    y_3d = y_norm * PITCH_LENGTH
+    z_3d = (1 - y_norm) * BALL_DIAMETER * 5  # Scale to approximate ball bounce height
+    return x_3d, y_3d, z_3d
+
+def estimate_trajectory(ball_positions, frames, detection_frames):
+    if len(ball_positions) < 2:
+        return None, None, None, None, None, None, None, None, None, "Error: Fewer than 2 ball detections for trajectory"
+    frame_height, frame_width = frames[0].shape[:2]
+
+    # Filter out sudden changes in position for continuous trajectory
+    filtered_positions = [ball_positions[0]]
+    filtered_frames = [detection_frames[0]]
+    for i in range(1, len(ball_positions)):
+        prev_pos = filtered_positions[-1]
+        curr_pos = ball_positions[i]
+        distance = np.sqrt((curr_pos[0] - prev_pos[0])**2 + (curr_pos[1] - prev_pos[1])**2)
+        if distance <= MAX_POSITION_JUMP:
+            filtered_positions.append(curr_pos)
+            filtered_frames.append(detection_frames[i])
+        else:
+            # Skip sudden jumps to maintain continuity
+            continue
+
+    if len(filtered_positions) < 2:
+        return None, None, None, None, None, None, None, None, None, "Error: Fewer than 2 valid ball detections after filtering"
+
+    x_coords = [pos[0] for pos in filtered_positions]
+    y_coords = [pos[1] for pos in filtered_positions]
+    times = np.array(filtered_frames) / FRAME_RATE
+
+    # Pitch point detection: Assume it happens when the ball reaches a certain low point on the y-axis
+    pitch_point = None
+    pitch_frame = None
+    for i in range(1, len(y_coords)):
+        if y_coords[i] > frame_height * 0.75:  # The ball reaches near the ground
+            pitch_point = filtered_positions[i]
+            pitch_frame = filtered_frames[i]
+            break
+
+    # Impact point detection: Look for sudden changes in the y-position (delta_y) or when ball enters impact zone
+    impact_idx = None
+    impact_frame = None
+    for i in range(1, len(y_coords)):
+        delta_y = abs(y_coords[i] - y_coords[i-1])
+        if delta_y > IMPACT_DELTA_Y:
+            impact_idx = i
+            impact_frame = filtered_frames[i]
+            break
+        elif y_coords[i] > frame_height * IMPACT_ZONE_Y:
+            impact_idx = i
+            impact_frame = filtered_frames[i]
+            break
+    if impact_idx is None:
+        impact_idx = len(filtered_positions) - 1
+        impact_frame = filtered_frames[-1]
+    impact_point = filtered_positions[impact_idx]
+
+    try:
+        # Use cubic interpolation for smoother trajectory
+        fx = interp1d(times[:impact_idx + 1], x_coords[:impact_idx + 1], kind='cubic', fill_value="extrapolate")
+        fy = interp1d(times[:impact_idx + 1], y_coords[:impact_idx + 1], kind='cubic', fill_value="extrapolate")
+    except Exception as e:
+        return None, None, None, None, None, None, None, None, None, f"Error in trajectory interpolation: {str(e)}"
 
-    # Smooth trajectory
-    confident_positions = [(idx, x, y) for idx, x, y, conf in ball_positions if conf > 0.5]
-    if not confident_positions:
-        logger.error("No confident ball detections found in the video")
-        output_video.release()
-        fig = go.Figure()
-        fig.add_annotation(text="No confident ball detections for trajectory plot", showarrow=False)
-        fig.update_layout(template="plotly_dark")
-        return output_path, "Error: No ball detections", fig
-
-    smooth_trajectory = []
-    if len(confident_positions) > 2:
-        frames_range, x_coords, y_coords = zip(*confident_positions)
-        try:
-            fx = interp1d(frames_range, x_coords, kind='cubic', fill_value="extrapolate")
-            fy = interp1d(frames_range, y_coords, kind='cubic', fill_value="extrapolate")
-            all_frames = np.arange(min(frames_range), max(frames_range) + 1)
-            smooth_trajectory = [
-                (int(fx(t)), int(fy(t)))
-                for t in all_frames
-                if 0 <= fx(t) < frame_width and 0 <= fy(t) < frame_height and not np.isnan(fx(t)) and not np.isnan(fy(t))
-            ]
-            logger.info(f"Generated smooth trajectory with {len(smooth_trajectory)} points")
-        except Exception as e:
-            logger.error(f"Interpolation failed: {str(e)}")
-            smooth_trajectory = [(int(x), int(y)) for idx, x, y, conf in ball_positions if conf > 0.5 and 0 <= x < frame_width and 0 <= y < frame_height]
+    # Generate dense points for all frames between first and last detection
+    total_frames = max(detection_frames) - min(detection_frames) + 1
+    t_full = np.linspace(times[0], times[-1], total_frames * SLOW_MOTION_FACTOR)
+    x_full = fx(t_full)
+    y_full = fy(t_full)
+    trajectory_2d = list(zip(x_full, y_full))
+
+    trajectory_3d = [pixel_to_3d(x, y, frame_height, frame_width) for x, y in trajectory_2d]
+    detections_3d = [pixel_to_3d(x, y, frame_height, frame_width) for x, y in filtered_positions]
+    
+    # Handle missing pitch and impact points gracefully
+    pitch_point_3d = pixel_to_3d(pitch_point[0], pitch_point[1], frame_height, frame_width) if pitch_point else None
+    impact_point_3d = pixel_to_3d(impact_point[0], impact_point[1], frame_height, frame_width) if impact_point else None
+
+    # Handle cases where no pitch/impact point is found
+    if pitch_point is None:
+        pitch_frame = "N/A"
+        pitch_point_3d = None  # No 3D coordinates for pitch point
+    if impact_point is None:
+        impact_frame = "N/A"
+        impact_point_3d = None  # No 3D coordinates for impact point
+
+    debug_log = (
+        f"Trajectory estimated successfully\n"
+        f"Pitch point at frame {pitch_frame + 1 if pitch_frame != 'N/A' else 'N/A'}: {pitch_point if pitch_point else 'Not detected'}\n"
+        f"Impact point at frame {impact_frame + 1 if impact_frame != 'N/A' else 'N/A'}: {impact_point if impact_point else 'Not detected'}\n"
+        f"Detections in frames: {filtered_frames}"
+    )
+    return trajectory_2d, pitch_point, impact_point, pitch_frame, impact_frame, detections_3d, trajectory_3d, pitch_point_3d, impact_point_3d, debug_log
+
+def lbw_decision(ball_positions, trajectory, frames, pitch_point, impact_point):
+    if not frames:
+        return "Error: No frames processed", None, None, None
+    if not trajectory or len(ball_positions) < 2:
+        return "Not enough data (insufficient ball detections)", None, None, None
+
+    # Check for None values before unpacking
+    if pitch_point is None or impact_point is None:
+        return "Not Out (Unable to determine pitch or impact points)", trajectory, pitch_point, impact_point
+
+    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_x, pitch_y = pitch_point
+    impact_x, impact_y = impact_point
+
+    if pitch_x < stumps_x - stumps_width_pixels / 2 or pitch_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
+    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
+    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
+    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, detection_frames, pitch_frame, impact_frame, output_path):
+    if not frames:
+        return None
+    frame_height, frame_width = frames[0].shape[:2]
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_path, fourcc, FRAME_RATE / SLOW_MOTION_FACTOR, (frame_width, frame_height))
+
+    # Map trajectory points to all frames between first and last detection
+    if trajectory and detection_frames:
+        min_frame = min(detection_frames)
+        max_frame = max(detection_frames)
+        total_frames = max_frame - min_frame + 1
+        trajectory_points = np.array(trajectory, dtype=np.int32).reshape((-1, 1, 2))
+        traj_per_frame = len(trajectory) // total_frames
+        trajectory_indices = [i * traj_per_frame for i in range(total_frames)]
     else:
-        smooth_trajectory = [(int(x), int(y)) for idx, x, y, conf in ball_positions if conf > 0.5 and 0 <= x < frame_width and 0 <= y < frame_height]
-        logger.warning(f"Insufficient confident detections ({len(confident_positions)}), using raw confident positions")
-
-    # LBW Decision
-    pitch_in_line = pitch_x is not None and frame_width * 0.4 < pitch_x < frame_width * 0.6
-    impact_in_line = impact_x is not None and frame_width * 0.4 < impact_x < frame_width * 0.6
-    stumps_hit = False
-    if impact_frame and smooth_trajectory:
-        last_x, last_y = smooth_trajectory[-1]
-        if last_y < frame_height * 0.3 and frame_width * 0.4 < last_x < frame_width * 0.6:
-            stumps_hit = True
-    if pitch_in_line and impact_in_line and stumps_hit:
-        decision = "Out"
-    logger.info(f"Decision: {decision}")
-
-    # Generate replay video
+        trajectory_points = np.array([], dtype=np.int32)
+        trajectory_indices = []
+
     for i, frame in enumerate(frames):
-        for x, y in smooth_trajectory:
-            try:
-                cv2.circle(frame, (x, y), 3, (0, 0, 255), -1)  # Red trajectory
-            except Exception as e:
-                logger.error(f"Error drawing trajectory at ({x}, {y}): {str(e)}")
-        if i == release_frame and release_x and release_y:
-            cv2.circle(frame, (int(release_x), int(release_y)), 5, (255, 0, 0), -1)  # Blue release
-        if i == pitch_frame and pitch_x and pitch_y:
-            cv2.circle(frame, (int(pitch_x), int(pitch_y)), 5, (0, 255, 255), -1)  # Yellow pitch
-        if i == impact_frame and impact_x and impact_y:
-            cv2.circle(frame, (int(impact_x), int(impact_y)), 5, (0, 255, 0), -1)  # Green impact
-        cv2.putText(frame, f"Decision: {decision}", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
-        output_video.write(frame)
-
-    output_video.release()
-
-    # Generate Plotly trajectory plots
-    if confident_positions:
-        frames_range, x_coords, y_coords = zip(*confident_positions)
-        # Plot 1: X, Y vs Frame Index
-        fig1 = go.Figure()
-        fig1.add_trace(go.Scatter(
-            x=frames_range, y=x_coords, mode='lines+markers', name='X Coordinate',
-            line=dict(color='blue'), marker=dict(size=8)
-        ))
-        fig1.add_trace(go.Scatter(
-            x=frames_range, y=y_coords, mode='lines+markers', name='Y Coordinate',
-            line=dict(color='red'), marker=dict(size=8)
-        ))
-        if release_frame:
-            fig1.add_trace(go.Scatter(
-                x=[release_frame], y=[release_y], mode='markers', name='Release Point',
-                marker=dict(size=12, color='blue', symbol='star')
-            ))
-        if pitch_frame:
-            fig1.add_trace(go.Scatter(
-                x=[pitch_frame], y=[pitch_y], mode='markers', name='Pitch Point',
-                marker=dict(size=12, color='yellow', symbol='star')
-            ))
-        if impact_frame:
-            fig1.add_trace(go.Scatter(
-                x=[impact_frame], y=[impact_y], mode='markers', name='Impact Point',
-                marker=dict(size=12, color='green', symbol='star')
-            ))
-        fig1.update_layout(
-            title="Ball Trajectory (X, Y vs Frame Index)",
-            xaxis_title="Frame Index",
-            yaxis_title="Pixel Coordinate",
-            template="plotly_dark",
-            showlegend=True
-        )
-
-        # Plot 2: X vs Y (Spatial Trajectory)
-        fig2 = go.Figure()
-        fig2.add_trace(go.Scatter(
-            x=x_coords, y=y_coords, mode='lines+markers', name='Ball Trajectory',
-            line=dict(color='red'), marker=dict(size=8)
-        ))
-        if release_frame:
-            fig2.add_trace(go.Scatter(
-                x=[release_x], y=[release_y], mode='markers', name='Release Point',
-                marker=dict(size=12, color='blue', symbol='star')
-            ))
-        if pitch_frame:
-            fig2.add_trace(go.Scatter(
-                x=[pitch_x], y=[pitch_y], mode='markers', name='Pitch Point',
-                marker=dict(size=12, color='yellow', symbol='star')
-            ))
-        if impact_frame:
-            fig2.add_trace(go.Scatter(
-                x=[impact_x], y=[impact_y], mode='markers', name='Impact Point',
-                marker=dict(size=12, color='green', symbol='star')
-            ))
-        fig2.update_layout(
-            title="Ball Trajectory (X vs Y, Spatial View)",
-            xaxis_title="X Coordinate (pixels)",
-            yaxis_title="Y Coordinate (pixels)",
-            template="plotly_dark",
-            showlegend=True,
-            xaxis=dict(range=[0, frame_width]),
-            yaxis=dict(range=[frame_height, 0])  # Invert y-axis to match video orientation
-        )
-
-        # Combine plots
-        fig = go.Figure()
-        fig.add_traces(fig1.data + fig2.data)
-        fig.update_layout(
-            title="Ball Trajectory Analysis",
-            grid=dict(rows=2, columns=1),
-            subplot_titles=["X, Y vs Frame Index", "X vs Y (Spatial View)"],
-            template="plotly_dark",
-            showlegend=True
-        )
-        fig.layout['xaxis'].update(title="Frame Index", range=[min(frames_range), max(frames_range)])
-        fig.layout['yaxis'].update(title="Pixel Coordinate")
-        fig.layout['xaxis2'].update(title="X Coordinate (pixels)", range=[0, frame_width])
-        fig.layout['yaxis2'].update(title="Y Coordinate (pixels)", range=[frame_height, 0])
-    else:
-        fig = go.Figure()
-        fig.add_annotation(text="No confident ball detections for trajectory plot", showarrow=False)
-        fig.update_layout(template="plotly_dark")
+        frame_idx = i - min_frame if trajectory_indices else -1
+        if frame_idx >= 0 and frame_idx < total_frames and trajectory_points.size > 0:
+            # Draw trajectory up to current frame
+            end_idx = trajectory_indices[frame_idx] + 1
+            cv2.polylines(frame, [trajectory_points[:end_idx]], False, (255, 0, 0), 2)
+        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)
+        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)
+        for _ in range(SLOW_MOTION_FACTOR):
+            out.write(frame)
+    out.release()
+    return output_path
+
+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, None, None
+
+    trajectory_2d, pitch_point, impact_point, pitch_frame, impact_frame, detections_3d, trajectory_3d, pitch_point_3d, impact_point_3d, trajectory_log = estimate_trajectory(ball_positions, frames, detection_frames)
+    
+    if trajectory_2d is None:
+        return (f"Error: {trajectory_log}\nDebug Log:\n{debug_log}", None, None, None)
+
+    decision, trajectory_2d, pitch_point, impact_point = lbw_decision(ball_positions, trajectory_2d, frames, pitch_point, impact_point)
+
+    output_path = f"output_{uuid.uuid4()}.mp4"
+    slow_motion_path = generate_slow_motion(frames, trajectory_2d, pitch_point, impact_point, detection_frames, pitch_frame, impact_frame, output_path)
+
+    detections_fig = None
+    trajectory_fig = None
+    if detections_3d:
+        detections_fig = create_3d_plot(detections_3d, trajectory_3d, pitch_point_3d, impact_point_3d, "detections")
+        trajectory_fig = create_3d_plot(detections_3d, trajectory_3d, pitch_point_3d, impact_point_3d, "trajectory")
 
-    logger.info("Video processing completed")
-    return output_path, decision, fig
+    debug_output = f"{debug_log}\n{trajectory_log}"
+    return (f"DRS Decision: {decision}\nDebug Log:\n{debug_output}", 
+            slow_motion_path, 
+            detections_fig, 
+            trajectory_fig)
 
-# Gradio Interface
+# Gradio interface
 iface = gr.Interface(
-    fn=process_video,
-    inputs=gr.Video(label="Upload Cricket Video (5-10s, 1080p, behind bowler/side-on)"),
+    fn=drs_review,
+    inputs=gr.Video(label="Upload Video Clip"),
     outputs=[
-        gr.Video(label="Replay Video"),
-        gr.Textbox(label="Decision"),
-        gr.Plot(label="Trajectory Plots (Temporal and Spatial)")
+        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.Plot(label="3D Single Ball Detections Plot"),
+        gr.Plot(label="3D Ball Trajectory Plot (Single Detections)")
     ],
-    title="Cricket DRS System",
-    description="Upload a cricket video to get a DRS analysis with smooth ball trajectory, Out/Not Out decision, and trajectory plots."
+    title="AI-Powered DRS for LBW in Local Cricket",
+    description="Upload a video clip of a cricket delivery to get an LBW decision, a slow-motion replay, and 3D visualizations. The replay shows ball detection (green boxes), trajectory (blue line), pitch point (red circle), and impact point (yellow circle). The 3D plots show single-detection frames (green markers) and trajectory (blue line) with wicket lines (black), pitch point (red), and impact point (yellow)."
 )
 
 if __name__ == "__main__":
-    iface.launch()
+    iface.launch()