""" 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