app.py

import subprocess

# Ensure setup.sh is executable and then run it using bash
subprocess.run(['chmod', '+x', 'setup.sh'])
subprocess.run(['bash', 'setup.sh'], check=True)

import streamlit as st
import cv2
import mediapipe as mp
import numpy as np
import tempfile
import os

# Initialize MediaPipe Pose
mp_pose = mp.solutions.pose
pose = mp_pose.Pose(static_image_mode=False, model_complexity=1, enable_segmentation=True, min_detection_confidence=0.5, min_tracking_confidence=0.5)
mp_drawing = mp.solutions.drawing_utils

def calculate_angle_between_vectors(v1, v2):
    unit_vector_1 = v1 / np.linalg.norm(v1)
    unit_vector_2 = v2 / np.linalg.norm(v2)
    dot_product = np.dot(unit_vector_1, unit_vector_2)
    angle = np.arccos(dot_product)
    return np.degrees(angle)

def process_video(video_path):
    cap = cv2.VideoCapture(video_path)
    output_dir = tempfile.mkdtemp()

    current_phase = "Not Setup phase"
    prev_wrist_left_y = None
    prev_wrist_right_y = None
    top_backswing_detected = False
    mid_downswing_detected = False
    ball_impact_detected = False
    top_backswing_frame = -2
    mid_downswing_frame = -2
    ball_impact_frame = -2

    BALL_IMPACT_DURATION = 2  # Duration in frames to display Ball Impact phase

    MIN_MOVEMENT_THRESHOLD = 0.01
    HIP_NEAR_THRESHOLD = 0.05
    MID_SWING_THRESHOLD = 0.05

    saved_phases = set()

    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break

        frame_no = int(cap.get(cv2.CAP_PROP_POS_FRAMES))
        image_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        result = pose.process(image_rgb)
        h, w, c = frame.shape

        if result.pose_landmarks:
            mp_drawing.draw_landmarks(
                frame, result.pose_landmarks, mp_pose.POSE_CONNECTIONS,
                mp_drawing.DrawingSpec(color=(255, 0, 0), thickness=2, circle_radius=2),
                mp_drawing.DrawingSpec(color=(255, 0, 255), thickness=2, circle_radius=2)
            )

            landmarks = result.pose_landmarks.landmark
            wrist_left_y = landmarks[mp_pose.PoseLandmark.LEFT_WRIST].y
            wrist_right_y = landmarks[mp_pose.PoseLandmark.RIGHT_WRIST].y
            hip_left_y = landmarks[mp_pose.PoseLandmark.LEFT_HIP].y
            hip_right_y = landmarks[mp_pose.PoseLandmark.RIGHT_HIP].y
            shoulder_left_y = landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER].y
            shoulder_right_y = landmarks[mp_pose.PoseLandmark.RIGHT_SHOULDER].y

            hip_y_avg = (hip_left_y + hip_right_y) / 2
            shoulder_y_avg = (shoulder_left_y + shoulder_right_y) / 2
            mid_swing_y = (shoulder_y_avg + hip_y_avg) / 2

            # Ensure the current phase persists for a few more milliseconds if it's Ball Impact
            if ball_impact_detected and frame_no <= ball_impact_frame + BALL_IMPACT_DURATION:
                current_phase = "Ball impact phase"
            elif (abs(wrist_left_y - hip_y_avg) < HIP_NEAR_THRESHOLD and abs(wrist_right_y - hip_y_avg) < HIP_NEAR_THRESHOLD):
                if prev_wrist_left_y is not None and prev_wrist_right_y is not None:
                    if (abs(wrist_left_y - prev_wrist_left_y) < MIN_MOVEMENT_THRESHOLD and abs(wrist_right_y - prev_wrist_right_y) < MIN_MOVEMENT_THRESHOLD):
                        if mid_downswing_detected and frame_no > mid_downswing_frame:
                            current_phase = "Ball impact phase"
                            ball_impact_detected = True
                            ball_impact_frame = frame_no
                        else:
                            current_phase = "Setup phase"
                        top_backswing_detected = False
                        mid_downswing_detected = False
                    else:
                        current_phase = ""
                else:
                    if mid_downswing_detected and frame_no > mid_downswing_frame:
                        current_phase = "Ball impact phase"
                        ball_impact_detected = True
                        ball_impact_frame = frame_no
                    else:
                        current_phase = "Setup phase"
                    top_backswing_detected = False
                    mid_downswing_detected = False
            elif (abs(wrist_left_y - mid_swing_y) < MID_SWING_THRESHOLD and abs(wrist_right_y - mid_swing_y) < MID_SWING_THRESHOLD and not top_backswing_detected and not ball_impact_detected):
                current_phase = "Mid backswing phase"
            elif (wrist_left_y < shoulder_left_y and wrist_right_y < shoulder_right_y and not mid_downswing_detected and not ball_impact_detected):
                current_phase = "Top backswing phase"
                top_backswing_detected = True
                top_backswing_frame = frame_no
            elif (abs(wrist_left_y - mid_swing_y) < MID_SWING_THRESHOLD and abs(wrist_right_y - mid_swing_y) < MID_SWING_THRESHOLD and top_backswing_detected and frame_no > top_backswing_frame):
                current_phase = "Mid downswing phase"
                mid_downswing_detected = True
                mid_downswing_frame = frame_no
            elif (wrist_left_y < shoulder_left_y and wrist_right_y < shoulder_right_y and ball_impact_detected and frame_no > ball_impact_frame):
                current_phase = "Follow through phase"
            else:
                current_phase = ""

            prev_wrist_left_y = wrist_left_y
            prev_wrist_right_y = wrist_right_y

            cv2.putText(frame, f"Phase: {current_phase}", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)

            # Save the frame for each detected phase
            if current_phase and current_phase not in saved_phases:
                phase_filename = os.path.join(output_dir, f"{current_phase.replace(' ', '_')}.png")
                cv2.imwrite(phase_filename, frame)
                saved_phases.add(current_phase)

    cap.release()
    cv2.destroyAllWindows()
    pose.close()

    return output_dir

st.title("Golf Swing Phase Detection")
st.write("Upload a video to detect different phases of a golf swing.")

video_file = st.file_uploader("Upload Video", type=["mp4", "avi", "mov", "mkv"])

if video_file is not None:
    tfile = tempfile.NamedTemporaryFile(delete=False)
    tfile.write(video_file.read())
    tfile_path = tfile.name

    st.write("Processing video...")
    output_dir = process_video(tfile_path)

    st.write("Detected phases saved to:", output_dir)
    st.write("Example frames from detected phases:")
    
    for phase_image in os.listdir(output_dir):
        st.image(os.path.join(output_dir, phase_image), caption=phase_image)
# import streamlit as st
# import cv2
# import mediapipe as mp
# import numpy as np
# import tempfile
# import os
# from collections import deque

# # Initialize MediaPipe Pose
# mp_pose = mp.solutions.pose
# mp_drawing = mp.solutions.drawing_utils

# # Define states for the state machine
# SETUP = "Setup phase"
# MID_BACKSWING = "Mid backswing phase"
# TOP_BACKSWING = "Top backswing phase"
# MID_DOWNSWING = "Mid downswing phase"
# BALL_IMPACT = "Ball impact phase"
# FOLLOW_THROUGH = "Follow through phase"
# UNKNOWN = "Unknown"

# # Parameters for logic
# NUM_FRAMES_STABLE = 5    # Number of frames to confirm a state transition
# VEL_THRESHOLD = 0.003     # Velocity threshold to confirm direction (tune as needed)
# MID_POINT_RATIO = 0.5     # Ratio for mid-swing line (between shoulders and hips)
# BALL_IMPACT_DURATION = 5  # Frames to keep Ball Impact state stable

# def smooth_positions(positions, window=5):
#     """Simple smoothing by averaging the last `window` positions."""
#     if len(positions) < window:
#         return positions[-1]
#     arr = np.array(positions[-window:])
#     return np.mean(arr, axis=0)

# def process_video(video_path):
#     pose = mp_pose.Pose(
#         static_image_mode=False,
#         model_complexity=1,
#         enable_segmentation=True,
#         min_detection_confidence=0.5,
#         min_tracking_confidence=0.5,
#     )

#     cap = cv2.VideoCapture(video_path)
#     output_dir = tempfile.mkdtemp()

#     # State machine variables
#     current_state = UNKNOWN
#     last_confirmed_state = UNKNOWN
#     state_confirmation_count = 0

#     # To store positions and smoothing
#     wrist_left_positions = deque(maxlen=30)
#     wrist_right_positions = deque(maxlen=30)

#     # For saving phases once
#     saved_phases = set()

#     # Reference positions (will be recorded from initial frames)
#     initial_hip_y = None
#     initial_shoulder_y = None
#     detected_initial_setup = False

#     # Variables to track top backswing peak
#     # We'll store the max height reached during backswing
#     max_wrist_height = None
#     top_backswing_reached = False

#     # For Ball impact stable frames
#     ball_impact_frame_no = -1
#     frame_count = 0

#     while cap.isOpened():
#         ret, frame = cap.read()
#         if not ret:
#             break
#         frame_count += 1
#         image_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
#         result = pose.process(image_rgb)
#         h, w, c = frame.shape

#         if result.pose_landmarks:
#             landmarks = result.pose_landmarks.landmark
#             # Extract relevant landmarks
#             wrist_left_y = landmarks[mp_pose.PoseLandmark.LEFT_WRIST].y
#             wrist_right_y = landmarks[mp_pose.PoseLandmark.RIGHT_WRIST].y
#             hip_left_y = landmarks[mp_pose.PoseLandmark.LEFT_HIP].y
#             hip_right_y = landmarks[mp_pose.PoseLandmark.RIGHT_HIP].y
#             shoulder_left_y = landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER].y
#             shoulder_right_y = landmarks[mp_pose.PoseLandmark.RIGHT_SHOULDER].y

#             hip_y_avg = (hip_left_y + hip_right_y) / 2
#             shoulder_y_avg = (shoulder_left_y + shoulder_right_y) / 2

#             # Record initial reference once at the start if not done
#             if initial_hip_y is None:
#                 initial_hip_y = hip_y_avg
#             if initial_shoulder_y is None:
#                 initial_shoulder_y = shoulder_y_avg

#             # Mid swing line (between shoulder and hip)
#             mid_swing_y = (shoulder_y_avg + hip_y_avg) / 2

#             # Append current positions
#             wrist_left_positions.append(wrist_left_y)
#             wrist_right_positions.append(wrist_right_y)

#             # Smooth positions
#             smoothed_left_y = smooth_positions(list(wrist_left_positions))
#             smoothed_right_y = smooth_positions(list(wrist_right_positions))

#             # Average wrist height
#             avg_wrist_y = (smoothed_left_y + smoothed_right_y) / 2.0

#             # Compute velocity as difference from last frame (if possible)
#             if len(wrist_left_positions) > 1:
#                 vel_wrist_y = avg_wrist_y - ((wrist_left_positions[-2] + wrist_right_positions[-2]) / 2.0)
#             else:
#                 vel_wrist_y = 0.0

#             # Define conditions for each phase based on relative positions and movement:
#             # We'll define logical checks:
#             # 1. Setup: wrists near hip level and minimal movement
#             # 2. Mid backswing: wrists have started moving upward from hip level toward shoulder
#             # 3. Top backswing: wrists reach a peak (highest point) and start descending
#             # 4. Mid downswing: wrists cross mid line going downward
#             # 5. Ball impact: wrists around hip level again with downward movement stabilized
#             # 6. Follow through: wrists go above shoulders again after impact

#             # Detect initial Setup:
#             # Setup if wrists near hips and minimal vertical movement for a few frames
#             near_hip = abs(avg_wrist_y - initial_hip_y) < 0.05
#             low_velocity = abs(vel_wrist_y) < VEL_THRESHOLD

#             # Mid Backswing check:
#             # Movement upward from hip towards shoulder
#             # Condition: wrist higher than hip but not yet at top, positive upward velocity
#             going_up = (vel_wrist_y < -VEL_THRESHOLD)  # remember y is normalized [0..1], top is smaller
#             mid_backswing_cond = (avg_wrist_y < mid_swing_y) and (avg_wrist_y < initial_hip_y) and going_up

#             # Top Backswing:
#             # Detecting a peak: we track max height during backswing.
#             # If currently going_up, update max_wrist_height.
#             # Once we detect a change from going_up to going_down, we mark top backswing.
#             if max_wrist_height is None or avg_wrist_y < max_wrist_height:
#                 max_wrist_height = avg_wrist_y
#             going_down = (vel_wrist_y > VEL_THRESHOLD)
#             # Top backswing if we previously were going up and now start going down
#             # and wrists are near or above shoulder level (or at least higher than mid swing).
#             top_backswing_cond = top_backswing_reached is False and going_down and (max_wrist_height < mid_swing_y)

#             # Mid Downswing:
#             # After top backswing, as we go down again and cross mid swing line downward
#             mid_downswing_cond = top_backswing_reached and (avg_wrist_y > mid_swing_y) and going_down

#             # Ball Impact:
#             # When wrists return to near hip level while still going down or stabilizing
#             # We'll consider ball impact when avg_wrist_y ~ hip level and we've come down from top backswing
#             ball_impact_cond = top_backswing_reached and (abs(avg_wrist_y - initial_hip_y) < 0.05) and going_down

#             # Follow Through:
#             # After impact, if wrists go up again above shoulder level
#             follow_through_cond = (ball_impact_frame_no > 0 and frame_count > ball_impact_frame_no + BALL_IMPACT_DURATION
#                                    and avg_wrist_y < mid_swing_y and going_up)

#             # State machine transitions:
#             desired_state = UNKNOWN

#             # Prioritize states in a logical order
#             if current_state == UNKNOWN:
#                 # Try to find a stable setup as a start
#                 if near_hip and low_velocity:
#                     desired_state = SETUP
#                 else:
#                     desired_state = UNKNOWN

#             elif current_state == SETUP:
#                 # From setup, if we start going up and cross mid line:
#                 if mid_backswing_cond:
#                     desired_state = MID_BACKSWING
#                 else:
#                     desired_state = SETUP

#             elif current_state == MID_BACKSWING:
#                 # If we detect a top backswing condition (peak reached):
#                 if top_backswing_cond:
#                     desired_state = TOP_BACKSWING
#                     top_backswing_reached = True
#                 else:
#                     desired_state = MID_BACKSWING

#             elif current_state == TOP_BACKSWING:
#                 # After top backswing, going down past mid line means mid downswing
#                 if mid_downswing_cond:
#                     desired_state = MID_DOWNSWING
#                 else:
#                     desired_state = TOP_BACKSWING

#             elif current_state == MID_DOWNSWING:
#                 # Reaching ball impact condition
#                 if ball_impact_cond:
#                     desired_state = BALL_IMPACT
#                     ball_impact_frame_no = frame_count
#                 else:
#                     desired_state = MID_DOWNSWING

#             elif current_state == BALL_IMPACT:
#                 # After ball impact, potentially follow through if going upward again
#                 if follow_through_cond:
#                     desired_state = FOLLOW_THROUGH
#                 else:
#                     # Keep showing ball impact for a few frames
#                     if frame_count <= ball_impact_frame_no + BALL_IMPACT_DURATION:
#                         desired_state = BALL_IMPACT
#                     else:
#                         desired_state = BALL_IMPACT  # could default to unknown if no follow through detected

#             elif current_state == FOLLOW_THROUGH:
#                 # Final phase, usually no more transitions expected
#                 desired_state = FOLLOW_THROUGH

#             # If we are UNKNOWN and can't find a better match:
#             if desired_state == UNKNOWN:
#                 # Try to match any phase heuristics if no known logic fits
#                 if near_hip and low_velocity:
#                     desired_state = SETUP
#                 else:
#                     desired_state = UNKNOWN

#             # Confirm state transitions only if stable for several frames
#             if desired_state == current_state:
#                 state_confirmation_count += 1
#             else:
#                 # Different desired state
#                 if desired_state != UNKNOWN:
#                     # Start counting from scratch for the new state
#                     current_state = desired_state
#                     state_confirmation_count = 1
#                 else:
#                     # If unknown requested, just switch immediately
#                     current_state = UNKNOWN
#                     state_confirmation_count = 1

#             # Once stable enough in a state, set last_confirmed_state
#             if state_confirmation_count >= NUM_FRAMES_STABLE:
#                 last_confirmed_state = current_state

#             # Draw Landmarks
#             mp_drawing.draw_landmarks(
#                 frame, 
#                 result.pose_landmarks, 
#                 mp_pose.POSE_CONNECTIONS,
#                 mp_drawing.DrawingSpec(color=(255, 0, 0), thickness=2, circle_radius=2),
#                 mp_drawing.DrawingSpec(color=(255, 0, 255), thickness=2, circle_radius=2)
#             )

#             cv2.putText(frame, f"Phase: {last_confirmed_state}", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,255), 2, cv2.LINE_AA)

#             # Save the frame for each detected phase (once)
#             if last_confirmed_state not in saved_phases and last_confirmed_state != UNKNOWN:
#                 phase_filename = os.path.join(output_dir, f"{last_confirmed_state.replace(' ', '_')}.png")
#                 cv2.imwrite(phase_filename, frame)
#                 saved_phases.add(last_confirmed_state)

#         cv2.imshow("Pose Estimation", frame)
#         if cv2.waitKey(1) & 0xFF == ord('q'):
#             break

#     cap.release()
#     cv2.destroyAllWindows()
#     pose.close()
#     return output_dir

# st.title("Golf Swing Phase Detection - Improved Logic")
# st.write("Upload a video to detect different phases of a golf swing with improved accuracy.")

# video_file = st.file_uploader("Upload Video", type=["mp4", "avi", "mov", "mkv"])

# if video_file is not None:
#     tfile = tempfile.NamedTemporaryFile(delete=False)
#     tfile.write(video_file.read())
#     tfile_path = tfile.name

#     st.write("Processing video...")
#     output_dir = process_video(tfile_path)

#     st.write("Detected phases saved to:", output_dir)
#     st.write("Example frames from detected phases:")

#     for phase_image in os.listdir(output_dir):
#         st.image(os.path.join(output_dir, phase_image), caption=phase_image)