remove useless info from api

backend_refactor/service/photo_analyzer.py

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

backend_refactor/service/video_analyzer.py

@@ -8,17 +8,17 @@ import cv2
 from config import UPLOAD_DIR
 from service.ai.util.torch_openpose import torch_openpose
 from service.ai.util.util import draw_bodypose
+from service.ai.video.classify.balancebeam import classify_balancebeam
 from service.ai.video.classify.gaotaitui import classify_gaotaitui
 from service.ai.video.classify.juanfu import classify_juanfu
-from service.ai.video.classify.shendun import classify_shendun
-from service.ai.video.classify.turnaround import classify_turnaround
-from service.ai.video.classify.standing import classify_standing
-from service.ai.video.classify.pingban import classify_pingban
-from service.ai.video.classify.balancebeam import classify_balancebeam
 from service.ai.video.classify.jump import classify_jump
 from service.ai.video.classify.jumpwithboth import classify_jumpwithboth
+from service.ai.video.classify.pingban import classify_pingban
+from service.ai.video.classify.shendun import classify_shendun
 from service.ai.video.classify.sitforward import classify_sitforward
+from service.ai.video.classify.standing import classify_standing
 from service.ai.video.classify.tennisthrow import classify_tennisthrow
+from service.ai.video.classify.turnaround import classify_turnaround
 from service.ai.video.inner_analyze import analyse_npy_side_jump, analyse_npy_side_juanfu, analyse_npy_side_shendun, \
     analyse_npy_side_gaotaitui
 from service.ai.video.video_score.balancebeam import cal_balancebeam
@@ -68,7 +68,7 @@ def run_openpose_for_npy_and_video(video_uuid, callback: Callable):
                 out.write(canvas)
 
             c += 1
-            callback("RUNNING", progress=min(99,int(100*c/(total_frames/sampling_fps))))
+            callback("RUNNING", progress=min(99, int(100 * c / (total_frames / sampling_fps))))
         else:
             break
 
@@ -108,42 +108,42 @@ class JumpVideoAnalyzer(BaseVideoAnalyzer):
     def _do_analyze(self):
         self.results = {k: analyse_npy_side_jump(v) for k, v in self.results.items()}
         raw = cal_jump(self.results)[1]
-        return {"raw": raw, "analysis": classify_jump(raw)}
+        return classify_jump(raw)
 
 
 class PingbanVideoAnalyzer(BaseVideoAnalyzer):
     def _do_analyze(self):
         self.results = {k: analyse_npy_side_jump(v) for k, v in self.results.items()}
         raw = cal_pingban(self.results)[1]
-        return {"raw": raw, "analysis": classify_pingban(raw)}
+        return classify_pingban(raw)
 
 
 class JuanfuVideoAnalyzer(BaseVideoAnalyzer):
     def _do_analyze(self):
         self.results = {k: analyse_npy_side_juanfu(v) for k, v in self.results.items()}
         raw = ignore_data_juanfu(self.results)[1]
-        return {"raw": raw, "analysis": classify_juanfu(raw)}
+        return classify_juanfu(raw)
 
 
 class ShendunVideoAnalyzer(BaseVideoAnalyzer):
     def _do_analyze(self):
         self.results = {k: analyse_npy_side_shendun(v) for k, v in self.results.items()}
         raw = ignore_data_shendun(self.results)[1]
-        return {"raw": raw, "analysis": classify_shendun(raw)}
+        return classify_shendun(raw)
 
 
 class GaotaituiVideoAnalyzer(BaseVideoAnalyzer):
     def _do_analyze(self):
         self.results = {k: analyse_npy_side_gaotaitui(v) for k, v in self.results.items()}
         raw = ignore_data_gaotaitui(self.results)[1]
-        return {"raw": raw, "analysis": classify_gaotaitui(raw)}
+        return classify_gaotaitui(raw)
 
 
 class TurnaroundVideoAnalyzer(BaseVideoAnalyzer):
     def _do_analyze(self):
         self.results = {k: analyse_npy_side_jump(v) for k, v in self.results.items()}
         raw = cal_turnaround(self.results)[1]
-        return {"raw": raw, "analysis": classify_turnaround(raw)}
+        return classify_turnaround(raw)
 
 
 class TennisthrowVideoAnalyzer(BaseVideoAnalyzer):
@@ -157,25 +157,25 @@ class JumpwithbothVideoAnalyzer(BaseVideoAnalyzer):
     def _do_analyze(self):
         self.results = {k: analyse_npy_side_jump(v) for k, v in self.results.items()}
         raw = cal_jumpwithboth(self.results)[1]
-        return {"raw": raw, "analysis": classify_jumpwithboth(raw)}
+        return classify_jumpwithboth(raw)
 
 
 class SitforwardVideoAnalyzer(BaseVideoAnalyzer):
     def _do_analyze(self):
         self.results = {k: analyse_npy_side_jump(v) for k, v in self.results.items()}
         raw = cal_sitforward(self.results)[1]
-        return {"raw": raw, "analysis": classify_sitforward(raw)}
+        return classify_sitforward(raw)
 
 
 class BalancebeamVideoAnalyzer(BaseVideoAnalyzer):
     def _do_analyze(self):
         self.results = {k: analyse_npy_side_jump(v) for k, v in self.results.items()}
         raw = cal_balancebeam(self.results)[1]
-        return {"raw": raw, "analysis": classify_balancebeam(raw)}
+        return classify_balancebeam(raw)
 
 
 class StandingVideoAnalyzer(BaseVideoAnalyzer):
     def _do_analyze(self):
         self.results = {k: analyse_npy_side_jump(v) for k, v in self.results.items()}
         raw = cal_standing(self.results)[1]
-        return {"raw": raw, "analysis": classify_standing(raw)}
+        return classify_standing(raw)