Updated app with new features

app.py

@@ -0,0 +1,28 @@
+import streamlit as st
+
+
+st.title('Anju AI Fitness Trainer')
+
+
+#displaying a local video file
+
+
+# Define the URL of the gif
+gif_url = "output_recorded.gif"
+
+# Display the gif using st.image
+st.image(gif_url)
+
+    
+    
+
+    
+
+
+
+    
+    
+
+    
+
+

packages.txt

@@ -0,0 +1,2 @@
+ffmpeg
+python3-opencv

pages/1_📷️_Live_Stream.py

@@ -0,0 +1,68 @@
+import av
+import os
+import sys
+import streamlit as st
+from streamlit_webrtc import VideoHTMLAttributes, webrtc_streamer
+from aiortc.contrib.media import MediaRecorder
+
+
+BASE_DIR = os.path.abspath(os.path.join(__file__, '../../'))
+sys.path.append(BASE_DIR)
+
+
+from utils import get_mediapipe_pose
+from process_frame import ProcessFrame
+from thresholds import get_thresholds_beginner, get_thresholds_pro
+
+
+st.title('Anju AI Fitness Trainer')
+
+mode = st.radio('Select Mode', ['Beginner', 'Pro'], horizontal=True)
+
+thresholds = None 
+
+if mode == 'Beginner':
+    thresholds = get_thresholds_beginner()
+
+elif mode == 'Pro':
+    thresholds = get_thresholds_pro()
+
+
+live_process_frame = ProcessFrame(thresholds=thresholds, flip_frame=True)
+# Initialize face mesh solution
+pose = get_mediapipe_pose()
+
+
+if 'download' not in st.session_state:
+    st.session_state['download'] = False
+
+output_video_file = f'output_live.flv'
+
+  
+
+def video_frame_callback(frame: av.VideoFrame):
+    frame = frame.to_ndarray(format="rgb24")  # Decode and get RGB frame
+    frame, _ = live_process_frame.process(frame, pose)  # Process frame
+    return av.VideoFrame.from_ndarray(frame, format="rgb24")  # Encode and return BGR frame
+
+
+def out_recorder_factory() -> MediaRecorder:
+        return MediaRecorder(output_video_file)
+
+
+ctx = webrtc_streamer(
+                        key="Squats-pose-analysis",
+                        video_frame_callback=video_frame_callback,
+                        rtc_configuration={"iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]},  # Add this config
+                        media_stream_constraints={"video": {"width": {'min':480, 'ideal':480}}, "audio": False},
+                        video_html_attrs=VideoHTMLAttributes(autoPlay=True, controls=False, muted=False),
+                        out_recorder_factory=None
+                    )
+
+
+
+
+
+    
+
+

pages/2_ ⬆️_Upload_Video.py

@@ -0,0 +1,135 @@
+import av
+import os
+import sys
+import streamlit as st
+import cv2
+import tempfile
+
+
+BASE_DIR = os.path.abspath(os.path.join(__file__, '../../'))
+sys.path.append(BASE_DIR)
+
+
+from utils import get_mediapipe_pose
+from process_frame import ProcessFrame
+from thresholds import get_thresholds_beginner, get_thresholds_pro
+
+
+
+st.title('Anju AI Fitness Trainer')
+
+mode = st.radio('Select Mode', ['Beginner', 'Pro'], horizontal=True)
+
+
+
+thresholds = None 
+
+if mode == 'Beginner':
+    thresholds = get_thresholds_beginner()
+
+elif mode == 'Pro':
+    thresholds = get_thresholds_pro()
+
+
+
+upload_process_frame = ProcessFrame(thresholds=thresholds)
+
+# Initialize face mesh solution
+pose = get_mediapipe_pose()
+
+
+download = None
+
+if 'download' not in st.session_state:
+    st.session_state['download'] = False
+
+
+output_video_file = f'output_recorded.mp4'
+
+if os.path.exists(output_video_file):
+    os.remove(output_video_file)
+
+
+with st.form('Upload', clear_on_submit=True):
+    up_file = st.file_uploader("Upload a Video", ['mp4','mov', 'avi'])
+    uploaded = st.form_submit_button("Upload")
+
+stframe = st.empty()
+
+ip_vid_str = '<p style="font-family:Helvetica; font-weight: bold; font-size: 16px;">Input Video</p>'
+warning_str = '<p style="font-family:Helvetica; font-weight: bold; color: Red; font-size: 17px;">Please Upload a Video first!!!</p>'
+
+warn = st.empty()
+
+
+download_button = st.empty()
+
+if up_file and uploaded:
+    
+    download_button.empty()
+    tfile = tempfile.NamedTemporaryFile(delete=False)
+
+    try:
+        warn.empty()
+        tfile.write(up_file.read())
+
+        vf = cv2.VideoCapture(tfile.name)
+
+        # ---------------------  Write the processed video frame. --------------------
+        fps = int(vf.get(cv2.CAP_PROP_FPS))
+        width = int(vf.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(vf.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        frame_size = (width, height)
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        video_output = cv2.VideoWriter(output_video_file, fourcc, fps, frame_size)
+        # -----------------------------------------------------------------------------
+
+        
+        txt = st.sidebar.markdown(ip_vid_str, unsafe_allow_html=True)   
+        ip_video = st.sidebar.video(tfile.name) 
+
+        while vf.isOpened():
+            ret, frame = vf.read()
+            if not ret:
+                break
+
+            # convert frame from BGR to RGB before processing it.
+            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            out_frame, _ = upload_process_frame.process(frame, pose)
+            stframe.image(out_frame)
+            video_output.write(out_frame[...,::-1])
+
+        
+        vf.release()
+        video_output.release()
+        stframe.empty()
+        ip_video.empty()
+        txt.empty()
+        tfile.close()
+    
+    except AttributeError:
+        warn.markdown(warning_str, unsafe_allow_html=True)   
+
+
+
+if os.path.exists(output_video_file):
+    with open(output_video_file, 'rb') as op_vid:
+        download = download_button.download_button('Download Video', data = op_vid, file_name='output_recorded.mp4')
+    
+    if download:
+        st.session_state['download'] = True
+
+
+
+if os.path.exists(output_video_file) and st.session_state['download']:
+    os.remove(output_video_file)
+    st.session_state['download'] = False
+    download_button.empty()
+
+
+    
+    
+
+    
+
+

process_frame.py

@@ -0,0 +1,554 @@
+import time
+import cv2
+import numpy as np
+from utils import find_angle, get_landmark_features, draw_text
+
+
+class ProcessFrame:
+    def __init__(self, thresholds, flip_frame = False):
+        
+        # Set if frame should be flipped or not.
+        self.flip_frame = flip_frame
+
+        # self.thresholds
+        self.thresholds = thresholds
+
+        # Font type.
+        self.font = cv2.FONT_HERSHEY_SIMPLEX
+
+        # line type
+        self.linetype = cv2.LINE_AA
+
+        # set radius to draw arc
+        self.radius = 20
+
+        # Colors in BGR format.
+        self.COLORS = {
+                        'blue'       : (0, 127, 255),
+                        'red'        : (255, 50, 50),
+                        'green'      : (0, 255, 127),
+                        'light_green': (100, 233, 127),
+                        'yellow'     : (255, 255, 0),
+                        'magenta'    : (255, 0, 255),
+                        'white'      : (255,255,255),
+                        'cyan'       : (0, 255, 255),
+                        'light_blue' : (102, 204, 255)
+                      }
+
+
+
+        # Dictionary to maintain the various landmark features.
+        self.dict_features = {}
+        self.left_features = {
+                                'shoulder': 11,
+                                'elbow'   : 13,
+                                'wrist'   : 15,                    
+                                'hip'     : 23,
+                                'knee'    : 25,
+                                'ankle'   : 27,
+                                'foot'    : 31
+                             }
+
+        self.right_features = {
+                                'shoulder': 12,
+                                'elbow'   : 14,
+                                'wrist'   : 16,
+                                'hip'     : 24,
+                                'knee'    : 26,
+                                'ankle'   : 28,
+                                'foot'    : 32
+                              }
+
+        self.dict_features['left'] = self.left_features
+        self.dict_features['right'] = self.right_features
+        self.dict_features['nose'] = 0
+
+        
+        # For tracking counters and sharing states in and out of callbacks.
+        self.state_tracker = {
+            'state_seq': [],
+
+            'start_inactive_time': time.perf_counter(),
+            'start_inactive_time_front': time.perf_counter(),
+            'INACTIVE_TIME': 0.0,
+            'INACTIVE_TIME_FRONT': 0.0,
+
+            # 0 --> Bend Backwards, 1 --> Bend Forward, 2 --> Keep shin straight, 3 --> Deep squat
+            'DISPLAY_TEXT' : np.full((4,), False),
+            'COUNT_FRAMES' : np.zeros((4,), dtype=np.int64),
+
+            'LOWER_HIPS': False,
+
+            'INCORRECT_POSTURE': False,
+
+            'prev_state': None,
+            'curr_state':None,
+
+            'SQUAT_COUNT': 0,
+            'IMPROPER_SQUAT':0
+            
+        }
+        
+        self.FEEDBACK_ID_MAP = {
+                                0: ('BEND BACKWARDS', 215, (0, 153, 255)),
+                                1: ('BEND FORWARD', 215, (0, 153, 255)),
+                                2: ('KNEE FALLING OVER TOE', 170, (255, 80, 80)),
+                                3: ('SQUAT TOO DEEP', 125, (255, 80, 80))
+                               }
+
+        
+
+
+    def _get_state(self, knee_angle):
+        
+        knee = None        
+
+        if self.thresholds['HIP_KNEE_VERT']['NORMAL'][0] <= knee_angle <= self.thresholds['HIP_KNEE_VERT']['NORMAL'][1]:
+            knee = 1
+        elif self.thresholds['HIP_KNEE_VERT']['TRANS'][0] <= knee_angle <= self.thresholds['HIP_KNEE_VERT']['TRANS'][1]:
+            knee = 2
+        elif self.thresholds['HIP_KNEE_VERT']['PASS'][0] <= knee_angle <= self.thresholds['HIP_KNEE_VERT']['PASS'][1]:
+            knee = 3
+
+        return f's{knee}' if knee else None
+
+
+
+    
+    def _update_state_sequence(self, state):
+
+        if state == 's2':
+            if (('s3' not in self.state_tracker['state_seq']) and (self.state_tracker['state_seq'].count('s2'))==0) or \
+                    (('s3' in self.state_tracker['state_seq']) and (self.state_tracker['state_seq'].count('s2')==1)):
+                        self.state_tracker['state_seq'].append(state)
+            
+
+        elif state == 's3':
+            if (state not in self.state_tracker['state_seq']) and 's2' in self.state_tracker['state_seq']: 
+                self.state_tracker['state_seq'].append(state)
+
+            
+
+
+    def _show_feedback(self, frame, c_frame, dict_maps, lower_hips_disp):
+
+
+        if lower_hips_disp:
+            draw_text(
+                    frame, 
+                    'LOWER YOUR HIPS', 
+                    pos=(30, 80),
+                    text_color=(0, 0, 0),
+                    font_scale=0.6,
+                    text_color_bg=(255, 255, 0)
+                )  
+
+        for idx in np.where(c_frame)[0]:
+            draw_text(
+                    frame, 
+                    dict_maps[idx][0], 
+                    pos=(30, dict_maps[idx][1]),
+                    text_color=(255, 255, 230),
+                    font_scale=0.6,
+                    text_color_bg=dict_maps[idx][2]
+                )
+
+        return frame
+
+
+
+    def process(self, frame: np.array, pose):
+        play_sound = None
+       
+
+        frame_height, frame_width, _ = frame.shape
+
+        # Process the image.
+        keypoints = pose.process(frame)
+
+        if keypoints.pose_landmarks:
+            ps_lm = keypoints.pose_landmarks
+
+            nose_coord = get_landmark_features(ps_lm.landmark, self.dict_features, 'nose', frame_width, frame_height)
+            left_shldr_coord, left_elbow_coord, left_wrist_coord, left_hip_coord, left_knee_coord, left_ankle_coord, left_foot_coord = \
+                                get_landmark_features(ps_lm.landmark, self.dict_features, 'left', frame_width, frame_height)
+            right_shldr_coord, right_elbow_coord, right_wrist_coord, right_hip_coord, right_knee_coord, right_ankle_coord, right_foot_coord = \
+                                get_landmark_features(ps_lm.landmark, self.dict_features, 'right', frame_width, frame_height)
+
+            offset_angle = find_angle(left_shldr_coord, right_shldr_coord, nose_coord)
+
+            if offset_angle > self.thresholds['OFFSET_THRESH']:
+                
+                display_inactivity = False
+
+                end_time = time.perf_counter()
+                self.state_tracker['INACTIVE_TIME_FRONT'] += end_time - self.state_tracker['start_inactive_time_front']
+                self.state_tracker['start_inactive_time_front'] = end_time
+
+                if self.state_tracker['INACTIVE_TIME_FRONT'] >= self.thresholds['INACTIVE_THRESH']:
+                    self.state_tracker['SQUAT_COUNT'] = 0
+                    self.state_tracker['IMPROPER_SQUAT'] = 0
+                    display_inactivity = True
+
+                cv2.circle(frame, nose_coord, 7, self.COLORS['white'], -1)
+                cv2.circle(frame, left_shldr_coord, 7, self.COLORS['yellow'], -1)
+                cv2.circle(frame, right_shldr_coord, 7, self.COLORS['magenta'], -1)
+
+                if self.flip_frame:
+                    frame = cv2.flip(frame, 1)
+
+                if display_inactivity:
+                    # cv2.putText(frame, 'Resetting SQUAT_COUNT due to inactivity!!!', (10, frame_height - 90), 
+                    #             self.font, 0.5, self.COLORS['blue'], 2, lineType=self.linetype)
+                    play_sound = 'reset_counters'
+                    self.state_tracker['INACTIVE_TIME_FRONT'] = 0.0
+                    self.state_tracker['start_inactive_time_front'] = time.perf_counter()
+
+                draw_text(
+                    frame, 
+                    "CORRECT: " + str(self.state_tracker['SQUAT_COUNT']), 
+                    pos=(int(frame_width*0.75), 30),
+                    text_color=(255, 255, 230),
+                    font_scale=0.7,
+                    text_color_bg=(18, 185, 0)
+                )  
+                
+
+                draw_text(
+                    frame, 
+                    "INCORRECT: " + str(self.state_tracker['IMPROPER_SQUAT']), 
+                    pos=(int(frame_width*0.75), 80),
+                    text_color=(255, 255, 230),
+                    font_scale=0.7,
+                    text_color_bg=(221, 0, 0),
+                    
+                )  
+                
+                
+                draw_text(
+                    frame, 
+                    'CAMERA NOT ALIGNED PROPERLY!!!', 
+                    pos=(30, frame_height-60),
+                    text_color=(255, 255, 230),
+                    font_scale=0.65,
+                    text_color_bg=(255, 153, 0),
+                ) 
+                
+                
+                draw_text(
+                    frame, 
+                    'OFFSET ANGLE: '+str(offset_angle), 
+                    pos=(30, frame_height-30),
+                    text_color=(255, 255, 230),
+                    font_scale=0.65,
+                    text_color_bg=(255, 153, 0),
+                ) 
+
+                # Reset inactive times for side view.
+                self.state_tracker['start_inactive_time'] = time.perf_counter()
+                self.state_tracker['INACTIVE_TIME'] = 0.0
+                self.state_tracker['prev_state'] =  None
+                self.state_tracker['curr_state'] = None
+            
+            # Camera is aligned properly.
+            else:
+
+                self.state_tracker['INACTIVE_TIME_FRONT'] = 0.0
+                self.state_tracker['start_inactive_time_front'] = time.perf_counter()
+
+
+                dist_l_sh_hip = abs(left_foot_coord[1]- left_shldr_coord[1])
+                dist_r_sh_hip = abs(right_foot_coord[1] - right_shldr_coord)[1]
+
+                shldr_coord = None
+                elbow_coord = None
+                wrist_coord = None
+                hip_coord = None
+                knee_coord = None
+                ankle_coord = None
+                foot_coord = None
+
+                if dist_l_sh_hip > dist_r_sh_hip:
+                    shldr_coord = left_shldr_coord
+                    elbow_coord = left_elbow_coord
+                    wrist_coord = left_wrist_coord
+                    hip_coord = left_hip_coord
+                    knee_coord = left_knee_coord
+                    ankle_coord = left_ankle_coord
+                    foot_coord = left_foot_coord
+
+                    multiplier = -1
+                                     
+                
+                else:
+                    shldr_coord = right_shldr_coord
+                    elbow_coord = right_elbow_coord
+                    wrist_coord = right_wrist_coord
+                    hip_coord = right_hip_coord
+                    knee_coord = right_knee_coord
+                    ankle_coord = right_ankle_coord
+                    foot_coord = right_foot_coord
+
+                    multiplier = 1
+                    
+
+                # ------------------- Verical Angle calculation --------------
+                
+                hip_vertical_angle = find_angle(shldr_coord, np.array([hip_coord[0], 0]), hip_coord)
+                cv2.ellipse(frame, hip_coord, (30, 30), 
+                            angle = 0, startAngle = -90, endAngle = -90+multiplier*hip_vertical_angle, 
+                            color = self.COLORS['white'], thickness = 3, lineType = self.linetype)
+
+                cv2.line(frame, (hip_coord[0], hip_coord[1] + 20), (hip_coord[0], hip_coord[1] - 80), self.COLORS['blue'], 4, lineType=self.linetype)
+
+
+
+
+                knee_vertical_angle = find_angle(hip_coord, np.array([knee_coord[0], 0]), knee_coord)
+                cv2.ellipse(frame, knee_coord, (20, 20), 
+                            angle = 0, startAngle = -90, endAngle = -90-multiplier*knee_vertical_angle, 
+                            color = self.COLORS['white'], thickness = 3,  lineType = self.linetype)
+
+                cv2.line(frame, (knee_coord[0], knee_coord[1] + 20), (knee_coord[0], knee_coord[1] - 50), self.COLORS['blue'], 4, lineType=self.linetype)
+
+
+
+                ankle_vertical_angle = find_angle(knee_coord, np.array([ankle_coord[0], 0]), ankle_coord)
+                cv2.ellipse(frame, ankle_coord, (30, 30),
+                            angle = 0, startAngle = -90, endAngle = -90 + multiplier*ankle_vertical_angle,
+                            color = self.COLORS['white'], thickness = 3,  lineType=self.linetype)
+
+                cv2.line(frame, (ankle_coord[0], ankle_coord[1] + 20), (ankle_coord[0], ankle_coord[1] - 50), self.COLORS['blue'], 4, lineType=self.linetype)
+
+                # ------------------------------------------------------------
+        
+                
+                # Join landmarks.
+                cv2.line(frame, shldr_coord, elbow_coord, self.COLORS['light_blue'], 4, lineType=self.linetype)
+                cv2.line(frame, wrist_coord, elbow_coord, self.COLORS['light_blue'], 4, lineType=self.linetype)
+                cv2.line(frame, shldr_coord, hip_coord, self.COLORS['light_blue'], 4, lineType=self.linetype)
+                cv2.line(frame, knee_coord, hip_coord, self.COLORS['light_blue'], 4,  lineType=self.linetype)
+                cv2.line(frame, ankle_coord, knee_coord,self.COLORS['light_blue'], 4,  lineType=self.linetype)
+                cv2.line(frame, ankle_coord, foot_coord, self.COLORS['light_blue'], 4,  lineType=self.linetype)
+                
+                # Plot landmark points
+                cv2.circle(frame, shldr_coord, 7, self.COLORS['yellow'], -1,  lineType=self.linetype)
+                cv2.circle(frame, elbow_coord, 7, self.COLORS['yellow'], -1,  lineType=self.linetype)
+                cv2.circle(frame, wrist_coord, 7, self.COLORS['yellow'], -1,  lineType=self.linetype)
+                cv2.circle(frame, hip_coord, 7, self.COLORS['yellow'], -1,  lineType=self.linetype)
+                cv2.circle(frame, knee_coord, 7, self.COLORS['yellow'], -1,  lineType=self.linetype)
+                cv2.circle(frame, ankle_coord, 7, self.COLORS['yellow'], -1,  lineType=self.linetype)
+                cv2.circle(frame, foot_coord, 7, self.COLORS['yellow'], -1,  lineType=self.linetype)
+
+                
+
+                current_state = self._get_state(int(knee_vertical_angle))
+                self.state_tracker['curr_state'] = current_state
+                self._update_state_sequence(current_state)
+
+
+
+                # -------------------------------------- COMPUTE COUNTERS --------------------------------------
+
+                if current_state == 's1':
+
+                    if len(self.state_tracker['state_seq']) == 3 and not self.state_tracker['INCORRECT_POSTURE']:
+                        self.state_tracker['SQUAT_COUNT']+=1
+                        play_sound = str(self.state_tracker['SQUAT_COUNT'])
+                        
+                    elif 's2' in self.state_tracker['state_seq'] and len(self.state_tracker['state_seq'])==1:
+                        self.state_tracker['IMPROPER_SQUAT']+=1
+                        play_sound = 'incorrect'
+
+                    elif self.state_tracker['INCORRECT_POSTURE']:
+                        self.state_tracker['IMPROPER_SQUAT']+=1
+                        play_sound = 'incorrect'
+                        
+                    
+                    self.state_tracker['state_seq'] = []
+                    self.state_tracker['INCORRECT_POSTURE'] = False
+
+
+                # ----------------------------------------------------------------------------------------------------
+
+
+
+
+                # -------------------------------------- PERFORM FEEDBACK ACTIONS --------------------------------------
+
+                else:
+                    if hip_vertical_angle > self.thresholds['HIP_THRESH'][1]:
+                        self.state_tracker['DISPLAY_TEXT'][0] = True
+                        
+
+                    elif hip_vertical_angle < self.thresholds['HIP_THRESH'][0] and \
+                         self.state_tracker['state_seq'].count('s2')==1:
+                            self.state_tracker['DISPLAY_TEXT'][1] = True
+                        
+                                        
+                    
+                    if self.thresholds['KNEE_THRESH'][0] < knee_vertical_angle < self.thresholds['KNEE_THRESH'][1] and \
+                       self.state_tracker['state_seq'].count('s2')==1:
+                        self.state_tracker['LOWER_HIPS'] = True
+
+
+                    elif knee_vertical_angle > self.thresholds['KNEE_THRESH'][2]:
+                        self.state_tracker['DISPLAY_TEXT'][3] = True
+                        self.state_tracker['INCORRECT_POSTURE'] = True
+
+                    
+                    if (ankle_vertical_angle > self.thresholds['ANKLE_THRESH']):
+                        self.state_tracker['DISPLAY_TEXT'][2] = True
+                        self.state_tracker['INCORRECT_POSTURE'] = True
+
+
+                # ----------------------------------------------------------------------------------------------------
+
+
+                
+                
+                # ----------------------------------- COMPUTE INACTIVITY ---------------------------------------------
+
+                display_inactivity = False
+                
+                if self.state_tracker['curr_state'] == self.state_tracker['prev_state']:
+
+                    end_time = time.perf_counter()
+                    self.state_tracker['INACTIVE_TIME'] += end_time - self.state_tracker['start_inactive_time']
+                    self.state_tracker['start_inactive_time'] = end_time
+
+                    if self.state_tracker['INACTIVE_TIME'] >= self.thresholds['INACTIVE_THRESH']:
+                        self.state_tracker['SQUAT_COUNT'] = 0
+                        self.state_tracker['IMPROPER_SQUAT'] = 0
+                        display_inactivity = True
+
+                
+                else:
+                    
+                    self.state_tracker['start_inactive_time'] = time.perf_counter()
+                    self.state_tracker['INACTIVE_TIME'] = 0.0
+
+                # -------------------------------------------------------------------------------------------------------
+              
+
+
+                hip_text_coord_x = hip_coord[0] + 10
+                knee_text_coord_x = knee_coord[0] + 15
+                ankle_text_coord_x = ankle_coord[0] + 10
+
+                if self.flip_frame:
+                    frame = cv2.flip(frame, 1)
+                    hip_text_coord_x = frame_width - hip_coord[0] + 10
+                    knee_text_coord_x = frame_width - knee_coord[0] + 15
+                    ankle_text_coord_x = frame_width - ankle_coord[0] + 10
+
+                
+                
+                if 's3' in self.state_tracker['state_seq']:
+                    self.state_tracker['LOWER_HIPS'] = False
+
+                self.state_tracker['COUNT_FRAMES'][self.state_tracker['DISPLAY_TEXT']]+=1
+
+                frame = self._show_feedback(frame, self.state_tracker['COUNT_FRAMES'], self.FEEDBACK_ID_MAP, self.state_tracker['LOWER_HIPS'])
+
+
+
+                if display_inactivity:
+                    # cv2.putText(frame, 'Resetting COUNTERS due to inactivity!!!', (10, frame_height - 20), self.font, 0.5, self.COLORS['blue'], 2, lineType=self.linetype)
+                    play_sound = 'reset_counters'
+                    self.state_tracker['start_inactive_time'] = time.perf_counter()
+                    self.state_tracker['INACTIVE_TIME'] = 0.0
+
+                
+                cv2.putText(frame, str(int(hip_vertical_angle)), (hip_text_coord_x, hip_coord[1]), self.font, 0.6, self.COLORS['light_green'], 2, lineType=self.linetype)
+                cv2.putText(frame, str(int(knee_vertical_angle)), (knee_text_coord_x, knee_coord[1]+10), self.font, 0.6, self.COLORS['light_green'], 2, lineType=self.linetype)
+                cv2.putText(frame, str(int(ankle_vertical_angle)), (ankle_text_coord_x, ankle_coord[1]), self.font, 0.6, self.COLORS['light_green'], 2, lineType=self.linetype)
+
+                 
+                draw_text(
+                    frame, 
+                    "CORRECT: " + str(self.state_tracker['SQUAT_COUNT']), 
+                    pos=(int(frame_width*0.75), 30),
+                    text_color=(255, 255, 230),
+                    font_scale=0.7,
+                    text_color_bg=(18, 185, 0)
+                )  
+                
+
+                draw_text(
+                    frame, 
+                    "INCORRECT: " + str(self.state_tracker['IMPROPER_SQUAT']), 
+                    pos=(int(frame_width*0.75), 80),
+                    text_color=(255, 255, 230),
+                    font_scale=0.7,
+                    text_color_bg=(221, 0, 0),
+                    
+                )  
+                
+                
+                self.state_tracker['DISPLAY_TEXT'][self.state_tracker['COUNT_FRAMES'] > self.thresholds['CNT_FRAME_THRESH']] = False
+                self.state_tracker['COUNT_FRAMES'][self.state_tracker['COUNT_FRAMES'] > self.thresholds['CNT_FRAME_THRESH']] = 0    
+                self.state_tracker['prev_state'] = current_state
+                                  
+
+       
+        
+        else:
+
+            if self.flip_frame:
+                frame = cv2.flip(frame, 1)
+
+            end_time = time.perf_counter()
+            self.state_tracker['INACTIVE_TIME'] += end_time - self.state_tracker['start_inactive_time']
+
+            display_inactivity = False
+
+            if self.state_tracker['INACTIVE_TIME'] >= self.thresholds['INACTIVE_THRESH']:
+                self.state_tracker['SQUAT_COUNT'] = 0
+                self.state_tracker['IMPROPER_SQUAT'] = 0
+                # cv2.putText(frame, 'Resetting SQUAT_COUNT due to inactivity!!!', (10, frame_height - 25), self.font, 0.7, self.COLORS['blue'], 2)
+                display_inactivity = True
+
+            self.state_tracker['start_inactive_time'] = end_time
+
+            draw_text(
+                    frame, 
+                    "CORRECT: " + str(self.state_tracker['SQUAT_COUNT']), 
+                    pos=(int(frame_width*0.75), 30),
+                    text_color=(255, 255, 230),
+                    font_scale=0.7,
+                    text_color_bg=(18, 185, 0)
+                )  
+                
+
+            draw_text(
+                    frame, 
+                    "INCORRECT: " + str(self.state_tracker['IMPROPER_SQUAT']), 
+                    pos=(int(frame_width*0.75), 80),
+                    text_color=(255, 255, 230),
+                    font_scale=0.7,
+                    text_color_bg=(221, 0, 0),
+                    
+                )  
+
+            if display_inactivity:
+                play_sound = 'reset_counters'
+                self.state_tracker['start_inactive_time'] = time.perf_counter()
+                self.state_tracker['INACTIVE_TIME'] = 0.0
+            
+            
+            # Reset all other state variables
+            
+            self.state_tracker['prev_state'] =  None
+            self.state_tracker['curr_state'] = None
+            self.state_tracker['INACTIVE_TIME_FRONT'] = 0.0
+            self.state_tracker['INCORRECT_POSTURE'] = False
+            self.state_tracker['DISPLAY_TEXT'] = np.full((5,), False)
+            self.state_tracker['COUNT_FRAMES'] = np.zeros((5,), dtype=np.int64)
+            self.state_tracker['start_inactive_time_front'] = time.perf_counter()
+            
+            
+            
+        return frame, play_sound
+
+                    

requirements.txt

@@ -0,0 +1,5 @@
+numpy
+opencv-python-headless
+mediapipe
+altair<5
+streamlit_webrtc

thresholds.py

@@ -0,0 +1,55 @@
+
+
+# Get thresholds for beginner mode
+def get_thresholds_beginner():
+
+    _ANGLE_HIP_KNEE_VERT = {
+                            'NORMAL' : (0,  30),
+                            'TRANS'  : (35, 65),
+                            'PASS'   : (70, 95)
+                           }    
+
+        
+    thresholds = {
+                    'HIP_KNEE_VERT': _ANGLE_HIP_KNEE_VERT,
+
+                    'HIP_THRESH'   : [10, 60],
+                    'ANKLE_THRESH' : 45,
+                    'KNEE_THRESH'  : [50, 70, 95],
+
+                    'OFFSET_THRESH'    : 50.0,
+                    'INACTIVE_THRESH'  : 15.0,
+
+                    'CNT_FRAME_THRESH' : 50
+                            
+                }
+
+    return thresholds
+
+
+
+# Get thresholds for beginner mode
+def get_thresholds_pro():
+
+    _ANGLE_HIP_KNEE_VERT = {
+                            'NORMAL' : (0,  30),
+                            'TRANS'  : (35, 65),
+                            'PASS'   : (80, 95)
+                           }    
+
+        
+    thresholds = {
+                    'HIP_KNEE_VERT': _ANGLE_HIP_KNEE_VERT,
+
+                    'HIP_THRESH'   : [15, 50],
+                    'ANKLE_THRESH' : 30,
+                    'KNEE_THRESH'  : [50, 80, 95],
+
+                    'OFFSET_THRESH'    : 50.0,
+                    'INACTIVE_THRESH'  : 15.0,
+
+                    'CNT_FRAME_THRESH' : 50
+                            
+                 }
+                 
+    return thresholds

utils.py

@@ -0,0 +1,168 @@
+import cv2
+import mediapipe as mp
+import numpy as np
+
+correct = cv2.imread('right.png')
+correct = cv2.cvtColor(correct, cv2.COLOR_BGR2RGB)
+incorrect = cv2.imread('wrong.png')
+incorrect = cv2.cvtColor(incorrect, cv2.COLOR_BGR2RGB)
+
+def draw_rounded_rect(img, rect_start, rect_end, corner_width, box_color):
+
+    x1, y1 = rect_start
+    x2, y2 = rect_end
+    w = corner_width
+
+    # draw filled rectangles
+    cv2.rectangle(img, (x1 + w, y1), (x2 - w, y1 + w), box_color, -1)
+    cv2.rectangle(img, (x1 + w, y2 - w), (x2 - w, y2), box_color, -1)
+    cv2.rectangle(img, (x1, y1 + w), (x1 + w, y2 - w), box_color, -1)
+    cv2.rectangle(img, (x2 - w, y1 + w), (x2, y2 - w), box_color, -1)
+    cv2.rectangle(img, (x1 + w, y1 + w), (x2 - w, y2 - w), box_color, -1)
+
+
+    # draw filled ellipses
+    cv2.ellipse(img, (x1 + w, y1 + w), (w, w),
+                angle = 0, startAngle = -90, endAngle = -180, color = box_color, thickness = -1)
+
+    cv2.ellipse(img, (x2 - w, y1 + w), (w, w),
+                angle = 0, startAngle = 0, endAngle = -90, color = box_color, thickness = -1)
+
+    cv2.ellipse(img, (x1 + w, y2 - w), (w, w),
+                angle = 0, startAngle = 90, endAngle = 180, color = box_color, thickness = -1)
+
+    cv2.ellipse(img, (x2 - w, y2 - w), (w, w),
+                angle = 0, startAngle = 0, endAngle = 90, color = box_color, thickness = -1)
+
+    return img
+
+
+
+
+def draw_dotted_line(frame, lm_coord, start, end, line_color):
+    pix_step = 0
+
+    for i in range(start, end+1, 8):
+        cv2.circle(frame, (lm_coord[0], i+pix_step), 2, line_color, -1, lineType=cv2.LINE_AA)
+
+    return frame
+
+def draw_text(
+    img,
+    msg,
+    width = 7,
+    font=cv2.FONT_HERSHEY_SIMPLEX,
+    pos=(0, 0),
+    font_scale=1,
+    font_thickness=2,
+    text_color=(0, 255, 0),
+    text_color_bg=(0, 0, 0),
+    box_offset=(20, 10),
+    overlay_image = False,
+    overlay_type = None
+):
+
+    offset = box_offset
+    x, y = pos
+    text_size, _ = cv2.getTextSize(msg, font, font_scale, font_thickness)
+    text_w, text_h = text_size
+
+    rec_start = tuple(p - o for p, o in zip(pos, offset))
+    rec_end = tuple(m + n - o for m, n, o in zip((x + text_w, y + text_h), offset, (25, 0)))
+
+    resize_height = 0
+
+    if overlay_image:
+        resize_height = rec_end[1] - rec_start[1]
+        # print("Height: ", resize_height)
+        # print("Width: ", rec_end[0] - rec_start[0])
+        img = draw_rounded_rect(img, rec_start, (rec_end[0]+resize_height, rec_end[1]), width, text_color_bg)
+        if overlay_type == "correct":
+            overlay_res = cv2.resize(correct, (resize_height, resize_height), interpolation = cv2.INTER_AREA)		
+        elif overlay_type == "incorrect":
+            overlay_res = cv2.resize(incorrect, (resize_height, resize_height), interpolation = cv2.INTER_AREA)
+
+        img[rec_start[1]:rec_start[1]+resize_height, rec_start[0]+width:rec_start[0]+width+resize_height] = overlay_res
+
+    else:
+        img = draw_rounded_rect(img, rec_start, rec_end, width, text_color_bg)
+
+
+    cv2.putText(
+        img,
+        msg,
+        (int(rec_start[0]+resize_height + 8), int(y + text_h + font_scale - 1)), 
+        font,
+        font_scale,
+        text_color,
+        font_thickness,
+        cv2.LINE_AA,
+    )
+
+    
+    
+    return text_size
+
+
+
+def find_angle(p1, p2, ref_pt = np.array([0,0])):
+    p1_ref = p1 - ref_pt
+    p2_ref = p2 - ref_pt
+
+    cos_theta = (np.dot(p1_ref,p2_ref)) / (1.0 * np.linalg.norm(p1_ref) * np.linalg.norm(p2_ref))
+    theta = np.arccos(np.clip(cos_theta, -1.0, 1.0))
+            
+    degree = int(180 / np.pi) * theta
+
+    return int(degree)
+
+
+
+
+
+def get_landmark_array(pose_landmark, key, frame_width, frame_height):
+
+    denorm_x = int(pose_landmark[key].x * frame_width)
+    denorm_y = int(pose_landmark[key].y * frame_height)
+
+    return np.array([denorm_x, denorm_y])
+
+
+
+
+def get_landmark_features(kp_results, dict_features, feature, frame_width, frame_height):
+
+    if feature == 'nose':
+        return get_landmark_array(kp_results, dict_features[feature], frame_width, frame_height)
+
+    elif feature == 'left' or 'right':
+        shldr_coord = get_landmark_array(kp_results, dict_features[feature]['shoulder'], frame_width, frame_height)
+        elbow_coord   = get_landmark_array(kp_results, dict_features[feature]['elbow'], frame_width, frame_height)
+        wrist_coord   = get_landmark_array(kp_results, dict_features[feature]['wrist'], frame_width, frame_height)
+        hip_coord   = get_landmark_array(kp_results, dict_features[feature]['hip'], frame_width, frame_height)
+        knee_coord   = get_landmark_array(kp_results, dict_features[feature]['knee'], frame_width, frame_height)
+        ankle_coord   = get_landmark_array(kp_results, dict_features[feature]['ankle'], frame_width, frame_height)
+        foot_coord   = get_landmark_array(kp_results, dict_features[feature]['foot'], frame_width, frame_height)
+
+        return shldr_coord, elbow_coord, wrist_coord, hip_coord, knee_coord, ankle_coord, foot_coord
+    
+    else:
+       raise ValueError("feature needs to be either 'nose', 'left' or 'right")
+
+
+def get_mediapipe_pose(
+                        static_image_mode = False, 
+                        model_complexity = 1,
+                        smooth_landmarks = True,
+                        min_detection_confidence = 0.5,
+                        min_tracking_confidence = 0.5
+
+                      ):
+    pose = mp.solutions.pose.Pose(
+                                    static_image_mode = static_image_mode,
+                                    model_complexity = model_complexity,
+                                    smooth_landmarks = smooth_landmarks,
+                                    min_detection_confidence = min_detection_confidence,
+                                    min_tracking_confidence = min_tracking_confidence
+                                 )
+    return pose