Spaces:
Build error
Build error
Download app2.py from ehsanhon/AI-PT-pose-comparison: direct link, hf CLI and curl.
- Browser
- Download file 15.1 kB
-
https://huggingface.co/spaces/ehsanhon/AI-PT-pose-comparison/resolve/main/app2.py
- Command line
-
hf download hf://spaces/ehsanhon/AI-PT-pose-comparison/app2.py
-
curl -L -o app2.py https://huggingface.co/spaces/ehsanhon/AI-PT-pose-comparison/resolve/main/app2.py
15.1 kB
| from fastapi import FastAPI, Request,UploadFile, File | |
| from fastapi.responses import HTMLResponse, JSONResponse | |
| from fastapi.staticfiles import StaticFiles | |
| from fastapi.templating import Jinja2Templates | |
| # | |
| import os | |
| import json | |
| # | |
| import mediapipe as mp | |
| import cv2 | |
| import numpy as np | |
| import math | |
| # | |
| import base64 | |
| ########################### === Setup server === ########################### | |
| app = FastAPI() | |
| app.mount("/img", StaticFiles(directory="img"), name="img") | |
| app.mount("/static", StaticFiles(directory="static"), name="static") | |
| templates = Jinja2Templates(directory="templates") | |
| ################angle detection and pose detection################## | |
| ref_1_angle = None | |
| ref_2_angle = None | |
| ##################### | |
| def calculate_angle(point1, point2, point3): | |
| x1, y1 = point1 | |
| x2, y2 = point2 | |
| x3, y3 = point3 | |
| # Calculate vectors | |
| vector1 = (x1 - x2, y1 - y2) | |
| vector2 = (x3 - x2, y3 - y2) | |
| # Calculate dot product | |
| dot_product = vector1[0] * vector2[0] + vector1[1] * vector2[1] | |
| # Calculate magnitudes (lengths) of the vectors | |
| magnitude1 = math.sqrt(vector1[0]**2 + vector1[1]**2) | |
| magnitude2 = math.sqrt(vector2[0]**2 + vector2[1]**2) | |
| # Calculate cosine of the angle | |
| if magnitude1 == 0 or magnitude2 == 0: | |
| return 0.0 # Handle cases where points are the same | |
| cos_theta = dot_product / (magnitude1 * magnitude2) | |
| # Ensure cos_theta is within the valid range [-1, 1] due to potential floating-point errors | |
| cos_theta = max(-1.0, min(1.0, cos_theta)) | |
| # Calculate the angle in radians and convert to degrees | |
| angle_radians = math.acos(cos_theta) | |
| angle_degrees = math.degrees(angle_radians) | |
| angle_degrees = angle_degrees-angle_degrees%1 | |
| return angle_degrees | |
| # Function to extract the coordinates of a landmark | |
| def get_landmark_coordinates(landmarks, landmark_id): | |
| try: | |
| x = landmarks.landmark[landmark_id].x | |
| y = landmarks.landmark[landmark_id].y | |
| x=x/1 | |
| y=y/1 | |
| return np.array([x, y]) | |
| except: | |
| return np.array([0, 0]) # Return [0, 0] if landmark is not detected | |
| def calculate_angles_landmarks(landmarks, mp_pose): | |
| # Left side angles | |
| left_shoulder = get_landmark_coordinates(landmarks, mp_pose.PoseLandmark.LEFT_SHOULDER) | |
| left_elbow = get_landmark_coordinates(landmarks, mp_pose.PoseLandmark.LEFT_ELBOW) | |
| left_wrist = get_landmark_coordinates(landmarks, mp_pose.PoseLandmark.LEFT_WRIST) | |
| # | |
| right_shoulder = get_landmark_coordinates(landmarks, mp_pose.PoseLandmark.RIGHT_SHOULDER) | |
| right_elbow = get_landmark_coordinates(landmarks, mp_pose.PoseLandmark.RIGHT_ELBOW) | |
| right_wrist = get_landmark_coordinates(landmarks, mp_pose.PoseLandmark.RIGHT_WRIST) | |
| # | |
| left_hip = get_landmark_coordinates(landmarks, mp_pose.PoseLandmark.LEFT_HIP) | |
| left_knee = get_landmark_coordinates(landmarks, mp_pose.PoseLandmark.LEFT_KNEE) | |
| # | |
| right_hip = get_landmark_coordinates(landmarks, mp_pose.PoseLandmark.RIGHT_HIP) | |
| right_knee = get_landmark_coordinates(landmarks, mp_pose.PoseLandmark.RIGHT_KNEE) | |
| # | |
| left_ankle = get_landmark_coordinates(landmarks,mp_pose.PoseLandmark.LEFT_ANKLE) | |
| right_ankle = get_landmark_coordinates(landmarks,mp_pose.PoseLandmark.RIGHT_ANKLE) | |
| # | |
| if np.any(left_shoulder) and np.any(left_elbow) and np.any(left_wrist): | |
| left_elbow_angle = calculate_angle(left_shoulder, left_elbow, left_wrist) | |
| else: left_elbow_angle = 0 | |
| if np.any(left_shoulder) and np.any(left_hip) and np.any(left_knee): | |
| left_hip_angle = calculate_angle(left_shoulder, left_hip, left_knee) | |
| else: left_hip_angle = 0 | |
| if np.any(right_shoulder) and np.any(right_elbow) and np.any(right_wrist): | |
| right_elbow_angle = calculate_angle(right_shoulder, right_elbow, right_wrist) | |
| else: right_elbow_angle = 0 | |
| if np.any(right_shoulder) and np.any(right_hip) and np.any(right_knee): | |
| right_hip_angle = calculate_angle(right_shoulder, right_hip, right_knee) | |
| else: right_hip_angle = 0 | |
| if np.any(right_knee) and np.any(right_ankle) and np.any(right_hip): | |
| right_knee_angle = calculate_angle(right_knee, right_ankle, right_hip) | |
| else: right_knee_angle = 0 | |
| if np.any(left_knee) and np.any(left_ankle) and np.any(left_hip): | |
| left_knee_angle = calculate_angle(left_knee, left_ankle, left_hip) | |
| else: left_knee_angle = 0 | |
| # Additional angles (e.g., shoulders, knees, etc.) | |
| head0 = 0 | |
| num = 0 | |
| head = get_landmark_coordinates(landmarks, mp_pose.PoseLandmark.NOSE) | |
| if not np.array_equal(head, head0): num += 1 | |
| head0 = head | |
| head += get_landmark_coordinates(landmarks, mp_pose.PoseLandmark.RIGHT_EYE) | |
| if (head[0]==head0[0]) & (head[1]==head0[1]): num += 1 | |
| head0 = head | |
| head += get_landmark_coordinates(landmarks, mp_pose.PoseLandmark.LEFT_EYE) | |
| if (head[0]==head0[0]) & (head[1]==head0[1]): num += 1 | |
| head0 = head | |
| head += get_landmark_coordinates(landmarks, mp_pose.PoseLandmark.RIGHT_EAR) | |
| if (head[0]==head0[0]) & (head[1]==head0[1]): num += 1 | |
| head0 = head | |
| head += get_landmark_coordinates(landmarks, mp_pose.PoseLandmark.LEFT_EAR) | |
| if (head[0]==head0[0]) & (head[1]==head0[1]): num += 1 | |
| head0 = head | |
| head /= num | |
| if np.any(head) and np.any(left_shoulder) and np.any(left_elbow): | |
| left_arm_angle = calculate_angle(head, left_shoulder, left_elbow) | |
| else: | |
| left_arm_angle = 0 | |
| if np.any(head) and np.any(right_shoulder) and np.any(right_elbow): | |
| right_arm_angle = calculate_angle(head, right_shoulder, right_elbow) | |
| else: | |
| right_arm_angle = 0 | |
| if np.any(head) and np.any(left_shoulder) and np.any(left_hip): | |
| left_back_angle = calculate_angle(head, left_shoulder, left_hip) | |
| else: | |
| left_back_angle = 0 | |
| if np.any(head) and np.any(right_shoulder) and np.any(right_hip): | |
| right_back_angle = calculate_angle(head, right_shoulder, right_hip) | |
| else: | |
| right_back_angle = 0 | |
| ############### | |
| angles = { | |
| "L_Elbow": left_elbow_angle, | |
| "L_Hip": left_hip_angle, | |
| "R_Elbow": right_elbow_angle, | |
| "R_Hip": right_hip_angle, | |
| "L_Arm": left_arm_angle, | |
| "R_Arm": right_arm_angle, | |
| "L_Back": left_back_angle, | |
| "R_Back": right_back_angle, | |
| "L_Knee": left_knee_angle, | |
| "R_Knee": right_knee_angle | |
| } | |
| locations={ | |
| "left_shoulder":left_shoulder, | |
| "left_elbow":left_elbow, | |
| "left_wrist":left_wrist, | |
| "right_shoulder":right_shoulder, | |
| "right_elbow":right_elbow, | |
| "right_wrist":right_wrist, | |
| "head":head, | |
| "left_hip":left_hip, | |
| "left_knee":left_knee, | |
| "left_ankle":left_ankle, | |
| "right_hip":right_hip, | |
| "right_knee":right_knee, | |
| "right_ankle":right_ankle | |
| } | |
| return angles,locations | |
| def putItems_on_image(image1,angs,locs,selected_angles,mp_pose,results): | |
| image = image1 | |
| decoded_angles = decode_selected_angles(selected_angles) | |
| # locations = get_locs_selected_angles(decoded_angles, mp_pose) | |
| ang = angs.copy() | |
| for key in angs.keys(): | |
| ang[key] = angs[key] if key in decoded_angles else 0 | |
| ########### | |
| angle_to_points = { | |
| "L_Elbow": [mp_pose.PoseLandmark.LEFT_SHOULDER, mp_pose.PoseLandmark.LEFT_ELBOW, mp_pose.PoseLandmark.LEFT_WRIST], | |
| "L_Hip": [mp_pose.PoseLandmark.LEFT_SHOULDER, mp_pose.PoseLandmark.LEFT_HIP, mp_pose.PoseLandmark.LEFT_KNEE], | |
| "R_Elbow": [mp_pose.PoseLandmark.RIGHT_SHOULDER, mp_pose.PoseLandmark.RIGHT_ELBOW, mp_pose.PoseLandmark.RIGHT_WRIST], | |
| "R_Hip": [mp_pose.PoseLandmark.RIGHT_SHOULDER, mp_pose.PoseLandmark.RIGHT_HIP, mp_pose.PoseLandmark.RIGHT_KNEE], | |
| "L_Knee": [mp_pose.PoseLandmark.LEFT_ANKLE, mp_pose.PoseLandmark.LEFT_KNEE, mp_pose.PoseLandmark.LEFT_HIP], | |
| "R_Knee": [mp_pose.PoseLandmark.RIGHT_ANKLE, mp_pose.PoseLandmark.RIGHT_KNEE, mp_pose.PoseLandmark.RIGHT_HIP], | |
| "L_Arm": [mp_pose.PoseLandmark.LEFT_ELBOW, mp_pose.PoseLandmark.LEFT_SHOULDER, mp_pose.PoseLandmark.NOSE], | |
| "R_Arm": [mp_pose.PoseLandmark.RIGHT_ELBOW, mp_pose.PoseLandmark.RIGHT_SHOULDER, mp_pose.PoseLandmark.NOSE], | |
| "L_Back": [mp_pose.PoseLandmark.LEFT_HIP, mp_pose.PoseLandmark.LEFT_SHOULDER, mp_pose.PoseLandmark.NOSE], | |
| "R_Back": [mp_pose.PoseLandmark.RIGHT_HIP, mp_pose.PoseLandmark.RIGHT_SHOULDER, mp_pose.PoseLandmark.NOSE] | |
| } | |
| for angle_name, value in ang.items(): | |
| if value != 0: | |
| if angle_name in angle_to_points: | |
| points = angle_to_points[angle_name] | |
| outer1 = points[0] | |
| middle = points[1] | |
| outer2 = points[2] | |
| # Get pixel locations | |
| h, w, _ = image.shape | |
| landmark_outer1 = results.pose_landmarks.landmark[outer1] | |
| landmark_middle = results.pose_landmarks.landmark[middle] | |
| landmark_outer2 = results.pose_landmarks.landmark[outer2] | |
| cx1, cy1 = int(landmark_outer1.x * w), int(landmark_outer1.y * h) | |
| cxm, cym = int(landmark_middle.x * w), int(landmark_middle.y * h) | |
| cx2, cy2 = int(landmark_outer2.x * w), int(landmark_outer2.y * h) | |
| # Draw circles | |
| cv2.circle(image, (cx1, cy1), 3, (0, 0, 255), cv2.FILLED) # outer1 | |
| cv2.circle(image, (cxm, cym), 3, (255, 0, 0), cv2.FILLED) # middle | |
| cv2.circle(image, (cx2, cy2), 3, (0, 0, 255), cv2.FILLED) # outer2 | |
| # Draw lines | |
| cv2.line(image, (cx1, cy1), (cxm, cym), (0, 255, 0), thickness=1) | |
| cv2.line(image, (cx2, cy2), (cxm, cym), (0, 255, 0), thickness=1) | |
| return image | |
| # Function to calculate the angles for both left and right sides and overlay on image | |
| def calculate_and_display_angles(image1,ang_select, return_angles=False): | |
| # pose = mp_pose.Pose( | |
| # min_detection_confidence=0.5, min_tracking_confidence=0.5, | |
| # static_image_mode=False, model_complexity=0, | |
| # enable_segmentation=False) | |
| # if return_angles == False: | |
| mp_pose = mp.solutions.pose | |
| pose = mp_pose.Pose( | |
| min_detection_confidence=0.5, | |
| min_tracking_confidence=0.5) | |
| image = image1#.copy() | |
| image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) | |
| # Get pose landmarks | |
| results = pose.process(image_rgb) | |
| if results.pose_landmarks: | |
| ang , locs = calculate_angles_landmarks(results.pose_landmarks , mp_pose) | |
| if return_angles: | |
| return ang | |
| image = putItems_on_image(image , ang , locs , ang_select , mp_pose , results) | |
| return image ,ang | |
| else: | |
| return image , None | |
| ##################pose chek | |
| def decode_selected_angles(binary_value): | |
| angle_mapping = { | |
| "L_Elbow": 1, # 2^0 | |
| "L_Hip": 2, # 2^1 | |
| "R_Elbow": 4, # 2^2 | |
| "R_Hip": 8, # 2^3 | |
| "L_Arm": 16, # 2^4 | |
| "R_Arm": 32, # 2^5 | |
| "L_Back": 64, # 2^6 | |
| "R_Back": 128, # 2^7 | |
| "L_Knee": 256, # 2^8 | |
| "R_Knee": 512 # 2^9 | |
| } | |
| selected_angles = [] | |
| for angle, value in angle_mapping.items(): | |
| if binary_value & value: # Bitwise AND: checks if this bit is on | |
| selected_angles.append(angle) | |
| return selected_angles | |
| curent_angle = None | |
| def compare_angles(angles3, angles_s): | |
| global ref_1_angle, ref_2_angle, curent_angle | |
| new_key = "Compared to" | |
| new_value = "ref image 1" | |
| if curent_angle is None or curent_angle == ref_1_angle: | |
| curent_angle = ref_1_angle | |
| if curent_angle is None or curent_angle == ref_2_angle: | |
| new_value = "ref image 2" | |
| curent_angle = ref_2_angle | |
| if curent_angle is None: | |
| new_value = "None" | |
| angles2 = curent_angle.copy() | |
| angles1 = angles3.copy() | |
| selected_angles = decode_selected_angles(angles_s) | |
| if angles1 is None or angles2 is None: | |
| return angles1[selected_angles] | |
| angle_diff = {} | |
| b= 0 | |
| for key in selected_angles: | |
| if key in angles1 and key in angles2: | |
| b+=1 | |
| angle_diff[key] = abs(angles1[key] - angles2[key]) | |
| else: | |
| angle_diff[key] = None # Missing in one of the sets | |
| a = sum(angle_diff.values()) | |
| if a< 10*b: | |
| if curent_angle == ref_1_angle: | |
| new_value = "Changed" | |
| curent_angle = ref_2_angle | |
| else: | |
| new_value = "Changed" | |
| curent_angle = ref_1_angle | |
| items = list(angle_diff.items()) | |
| items.insert(0, (new_key, new_value)) | |
| angles = dict(items) | |
| return angles | |
| async def Pose_detector(request: Request): | |
| data = await request.json() | |
| image_base64 = data["image"].split(",")[1] # strip the header | |
| ref_name = data["name"] | |
| ang_select = data["angle"] | |
| # Decode base64 to image bytes | |
| img_bytes = base64.b64decode(image_base64) | |
| np_arr = np.frombuffer(img_bytes, np.uint8) | |
| image = cv2.imdecode(np_arr, cv2.IMREAD_COLOR) | |
| # return JSONResponse(content={"processed_image": None , "angles": {'sda':ang_select}}) | |
| image2, ang = None , None#calculate_and_display_angles(image, return_angles=False) | |
| #caculate and copmare angles | |
| if ref_name == "1" or ref_name == "2": | |
| image2, ang = calculate_and_display_angles(image,ang_select, return_angles=False) | |
| global ref_1_angle, ref_2_angle,curent_angle | |
| if ref_name == "1": | |
| ref_1_angle = ang | |
| elif ref_name == "2": | |
| ref_2_angle = ang | |
| elif ref_name == "3": | |
| ang = calculate_and_display_angles(image,ang_select , return_angles=True) | |
| ang = compare_angles(ang , ang_select) | |
| return JSONResponse(content={"processed_image": None , "angles": ang}) | |
| else: | |
| image2, ang = calculate_and_display_angles(image,ang_select, return_angles=False) | |
| ang = compare_angles(ang , ang_select) | |
| _, buffer = cv2.imencode(".png", image2) | |
| processed_base64 = base64.b64encode(buffer).decode("utf-8") | |
| data_url = f"data:image/png;base64,{processed_base64}" | |
| return JSONResponse(content={"processed_image": data_url, "angles": ang}) | |
| ###########basic API for testing ###########` | |
| # ` | |
| async def index(request: Request): | |
| return templates.TemplateResponse("index.html", {"request": request}) | |