code move.

backend_refactor/service/photo_analyzer.py

@@ -375,7 +375,7 @@ class StandingPhotoAnalyzer(BasePhotoAnalyzer):
                 photos.append(UPLOAD_DIR + '{}.result.jpg'.format(i))
 
             callback("FINISHED", result={"photos": {"front": photos[0], "right": photos[1]},
-                                         "text": {"front": npys[0], "right": npys[1]}})
+                                         "advice": {"front": npys[0], "right": npys[1]}})
         except Exception as e:
             callback("ERROR", error=e)
             raise e

backend_refactor/service/video_analyzer.py

@@ -1,10 +1,8 @@
-import math
-import os
+import pickle
 from typing import Callable
 from config import UPLOAD_DIR
 import cv2
 import logging
-import numpy as np
 
 from service.aiutil.torch_openpose import torch_openpose
 from service.aiutil.util import draw_bodypose
@@ -12,10 +10,6 @@ from service.aiutil.util import draw_bodypose
 
 def run_openpose_for_npy_and_video(video_uuid):
     video_path = UPLOAD_DIR + video_uuid + ".mp4"
-    frames_dir = UPLOAD_DIR + "frames/" + video_uuid + "/"
-
-    if not os.path.exists(frames_dir):  # Already split
-        os.makedirs(frames_dir)
 
     cap = cv2.VideoCapture(video_path)
     FPS = cap.get(5)  # 5 means fps
@@ -27,23 +21,22 @@ def run_openpose_for_npy_and_video(video_uuid):
 
     tp = torch_openpose('body_25')  # AI Model
 
+    results = {}
+
     while True:
         ret, frame = cap.read()
         if ret:
             if c % sampling_fps == 0:
-
-                # if os.path.exists(frames_dir + str(c) + ".npy"):
-                #     continue
-
                 logging.debug("Running openpose for %s %s" % (video_uuid, c))
 
                 poses = tp(frame)
-                np.save(frames_dir + str(c) + ".npy", poses)
+                results[c] = poses
 
                 canvas = draw_bodypose(frame, poses, 'body_25')
 
                 if out is None:
-                    out = cv2.VideoWriter(frames_dir + "result.mp4", cv2.VideoWriter_fourcc(*"mp4v"), FPS, (canvas.shape[1], canvas.shape[0]))  # So fucking stupid
+                    out = cv2.VideoWriter(UPLOAD_DIR + video_uuid + ".result.mp4", cv2.VideoWriter_fourcc(*"mp4v"), FPS,
+                                          (canvas.shape[1], canvas.shape[0]))  # So fucking stupid
                 out.write(canvas)
 
             c += 1
@@ -53,10 +46,13 @@ def run_openpose_for_npy_and_video(video_uuid):
     cap.release()
     out.release()
 
+    return results
+
 
 class BaseVideoAnalyzer:
     def __init__(self, data: dict):
         self.video_uuid = data['video_uuid']
+        self.results = None
 
     def _do_analyze(self):
         assert False, "Internal error: You should override this with a subclass!"
@@ -64,327 +60,78 @@ class BaseVideoAnalyzer:
     def analyze(self, callback: Callable):
         try:
             callback("RUNNING")
-            run_openpose_for_npy_and_video(self.video_uuid)
+            self.results = run_openpose_for_npy_and_video(self.video_uuid)
+            pickle.dump(self.results, open(UPLOAD_DIR + self.video_uuid + ".dump", "wb"))
+
             callback("FINISHED", result=self._do_analyze())
         except Exception as e:
             callback("ERROR", error=e)
             raise e
 
 
-def angle1(v1, v2):
-    dx1 = v1[2] - v1[0]
-    dy1 = v1[3] - v1[1]
-    angle1 = float(math.atan2(dy1, dx1))
-    angle2 = abs(round(angle1 * 180.0 / math.pi, 2))
-    return angle2
-
-
-# calculate the angle between 3 points under the coordinates
-# params: list, item [x,y]
-# return: the angle value of b
-def cal_angle(point_a, point_b, point_c):
-    a_x, b_x, c_x = point_a[0], point_b[0], point_c[0]
-    a_y, b_y, c_y = point_a[1], point_b[1], point_c[1]
-    a_z, b_z, c_z = 0, 0, 0
-    #  m=(x1,y1,z1), n=(x2,y2,z2)
-    x1, y1, z1 = (a_x - b_x), (a_y - b_y), (a_z - b_z)
-    x2, y2, z2 = (c_x - b_x), (c_y - b_y), (c_z - b_z)
-
-    cos_b = (x1 * x2 + y1 * y2 + z1 * z2) / (
-            math.sqrt(x1 ** 2 + y1 ** 2 + z1 ** 2) * (math.sqrt(x2 ** 2 + y2 ** 2 + z2 ** 2)))
-    B = math.degrees(math.acos(cos_b))
-    return round(B, 2)
-
-
-def analyse_npy_crunch_side(data):
-    result = {}
-
-    print(len(data))
-    assert len(data) == 25, "error"
-
-    nose_x = data[0][0]
-    nose_y = data[0][1]
-    shoulder_r_x = data[2][0]
-    shoulder_r_y = data[2][1]
-    elbow_r_x = data[3][0]
-    elbow_r_y = data[3][1]
-    wrist_r_x = data[4][0]
-    wrist_r_y = data[4][1]
-
-    hip_r_x = data[9][0]
-    hip_r_y = data[9][1]
-    knee_r_x = data[10][0]
-    knee_r_y = data[10][1]
-    neck_x = data[1][0]
-    neck_y = data[1][1]
-    ankle_r_x = data[11][0]
-    ankle_r_y = data[11][1]
-    leg_heigh = data[11][1]
-    neck_hip_angle = round(angle1([neck_x, neck_y, hip_r_x, hip_r_y], [0, 0, 0, -1]), 2)
-    nose_neck_angle = round(angle1([nose_x, nose_y, neck_x, neck_y], [0, 0, 0, -1]), 2)
-    hip_knee_angle = round(angle1([hip_r_x, hip_r_y, knee_r_x, knee_r_y], [0, 0, 0, -1]), 2)
-    knee_ankle_angle = round(angle1([knee_r_x, knee_r_y, ankle_r_x, ankle_r_y], [0, 0, 0, -1]), 2)
-    result["neck_hip_angle"] = neck_hip_angle
-    result["nose_neck_angle"] = nose_neck_angle
-    result["hip_knee_angle"] = hip_knee_angle
-    result["knee_ankle_angle"] = knee_ankle_angle
-    return result
-
-
-def analyse_npy_side_pingban(data):
-    result = {}
-    assert len(data) >= 15, "error"
-
-    shoulder_r_x = data[2][0]
-    shoulder_r_y = data[2][1]
-    elbow_r_x = data[3][0]
-    elbow_r_y = data[3][1]
-    wrist_r_x = data[4][0]
-    wrist_r_y = data[4][1]
-
-    hip_r_x = data[9][0]
-    hip_r_y = data[9][1]
-    knee_r_x = data[10][0]
-    knee_r_y = data[10][1]
-    neck_x = data[1][0]
-    neck_y = data[1][1]
-    ankle_r_x = data[11][0]
-    ankle_r_y = data[11][1]
-    bigToe_r_x = data[22][0]
-    bigToe_r_y = data[22][1]
-    knee_ankle_angle = round(angle1([knee_r_x, knee_r_y, ankle_r_x, ankle_r_y], [0, 0, 0, -1]), 2)
-    leg_heigh = data[11][1]
-    neck_hip_angle = round(angle1([neck_x, neck_y, hip_r_x, hip_r_y], [0, 0, 0, -1]), 2)
-    hip_knee_angle = round(angle1([hip_r_x, hip_r_y, knee_r_x, knee_r_y], [0, 0, 0, -1]), 2)
-    s_e_angle = round(angle1([shoulder_r_x, shoulder_r_y, elbow_r_x, elbow_r_y], []), 2)
-    e_w_angle = round(angle1([elbow_r_x, elbow_r_y, wrist_r_x, wrist_r_y], []), 2)
-    hip_heigh = hip_r_y
-
-    result["knee_ankle_angle"] = knee_ankle_angle
-    result["leg_heigh"] = leg_heigh
-    result["neck_hip_angle"] = neck_hip_angle
-    result["hip_knee_angle"] = hip_knee_angle
-    result["hip_heigh"] = hip_heigh
-    result["s_e_angle"] = s_e_angle
-    result["e_w_angle"] = e_w_angle
-
-    # print(npy_side)
-    return result
-
-
-def analyse_npy_side_jump(data):
-    result = {}
-
-    assert len(data) == 25, "error"
-
-    # should-elbow-wrist r2-3-4 l5-6-7
-    # neck-hip-knee r1-9-10 l1-12-13
-    # hip-knee-ankle r9-10-11 l12-13-14
-    # knee-ankle-bigToe r10-11-22 l13-14-19
-    result["elbow_right_angle"] = cal_angle(data[2], data[3], data[4])
-    result["elbow_left_angle"] = cal_angle(data[5], data[6], data[7])
-    result["hip_right_angle"] = cal_angle(data[1], data[9], data[10])
-    result["hip_left_angle"] = cal_angle(data[1], data[12], data[13])
-    result["knee_right_angle"] = cal_angle(data[9], data[10], data[11])
-    result["knee_left_angle"] = cal_angle(data[12], data[13], data[14])
-    result["ankle_right_angle"] = cal_angle(data[10], data[11], data[12])
-    result["ankle_left_angle"] = cal_angle(data[13], data[14], data[19])
-    result["leg_heigh"] = data[11][1]  # ankle
-    result["hip_heigh"] = data[9][1]  # hip
-    result["wrist_heigh"] = data[4][1]
-    result["neck_heigh"] = data[1][1]
-
-    # knee_ankle_angle = round(angle1([knee_r_x, knee_r_y, ankle_r_x, ankle_r_y], [0, 0, 0, -1]), 2)
-    # neck_hip_angle = round(angle1([neck_x, neck_y, hip_r_x, hip_r_y], [0, 0, 0, -1]), 2)
-    # hip_knee_angle = round(angle1([hip_r_x, hip_r_y, knee_r_x, knee_r_y], [0, 0, 0, -1]), 2)
-    # hip_heigh = hip_r_y
-    # result["knee_ankle_angle"] = knee_ankle_angle
-    # result["leg_heigh"] = leg_heigh
-    # result["neck_hip_angle"] = neck_hip_angle
-    # result["hip_knee_angle"] = hip_knee_angle
-    # result["hip_heigh"] = hip_heigh
-
-    return result
-
-
-def analyse_npy_side_gaotaitui(data):
-    result = {}
-
-    assert len(data) == 25, "error"
-    # print(data)
-    hip_r_x = data[9][0]
-    hip_r_y = data[9][1]
-    knee_r_x = data[10][0]
-    knee_r_y = data[10][1]
-
-    hip_l_x = data[12][0]
-    hip_l_y = data[12][1]
-    knee_l_x = data[13][0]
-    knee_l_y = data[13][1]
-    # print(head_forward_level)
-    # upper part of body
-    up_risk_level = ""
-    up_state = ""
-    neck_x = data[1][0]
-    neck_y = data[1][1]
-    ankle_r_x = data[11][0]
-    ankle_r_y = data[11][1]
-    ankle_l_x = data[14][0]
-    ankle_l_y = data[14][1]
-    knee_ankle_r_angle = round(angle1([knee_r_x, knee_r_y, ankle_r_x, ankle_r_y], [0, 0, 0, -1]), 2)  # ϥ�ǵ���
-    knee_ankle_l_angle = round(angle1([knee_l_x, knee_l_y, ankle_l_x, ankle_l_y], [0, 0, 0, -1]), 2)  # ϥ�ǵ���
-
-    hip_knee_r_angle = round(angle1([hip_r_x, hip_r_y, knee_r_x, knee_r_y], [0, 0, 0, -1]), 2)
-    hip_knee_l_angle = round(angle1([hip_l_x, hip_l_y, knee_l_x, knee_l_y], [0, 0, 0, -1]), 2)
-    neck_hip_angle = round(angle1([neck_x, neck_y, hip_r_x, hip_r_y], [0, 0, 0, -1]), 2)
-    # hip_knee_angle=round(angle1([hip_r_x, hip_r_y,knee_r_x, knee_r_y], [0, 0, 0, -1]), 2)
-    hip_heigh = hip_r_y
-
-    result["knee_ankle_r_angle"] = knee_ankle_r_angle
-    result["knee_ankle_l_angle"] = knee_ankle_l_angle
-    result["hip_knee_r_angle"] = hip_knee_r_angle
-    result["hip_knee_l_angle"] = hip_knee_l_angle
-    result["r_d"] = abs(0 - float(hip_knee_r_angle) + float(knee_ankle_r_angle))
-    result["l_d"] = abs(0 + float(knee_ankle_l_angle) - float(hip_knee_l_angle))
-    return result
-
-
-def analyse_npy_side_shendun(data):
-    result = {}
-    assert len(data) == 25, "data length must be 25."
-    hip_r_x = data[9][0]
-    hip_r_y = data[9][1]
-    knee_r_x = data[10][0]
-    knee_r_y = data[10][1]
-
-    hip_l_x = data[12][0]
-    hip_l_y = data[12][1]
-    knee_l_x = data[13][0]
-    knee_l_y = data[13][1]
-    # print(head_forward_level)
-    # upper part of body
-    up_risk_level = ""
-    up_state = ""
-    neck_x = data[1][0]
-    neck_y = data[1][1]
-    ankle_r_x = data[11][0]
-    ankle_r_y = data[11][1]
-    ankle_l_x = data[14][0]
-    ankle_l_y = data[14][1]
-    knee_ankle_r_angle = round(angle1([knee_r_x, knee_r_y, ankle_r_x, ankle_r_y], [0, 0, 0, -1]), 2)
-    knee_ankle_l_angle = round(angle1([knee_l_x, knee_l_y, ankle_l_x, ankle_l_y], [0, 0, 0, -1]), 2)
-
-    hip_knee_r_angle = round(angle1([hip_r_x, hip_r_y, knee_r_x, knee_r_y], [0, 0, 0, -1]), 2)
-    hip_knee_l_angle = round(angle1([hip_l_x, hip_l_y, knee_l_x, knee_l_y], [0, 0, 0, -1]), 2)
-    neck_hip_angle = round(angle1([neck_x, neck_y, hip_r_x, hip_r_y], [0, 0, 0, -1]), 2)
-    # hip_knee_angle=round(angle1([hip_r_x, hip_r_y,knee_r_x, knee_r_y], [0, 0, 0, -1]), 2)
-    hip_heigh = hip_r_y
-
-    result["knee_ankle_r_angle"] = knee_ankle_r_angle
-    result["knee_ankle_l_angle"] = knee_ankle_l_angle
-    result["hip_knee_r_angle"] = hip_knee_r_angle
-    result["hip_knee_l_angle"] = hip_knee_l_angle
-    result["r_d"] = abs(float(result["hip_knee_r_angle"]) - float(result["knee_ankle_r_angle"]))
-
-    return result
-
-
-def ignore_data_jump(result_ig: dict):
-    max_index = max(result_ig.keys())
-    min_index = min(result_ig.keys())
-
-    max_leg_knee_angle = result_ig[min_index]["knee_ankle_angle"]
-    max_leg_knee_angle_num = int(min_index)
-    less_angle = 100
-    less_num = 1
-    ankle = result_ig[min_index]["leg_heigh"]
-    max_leg_knee_hip_knee = math.fabs(
-        float(result_ig[min_index]["hip_knee_angle"]) - float(result_ig[min_index]["knee_ankle_angle"]))
-    max_l_h_num = 1
-    hip_hei_init = float(result_ig[min_index]["hip_heigh"])
-    # print("max")
-    # print(max_index)
-    # print(hip_hei_init)
-
-    for i in result_ig:
-        if int(i) <= max_index / 5:
-            if float(max_leg_knee_angle) < float(result_ig[i]["knee_ankle_angle"]):
-                max_leg_knee_angle_num = int(i)
-                max_leg_knee_angle = result_ig[i]["knee_ankle_angle"]
-        if int(i) <= max_index / 2 and int(i) > max_index / 3:
-            val = math.fabs(
-                math.fabs(float(result_ig[i]["hip_knee_angle"])) - math.fabs(float(result_ig[i]["knee_ankle_angle"])))
-            if (math.fabs(math.fabs(float(result_ig[i]["hip_knee_angle"])) - math.fabs(
-                    float(result_ig[i]["knee_ankle_angle"]))) < less_angle):
-                less_angle = val
-                less_num = int(i)
-
-        if int(i) <= max_index and int(i) > (max_index / 3):
-
-            if (float(result_ig[i]["hip_heigh"])) < (float(hip_hei_init)) and max_l_h_num != 1:
-                break
-            if (math.fabs(math.fabs(float(result_ig[i]["hip_knee_angle"])) - math.fabs(
-                    float(result_ig[i]["knee_ankle_angle"])))) > max_leg_knee_hip_knee and math.fabs(
-                float(result_ig[i]["leg_heigh"]) - float(ankle)) <= 20:
-                max_leg_knee_hip_knee = math.fabs(
-                    float(result_ig[i]["hip_knee_angle"]) - math.fabs(float(result_ig[i]["knee_ankle_angle"])))
-                max_l_h_num = int(i)
-
-            #    ankle=result_ig[i]["leg_heigh"]
-            #    ankle_num=int(i)
-            # elif ankle!=1 and int(i)>=(le/3*2):
-            #    break
-
-    print(max_leg_knee_angle)
-    print(max_leg_knee_angle_num)
-    print(less_num)
-    print(less_angle)
-    # print(ankle)
-    # print(ankle_num)
-    print(max_leg_knee_hip_knee)
-    print(max_l_h_num)
-    re = {}
-    re["1"] = {}
-    re["1"]["num"] = max_leg_knee_angle_num
-    re["1"]["val"] = max_leg_knee_angle
-    re["2"] = {}
-    re["2"]["num"] = less_num
-    re["2"]["val"] = less_angle
-    re["3"] = {}
-    re["3"]["num"] = max_l_h_num
-    re["3"]["val"] = max_leg_knee_hip_knee
-    print(re)
-
-    return re
-
-
-class HighKneesVideoAnalyzer(BaseVideoAnalyzer):
+from video_score.jump import cal_jump
+from video_score.pingban import cal_pingban
+from video_score.turnaround import cal_turnaround
+from video_score.tennisthrow import cal_tennisthrow
+from video_score.jumpwithboth import cal_jumpwithboth
+from video_score.standing import cal_standing
+from video_score.balancebeam import cal_balancebeam
+from video_score.sitforward import cal_sitforward
+
+from video_score.juanfu import ignore_data_juanfu
+from video_score.shendun import ignore_data_shendun
+from video_score.gaotaitui import ignore_data_gaotaitui
+
+class JumpAnalyzer(BaseVideoAnalyzer):
+    def _do_analyze(self):
+        return {"data": cal_jump(self.results)[1], "advice": "AI组说还没写完"}
+
+
+class PingbanAnalyzer(BaseVideoAnalyzer):
+    def _do_analyze(self):
+        return {"data": cal_pingban(self.results)[1], "advice": "AI组说还没写完"}
+
+
+class JuanfuAnalyzer(BaseVideoAnalyzer):
+    def _do_analyze(self):
+        return {"data": ignore_data_juanfu(self.results)[1], "advice": "AI组说还没写完"}
+
+
+class ShendunAnalyzer(BaseVideoAnalyzer):
+    def _do_analyze(self):
+        return {"data": ignore_data_shendun(self.results)[1], "advice": "AI组说还没写完"}
+
+
+class GaotaituiAnalyzer(BaseVideoAnalyzer):
+    def _do_analyze(self):
+        return {"data": ignore_data_gaotaitui(self.results)[1], "advice": "AI组说还没写完"}
+
+
+class TrunaroundAnalyzer(BaseVideoAnalyzer):
+    def _do_analyze(self):
+        return {"data": cal_turnaround(self.results)[1], "advice": "AI组说还没写完"}
+
+
+class TennisthrowAnalyzer(BaseVideoAnalyzer):
     def _do_analyze(self):
-        pass
+        return {"data": cal_tennisthrow(self.results)[1], "advice": "AI组说还没写完"}
 
 
-class CrunchVideoAnalyzer(BaseVideoAnalyzer):
+class JumpwithbothAnalyzer(BaseVideoAnalyzer):
     def _do_analyze(self):
-        pass
+        return {"data": cal_jumpwithboth(self.results)[1], "advice": "AI组说还没写完"}
 
 
-class StandingLongJumpVideoAnalyzer(BaseVideoAnalyzer):
+class SitforwardAnalyzer(BaseVideoAnalyzer):
     def _do_analyze(self):
-        frames_dir = UPLOAD_DIR + "frames/" + self.video_uuid + "/"
-        result = {}
-        for i in os.listdir(frames_dir):
-            if i.endswith(".npy"):
-                data = np.load(frames_dir + i)[0]
-                result_side = analyse_npy_side_jump(data)  # Analyze each frame
-                result[int(i.replace(".npy", ""))] = result_side  # Get the frame number to store the result
-        return ignore_data_jump(result)
+        return {"data": cal_sitforward(self.results)[1], "advice": "AI组说还没写完"}
 
 
-class PlankVideoAnalyzer(BaseVideoAnalyzer):
+class BalancebeamAnalyzer(BaseVideoAnalyzer):
     def _do_analyze(self):
-        pass
+        return {"data": cal_balancebeam(self.results)[1], "advice": "AI组说还没写完"}
 
 
-class SquatVideoAnalyzer(BaseVideoAnalyzer):
+class StandingAnalyzer(BaseVideoAnalyzer):
     def _do_analyze(self):
-        pass
+        return {"data": cal_standing(self.results)[1], "advice": "AI组说还没写完"}

backend_refactor/service/video_score/balancebeam.py

@@ -0,0 +1,89 @@
+def cal_ratio(measured_angle, max_angle):
+    num1 = float(measured_angle)
+    num2 = float(max_angle)
+    diff = 0
+    if num1 > num2:
+        diff = num1 - num2
+        num1 = num2 - diff
+    if num1 < 0:
+        return 0
+    score = round(num1 / num2, 2)
+    return score
+
+
+def is_zero(result_ig, index):
+    if float(result_ig[index]["elbow_right_angle"]) == 0:
+        result_ig[index]["elbow_right_angle"] = result_ig[index]["elbow_left_angle"]
+    if float(result_ig[index]["elbow_left_angle"]) == 0:
+        result_ig[index]["elbow_left_angle"] = result_ig[index]["elbow_right_angle"]
+    if float(result_ig[index]["hip_right_angle"]) == 0:
+        result_ig[index]["hip_right_angle"] = result_ig[index]["hip_left_angle"]
+    if float(result_ig[index]["hip_left_angle"]) == 0:
+        result_ig[index]["hip_left_angle"] = result_ig[index]["hip_right_angle"]
+    if float(result_ig[index]["ankle_right_angle"]) == 0:
+        result_ig[index]["ankle_right_angle"] = result_ig[index]["ankle_left_angle"]
+    if float(result_ig[index]["ankle_left_angle"]) == 0:
+        result_ig[index]["ankle_left_angle"] = result_ig[index]["ankle_right_angle"]
+    return result_ig
+
+
+# cal average score of all satisfied pics
+def cal_second_score(list):
+    num = len(list)
+    sum_score = 0
+    score = 0
+    for item in list:
+        if float(item["neck_centre_angle"]) == 0 or float(item["elbow_right_angle"]) == 0 or float(
+                item["elbow_left_angle"]) == 0:
+            num = num - 1
+        else:
+            score = cal_ratio(item["neck_centre_angle"], 180) * 60 + cal_ratio(item["elbow_right_angle"],
+                                                                               180) * 20 + cal_ratio(
+                item["elbow_left_angle"],
+                180) * 20
+            sum_score = sum_score + score
+
+    sum_score = round(sum_score / num, 2)
+    return sum_score
+
+
+
+def cal_balancebeam(result):
+    result_ig = result
+    re = {}
+
+    satisfied_pics = []
+    highest_wrist = 1000
+    highest_wrist_index = 0
+    begin_index = 0
+    finish_index = 0
+    is_begin = False
+    end_index = 0
+    for index in result:
+        if float(result[index]["neck_centre_angle"]) > 135 and is_begin == False:
+            is_begin = True
+            begin_index = index
+        if is_begin:
+            if result[index]["neck_centre_angle"] != 0:
+                result_ig = is_zero(result_ig, index)
+                satisfied_pics.append(result_ig[index])
+                if float(result[index]["wrist_heigh"]) < float(highest_wrist):
+                    highest_wrist = result[index]["wrist_heigh"]
+                    highest_wrist_index = index
+            if float(result[index]["neck_centre_angle"]) < 90 and float(result[index]["neck_centre_angle"]) != 0:
+                finish_index = index
+                break
+        end_index = index
+    if finish_index == 0:
+        finish_index = end_index
+    total_score = cal_second_score(satisfied_pics)
+    re["1"] = result[highest_wrist_index]
+    re["1"]["number_of_satisfied"] = len(satisfied_pics)
+    re["1"]["begin_index"] = begin_index
+    re["1"]["finish_index"] = finish_index
+    re["1"]["highest_wrist_index"] = highest_wrist_index
+    re["1"]["total_score"] = round(total_score, 2)
+    print("finish capturing postures and calculating scores")
+    print("result-----------")
+    print(re)
+    return result_ig, re

backend_refactor/service/video_score/gaotaitui.py

@@ -0,0 +1,45 @@
+def ignore_data_gaotaitui(result):
+    result_ig = result
+    k = "0"
+    last = {}
+    max_index = 1
+    for re in result:
+        if k == "0":
+            k = re
+        else:
+            if (max_index < int(re)):
+                max_index = int(re)
+    print("ignore_data_gaotaitui--------")
+    print(k)
+
+    max_leg_knee_r_angle = result_ig[k]["knee_ankle_r_angle"]
+    max_leg_knee_l_angle = result_ig[k]["knee_ankle_l_angle"]
+    max_leg_knee_angle_num = int(k)
+    panduan = {}
+    for i in result_ig:
+        if (float(result_ig[i]["l_d"]) < 30):
+            if (float(result_ig[i]["knee_ankle_r_angle"]) < 60 and float(result_ig[i]["hip_knee_r_angle"]) > 120):
+                panduan[i] = result_ig[i]["r_d"]
+    f = 0
+    # ma=0
+    print("panduan-----------")
+    print(panduan)
+    ma = panduan[k]
+    key_k = k
+    for key in panduan:
+        if f == 0:
+            ma = panduan[key]
+            f = 1
+            key_k = key
+        elif float(ma) > float(panduan[key]):
+            key_k = key
+            ma = panduan[key]
+
+    re = {}
+    re["1"] = {}
+    re["1"]["num"] = key_k
+    re["1"]["val"] = ma
+    re["1"]["hip_knee_r_angle"] = result_ig[key_k]["hip_knee_r_angle"]
+    re["1"]["knee_ankle_r_angle"] = result_ig[key_k]["knee_ankle_r_angle"]
+
+    return result_ig, re

backend_refactor/service/video_score/juanfu.py

@@ -0,0 +1,82 @@
+
+def ignore_data_juanfu(result):
+    result_ig = result
+    k = "0"
+    last = {}
+    max_index = 1
+    for re in result:
+        if k == "0":
+            k = re
+        else:
+            if (max_index < int(re)):
+                max_index = int(re)
+
+    max_angle = result[k]["nose_neck_angle"]
+    max_num = int(k)
+
+    less_h_k_a = result[k]["hip_knee_angle"]
+    less_h_k_num = k
+
+    max_h_k_a = result[k]["hip_knee_angle"]
+    max_h_k_num = k
+
+    less_k_a_a = result[k]["knee_ankle_angle"]
+    less_k_a_num = k
+
+    max_k_a_a = result[k]["knee_ankle_angle"]
+    max_k_a_num = k
+
+    max_neck_hip_a = result[k]["neck_hip_angle"]
+    max_neck_hip_num = k
+
+    for i in result_ig:
+        if (float(result_ig[i]["nose_neck_angle"]) > float(max_angle)):
+            max_num = int(i)
+            max_angle = result_ig[i]["nose_neck_angle"]
+
+        if (float(result_ig[i]["hip_knee_angle"]) > float(max_h_k_a)):
+            max_h_k_num = int(i)
+            max_h_k_a = result_ig[i]["hip_knee_angle"]
+
+        if (float(result_ig[i]["knee_ankle_angle"]) > float(max_k_a_a)):
+            max_k_a_num = int(i)
+            max_k_a_a = result_ig[i]["knee_ankle_angle"]
+
+        if (float(result_ig[i]["neck_hip_angle"]) > float(max_neck_hip_a)):
+            max_neck_hip_num = int(i)
+            max_neck_hip_a = result_ig[i]["neck_hip_angle"]
+
+        if (float(result_ig[i]["hip_knee_angle"]) < float(less_h_k_a)):
+            less_h_k_num = int(i)
+            less_h_k_a = result_ig[i]["hip_knee_angle"]
+
+        if (float(result_ig[i]["knee_ankle_angle"]) < float(less_k_a_a)):
+            less_k_a_num = int(i)
+            less_k_a_a = result_ig[i]["knee_ankle_angle"]
+
+    re = {}
+    re["1"] = {}
+    re["1"]["num"] = max_num
+    re["1"]["val"] = max_angle
+    re["2"] = {}
+    re["2"]["num"] = max_neck_hip_num
+    re["2"]["val"] = max_neck_hip_a
+    re["3"] = {}
+    re["3"]["num"] = float(max_h_k_a) - float(less_h_k_a)
+    re["3"]["num1"] = max_h_k_num
+    re["3"]["num2"] = less_h_k_num
+    re["3"]["val1"] = max_h_k_a
+    re["3"]["val2"] = less_h_k_a
+    re["4"] = {}
+    re["4"]["num"] = float(max_k_a_a) - float(less_k_a_a)
+    re["4"]["num1"] = max_k_a_num
+    re["4"]["num2"] = less_k_a_num
+    re["4"]["val1"] = max_k_a_a
+    re["4"]["val2"] = less_k_a_a
+    # 1表示头部和脖子角度
+    # 2表示脖子和臀部角度
+    # 3表示hip-knee的极差 稳定性
+    # 4表示knee-ankle的极差 稳定性
+    # 3的数据误差太大 待用性待考察
+    print(re)
+    return result_ig, re

backend_refactor/service/video_score/jump.py

@@ -0,0 +1,172 @@
+def cal_ratio(measured_angle, max_angle):
+    num1 = float(measured_angle)
+    num2 = float(max_angle)
+    diff = 0
+    if num1 > num2:
+        diff = num1 - num2
+        num1 = num2 - diff
+    if num1 < 0:
+        return 0
+    score = round(num1 / num2, 2)
+    return score
+
+
+def is_zero(result_ig, index):
+    if float(result_ig[index]["elbow_right_angle"]) == 0:
+        result_ig[index]["elbow_right_angle"] = result_ig[index]["elbow_left_angle"]
+    if float(result_ig[index]["elbow_left_angle"]) == 0:
+        result_ig[index]["elbow_left_angle"] = result_ig[index]["elbow_right_angle"]
+    if float(result_ig[index]["hip_right_angle"]) == 0:
+        result_ig[index]["hip_right_angle"] = result_ig[index]["hip_left_angle"]
+    if float(result_ig[index]["hip_left_angle"]) == 0:
+        result_ig[index]["hip_left_angle"] = result_ig[index]["hip_right_angle"]
+    if float(result_ig[index]["ankle_right_angle"]) == 0:
+        result_ig[index]["ankle_right_angle"] = result_ig[index]["ankle_left_angle"]
+    if float(result_ig[index]["ankle_left_angle"]) == 0:
+        result_ig[index]["ankle_left_angle"] = result_ig[index]["ankle_right_angle"]
+    if float(result_ig[index]["knee_right_angle"]) == 0:
+        result_ig[index]["knee_right_angle"] = result_ig[index]["knee_left_angle"]
+    if float(result_ig[index]["knee_left_angle"]) == 0:
+        result_ig[index]["knee_left_angle"] = result_ig[index]["knee_right_angle"]
+    return result_ig
+
+
+# get scores based on data from /cap_file/name/file1.txt about standing long jump
+def cal_jump(result):
+    result_ig = result
+    re = {}
+    initial_ankle_height = float(result[list(result.keys())[0]]["leg_heigh"])
+    min_ankle_height = initial_ankle_height
+    for index in result:
+        if float(result[index]["leg_heigh"]) < initial_ankle_height - 3:
+            if float(result[index]["leg_heigh"]) < float(min_ankle_height) and float(
+                    result[index]["leg_heigh"]) != 0.0:
+                min_ankle_height = float(result[index]["leg_heigh"])
+                highest_ankle_index = index
+    # first socre
+    min_wrist_height = float(result[list(result.keys())[0]]["wrist_heigh"])
+    min_hip_angle = float(result[list(result.keys())[0]]["hip_right_angle"])
+    min_wrist_index = 0
+    for index in result:
+        if float(result[index]["leg_heigh"]) >= initial_ankle_height - 3:
+            if float(result[index]["hip_right_angle"]) <= min_hip_angle and float(
+                    result[index]["hip_right_angle"]) != 0.0:
+                min_hip_angle = float(result[index]["hip_right_angle"])
+                min_hip_angle_index = index
+        if float(index) > float(highest_ankle_index):
+            break
+        # else:
+        #     leave_index = index
+        #     break
+    leave_index = min_hip_angle_index
+    for index in result:
+        if float(index) < float(min_hip_angle_index):
+            if float(result[index]["leg_heigh"]) >= initial_ankle_height - 3:
+                if float(result[index]["wrist_heigh"]) <= min_wrist_height and float(
+                        result[index]["wrist_heigh"]) != 0.0:
+                    min_wrist_height = float(result[index]["wrist_heigh"])
+                    min_wrist_index = index
+        else:
+            break
+    # if result[min_wrist_index]["elbow_right_angle"]==0 :
+    is_prepared = True
+    result_ig = is_zero(result_ig, min_wrist_index)
+    if float(result_ig[min_wrist_index]["wrist_heigh"]) > float(result_ig[min_wrist_index]["neck_heigh"]):
+        is_prepared = False
+    first_score = round((cal_ratio(float(result_ig[min_wrist_index]["elbow_right_angle"]), 180) * 10 + cal_ratio(
+        float(result_ig[min_wrist_index]["elbow_left_angle"]), 180) * 10 + cal_ratio(
+        float(result_ig[min_wrist_index]["hip_right_angle"]), 180) * 20 + cal_ratio(
+        float(result_ig[min_wrist_index]["hip_left_angle"]), 180) * 20 + cal_ratio(
+        float(result_ig[min_wrist_index]["knee_right_angle"]), 180) * 10 + cal_ratio(
+        float(result_ig[min_wrist_index]["knee_left_angle"]), 180) * 10 + cal_ratio(
+        float(result_ig[min_wrist_index]["ankle_right_angle"]), 90) * 10 + cal_ratio(
+        float(result_ig[min_wrist_index]["ankle_left_angle"]), 90) * 10), 2)
+
+    re["1"] = result_ig[min_wrist_index]
+    re["1"]["first_score"] = round(first_score, 2)
+    re["1"]["first_score_index"] = min_wrist_index
+    re["1"]["is_prepared"] = is_prepared
+    # second socre
+    result_ig = is_zero(result_ig, min_hip_angle_index)
+    second_score = round((cal_ratio(float(result_ig[min_hip_angle_index]["hip_right_angle"]), 45) * 20 + cal_ratio(
+        float(result_ig[min_hip_angle_index]["hip_left_angle"]), 45) * 20 + cal_ratio(
+        float(result_ig[min_hip_angle_index]["knee_right_angle"]), 90) * 20 + cal_ratio(
+        float(result_ig[min_hip_angle_index]["knee_left_angle"]), 90) * 20 +
+                          cal_ratio(float(result_ig[min_hip_angle_index]["ankle_right_angle"]), 85) * 10 +
+                          cal_ratio(float(result_ig[min_hip_angle_index][
+                                              "ankle_left_angle"]), 85) * 10), 2)
+    re["2"] = result_ig[min_hip_angle_index]
+    re["2"]["second_score"] = round(second_score, 2)
+    re["2"]["second_score_index"] = min_hip_angle_index
+    # third score
+    max_hip_angle = float(result[min_hip_angle_index]["knee_right_angle"])
+    max_hip_index = "1"
+    highest_ankle_index = "1"
+    min_ankle_height = initial_ankle_height
+    for index in result:
+        if float(index) > float(leave_index):
+            if float(result[index]["leg_heigh"]) < initial_ankle_height - 3:
+                if float(result[index]["knee_right_angle"]) >= float(max_hip_angle):
+                    max_hip_angle = float(result[index]["knee_right_angle"])
+                    max_hip_index = index
+                if float(result[index]["leg_heigh"]) < float(min_ankle_height) and float(
+                        result[index]["leg_heigh"]) != 0.0:
+                    min_ankle_height = float(result[index]["leg_heigh"])
+                    highest_ankle_index = index
+            else:
+                reland_index = index
+    result_ig = is_zero(result_ig, max_hip_index)
+    third_score = cal_ratio(result_ig[max_hip_index]["hip_right_angle"], 180) * 15 + cal_ratio(
+        result_ig[max_hip_index]["hip_left_angle"], 180) * 15 + cal_ratio(result_ig[max_hip_index]["knee_right_angle"],
+                                                                          180) * 15 + cal_ratio(
+        result_ig[max_hip_index]["knee_left_angle"], 180) * 15 + cal_ratio(
+        result_ig[max_hip_index]["ankle_right_angle"], 165) * 20 + cal_ratio(
+        result_ig[max_hip_index]["ankle_left_angle"], 165) * 20
+
+    re["3"] = result_ig[max_hip_index]
+    re["3"]["third_score"] = round(third_score, 2)
+    re["3"]["third_score_index"] = max_hip_index
+    # forth score
+    result_ig = is_zero(result_ig, highest_ankle_index)
+    forth_score = cal_ratio(result_ig[highest_ankle_index]["hip_right_angle"], 180) * 25 + cal_ratio(
+        result_ig[highest_ankle_index]["hip_left_angle"], 180) * 25 + cal_ratio(
+        result_ig[highest_ankle_index]["knee_right_angle"], 55) * 25 + cal_ratio(
+        result_ig[highest_ankle_index]["knee_left_angle"], 55) * 25
+
+    re["4"] = result_ig[highest_ankle_index]
+    re["4"]["forth_score"] = round(forth_score, 2)
+    re["4"]["forth_score_index"] = highest_ankle_index
+    # fifth score
+    lowest_ankle_height = float(result[reland_index]["leg_heigh"])
+    lowest_ankle_index = "1"
+    for index in result:
+        if int(index) <= int(highest_ankle_index):
+            continue
+        else:
+            if float(result[str(int(index) - 1)]["leg_heigh"]) <= float(result[index]["leg_heigh"]) or float(result[index]["leg_heigh"])>float(lowest_ankle_height):
+                lowest_ankle_height = float(result[index]["leg_heigh"])
+                lowest_ankle_index = index
+
+
+    result_ig = is_zero(result_ig, lowest_ankle_index)
+
+    fifth_score = cal_ratio(result_ig[lowest_ankle_index]["hip_right_angle"], 85) * 20 + cal_ratio(
+        result_ig[lowest_ankle_index]["hip_left_angle"], 85) * 20 + cal_ratio(
+        result_ig[lowest_ankle_index]["knee_right_angle"], 85) * 20 + cal_ratio(
+        result_ig[lowest_ankle_index]["knee_left_angle"], 85) * 20 + cal_ratio(
+        result_ig[lowest_ankle_index]["ankle_right_angle"], 90) * 10 + cal_ratio(
+        result_ig[lowest_ankle_index]["ankle_left_angle"], 90) * 10
+
+    re["5"] = result_ig[lowest_ankle_index]
+    re["5"]["fifth_score"] = round(fifth_score, 2)
+    re["5"]["fifth_score_index"] = lowest_ankle_index
+    if is_prepared:
+        re["5"]["total_score"] = round(
+            0.1 * first_score + 0.2 * second_score + 0.3 * third_score + 0.3 * forth_score + 0.1 * fifth_score, 2)
+    else:
+        re["5"]["total_score"] = round(0.2 * second_score + 0.3 * third_score + 0.4 * forth_score + 0.1 * fifth_score,
+                                       2)
+    print("finish capturing postures and calculating scores")
+    print("result-----------")
+    print(re)
+    return result_ig, re

backend_refactor/service/video_score/jumpwithboth.py

@@ -0,0 +1,110 @@
+def cal_ratio(measured_angle, max_angle):
+    num1 = float(measured_angle)
+    num2 = float(max_angle)
+    diff = 0
+    if num1 > num2:
+        diff = num1 - num2
+        num1 = num2 - diff
+    if num1 < 0:
+        return 0
+    score = round(num1 / num2, 2)
+    return score
+
+
+def is_zero(result_ig, index):
+    if float(result_ig[index]["ankle_right_angle"]) == 0:
+        result_ig[index]["ankle_right_angle"] = result_ig[index]["ankle_left_angle"]
+    if float(result_ig[index]["ankle_left_angle"]) == 0:
+        result_ig[index]["ankle_left_angle"] = result_ig[index]["ankle_right_angle"]
+    if float(result_ig[index]["knee_right_angle"]) == 0:
+        result_ig[index]["knee_right_angle"] = result_ig[index]["knee_left_angle"]
+    if float(result_ig[index]["knee_left_angle"]) == 0:
+        result_ig[index]["knee_left_angle"] = result_ig[index]["knee_right_angle"]
+    return result_ig
+
+
+def check_elbow(item):
+    if float(item["ankle_right_angle"]) == 0 and float(item["ankle_left_angle"]) == 0:
+        return False
+    elif float(item["knee_right_angle"]) == 0 and float(item["knee_left_angle"]) == 0:
+        return False
+    return True
+
+
+# cal average score of all satisfied pics
+def cal_average_score(list, mode):
+    num = len(list)
+    sum_score = 0
+    score = 0
+    is_clean = True
+    for item in list:
+        if mode == 1:
+            score = cal_ratio(
+                item["ankle_right_angle"],
+                155) * 20 + cal_ratio(
+                item["ankle_right_angle"], 155) * 20 + cal_ratio(item["knee_left_angle"], 170) * 30 + cal_ratio(
+                item["knee_right_angle"], 170) * 30
+
+        else:
+            is_clean = check_elbow(item)
+            if (is_clean):
+                score = cal_ratio(item["ankle_right_angle"], 90) * 10 + cal_ratio(
+                    item["ankle_right_angle"], 90) * 10 + cal_ratio(item["knee_left_angle"], 120) * 40 + cal_ratio(
+                    item["knee_right_angle"], 120) * 40
+            else:
+                num = num - 1
+                score = 0
+
+        sum_score = sum_score + score
+    sum_score = round(sum_score / num, 2)
+    return sum_score
+
+
+def check_zero(result_ig, index):
+    while float(result_ig[index]["bigToe_heigh"]) == 0:
+        index = str(int(index) + 1)
+    return index
+
+
+def cal_jumpwithboth(result):
+    result_ig = result
+    re = {}
+    highest_ankle = 10000
+    highest_ankle_index = 0
+
+    for index in result:
+        if float(result[index]["leg_heigh"]) < float(highest_ankle) and float(
+                result[index]["leg_heigh"]) != 0.0:
+            highest_ankle = float(result[index]["leg_heigh"])
+            highest_ankle_index = index
+    highest_ankle_index = check_zero(result_ig, highest_ankle_index)
+    result_ig = is_zero(result_ig, highest_ankle_index)
+    first_score = cal_average_score([result_ig[highest_ankle_index]], 1)
+    re["1"] = result_ig[highest_ankle_index]
+    re["1"]["highest_ankle"] = highest_ankle
+    re["1"]["highest_ankle_index"] = highest_ankle_index
+    re["1"]["first_score"] = first_score
+
+    # second score
+    reload_pics_index = []
+    reload_pics = []
+    ground_height = max(float(result[list(result.keys())[0]]["leg_left_heigh"]),
+                        float(result[list(result.keys())[0]]["leg_right_heigh"]))
+    for index in result:
+        if index == list(result.keys())[0]: continue
+        if float(result[str(int(index) - 1)]["leg_heigh"]) <= float(result[index]["leg_heigh"]) and float(
+                result[index]["leg_heigh"]) >= ground_height:
+            result_ig = is_zero(result_ig, index)
+            reload_pics.append(result_ig[index])
+            reload_pics_index.append(index)
+    second_score = cal_average_score(reload_pics, 2)
+    re["2"] = result_ig[reload_pics_index[0]]
+    re["2"]["number_of_satisfied"] = len(reload_pics)
+    re["2"]["index_of_satisfied"] = reload_pics_index
+    re["2"]["second_score"] = second_score
+    re["2"]["total_score"] = round(0.6 * first_score + 0.4 * second_score, 2)
+    print("finish capturing postures and calculating scores")
+    print("result-----------")
+    print(re)
+
+    return result_ig, re

backend_refactor/service/video_score/pingban.py

@@ -0,0 +1,111 @@
+def cal_ratio(measured_angle, max_angle):
+    num1 = float(measured_angle)
+    num2 = float(max_angle)
+    diff = 0
+    if num1 > num2:
+        diff = num1 - num2
+        num1 = num2 - diff
+    if num1 < 0:
+        return 0
+    score = round(num1 / num2, 2)
+    return score
+
+
+def is_zero(result_ig, index):
+    if float(result_ig[index]["elbow_right_angle"]) == 0:
+        result_ig[index]["elbow_right_angle"] = result_ig[index]["elbow_left_angle"]
+    if float(result_ig[index]["elbow_left_angle"]) == 0:
+        result_ig[index]["elbow_left_angle"] = result_ig[index]["elbow_right_angle"]
+    if float(result_ig[index]["hip_right_angle"]) == 0:
+        result_ig[index]["hip_right_angle"] = result_ig[index]["hip_left_angle"]
+    if float(result_ig[index]["hip_left_angle"]) == 0:
+        result_ig[index]["hip_left_angle"] = result_ig[index]["hip_right_angle"]
+    if float(result_ig[index]["ankle_right_angle"]) == 0:
+        result_ig[index]["ankle_right_angle"] = result_ig[index]["ankle_left_angle"]
+    if float(result_ig[index]["ankle_left_angle"]) == 0:
+        result_ig[index]["ankle_left_angle"] = result_ig[index]["ankle_right_angle"]
+    return result_ig
+
+
+# cal average score of all satisfied pics in 2th posture of pingban
+def cal_second_score(list):
+    num = len(list)
+    sum_score = 0
+    score = 0
+    for item in list:
+        score = cal_ratio(item["ankle_right_angle"], 90) * 10 + cal_ratio(item["ankle_left_angle"],
+                                                                          90) * 10 + cal_ratio(item["knee_left_angle"],
+                                                                                               180) * 15 + cal_ratio(
+            item["knee_right_angle"], 180) * 15 + cal_ratio(item["elbow_right_angle"], 180) * 25 + cal_ratio(
+            item["elbow_left_angle"], 180) * 25
+        sum_score = sum_score + round(score / num, 2)
+    return sum_score
+
+
+#
+def cal_pingban(result):
+    result_ig = result
+    re = {}
+    # clean the data
+    for index in result:
+        if float(result[index]["knee_right_angle"]) == 0.0:
+            result_ig[index]["knee_right_angle"] = result[index]["knee_left_angle"]
+        if float(result[index]["knee_left_angle"]) == 0.0:
+            result_ig[index]["knee_left_angle"] = result[index]["knee_right_angle"]
+    # whether it has prepared posture
+    is_prepared = False
+    for index in result:
+        if float(result[index]["knee_right_angle"]) < 100 and float(result[index]["knee_left_angle"]) < 100:
+            is_prepared = True
+    # prepared posture: when knee at its lowest,number is highest
+    first_index = "1"
+    first_score = 0
+    if is_prepared:
+        lowest_knee = float(result_ig[list(result.keys())[0]]["knee_heigh"])
+        for index in result:
+            if float(lowest_knee) < float(result[index]["knee_heigh"]):
+                lowest_knee = result[index]["knee_heigh"]
+                first_index = index
+        first_score = cal_ratio(result_ig[first_index]["knee_right_angle"], 90) * 15 + cal_ratio(
+            result_ig[first_index]["knee_left_angle"], 90) * 15 + cal_ratio(result_ig[first_index]["hip_right_angle"],
+                                                                            90) * 15 + cal_ratio(
+            result_ig[first_index]["hip_left_angle"], 90) * 15 + cal_ratio(result_ig[first_index]["elbow_right_angle"],
+                                                                           180) * 20 + cal_ratio(
+            result_ig[first_index]["elbow_left_angle"], 180) * 20
+        re["1"] = result_ig[first_index]
+        re["1"]["first_score"] = round(first_score, 2)
+        re["1"]["first_index"] = first_index
+    else:
+        re["1"] = result_ig["1"]
+        re["1"]["no_first_posture"] = "true"
+    # second posture
+    max_knee_angle = float(result_ig[list(result.keys())[0]]["hip_right_angle"])
+    max_knee_angle_index = "1"
+    second_pics = []
+    satisfied_index = []
+    for index in result:
+        if float(index) < float(first_index):
+            continue
+        else:
+            if float(result[index]["hip_right_angle"]) > 150:
+                result_ig = is_zero(result_ig, index)
+                satisfied_index.append(index)
+                second_pics.append(result_ig[index])
+                if float(result[index]["hip_right_angle"]) > float(max_knee_angle):
+                    max_knee_angle = result[index]["hip_right_angle"]
+                    max_knee_angle_index = index
+    pingban_2_score = cal_second_score(second_pics)
+    total_score = pingban_2_score
+    if first_score != 0:
+        total_score = round(0.05 * first_score + 0.95 * pingban_2_score, 2)
+    re["2"] = result_ig[max_knee_angle_index]
+    re["2"]["number_of_satisfied"] = len(second_pics)
+    re["2"]["satisfied_index"] = satisfied_index
+    re["2"]["second_score"] = round(pingban_2_score, 2)
+    re["2"]["max_knee_angle"] = max_knee_angle
+    re["2"]["max_knee_angle_index"] = max_knee_angle_index
+    re["2"]["total_score"] = round(total_score, 2)
+    print("finish capturing postures and calculating scores")
+    print("result-----------")
+    print(re)
+    return result_ig, re

backend_refactor/service/video_score/shendun.py

@@ -0,0 +1,26 @@
+def ignore_data_shendun(result):
+    result_ig = result
+    k = "0"
+    last = {}
+    max_index = 1
+    for re in result:
+        if k == "0":
+            k = re
+        else:
+            if (max_index < int(re)):
+                max_index = int(re)
+
+    max_d_num = k
+    max_d = result[k]["r_d"]
+    for i in result_ig:
+        if (float(result_ig[i]["r_d"]) > float(max_d)):
+            max_d_num = int(i)
+            max_d = result_ig[i]["r_d"]
+
+    re = {}
+    re["1"] = {}
+    re["1"]["num"] = max_d_num
+    re["1"]["val"] = max_d
+
+    # 1最大的深蹲角度
+    return result_ig, re

backend_refactor/service/video_score/sitforward.py

@@ -0,0 +1,59 @@
+def cal_ratio(measured_angle, max_angle):
+    num1 = float(measured_angle)
+    num2 = float(max_angle)
+    diff = 0
+    if num1 > num2:
+        diff = num1 - num2
+        num1 = num2 - diff
+    if num1 < 0:
+        return 0
+    score = round(num1 / num2, 2)
+    return score
+
+
+def is_zero(result_ig, index):
+    if float(result_ig[index]["elbow_right_angle"]) == 0:
+        result_ig[index]["elbow_right_angle"] = result_ig[index]["elbow_left_angle"]
+    if float(result_ig[index]["elbow_left_angle"]) == 0:
+        result_ig[index]["elbow_left_angle"] = result_ig[index]["elbow_right_angle"]
+    if float(result_ig[index]["hip_right_angle"]) == 0:
+        result_ig[index]["hip_right_angle"] = result_ig[index]["hip_left_angle"]
+    if float(result_ig[index]["hip_left_angle"]) == 0:
+        result_ig[index]["hip_left_angle"] = result_ig[index]["hip_right_angle"]
+    if float(result_ig[index]["ankle_right_angle"]) == 0:
+        result_ig[index]["ankle_right_angle"] = result_ig[index]["ankle_left_angle"]
+    if float(result_ig[index]["ankle_left_angle"]) == 0:
+        result_ig[index]["ankle_left_angle"] = result_ig[index]["ankle_right_angle"]
+    if float(result_ig[index]["knee_right_angle"]) == 0:
+        result_ig[index]["knee_right_angle"] = result_ig[index]["knee_left_angle"]
+    if float(result_ig[index]["knee_left_angle"]) == 0:
+        result_ig[index]["knee_left_angle"] = result_ig[index]["knee_right_angle"]
+    return result_ig
+
+
+def cal_sitforward(result):
+    result_ig = result
+    re = {}
+    highest_wrist_x = result[list(result.keys())[0]]["wrist_x"]
+    highest_weist_index = 0
+
+    for index in result:
+        if float(result[index]["wrist_x"]) < float(highest_wrist_x) and float(result[index]["wrist_x"])!=0:
+            highest_wrist_x = result[index]["wrist_x"]
+            highest_weist_index = index
+    is_zero(result_ig, highest_weist_index)
+    total_score = cal_ratio(result_ig[highest_weist_index]["elbow_right_angle"], 180) * 20 + cal_ratio(
+        result_ig[highest_weist_index]["elbow_left_angle"], 180) * 20 + cal_ratio(
+        result_ig[highest_weist_index]["knee_right_angle"], 180) * 20 + cal_ratio(
+        result_ig[highest_weist_index]["knee_left_angle"], 180) * 20 + cal_ratio(
+        result_ig[highest_weist_index]["ankle_right_angle"], 90) * 10 + cal_ratio(
+        result_ig[highest_weist_index]["ankle_left_angle"], 90) * 10
+
+    re["1"] = result[highest_weist_index]
+    re["1"]["highest_wrist_x"] = highest_wrist_x
+    re["1"]["highest_weist_index"] = highest_weist_index
+    re["1"]["total_score"] = total_score
+    print("finish capturing postures and calculating scores")
+    print("result-----------")
+    print(re)
+    return result_ig, re

backend_refactor/service/video_score/standing.py

@@ -0,0 +1,98 @@
+def cal_ratio(measured_angle, max_angle):
+    num1 = float(measured_angle)
+    num2 = float(max_angle)
+    diff = 0
+    if num1 > num2:
+        diff = num1 - num2
+        num1 = num2 - diff
+    if num1 < 0:
+        return 0
+    score = round(num1 / num2, 2)
+    return score
+
+
+def is_zero(result_ig, index):
+    if float(result_ig[index]["elbow_right_angle"]) == 0:
+        result_ig[index]["elbow_right_angle"] = result_ig[index]["elbow_left_angle"]
+    if float(result_ig[index]["elbow_left_angle"]) == 0:
+        result_ig[index]["elbow_left_angle"] = result_ig[index]["elbow_right_angle"]
+    if float(result_ig[index]["hip_right_angle"]) == 0:
+        result_ig[index]["hip_right_angle"] = result_ig[index]["hip_left_angle"]
+    if float(result_ig[index]["hip_left_angle"]) == 0:
+        result_ig[index]["hip_left_angle"] = result_ig[index]["hip_right_angle"]
+    if float(result_ig[index]["ankle_right_angle"]) == 0:
+        result_ig[index]["ankle_right_angle"] = result_ig[index]["ankle_left_angle"]
+    if float(result_ig[index]["ankle_left_angle"]) == 0:
+        result_ig[index]["ankle_left_angle"] = result_ig[index]["ankle_right_angle"]
+    if float(result_ig[index]["knee_right_angle"]) == 0:
+        result_ig[index]["knee_right_angle"] = result_ig[index]["knee_left_angle"]
+    if float(result_ig[index]["knee_left_angle"]) == 0:
+        result_ig[index]["knee_left_angle"] = result_ig[index]["knee_right_angle"]
+    return result_ig
+
+
+# cal average score of all satisfied pics
+def cal_average_score(list, mode):
+    num = len(list)
+    sum_score = 0
+    score = 0
+    for item in list:
+        if mode == "knee_left_angle":
+            score = cal_ratio(item["elbow_right_angle"], 180) * 5 + cal_ratio(item["elbow_left_angle"],
+                                                                              180) * 5 + cal_ratio(
+                item["should_right_angle"],
+                180) * 5 + cal_ratio(
+                item["should_left_angle"], 180) * 5 + cal_ratio(item["neck_right_angle"], 65) * 10 + cal_ratio(
+                item["neck_left_angle"], 65) * 10 + cal_ratio(item["knee_left_angle"], 90) * 30 + cal_ratio(
+                item["knee_right_angle"], 180) * 30
+        else:
+            score = cal_ratio(item["elbow_right_angle"], 180) * 5 + cal_ratio(item["elbow_left_angle"],
+                                                                              180) * 5 + cal_ratio(
+                item["should_right_angle"], 180) * 5 + cal_ratio(item["should_left_angle"], 180) * 5 + cal_ratio(
+                item["neck_right_angle"], 65) * 10 + cal_ratio(item["neck_left_angle"], 65) * 10 + cal_ratio(
+                item["knee_right_angle"], 90) * 30 + cal_ratio(item["knee_left_angle"], 180) * 30
+
+        sum_score = sum_score + score
+    sum_score = round(sum_score / num, 2)
+    return sum_score
+
+
+def cal_standing(result):
+    result_ig = result
+    re = {}
+    mode = "knee_left_angle"
+    begin_index = 0
+    finish_index = 0
+    highest_ankle_index = 0
+    highest_ankle = 1000
+    satisfied_pics = []
+
+    for index in result:
+        if float(result[index]["knee_right_angle"]) < 165:
+            mode = "knee_right_angle"
+    for index in result:
+        if float(result[index][mode]) < 168:
+            if begin_index == 0:
+                begin_index = index
+            result_ig = is_zero(result_ig, index)
+            satisfied_pics.append(result_ig[index])
+        if float(result[index]["leg_left_heigh"]) < float(highest_ankle) and mode == "knee_left_angle":
+            highest_ankle = result[index]["leg_left_heigh"]
+            highest_ankle_index = index
+        if float(result[index]["leg_right_heigh"]) < float(highest_ankle) and mode == "knee_right_angle":
+            highest_ankle = result[index]["leg_right_heigh"]
+            highest_ankle_index = index
+
+    total_score = cal_average_score(satisfied_pics, mode)
+    highest_ankle_score = cal_average_score([result[highest_ankle_index]], mode)
+    re["1"] = result[highest_ankle_index]
+    re["1"]["begin_index"] = begin_index
+    re["1"]["number_of_satisfied"] = len(satisfied_pics)
+    re["1"]["highest_ankle_height"] = highest_ankle
+    re["1"]["highest_ankle_index"] = highest_ankle_index
+    re["1"]["highest_ankle_score"] = highest_ankle_score
+    re["1"]["total_score"] = total_score
+    print("finish capturing postures and calculating scores")
+    print("result-----------")
+    print(re)
+    return result_ig, re

backend_refactor/service/video_score/tennisthrow.py

@@ -0,0 +1,132 @@
+def cal_ratio(measured_angle, max_angle):
+    num1 = float(measured_angle)
+    num2 = float(max_angle)
+    diff = 0
+    if num1 > num2:
+        diff = num1 - num2
+        num1 = num2 - diff
+    if num1 < 0:
+        return 0
+    score = round(num1 / num2, 2)
+    return score
+
+
+def is_zero(result_ig, index):
+    if float(result_ig[index]["ankle_right_angle"]) == 0:
+        result_ig[index]["ankle_right_angle"] = result_ig[index]["ankle_left_angle"]
+    if float(result_ig[index]["ankle_left_angle"]) == 0:
+        result_ig[index]["ankle_left_angle"] = result_ig[index]["ankle_right_angle"]
+    if float(result_ig[index]["knee_right_angle"]) == 0:
+        result_ig[index]["knee_right_angle"] = result_ig[index]["knee_left_angle"]
+    if float(result_ig[index]["knee_left_angle"]) == 0:
+        result_ig[index]["knee_left_angle"] = result_ig[index]["knee_right_angle"]
+    return result_ig
+
+
+# cal average score of all satisfied pics
+def cal_average_score(item, hand, mode):
+    score = 0
+    if hand == "elbow_left_angle" and mode == 1:
+        score = cal_ratio(item[hand], 85) * 50 + cal_ratio(
+            item["hip_right_angle"], 160) * 20 + cal_ratio(item["knee_right_angle"], 135) * 15 + cal_ratio(
+            item["knee_left_angle"], 145) * 15
+    elif hand == "elbow_right_angle" and mode == 1:
+        score = cal_ratio(item[hand], 85) * 50 + cal_ratio(
+            item["hip_left_angle"], 160) * 20 + cal_ratio(item["knee_left_angle"], 135) * 15 + cal_ratio(
+            item["knee_right_angle"], 145) * 15
+    elif hand == "elbow_left_angle" and mode == 2:
+        score = cal_ratio(item[hand], 135) * 70 + cal_ratio(item["knee_right_angle"], 135) * 15 + cal_ratio(
+            item["knee_left_angle"], 160) * 15
+    elif hand == "elbow_right_angle" and mode == 2:
+        score = cal_ratio(item[hand], 135) * 70 + cal_ratio(item["knee_left_angle"], 135) * 15 + cal_ratio(
+            item["knee_right_angle"], 160) * 15
+    elif hand == "elbow_left_angle" and mode == 3:
+        score = cal_ratio(item[hand], 175) * 40 + cal_ratio(item["knee_right_angle"], 135) * 30 + cal_ratio(
+            item["knee_left_angle"], 180) * 30
+    elif hand == "elbow_right_angle" and mode == 3:
+        score = cal_ratio(item[hand], 175) * 40 + cal_ratio(item["knee_left_angle"], 135) * 30 + cal_ratio(
+            item["knee_right_angle"], 180) * 30
+    elif hand == "elbow_left_angle" and mode == 4:
+        score = cal_ratio(item[hand], 180) * 30 + cal_ratio(item["knee_right_angle"], 145) * 30 + cal_ratio(
+            item["knee_left_angle"], 180) * 40
+    else:
+        score = cal_ratio(item[hand], 180) * 30 + cal_ratio(item["knee_left_angle"], 145) * 30 + cal_ratio(
+            item["knee_right_angle"], 180) * 40
+
+    return score
+
+
+def check_zero(result_ig, index):
+    while float(result_ig[index]["neck_heigh"]) == 0 or float(result_ig[index]["wrist_heigh"]) == 0 or float(
+            result_ig[index]["leg_heigh"]) == 0:
+        index = str(int(index) + 1)
+    return index
+
+
+def cal_tennisthrow(result):
+    result_ig = result
+    re = {}
+    # judge left or right hand
+    neck_height = result[list(result.keys())[0]]["neck_heigh"]
+    hand = "elbow_right_angle"
+    highest_wrist = 1000
+    highest_wrist_index = 0
+    for index in result:
+        if float(result[index]["wrist_left_heigh"]) < float(neck_height) and float(
+                result[index]["wrist_left_heigh"]) != 0:
+            print(float(result[index]["wrist_left_heigh"]))
+            hand = "elbow_left_angle"
+            break
+    print("======")
+    print(hand)
+    # third score
+    for index in result:
+        if hand == "elbow_right_angle":
+            if float(result[index]["wrist_right_heigh"]) < float(highest_wrist) and float(
+                    result[index]["wrist_right_heigh"]) != 0:
+                highest_wrist = result[index]["wrist_right_heigh"]
+                highest_wrist_index = index
+        else:
+            if float(result[index]["wrist_left_heigh"]) < float(highest_wrist) and float(
+                    result[index]["wrist_left_heigh"]) != 0:
+                highest_wrist = result[index]["wrist_left_heigh"]
+                highest_wrist_index = index
+    highest_wrist_index = check_zero(result_ig, highest_wrist_index)
+    result_ig = is_zero(result_ig, highest_wrist_index)
+    third_score = cal_average_score(result_ig[highest_wrist_index], hand, 3)
+    # first score
+    farrest_distance_index = 0
+    farrest_distance = 0
+    for index in result:
+        if float(index) < float(highest_wrist_index):
+            if hand == "elbow_right_angle":
+                if float(result[index]["wrist_right_distance"]) > float(farrest_distance) and float(
+                        result[index]["wrist_right_distance"]) != 0:
+                    farrest_distance = result[index]["wrist_right_distance"]
+                    farrest_distance_index = index
+            else:
+                if float(result[index]["wrist_left_distance"]) > float(farrest_distance) and float(
+                        result[index]["wrist_left_distance"]) != 0:
+                    farrest_distance = result[index]["wrist_left_distance"]
+                    farrest_distance_index = index
+        else:
+            break
+    farrest_distance_index = check_zero(result_ig, farrest_distance_index)
+    result_ig = is_zero(result_ig, farrest_distance_index)
+    first_score = cal_average_score(result_ig[farrest_distance_index], hand, 1)
+    re["1"] = result_ig[farrest_distance_index]
+    re["1"]["farrest_distance_index"] = farrest_distance_index
+    re["1"]["farrest_distance"] = farrest_distance
+    re["1"]["first_score"] = first_score
+
+
+    re["3"] = result_ig[highest_wrist_index]
+    re["3"]["highest_wrist_index"] = highest_wrist_index
+    re["3"]["highest_wrist"] = highest_wrist
+    re["3"]["third_score"] = third_score
+
+    print("finish capturing postures and calculating scores")
+    print("result-----------")
+    print(re)
+
+    return result_ig, re

backend_refactor/service/video_score/turnaround.py

@@ -0,0 +1,134 @@
+def is_zero(result_ig, index):
+    if float(result_ig[index]["elbow_right_angle"]) == 0:
+        result_ig[index]["elbow_right_angle"] = result_ig[index]["elbow_left_angle"]
+    if float(result_ig[index]["elbow_left_angle"]) == 0:
+        result_ig[index]["elbow_left_angle"] = result_ig[index]["elbow_right_angle"]
+    if float(result_ig[index]["hip_right_angle"]) == 0:
+        result_ig[index]["hip_right_angle"] = result_ig[index]["hip_left_angle"]
+    if float(result_ig[index]["hip_left_angle"]) == 0:
+        result_ig[index]["hip_left_angle"] = result_ig[index]["hip_right_angle"]
+    if float(result_ig[index]["ankle_right_angle"]) == 0:
+        result_ig[index]["ankle_right_angle"] = result_ig[index]["ankle_left_angle"]
+    if float(result_ig[index]["ankle_left_angle"]) == 0:
+        result_ig[index]["ankle_left_angle"] = result_ig[index]["ankle_right_angle"]
+    if float(result_ig[index]["knee_right_angle"]) == 0:
+        result_ig[index]["knee_right_angle"] = result_ig[index]["knee_left_angle"]
+    if float(result_ig[index]["knee_left_angle"]) == 0:
+        result_ig[index]["knee_left_angle"] = result_ig[index]["knee_right_angle"]
+
+    return result_ig
+
+
+def cal_ratio(measured_angle, max_angle):
+    num1 = float(measured_angle)
+    num2 = float(max_angle)
+    diff = 0
+    if num1 > num2:
+        diff = num1 - num2
+        num1 = num2 - diff
+    if num1 < 0:
+        return 0
+    score = round(num1 / num2, 2)
+    return score
+
+
+def check_elbow(item):
+    if float(item["elbow_right_angle"]) == 0 and float(item["elbow_left_angle"]) == 0:
+        return False
+    elif float(item["ankle_right_angle"]) == 0 and float(item["ankle_left_angle"]) == 0:
+        return False
+    elif float(item["knee_right_angle"]) == 0 and float(item["knee_left_angle"]) == 0:
+        return False
+    return True
+
+
+# cal average score of all satisfied pics
+def cal_average_score(list, mode):
+    num = len(list)
+    sum_score = 0
+    score = 0
+    is_clean = True
+    for item in list:
+        if mode == 1:
+            is_clean = check_elbow(item)
+            if (is_clean):
+                score = cal_ratio(item["elbow_right_angle"], 95) * 20 + cal_ratio(item["elbow_left_angle"],
+                                                                                  95) * 20 + cal_ratio(
+                    item["ankle_right_angle"],
+                    95) * 10 + cal_ratio(
+                    item["ankle_right_angle"], 95) * 10 + cal_ratio(item["knee_left_angle"], 165) * 20 + cal_ratio(
+                    item["knee_right_angle"], 165) * 20
+            else:
+                num = num - 1
+                score = 0
+        else:
+            score = cal_ratio(item["knee_left_angle"], 165) * 15 + cal_ratio(
+                item["knee_right_angle"], 165) * 35 + cal_ratio(item["ankle_small_left_angle"],
+                                                                90) * 15 + cal_ratio(
+                item["ankle_small_right_angle"], 90) * 35
+
+        sum_score = sum_score + score
+    sum_score = round(sum_score / num, 2)
+    return sum_score
+
+
+def check_zero(result_ig, index):
+    while float(result_ig[index]["bigToe_heigh"]) == 0:
+        index = str(int(index) + 1)
+    return index
+
+
+
+# 10-meter turnaround
+def cal_turnaround(result):
+    result_ig = result
+    re = {}
+    satisfied_pics = []
+    max_distance = 0
+    max_distance_index = 0
+    key_index = 0
+    satisfied_index = []
+    for index in result:
+        if float(result[index]["foot_distance"]) > float(
+                result[list(result.keys())[key_index - 1]]["foot_distance"]) and float(
+            result[index]["foot_distance"]) < float(
+            result[list(result.keys())[key_index + 1]]["foot_distance"]) and index != \
+                list(result.keys())[0] and index != list(result.keys())[-1] and float(
+            result[index]["foot_distance"]) > 50:
+            result_ig = is_zero(result_ig, index)
+            satisfied_index.append(index)
+            satisfied_pics.append(result_ig[index])
+        # if float(result[index]["foot_distance"]) > float(max_distance):
+        #     max_distance = result[index]["foot_distance"]
+        #     max_distance_index = index
+        key_index += 1
+    first_score = cal_average_score(satisfied_pics, 1)
+    re["1"] = result_ig[satisfied_index[0]]
+    # re["1"]["max_distance"] = max_distance
+    # re["1"]["max_distance_index"] = max_distance_index
+    re["1"]["satisfied_index"] = satisfied_index
+    re["1"]["number_of_satisfied"] = len(satisfied_pics)
+    re["1"]["first_score"] = first_score
+
+    # second score
+    lowest_midhip = 0
+    lowest_midhip_index = 0
+    for index in result:
+        if float(lowest_midhip) < float(result[index]["midhip_heigh"]) and float(
+                result[index]["midhip_heigh"]) != 0:
+            lowest_midhip = result[index]["midhip_heigh"]
+            lowest_midhip_index = index
+    lowest_midhip_index = check_zero(result_ig, lowest_midhip_index)
+    result_ig = is_zero(result_ig, lowest_midhip_index)
+    second_score = cal_average_score([result_ig[lowest_midhip_index]], 2)
+
+    re["2"] = result_ig[lowest_midhip_index]
+    re["2"]["lowest_midhip"] = lowest_midhip
+    re["2"]["lowest_midhip_index"] = lowest_midhip_index
+    re["2"]["second_score"] = second_score
+    re["2"]["total_score"] = round(0.7 * first_score + 0.3 * second_score, 2)
+    print("finish capturing postures and calculating scores")
+    print("result-----------")
+    print(re)
+
+    return result_ig, re