Update app_utils.py

app_utils.py

@@ -87,7 +87,7 @@ def preprocess_video_and_predict(video):
 
 
 #to return scores
-def preprocess_video_and_rank(video):
+def video_score(video):
     
     cap = cv2.VideoCapture(video)
     w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
@@ -246,173 +246,334 @@ def preprocess_video_and_rank(video):
     return stat,scores_str,"data/audio.wav"
 
 ###########################################################################################################################
-def video_score(video):
-    cap = cv2.VideoCapture(video)
-    w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    fps = np.round(cap.get(cv2.CAP_PROP_FPS))
-
-    path_save_video_face = 'result_face.mp4'
-    vid_writer_face = cv2.VideoWriter(path_save_video_face, cv2.VideoWriter_fourcc(*'mp4v'), fps, (224, 224))
-
-    # path_save_video_hm = 'result_hm.mp4'
-    # vid_writer_hm = cv2.VideoWriter(path_save_video_hm, cv2.VideoWriter_fourcc(*'mp4v'), fps, (224, 224))
-
-    lstm_features = []
-    count_frame = 1
-    count_face = 0
-    probs = []
-    frames = []
-    last_output = None
-    last_heatmap = None 
-    cur_face = None
-
-    with mp_face_mesh.FaceMesh(
-    max_num_faces=1,
-    refine_landmarks=False,
-    min_detection_confidence=0.5,
-    min_tracking_confidence=0.5) as face_mesh:
-
-        while cap.isOpened():
-            _, frame = cap.read()
-            if frame is None: break
-
-            frame_copy = frame.copy()
-            frame_copy.flags.writeable = False
-            frame_copy = cv2.cvtColor(frame_copy, cv2.COLOR_BGR2RGB)
-            results = face_mesh.process(frame_copy)
-            frame_copy.flags.writeable = True
-
-            if results.multi_face_landmarks:
-                for fl in results.multi_face_landmarks:
-                    startX, startY, endX, endY  = get_box(fl, w, h)
-                    cur_face = frame_copy[startY:endY, startX: endX]
-
-                    if count_face%config_data.FRAME_DOWNSAMPLING == 0:
-                        cur_face_copy = pth_processing(Image.fromarray(cur_face))
-                        with torch.no_grad():
-                            features = torch.nn.functional.relu(pth_model_static.extract_features(cur_face_copy)).detach().numpy()
-
-                        # grayscale_cam = cam(input_tensor=cur_face_copy)
-                        # grayscale_cam = grayscale_cam[0, :]
-                        # cur_face_hm = cv2.resize(cur_face,(224,224), interpolation = cv2.INTER_AREA)
-                        # cur_face_hm = np.float32(cur_face_hm) / 255
-                        # heatmap = show_cam_on_image(cur_face_hm, grayscale_cam, use_rgb=False)
-                        # last_heatmap = heatmap
+# def video_score(video):
+#     cap = cv2.VideoCapture(video)
+#     w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+#     h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+#     fps = np.round(cap.get(cv2.CAP_PROP_FPS))
+
+#     path_save_video_face = 'result_face.mp4'
+#     vid_writer_face = cv2.VideoWriter(path_save_video_face, cv2.VideoWriter_fourcc(*'mp4v'), fps, (224, 224))
+
+#     # path_save_video_hm = 'result_hm.mp4'
+#     # vid_writer_hm = cv2.VideoWriter(path_save_video_hm, cv2.VideoWriter_fourcc(*'mp4v'), fps, (224, 224))
+
+#     lstm_features = []
+#     count_frame = 1
+#     count_face = 0
+#     probs = []
+#     frames = []
+#     last_output = None
+#     last_heatmap = None 
+#     cur_face = None
+
+#     with mp_face_mesh.FaceMesh(
+#     max_num_faces=1,
+#     refine_landmarks=False,
+#     min_detection_confidence=0.5,
+#     min_tracking_confidence=0.5) as face_mesh:
+
+#         while cap.isOpened():
+#             _, frame = cap.read()
+#             if frame is None: break
+
+#             frame_copy = frame.copy()
+#             frame_copy.flags.writeable = False
+#             frame_copy = cv2.cvtColor(frame_copy, cv2.COLOR_BGR2RGB)
+#             results = face_mesh.process(frame_copy)
+#             frame_copy.flags.writeable = True
+
+#             if results.multi_face_landmarks:
+#                 for fl in results.multi_face_landmarks:
+#                     startX, startY, endX, endY  = get_box(fl, w, h)
+#                     cur_face = frame_copy[startY:endY, startX: endX]
+
+#                     if count_face%config_data.FRAME_DOWNSAMPLING == 0:
+#                         cur_face_copy = pth_processing(Image.fromarray(cur_face))
+#                         with torch.no_grad():
+#                             features = torch.nn.functional.relu(pth_model_static.extract_features(cur_face_copy)).detach().numpy()
+
+#                         # grayscale_cam = cam(input_tensor=cur_face_copy)
+#                         # grayscale_cam = grayscale_cam[0, :]
+#                         # cur_face_hm = cv2.resize(cur_face,(224,224), interpolation = cv2.INTER_AREA)
+#                         # cur_face_hm = np.float32(cur_face_hm) / 255
+#                         # heatmap = show_cam_on_image(cur_face_hm, grayscale_cam, use_rgb=False)
+#                         # last_heatmap = heatmap
         
-                        if len(lstm_features) == 0:
-                            lstm_features = [features]*10
-                        else:
-                            lstm_features = lstm_features[1:] + [features]
-
-                        lstm_f = torch.from_numpy(np.vstack(lstm_features))
-                        lstm_f = torch.unsqueeze(lstm_f, 0)
-                        with torch.no_grad():
-                            output = pth_model_dynamic(lstm_f).detach().numpy()
-                        last_output = output
-
-                        if count_face == 0:
-                            count_face += 1
-
-                    else:
-                        if last_output is not None:
-                            output = last_output
-                            # heatmap = last_heatmap
-
-                        elif last_output is None:
-                            output = np.empty((1, 7))
-                            output[:] = np.nan
+#                         if len(lstm_features) == 0:
+#                             lstm_features = [features]*10
+#                         else:
+#                             lstm_features = lstm_features[1:] + [features]
+
+#                         lstm_f = torch.from_numpy(np.vstack(lstm_features))
+#                         lstm_f = torch.unsqueeze(lstm_f, 0)
+#                         with torch.no_grad():
+#                             output = pth_model_dynamic(lstm_f).detach().numpy()
+#                         last_output = output
+
+#                         if count_face == 0:
+#                             count_face += 1
+
+#                     else:
+#                         if last_output is not None:
+#                             output = last_output
+#                             # heatmap = last_heatmap
+
+#                         elif last_output is None:
+#                             output = np.empty((1, 7))
+#                             output[:] = np.nan
                             
-                    probs.append(output[0])
-                    frames.append(count_frame)
-            else:
-                if last_output is not None:
-                    lstm_features = []
-                    empty = np.empty((7))
-                    empty[:] = np.nan
-                    probs.append(empty)
-                    frames.append(count_frame)                        
-
-            if cur_face is not None:
-                # heatmap_f = display_info(heatmap, 'Frame: {}'.format(count_frame), box_scale=.3)
-
-                cur_face = cv2.cvtColor(cur_face, cv2.COLOR_RGB2BGR)
-                cur_face = cv2.resize(cur_face, (224,224), interpolation = cv2.INTER_AREA)
-                cur_face = display_info(cur_face, 'Frame: {}'.format(count_frame), box_scale=.3)
-                vid_writer_face.write(cur_face)
-                # vid_writer_hm.write(heatmap_f)
-
-            count_frame += 1
-            if count_face != 0:
-                count_face += 1
+#                     probs.append(output[0])
+#                     frames.append(count_frame)
+#             else:
+#                 if last_output is not None:
+#                     lstm_features = []
+#                     empty = np.empty((7))
+#                     empty[:] = np.nan
+#                     probs.append(empty)
+#                     frames.append(count_frame)                        
+
+#             if cur_face is not None:
+#                 # heatmap_f = display_info(heatmap, 'Frame: {}'.format(count_frame), box_scale=.3)
+
+#                 cur_face = cv2.cvtColor(cur_face, cv2.COLOR_RGB2BGR)
+#                 cur_face = cv2.resize(cur_face, (224,224), interpolation = cv2.INTER_AREA)
+#                 cur_face = display_info(cur_face, 'Frame: {}'.format(count_frame), box_scale=.3)
+#                 vid_writer_face.write(cur_face)
+#                 # vid_writer_hm.write(heatmap_f)
+
+#             count_frame += 1
+#             if count_face != 0:
+#                 count_face += 1
+
+#         vid_writer_face.release()
+#         # vid_writer_hm.release()
+
+#         stat = statistics_plot(frames, probs)
+
+#         if not stat:
+#             return None, None
+
+#     #for debug
+#     print(type(frames))
+#     print(frames)
+#     print(type(probs))
+#     print(probs)        
+#     # to calculate scores
+#     nan=float('nan')
+#     s1 = 0
+#     s2 = 0
+#     s3 = 0
+#     s4 = 0
+#     s5 = 0
+#     s6 = 0
+#     s7 = 0
+#     frames_len=len(frames)
+#     for i in range(frames_len):
+#         if np.isnan(probs[i][0]):
+#             frames_len=frames_len-1
+#         else: 
+#             s1=s1+probs[i][0]
+#             s2=s2+probs[i][1]
+#             s3=s3+probs[i][2]
+#             s4=s4+probs[i][3]
+#             s5=s5+probs[i][4]
+#             s6=s6+probs[i][5]
+#             s7=s7+probs[i][6]
+#     s1=s1/frames_len
+#     s2=s2/frames_len
+#     s3=s3/frames_len
+#     s4=s4/frames_len
+#     s5=s5/frames_len
+#     s6=s6/frames_len
+#     s7=s7/frames_len
+#     prob=[s1,s2,s3,s4,s5,s6,s7]
+#     prob_str=str(prob)
+#     with open("local_data/data.txt",'a', encoding="utf8") as f:
+#         f.write(prob_str+'\n')
+
+#     with open("local_data/data.txt",'r', encoding="utf8") as f:
+#         for i in f:
+#             print(i)
+#     #平衡点值为零，越正越负面
+#     score1=0*prob[0]-8*prob[1]+4*prob[2]+0*prob[3]+2*prob[4]+2*prob[5]+4*prob[6]
+#     print("score1=",score1)
+    
+#     #trans the audio file
+#     my_audio_clip = AudioFileClip(video)
+#     my_audio_clip.write_audiofile("newaudio.wav",ffmpeg_params=["-ac","1"])
+    
+#     # Audio="data/audio.wav"
+#     # text,prob2,label,path=classify_continuous(Audio)
+#     #0是抑郁概率，1是非抑郁概率
+#     # score2=10*prob2[0]-10*prob[1]
+#     # print(prob2,label)
+#     # score2=0
+#     # print("score2=",score2)
+
+#     # text_result="demo"
+#     # # text_result=text_api(text)
+#     # print(text_result)
+    
+#     return score1
 
-        vid_writer_face.release()
-        # vid_writer_hm.release()
 
-        stat = statistics_plot(frames, probs)
 
-        if not stat:
-            return None, None
-
-    #for debug
-    print(type(frames))
-    print(frames)
-    print(type(probs))
-    print(probs)        
-    # to calculate scores
-    nan=float('nan')
-    s1 = 0
-    s2 = 0
-    s3 = 0
-    s4 = 0
-    s5 = 0
-    s6 = 0
-    s7 = 0
-    frames_len=len(frames)
-    for i in range(frames_len):
-        if np.isnan(probs[i][0]):
-            frames_len=frames_len-1
-        else: 
-            s1=s1+probs[i][0]
-            s2=s2+probs[i][1]
-            s3=s3+probs[i][2]
-            s4=s4+probs[i][3]
-            s5=s5+probs[i][4]
-            s6=s6+probs[i][5]
-            s7=s7+probs[i][6]
-    s1=s1/frames_len
-    s2=s2/frames_len
-    s3=s3/frames_len
-    s4=s4/frames_len
-    s5=s5/frames_len
-    s6=s6/frames_len
-    s7=s7/frames_len
-    prob=[s1,s2,s3,s4,s5,s6,s7]
-    prob_str=str(prob)
-    with open("local_data/data.txt",'a', encoding="utf8") as f:
-        f.write(prob_str+'\n')
-
-    with open("local_data/data.txt",'r', encoding="utf8") as f:
-        for i in f:
-            print(i)
-    #平衡点值为零，越正越负面
-    score1=0*prob[0]-8*prob[1]+4*prob[2]+0*prob[3]+2*prob[4]+2*prob[5]+4*prob[6]
-    print("score1=",score1)
+#可以运行的代码，誊抄用
+# def preprocess_video_and_rank(video):
     
-    #trans the audio file
-    my_audio_clip = AudioFileClip(video)
-    my_audio_clip.write_audiofile("newaudio.wav",ffmpeg_params=["-ac","1"])
-    
-    # Audio="data/audio.wav"
-    # text,prob2,label,path=classify_continuous(Audio)
-    #0是抑郁概率，1是非抑郁概率
-    # score2=10*prob2[0]-10*prob[1]
-    # print(prob2,label)
-    # score2=0
-    # print("score2=",score2)
-
-    # text_result="demo"
-    # # text_result=text_api(text)
-    # print(text_result)
+#     cap = cv2.VideoCapture(video)
+#     w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+#     h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+#     fps = np.round(cap.get(cv2.CAP_PROP_FPS))
+
+#     path_save_video_face = 'result_face.mp4'
+#     vid_writer_face = cv2.VideoWriter(path_save_video_face, cv2.VideoWriter_fourcc(*'mp4v'), fps, (224, 224))
+
+#     # path_save_video_hm = 'result_hm.mp4'
+#     # vid_writer_hm = cv2.VideoWriter(path_save_video_hm, cv2.VideoWriter_fourcc(*'mp4v'), fps, (224, 224))
+
+#     lstm_features = []
+#     count_frame = 1
+#     count_face = 0
+#     probs = []
+#     frames = []
+#     last_output = None
+#     last_heatmap = None 
+#     cur_face = None
+
+#     with mp_face_mesh.FaceMesh(
+#     max_num_faces=1,
+#     refine_landmarks=False,
+#     min_detection_confidence=0.5,
+#     min_tracking_confidence=0.5) as face_mesh:
+
+#         while cap.isOpened():
+#             _, frame = cap.read()
+#             if frame is None: break
+
+#             frame_copy = frame.copy()
+#             frame_copy.flags.writeable = False
+#             frame_copy = cv2.cvtColor(frame_copy, cv2.COLOR_BGR2RGB)
+#             results = face_mesh.process(frame_copy)
+#             frame_copy.flags.writeable = True
+
+#             if results.multi_face_landmarks:
+#                 for fl in results.multi_face_landmarks:
+#                     startX, startY, endX, endY  = get_box(fl, w, h)
+#                     cur_face = frame_copy[startY:endY, startX: endX]
+
+#                     if count_face%config_data.FRAME_DOWNSAMPLING == 0:
+#                         cur_face_copy = pth_processing(Image.fromarray(cur_face))
+#                         with torch.no_grad():
+#                             features = torch.nn.functional.relu(pth_model_static.extract_features(cur_face_copy)).detach().numpy()
+
+#                         # grayscale_cam = cam(input_tensor=cur_face_copy)
+#                         # grayscale_cam = grayscale_cam[0, :]
+#                         # cur_face_hm = cv2.resize(cur_face,(224,224), interpolation = cv2.INTER_AREA)
+#                         # cur_face_hm = np.float32(cur_face_hm) / 255
+#                         # heatmap = show_cam_on_image(cur_face_hm, grayscale_cam, use_rgb=False)
+#                         # last_heatmap = heatmap
+        
+#                         if len(lstm_features) == 0:
+#                             lstm_features = [features]*10
+#                         else:
+#                             lstm_features = lstm_features[1:] + [features]
+
+#                         lstm_f = torch.from_numpy(np.vstack(lstm_features))
+#                         lstm_f = torch.unsqueeze(lstm_f, 0)
+#                         with torch.no_grad():
+#                             output = pth_model_dynamic(lstm_f).detach().numpy()
+#                         last_output = output
+
+#                         if count_face == 0:
+#                             count_face += 1
+
+#                     else:
+#                         if last_output is not None:
+#                             output = last_output
+#                             # heatmap = last_heatmap
+
+#                         elif last_output is None:
+#                             output = np.empty((1, 7))
+#                             output[:] = np.nan
+                            
+#                     probs.append(output[0])
+#                     frames.append(count_frame)
+#             else:
+#                 if last_output is not None:
+#                     lstm_features = []
+#                     empty = np.empty((7))
+#                     empty[:] = np.nan
+#                     probs.append(empty)
+#                     frames.append(count_frame)                        
+
+#             if cur_face is not None:
+#                 # heatmap_f = display_info(heatmap, 'Frame: {}'.format(count_frame), box_scale=.3)
+
+#                 cur_face = cv2.cvtColor(cur_face, cv2.COLOR_RGB2BGR)
+#                 cur_face = cv2.resize(cur_face, (224,224), interpolation = cv2.INTER_AREA)
+#                 cur_face = display_info(cur_face, 'Frame: {}'.format(count_frame), box_scale=.3)
+#                 vid_writer_face.write(cur_face)
+#                 # vid_writer_hm.write(heatmap_f)
+
+#             count_frame += 1
+#             if count_face != 0:
+#                 count_face += 1
+
+#         vid_writer_face.release()
+#         # vid_writer_hm.release()
+
+#         stat = statistics_plot(frames, probs)
+
+#         if not stat:
+#             return None, None
+
+#     #for debug
+#     print(type(frames))
+#     print(frames)
+#     print(type(probs))
+#     print(probs)        
+#     # to calculate scores
+#     nan=float('nan')
+#     s1 = 0
+#     s2 = 0
+#     s3 = 0
+#     s4 = 0
+#     s5 = 0
+#     s6 = 0
+#     s7 = 0
+#     frames_len=len(frames)
+#     for i in range(frames_len):
+#         if np.isnan(probs[i][0]):
+#             frames_len=frames_len-1
+#         else: 
+#             s1=s1+probs[i][0]
+#             s2=s2+probs[i][1]
+#             s3=s3+probs[i][2]
+#             s4=s4+probs[i][3]
+#             s5=s5+probs[i][4]
+#             s6=s6+probs[i][5]
+#             s7=s7+probs[i][6]
+#     s1=s1/frames_len
+#     s2=s2/frames_len
+#     s3=s3/frames_len
+#     s4=s4/frames_len
+#     s5=s5/frames_len
+#     s6=s6/frames_len
+#     s7=s7/frames_len
+#     scores=[s1,s2,s3,s4,s5,s6,s7]
+#     scores_str=str(scores)
+#     with open("local_data/data.txt",'a', encoding="utf8") as f:
+#         f.write(scores_str+'\n')
+
+#     with open("local_data/data.txt",'r', encoding="utf8") as f:
+#         for i in f:
+#             print(i)
+
+
+#     #trans the audio file
+#     my_audio_clip = AudioFileClip(video)
+#     my_audio_clip.write_audiofile("data/audio.wav",ffmpeg_params=["-ac","1"])
     
-    return score1
+#     return stat,scores_str,"data/audio.wav"