optimize video split for robustness and change filenames.

backend_refactor/route/analyze.py

@@ -1,11 +1,5 @@
-from hashlib import new
-import random
-import logging
 import uuid, json
-from db import task
-from service.photo.BasePhotoAnalyzer import BasePhotoAnalyzer
-from service.video.BaseVideoAnalyzer import BaseVideoAnalyzer
-from config import MYSQL_URI
+from service.video_analyzer import BaseVideoAnalyzer
 # from service.video.Video3DAnalyzer import Video3DAnalyzer
 
 from db import db
@@ -14,9 +8,7 @@ from db.task import Task
 from worker.thread_pool import pool
 from route.util import make_response
 from flask import Blueprint
-from service.photo.StandingPhotoAnalyzer import StandingPhotoAnalyzer
-from sqlalchemy import create_engine
-
+from service.StandingPhotoAnalyzer import StandingPhotoAnalyzer
 
 import logging
 

backend_refactor/service/photo/BasePhotoAnalyzer.py

@@ -1,3 +0,0 @@
-class BasePhotoAnalyzer:
-    def __init__(self):
-        pass

backend_refactor/service/photo/StandingPhotoAnalyzer.py → backend_refactor/service/photo_analyzer.py

@@ -1,17 +1,17 @@
 import math
 from typing import Callable
-
-from service.photo.BasePhotoAnalyzer import BasePhotoAnalyzer
-
 import cv2
 import copy
-
 from config import UPLOAD_DIR
-
 from service.aiutil import torch_openpose
 import service.aiutil as aiutil
 
 
+class BasePhotoAnalyzer:
+    def __init__(self):
+        pass
+
+
 def angle(v1, v2):
     dx1 = v1[2] - v1[0]
     dy1 = v1[3] - v1[1]
@@ -48,7 +48,7 @@ def cal_head_extra_stress(angle):
     HEAD_STRESS_ARGUMENT_2 = 0.00981481481482367
     HEAD_STRESS_ARGUMENT_3 = -0.000567901234568158
     HEAD_STRESS_ARGUMENT_4 = 0.00000576131687243021
-    return (HEAD_STRESS_ARGUMENT_1 * angle + HEAD_STRESS_ARGUMENT_2 * pow(angle, 2) \
+    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
 
 
@@ -373,7 +373,8 @@ class StandingPhotoAnalyzer(BasePhotoAnalyzer):
                 cv2.imwrite(UPLOAD_DIR + '{}-result.jpg'.format(i), canvas)
                 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]}})
+            callback("FINISHED", result={"photos": {"front": photos[0], "right": photos[1]},
+                                         "text": {"front": npys[0], "right": npys[1]}})
         except Exception as e:
             callback("ERROR", error=e)
             raise e

backend_refactor/service/video/BaseVideoAnalyzer.py

@@ -1,77 +0,0 @@
-
-import os
-from typing import Callable
-from config import UPLOAD_DIR
-import cv2
-import logging
-import numpy as np
-
-
-def split_video(video_uuid):
-    video_path = UPLOAD_DIR + video_uuid + ".mp4"
-    frames_dir = UPLOAD_DIR + "frames/" + video_uuid + "/"
-
-    if os.path.exists(frames_dir):  # Already split
-        return
-
-    os.makedirs(frames_dir)
-
-    cap = cv2.VideoCapture(video_path)
-    FPS = cap.get(5)  # 5 means fps
-    logging.debug("Splitting video %s, FPS: %s" % (video_path, FPS))
-
-    c = 1
-    sampling_fps = 1
-
-    while True:
-        ret, frame = cap.read()
-        if ret:
-            if c % sampling_fps == 0:
-                target_path = frames_dir + str(c) + ".jpg"
-                cv2.imwrite(target_path, frame)
-                logging.debug("Writing frame %s, %s" % (c, target_path))
-            c += 1
-        else:
-            break
-
-    cap.release()
-
-
-from service.aiutil.torch_openpose import torch_openpose
-from service.aiutil.util import draw_bodypose
-
-
-def run_openpose_for_frames(video_uuid):
-    tp = torch_openpose('body_25')
-
-    frames_dir = UPLOAD_DIR + "frames/" + video_uuid + "/"
-    for i in os.listdir(frames_dir):
-        if i.endswith(".jpg") and "result" not in i:
-            
-            logging.debug("Running openpose for %s %s" % (video_uuid, i))
-
-            oriImg = cv2.imread(frames_dir + i)
-            poses = tp(oriImg)
-            np.save(frames_dir + i + ".npy", poses)
-
-            canvas = draw_bodypose(oriImg, poses, 'body_25')
-
-            cv2.imwrite(frames_dir + i.replace(".jpg", ".result.jpg"), canvas)
-
-
-
-class BaseVideoAnalyzer:
-    def __init__(self, video_uuid):
-        self.video_uuid = video_uuid
-
-    def analyze(self, callback: Callable):
-        try:
-            callback("RUNNING")
-            split_video(self.video_uuid)
-            run_openpose_for_frames(self.video_uuid)
-            callback("FINISHED", result={})
-        except Exception as e:
-            callback("ERROR", error=e)
-            raise e
-
-

backend_refactor/service/video/Video3DAnalyzer.py

@@ -1,164 +0,0 @@
-import glob
-import logging
-import subprocess as sp
-import time
-
-import cv2
-import numpy as np
-# from detectron2 import model_zoo
-# from detectron2.config import get_cfg
-# from detectron2.engine import DefaultPredictor
-# from detectron2.utils.logger import setup_logger
-
-from service.video.BaseVideoAnalyzer import BaseVideoAnalyzer
-
-
-# def get_resolution(filename):
-#     command = ['ffprobe', '-v', 'error', '-select_streams', 'v:0',
-#                '-show_entries', 'stream=width,height', '-of', 'csv=p=0', filename]
-#     pipe = sp.Popen(command, stdout=sp.PIPE, bufsize=-1)
-#     for line in pipe.stdout:
-#         w, h = line.decode().strip().split(',')
-#         return int(w), int(h)
-
-
-# def read_video(filename):
-#     w, h = get_resolution(filename)
-#
-#     command = ['ffmpeg',
-#                '-i', filename,
-#                '-f', 'image2pipe',
-#                '-pix_fmt', 'bgr24',
-#                '-vsync', '0',
-#                '-vcodec', 'rawvideo', '-']
-#
-#     pipe = sp.Popen(command, stdout=sp.PIPE, bufsize=-1)
-#     while True:
-#         data = pipe.stdout.read(w * h * 3)
-#         if not data:
-#             break
-#         yield np.frombuffer(data, dtype='uint8').reshape((h, w, 3))
-#
-#
-# def run_3d(file_name):
-#     cfg = get_cfg()
-#     cfg_path = 'COCO-Keypoints/keypoint_rcnn_R_101_FPN_3x.yaml'
-#     cfg.merge_from_file(model_zoo.get_config_file(cfg_path))
-#     cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.7
-#     cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(cfg_path)
-#     predictor = DefaultPredictor(cfg)
-#     input_folder = file_name
-#     output_folder = file_name.replace(os.path.basename(file_name), "")
-#
-#     if os.path.isdir(input_folder):
-#         im_list = glob.iglob(input_folder + '/*.mp4')
-#     else:
-#         im_list = [input_folder]
-#
-#     for video_name in im_list:
-#         out_name = os.path.join(
-#             output_folder, os.path.basename(video_name)
-#         )
-#         print('Processing {}'.format(video_name))
-#
-#         boxes = []
-#         segments = []
-#         keypoints = []
-#
-#         for frame_i, im in enumerate(read_video(video_name)):
-#             t = time.time()
-#             outputs = predictor(im)['instances'].to('cpu')
-#
-#             print('Frame {} processed in {:.3f}s'.format(frame_i, time.time() - t))
-#
-#             has_bbox = False
-#             if outputs.has('pred_boxes'):
-#                 bbox_tensor = outputs.pred_boxes.tensor.numpy()
-#                 if len(bbox_tensor) > 0:
-#                     has_bbox = True
-#                     scores = outputs.scores.numpy()[:, None]
-#                     bbox_tensor = np.concatenate((bbox_tensor, scores), axis=1)
-#             if has_bbox:
-#                 kps = outputs.pred_keypoints.numpy()
-#                 kps_xy = kps[:, :, :2]
-#                 kps_prob = kps[:, :, 2:3]
-#                 kps_logit = np.zeros_like(kps_prob)  # Dummy
-#                 kps = np.concatenate((kps_xy, kps_logit, kps_prob), axis=2)
-#                 kps = kps.transpose(0, 2, 1)
-#             else:
-#                 kps = []
-#                 bbox_tensor = []
-#
-#             # Mimic Detectron1 format
-#             cls_boxes = [[], bbox_tensor]
-#             cls_keyps = [[], kps]
-#
-#             boxes.append(cls_boxes)
-#             segments.append(None)
-#             keypoints.append(cls_keyps)
-#
-#         # Video resolution
-#         metadata = {
-#             'w': im.shape[1],
-#             'h': im.shape[0],
-#         }
-#
-#         np.savez_compressed(out_name, boxes=boxes, segments=segments, keypoints=keypoints, metadata=metadata)
-#
-#
-# def do_analysis(a_path, video_uuid, mode):
-#     # tur = os.path.split(path)
-#     try:
-#         os.mkdir(UPLOAD_DIR + "./frames/" + video_uuid)
-#     except:
-#         pass
-#
-#     # source_npy_side = a_path
-#
-#     # output = open("./cap_file/" + name + "/file2" + ".txt", "w")
-#     # output.close()
-#
-#     result = {}
-#     p = './capture_image/' + name + "/"
-#     lenF = int(len(glob.glob(p + '*.png')) / 2)
-#     # 对每一张图片的body_25点数据进行分析
-#     for i in range(1, lenF):  # run_openpose_for_normal(i)
-#         if (mode == "jump"):
-#             result_side = analyse_npy_side_jump(name, i, source_npy_side.format(i))
-#         elif (mode == "pingban"):
-#             result_side = analyse_npy_side_pingban(name, i, source_npy_side.format(i))
-#         elif (mode == "juanfu"):
-#             result_side = analyse_npy_side_juanfu(name, i, source_npy_side.format(i))
-#         elif (mode == "gaotaitui"):
-#             result_side = analyse_npy_side_gaotaitui(name, i, source_npy_side.format(i))
-#         elif (mode == "shendun"):
-#             result_side = analyse_npy_side_shendun(name, i, source_npy_side.format(i))
-#
-#         if (result_side != False):
-#             result[i] = result_side
-#             # print(result[i])
-#
-#     output = open("./cap_file/" + name + "/file1.txt", "w")
-#     for re in result:
-#         print(re, file=output)
-#         for (name, value) in result[re].items():
-#             print(name, value, sep=',', file=output)
-#         print("kv-over", file=output)
-#     output.close()
-
-
-class Video3DAnalyzer(BaseVideoAnalyzer):
-    """Perform inference on a single video"""
-
-    def __init__(self):
-        super().__init__()
-
-    def analyze(self, filename):
-        pass
-        # setup_logger()
-        # return run_3d(filename)
-
-
-if __name__ == '__main__':
-    split_video("original")
-    run_openpose_for_frames("original")

backend_refactor/service/video_analyzer.py

@@ -0,0 +1,146 @@
+import os
+from typing import Callable
+from config import UPLOAD_DIR
+import cv2
+import logging
+import numpy as np
+
+
+def split_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
+    logging.debug("Splitting video %s, FPS: %s" % (video_path, FPS))
+
+    c = 1
+    sampling_fps = 1
+
+    while True:
+        ret, frame = cap.read()
+        if ret:
+            if c % sampling_fps == 0:
+                target_path = frames_dir + str(c) + ".jpg"
+                if not os.path.exists(target_path):
+                    cv2.imwrite(target_path, frame)
+                    logging.debug("Writing frame %s, %s" % (c, target_path))
+            c += 1
+        else:
+            break
+
+    cap.release()
+
+
+from service.aiutil.torch_openpose import torch_openpose
+from service.aiutil.util import draw_bodypose
+
+
+def run_openpose_for_frames(video_uuid):
+    tp = torch_openpose('body_25')
+
+    frames_dir = UPLOAD_DIR + "frames/" + video_uuid + "/"
+    for i in os.listdir(frames_dir):
+        if i.endswith(".jpg") and "result" not in i:
+
+            if os.path.exists(frames_dir + i.replace(".jpg", ".result.jpg")) and os.path.exists(
+                    frames_dir + i + ".npy"):
+                continue
+
+            logging.debug("Running openpose for %s %s" % (video_uuid, i))
+
+            oriImg = cv2.imread(frames_dir + i)
+            poses = tp(oriImg)
+            np.save(frames_dir + i + ".npy", poses)
+
+            canvas = draw_bodypose(oriImg, poses, 'body_25')
+
+            cv2.imwrite(frames_dir + i.replace(".jpg", ".result.jpg"), canvas)
+
+
+class BaseVideoAnalyzer:
+    def __init__(self, video_uuid):
+        self.video_uuid = video_uuid
+
+    def analyze(self, callback: Callable):
+        try:
+            callback("RUNNING")
+            split_video(self.video_uuid)
+            run_openpose_for_frames(self.video_uuid)
+            callback("FINISHED", result={})
+        except Exception as e:
+            callback("ERROR", error=e)
+            raise e
+
+
+class HighKneesVideoAnalyzer(BaseVideoAnalyzer):
+    def __init__(self, video_uuid):
+        super().__init__(video_uuid)
+
+    def analyze(self, callback: Callable):
+        try:
+            callback("RUNNING")
+
+            callback("FINISHED", result={})
+        except Exception as e:
+            callback("ERROR", error=e)
+            raise e
+
+
+class CrunchVideoAnalyzer(BaseVideoAnalyzer):
+    def __init__(self, video_uuid):
+        super().__init__(video_uuid)
+
+    def analyze(self, callback: Callable):
+        try:
+            callback("RUNNING")
+
+            callback("FINISHED", result={})
+        except Exception as e:
+            callback("ERROR", error=e)
+            raise e
+
+
+class StandingLongJumpVideoAnalyzer(BaseVideoAnalyzer):
+    def __init__(self, video_uuid):
+        super().__init__(video_uuid)
+
+    def analyze(self, callback: Callable):
+        try:
+            callback("RUNNING")
+
+            callback("FINISHED", result={})
+        except Exception as e:
+            callback("ERROR", error=e)
+            raise e
+
+
+class PlankVideoAnalyzer(BaseVideoAnalyzer):
+    def __init__(self, video_uuid):
+        super().__init__(video_uuid)
+
+    def analyze(self, callback: Callable):
+        try:
+            callback("RUNNING")
+
+            callback("FINISHED", result={})
+        except Exception as e:
+            callback("ERROR", error=e)
+            raise e
+
+
+class SquatVideoAnalyzer(BaseVideoAnalyzer):
+    def __init__(self, video_uuid):
+        super().__init__(video_uuid)
+
+    def analyze(self, callback: Callable):
+        try:
+            callback("RUNNING")
+
+            callback("FINISHED", result={})
+        except Exception as e:
+            callback("ERROR", error=e)
+            raise e