File size: 4,762 Bytes
39b4c8c |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 |
import numpy as np
import cv2
#import scipy.fftpack as fftpack
import scipy
def gaussian_video(video, pyramid_levels):
"""Create a gaussian representation of a video"""
vid_data = None
for x in range(0, video.shape[0]):
frame = video[x]
gauss_copy = np.ndarray(shape=frame.shape, dtype="float")
gauss_copy[:] = frame
for i in range(pyramid_levels):
gauss_copy = gausPyrDown(gauss_copy)
if x == 0:
vid_data = np.zeros((video.shape[0], gauss_copy.shape[0], gauss_copy.shape[1], 3))
vid_data[x] = gauss_copy
return vid_data
def gausPyrDown(frame,sz=5,sigma=1):
height, width, channel = frame.shape
convFrame = np.zeros(shape=(height, width,channel), dtype="float")
kernel = gausKernel(sz=sz,sigma=sigma)
for channel_i in range(channel):
convFrame[:,:,channel_i] = scipy.ndimage.convolve(frame[:,:,channel_i],kernel)
downFrame = convFrame[::2,::2,:]
return downFrame
def gausPyrUp(frame,sz=5,sigma=1):
height, width, channel = frame.shape
upFrame = np.zeros(shape=(2*height, 2*width,channel), dtype="float")
kernel = gausKernel(sz=sz,sigma=sigma)
for channel_i in range(channel):
upFrame[::2,::2,channel_i] = frame[:,:,channel_i]
upFrame[:,:,channel_i] = scipy.ndimage.convolve(upFrame[:,:,channel_i],kernel*4)
return upFrame
# Define the Gaussian kernel
def gausKernel(sz = 5,sigma=1):
kernel = np.zeros((sz,sz))
### STUDENT: Implement the Gaussian kernel
sz_1 = int(sz/2)
for x in (np.arange(sz)-sz_1):
for y in (np.arange(sz)-sz_1):
ix,iy = x+sz_1,y+sz_1
kernel[ix,iy] = np.exp(-(x**2+y**2)/(2.0*sigma**2))
kernel = kernel / np.sum(kernel)
### STUDENT END
return kernel
# We will use your previously implemented temporal bandpass filter, so make sure it works！
def temporal_bandpass_filter(data, fps, freq_min=0.833, freq_max=1, axis=0):
# Inputs:
# data: video data of shape #frames x height x width x #channel (3,RGB)
# fps: frames per second (30)
# freq_min, freq_max: cut-off frequencies for bandpass filter
# axis: dimension along which to apply FFT (default:0,
# time domain <->for a single pixel along all frames)
# Output:
# Band-passed video data, with only frequency components (absolute value)
# between freq_min and freq_max preserved
# of shape #frames x height x width x #channel (3,RGB)
data_process = np.zeros(data.shape)
sample_interval = 1.0/fps
for x in range(data.shape[1]):
for y in range(data.shape[2]):
for z in range(data.shape[3]):
# the bandpass_filter is YOUR implementation!
data_process[:,x,y,z] = bandpass_filter(data[:,x,y,z], sample_interval, freq_min, freq_max)
return data_process
# Implement the temporal bandpass filter
def bandpass_filter(x, sample_interval, freq_min, freq_max):
# Inputs:
# x: temporal signal of shape (N,)
# sample_interval: the temporal sampling interval.
# freq_min, freq_max: cut-off frequencies for bandpass filter
# Output:
# Band-passed signal, with only frequency components (absolute value)
# between freq_min and freq_max preserved
### STUDENT: Implement the bandpass filter.
### Feel free to use numpy.fft.fft, numpy.fft.fftfreq, numpy.fft.ifft
X = np.fft.fft(x)
frequencies = np.fft.fftfreq(len(x), d=sample_interval)
bound_low = (np.abs(frequencies - freq_min)).argmin()
bound_high = (np.abs(frequencies - freq_max)).argmin()
X[:bound_low] = 0
X[bound_high:-bound_high] = 0
X[-bound_low:] = 0
band_pass_signal = np.abs(np.fft.ifft(X, axis=0))
### STUDENT END
return band_pass_signal
# Utility function: used to convert numpy array to comform with video format
def convertScaleAbs(frame):
outFrame = np.ndarray(shape=frame.shape, dtype="uint8")
for channel_i in range(3):
outFrame[:,:,channel_i] = np.clip(np.abs(frame[:,:,channel_i]),0,255).astype(np.uint8).copy()
return outFrame
def combine_pyramid_and_save(g_video, orig_video, enlarge_multiple, fps):
"""Combine a gaussian video representation with the original"""
width, height = orig_video.shape[2], orig_video.shape[1]
mag_data = np.zeros(orig_video.shape, dtype='uint8')
for x in range(0, g_video.shape[0]):
img = np.ndarray(shape=g_video[x].shape, dtype='float')
img[:] = g_video[x]
for i in range(enlarge_multiple):
img = gausPyrUp(img)
img[:height, :width] = img[:height, :width] + orig_video[x]
res = convertScaleAbs(img[:height, :width])
mag_data[x] = res
return mag_data
|