Upload 9 files

app.py

@@ -0,0 +1,51 @@
+import streamlit as st
+import os
+import logging
+from gully_drs_core.ball_detection import process_video
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Streamlit configuration
+st.set_page_config(page_title="GullyDRS", layout="wide")
+st.title("GullyDRS - AI-Powered Decision Review System")
+
+# Directories for uploads and outputs
+UPLOAD_DIR = "uploads"
+OUTPUT_DIR = "outputs"
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+def main():
+    st.header("Upload Match Video for DRS Analysis")
+    uploaded_file = st.file_uploader("Choose a video file (MP4, AVI)", type=["mp4", "avi"])
+    
+    if uploaded_file is not None:
+        try:
+            # Save uploaded video
+            video_path = os.path.join(UPLOAD_DIR, uploaded_file.name)
+            with open(video_path, "wb") as f:
+                f.write(uploaded_file.getbuffer())
+            st.success(f"Video '{uploaded_file.name}' uploaded successfully!")
+            
+            # Process video
+            with st.spinner("Processing video for DRS analysis..."):
+                result = process_video(video_path)
+                if result["status"] == "success":
+                    # Display replay video (live preview)
+                    st.subheader("Replay Video")
+                    st.video(result["replay_path"])
+                    st.write(f"**LBW Decision**: {result['decision']}")
+                    st.write(f"**Ball Speed**: {result['speed_kmh']:.2f} km/h")
+                    # External test frame (local file access for testing)
+                    st.subheader("External Replay (Test Frame)")
+                    st.markdown(f'<video width="640" height="360" controls><source src="file://{result["replay_path"]}" type="video/mp4"></video>', unsafe_allow_html=True)
+                else:
+                    st.error(f"Error: {result['error']}")
+        except Exception as e:
+            logger.error(f"Error processing video: {str(e)}")
+            st.error(f"Failed to process video: {str(e)}")
+
+if __name__ == "__main__":
+    main()

gully_drs_core/ball_detection.py

@@ -0,0 +1,91 @@
+import cv2
+import numpy as np
+import torch
+import logging
+import os
+from gully_drs_core.replay_utils import generate_replay
+from gully_drs_core.video_utils import get_video_properties
+from gully_drs_core.model_utils import load_yolo_model
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Load YOLOv5 model
+model = load_yolo_model()
+
+# Stump zone coordinates (example, adjust based on video resolution)
+STUMP_ZONE = [(200, 400), (300, 400), (300, 600), (200, 600)]  # [x1,y1, x2,y2, x3,y3, x4,y4]
+
+def process_video(video_path):
+    try:
+        # Validate video file
+        if not os.path.exists(video_path):
+            return {"status": "error", "error": "Video file not found"}
+        
+        # Get video properties
+        fps, width, height = get_video_properties(video_path)
+        if fps == 0:
+            return {"status": "error", "error": "Invalid video file"}
+        
+        # Initialize video capture
+        cap = cv2.VideoCapture(video_path)
+        ball_positions = []
+        bounce_point = None
+        frame_count = 0
+        
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+            
+            # Detect ball using YOLOv5
+            results = model(frame)
+            detections = results.xyxy[0].cpu().numpy()  # [x1, y1, x2, y2, conf, class]
+            
+            ball_center = None
+            for det in detections:
+                if det[5] == 0:  # Assuming class 0 is the ball
+                    x1, y1, x2, y2 = map(int, det[:4])
+                    ball_center = ((x1 + x2) // 2, (y1 + y2) // 2)
+                    ball_positions.append(ball_center)
+                    # Detect bounce point (simplified: assume bounce near ground)
+                    if y1 > height * 0.8 and bounce_point is None:
+                        bounce_point = ball_center
+                    break
+            
+            frame_count += 1
+        
+        cap.release()
+        
+        # Check LBW decision
+        decision = "Not Out"
+        for pos in ball_positions:
+            if is_ball_in_stump_zone(pos):
+                decision = "Out"
+                break
+        
+        # Calculate speed (pixels per frame to km/h)
+        speed_kmh = 0
+        if len(ball_positions) >= 2:
+            pixel_dist = np.sqrt((ball_positions[-1][0] - ball_positions[-2][0])**2 +
+                                 (ball_positions[-1][1] - ball_positions[-2][1])**2)
+            speed_kmh = (pixel_dist / (1/fps)) * 0.036  # Simplified conversion, adjust scale factor
+        
+        # Generate replay video
+        replay_path = generate_replay(video_path, ball_positions, STUMP_ZONE, decision, speed_kmh, bounce_point)
+        
+        return {
+            "status": "success",
+            "decision": decision,
+            "speed_kmh": speed_kmh,
+            "replay_path": replay_path
+        }
+    except Exception as e:
+        logger.error(f"Error processing video: {str(e)}")
+        return {"status": "error", "error": str(e)}
+
+def is_ball_in_stump_zone(ball_center):
+    x, y = ball_center
+    x1, y1, x2, y2, x3, y3, x4, y4 = STUMP_ZONE[0] + STUMP_ZONE[1] + STUMP_ZONE[2] + STUMP_ZONE[3]
+    return (x1 <= x <= x2) and (y1 <= y <= y3)

gully_drs_core/init__.py

@@ -0,0 +1 @@
+# Package initialization for gully_drs_core

gully_drs_core/model_utils.py

@@ -0,0 +1,17 @@
+import torch
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def load_yolo_model():
+    try:
+        # Load YOLOv5s model (use pre-trained or fine-tuned weights)
+        model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True)
+        model.eval()
+        logger.info("YOLOv5 model loaded successfully")
+        return model
+    except Exception as e:
+        logger.error(f"Error loading YOLOv5 model: {str(e)}")
+        raise

gully_drs_core/replay_utils.py

@@ -0,0 +1,61 @@
+import cv2
+import numpy as np
+from scipy.interpolate import CubicSpline
+import os
+from gully_drs_core.video_utils import get_video_properties
+
+def generate_replay(video_path, ball_positions, stump_zone, decision, speed_kmh, bounce_point):
+    try:
+        # Get video properties
+        fps, width, height = get_video_properties(video_path)
+        
+        # Initialize video capture and output
+        cap = cv2.VideoCapture(video_path)
+        output_path = os.path.join("outputs", f"replay_{os.path.basename(video_path)}")
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+        
+        frame_idx = 0
+        
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+            
+            # Draw stump zone
+            cv2.polylines(frame, [np.array(stump_zone)], isClosed=True, color=(0, 0, 255), thickness=2)
+            
+            # Draw ball position
+            if frame_idx < len(ball_positions):
+                x, y = ball_positions[frame_idx]
+                cv2.circle(frame, (x, y), 5, (0, 255, 0), -1)
+            
+            # Draw bounce point
+            if bounce_point and frame_idx >= len(ball_positions) // 2:
+                cv2.circle(frame, bounce_point, 8, (255, 255, 0), -1)
+            
+            # Draw Bezier curve trajectory
+            if len(ball_positions) > 3 and frame_idx < len(ball_positions):
+                points = np.array(ball_positions[:frame_idx + 1])
+                if len(points) > 3:
+                    t = np.linspace(0, 1, len(points))
+                    cs_x = CubicSpline(t, points[:, 0])
+                    cs_y = CubicSpline(t, points[:, 1])
+                    t_fine = np.linspace(0, 1, min(100, len(points) * 10))
+                    curve_x = cs_x(t_fine).astype(int)
+                    curve_y = cs_y(t_fine).astype(int)
+                    for i in range(1, len(curve_x)):
+                        cv2.line(frame, (curve_x[i-1], curve_y[i-1]), (curve_x[i], curve_y[i]), (255, 0, 0), 2)
+            
+            # Add text overlays
+            cv2.putText(frame, f"Decision: {decision}", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
+            cv2.putText(frame, f"Speed: {speed_kmh:.2f} km/h", (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
+            
+            out.write(frame)
+            frame_idx += 1
+        
+        cap.release()
+        out.release()
+        return output_path
+    except Exception as e:
+        raise Exception(f"Error generating replay: {str(e)}")

gully_drs_core/video_utils.py

@@ -0,0 +1,21 @@
+import cv2
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def get_video_properties(video_path):
+    try:
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            logger.error("Failed to open video file")
+            return 0, 0, 0
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        cap.release()
+        return fps, width, height
+    except Exception as e:
+        logger.error(f"Error getting video properties: {str(e)}")
+        return 0, 0, 0

pages/live_match.py

@@ -0,0 +1,5 @@
+import streamlit as st
+
+st.set_page_config(page_title="GullyDRS - Live Match")
+st.title("GullyDRS - Live Match")
+st.write("Live match analysis is planned for future phases.")

pages/upload_analysis.py

@@ -0,0 +1,5 @@
+import streamlit as st
+
+st.set_page_config(page_title="GullyDRS - Upload Analysis")
+st.title("GullyDRS - Upload Analysis")
+st.write("Upload a match video for DRS analysis. Navigate to the Home page to process videos.")

requirements.txt

@@ -0,0 +1,6 @@
+streamlit==1.35.0
+opencv-python==4.10.0
+torch==2.0.1
+yolov5==7.0.12
+numpy==1.26.4
+scipy==1.13.1