Update1

app.py

@@ -0,0 +1,720 @@
+# Consolidated Streamlit App
+import streamlit as st
+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
+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
+
+
+# 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()
+
+
+# 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),
+    )
+    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()
+
+