Create app.py

app.py

@@ -0,0 +1,148 @@
+import gradio as gr
+import cv2
+import numpy as np
+from ultralytics import YOLO
+import tensorflow as tf
+import math
+import os
+from pathlib import Path
+
+# Configuration
+PITCH_LENGTH = 20.12  # Pitch length in meters
+PITCH_WIDTH = 3.05    # Pitch width in meters
+STUMP_HEIGHT = 0.71   # Stump height in meters
+STUMP_WIDTH = 0.23    # Stump width in meters
+FPS = 60              # Frames per second of video
+OUTPUT_DIR = "outputs"
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+# Load fine-tuned YOLOv8 model
+model = YOLO('best.pt')
+
+def pixel_to_world(x, y, frame_width, frame_height):
+    world_x = -PITCH_LENGTH/2 + (x / frame_width) * PITCH_LENGTH
+    world_z = -(y / frame_height) * PITCH_WIDTH
+    world_y = 0.5  # Assume ball height
+    return world_x, world_y, world_z
+
+def predict_trajectory(positions):
+    if len(positions) < 2:
+        return None
+    x = np.array([p[0] for p in positions])
+    y = np.array([p[1] for p in positions])
+    z = np.array([p[2] for p in positions])
+    t = np.arange(len(positions))
+    
+    px = np.polyfit(t, x, 1)
+    py = np.polyfit(t, y, 1)
+    pz = np.polyfit(t, z, 1)
+    
+    t_stump = (PITCH_LENGTH/2 - x[-1]) / px[0] if px[0] != 0 else 0
+    pred_y = py[0] * t_stump + y[-1]
+    pred_z = pz[0] * t_stump + z[-1]
+    return pred_y, pred_z
+
+def lbw_decision(pitch_impact, impact_point, stump_prediction):
+    pitching_in_line = -STUMP_WIDTH/2 <= pitch_impact[2] <= STUMP_WIDTH/2
+    impact_in_line = -STUMP_WIDTH/2 <= impact_point[2] <= STUMP_WIDTH/2 if impact_point else True
+    hitting_stumps = (stump_prediction is not None and 
+                      0 <= stump_prediction[0] <= STUMP_HEIGHT and 
+                      -STUMP_WIDTH/2 <= stump_prediction[1] <= STUMP_WIDTH/2)
+    
+    if pitching_in_line and impact_in_line and hitting_stumps:
+        return "OUT", "Ball pitched in line, hit in line, would hit stumps."
+    else:
+        reasons = []
+        if not pitching_in_line:
+            reasons.append("Ball pitched outside line.")
+        if not impact_in_line:
+            reasons.append("Impact outside line.")
+        if not hitting_stumps:
+            reasons.append("Ball would not hit stumps.")
+        return "NOT OUT", " ".join(reasons)
+
+def process_video(video_path):
+    # Initialize video capture
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        return "Error: Could not open video.", "", ""
+
+    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    output_path = os.path.join(OUTPUT_DIR, "output_video.mp4")
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_path, fourcc, FPS, (frame_width, frame_height))
+
+    ball_positions = []
+    pitch_impact = None
+    impact_point = None
+    frame_count = 0
+
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        frame_count += 1
+        results = model(frame, conf=0.3)
+        ball_detected = False
+
+        for result in results:
+            boxes = result.boxes.xyxy.numpy()
+            for box in boxes:
+                x1, y1, x2, y2 = box[:4]
+                center_x, center_y = (x1 + x2) / 2, (y1 + y2) / 2
+
+                world_x, world_y, world_z = pixel_to_world(center_x, center_y, frame_width, frame_height)
+                ball_positions.append((world_x, world_y, world_z))
+                ball_detected = True
+
+                cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), 2)
+
+                if world_y < 0.2 and pitch_impact is None:
+                    pitch_impact = (world_x, world_y, world_z)
+                    cv2.circle(frame, (int(center_x), int(center_y)), 5, (0, 0, 255), -1)
+                    cv2.putText(frame, "Pitch Impact", (int(center_x), int(center_y) - 10), 
+                                cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
+
+                if pitch_impact is not None and world_x > PITCH_LENGTH/2 - 1 and impact_point is None:
+                    impact_point = (world_x, world_y, world_z)
+                    cv2.circle(frame, (int(center_x), int(center_y)), 5, (255, 0, 0), -1)
+                    cv2.putText(frame, "Batsman Impact", (int(center_x), int(center_y) - 10), 
+                                cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
+                    break
+
+        if not ball_detected and pitch_impact is not None and impact_point is None:
+            impact_point = None
+
+        out.write(frame)
+
+    stump_prediction = predict_trajectory(ball_positions) if ball_positions else None
+    if stump_prediction:
+        pred_y, pred_z = stump_prediction
+        cv2.putText(frame, f"Predicted Stump Hit: ({pred_y:.2f}, {pred_z:.2f})", 
+                    (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 0), 2)
+        out.write(frame)
+
+    decision, reason = lbw_decision(pitch_impact, impact_point, stump_prediction)
+
+    cap.release()
+    out.release()
+
+    return decision, reason, output_path
+
+# Gradio interface
+iface = gr.Interface(
+    fn=process_video,
+    inputs=gr.Video(label="Upload Cricket Delivery Video"),
+    outputs=[
+        gr.Textbox(label="LBW Decision"),
+        gr.Textbox(label="Reason"),
+        gr.Video(label="Processed Video with Annotations")
+    ],
+    title="Gully Cricket DRS for LBW",
+    description="Upload a video of a cricket delivery to analyze LBW decisions."
+)
+
+if __name__ == "__main__":
+    iface.launch()