Update app.py

app.py

@@ -16,15 +16,15 @@ model.to('cuda' if torch.cuda.is_available() else 'cpu')  # Use GPU if available
 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 = 3  # For very slow motion (3x slower)
-CONF_THRESHOLD = 0.25  # Lowered further to improve detection chances
-IMPACT_ZONE_Y = 0.8  # Fraction of frame height for impact zone
-IMPACT_VELOCITY_THRESHOLD = 1000  # Pixels/second for detecting impact
+SLOW_MOTION_FACTOR = 1.5  # Faster replay (e.g., 30 / 1.5 = 20 FPS)
+CONF_THRESHOLD = 0.25  # Confidence threshold for 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 = 50  # For smoother trajectory filtering
+MAX_POSITION_JUMP = 150  # Increased to include more detections
 
 def process_video(video_path):
     if not os.path.exists(video_path):
@@ -59,6 +59,7 @@ def process_video(video_path):
         if detections == 1:  # Only process frames with exactly one ball detection
             for detection in results[0].boxes:
                 if detection.cls == 0:  # Class 0 is the ball
+                    conf = detection.conf.cpu().numpy()[0]
                     x1, y1, x2, y2 = detection.xyxy[0].cpu().numpy()
                     # Scale coordinates back to original frame size
                     x1 = x1 * frame_width / img_width
@@ -68,8 +69,10 @@ def process_video(video_path):
                     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)
+                    debug_log.append(f"Frame {frame_count}: 1 ball detection, confidence={conf:.3f}")
+        else:
+            debug_log.append(f"Frame {frame_count}: {detections} ball detections")
         frames[-1] = frame
-        debug_log.append(f"Frame {frame_count}: {detections} ball detections")
         # Save debug frame
         cv2.imwrite(f"debug_frame_{frame_count}.jpg", frame)
     cap.release()
@@ -108,6 +111,7 @@ def estimate_trajectory(ball_positions, frames, detection_frames):
             filtered_positions.append(curr_pos)
             filtered_frames.append(detection_frames[i])
         else:
+            debug_log.append(f"Filtered out detection at frame {detection_frames[i] + 1}: large jump ({distance:.1f} pixels)")
             continue
 
     if len(filtered_positions) < 2:
@@ -117,43 +121,32 @@ def estimate_trajectory(ball_positions, frames, detection_frames):
     y_coords = [pos[1] for pos in filtered_positions]
     times = np.array(filtered_frames) / FRAME_RATE
 
-    # Convert to 3D for pitch point detection
+    # Convert to 3D for visualization
     detections_3d = [pixel_to_3d(x, y, frame_height, frame_width) for x, y in filtered_positions]
     
-    # Pitch point: Detection with lowest z-coordinate (closest to ground)
-    pitch_idx = min(range(len(detections_3d)), key=lambda i: detections_3d[i][2])
+    # 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_frame = filtered_frames[pitch_idx]
 
-    # Impact point: Detect sudden velocity change or impact zone
-    impact_idx = None
-    impact_frame = None
-    velocities = [np.sqrt((x_coords[i] - x_coords[i-1])**2 + (y_coords[i] - y_coords[i-1])**2) / (times[i] - times[i-1]) 
-                  for i in range(1, len(x_coords))]
-    for i in range(1, len(y_coords)):
-        if velocities[i-1] > IMPACT_VELOCITY_THRESHOLD:
-            impact_idx = i
-            impact_frame = filtered_frames[i]
-            break
-        elif y_coords[i] > frame_height * IMPACT_ZONE_Y:
-            impact_idx = i
-            impact_frame = filtered_frames[i]
-            break
-    if impact_idx is None:
-        impact_idx = len(filtered_positions) - 1
-        impact_frame = filtered_frames[-1]
+    # 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_frame = filtered_frames[impact_idx]
 
     try:
         # Use linear interpolation for more stable trajectory
-        fx = interp1d(times[:impact_idx + 1], x_coords[:impact_idx + 1], kind='linear', fill_value="extrapolate")
-        fy = interp1d(times[:impact_idx + 1], y_coords[:impact_idx + 1], kind='linear', fill_value="extrapolate")
+        fx = interp1d(times, x_coords, kind='linear', fill_value="extrapolate")
+        fy = interp1d(times, y_coords, kind='linear', fill_value="extrapolate")
     except Exception as e:
         return None, None, None, None, None, None, None, None, None, f"Error in trajectory interpolation: {str(e)}"
 
     # Generate dense points for all frames between first and last detection
     total_frames = max(detection_frames) - min(detection_frames) + 1
-    t_full = np.linspace(times[0], times[impact_idx], total_frames * SLOW_MOTION_FACTOR)
+    t_full = np.linspace(times[0], times[-1], total_frames * SLOW_MOTION_FACTOR)
     x_full = fx(t_full)
     y_full = fy(t_full)
     trajectory_2d = list(zip(x_full, y_full))
@@ -163,13 +156,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 = (
-        f"Trajectory estimated successfully\n"
-        f"Pitch point at frame {pitch_frame + 1}: ({pitch_point[0]:.1f}, {pitch_point[1]:.1f}), 3D: {pitch_point_3d}\n"
-        f"Impact point at frame {impact_frame + 1}: ({impact_point[0]:.1f}, {impact_point[1]:.1f}), 3D: {impact_point_3d}\n"
-        f"Detections in frames: {filtered_frames}\n"
-        f"Velocities: {velocities}"
-    )
+    debug_log = [
+        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"
+    ]
     # Save trajectory plot for debugging
     import matplotlib.pyplot as plt
     plt.plot(x_coords, y_coords, 'bo-', label='Filtered Detections')
@@ -178,7 +171,7 @@ def estimate_trajectory(ball_positions, frames, detection_frames):
     plt.legend()
     plt.savefig("trajectory_debug.png")
 
-    return trajectory_2d, pitch_point, impact_point, pitch_frame, impact_frame, detections_3d, trajectory_3d, pitch_point_3d, impact_point_3d, debug_log
+    return trajectory_2d, pitch_point, impact_point, pitch_frame, impact_frame, detections_3d, trajectory_3d, pitch_point_3d, impact_point_3d, "\n".join(debug_log)
 
 def create_3d_plot(detections_3d, trajectory_3d, pitch_point_3d, impact_point_3d, plot_type="detections"):
     """Create 3D Plotly visualization for detections or trajectory using single-detection frames."""
@@ -291,18 +284,18 @@ def generate_slow_motion(frames, trajectory, pitch_point, impact_point, detectio
         frame_idx = i - min_frame if trajectory_indices else -1
         if frame_idx >= 0 and frame_idx < total_frames and trajectory_points.size > 0:
             end_idx = trajectory_indices[frame_idx] + 1
-            cv2.polylines(frame, [trajectory_points[:end_idx]], False, (255, 0, 0), 2)
+            cv2.polylines(frame, [trajectory_points[:end_idx]], False, (255, 0, 0), 2)  # Blue line in BGR
         if pitch_point and i == pitch_frame:
             x, y = pitch_point
-            cv2.circle(frame, (int(x), int(y)), 8, (0, 0, 255), -1)
+            cv2.circle(frame, (int(x), int(y)), 8, (0, 0, 255), -1)  # Red circle
             cv2.putText(frame, "Pitch Point", (int(x) + 10, int(y) - 10), 
                         cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
         if impact_point and i == impact_frame:
             x, y = impact_point
-            cv2.circle(frame, (int(x), int(y)), 8, (0, 255, 255), -1)
+            cv2.circle(frame, (int(x), int(y)), 8, (0, 255, 255), -1)  # Yellow circle
             cv2.putText(frame, "Impact Point", (int(x) + 10, int(y) + 20), 
                         cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 255), 2)
-        for _ in range(SLOW_MOTION_FACTOR):
+        for _ in range(int(SLOW_MOTION_FACTOR)):
             out.write(frame)
     out.release()
     return output_path