Upload 8 files

app.py

@@ -0,0 +1,35 @@
+import cv2
+from ball_tracker import detect_ball
+from trajectory import predict_trajectory
+from lbw_engine import evaluate_lbw
+from overlay_display import draw_overlay
+
+cap = cv2.VideoCapture(0)
+ball_path = []
+
+while True:
+    ret, frame = cap.read()
+    if not ret:
+        break
+
+    ball = detect_ball(frame)
+    if ball:
+        ball_path.append(ball)
+
+    if len(ball_path) > 5:
+        a, b, c = predict_trajectory(ball_path)
+        trajectory_func = lambda x: a * x**2 + b * x + c
+
+        pitch_x = ball_path[0][0]
+        impact_x = ball_path[-1][0]
+        wicket_x = int((impact_x + 100) / 2)
+
+        verdict, pitch, impact, wickets = evaluate_lbw(pitch_x, impact_x, wicket_x, ball_path)
+        frame = draw_overlay(frame, ball_path, trajectory_func, verdict, (pitch, impact, wickets))
+
+    cv2.imshow("Gully Cricket DRS", frame)
+    if cv2.waitKey(1) == ord('q'):
+        break
+
+cap.release()
+cv2.destroyAllWindows()

ball_tracker.py

@@ -0,0 +1,21 @@
+import cv2
+import numpy as np
+
+def detect_ball(frame):
+    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
+    lower_red1 = np.array([0, 100, 100])
+    upper_red1 = np.array([10, 255, 255])
+    lower_red2 = np.array([160, 100, 100])
+    upper_red2 = np.array([180, 255, 255])
+    
+    mask1 = cv2.inRange(hsv, lower_red1, upper_red1)
+    mask2 = cv2.inRange(hsv, lower_red2, upper_red2)
+    mask = mask1 | mask2
+    
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if contours:
+        largest = max(contours, key=cv2.contourArea)
+        (x, y), radius = cv2.minEnclosingCircle(largest)
+        return (int(x), int(y))
+    return None
+

gradio_app.py

@@ -0,0 +1,53 @@
+import gradio as gr
+import cv2
+import numpy as np
+from ball_tracker import detect_ball
+from trajectory import predict_trajectory
+from lbw_engine import evaluate_lbw
+from overlay_display import draw_overlay
+import tempfile
+
+def process_video(video_file):
+    cap = cv2.VideoCapture(video_file)
+    ball_path = []
+    output_frames = []
+
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        ball = detect_ball(frame)
+        if ball:
+            ball_path.append(ball)
+
+        if len(ball_path) > 5:
+            try:
+                a, b, c = predict_trajectory(ball_path)
+                trajectory_func = lambda x: a * x**2 + b * x + c
+                pitch_x = ball_path[0][0]
+                impact_x = ball_path[-1][0]
+                wicket_x = int((impact_x + 100) / 2)
+                frame_width = frame.shape[1]
+                verdict, pitch, impact, wickets = evaluate_lbw(pitch_x, impact_x, wicket_x, ball_path, frame_width)
+                frame = draw_overlay(frame, ball_path, trajectory_func, verdict, (pitch, impact, wickets))
+            except Exception as e:
+                print("Prediction error:", e)
+
+        output_frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+
+    cap.release()
+
+    return output_frames[-1] if output_frames else None
+
+
+demo = gr.Interface(
+    fn=process_video,
+    inputs=gr.Video(label="Upload a Cricket Delivery Video"),
+    outputs=gr.Image(label="Decision Frame with Overlay"),
+    title="🏏 Gully Cricket DRS - LBW Analysis"
+)
+
+if __name__ == "__main__":
+    demo.launch(inbrowser=True, share=False)
+

lbw_engine.py

@@ -0,0 +1,17 @@
+def evaluate_lbw(pitch_x, impact_x, wicket_x, predicted_path, frame_width):
+    # Use frame-relative zones instead of fixed pixel values
+    leg_boundary = int(frame_width * 0.33)
+    off_boundary = int(frame_width * 0.66)
+
+    # Determine zones
+    pitch_zone = "In Line" if leg_boundary < pitch_x < off_boundary else "Outside Leg"
+    impact_zone = "In Line" if leg_boundary < impact_x < off_boundary else "Outside Off"
+    hitting_wickets = leg_boundary < wicket_x < off_boundary
+
+    if pitch_zone == "Outside Leg":
+        return "Not Out", pitch_zone, impact_zone, "Missing"
+    if impact_zone != "In Line":
+        return "Not Out", pitch_zone, impact_zone, "Missing"
+    if hitting_wickets:
+        return "Out", pitch_zone, impact_zone, "Hitting"
+    return "Not Out", pitch_zone, impact_zone, "Missing"

overlay_display.py

@@ -0,0 +1,69 @@
+import cv2
+
+def draw_overlay(frame, ball_points, trajectory_func, verdict, labels):
+    height, width = frame.shape[:2]
+
+    # 1. Draw smooth RED arc (trajectory)
+    draw_trajectory_arc(frame, trajectory_func, ball_points[0][0], ball_points[-1][0])
+
+    # 2. Draw BLUE prediction line from impact point forward
+    if len(ball_points) > 1:
+        draw_prediction_line(frame, ball_points[-1], trajectory_func)
+
+    # 3. Draw YELLOW stumps (centered)
+    draw_stumps(frame, width // 2)
+
+    # 4. Display Decision and Details
+    text_color = (0, 255, 0) if verdict == "Out" else (0, 255, 255)
+    cv2.putText(frame, f"Decision: {verdict}", (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 1.0, text_color, 3)
+    cv2.putText(frame, f"Pitching: {labels[0]}", (20, 75), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 255, 0), 2)
+    cv2.putText(frame, f"Impact: {labels[1]}", (20, 105), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 255, 0), 2)
+    cv2.putText(frame, f"Wickets: {labels[2]}", (20, 135), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 255, 0), 2)
+
+    return frame
+
+
+# ============================
+# 📦 Helper Drawing Functions
+# ============================
+
+def draw_trajectory_arc(frame, trajectory_func, start_x, end_x, step=5, color=(0, 0, 255)):
+    height, width = frame.shape[:2]
+    for x in range(start_x, min(end_x, width - step), step):
+        try:
+            y1 = int(trajectory_func(x))
+            y2 = int(trajectory_func(x + step))
+            if 0 <= y1 < height and 0 <= y2 < height:
+                cv2.line(frame, (x, y1), (x + step, y2), color, 2)
+        except:
+            continue
+
+def draw_prediction_line(frame, start_point, trajectory_func, distance=100, color=(255, 0, 0)):
+    x1 = start_point[0]
+    x2 = x1 + distance
+    try:
+        y2 = int(trajectory_func(x2))
+        height, width = frame.shape[:2]
+        if 0 <= y2 < height and x2 < width:
+            cv2.line(frame, start_point, (x2, y2), color, 2)
+    except:
+        pass
+
+def draw_stumps(frame, center_x, color=(0, 255, 255)):
+    height = frame.shape[0]
+    stump_top = int(height * 0.55)
+    stump_bottom = int(height * 0.85)
+    for dx in [-10, 0, 10]:
+        cv2.line(frame, (center_x + dx, stump_top), (center_x + dx, stump_bottom), color, 2)
+
+def draw_ball_path(frame, ball_path, color=(0, 255, 0)):
+    for i in range(1, len(ball_path)):
+        cv2.line(frame, ball_path[i - 1], ball_path[i], color, thickness=2)
+
+def draw_ball(frame, position, radius=5, color=(0, 0, 255)):
+    cv2.circle(frame, position, radius, color, -1)
+
+def draw_pitch_impact_wickets(frame, pitch, impact, wickets):
+    cv2.putText(frame, f"Pitch: {pitch}", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 0), 2)
+    cv2.putText(frame, f"Impact: {impact}", (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 0), 2)
+    cv2.putText(frame, f"Wickets: {wickets}", (10, 90), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 0), 2)

test_app.py

@@ -0,0 +1,2 @@
+import streamlit as st
+st.title("✅ Streamlit is working properly")

trajectory.py

@@ -0,0 +1,22 @@
+import numpy as np
+from scipy.optimize import curve_fit
+
+def predict_trajectory(points):
+    if len(points) < 5:
+        raise ValueError("Not enough data points for trajectory prediction.")
+
+    points = np.array(points)
+    x = points[:, 0]
+    y = points[:, 1]
+
+    def poly2(x, a, b, c):
+        return a * x**2 + b * x + c
+
+    try:
+        params, _ = curve_fit(poly2, x, y)
+    except Exception as e:
+        print(f"Curve fitting failed: {e}")
+        raise e
+
+    return params
+