import cv2 import numpy as np from scipy import signal import os import subprocess import tempfile CROP_SCALE = 0.4 WINDOW_MARGIN = 12 START_IDX, STOP_IDX = 3, 5 STABLE_POINTS = (36, 45, 33, 48, 54) CROP_HEIGHT, CROP_WIDTH = 96, 96 # PATH='/home/users/u100438/home200093/dataset_release/' REFERENCE = np.load(os.path.join( os.path.dirname(__file__), '20words_mean_face.npy')) def crop_and_save_audio(mp4_path: str, saving_path:str, start_audio: float, end_audio: float) -> None: """ Crops original audio corresponding to the start and end time. Saves it as wav file with single channel and 16kHz sampling rate. :param mp4_path: str, path to original video. :param saving_path: str, path where audio will be saved. SHOULD END WITH .wav :param start_audio: float, start time of clip in seconds :param end_audio: float, end time of clip in seconds :return: None. """ # write audio. command = f"ffmpeg -loglevel error -y -i {mp4_path} -ss {start_audio} -to {end_audio} -vn -acodec pcm_s16le -ar 16000 -ac 1 {saving_path}" subprocess.call(command, shell=True) def crop_video(vid_path: str, clip_data: dict): ''' Reads the video frames of video (in vid_path) between clip_data['start'] and clip_data['end'] times. Crops the faces in these frames using bounding boxes given by clip_data['bboxs'] Returns sequence of faces and clip['landmarks'] aligned to 224x224 resolution. ''' cap = cv2.VideoCapture(vid_path) frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) num_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) start_frame, end_frame = round(clip_data['start']*25), round(clip_data['end']*25) clip_frames = end_frame - start_frame assert end_frame <= num_frames, f'End frame ({end_frame}) exceeds total number of frames ({num_frames})' landmarks_n, bboxs_n = np.array(clip_data['landmarks']), np.array(clip_data['bboxs']) bboxs = np.multiply(bboxs_n, [frame_width, frame_height, frame_width, frame_height]) landmarks = np.multiply(landmarks_n, [frame_width, frame_height]) assert len(landmarks) == clip_frames, f'Landmarks length ({len(landmarks)}) does not match the number of frames in the clip ({clip_frames})' dets = {'x':[], 'y':[], 's':[]} for det in bboxs: dets['s'].append(max((det[3]-det[1]),(det[2]-det[0]))/2) dets['y'].append((det[1]+det[3])/2) # crop center x dets['x'].append((det[0]+det[2])/2) # crop center y # Smooth detections dets['s'] = signal.medfilt(dets['s'],kernel_size=13) dets['x'] = signal.medfilt(dets['x'],kernel_size=13) dets['y'] = signal.medfilt(dets['y'],kernel_size=13) image_seq = [] current_frame = start_frame cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame) while current_frame < end_frame: ret, frame = cap.read() count = current_frame - start_frame current_frame += 1 if not ret: break bs = dets['s'][count] # Detection box size bsi = int(bs*(1+2*CROP_SCALE)) # Pad videos by this amount image = frame lands = landmarks[count] frame_ = np.pad(image,((bsi,bsi),(bsi,bsi),(0,0)), 'constant', constant_values=(110,110)) my = dets['y'][count]+bsi # BBox center Y mx = dets['x'][count]+bsi # BBox center X face = frame_[int(my-bs):int(my+bs*(1+2*CROP_SCALE)),int(mx-bs*(1+CROP_SCALE)):int(mx+bs*(1+CROP_SCALE))] ## lands translation and scaling lands[:,0] -= int(mx-bs*(1+CROP_SCALE) - bsi) lands[:,1] -= int(my - bs - bsi) lands[:,0] *= (224/face.shape[1]) lands[:,1] *= (224/face.shape[0]) image_seq.append(cv2.resize(face,(224,224))) image_seq = np.array(image_seq) return image_seq, landmarks def landmarks_interpolate(landmarks): """landmarks_interpolate. :param landmarks: List, the raw landmark (in-place) """ valid_frames_idx = [idx for idx, _ in enumerate(landmarks) if _ is not None] if not valid_frames_idx: return None for idx in range(1, len(valid_frames_idx)): if valid_frames_idx[idx] - valid_frames_idx[idx-1] == 1: continue else: landmarks = linear_interpolate(landmarks, valid_frames_idx[idx-1], valid_frames_idx[idx]) valid_frames_idx = [idx for idx, _ in enumerate(landmarks) if _ is not None] # -- Corner case: keep frames at the beginning or at the end failed to be detected. if valid_frames_idx: landmarks[:valid_frames_idx[0]] = [landmarks[valid_frames_idx[0]]] * valid_frames_idx[0] landmarks[valid_frames_idx[-1]:] = [landmarks[valid_frames_idx[-1]]] * (len(landmarks) - valid_frames_idx[-1]) valid_frames_idx = [idx for idx, _ in enumerate(landmarks) if _ is not None] assert len(valid_frames_idx) == len(landmarks), "not every frame has landmark" return landmarks def crop_patch(image_seq, landmarks): """crop_patch. :param video_pathname: str, the filename for the processed video. :param landmarks: List, the interpolated landmarks. """ frame_idx = 0 sequence = [] for frame in image_seq: window_margin = min(WINDOW_MARGIN // 2, frame_idx, len(landmarks) - 1 - frame_idx) smoothed_landmarks = np.mean([landmarks[x] for x in range(frame_idx - window_margin, frame_idx + window_margin + 1)], axis=0) smoothed_landmarks += landmarks[frame_idx].mean(axis=0) - smoothed_landmarks.mean(axis=0) transformed_frame, transformed_landmarks = affine_transform(frame, smoothed_landmarks, REFERENCE) sequence.append( cut_patch( transformed_frame, transformed_landmarks[START_IDX : STOP_IDX], CROP_HEIGHT//2, CROP_WIDTH//2,)) frame_idx += 1 return np.array(sequence) def affine_transform(frame, landmarks, reference, target_size=(256, 256), reference_size=(256, 256), stable_points=STABLE_POINTS, interpolation=cv2.INTER_LINEAR, border_mode=cv2.BORDER_CONSTANT, border_value=0 ): """affine_transform. :param frame: numpy.array, the input sequence. :param landmarks: List, the tracked landmarks. :param reference: numpy.array, the neutral reference frame. :param target_size: tuple, size of the output image. :param reference_size: tuple, size of the neural reference frame. :param stable_points: tuple, landmark idx for the stable points. :param interpolation: interpolation method to be used. :param border_mode: Pixel extrapolation method . :param border_value: Value used in case of a constant border. By default, it is 0. """ lands = [landmarks[x] for x in range(5)] stable_reference = np.vstack([reference[x] for x in stable_points]) stable_reference[:, 0] -= (reference_size[0] - target_size[0]) / 2.0 stable_reference[:, 1] -= (reference_size[1] - target_size[1]) / 2.0 # Warp the face patch and the landmarks transform = cv2.estimateAffinePartial2D(np.vstack(lands), stable_reference, method=cv2.LMEDS)[0] transformed_frame = cv2.warpAffine( frame, transform, dsize=(target_size[0], target_size[1]), flags=interpolation, borderMode=border_mode, borderValue=border_value, ) transformed_landmarks = np.matmul(landmarks, transform[:, :2].transpose()) + transform[:, 2].transpose() return transformed_frame, transformed_landmarks def cut_patch(img, landmarks, height, width, threshold=5): """cut_patch. :param img: ndarray, an input image. :param landmarks: ndarray, the corresponding landmarks for the input image. :param height: int, the distance from the centre to the side of of a bounding box. :param width: int, the distance from the centre to the side of of a bounding box. :param threshold: int, the threshold from the centre of a bounding box to the side of image. """ center_x, center_y = np.mean(landmarks, axis=0) if center_y - height < 0: center_y = height if center_y - height < 0 - threshold: raise Exception('too much bias in height') if center_x - width < 0: center_x = width if center_x - width < 0 - threshold: raise Exception('too much bias in width') if center_y + height > img.shape[0]: center_y = img.shape[0] - height if center_y + height > img.shape[0] + threshold: raise Exception('too much bias in height') if center_x + width > img.shape[1]: center_x = img.shape[1] - width if center_x + width > img.shape[1] + threshold: raise Exception('too much bias in width') cutted_img = np.copy(img[ int(round(center_y) - round(height)): int(round(center_y) + round(height)), int(round(center_x) - round(width)): int(round(center_x) + round(width))]) return cutted_img def crop_face(image_seq, landmarks): # Interpolate the landmarks preprocessed_landmarks = landmarks_interpolate(list(landmarks)) # crop the face to obtain a sequence of 96x96 sized mouth rois crop_seq = crop_patch(image_seq, preprocessed_landmarks) return crop_seq def merge_audio_video(tmp_path, audio_path, save_video_path): # Will merge the corresponding audio and video tracks of the clip. The associated .wav file will be removed. command = f"ffmpeg -loglevel error -y -i {tmp_path} -i {audio_path} -c:v libx264 -c:a aac -ar 16000 -ac 1 {save_video_path}" tval = subprocess.call(command, shell=True) tval = subprocess.call(f'rm {tmp_path}', shell=True) tval = subprocess.call(f'rm {audio_path}', shell=True) def convert_ffmpeg(vid_path): # converts the mpeg4 video to h264 using ffmpeg. Saves disk space, but takes additional time tmp_path = vid_path[:-4] + 'temp2.mp4' cmd = f"cp {vid_path} {tmp_path}" tval = subprocess.call(cmd, shell=True) cmd = f"ffmpeg -loglevel error -i {tmp_path} -r 25 -vcodec libx264 -q:v 1 -y {vid_path}" tval = subprocess.call(cmd, shell=True) tval = subprocess.call(f"rm {tmp_path}", shell=True) def write_video(save_video_path, crop_seq, audio_path=None, merge_audio=False, use_ffmpeg=False): # Writes the clip video to disk. Merges with audio if enabled tmp_path = save_video_path.replace('.mp4','_temp.mp4') if merge_audio else save_video_path vid_writer = cv2.VideoWriter(tmp_path, cv2.VideoWriter_fourcc(*'mp4v'), 25, (96, 96)) for ci in crop_seq: vid_writer.write(ci) vid_writer.release() if use_ffmpeg and not merge_audio: convert_ffmpeg(tmp_path) if merge_audio: merge_audio_video(tmp_path, audio_path, save_video_path)