Update app.py

app.py

@@ -7,6 +7,7 @@ from scipy.interpolate import interp1d
 import plotly.graph_objects as go
 import uuid
 import os
+from scipy.ndimage import uniform_filter1d
 
 # Load the trained YOLOv8n model with optimizations
 model = YOLO("best.pt")
@@ -17,14 +18,13 @@ STUMPS_WIDTH = 0.2286  # meters (width of stumps)
 BALL_DIAMETER = 0.073  # meters (approx. cricket ball diameter)
 FRAME_RATE = 20  # Default frame rate, updated dynamically
 SLOW_MOTION_FACTOR = 1.5  # Faster replay (e.g., 30 / 1.5 = 20 FPS)
-CONF_THRESHOLD = 0.25  # Confidence threshold for detection
+CONF_THRESHOLD = 0.2  # Lowered for better detection
 IMPACT_ZONE_Y = 0.9  # Adjusted to 90% of frame height for impact zone
-IMPACT_VELOCITY_THRESHOLD = 500  # Reduced for better impact detection
 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 = 150  # Increased to include more detections
+MAX_POSITION_JUMP = 200  # Increased to include more detections
 
 def process_video(video_path):
     if not os.path.exists(video_path):
@@ -50,10 +50,11 @@ def process_video(video_path):
             break
         frame_count += 1
         frames.append(frame.copy())
-        # Enhance frame contrast and sharpness for better detection
-        frame = cv2.convertScaleAbs(frame, alpha=1.5, beta=20)
-        kernel = np.array([[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]])
-        frame = cv2.filter2D(frame, -1, kernel)
+        # Enhance frame contrast and apply adaptive thresholding
+        frame = cv2.convertScaleAbs(frame, alpha=1.3, beta=10)
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        frame = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2)
+        frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR)
         results = model.predict(frame, conf=CONF_THRESHOLD, imgsz=(img_height, img_width), iou=0.5, max_det=3)
         detections = sum(1 for detection in results[0].boxes if detection.cls == 0)
         if detections == 1:  # Only process frames with exactly one ball detection
@@ -99,6 +100,7 @@ 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 frames with one ball detection"
     frame_height, frame_width = frames[0].shape[:2]
+    debug_log = []
 
     # Filter out sudden changes in position for continuous trajectory
     filtered_positions = [ball_positions[0]]
@@ -121,24 +123,28 @@ def estimate_trajectory(ball_positions, frames, detection_frames):
     y_coords = [pos[1] for pos in filtered_positions]
     times = np.array(filtered_frames) / FRAME_RATE
 
+    # Smooth coordinates to avoid sudden jumps
+    x_coords = uniform_filter1d(x_coords, size=3)
+    y_coords = uniform_filter1d(y_coords, size=3)
+
     # Convert to 3D for visualization
-    detections_3d = [pixel_to_3d(x, y, frame_height, frame_width) for x, y in filtered_positions]
+    detections_3d = [pixel_to_3d(x, y, frame_height, frame_width) for x, y in zip(x_coords, y_coords)]
     
     # Pitch point: Detection with lowest y-coordinate (near bowler's end)
-    pitch_idx = min(range(len(filtered_positions)), key=lambda i: filtered_positions[i][1])
-    pitch_point = filtered_positions[pitch_idx]
+    pitch_idx = min(range(len(filtered_positions)), key=lambda i: y_coords[i])
+    pitch_point = (x_coords[pitch_idx], y_coords[pitch_idx])
     pitch_frame = filtered_frames[pitch_idx]
 
     # Impact point: Detection with highest y-coordinate after pitch point (near stumps)
     post_pitch_indices = [i for i in range(len(filtered_positions)) if filtered_frames[i] > pitch_frame]
     if not post_pitch_indices:
         return None, None, None, None, None, None, None, None, None, "Error: No detections after pitch point"
-    impact_idx = max(post_pitch_indices, key=lambda i: filtered_positions[i][1])
-    impact_point = filtered_positions[impact_idx]
+    impact_idx = max(post_pitch_indices, key=lambda i: y_coords[i])
+    impact_point = (x_coords[impact_idx], y_coords[impact_idx])
     impact_frame = filtered_frames[impact_idx]
 
     try:
-        # Use linear interpolation for more stable trajectory
+        # Use linear interpolation for stable trajectory
         fx = interp1d(times, x_coords, kind='linear', fill_value="extrapolate")
         fy = interp1d(times, y_coords, kind='linear', fill_value="extrapolate")
     except Exception as e:
@@ -156,13 +162,13 @@ def estimate_trajectory(ball_positions, frames, detection_frames):
     impact_point_3d = pixel_to_3d(impact_point[0], impact_point[1], frame_height, frame_width)
 
     # Debug trajectory and points
-    debug_log = [
+    debug_log.extend([
         f"Trajectory estimated successfully",
         f"Pitch point at frame {pitch_frame + 1}: ({pitch_point[0]:.1f}, {pitch_point[1]:.1f}), 3D: {pitch_point_3d}",
         f"Impact point at frame {impact_frame + 1}: ({impact_point[0]:.1f}, {impact_point[1]:.1f}), 3D: {impact_point_3d}",
         f"Detections in frames: {filtered_frames}",
-        f"Velocities: {velocities}" if 'velocities' in locals() else "Velocities: Not calculated"
-    ]
+        f"Total filtered detections: {len(filtered_frames)}"
+    ])
     # Save trajectory plot for debugging
     import matplotlib.pyplot as plt
     plt.plot(x_coords, y_coords, 'bo-', label='Filtered Detections')