Update app.py

app.py

@@ -1,33 +1,49 @@
-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
+import time
+import base64
 
 # 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
+pose = mp_pose.Pose(
+    static_image_mode=False,
+    model_complexity=1,
+    enable_segmentation=True,
+    min_detection_confidence=0.5,
+    min_tracking_confidence=0.5
+)
 
 def calculate_angle_between_vectors(v1, v2):
+    """
+    Calculates the angle between two vectors in degrees.
+    """
     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)
+    angle = np.arccos(np.clip(dot_product, -1.0, 1.0))  # Clip for numerical stability
     return np.degrees(angle)
 
 def process_video(video_path):
     cap = cv2.VideoCapture(video_path)
-    output_dir = tempfile.mkdtemp()
 
-    current_phase = "Not Setup phase"
+    # Define the order of phases
+    phases_order = [
+        "Setup Phase",
+        "Mid Backswing Phase",
+        "Top Backswing Phase",
+        "Mid Downswing Phase",
+        "Ball Impact Phase",
+        "Follow Through Phase"
+    ]
+
+    # Initialize a dictionary to store the first detected frame for each phase
+    phase_images = {phase: None for phase in phases_order}
+
+    # Initialize variables for phase detection
+    current_phase = "Not Setup Phase"
     prev_wrist_left_y = None
     prev_wrist_right_y = None
     top_backswing_detected = False
@@ -37,13 +53,17 @@ def process_video(video_path):
     mid_downswing_frame = -2
     ball_impact_frame = -2
 
+    mid_backswing_wrist_left_y = None
+    mid_backswing_wrist_right_y = None
+
     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()
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    processed_frames = 0
 
     while cap.isOpened():
         ret, frame = cap.read()
@@ -53,15 +73,8 @@ def process_video(video_path):
         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
@@ -74,369 +87,235 @@ def process_video(video_path):
             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):
+            # Phase Detection Logic
+            if ball_impact_detected and frame_no > ball_impact_frame + BALL_IMPACT_DURATION:
+                current_phase = "Follow Through Phase"
+            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"
+                mid_backswing_wrist_left_y = wrist_left_y
+                mid_backswing_wrist_right_y = wrist_right_y
+            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 mid_backswing_wrist_left_y is not None and mid_backswing_wrist_right_y is not None and \
+                 abs(wrist_left_y - mid_backswing_wrist_left_y) < MID_SWING_THRESHOLD and \
+                 abs(wrist_right_y - mid_backswing_wrist_right_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 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 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"
+                            current_phase = "Ball Impact Phase"
                             ball_impact_detected = True
                             ball_impact_frame = frame_no
                         else:
-                            current_phase = "Setup phase"
+                            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"
+                        current_phase = "Ball Impact Phase"
                         ball_impact_detected = True
                         ball_impact_frame = frame_no
                     else:
-                        current_phase = "Setup phase"
+                        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)
+            # **Removed Overlay of Phase Information on Video Frames**
+
+            # Encode frame for display
+            frame_bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
+            ret, buffer = cv2.imencode('.jpg', frame_bgr)
+            frame_jpg = buffer.tobytes()
 
-            # 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)
+            # Store the first detected frame for each phase
+            if current_phase in phases_order and phase_images[current_phase] is None:
+                phase_images[current_phase] = frame_jpg
+
+        processed_frames += 1
+        yield frame_jpg, current_phase, processed_frames, total_frames
 
     cap.release()
-    cv2.destroyAllWindows()
     pose.close()
+    yield phase_images, None, processed_frames, total_frames
+
+# Streamlit UI Configuration
+
+# Custom CSS for styling
+st.markdown("""
+    <style>
+    /* General Styles */
+    body {
+        background-color: #f5f5f5;
+    }
+    .title {
+        font-size: 36px;
+        font-weight: bold;
+        color: #2E86C1;
+        text-align: center;
+        margin-bottom: 10px;
+    }
+    .subtitle {
+        font-size: 18px;
+        color: #555;
+        text-align: center;
+        margin-bottom: 30px;
+    }
+    .phase-placeholder {
+        border: 2px solid #2E86C1; 
+        background-color: #D6EAF8;
+        padding: 15px; 
+        text-align: center; 
+        font-size: 24px; 
+        border-radius: 10px; 
+        height: 60px;
+        margin-bottom: 20px;
+        color: #1B4F72;
+    }
+    .detected-phases {
+        display: flex;
+        flex-wrap: wrap;
+        justify-content: center;
+        gap: 30px; /* Increased gap for more space between phase cards */
+    }
+    .phase-card {
+        border: 1px solid #ddd;
+        border-radius: 10px;
+        padding: 15px;
+        background-color: #fff;
+        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+        text-align: center;
+        width: 250px;
+        height: 300px; /* Fixed height to accommodate image and text */
+        display: flex;
+        flex-direction: column;
+        justify-content: center;
+        align-items: center;
+    }
+    .phase-card img {
+        width: 200px;   /* Fixed width */
+        height: 200px;  /* Fixed height */
+        object-fit: cover; /* Ensures image covers the area without distortion */
+        border-radius: 10px;
+        margin-bottom: 10px;
+    }
+    .footer {
+        text-align: center;
+        font-size: 14px;
+        color: #aaa;
+        margin-top: 40px;
+    }
+    </style>
+""", unsafe_allow_html=True)
+
+# Title and Description
+st.markdown("<div class='title'>🏌️‍♂️ Golf Swing Phase Detection</div><hr>", unsafe_allow_html=True)
+st.markdown("<div class='subtitle'>Upload a golf swing video to automatically detect and visualize its different phases.</div>", unsafe_allow_html=True)
+
+# File Uploader
+video_file = st.file_uploader("🎥 **Upload Your Golf Swing Video**", type=["mp4", "avi", "mov", "mkv"])
 
-    return output_dir
-
-st.title("Golf Swing Phase Detection")
-st.write("Upload a video to detect different phases of a golf swing.")
+if video_file is not None:
+    with st.spinner("🔍 Processing video..."):
+        try:
+            # Save uploaded video to a temporary file
+            tfile = tempfile.NamedTemporaryFile(delete=False)
+            tfile.write(video_file.read())
+            tfile_path = tfile.name
+
+            phase_placeholder = st.empty()
+            video_placeholder = st.empty()
+            progress_bar = st.progress(0)
+            progress_text = st.empty()
+
+            phase_images = {}
+            detected_phases = []
+
+            for result, current_phase, processed, total in process_video(tfile_path):
+                if current_phase is not None:
+                    # Update phase placeholder
+                    phase_placeholder.markdown(
+                        f"<div class='phase-placeholder'>{current_phase}</div>",
+                        unsafe_allow_html=True
+                    )
+                    # Display video frame
+                    video_placeholder.image(result, channels='BGR', use_column_width=True)
+                    # Update progress bar
+                    progress = processed / total if total > 0 else 0
+                    progress_bar.progress(progress)
+                    progress_text.text(f"Processing frame {processed} of {total}")
+                    # Collect detected phases
+                    if current_phase not in detected_phases and current_phase != "Not Setup Phase":
+                        detected_phases.append(current_phase)
+                    time.sleep(0.01)  # Adjust delay as needed for smoother progress
+                else:
+                    phase_images = result
+
+            # Cleanup placeholders
+            phase_placeholder.empty()
+            video_placeholder.empty()
+            progress_bar.empty()
+            progress_text.empty()
+
+            st.success("✅ Video processing complete!")
+
+            # Define the order of phases for fixed grid positions
+            phases_order = [
+                "Setup Phase",
+                "Mid Backswing Phase",
+                "Top Backswing Phase",
+                "Mid Downswing Phase",
+                "Ball Impact Phase",
+                "Follow Through Phase"
+            ]
+
+            # Display Detected Phases in Fixed Grid Layout
+            st.markdown("### 🏆 Detected Phases:")
+            if phases_order:
+                st.markdown("<div class='detected-phases'>", unsafe_allow_html=True)
+                for phase in phases_order:
+                    image = phase_images.get(phase)
+                    if image:
+                        # Proper Base64 encoding
+                        encoded_image = base64.b64encode(image).decode('utf-8')
+                        st.markdown(f"""
+                            <div class='phase-card'>
+                                <img src="data:image/jpeg;base64,{encoded_image}" alt="{phase}">
+                                <h3>{phase}</h3>
+                            </div>
+                        """, unsafe_allow_html=True)
+                    else:
+                        # Placeholder for missing phases
+                        st.markdown(f"""
+                            <div class='phase-card'>
+                                <img src="https://via.placeholder.com/200x200.png?text=No+Image" alt="{phase}">
+                                <h3>{phase}</h3>
+                                <p style="color: #aaa; font-size: 14px;">Not Detected</p>
+                            </div>
+                        """, unsafe_allow_html=True)
+                st.markdown("</div>", unsafe_allow_html=True)
+            else:
+                st.warning("⚠️ No distinct phases detected.")
 
-video_file = st.file_uploader("Upload Video", type=["mp4", "avi", "mov", "mkv"])
+        except Exception as e:
+            st.error(f"An error occurred during video processing: {e}")
 
-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)
+    # Footer
+    st.markdown("<div class='footer'>Developed by Your Name | © 2024 Golf Swing Analyzer</div>", unsafe_allow_html=True)