utils.py

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