Update app.py

app.py

@@ -24,6 +24,7 @@ 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 = 100  # Pixels, threshold for unexpected position changes
 
 def process_video(video_path):
     if not os.path.exists(video_path):
@@ -50,10 +51,11 @@ def process_video(video_path):
         for detection in results[0].boxes:
             if detection.cls == 0:  # Class 0 is the ball
                 detections += 1
-                x1, y1, x2, y2 = detection.xyxy[0].cpu().numpy()
-                ball_positions.append([(x1 + x2) / 2, (y1 + y2) / 2])
-                detection_frames.append(frame_count - 1)
-                cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), 2)
+                if detections == 1:  # Only consider frames with exactly one detection
+                    x1, y1, x2, y2 = detection.xyxy[0].cpu().numpy()
+                    ball_positions.append([(x1 + x2) / 2, (y1 + y2) / 2])
+                    detection_frames.append(frame_count - 1)
+                    cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), 2)
         frames[-1] = frame
         debug_log.append(f"Frame {frame_count}: {detections} ball detections")
     cap.release()
@@ -80,12 +82,26 @@ def estimate_trajectory(ball_positions, frames, detection_frames):
         return None, None, None, None, None, None, None, None, None, "Error: Fewer than 2 ball detections for trajectory"
     frame_height, frame_width = frames[0].shape[:2]
 
-    x_coords = [pos[0] for pos in ball_positions]
-    y_coords = [pos[1] for pos in ball_positions]
-    times = np.array(detection_frames) / FRAME_RATE
+    # Filter out unexpected jumps in position
+    filtered_positions = [ball_positions[0]]
+    filtered_frames = [detection_frames[0]]
+    for i in range(1, len(ball_positions)):
+        prev_pos = ball_positions[i-1]
+        curr_pos = ball_positions[i]
+        distance = np.sqrt((curr_pos[0] - prev_pos[0])**2 + (curr_pos[1] - prev_pos[1])**2)
+        if distance <= MAX_POSITION_JUMP:
+            filtered_positions.append(curr_pos)
+            filtered_frames.append(detection_frames[i])
 
-    pitch_point = ball_positions[0]
-    pitch_frame = detection_frames[0]
+    if len(filtered_positions) < 2:
+        return None, None, None, None, None, None, None, None, None, "Error: Fewer than 2 valid ball detections after filtering"
+
+    x_coords = [pos[0] for pos in filtered_positions]
+    y_coords = [pos[1] for pos in filtered_positions]
+    times = np.array(filtered_frames) / FRAME_RATE
+
+    pitch_point = filtered_positions[0]
+    pitch_frame = filtered_frames[0]
 
     # Prioritize sudden y-change for impact detection
     impact_idx = None
@@ -94,16 +110,16 @@ def estimate_trajectory(ball_positions, frames, detection_frames):
         delta_y = abs(y_coords[i] - y_coords[i-1])
         if delta_y > IMPACT_DELTA_Y:
             impact_idx = i
-            impact_frame = detection_frames[i]
+            impact_frame = filtered_frames[i]
             break
         elif y_coords[i] > frame_height * IMPACT_ZONE_Y:
             impact_idx = i
-            impact_frame = detection_frames[i]
+            impact_frame = filtered_frames[i]
             break
     if impact_idx is None:
-        impact_idx = len(ball_positions) - 1
-        impact_frame = detection_frames[-1]
-    impact_point = ball_positions[impact_idx]
+        impact_idx = len(filtered_positions) - 1
+        impact_frame = filtered_frames[-1]
+    impact_point = filtered_positions[impact_idx]
 
     try:
         fx = interp1d(times[:impact_idx + 1], x_coords[:impact_idx + 1], kind='linear', fill_value="extrapolate")
@@ -111,13 +127,13 @@ def estimate_trajectory(ball_positions, frames, detection_frames):
     except Exception as e:
         return None, None, None, None, None, None, None, None, None, f"Error in trajectory interpolation: {str(e)}"
 
-    t_full = np.linspace(times[0], times[-1] + 0.5, len(times) + 10)
+    t_full = np.linspace(times[0], times[-1] + 0.5, len(times) * 2)  # Smoother trajectory
     x_full = fx(t_full)
     y_full = fy(t_full)
     trajectory_2d = list(zip(x_full, y_full))
 
     trajectory_3d = [pixel_to_3d(x, y, frame_height, frame_width) for x, y in trajectory_2d]
-    detections_3d = [pixel_to_3d(x, y, frame_height, frame_width) for x, y in ball_positions]
+    detections_3d = [pixel_to_3d(x, y, frame_height, frame_width) for x, y in filtered_positions]
     pitch_point_3d = pixel_to_3d(pitch_point[0], pitch_point[1], frame_height, frame_width)
     impact_point_3d = pixel_to_3d(impact_point[0], impact_point[1], frame_height, frame_width)
 
@@ -125,7 +141,7 @@ def estimate_trajectory(ball_positions, frames, detection_frames):
         f"Trajectory estimated successfully\n"
         f"Pitch point at frame {pitch_frame + 1}: ({pitch_point[0]:.1f}, {pitch_point[1]:.1f})\n"
         f"Impact point at frame {impact_frame + 1}: ({impact_point[0]:.1f}, {impact_point[1]:.1f})\n"
-        f"Detections in frames: {detection_frames}"
+        f"Detections in frames: {filtered_frames}"
     )
     return trajectory_2d, pitch_point, impact_point, pitch_frame, impact_frame, detections_3d, trajectory_3d, pitch_point_3d, impact_point_3d, debug_log