update 7

app.py

@@ -2,747 +2,259 @@ import streamlit as st
 import cv2
 import mediapipe as mp
 import numpy as np
-import time
-from sklearn.ensemble import IsolationForest
+from streamlit_webrtc import webrtc_streamer, VideoTransformerBase
+import av
+import threading
+from dataclasses import dataclass
+from typing import List
 
-# Encapsulated workout functions
+# Mediapipe setup
+mp_drawing = mp.solutions.drawing_utils
+mp_pose = mp.solutions.pose
 
-def bicep_curl():
-    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
-    
-    
-    # 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()
+# Custom CSS
+st.markdown("""
+<style>
+    .main {
+        background: linear-gradient(135deg, #001f3f 0%, #00b4d8 100%);
+    }
+    .stButton > button {
+        background-color: #00b4d8;
+        color: white;
+        border: none;
+        padding: 0.5rem 2rem;
+        border-radius: 5px;
+        margin: 0.5rem;
+        transition: all 0.3s;
+    }
+    .stButton > button:hover {
+        background-color: #0077b6;
+    }
+    h1, h2, h3 {
+        color: #001f3f;
+    }
+    .workout-container {
+        background: rgba(0, 180, 216, 0.1);
+        padding: 2rem;
+        border-radius: 10px;
+        margin: 1rem 0;
+    }
+    .feedback-text {
+        background: rgba(0, 31, 63, 0.1);
+        padding: 1rem;
+        border-radius: 5px;
+        margin: 1rem 0;
+    }
+</style>
+""", unsafe_allow_html=True)
 
+@dataclass
+class ExerciseState:
+    counter: int = 0
+    stage: str = None
+    feedback: str = ""
 
-def lateral_raise():
-    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
-    
-    
-    # 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)
-    
-    
-    # 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
-                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_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("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()
+# Global state
+state = ExerciseState()
+lock = threading.Lock()
 
+def calculate_angle(a, b, c):
+    """Calculate angle between three points."""
+    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 shoulder_press():
-    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)
+def calculate_lateral_raise_angle(shoulder, wrist):
+    """Calculate angle for lateral raise."""
+    horizontal_reference = np.array([1, 0])
+    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)
     
-    # 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
+    if magnitude_arm == 0 or magnitude_reference == 0:
+        return 0
     
-    
-    # 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)
-    
-    
-    # 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__":
-        main()
+    cos_angle = dot_product / (magnitude_reference * magnitude_arm)
+    angle = np.arccos(np.clip(cos_angle, -1.0, 1.0))
+    return np.degrees(angle)
 
+class VideoTransformer(VideoTransformerBase):
+    def __init__(self):
+        self.pose = mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5)
+        self.workout_type = "bicep_curl"  # Default workout
+        
+    def process_bicep_curl(self, landmarks):
+        """Process frame for bicep curl exercise."""
+        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 = calculate_angle(shoulder, elbow, wrist)
+        
+        with lock:
+            if angle > 160 and state.stage != "down":
+                state.stage = "down"
+                state.feedback = "Lower the weight"
+            elif angle < 40 and state.stage == "down":
+                state.stage = "up"
+                state.counter += 1
+                state.feedback = f"Good rep! Count: {state.counter}"
+        
+        return angle
 
-# Streamlit configuration
-st.set_page_config(page_title="Workout Tracker", page_icon="💪", layout="centered")
+    def process_lateral_raise(self, landmarks):
+        """Process frame for lateral raise exercise."""
+        shoulder = [landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].x,
+                   landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].y]
+        wrist = [landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].x,
+                landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].y]
+        
+        angle = calculate_lateral_raise_angle(shoulder, wrist)
+        
+        with lock:
+            if angle < 20 and state.stage != "down":
+                state.stage = "down"
+                state.feedback = "Raise your arms"
+            elif 70 <= angle <= 110 and state.stage == "down":
+                state.stage = "up"
+                state.counter += 1
+                state.feedback = f"Good rep! Count: {state.counter}"
+        
+        return angle
 
-# Custom CSS for styling
-st.markdown(
-    '''
-    <style>
-    body {
-        background-color: #001f3f;
-        color: #7FDBFF;
-        font-family: Arial, sans-serif;
-    }
-    .stButton > button {
-        background-color: #0074D9;
-        color: white;
-        border-radius: 5px;
-        padding: 10px 20px;
-        font-size: 18px;
-    }
-    .stButton > button:hover {
-        background-color: #7FDBFF;
-        color: #001f3f;
-    }
-    </style>
-    ''',
-    unsafe_allow_html=True
-)
+    def process_shoulder_press(self, landmarks):
+        """Process frame for shoulder press exercise."""
+        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 = calculate_angle(shoulder, elbow, wrist)
+        
+        with lock:
+            if 80 <= angle <= 100 and state.stage != "down":
+                state.stage = "down"
+                state.feedback = "Press up!"
+            elif angle > 160 and state.stage == "down":
+                state.stage = "up"
+                state.counter += 1
+                state.feedback = f"Good rep! Count: {state.counter}"
+        
+        return angle
 
-# Title and Introduction
-st.title("Workout Tracker")
-st.markdown("Welcome to the **Workout Tracker App**! Select your desired workout below and receive real-time feedback as you exercise.")
+    def recv(self, frame):
+        img = frame.to_ndarray(format="bgr24")
+        
+        # Process the image
+        image = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        results = self.pose.process(image)
+        
+        if results.pose_landmarks:
+            # Draw pose landmarks
+            mp_drawing.draw_landmarks(
+                img, results.pose_landmarks, mp_pose.POSE_CONNECTIONS,
+                mp_drawing.DrawingSpec(color=(0, 255, 0), thickness=2, circle_radius=2),
+                mp_drawing.DrawingSpec(color=(0, 255, 0), thickness=2)
+            )
+            
+            # Process based on workout type
+            if self.workout_type == "bicep_curl":
+                angle = self.process_bicep_curl(results.pose_landmarks.landmark)
+            elif self.workout_type == "lateral_raise":
+                angle = self.process_lateral_raise(results.pose_landmarks.landmark)
+            else:  # shoulder_press
+                angle = self.process_shoulder_press(results.pose_landmarks.landmark)
+            
+            # Draw angle and counter
+            cv2.putText(img, f"Angle: {angle:.2f}", (10, 30),
+                       cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
+            cv2.putText(img, f"Counter: {state.counter}", (10, 70),
+                       cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
+            cv2.putText(img, f"Feedback: {state.feedback}", (10, 110),
+                       cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
+        
+        return av.VideoFrame.from_ndarray(img, format="bgr24")
 
-# Check webcam availability
-def check_webcam():
-    try:
-        cap = cv2.VideoCapture(0)
-        if not cap.isOpened():
-            st.error("Webcam not detected! Please ensure a webcam is connected.")
-            return False
-        cap.release()
-        return True
-    except Exception as e:
-        st.error(f"Error accessing webcam: {e}")
-        return False
+def main():
+    st.title("🏋️‍♂️ AI Workout Trainer")
+    
+    st.markdown("""
+    <div class='workout-container'>
+        Welcome to your AI Workout Trainer! This app will help you perfect your form
+        and track your exercises in real-time. Choose a workout and follow the feedback
+        to improve your technique.
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Workout selection
+    workout_options = {
+        "Bicep Curl": "bicep_curl",
+        "Lateral Raise": "lateral_raise",
+        "Shoulder Press": "shoulder_press"
+    }
+    
+    selected_workout = st.selectbox(
+        "Choose your workout:",
+        list(workout_options.keys())
+    )
+    
+    # Reset state when workout changes
+    if 'last_workout' not in st.session_state or st.session_state.last_workout != selected_workout:
+        with lock:
+            state.counter = 0
+            state.stage = None
+            state.feedback = ""
+        st.session_state.last_workout = selected_workout
 
-# Workout Selection
-workout_option = st.radio("Select Your Workout:", ["Bicep Curl", "Lateral Raise", "Shoulder Press"])
+    # Exercise descriptions
+    descriptions = {
+        "Bicep Curl": "Focus on keeping your upper arm still and curl the weight up smoothly.",
+        "Lateral Raise": "Raise your arms to shoulder height, keeping them slightly bent.",
+        "Shoulder Press": "Press the weight overhead, fully extending your arms."
+    }
+    
+    st.markdown(f"""
+    <div class='workout-container'>
+        <h3>{selected_workout}</h3>
+        <p>{descriptions[selected_workout]}</p>
+    </div>
+    """, unsafe_allow_html=True)
 
-# Start Button
-if st.button("Start Workout"):
-    if not check_webcam():
-        st.stop()
-    if workout_option == "Bicep Curl":
-        st.write("Launching Bicep Curl Tracker...")
-        bicep_curl()
-    elif workout_option == "Lateral Raise":
-        st.write("Launching Lateral Raise Tracker...")
-        lateral_raise()
-    elif workout_option == "Shoulder Press":
-        st.write("Launching Shoulder Press Tracker...")
-        shoulder_press()
+    # Initialize WebRTC streamer
+    webrtc_ctx = webrtc_streamer(
+        key="workout",
+        video_transformer_factory=VideoTransformer,
+        rtc_configuration={"iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]}
+    )
+    
+    if webrtc_ctx.video_transformer:
+        webrtc_ctx.video_transformer.workout_type = workout_options[selected_workout]
+    
+    # Display feedback
+    feedback_placeholder = st.empty()
+    if webrtc_ctx.state.playing:
+        feedback_placeholder.markdown(f"""
+        <div class='feedback-text'>
+            <h4>Current Exercise: {selected_workout}</h4>
+            <p>Reps Completed: {state.counter}</p>
+            <p>Feedback: {state.feedback}</p>
+        </div>
+        """, unsafe_allow_html=True)
 
-# Footer
-st.markdown("---")
-st.markdown("**Note**: Close the workout window or press 'q' in the camera feed to stop the workout.")
+if __name__ == "__main__":
+    main()