Update app.py

app.py

@@ -1,19 +1,99 @@
+I understand your concern. You're expecting a real-time DRS (Decision Review System) output similar to what you see in international T20 cricket matches, with precise ball tracking, pitch analysis, and wicket-hitting prediction, as used by third umpires. The current output—while functional—falls short of that professional standard in terms of accuracy, visualization, and real-time capability. Let’s break down the gap between your expectations and the current output, then outline how to achieve a more professional DRS-like system.
+
+Understanding Your Expectation
+In international T20 matches, the DRS (e.g., Hawk-Eye) provides:
+
+Real-Time Ball Tracking:
+High-speed cameras (e.g., 6–8 cameras at 500+ fps) track the ball from the bowler’s release to impact.
+A smooth 3D trajectory is shown, often as a curved path, accounting for swing, spin, and bounce.
+Pitch Analysis:
+The system identifies the exact pitching point (where the ball bounces) and checks if it’s in line with the stumps (inside, outside leg, or outside off).
+A 2D or 3D pitch map shows the pitching point relative to the stumps.
+Wicket-Hitting Prediction:
+The system predicts the ball’s path after impact (e.g., hitting the pad) to determine if it would hit the stumps.
+A 3D visualization shows the projected path, often with a “stump cam” view indicating whether the ball would hit, miss, or clip the stumps.
+Detailed Decision:
+The DRS provides a step-by-step breakdown: pitching (inline/outside), impact (inline/outside), and wicket-hitting (yes/no).
+A final decision (“Out” or “Not Out”) is shown with high accuracy (99.9% in professional systems).
+Professional Visualization:
+Smooth animations of the ball’s path (curved, not linear).
+3D renderings of the pitch, stumps, and trajectory.
+Clear annotations (e.g., “Ball Pitching: Inline,” “Impact: Inline,” “Wickets: Hitting”).
+The current app output, while a starting point, has these shortcomings:
+
+Simplified Tracking: It uses basic OpenCV to detect the ball in a pre-uploaded video, not real-time camera feeds.
+Linear Trajectories: The red (actual) and blue (projected) paths are linear, not curved, and don’t account for swing or spin.
+Basic Pitch Analysis: Pitching and impact points are estimated roughly, not precisely detected.
+2D Visualization: The visualization is a flat 2D canvas, lacking the 3D depth and smoothness of professional DRS.
+Dummy ML Model: The LBW decision uses a simplistic logistic regression model, not a robust ML system trained on real cricket data.
+Not Real-Time: The app processes uploaded videos, not live camera feeds.
+How to Achieve a Real-Time DRS-Like System
+To meet your expectations, we need to upgrade the app to handle real-time ball tracking, accurate pitch analysis, wicket-hitting prediction, and professional-grade visualization. Here’s a step-by-step plan, followed by updated code to move closer to your goal.
+
+Key Requirements for a DRS-Like System
+Real-Time Camera Integration:
+Use multiple high-speed cameras (e.g., 120–240 fps) to capture the ball’s movement live.
+Process camera feeds in real-time to track the ball.
+Note: Hugging Face Spaces cannot access cameras (no webcam support), so this must be done locally or on a server with camera access.
+Advanced Ball Tracking:
+Use computer vision (OpenCV) to detect the ball in each frame.
+Apply trajectory smoothing (e.g., spline interpolation) to create a curved path.
+Detect swing (lateral deviation) and spin (rotation).
+Pitch and Impact Detection:
+Identify the pitching point by detecting the ball’s bounce (sudden change in y-coordinate).
+Detect the impact point by identifying when the ball stops (e.g., hits the pad, often with a sudden slowdown).
+Use pitch markings (e.g., creases, stumps) to determine if pitching/impact is inline.
+Wicket-Hitting Prediction:
+Model the ball’s physics (swing, spin, bounce) to predict the post-impact path.
+Use an ML model to refine predictions based on historical data.
+Professional Visualization:
+Use a 3D rendering library (e.g., Three.js) for realistic trajectory visualization.
+Show a detailed breakdown (pitching, impact, wicket-hitting) with annotations.
+Robust ML Model:
+Train a deep learning model (e.g., CNN) on real cricket video data to predict LBW outcomes.
+Host the model on Hugging Face Model Hub for inference.
+Challenges
+Hardware: Professional DRS uses 6–8 high-speed cameras ($100,000+ setup). For a playground, 2–4 consumer cameras (e.g., GoPro, $500–$2,000 each) can work but reduce accuracy.
+Real-Time Processing: Processing multiple camera feeds in real-time requires significant compute power (e.g., GPU server). Hugging Face Spaces (free tier: 2 vCPUs, 8GB RAM) can’t handle this; you’ll need a local setup or cloud server (e.g., AWS).
+Data: Training an ML model for LBW requires labeled cricket video data (scarce publicly). You may need to collect and annotate your own dataset.
+Visualization: 3D rendering (e.g., with Three.js) is more complex than the current 2D Canvas and requires additional setup.
+Plan to Achieve DRS-Like Output
+Since real-time camera integration and 3D visualization are complex, let’s break this into phases. For now, we’ll enhance the app to:
+
+Improve ball tracking with smoother trajectories.
+Add detailed LBW analysis (pitching, impact, wicket-hitting breakdown).
+Upgrade visualization to show a more professional 2D output (we’ll add 3D later).
+Provide guidance for real-time setup (local or cloud).
+Updated Code
+app.py
+This version improves ball tracking, adds detailed LBW analysis, and prepares for real-time integration.
+
+python
+
+Collapse
+
+Wrap
+
+Run
+
+Copy
 from flask import Flask, render_template, request, jsonify
 import numpy as np
 from sklearn.linear_model import LogisticRegression
 import cv2
 import os
 from werkzeug.utils import secure_filename
+from scipy.interpolate import splprep, splev  # For smooth trajectory
 
 app = Flask(__name__)
 
-# Configure upload folder to use /tmp (writable on Hugging Face Spaces)
+# Configure upload folder
 UPLOAD_FOLDER = '/tmp/uploads'
-os.makedirs(UPLOAD_FOLDER, exist_ok=True)  # This should now work in /tmp
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
 app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
 ALLOWED_EXTENSIONS = {'mp4', 'avi', 'mov'}
 
-# Dummy ML model for LBW decision
+# Dummy ML model for LBW decision (to be replaced with a real model)
 def train_dummy_model():
     X = np.array([
         [0.5, 0.0, 0.4, 0.5, 30, 0],  # Not Out
@@ -28,30 +108,39 @@ def train_dummy_model():
 
 model = train_dummy_model()
 
-# Check allowed file extensions
 def allowed_file(filename):
     return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
 
-# Process video to extract ball trajectory
+def smooth_trajectory(points):
+    if len(points) < 3:
+        return points
+    x = [p["x"] for p in points]
+    y = [p["y"] for p in points]
+    tck, u = splprep([x, y], s=0)
+    u_new = np.linspace(0, 1, 50)  # Smooth with 50 points
+    x_new, y_new = splev(u_new, tck)
+    return [{"x": x, "y": y} for x, y in zip(x_new, y_new)]
+
 def process_video(video_path):
     cap = cv2.VideoCapture(video_path)
     if not cap.isOpened():
         return None, None, "Failed to open video"
 
-    # Lists to store trajectory points
     actual_path = []
     frame_count = 0
-    total_speed = 0
-    spin = 0  # Simplified: Assume no spin for now
+    spin = 0
+    last_point = None
+    pitching_detected = False
+    impact_detected = False
+    y_positions = []
 
     while cap.isOpened():
         ret, frame = cap.read()
         if not ret:
             break
 
-        # Convert to HSV and detect ball (assuming a red ball)
         hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
-        mask = cv2.inRange(hsv, (0, 120, 70), (10, 255, 255))
+        mask = cv2.inRange(hsv, (0, 120, 70), (10, 255, 255))  # Adjust for your ball color
         contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
 
         if contours:
@@ -59,14 +148,33 @@ def process_video(video_path):
             x, y, w, h = cv2.boundingRect(c)
             center_x = x + w / 2
             center_y = y + h / 2
-
-            # Normalize coordinates to 0-1 (assuming 1280x720 video resolution)
             norm_x = center_x / 1280
             norm_y = center_y / 720
-            actual_path.append({"x": norm_x, "y": norm_y})
+            current_point = (norm_x, norm_y)
+
+            if last_point != current_point:
+                actual_path.append({"x": norm_x, "y": norm_y})
+                y_positions.append(norm_y)
+                last_point = current_point
+
+            # Detect pitching (first significant downward movement)
+            if len(y_positions) > 2 and not pitching_detected:
+                if y_positions[-1] < y_positions[-2] and y_positions[-2] < y_positions[-3]:
+                    pitching_detected = True
+                    pitching_x = actual_path[-2]["x"]
+                    pitching_y = actual_path[-2]["y"]
+
+            # Detect impact (sudden slowdown or stop)
+            if len(actual_path) > 2 and not impact_detected:
+                speed_current = abs(y_positions[-1] - y_positions[-2])
+                speed_prev = abs(y_positions[-2] - y_positions[-3])
+                if speed_current < speed_prev * 0.3:  # Significant slowdown
+                    impact_detected = True
+                    impact_x = actual_path[-1]["x"]
+                    impact_y = actual_path[-1]["y"]
 
         frame_count += 1
-        if frame_count > 30:  # Process first 30 frames for simplicity
+        if frame_count > 50:  # Process more frames for accuracy
             break
 
     cap.release()
@@ -74,23 +182,32 @@ def process_video(video_path):
     if not actual_path:
         return None, None, "No ball detected in video"
 
-    # Assume last point is impact, calculate pitching as midpoint
-    pitching_x = actual_path[len(actual_path)//2]["x"]
-    pitching_y = actual_path[len(actual_path)//2]["y"]
-    impact_x = actual_path[-1]["x"]
-    impact_y = actual_path[-1]["y"]
+    if not pitching_detected:
+        pitching_x = actual_path[len(actual_path)//2]["x"]
+        pitching_y = actual_path[len(actual_path)//2]["y"]
+
+    if not impact_detected:
+        impact_x = actual_path[-1]["x"]
+        impact_y = actual_path[-1]["y"]
 
-    # Simulate speed (frames per second to m/s, rough estimate)
     fps = cap.get(cv2.CAP_PROP_FPS) or 30
-    speed = (len(actual_path) / (frame_count / fps)) * 0.5  # Simplified conversion
+    speed = (len(actual_path) / (frame_count / fps)) * 0.5
 
-    # Projected path (linear from impact to stumps, adjusted for spin)
+    # Smooth the actual path
+    actual_path = smooth_trajectory(actual_path)
+
+    # Projected path with basic physics (linear for now, add swing/spin later)
     projected_path = [
         {"x": impact_x, "y": impact_y},
-        {"x": impact_x + spin * 0.1, "y": 1.0}  # Stumps at y=1.0
+        {"x": impact_x + spin * 0.1, "y": 1.0}
     ]
 
-    return actual_path, projected_path, pitching_x, pitching_y, impact_x, impact_y, speed, spin
+    # Determine pitching and impact status
+    pitching_status = "Inline" if 0.4 <= pitching_x <= 0.6 else "Outside Leg" if pitching_x < 0.4 else "Outside Off"
+    impact_status = "Inline" if 0.4 <= impact_x <= 0.6 else "Outside"
+    wicket_status = "Hitting" if 0.4 <= projected_path[-1]["x"] <= 0.6 else "Missing"
+
+    return actual_path, projected_path, pitching_x, pitching_y, impact_x, impact_y, speed, spin, pitching_status, impact_status, wicket_status
 
 @app.route('/')
 def index():
@@ -105,26 +222,22 @@ def analyze():
     if file.filename == '' or not allowed_file(file.filename):
         return jsonify({'error': 'Invalid file'}), 400
 
-    # Save the uploaded video
     filename = secure_filename(file.filename)
     video_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
     file.save(video_path)
 
-    # Process video
     result = process_video(video_path)
     if result[0] is None:
-        os.remove(video_path)  # Clean up
-        return jsonify({'error': result[2]}), 400  # result[2] holds error message
+        os.remove(video_path)
+        return jsonify({'error': result[2]}), 400
 
-    actual_path, projected_path, pitching_x, pitching_y, impact_x, impact_y, speed, spin = result
+    actual_path, projected_path, pitching_x, pitching_y, impact_x, impact_y, speed, spin, pitching_status, impact_status, wicket_status = result
 
-    # Predict LBW decision
     features = np.array([[pitching_x, pitching_y, impact_x, impact_y, speed, spin]])
     prediction = model.predict(features)[0]
-    confidence = model.predict_proba(features)[0][prediction]
+    confidence = min(model.predict_proba(features)[0][prediction], 0.99)
     decision = "Out" if prediction == 1 else "Not Out"
 
-    # Clean up
     os.remove(video_path)
 
     return jsonify({
@@ -132,8 +245,9 @@ def analyze():
         'projected_path': projected_path,
         'decision': decision,
         'confidence': round(confidence, 2),
-        'pitching': {'x': pitching_x, 'y': pitching_y},
-        'impact': {'x': impact_x, 'y': impact_y}
+        'pitching': {'x': pitching_x, 'y': pitching_y, 'status': pitching_status},
+        'impact': {'x': impact_x, 'y': impact_y, 'status': impact_status},
+        'wicket': wicket_status
     })
 
 if __name__ == '__main__':