Upload 4 files

exercises/hammer_curl.py

@@ -0,0 +1,122 @@
+import cv2
+import numpy as np
+from pose_estimation.angle_calculation import calculate_angle
+from voice_feedback.feedback import provide_hammer_curl_feedback , speak
+
+
+class HammerCurl:
+    def __init__(self):
+        self.counter_right = 0
+        self.counter_left = 0
+        self.stage_right = None  # 'up' or 'down' for right arm
+        self.stage_left = None  # 'up' or 'down' for left arm
+
+        self.angle_threshold = 40  # Angle threshold for misalignment
+        self.flexion_angle_up = 155  # Flexion angle for 'up' stage
+        self.flexion_angle_down = 35  # Flexion angle for 'down' stage
+
+        self.angle_threshold_up = 155  # Upper threshold for 'up' stage
+        self.angle_threshold_down = 47  # Lower threshold for 'down' stage
+
+    def calculate_shoulder_elbow_hip_angle(self, shoulder, elbow, hip):
+        """Calculate the angle between shoulder, elbow, and hip."""
+        return calculate_angle(elbow, shoulder, hip)
+
+    def calculate_shoulder_elbow_wrist(self, shoulder, elbow, wrist):
+        """Calculate the angle between shoulder, elbow, and wrist."""
+        return calculate_angle(shoulder, elbow, wrist)
+
+    def track_hammer_curl(self, landmarks, frame):
+        # Right arm landmarks (shoulder, elbow, hip, wrist)
+        shoulder_right = [int(landmarks[11].x * frame.shape[1]), int(landmarks[11].y * frame.shape[0])]
+        elbow_right = [int(landmarks[13].x * frame.shape[1]), int(landmarks[13].y * frame.shape[0])]
+        hip_right = [int(landmarks[23].x * frame.shape[1]), int(landmarks[23].y * frame.shape[0])]
+        wrist_right = [int(landmarks[15].x * frame.shape[1]), int(landmarks[15].y * frame.shape[0])]
+
+        # Left arm landmarks (shoulder, elbow, hip, wrist)
+        shoulder_left = [int(landmarks[12].x * frame.shape[1]), int(landmarks[12].y * frame.shape[0])]
+        elbow_left = [int(landmarks[14].x * frame.shape[1]), int(landmarks[14].y * frame.shape[0])]
+        hip_left = [int(landmarks[24].x * frame.shape[1]), int(landmarks[24].y * frame.shape[0])]
+        wrist_left = [int(landmarks[16].x * frame.shape[1]), int(landmarks[16].y * frame.shape[0])]
+
+        # Calculate the angle for counting (elbow flexion angle)
+        angle_right_counter = self.calculate_shoulder_elbow_wrist(shoulder_right, elbow_right, wrist_right)
+        angle_left_counter = self.calculate_shoulder_elbow_wrist(shoulder_left, elbow_left, wrist_left)
+
+        # Calculate the angle for the right arm (shoulder, elbow, hip)
+        angle_right = self.calculate_shoulder_elbow_hip_angle(shoulder_right, elbow_right, hip_right)
+
+        # Calculate the angle for the left arm (shoulder, elbow, hip)
+        angle_left = self.calculate_shoulder_elbow_hip_angle(shoulder_left, elbow_left, hip_left)
+
+        # Draw lines with improved style
+        self.draw_line_with_style(frame, shoulder_left, elbow_left, (0, 0, 255), 4)
+        self.draw_line_with_style(frame, elbow_left, wrist_left, (0, 0, 255), 4)
+
+        self.draw_line_with_style(frame, shoulder_right, elbow_right, (0, 0, 255), 4)
+        self.draw_line_with_style(frame, elbow_right, wrist_right, (0, 0, 255), 4)
+
+        # Add circles to highlight key points
+        self.draw_circle(frame, shoulder_left, (0, 0, 255), 8)
+        self.draw_circle(frame, elbow_left, (0, 0, 255), 8)
+        self.draw_circle(frame, wrist_left, (0, 0, 255), 8)
+
+        self.draw_circle(frame, shoulder_right, (0, 0, 255), 8)
+        self.draw_circle(frame, elbow_right, (0, 0, 255), 8)
+        self.draw_circle(frame, wrist_right, (0, 0, 255), 8)
+
+        # Convert the angles to integers and update the text positions
+        angle_text_position_left = (elbow_left[0] + 10, elbow_left[1] - 10)
+        cv2.putText(frame, f'Angle: {int(angle_left_counter)}', angle_text_position_left, cv2.FONT_HERSHEY_SIMPLEX, 0.5,
+                     (255, 255, 255), 2)
+
+        angle_text_position_right = (elbow_right[0] + 10, elbow_right[1] - 10)
+        cv2.putText(frame, f'Angle: {int(angle_right_counter)}', angle_text_position_right, cv2.FONT_HERSHEY_SIMPLEX,
+                    0.5,
+                    (255, 255, 255), 2)
+
+        warning_message_right = None
+        warning_message_left = None
+
+        # Check for misalignment based on shoulder-elbow-hip angle
+        if abs(angle_right) > self.angle_threshold:
+            warning_message_right = f"Right Shoulder-Elbow-Hip Misalignment! Angle: {angle_right:.2f}°"
+        if abs(angle_left) > self.angle_threshold:
+            warning_message_left = f"Left Shoulder-Elbow-Hip Misalignment! Angle: {angle_left:.2f}°"
+
+        if angle_right_counter > self.angle_threshold_up:
+            self.stage_right = "Flex"
+        elif self.angle_threshold_down < angle_right_counter < self.angle_threshold_up and self.stage_right == "Flex":
+            self.stage_right = "Up"
+        elif angle_right_counter < self.angle_threshold_down and self.stage_right=="Up":
+            self.stage_right = "Down"
+            self.counter_right +=1
+
+        if angle_left_counter > self.angle_threshold_up:
+            self.stage_left = "Flex"
+        elif self.angle_threshold_down < angle_left_counter < self.angle_threshold_up and self.stage_left == "Flex":
+            self.stage_left = "Up"
+        elif angle_left_counter < self.angle_threshold_down and self.stage_left == "Up":
+            self.stage_left = "Down"
+            self.counter_left +=1
+
+        # Progress percentages: 1 for "up", 0 for "down"
+        progress_right = 1 if self.stage_right == "up" else 0 # Note: your stage names are 'Flex', 'Up', 'Down'
+        progress_left = 1 if self.stage_left == "up" else 0   # This logic might need adjusting based on stage names
+
+        return self.counter_right, angle_right_counter, self.counter_left, angle_left_counter, warning_message_right, warning_message_left, progress_right, progress_left, self.stage_right, self.stage_left
+
+    def draw_line_with_style(self, frame, start_point, end_point, color, thickness):
+        cv2.line(frame, start_point, end_point, color, thickness, lineType=cv2.LINE_AA)
+
+    def draw_circle(self, frame, center, color, radius):
+        """Draw a circle with specified style."""
+        cv2.circle(frame, center, radius, color, -1)  # -1 to fill the circle
+
+    # Inside the HammerCurl class in hammer_curl.py
+    def reset_reps(self):
+        self.counter_right = 0
+        self.counter_left = 0
+        self.stage_right = None  # Or your desired initial stage, e.g., "Down" or "Flex"
+        self.stage_left = None   # Or your desired initial stage
+        print("HammerCurl reps and stages reset for new set.")

exercises/push_up.py

@@ -0,0 +1,137 @@
+import mediapipe as mp
+import time
+from pose_estimation.angle_calculation import calculate_angle
+
+class PushUp:
+    def __init__(self):
+        self.counter = 0
+        self.stage = "up"  # Changed from "Initial"
+        self.angle_threshold_up = 150
+        self.angle_threshold_down = 70
+        self.last_counter_update = time.time()
+        self.mp_pose = mp.solutions.pose # Added
+
+    def calculate_shoulder_elbow_wrist_angle(self, shoulder, elbow, wrist):
+        """Calculate the angle between shoulder, elbow, and wrist."""
+        return calculate_angle(shoulder, elbow, wrist)
+
+    def track_push_up(self, landmarks_mp, frame_width, frame_height):
+        lm = landmarks_mp # shortcut
+
+        # Left side landmarks
+        shoulder_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_SHOULDER.value].x * frame_width),
+                         int(lm[self.mp_pose.PoseLandmark.LEFT_SHOULDER.value].y * frame_height)]
+        elbow_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_ELBOW.value].x * frame_width),
+                      int(lm[self.mp_pose.PoseLandmark.LEFT_ELBOW.value].y * frame_height)]
+        wrist_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_WRIST.value].x * frame_width),
+                      int(lm[self.mp_pose.PoseLandmark.LEFT_WRIST.value].y * frame_height)]
+
+        # Right side landmarks
+        shoulder_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value].x * frame_width),
+                          int(lm[self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value].y * frame_height)]
+        elbow_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_ELBOW.value].x * frame_width),
+                       int(lm[self.mp_pose.PoseLandmark.RIGHT_ELBOW.value].y * frame_height)]
+        wrist_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_WRIST.value].x * frame_width),
+                       int(lm[self.mp_pose.PoseLandmark.RIGHT_WRIST.value].y * frame_height)]
+
+        # Calculate angles
+        angle_left = self.calculate_shoulder_elbow_wrist_angle(shoulder_left, elbow_left, wrist_left)
+        angle_right = self.calculate_shoulder_elbow_wrist_angle(shoulder_right, elbow_right, wrist_right)
+
+        # Stage and Counter Logic
+        current_angle_for_logic = angle_left
+        current_time = time.time()
+
+        if current_angle_for_logic > self.angle_threshold_up:
+            self.stage = "up"
+        elif self.angle_threshold_down < current_angle_for_logic < self.angle_threshold_up and self.stage == "up":
+            self.stage = "down"
+        elif current_angle_for_logic < self.angle_threshold_down and self.stage == "down":
+            if current_time - self.last_counter_update > 1:  # 1 second debounce
+                self.counter += 1
+                self.last_counter_update = current_time
+            self.stage = "up" # Transition back to up
+
+        feedback = self._get_push_up_feedback(angle_left, angle_right, self.stage)
+
+        return {
+            "counter": self.counter,
+            "stage": self.stage,
+            "angle_left": angle_left,
+            "angle_right": angle_right,
+            "feedback": feedback
+        }
+
+    def _get_push_up_feedback(self, angle_left, angle_right, stage):
+        feedback = "Keep going!" # Default
+
+        if stage == "down":
+            if min(angle_left, angle_right) < self.angle_threshold_down - 5:
+                feedback = "Good depth!"
+            elif min(angle_left, angle_right) > self.angle_threshold_down + 10:
+                feedback = "Go lower."
+        elif stage == "up":
+             feedback = "Push up!" # Or "Ready"
+
+        if abs(angle_left - angle_right) > 25:
+            feedback += " Try to keep your push-up even." if feedback != "Keep going!" else "Try to keep your push-up even."
+
+        return feedback.strip()
+
+    def get_drawing_annotations(self, landmarks_mp, frame_width, frame_height, exercise_data_dict):
+        annotations = []
+        lm = landmarks_mp # shortcut
+
+        # Pixel coordinates
+        shoulder_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_SHOULDER.value].x * frame_width),
+                         int(lm[self.mp_pose.PoseLandmark.LEFT_SHOULDER.value].y * frame_height)]
+        elbow_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_ELBOW.value].x * frame_width),
+                      int(lm[self.mp_pose.PoseLandmark.LEFT_ELBOW.value].y * frame_height)]
+        wrist_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_WRIST.value].x * frame_width),
+                      int(lm[self.mp_pose.PoseLandmark.LEFT_WRIST.value].y * frame_height)]
+
+        shoulder_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value].x * frame_width),
+                          int(lm[self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value].y * frame_height)]
+        elbow_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_ELBOW.value].x * frame_width),
+                       int(lm[self.mp_pose.PoseLandmark.RIGHT_ELBOW.value].y * frame_height)]
+        wrist_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_WRIST.value].x * frame_width),
+                       int(lm[self.mp_pose.PoseLandmark.RIGHT_WRIST.value].y * frame_height)]
+
+        # Lines (original colors: left (0,0,255) -> BGR [255,0,0], right (102,0,0) -> BGR [0,0,102])
+        annotations.append({"type": "line", "start_point": shoulder_left, "end_point": elbow_left, "color_bgr": [255, 0, 0], "thickness": 2})
+        annotations.append({"type": "line", "start_point": elbow_left, "end_point": wrist_left, "color_bgr": [255, 0, 0], "thickness": 2})
+        annotations.append({"type": "line", "start_point": shoulder_right, "end_point": elbow_right, "color_bgr": [0, 0, 102], "thickness": 2})
+        annotations.append({"type": "line", "start_point": elbow_right, "end_point": wrist_right, "color_bgr": [0, 0, 102], "thickness": 2})
+
+        # Circles
+        annotations.append({"type": "circle", "center_point": shoulder_left, "radius": 8, "color_bgr": [255, 0, 0], "filled": True})
+        annotations.append({"type": "circle", "center_point": elbow_left, "radius": 8, "color_bgr": [255, 0, 0], "filled": True})
+        annotations.append({"type": "circle", "center_point": wrist_left, "radius": 8, "color_bgr": [255, 0, 0], "filled": True})
+        annotations.append({"type": "circle", "center_point": shoulder_right, "radius": 8, "color_bgr": [0, 0, 102], "filled": True})
+        annotations.append({"type": "circle", "center_point": elbow_right, "radius": 8, "color_bgr": [0, 0, 102], "filled": True})
+        annotations.append({"type": "circle", "center_point": wrist_right, "radius": 8, "color_bgr": [0, 0, 102], "filled": True})
+
+        # Text for angles
+        if 'angle_left' in exercise_data_dict:
+            annotations.append({"type": "text", "text_content": f"Angle L: {int(exercise_data_dict['angle_left'])}",
+                                "position": [elbow_left[0] + 10, elbow_left[1] - 10],
+                                "font_scale": 0.5, "color_bgr": [255, 255, 255], "thickness": 2})
+        if 'angle_right' in exercise_data_dict:
+            annotations.append({"type": "text", "text_content": f"Angle R: {int(exercise_data_dict['angle_right'])}",
+                                "position": [elbow_right[0] + 10, elbow_right[1] - 10],
+                                "font_scale": 0.5, "color_bgr": [255, 255, 255], "thickness": 2})
+
+        # Display main feedback from exercise_data_dict
+        if 'feedback' in exercise_data_dict:
+             annotations.append({"type": "text", "text_content": exercise_data_dict['feedback'],
+                                "position": [frame_width // 2 - 150, frame_height - 40], # Adjusted for longer text
+                                "font_scale": 0.7, "color_bgr": [0, 255, 0], "thickness": 2}) # Green for feedback
+
+        return annotations
+    
+    # Inside the PushUp class in push_up.py
+    def reset_reps(self):
+        self.counter = 0
+        self.stage = "up"  # Reset to the initial stage
+        self.last_counter_update = time.time() # Important to reset debounce timer
+        print("PushUp reps and stage reset for new set.")

exercises/squat.py

@@ -0,0 +1,148 @@
+import mediapipe as mp
+from pose_estimation.angle_calculation import calculate_angle
+
+class Squat:
+    def __init__(self):
+        self.counter = 0
+        self.stage = "up"  # Initial stage
+        self.mp_pose = mp.solutions.pose # Added for convenience
+
+    def calculate_angle(self, point1, point2, point3): # Assuming these are pixel coordinates
+        return calculate_angle(point1, point2, point3)
+
+    def track_squat(self, landmarks_mp, frame_width, frame_height):
+        lm = landmarks_mp # shortcut
+
+        # Left side landmarks
+        shoulder_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_SHOULDER.value].x * frame_width),
+                         int(lm[self.mp_pose.PoseLandmark.LEFT_SHOULDER.value].y * frame_height)]
+        hip_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_HIP.value].x * frame_width),
+                    int(lm[self.mp_pose.PoseLandmark.LEFT_HIP.value].y * frame_height)]
+        knee_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_KNEE.value].x * frame_width),
+                     int(lm[self.mp_pose.PoseLandmark.LEFT_KNEE.value].y * frame_height)]
+        # ankle_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_ANKLE.value].x * frame_width),
+        #               int(lm[self.mp_pose.PoseLandmark.LEFT_ANKLE.value].y * frame_height)]
+
+
+        # Right side landmarks
+        shoulder_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value].x * frame_width),
+                          int(lm[self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value].y * frame_height)]
+        hip_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_HIP.value].x * frame_width),
+                     int(lm[self.mp_pose.PoseLandmark.RIGHT_HIP.value].y * frame_height)]
+        knee_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_KNEE.value].x * frame_width),
+                      int(lm[self.mp_pose.PoseLandmark.RIGHT_KNEE.value].y * frame_height)]
+        # ankle_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_ANKLE.value].x * frame_width),
+        #                int(lm[self.mp_pose.PoseLandmark.RIGHT_ANKLE.value].y * frame_height)]
+
+        # Calculate angles
+        angle_left = self.calculate_angle(shoulder_left, hip_left, knee_left)
+        angle_right = self.calculate_angle(shoulder_right, hip_right, knee_right)
+
+        # Stage and counter logic (using angle_left for primary logic)
+        current_angle_for_logic = angle_left
+        if current_angle_for_logic > 170:
+            self.stage = "up"
+        elif 90 < current_angle_for_logic < 170 and self.stage == "up":
+            self.stage = "down"
+        elif current_angle_for_logic < 90 and self.stage == "down":
+            self.stage = "up"
+            self.counter += 1
+
+        feedback_message = self._get_squat_feedback(angle_left, angle_right, self.stage,
+                                                    knee_left, hip_left, shoulder_left,
+                                                    knee_right, hip_right, shoulder_right)
+
+        return {
+            "counter": self.counter,
+            "stage": self.stage,
+            "angle_left": angle_left,
+            "angle_right": angle_right,
+            "feedback": feedback_message
+        }
+
+    def _get_squat_feedback(self, angle_left, angle_right, stage,
+                            knee_left, hip_left, shoulder_left,
+                            knee_right, hip_right, shoulder_right): # Added points for future use
+        feedback = "Keep going." # Default feedback
+
+        if stage == "down":
+            if min(angle_left, angle_right) < 80:
+                feedback = "Good depth!"
+            elif min(angle_left, angle_right) > 100: # Knees should be more bent
+                feedback = "Go lower."
+
+        if abs(angle_left - angle_right) > 20: # Check for uneven squat
+             # Adding a check to see if there's significant movement, e.g., not in "up" stage fully extended
+            if not (stage == "up" and min(angle_left, angle_right) > 160): # Avoid this message if standing straight
+                feedback += " Try to keep your squat even." if feedback != "Keep going." else "Try to keep your squat even."
+
+
+        # Placeholder for more advanced feedback using the passed points:
+        # E.g., Knee valgus: check if knee_left.x < hip_left.x and knee_left.x > shoulder_left.x (simplified)
+        # E.g., Back posture: calculate angle shoulder-hip-ankle (requires ankle points)
+
+        return feedback.strip()
+
+
+    def get_drawing_annotations(self, landmarks_mp, frame_width, frame_height, exercise_data_dict):
+        annotations = []
+        lm = landmarks_mp # shortcut
+
+        # Re-calculate or retrieve necessary points (pixel coordinates)
+        # For simplicity, re-calculating here. Could be optimized by passing from track_squat.
+        shoulder_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_SHOULDER.value].x * frame_width),
+                         int(lm[self.mp_pose.PoseLandmark.LEFT_SHOULDER.value].y * frame_height)]
+        hip_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_HIP.value].x * frame_width),
+                    int(lm[self.mp_pose.PoseLandmark.LEFT_HIP.value].y * frame_height)]
+        knee_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_KNEE.value].x * frame_width),
+                     int(lm[self.mp_pose.PoseLandmark.LEFT_KNEE.value].y * frame_height)]
+
+        shoulder_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value].x * frame_width),
+                          int(lm[self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value].y * frame_height)]
+        hip_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_HIP.value].x * frame_width),
+                     int(lm[self.mp_pose.PoseLandmark.RIGHT_HIP.value].y * frame_height)]
+        knee_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_KNEE.value].x * frame_width),
+                      int(lm[self.mp_pose.PoseLandmark.RIGHT_KNEE.value].y * frame_height)]
+
+        # Lines for left side (original color: (178, 102, 255) -> BGR: [255, 102, 178])
+        annotations.append({"type": "line", "start_point": shoulder_left, "end_point": hip_left, "color_bgr": [255, 102, 178], "thickness": 2})
+        annotations.append({"type": "line", "start_point": hip_left, "end_point": knee_left, "color_bgr": [255, 102, 178], "thickness": 2})
+
+        # Lines for right side (original color: (51, 153, 255) -> BGR: [255, 153, 51])
+        annotations.append({"type": "line", "start_point": shoulder_right, "end_point": hip_right, "color_bgr": [255, 153, 51], "thickness": 2})
+        annotations.append({"type": "line", "start_point": hip_right, "end_point": knee_right, "color_bgr": [255, 153, 51], "thickness": 2})
+
+        # Circles for left side
+        annotations.append({"type": "circle", "center_point": shoulder_left, "radius": 8, "color_bgr": [255, 102, 178], "filled": True})
+        annotations.append({"type": "circle", "center_point": hip_left, "radius": 8, "color_bgr": [255, 102, 178], "filled": True})
+        annotations.append({"type": "circle", "center_point": knee_left, "radius": 8, "color_bgr": [255, 102, 178], "filled": True})
+
+        # Circles for right side
+        annotations.append({"type": "circle", "center_point": shoulder_right, "radius": 8, "color_bgr": [255, 153, 51], "filled": True})
+        annotations.append({"type": "circle", "center_point": hip_right, "radius": 8, "color_bgr": [255, 153, 51], "filled": True})
+        annotations.append({"type": "circle", "center_point": knee_right, "radius": 8, "color_bgr": [255, 153, 51], "filled": True})
+
+        # Text for angles
+        if 'angle_left' in exercise_data_dict:
+            annotations.append({"type": "text", "text_content": f"Angle L: {int(exercise_data_dict['angle_left'])}",
+                                "position": [knee_left[0] + 10, knee_left[1] - 10],
+                                "font_scale": 0.5, "color_bgr": [255, 255, 255], "thickness": 2})
+        if 'angle_right' in exercise_data_dict:
+            annotations.append({"type": "text", "text_content": f"Angle R: {int(exercise_data_dict['angle_right'])}",
+                                "position": [knee_right[0] + 10, knee_right[1] - 10],
+                                "font_scale": 0.5, "color_bgr": [255, 255, 255], "thickness": 2})
+
+        # Display main feedback from exercise_data_dict
+        if 'feedback' in exercise_data_dict:
+             annotations.append({"type": "text", "text_content": exercise_data_dict['feedback'],
+                                "position": [frame_width // 2 - 100, frame_height - 40], # Centered at bottom
+                                "font_scale": 0.7, "color_bgr": [0, 0, 255], "thickness": 2})
+
+
+        return annotations
+    
+    # Inside the Squat class in squat.py
+    def reset_reps(self):
+        self.counter = 0
+        self.stage = "up"  # Reset to the initial stage
+        print("Squat reps and stage reset for new set.")