| """ | |
| A utils module used in the actual evm module performing such tasks as | |
| pyramid construction, video io and filter application | |
| functions were originally written by flyingzhao but adapted for this module | |
| """ | |
| import cv2 | |
| import numpy as np | |
| import scipy.signal as signal | |
| import scipy.fftpack as fftpack | |
| def build_gaussian_pyramid(src, levels=3): | |
| """ | |
| Function: build_gaussian_pyramid | |
| -------------------------------- | |
| Builds a gaussian pyramid | |
| Args: | |
| ----- | |
| src: the input image | |
| levels: the number levels in the gaussian pyramid | |
| Returns: | |
| -------- | |
| A gaussian pyramid | |
| """ | |
| s=src.copy() | |
| pyramid=[s] | |
| for i in range(levels): | |
| s=cv2.pyrDown(s) | |
| pyramid.append(s) | |
| return pyramid | |
| def gaussian_video(video, levels=3): | |
| """ | |
| Function: gaussian_video | |
| ------------------------ | |
| generates a gaussian pyramid for each frame in a video | |
| Args: | |
| ----- | |
| video: the input video array | |
| levels: the number of levels in the gaussian pyramid | |
| Returns: | |
| -------- | |
| the gaussian video | |
| """ | |
| n = video.shape[0] | |
| for i in range(0, n): | |
| pyr = build_gaussian_pyramid(video[i], levels=levels) | |
| gaussian_frame=pyr[-1] | |
| if i==0: | |
| vid_data = np.zeros((n, *gaussian_frame.shape)) | |
| vid_data[i] = gaussian_frame | |
| return vid_data | |
| def reconstruct_video_g(amp_video, original_video, levels=3): | |
| """ | |
| Function: reconstruct_video_g | |
| ----------------------------- | |
| reconstructs a video from a gaussian pyramid and the original | |
| Args: | |
| ----- | |
| amp_video: the amplified gaussian video | |
| original_video: the original video | |
| levels: the levels in the gaussian video | |
| Returns: | |
| -------- | |
| the reconstructed video | |
| """ | |
| final_video = np.zeros(original_video.shape) | |
| for i in range(0, amp_video.shape[0]): | |
| img = amp_video[i] | |
| for x in range(levels): | |
| img = cv2.pyrUp(img) | |
| img = img + original_video[i] | |
| final_video[i] = img | |
| return final_video | |
| def build_laplacian_pyramid(src,levels=3): | |
| """ | |
| Function: build_laplacian_pyramid | |
| --------------------------------- | |
| Builds a Laplacian Pyramid | |
| Args: | |
| ----- | |
| src: the input image | |
| levels: the number levels in the laplacian pyramid | |
| Returns: | |
| -------- | |
| A Laplacian pyramid | |
| """ | |
| gaussianPyramid = build_gaussian_pyramid(src, levels) | |
| pyramid=[] | |
| for i in range(levels,0,-1): | |
| GE=cv2.pyrUp(gaussianPyramid[i]) | |
| L=cv2.subtract(gaussianPyramid[i-1],GE) | |
| pyramid.append(L) | |
| return pyramid | |
| def laplacian_video(video, levels=3): | |
| """ | |
| Function: laplacian_video | |
| ------------------------- | |
| generates a laplaican pyramid for each frame in a video | |
| Args: | |
| ----- | |
| video: the input video array | |
| levels: the number of levels for each laplacian pyramid | |
| Returns: | |
| -------- | |
| The laplacian video | |
| """ | |
| tensor_list=[] | |
| n = video.shape[0] | |
| for i in range(0, n): | |
| frame=video[i] | |
| pyr = build_laplacian_pyramid(frame,levels=levels) | |
| if i==0: | |
| for k in range(levels): | |
| tensor_list.append(np.zeros((n, *pyr[k].shape))) | |
| for n in range(levels): | |
| tensor_list[n][i] = pyr[n] | |
| return tensor_list | |
| def reconstruct_video_l(lap_pyr, levels=3): | |
| """ | |
| Function: reconstruct_video_l | |
| ----------------------------- | |
| reconstructs a video from a laplacian pyramid and the original | |
| Args: | |
| ----- | |
| lap_pyr: the amplified laplacian pyramid | |
| levels: the levels in the laplacian video | |
| Returns: | |
| -------- | |
| the reconstructed video | |
| """ | |
| final = np.zeros(lap_pyr[-1].shape) | |
| for i in range(lap_pyr[0].shape[0]): | |
| up = lap_pyr[0][i] | |
| for n in range(levels-1): | |
| up = cv2.pyrUp(up) + lap_pyr[n + 1][i] | |
| final[i] = up | |
| return final | |
| def save_video(video, filename='out.avi'): | |
| """ | |
| Function: save_video | |
| -------------------- | |
| saves a video to a file | |
| Args: | |
| ----- | |
| video: the numpy array representing the video | |
| filename: the name of the output file | |
| Returns: | |
| None | |
| """ | |
| fourcc = cv2.VideoWriter_fourcc('M','J','P','G') | |
| n, h, w, _ = video.shape | |
| writer = cv2.VideoWriter(filename, fourcc, 30, (w, h), 1) | |
| for i in range(0, n): | |
| writer.write(cv2.convertScaleAbs(video[i])) | |
| writer.release() | |
| def load_video(video_filename): | |
| """ | |
| Function: load_video | |
| -------------------- | |
| Loads a video from a file | |
| Args: | |
| ----- | |
| video_filename: the name of the video file | |
| Returns: | |
| -------- | |
| a numpy array with shape (num_frames, height, width, channels) | |
| the frame rate of the video | |
| """ | |
| cap = cv2.VideoCapture(video_filename) | |
| frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) | |
| width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) | |
| height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) | |
| fps = int(cap.get(cv2.CAP_PROP_FPS)) | |
| video = np.zeros((frame_count, height, width, 3), dtype='float') | |
| x = 0 | |
| while cap.isOpened(): | |
| ret, frame = cap.read() | |
| if ret is True: | |
| video[x] = frame | |
| x += 1 | |
| else: | |
| break | |
| return video, fps | |
| def temporal_ideal_filter(arr, low, high, fps, axis=0): | |
| """ | |
| Function: temporal_ideal_filter | |
| ------------------------------- | |
| Applies a temporal ideal filter to a numpy array | |
| Args: | |
| ----- | |
| arr: a numpy array with shape (N, H, W, C) | |
| N: number of frames | |
| H: height | |
| W: width | |
| C: channels | |
| low: the low frequency bound | |
| high: the high frequency bound | |
| fps: the video frame rate | |
| axis: the axis of video, should always be 0 | |
| Returns: | |
| -------- | |
| the array with the filter applied | |
| """ | |
| fft = fftpack.fft(arr, axis=axis) | |
| frequencies = fftpack.fftfreq(arr.shape[0], d=1.0 / fps) | |
| bound_low = (np.abs(frequencies - low)).argmin() | |
| bound_high = (np.abs(frequencies - high)).argmin() | |
| fft[:bound_low] = 0 | |
| fft[bound_high:-bound_high] = 0 | |
| fft[-bound_low:] = 0 | |
| iff=fftpack.ifft(fft, axis=axis) | |
| return np.abs(iff) | |
| def butter_bandpass_filter(data, lowcut, highcut, fs, order=5): | |
| """ | |
| Function: butter_bandpass_filter | |
| -------------------------------- | |
| applies a buttersworth bandpass filter | |
| Args: | |
| ----- | |
| data: the input data | |
| lowcut: the low cut value | |
| highcut: the high cut value | |
| fs: the frame rate in frames per second | |
| order: the order for butter | |
| Returns: | |
| -------- | |
| the result of the buttersworth bandpass filter | |
| """ | |
| omega = 0.5 * fs | |
| low = lowcut / omega | |
| high = highcut / omega | |
| b, a = signal.butter(order, [low, high], btype='band') | |
| y = signal.lfilter(b, a, data, axis=0) | |
| return y | |