PoseCorrection/backend/analyse_by_npy.py

import math
import sys

import numpy as np

from demo_func import run_openpose_for_image_front, run_openpose_for_image_side

sys.path.append('../')

index = sys.argv[1]
height = sys.argv[2]

print(height)

level_0 = 2
level_1 = 10
level_2 = 20

O_ARGUMENT_1 = 0.2
X_ARGUMENT_1 = 1.1

HEAD_FORWARD_ARGUMENT_0 = 2
HEAD_FORWARD_ARGUMENT_1 = 8
HEAD_FORWARD_ARGUMENT_2 = 15

HEAD_STRESS_ARGUMENT_0 = 11
HEAD_STRESS_ARGUMENT_1 = 1.02777777777769
HEAD_STRESS_ARGUMENT_2 = 0.00981481481482367
HEAD_STRESS_ARGUMENT_3 = -0.000567901234568158
HEAD_STRESS_ARGUMENT_4 = 0.00000576131687243021

SHOULDER_OFFSET_ARGUMENT_0 = 0.5
SHOULDER_OFFSET_ARGUMENT_1 = 1
SHOULDER_OFFSET_ARGUMENT_2 = 3

HIP_OFFSET_ARGUMENT_0 = 0.5
HIP_OFFSET_ARGUMENT_1 = 1
HIP_OFFSET_ARGUMENT_2 = 3

HIP_OFFSET_ARGUMENT_0 = 0.5
HIP_OFFSET_ARGUMENT_1 = 1
HIP_OFFSET_ARGUMENT_2 = 3

UP_FORWARD_ARGUMENT_0 = 2
UP_FORWARD_ARGUMENT_1 = 10
UP_FORWARD_ARGUMENT_2 = 20

HIP_FORWARD_ARGUMENT_0 = 2
HIP_FORWARD_ARGUMENT_1 = 5
HIP_FORWARD_ARGUMENT_2 = 10

KNEE_FORWARD_ARGUMENT_0 = 1
KNEE_FORWARD_ARGUMENT_1 = 5
KNEE_FORWARD_ARGUMENT_2 = 10

source_npy_front = "pose_temp_data/{}-0.npy".format(index)
source_npy_side = "pose_temp_data/{}-1.npy".format(index)
save_path = "pose_processed_txt/{}.txt".format(index)


def text_save(filename, data):  # filename为写入CSV文件的路径，data为要写入数据列表.
    file = open(filename, 'w', encoding='utf-8')
    for i in range(len(data)):
        s = str(data[i]).replace('[', '').replace(']', '')
        s = s.replace("'", '').replace(',', '') + '\n'
        file.write(s)
    file.close()
    print("保存成功")


def angle(v1, v2):
    dx1 = v1[2] - v1[0]
    dy1 = v1[3] - v1[1]
    dx2 = v2[2] - v2[0]
    dy2 = v2[3] - v2[1]
    angle1 = math.atan2(dy1, dx1)
    angle1 = round(angle1 * 180.0 / math.pi, 2)
    # print(angle1)
    angle2 = math.atan2(dy2, dx2)
    angle2 = round(angle2 * 180.0 / math.pi, 2)
    # print(angle2)
    if angle1 * angle2 >= 0:
        included_angle = abs(angle1 - angle2)
    else:
        included_angle = abs(angle1) + abs(angle2)
        if included_angle > 180:
            included_angle = 360 - included_angle
    return included_angle


def cal_head_extra_stress(angle):
    return (HEAD_STRESS_ARGUMENT_1 * angle + HEAD_STRESS_ARGUMENT_2 * pow(angle, 2) \
            + HEAD_STRESS_ARGUMENT_3 * pow(angle, 3) + HEAD_STRESS_ARGUMENT_4 * pow(angle, 4)) / HEAD_STRESS_ARGUMENT_0


def analyse_npy_front(npy_front):
    result = []
    data = np.load(npy_front)

    print("------------------")
    result.append("------------------")

    print("正面分析内容如下：")
    result.append("正面分析内容如下：")

    # h-eye - h-elbow
    h_pixel_eye2elbow = abs(data[14][1] - data[3][1])
    # print("h_pixel{}".format(h_pixel_eye2elbow))

    h_real_eye2elbow = float(height) * 0.333
    # print("h_real{}".format(h_real_eye2elbow))

    # body mid x
    ankle_mid_x = (data[13][0] + data[10][0]) / 2

    # for head
    ear_r_x = data[16][0]
    ear_r_y = data[16][1]
    ear_l_x = data[17][0]
    ear_l_y = data[17][1]

    head_angle = angle([ear_r_x, ear_r_y, ear_l_x, ear_l_y], [0, 0, 1, 0])
    ear_level = ""
    if head_angle <= level_0:
        ear_level = ""
    elif head_angle <= level_1 and head_angle > level_0:
        ear_level = "轻微"
    elif head_angle > level_1 and head_angle <= level_2:
        ear_level = "中等"
    else:
        ear_level = "严重"

    if ear_l_y < ear_r_y and ear_level != "":
        print("头部分析：头部左部高，向右倾斜，角度为{}度，程度{}".format(head_angle, ear_level))
        result.append("头部分析：头部左部高，向右倾斜，角度为{}度，程度{}".format(head_angle, ear_level))
    elif ear_l_y > ear_r_y and ear_level != "":
        print("头部分析：头部右部高，向左倾斜，角度为{}度，程度{}".format(head_angle, ear_level))
        result.append("头部分析：头部右部高，向左倾斜，角度为{}度，程度{}".format(head_angle, ear_level))
    else:
        print("头部分析：头部保持完美平衡")
        result.append("头部分析：头部保持完美平衡")

    # for shoulder
    shoulder_r_x = data[2][0]
    shoulder_r_y = data[2][1]
    shoulder_l_x = data[5][0]
    shoulder_l_y = data[5][1]
    shoulder_mid_x = (shoulder_l_x + shoulder_r_x) / 2
    offset_x_shoulder = (shoulder_mid_x - ankle_mid_x) * h_real_eye2elbow / h_pixel_eye2elbow
    d_shoulder = abs(data[5][1] - data[2][1])
    l_shoulder = math.sqrt((shoulder_l_x - shoulder_r_x) ** 2 + (shoulder_l_y - shoulder_r_y) ** 2)
    rate_shoulder = d_shoulder / l_shoulder
    shoulder_angle = angle([shoulder_r_x, shoulder_r_y, shoulder_l_x, shoulder_l_y], [0, 0, 1, 0])
    shoulder_level = ""
    shoulder_offset_level = ""
    if shoulder_angle <= level_0:
        shoulder_level = ""
    elif shoulder_angle <= level_1 and shoulder_angle > level_0:
        shoulder_level = "轻微"
    elif shoulder_angle > level_1 and shoulder_angle <= level_2:
        shoulder_level = "中等"
    else:
        shoulder_level = "严重"

    if offset_x_shoulder <= SHOULDER_OFFSET_ARGUMENT_0:
        shoulder_offset_level = ""
    elif offset_x_shoulder <= SHOULDER_OFFSET_ARGUMENT_1 and offset_x_shoulder > SHOULDER_OFFSET_ARGUMENT_0:
        shoulder_offset_level = "轻微"
    elif offset_x_shoulder > SHOULDER_OFFSET_ARGUMENT_1 and offset_x_shoulder <= SHOULDER_OFFSET_ARGUMENT_2:
        shoulder_offset_level = "中等"
    else:
        shoulder_offset_level = "严重"

    print("肩部分析：")
    result.append("肩部分析：")
    if offset_x_shoulder > 0 and shoulder_offset_level != "":
        print("肩部向左横移，距离为{}cm，程度{}".format(round(abs(offset_x_shoulder), 3), shoulder_offset_level))
        result.append("肩部向左横移，距离为{}cm，程度{}".format(round(abs(offset_x_shoulder), 3), shoulder_offset_level))
    elif offset_x_shoulder < 0 and shoulder_offset_level != "":
        print("肩部向右横移，距离为{}cm，程度{}".format(round(abs(offset_x_shoulder), 3), shoulder_offset_level))
        result.append("肩部向右横移，距离为{}cm，程度{}".format(round(abs(offset_x_shoulder), 3), shoulder_offset_level))
    else:
        print("肩部中心位居中轴，位置良好")
        result.append("肩部中心位居中轴，位置良好")

    if shoulder_l_y < shoulder_r_y and shoulder_level != "":
        print("肩部左部高，向右倾斜，角度为{}度，程度{}，高度差异与肩长比值为{}%".format(shoulder_angle, shoulder_level,
                                                            round(rate_shoulder * 100, 2)))
        result.append("肩部左部高，向右倾斜，角度为{}度，程度{}，高度差异与肩长比值为{}%".format(shoulder_angle, shoulder_level,
                                                                    round(rate_shoulder * 100, 2)))
    elif ear_l_y > ear_r_y and shoulder_level != "":
        print("肩部右部高，向左倾斜，角度为{}度，程度{}，高度差异与肩长比值为{}%".format(shoulder_angle, shoulder_level,
                                                            round(rate_shoulder * 100, 2)))
        result.append("肩部右部高，向左倾斜，角度为{}度，程度{}，高度差异与肩长比值为{}%".format(shoulder_angle, shoulder_level,
                                                                    round(rate_shoulder * 100, 2)))
    else:
        print("肩部角度保持完美平衡")
        result.append("肩部角度保持完美平衡")

    # for hip
    hip_r_x = data[8][0]
    hip_r_y = data[8][1]
    hip_l_x = data[11][0]
    hip_l_y = data[11][1]
    hip_mid_x = (hip_r_x + hip_l_x) / 2
    offset_x_hip = (hip_mid_x - ankle_mid_x) * h_real_eye2elbow / h_pixel_eye2elbow
    hd_hip = abs(data[11][1] - data[8][1])
    d_hip = math.sqrt((hip_l_x - hip_r_x) ** 2 + (hip_l_y - hip_r_y) ** 2)
    rate_hip = hd_hip / d_hip
    hip_angle = angle([hip_r_x, hip_r_y, hip_l_x, hip_l_y], [0, 0, 1, 0])
    hip_level = ""
    hip_offset_level = ""
    if hip_angle <= level_0:
        hip_level = ""
    elif hip_angle <= level_1 and hip_angle > level_0:
        hip_level = "轻微"
    elif hip_angle > level_1 and hip_angle <= level_2:
        hip_level = "中等"
    else:
        hip_level = "严重"

    if offset_x_hip <= HIP_OFFSET_ARGUMENT_0:
        hip_offset_level = ""
    elif offset_x_hip <= HIP_OFFSET_ARGUMENT_1 and offset_x_hip > HIP_OFFSET_ARGUMENT_0:
        hip_offset_level = "轻微"
    elif offset_x_hip > HIP_OFFSET_ARGUMENT_1 and offset_x_hip <= HIP_OFFSET_ARGUMENT_2:
        hip_offset_level = "中等"
    else:
        hip_offset_level = "严重"
    print("髋部分析：")
    result.append("髋部分析：")

    if offset_x_hip > 0 and hip_offset_level != "":
        print("髋部向左横移，距离为{}cm，程度{}".format(round(abs(offset_x_hip), 3), hip_offset_level))
        result.append("髋部向左横移，距离为{}cm，程度{}".format(round(abs(offset_x_hip), 3), hip_offset_level))
    elif offset_x_hip < 0 and hip_offset_level != "":
        print("髋部向右横移，距离为{}cm，程度{}".format(round(abs(offset_x_hip), 3), hip_offset_level))
        result.append("髋部向右横移，距离为{}cm，程度{}".format(round(abs(offset_x_hip), 3), hip_offset_level))
    else:
        print("髋部中心位居中轴，位置良好")
        result.append("髋部中心位居中轴，位置良好")

    if hip_l_y < hip_r_y:
        print("髋部左部高，向右倾斜，角度为{}度，程度{}，高度差异与髋宽比值为{}%".format(hip_angle, hip_level, round(rate_hip * 100, 2)))
        result.append("髋部左部高，向右倾斜，角度为{}度，程度{}，高度差异与髋宽比值为{}%".format(hip_angle, hip_level, round(rate_hip * 100, 2)))
    elif ear_l_y > ear_r_y:
        print("髋部右部高，向左倾斜，角度为{}度，程度{}，高度差异与髋宽比值为{}%".format(hip_angle, hip_level, round(rate_hip * 100, 2)))
        result.append("髋部右部高，向左倾斜，角度为{}度，程度{}，高度差异与髋宽比值为{}%".format(hip_angle, hip_level, round(rate_hip * 100, 2)))
    else:
        print("髋部角度保持完美平衡")
        result.append("髋部角度保持完美平衡")

    #

    print("腿型分析：")
    result.append("腿型分析：")

    # for knee distance
    knee_r_x = data[9][0]
    knee_r_y = data[9][1]
    knee_l_x = data[12][0]
    knee_l_y = data[12][1]
    d_knee = math.sqrt((knee_l_x - knee_r_x) ** 2 + (knee_l_y - knee_r_y) ** 2)
    rate_knee = d_knee / d_hip
    print("双膝间距与髋宽比值为{}%".format(round(rate_knee * 100, 2)))
    result.append("双膝间距与髋宽比值为{}%".format(round(rate_knee * 100, 2)))

    # XO judgement
    ankle_r_x = data[10][0]
    ankle_r_y = data[10][1]
    ankle_l_x = data[13][0]
    ankle_l_y = data[13][1]
    d_ankle = math.sqrt((ankle_l_x - ankle_r_x) ** 2 + (ankle_l_y - ankle_r_y) ** 2)
    rate_ankle = d_ankle / d_knee
    print("脚踝间距与双膝间距比值为{}%".format(round(rate_ankle * 100, 2)))
    result.append("脚踝间距与双膝间距比值为{}%".format(round(rate_ankle * 100, 2)))

    if rate_ankle > X_ARGUMENT_1:
        print("腿型可能为X型腿")
        result.append("腿型可能为X型腿")
    elif rate_knee - rate_ankle > O_ARGUMENT_1:
        print("腿型可能为O型腿")
        result.append("腿型可能为O型腿")
    else:
        print("腿型基本正常，非X、O型腿")
        result.append("腿型基本正常，非X、O型腿")

    return result


def analyse_npy_side(npy_side):
    result = []
    data = np.load(npy_side)

    result.append(" ")
    print("------------------")
    result.append("------------------")
    print("侧面分析内容如下：")
    result.append("侧面分析内容如下：")

    # for head
    ear_r_x = data[len(data) - 1][0]
    ear_r_y = data[len(data) - 1][1]
    shoulder_r_x = data[2][0]
    shoulder_r_y = data[2][1]
    head_forward_angle = angle([shoulder_r_x, shoulder_r_y, ear_r_x, ear_r_y, ], [0, 0, 0, -1])
    head_forward_level = ""
    head_extra_stress = 0

    if head_forward_angle < 90 and head_forward_angle > 0:
        head_extra_stress = round(cal_head_extra_stress(head_forward_angle), 3)
    if head_forward_angle <= HEAD_FORWARD_ARGUMENT_0:
        head_forward_level = ""
    elif head_forward_angle <= HEAD_FORWARD_ARGUMENT_1 and head_forward_angle > HEAD_FORWARD_ARGUMENT_0:
        head_forward_level = "轻微"
    elif head_forward_angle > HEAD_FORWARD_ARGUMENT_1 and head_forward_angle <= HEAD_FORWARD_ARGUMENT_2:
        head_forward_level = "中等"
    else:
        head_forward_level = "严重"
    if ear_r_x > shoulder_r_x and head_forward_level != "":
        print("颈椎分析：头部前倾，角度为{}度，程度{}，颈椎额外承受压力为头部重量{}倍".format(round(head_forward_angle, 2), head_forward_level,
                                                              head_extra_stress))
        result.append("颈椎分析：头部前倾，角度为{}度，程度{}，颈椎额外承受压力为头部重量{}倍".format(round(head_forward_angle, 2), head_forward_level,
                                                                      head_extra_stress))
    elif ear_r_x < shoulder_r_x and head_forward_level != "":
        print("颈椎分析：头部后仰，角度为{}度，程度{}，颈椎额外承受压力为头部重量{}倍".format(round(head_forward_angle, 2), head_forward_level,
                                                              head_extra_stress))
        result.append("颈椎分析：头部后仰，角度为{}度，程度{}，颈椎额外承受压力为头部重量{}倍".format(round(head_forward_angle, 2), head_forward_level,
                                                                      head_extra_stress))
    else:
        print("无头部前倾问题")
        result.append("无头部前倾问题")

    # upper part of body
    up_risk_level = ""
    up_state = ""
    neck_x = data[1][0]
    neck_y = data[1][1]

    ankle_r_x = data[10][0]
    ankle_r_y = data[10][1]
    up_angle = round(angle([ankle_r_x, ankle_r_y, neck_x, neck_y], [0, 0, 0, -1]), 2)
    if up_angle >= UP_FORWARD_ARGUMENT_0 and up_angle < UP_FORWARD_ARGUMENT_1:
        up_risk_level = "轻微"
    elif up_angle < UP_FORWARD_ARGUMENT_2 and up_angle >= UP_FORWARD_ARGUMENT_1:
        up_risk_level = "中度"
    elif up_angle >= UP_FORWARD_ARGUMENT_2:
        up_risk_level = "严重"
    else:
        up_risk_level = ""

    if neck_x < ankle_r_x and up_angle >= HIP_FORWARD_ARGUMENT_0:
        up_state = "身体整体后倾，程度{}，身体与竖直方向角度为{}度".format(up_risk_level, up_angle)
    elif neck_x > ankle_r_x and up_angle >= HIP_FORWARD_ARGUMENT_0:
        up_state = "身体整体前倾，程度{}，身体与竖直方向角度为{}度".format(up_risk_level, up_angle)
    else:
        up_state = "身体整体竖直于地面，无明显站姿前后倾斜"

    print("站姿分析：{}".format(up_state))
    result.append("站姿分析：{}".format(up_state))

    # for hip
    hip_state = ""
    hip_risk_level = ""
    hip_r_x = data[8][0]
    hip_r_y = data[8][1]
    knee_r_x = data[9][0]
    knee_r_y = data[9][1]
    hip_angle = 180 - angle([hip_r_x, hip_r_y, neck_x, neck_y], [hip_r_x, hip_r_y, knee_r_x, knee_r_y])
    if hip_angle >= 90:
        hip_angle = 180 - hip_angle
    if hip_angle >= HIP_FORWARD_ARGUMENT_0 and hip_angle < HIP_FORWARD_ARGUMENT_1:
        hip_risk_level = "轻微"
    elif hip_angle < HIP_FORWARD_ARGUMENT_2 and hip_angle >= HIP_FORWARD_ARGUMENT_1:
        hip_risk_level = "中度"
    elif hip_angle >= HIP_FORWARD_ARGUMENT_2:
        hip_risk_level = "严重"
    else:
        hip_risk_level = ""
    if hip_angle > 90:
        hip_angle = 180 - hip_angle
    if knee_r_x > hip_r_x and hip_angle >= HIP_FORWARD_ARGUMENT_0:
        hip_state = "髋部后移，程度{}，躯干与腿部角度为{}度".format(hip_risk_level, round(180 - hip_angle, 2))
    elif knee_r_x < hip_r_x and hip_angle >= HIP_FORWARD_ARGUMENT_0:
        hip_state = "髋部前移，程度{}，躯干与腿部角度为{}度".format(hip_risk_level, round(180 - hip_angle, 2))
    else:
        hip_state = "无明显髋部前移或后移"

    print("髋部分析：{}".format(hip_state))
    result.append("髋部分析：{}".format(hip_state))

    # for knee
    knee_angle_r = 180 - angle([hip_r_x, hip_r_y, knee_r_x, knee_r_y], [knee_r_x, knee_r_y, ankle_r_x, ankle_r_y])
    if knee_angle_r > 90:
        knee_angle_r = 180 - knee_angle_r
    knee_forward_risk_level = ""
    if knee_angle_r >= KNEE_FORWARD_ARGUMENT_0 and knee_angle_r < KNEE_FORWARD_ARGUMENT_1:
        knee_forward_risk_level = "轻微"
    elif knee_angle_r < KNEE_FORWARD_ARGUMENT_2 and knee_angle_r >= KNEE_FORWARD_ARGUMENT_1:
        knee_forward_risk_level = "中度"
    elif knee_angle_r >= KNEE_FORWARD_ARGUMENT_2:
        knee_forward_risk_level = "严重"
    else:
        knee_forward_risk_level = ""

    if knee_forward_risk_level == "":
        print("膝盖角度分析：膝盖无明显超伸")
        result.append("膝盖角度分析：膝盖无明显超伸")
    else:
        print("膝盖角度分析：下肢膝盖超伸角度为{}度，程度{}".format(round(knee_angle_r, 2), knee_forward_risk_level))
        result.append("膝盖角度分析：下肢膝盖超伸角度为{}度，程度{}".format(round(knee_angle_r, 2), knee_forward_risk_level))

    return result


run_openpose_for_image_front(index)
run_openpose_for_image_side(index)
result_front = analyse_npy_front(source_npy_front)
result_side = analyse_npy_side(source_npy_side)
result = result_front + result_side
text_save(save_path, result)