back to update 1

app.py

@@ -1,331 +1,721 @@
+# Consolidated Streamlit App
 import streamlit as st
-from streamlit_webrtc import webrtc_streamer, WebRtcMode, RTCConfiguration
-import av
-import numpy as np
+import subprocess
+
+# Title and introduction
+st.title("Workout Tracker")
+st.markdown("""
+Welcome to the **Workout Tracker App**! 
+Select your desired workout below, and the app will guide you through the exercise with real-time feedback.
+""")
+
+# Workout options
+st.header("Choose Your Workout")
+workout_option = st.selectbox(
+    "Available Workouts:",
+    ["Bicep Curl", "Lateral Raise", "Shoulder Press"]
+)
+
+# Button to start the workout
+if st.button("Start Workout"):
+    st.write(f"Starting {workout_option}...")
+
+    # Map the workout to the corresponding script
+    workout_scripts = {
+        "Bicep Curl": "bicep_curl.py",
+        "Lateral Raise": "lateral_raise.py",
+        "Shoulder Press": "shoulder_press.py",
+    }
+    
+    selected_script = workout_scripts.get(workout_option)
+    
+    # Run the corresponding script
+    try:
+        subprocess.run(["python", selected_script], check=True)
+        st.success(f"{workout_option} workout completed! Check the feedback on your terminal.")
+    except subprocess.CalledProcessError as e:
+        st.error(f"An error occurred while running {workout_option}. Please try again.")
+    except FileNotFoundError:
+        st.error(f"Workout script {selected_script} not found! Ensure the file exists in the same directory.")
+
+# Footer
+st.markdown("""
+---
+**Note**: Close the workout window or press "q" in the camera feed to stop the workout.
+""")
+
+
+# From bicep_with_feedback.py
+import cv2
 import mediapipe as mp
-from typing import List, Tuple, Dict
-import logging
-from PIL import Image
-import queue
-import threading
-import logging
-import sys
-
-try:
-    from typing import Literal
-except ImportError:
-    from typing_extensions import Literal
-
-# Configure logging
-logging.basicConfig(level=logging.DEBUG)
-logger = logging.getLogger(__name__)
-
-# Initialize MediaPipe Pose
+import numpy as np
+import time
+from sklearn.ensemble import IsolationForest
+
+# Mediapipe utilities
+mp_drawing = mp.solutions.drawing_utils
 mp_pose = mp.solutions.pose
+
+
+# Function to calculate angles between three points
+def calculate_angle(a, b, c):
+    a = np.array(a)
+    b = np.array(b)
+    c = np.array(c)
+
+    radians = np.arctan2(c[1] - b[1], c[0] - b[0]) - np.arctan2(a[1] - b[1], a[0] - b[0])
+    angle = np.abs(np.degrees(radians))
+    if angle > 180.0:
+        angle = 360 - angle
+    return angle
+
+
+# Function to draw text with a background
+def draw_text_with_background(image, text, position, font, font_scale, color, thickness, bg_color, padding=10):
+    text_size = cv2.getTextSize(text, font, font_scale, thickness)[0]
+    text_x, text_y = position
+    box_coords = (
+        (text_x - padding, text_y - padding),
+        (text_x + text_size[0] + padding, text_y + text_size[1] + padding),
+    )
+    cv2.rectangle(image, box_coords[0], box_coords[1], bg_color, cv2.FILLED)
+    cv2.putText(image, text, (text_x, text_y + text_size[1]), font, font_scale, color, thickness)
+
+
+# Real-time feedback for single rep
+def analyze_single_rep(rep, rep_data):
+    """Provide actionable feedback for a single rep."""
+    feedback = []
+    avg_rom = np.mean([r["ROM"] for r in rep_data])
+    avg_tempo = np.mean([r["Tempo"] for r in rep_data])
+    avg_smoothness = np.mean([r["Smoothness"] for r in rep_data])
+
+    if rep["ROM"] < avg_rom * 0.8:
+        feedback.append("Extend arm more")
+    if rep["Tempo"] < avg_tempo * 0.8:
+        feedback.append("Slow down")
+    if rep["Smoothness"] > avg_smoothness * 1.2:
+        feedback.append("Move smoothly")
+
+    return " | ".join(feedback) if feedback else "Good rep!"
+
+
+# Post-workout feedback function with Isolation Forest
+def analyze_workout_with_isolation_forest(rep_data):
+    if not rep_data:
+        print("No reps completed.")
+        return
+
+    print("\n--- Post-Workout Summary ---")
+
+    # Convert rep_data to a feature matrix
+    features = np.array([[rep["ROM"], rep["Tempo"], rep["Smoothness"]] for rep in rep_data])
+
+    # Train Isolation Forest
+    model = IsolationForest(contamination=0.2, random_state=42)
+    predictions = model.fit_predict(features)
+
+    # Analyze reps
+    for i, (rep, prediction) in enumerate(zip(rep_data, predictions), 1):
+        status = "Good" if prediction == 1 else "Anomalous"
+        reason = []
+        if prediction == -1:  # If anomalous
+            if rep["ROM"] < np.mean(features[:, 0]) - np.std(features[:, 0]):
+                reason.append("Low ROM")
+            if rep["Tempo"] < np.mean(features[:, 1]) - np.std(features[:, 1]):
+                reason.append("Too Fast")
+            if rep["Smoothness"] > np.mean(features[:, 2]) + np.std(features[:, 2]):
+                reason.append("Jerky Movement")
+        reason_str = ", ".join(reason) if reason else "None"
+        print(f"Rep {i}: {status} | ROM: {rep['ROM']:.2f}, Tempo: {rep['Tempo']:.2f}s, Smoothness: {rep['Smoothness']:.2f} | Reason: {reason_str}")
+
+
+# Main workout tracking function
+def main():
+    cap = cv2.VideoCapture(0)
+    counter = 0  # Rep counter
+    stage = None  # Movement stage
+    max_reps = 10
+    rep_data = []  # Store metrics for each rep
+    feedback = ""  # Real-time feedback for the video feed
+    workout_start_time = None  # Timer start
+
+    with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose:
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                print("Failed to grab frame.")
+                break
+
+            # Initialize workout start time
+            if workout_start_time is None:
+                workout_start_time = time.time()
+
+            # Timer
+            elapsed_time = time.time() - workout_start_time
+            timer_text = f"Timer: {int(elapsed_time)}s"
+
+            # Convert frame to RGB
+            image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            image.flags.writeable = False
+            results = pose.process(image)
+
+            # Convert back to BGR
+            image.flags.writeable = True
+            image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+
+            # Check if pose landmarks are detected
+            if results.pose_landmarks:
+                landmarks = results.pose_landmarks.landmark
+
+                # Extract key joints
+                shoulder = [
+                    landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].x,
+                    landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].y
+                ]
+                elbow = [
+                    landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].x,
+                    landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].y
+                ]
+                wrist = [
+                    landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].x,
+                    landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].y
+                ]
+
+                # Check visibility of key joints
+                visibility_threshold = 0.5
+                if (landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].visibility < visibility_threshold or
+                        landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].visibility < visibility_threshold or
+                        landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].visibility < visibility_threshold):
+                    draw_text_with_background(image, "Ensure all key joints are visible!", (50, 150),
+                                              cv2.FONT_HERSHEY_SIMPLEX, 2, (255, 255, 255), 5, (0, 0, 255))
+                    cv2.imshow('Workout Feedback', image)
+                    continue  # Skip processing if joints are not visible
+
+                # Calculate the angle
+                angle = calculate_angle(shoulder, elbow, wrist)
+
+                # Stage logic for counting reps
+                if angle > 160 and stage != "down":
+                    stage = "down"
+                    start_time = time.time()  # Start timing for the rep
+                    start_angle = angle  # Record the starting angle
+
+                    # Stop the program if it's the 10th rep down stage
+                    if counter == max_reps:
+                        print("Workout complete at rep 10 (down stage)!")
+                        break
+                elif angle < 40 and stage == "down":
+                    stage = "up"
+                    counter += 1
+                    end_time = time.time()  # End timing for the rep
+                    end_angle = angle  # Record the ending angle
+
+                    # Calculate rep metrics
+                    rom = start_angle - end_angle  # Range of Motion
+                    tempo = end_time - start_time  # Duration of the rep
+                    smoothness = np.std([start_angle, end_angle])  # Dummy smoothness metric
+                    rep_data.append({"ROM": rom, "Tempo": tempo, "Smoothness": smoothness})
+
+                    # Analyze the rep using Isolation Forest
+                    feedback = analyze_single_rep(rep_data[-1], rep_data)
+
+                # Wireframe color based on form
+                wireframe_color = (0, 255, 0) if stage == "up" or stage == "down" else (0, 0, 255)
+
+                # Draw wireframe
+                mp_drawing.draw_landmarks(
+                    image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS,
+                    mp_drawing.DrawingSpec(color=wireframe_color, thickness=5, circle_radius=4),
+                    mp_drawing.DrawingSpec(color=wireframe_color, thickness=5, circle_radius=4)
+                )
+
+                # Display reps, stage, timer, and feedback
+                draw_text_with_background(image, f"Reps: {counter}", (50, 150),
+                                          cv2.FONT_HERSHEY_SIMPLEX, 3, (255, 255, 255), 5, (0, 0, 0))
+                draw_text_with_background(image, f"Stage: {stage if stage else 'N/A'}", (50, 300),
+                                          cv2.FONT_HERSHEY_SIMPLEX, 3, (255, 255, 255), 5, (0, 0, 0))
+                draw_text_with_background(image, timer_text, (1000, 50),  # Timer in the top-right corner
+                                          cv2.FONT_HERSHEY_SIMPLEX, 1.5, (255, 255, 255), 3, (0, 0, 0))
+                draw_text_with_background(image, feedback, (50, 450),
+                                          cv2.FONT_HERSHEY_SIMPLEX, 1.5, (255, 255, 255), 3, (0, 0, 0))
+
+            # Show video feed
+            cv2.imshow('Workout Feedback', image)
+
+            # Break if 'q' is pressed
+            if cv2.waitKey(10) & 0xFF == ord('q'):
+                break
+
+    cap.release()
+    cv2.destroyAllWindows()
+
+    # Post-workout analysis
+    analyze_workout_with_isolation_forest(rep_data)
+
+
+if __name__ == "__main__":
+    main()
+
+
+# From lateral_raise.py
+import cv2
+import mediapipe as mp
+import numpy as np
+import time
+from sklearn.ensemble import IsolationForest
+
+# Mediapipe utilities
 mp_drawing = mp.solutions.drawing_utils
+mp_pose = mp.solutions.pose
 
-# Page config
-st.set_page_config(page_title="AI Workout Trainer", page_icon="💪")
 
-# Constants
-RTC_CONFIGURATION = RTCConfiguration(
-    {"iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]}
-)
+# Function to calculate lateral raise angle
+def calculate_angle_for_lateral_raise(shoulder, wrist):
+    """
+    Calculate the angle of the arm relative to the horizontal plane
+    passing through the shoulder.
+    """
+    horizontal_reference = np.array([1, 0])  # Horizontal vector
+    arm_vector = np.array([wrist[0] - shoulder[0], wrist[1] - shoulder[1]])
+    dot_product = np.dot(horizontal_reference, arm_vector)
+    magnitude_reference = np.linalg.norm(horizontal_reference)
+    magnitude_arm = np.linalg.norm(arm_vector)
+    if magnitude_arm == 0 or magnitude_reference == 0:
+        return 0
+    cos_angle = dot_product / (magnitude_reference * magnitude_arm)
+    angle = np.arccos(np.clip(cos_angle, -1.0, 1.0))
+    return np.degrees(angle)
 
-# CSS
-st.markdown("""
-<style>
-    .main {
-        background: linear-gradient(135deg, #1e3c72 0%, #2a5298 100%);
-    }
-    .stButton > button {
-        width: 100%;
-        background-color: #2a5298;
-        color: white;
-        border-radius: 5px;
-        padding: 10px;
-        margin: 5px 0;
-    }
-    .workout-container {
-        background-color: rgba(255, 255, 255, 0.1);
-        padding: 20px;
-        border-radius: 10px;
-        margin: 10px 0;
-    }
-    h1, h2, h3 {
-        color: white;
-    }
-</style>
-""", unsafe_allow_html=True)
-
-class PoseTracker:
-    def __init__(self):
-        self.pose = mp_pose.Pose(
-            min_detection_confidence=0.5,
-            min_tracking_confidence=0.5
-        )
-        self.counter = 0
-        self.stage = None
-        self.feedback = ""
-        
-    def calculate_angle(self, a: np.ndarray, b: np.ndarray, c: np.ndarray) -> float:
-        a = np.array(a)
-        b = np.array(b)
-        c = np.array(c)
-        
-        radians = np.arctan2(c[1]-b[1], c[0]-b[0]) - \
-                 np.arctan2(a[1]-b[1], a[0]-b[0])
-        angle = np.abs(np.degrees(radians))
-        
-        if angle > 180.0:
-            angle = 360-angle
-            
-        return angle
-
-    def process_frame(self, frame: np.ndarray, exercise_type: str) -> Tuple[np.ndarray, str]:
-        try:
-            # Convert BGR to RGB
-            image = frame.copy()
+
+# Function to draw text with a background
+def draw_text_with_background(image, text, position, font, font_scale, color, thickness, bg_color, padding=10):
+    text_size = cv2.getTextSize(text, font, font_scale, thickness)[0]
+    text_x, text_y = position
+    box_coords = (
+        (text_x - padding, text_y - padding),
+        (text_x + text_size[0] + padding, text_y + text_size[1] + padding),
+    )
+    cv2.rectangle(image, box_coords[0], box_coords[1], bg_color, cv2.FILLED)
+    cv2.putText(image, text, (text_x, text_y + text_size[1]), font, font_scale, color, thickness)
+
+
+# Function to check if all required joints are visible
+def are_key_joints_visible(landmarks, visibility_threshold=0.5):
+    """
+    Ensure that all required joints are visible based on their visibility scores.
+    """
+    required_joints = [
+        mp_pose.PoseLandmark.LEFT_SHOULDER.value,
+        mp_pose.PoseLandmark.RIGHT_SHOULDER.value,
+        mp_pose.PoseLandmark.LEFT_WRIST.value,
+        mp_pose.PoseLandmark.RIGHT_WRIST.value,
+    ]
+    for joint in required_joints:
+        if landmarks[joint].visibility < visibility_threshold:
+            return False
+    return True
+
+
+# Real-time feedback for single rep
+def analyze_single_rep(rep, rep_data):
+    """Provide actionable feedback for a single rep."""
+    feedback = []
+
+    # Calculate averages from previous reps
+    avg_rom = np.mean([r["ROM"] for r in rep_data]) if rep_data else 0
+    avg_tempo = np.mean([r["Tempo"] for r in rep_data]) if rep_data else 0
+
+    # Dynamic tempo thresholds
+    lower_tempo_threshold = 2.0  # Minimum grace threshold for faster tempo
+    upper_tempo_threshold = 9.0  # Maximum grace threshold for slower tempo
+
+    # Adjust thresholds after a few reps
+    if len(rep_data) > 3:
+        lower_tempo_threshold = max(2.0, avg_tempo * 0.7)
+        upper_tempo_threshold = min(9.0, avg_tempo * 1.3)
+
+    # Feedback for ROM
+    if rep["ROM"] < 30:  # Minimum ROM threshold
+        feedback.append("Lift arm higher")
+    elif rep_data and rep["ROM"] < avg_rom * 0.8:
+        feedback.append("Increase ROM")
+
+    # Feedback for Tempo
+    if rep["Tempo"] < lower_tempo_threshold:  # Tempo too fast
+        feedback.append("Slow down")
+    elif rep["Tempo"] > upper_tempo_threshold:  # Tempo too slow
+        feedback.append("Speed up")
+
+    return feedback
+
+
+# Post-workout feedback function
+def analyze_workout_with_isolation_forest(rep_data):
+    if not rep_data:
+        print("No reps completed.")
+        return
+
+    print("\n--- Post-Workout Summary ---")
+
+    # Filter valid reps for recalculating thresholds
+    valid_reps = [rep for rep in rep_data if rep["ROM"] > 20]  # Ignore very low ROM reps
+
+    if not valid_reps:
+        print("No valid reps to analyze.")
+        return
+
+    features = np.array([[rep["ROM"], rep["Tempo"]] for rep in valid_reps])
+
+    avg_rom = np.mean(features[:, 0])
+    avg_tempo = np.mean(features[:, 1])
+    std_rom = np.std(features[:, 0])
+    std_tempo = np.std(features[:, 1])
+
+    # Adjusted bounds for anomalies
+    rom_lower_bound = max(20, avg_rom - std_rom * 2)
+    tempo_lower_bound = max(1.0, avg_tempo - std_tempo * 2)
+    tempo_upper_bound = min(10.0, avg_tempo + std_tempo * 2)
+
+    print(f"ROM Lower Bound: {rom_lower_bound}")
+    print(f"Tempo Bounds: {tempo_lower_bound}-{tempo_upper_bound}")
+
+    # Anomaly detection
+    for i, rep in enumerate(valid_reps, 1):
+        feedback = []
+        if rep["ROM"] < rom_lower_bound:
+            feedback.append("Low ROM")
+        if rep["Tempo"] < tempo_lower_bound:
+            feedback.append("Too Fast")
+        elif rep["Tempo"] > tempo_upper_bound:
+            feedback.append("Too Slow")
+
+        if feedback:
+            print(f"Rep {i}: Anomalous | Feedback: {', '.join(feedback[:1])}")
+
+    # Use Isolation Forest for secondary anomaly detection
+    model = IsolationForest(contamination=0.1, random_state=42)  # Reduced contamination
+    predictions = model.fit_predict(features)
+
+    for i, prediction in enumerate(predictions, 1):
+        if prediction == -1:  # Outlier
+            print(f"Rep {i}: Isolation Forest flagged this rep as anomalous.")
+
+
+# Main workout tracking function
+def main():
+    cap = cv2.VideoCapture(0)
+    counter = 0  # Rep counter
+    stage = None  # Movement stage
+    feedback = []  # Real-time feedback for the video feed
+    rep_data = []  # Store metrics for each rep
+    angles_during_rep = []  # Track angles during a single rep
+    workout_start_time = None  # Timer start
+
+    with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose:
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                print("Failed to grab frame.")
+                break
+
+            # Initialize workout start time
+            if workout_start_time is None:
+                workout_start_time = time.time()
+
+            # Timer
+            elapsed_time = time.time() - workout_start_time
+            timer_text = f"Timer: {int(elapsed_time)}s"
+
+            # Convert the image to RGB
+            image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
             image.flags.writeable = False
-            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-            results = self.pose.process(image)
-            
-            # Draw landmarks
+            results = pose.process(image)
+
+            # Convert back to BGR
             image.flags.writeable = True
             image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
-            
+
+            # Check if pose landmarks are detected
             if results.pose_landmarks:
+                landmarks = results.pose_landmarks.landmark
+
+                # Check if key joints are visible
+                if not are_key_joints_visible(landmarks):
+                    draw_text_with_background(
+                        image, "Ensure all joints are visible", (50, 50),
+                        cv2.FONT_HERSHEY_SIMPLEX, 1.5, (255, 255, 255), 2, (0, 0, 255)
+                    )
+                    cv2.imshow("Lateral Raise Tracker", image)
+                    continue
+
+                # Extract key joints
+                left_shoulder = [
+                    landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].x,
+                    landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].y,
+                ]
+                left_wrist = [
+                    landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].x,
+                    landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].y,
+                ]
+
+                # Calculate angle for lateral raise
+                angle = calculate_angle_for_lateral_raise(left_shoulder, left_wrist)
+
+                # Track angles during a rep
+                if stage == "up" or stage == "down":
+                    angles_during_rep.append(angle)
+
+                # Stage logic for counting reps
+                if angle < 20 and stage != "down":
+                    stage = "down"
+                    if counter == 10:  # Stop on the down stage of the 10th rep
+                        print("Workout complete! 10 reps reached.")
+                        break
+
+                    # Calculate ROM for the completed rep
+                    if len(angles_during_rep) > 1:
+                        rom = max(angles_during_rep) - min(angles_during_rep)
+                    else:
+                        rom = 0.0
+
+                    tempo = elapsed_time
+                    print(f"Rep {counter + 1}: ROM={rom:.2f}, Tempo={tempo:.2f}s")
+
+                    # Record metrics for the rep
+                    rep_data.append({
+                        "ROM": rom,
+                        "Tempo": tempo,
+                    })
+
+                    # Reset angles and timer for the next rep
+                    angles_during_rep = []
+                    workout_start_time = time.time()  # Reset timer
+
+                if 70 <= angle <= 110 and stage == "down":
+                    stage = "up"
+                    counter += 1
+
+                    # Analyze feedback
+                    feedback = analyze_single_rep(rep_data[-1], rep_data)
+
+                # Determine wireframe color
+                wireframe_color = (0, 255, 0) if not feedback else (0, 0, 255)
+
+                # Display feedback
+                draw_text_with_background(image, f"Reps: {counter}", (50, 50),
+                                          cv2.FONT_HERSHEY_SIMPLEX, 1.5, (255, 255, 255), 2, (0, 0, 0))
+                draw_text_with_background(image, " | ".join(feedback), (50, 120),
+                                          cv2.FONT_HERSHEY_SIMPLEX, 1.5, (255, 255, 255), 2, (0, 0, 0))
+                draw_text_with_background(image, timer_text, (50, 190),
+                                          cv2.FONT_HERSHEY_SIMPLEX, 1.5, (255, 255, 255), 2, (0, 0, 0))
+
+                # Render detections with wireframe color
                 mp_drawing.draw_landmarks(
                     image,
                     results.pose_landmarks,
-                    mp_pose.POSE_CONNECTIONS
+                    mp_pose.POSE_CONNECTIONS,
+                    mp_drawing.DrawingSpec(color=wireframe_color, thickness=2, circle_radius=2),
+                    mp_drawing.DrawingSpec(color=wireframe_color, thickness=2, circle_radius=2),
                 )
-                
-                # Extract landmarks
-                try:
-                    landmarks = results.pose_landmarks.landmark
-                    
-                    # Process based on exercise type
-                    if exercise_type == "bicep_curl":
-                        feedback = self._process_bicep_curl(landmarks, image)
-                    elif exercise_type == "shoulder_press":
-                        feedback = self._process_shoulder_press(landmarks, image)
-                    elif exercise_type == "lateral_raise":
-                        feedback = self._process_lateral_raise(landmarks, image)
-                    else:
-                        feedback = "Unknown exercise type"
-                        
-                    return image, feedback
-                    
-                except Exception as e:
-                    logger.error(f"Error processing landmarks: {str(e)}")
-                    return image, "Error processing pose"
-            
-            return image, "No pose detected"
-            
-        except Exception as e:
-            logger.error(f"Error in process_frame: {str(e)}")
-            return frame, "Error processing frame"
-
-    def _process_bicep_curl(self, landmarks, image) -> str:
-        # Get coordinates
-        shoulder = [landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].x,
-                   landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].y]
-        elbow = [landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].x,
-                landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].y]
-        wrist = [landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].x,
-                landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].y]
-        
-        # Calculate angle
-        angle = self.calculate_angle(shoulder, elbow, wrist)
-        
-        # Counter logic
-        if angle > 160:
-            self.stage = "down"
-        elif angle < 30 and self.stage == "down":
-            self.stage = "up"
-            self.counter += 1
-            
-        # Add text to image
-        cv2.putText(image, f'Angle: {angle:.2f}', (10,30), 
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255), 2)
-        cv2.putText(image, f'Count: {self.counter}', (10,60),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255), 2)
-                    
-        if angle < 160 and self.stage == "down":
-            return "Curl up"
-        elif angle > 30 and self.stage == "up":
-            return "Lower the weight"
-        else:
-            return f"Count: {self.counter}"
-
-    def _process_shoulder_press(self, landmarks, image) -> str:
-        # Similar structure to bicep curl but with shoulder press specific angles
-        shoulder = [landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].x,
-                   landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].y]
-        elbow = [landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].x,
-                landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].y]
-        wrist = [landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].x,
-                landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].y]
-        
-        angle = self.calculate_angle(shoulder, elbow, wrist)
-        
-        if angle < 90:
-            self.stage = "down"
-        elif angle > 160 and self.stage == "down":
-            self.stage = "up"
-            self.counter += 1
-            
-        cv2.putText(image, f'Angle: {angle:.2f}', (10,30),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255), 2)
-        cv2.putText(image, f'Count: {self.counter}', (10,60),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255), 2)
-        
-        if angle > 90 and self.stage == "down":
-            return "Press up fully"
-        elif angle < 160 and self.stage == "up":
-            return "Lower the weight"
-        else:
-            return f"Count: {self.counter}"
-
-    def _process_lateral_raise(self, landmarks, image) -> str:
-        shoulder = [landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].x,
-                   landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].y]
-        elbow = [landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].x,
-                landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].y]
-        wrist = [landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].x,
-                landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].y]
-        
-        angle = self.calculate_angle(shoulder, elbow, wrist)
-        
-        if angle < 20:
-            self.stage = "down"
-        elif angle > 80 and self.stage == "down":
-            self.stage = "up"
-            self.counter += 1
-            
-        cv2.putText(image, f'Angle: {angle:.2f}', (10,30),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255), 2)
-        cv2.putText(image, f'Count: {self.counter}', (10,60),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255), 2)
-        
-        if angle < 80 and self.stage == "down":
-            return "Raise arms higher"
-        elif angle > 20 and self.stage == "up":
-            return "Lower arms"
-        else:
-            return f"Count: {self.counter}"
-
-class VideoProcessor:
-    def __init__(self) -> None:
-        self.pose_tracker = PoseTracker()
-        self._exercise_type = "bicep_curl"
-        
-    @property
-    def exercise_type(self) -> str:
-        return self._exercise_type
-        
-    @exercise_type.setter
-    def exercise_type(self, value: str) -> None:
-        self._exercise_type = value
-        
-    def recv(self, frame: av.VideoFrame) -> av.VideoFrame:
-        try:
-            img = frame.to_ndarray(format="bgr24")
-            
-            # Process the frame
-            processed_frame, feedback = self.pose_tracker.process_frame(img, self.exercise_type)
-            
-            # Add feedback to frame
-            cv2.putText(processed_frame, feedback, (10,90),
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255), 2)
-            
-            return av.VideoFrame.from_ndarray(processed_frame, format="bgr24")
-        except Exception as e:
-            logger.error(f"Error in recv: {str(e)}")
-            return frame
 
-def main():
-    # Title and description
-    st.title("🏋️‍♂️ AI Workout Trainer")
-    st.markdown("""
-    <div class="workout-container">
-        <p>Welcome to your personal AI workout trainer! This app will help you:
-        <ul>
-            <li>Track your exercise form in real-time</li>
-            <li>Count your reps automatically</li>
-            <li>Provide instant feedback on your technique</li>
-        </ul></p>
-    </div>
-    """, unsafe_allow_html=True)
-    
-    # Exercise selection
-    exercise_type = st.selectbox(
-        "Choose your exercise:",
-        ["bicep_curl", "shoulder_press", "lateral_raise"],
-        format_func=lambda x: x.replace('_', ' ').title()
-    )
-    
-    # Create VideoProcessor instance
-    ctx = webrtc_streamer(
-        key="workout-tracker",
-        mode=WebRtcMode.SENDRECV,
-        rtc_configuration=RTC_CONFIGURATION,
-        video_processor_factory=VideoProcessor,
-        media_stream_constraints={"video": True, "audio": False},
-        async_processing=True,
+            # Display the image
+            cv2.imshow("Lateral Raise Tracker", image)
+
+            if cv2.waitKey(10) & 0xFF == ord("q"):
+                break
+
+    cap.release()
+    cv2.destroyAllWindows()
+
+    # Post-workout analysis
+    analyze_workout_with_isolation_forest(rep_data)
+
+
+if __name__ == "__main__":
+    main()
+
+
+# From shoulder_press.py
+import cv2
+import mediapipe as mp
+import numpy as np
+import time
+
+# Mediapipe utilities
+mp_drawing = mp.solutions.drawing_utils
+mp_pose = mp.solutions.pose
+
+# Function to calculate angles
+def calculate_angle(point_a, point_b, point_c):
+    vector_ab = np.array([point_a[0] - point_b[0], point_a[1] - point_b[1]])
+    vector_cb = np.array([point_c[0] - point_b[0], point_c[1] - point_b[1]])
+    dot_product = np.dot(vector_ab, vector_cb)
+    magnitude_ab = np.linalg.norm(vector_ab)
+    magnitude_cb = np.linalg.norm(vector_cb)
+    if magnitude_ab == 0 or magnitude_cb == 0:
+        return 0
+    cos_angle = dot_product / (magnitude_ab * magnitude_cb)
+    angle = np.arccos(np.clip(cos_angle, -1.0, 1.0))
+    return np.degrees(angle)
+
+
+# Function to check if all required joints are visible
+def are_key_joints_visible(landmarks, visibility_threshold=0.5):
+    required_joints = [
+        mp_pose.PoseLandmark.LEFT_SHOULDER.value,
+        mp_pose.PoseLandmark.RIGHT_SHOULDER.value,
+        mp_pose.PoseLandmark.LEFT_ELBOW.value,
+        mp_pose.PoseLandmark.RIGHT_ELBOW.value,
+        mp_pose.PoseLandmark.LEFT_WRIST.value,
+        mp_pose.PoseLandmark.RIGHT_WRIST.value,
+    ]
+    for joint in required_joints:
+        if landmarks[joint].visibility < visibility_threshold:
+            return False
+    return True
+
+
+# Function to draw text with a background
+def draw_text_with_background(image, text, position, font, font_scale, color, thickness, bg_color, padding=10):
+    text_size = cv2.getTextSize(text, font, font_scale, thickness)[0]
+    text_x, text_y = position
+    box_coords = (
+        (text_x - padding, text_y - padding),
+        (text_x + text_size[0] + padding, text_y + text_size[1] + padding),
     )
-    
-    # Update exercise type when changed
-    if ctx.video_processor:
-        ctx.video_processor.exercise_type = exercise_type
-    
-    # Instructions based on exercise
-    if exercise_type == "bicep_curl":
-        st.markdown("""
-        <div class="workout-container">
-            <h3>Bicep Curl Instructions:</h3>
-            <ul>
-                <li>Stand straight with weights at your sides</li>
-                <li>Keep your upper arms still</li>
-                <li>Curl the weights up towards your shoulders</li>
-                <li>Lower the weights back down controlled</li>
-            </ul>
-        </div>
-        """, unsafe_allow_html=True)
-    elif exercise_type == "shoulder_press":
-        st.markdown("""
-        <div class="workout-container">
-            <h3>Shoulder Press Instructions:</h3>
-            <ul>
-                <li>Start with weights at shoulder height</li>
-                <li>Press weights straight up overhead</li>
-                <li>Keep your core tight</li>
-                <li>Lower weights back to shoulders controlled</li>
-            </ul>
-        </div>
-        """, unsafe_allow_html=True)
-    else:  # lateral_raise
-        st.markdown("""
-        <div class="workout-container">
-            <h3>Lateral Raise Instructions:</h3>
-            <ul>
-                <li>Stand straight with weights at your sides</li>
-                <li>Raise arms out to sides up to shoulder height</li>
-                <li>Keep a slight bend in your elbows</li>
-                <li>Lower weights back down controlled</li>
-            </ul>
-        </div>
-        """, unsafe_allow_html=True)
+    cv2.rectangle(image, box_coords[0], box_coords[1], bg_color, cv2.FILLED)
+    cv2.putText(image, text, (text_x, text_y + text_size[1]), font, font_scale, color, thickness)
+
+
+# Main workout tracking function
+def main():
+    cap = cv2.VideoCapture(0)
+    counter = 0
+    stage = None
+    feedback = ""
+    workout_start_time = None
+    rep_start_time = None
+
+    with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose:
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                print("Failed to grab frame.")
+                break
+
+            # Initialize workout start time
+            if workout_start_time is None:
+                workout_start_time = time.time()
+
+            # Timer
+            elapsed_time = time.time() - workout_start_time
+            timer_text = f"Timer: {int(elapsed_time)}s"
+
+            # Convert the image to RGB
+            image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            image.flags.writeable = False
+            results = pose.process(image)
+
+            # Convert back to BGR
+            image.flags.writeable = True
+            image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+
+            # Check if pose landmarks are detected
+            if results.pose_landmarks:
+                landmarks = results.pose_landmarks.landmark
+
+                # Check if key joints are visible
+                if not are_key_joints_visible(landmarks):
+                    feedback = "Ensure all joints are visible"
+                    draw_text_with_background(
+                        image, feedback, (50, 50),
+                        cv2.FONT_HERSHEY_SIMPLEX, 1.5, (255, 255, 255), 2, (0, 0, 255)
+                    )
+                    cv2.imshow("Shoulder Press Tracker", image)
+                    continue
+
+                # Extract key joints for both arms
+                left_shoulder = [
+                    landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].x,
+                    landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].y,
+                ]
+                left_elbow = [
+                    landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].x,
+                    landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].y,
+                ]
+                left_wrist = [
+                    landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].x,
+                    landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].y,
+                ]
+
+                right_shoulder = [
+                    landmarks[mp_pose.PoseLandmark.RIGHT_SHOULDER.value].x,
+                    landmarks[mp_pose.PoseLandmark.RIGHT_SHOULDER.value].y,
+                ]
+                right_elbow = [
+                    landmarks[mp_pose.PoseLandmark.RIGHT_ELBOW.value].x,
+                    landmarks[mp_pose.PoseLandmark.RIGHT_ELBOW.value].y,
+                ]
+                right_wrist = [
+                    landmarks[mp_pose.PoseLandmark.RIGHT_WRIST.value].x,
+                    landmarks[mp_pose.PoseLandmark.RIGHT_WRIST.value].y,
+                ]
+
+                # Calculate angles
+                left_elbow_angle = calculate_angle(left_shoulder, left_elbow, left_wrist)
+                right_elbow_angle = calculate_angle(right_shoulder, right_elbow, right_wrist)
+
+                # Check starting and ending positions
+                if 80 <= left_elbow_angle <= 100 and 80 <= right_elbow_angle <= 100 and stage != "down":
+                    stage = "down"
+                    if counter == 10:
+                        feedback = "Workout complete! 10 reps done."
+                        draw_text_with_background(image, feedback, (50, 120),
+                                                  cv2.FONT_HERSHEY_SIMPLEX, 1.5, (255, 255, 255), 2, (0, 0, 255))
+                        cv2.imshow("Shoulder Press Tracker", image)
+                        break
+                    if rep_start_time is not None:
+                        tempo = time.time() - rep_start_time
+                        feedback = f"Rep {counter} completed! Tempo: {tempo:.2f}s"
+                        rep_start_time = None
+                elif left_elbow_angle > 160 and right_elbow_angle > 160 and stage == "down":
+                    stage = "up"
+                    counter += 1
+                    rep_start_time = time.time()
+
+                # Wireframe color
+                wireframe_color = (0, 255, 0) if "completed" in feedback or "Good" in feedback else (0, 0, 255)
+
+                # Display feedback
+                draw_text_with_background(image, f"Reps: {counter}", (50, 50),
+                                          cv2.FONT_HERSHEY_SIMPLEX, 1.5, (255, 255, 255), 2, (0, 0, 0))
+                draw_text_with_background(image, feedback, (50, 120),
+                                          cv2.FONT_HERSHEY_SIMPLEX, 1.5, (255, 255, 255), 2, (0, 0, 0))
+                draw_text_with_background(image, timer_text, (50, 190),
+                                          cv2.FONT_HERSHEY_SIMPLEX, 1.5, (255, 255, 255), 2, (0, 0, 0))
+
+                # Render detections with wireframe color
+                mp_drawing.draw_landmarks(
+                    image,
+                    results.pose_landmarks,
+                    mp_pose.POSE_CONNECTIONS,
+                    mp_drawing.DrawingSpec(color=wireframe_color, thickness=2, circle_radius=2),
+                    mp_drawing.DrawingSpec(color=wireframe_color, thickness=2, circle_radius=2),
+                )
+
+            # Display the image
+            cv2.imshow("Shoulder Press Tracker", image)
+
+            if cv2.waitKey(10) & 0xFF == ord("q"):
+                break
+
+    cap.release()
+    cv2.destroyAllWindows()
+
 
 if __name__ == "__main__":
-    try:
-        # Import OpenCV
-        import cv2
-        main()
-    except Exception as e:
-        st.error(f"An error occurred: {str(e)}")
-        if "cv2" in str(e):
-            st.warning("OpenCV import failed. Please check your installation.")
-        logger.error(f"Application error: {str(e)}")
+    main()
+
+