def part_5b():
"""Frame interpolation
Follow the instructions in the problem set instructions.
Place all your work in this file and this section.
"""
mc01 = cv2.imread(os.path.join(input_dir, 'MiniCooper', 'mc01.png'),
0) / 255.
mc02 = cv2.imread(os.path.join(input_dir, 'MiniCooper', 'mc02.png'),
0) / 255.
mc03 = cv2.imread(os.path.join(input_dir, 'MiniCooper', 'mc03.png'),
0) / 255.
levels = 8 # TODO: Define the number of levels
k_size = 20 # TODO: Select a kernel size
k_type = "gaussian" # TODO: Select a kernel type
sigma = 6 # TODO: Select a sigma value if you are using a gaussian kernel
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
# get the frames part b1
frames = interpolate(mc01, mc02, levels, k_size, k_type, sigma,
interpolation, border_mode)
cv2.imwrite(os.path.join(output_dir, "ps4-5-b-1.png"),
ps4.normalize_and_scale(frames))
# get the frames part b2
frames = interpolate(mc02, mc03, levels, k_size, k_type, sigma,
interpolation, border_mode)
cv2.imwrite(os.path.join(output_dir, "ps4-5-b-2.png"),
ps4.normalize_and_scale(frames))
def part_5b():
"""Frame interpolation
Follow the instructions in the problem set instructions.
Place all your work in this file and this section.
"""
mc01 = cv2.imread(os.path.join(input_dir, 'MiniCooper', 'mc01.png'),
0) / 255.
mc02 = cv2.imread(os.path.join(input_dir, 'MiniCooper', 'mc02.png'),
0) / 255.
mc03 = cv2.imread(os.path.join(input_dir, 'MiniCooper', 'mc03.png'),
0) / 255.
# Optional: smooth the images if LK doesn't work well on raw images
levels = 5 # TODO: Define the number of levels
k_size = 20 # TODO: Select a kernel size
k_type = "uniform" # TODO: Select a kernel type
sigma = 0 # TODO: Select a sigma value if you are using a gaussian kernel
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
u, v = ps4.hierarchical_lk(mc01, mc02, levels, k_size, k_type, sigma,
interpolation, border_mode)
# Flow image
shift_02 = ps4.warp(mc02, 0.8 * u, 0.8 * v, interpolation, border_mode)
shift_04 = ps4.warp(mc02, 0.6 * u, 0.6 * v, interpolation, border_mode)
shift_06 = ps4.warp(mc02, 0.4 * u, 0.4 * v, interpolation, border_mode)
shift_08 = ps4.warp(mc02, 0.2 * u, 0.2 * v, interpolation, border_mode)
u_v = np.vstack((np.hstack(
(mc01, shift_02, shift_04)), np.hstack((shift_06, shift_08, mc02))))
cv2.imwrite(os.path.join(output_dir, "ps4-5-b-1.png"),
ps4.normalize_and_scale(u_v))
# Optional: smooth the images if LK doesn't work well on raw images
levels = 6 # TODO: Define the number of levels
k_size = 60 # TODO: Select a kernel size
k_type = "uniform" # TODO: Select a kernel type
sigma = 9 # TODO: Select a sigma value if you are using a gaussian kernel
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
mc02g = cv2.GaussianBlur(mc02, ksize=(15, 15), sigmaX=sigma, sigmaY=sigma)
mc03g = cv2.GaussianBlur(mc03, ksize=(15, 15), sigmaX=sigma, sigmaY=sigma)
u, v = ps4.hierarchical_lk(mc02g, mc03g, levels, k_size, k_type, sigma,
interpolation, border_mode)
# Flow image
shift_02 = ps4.warp(mc03, 0.8 * u, 0.8 * v, interpolation, border_mode)
shift_04 = ps4.warp(mc03, 0.6 * u, 0.6 * v, interpolation, border_mode)
shift_06 = ps4.warp(mc03, 0.4 * u, 0.4 * v, interpolation, border_mode)
shift_08 = ps4.warp(mc03, 0.2 * u, 0.2 * v, interpolation, border_mode)
u_v = np.vstack((np.hstack(
(mc02, shift_02, shift_04)), np.hstack((shift_06, shift_08, mc03))))
cv2.imwrite(os.path.join(output_dir, "ps4-5-b-2.png"),
ps4.normalize_and_scale(u_v))
def part_6():
"""Challenge Problem
Follow the instructions in the problem set instructions.
Place all your work in this file and this section.
"""
skip = 2
video1 = 'input_videos/racecar.mp4'
print video1
image_gen1 = video_frame_generator(video1)
image1 = image_gen1.next()
for _ in range(skip):
image2 = image_gen1.next()
h1, w1 = image1.shape[:2]
frame_num = 1
out_path = "output/optic_flow_racecar.mp4"
video_out = mp4_video_writer(out_path, (w1, h1), fps=20)
frame_ct = 0
while (image2 is not None) and (frame_ct < 300):
frame_ct += 1
print "Processing frame {}".format(frame_num)
levels = 5 # TODO: Define the number of levels
k_size = 50 # TODO: Select a kernel size
k_type = "gaussian" # TODO: Select a kernel type
sigma = 20 # TODO: Select a sigma value if you are using a gaussian kernel
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
image1bw = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
image2bw = cv2.cvtColor(image2, cv2.COLOR_BGR2GRAY)
image1bw = ps4.normalize_and_scale(image1bw * 1., scale_range=(0, 1))
image2bw = ps4.normalize_and_scale(image2bw * 1., scale_range=(0, 1))
u20, v20 = ps4.hierarchical_lk(image1bw, image2bw, levels, k_size,
k_type, sigma, interpolation,
border_mode)
u_v = quiver(u20, v20, scale=3, stride=20)
image_out = image1.copy()
image_out[np.where(u_v > 10)] = 255
if frame_ct == 30:
cv2.imwrite(os.path.join(output_dir, "ps4-6-a-1.png"), image_out)
if frame_ct == 200:
cv2.imwrite(os.path.join(output_dir, "ps4-6-a-2.png"), image_out)
video_out.write(image_out)
image1 = image2.copy()
for _ in range(skip):
image2 = image_gen1.next()
frame_num += 1
video_out.release()
def part_5b():
"""Frame interpolation
Follow the instructions in the problem set instructions.
Place all your work in this file and this section.
"""
mc_01 = cv2.imread(os.path.join(input_dir, 'MiniCooper', 'mc01.png'),
0) / 255.
mc_02 = cv2.imread(os.path.join(input_dir, 'MiniCooper', 'mc02.png'),
0) / 255.
mc_03 = cv2.imread(os.path.join(input_dir, 'MiniCooper', 'mc03.png'),
0) / 255.
h, w = mc_01.shape
# ============b_1============
frames = interpolate_frames(mc_01, mc_02, levels=6, k_size=11)
frames = [ps4.normalize_and_scale(f) for f in frames]
combined = np.zeros((h * 2, w * 3), np.float32)
f_n = 0
for i in range(2):
for j in range(3):
combined[i * h:(i + 1) * h, j * w:(j + 1) * w] = frames[f_n]
f_n += 1
cv2.imwrite(os.path.join(output_dir, "ps4-5-b-1.png"), combined)
# for i, f in enumerate(frames):
# cv2.imwrite(os.path.join(output_dir, "ps4-5-b-1_{}.png".format(i)), f)
# ===========b_2=============
frames = interpolate_frames(mc_02, mc_03, levels=6, k_size=11)
frames = [ps4.normalize_and_scale(f) for f in frames]
combined = np.zeros((h * 2, w * 3), np.float32)
f_n = 0
for i in range(2):
for j in range(3):
combined[i * h:(i + 1) * h, j * w:(j + 1) * w] = frames[f_n]
f_n += 1
cv2.imwrite(os.path.join(output_dir, "ps4-5-b-2.png"), combined)
for i, f in enumerate(frames):
cv2.imwrite(os.path.join(output_dir, "ps4-5-b-2_{}.png".format(i)), f)
def part_5a():
"""Frame interpolation
Follow the instructions in the problem set instructions.
Place all your work in this file and this section.
"""
shift_0 = cv2.imread(os.path.join(input_dir, 'TestSeq', 'Shift0.png'),
0) / 255.
shift_r10 = cv2.imread(os.path.join(input_dir, 'TestSeq', 'ShiftR10.png'),
0) / 255.
levels = 6 # TODO: Define the number of levels
k_size = 60 # TODO: Select a kernel size
k_type = "uniform" # TODO: Select a kernel type
sigma = 0 # TODO: Select a sigma value if you are using a gaussian kernel
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
# get the frames
frames = interpolate(shift_0, shift_r10, levels, k_size, k_type, sigma,
interpolation, border_mode)
# Write out
cv2.imwrite(os.path.join(output_dir, "ps4-5-a-1.png"),
ps4.normalize_and_scale(frames))
def part_5a():
"""Frame interpolation
Follow the instructions in the problem set instructions.
Place all your work in this file and this section.
"""
shift_0 = cv2.imread(os.path.join(input_dir, 'TestSeq', 'Shift0.png'),
0) / 255.
shift_r10 = cv2.imread(os.path.join(input_dir, 'TestSeq', 'ShiftR10.png'),
0) / 255.
h, w = shift_0.shape
frames = interpolate_frames(shift_0, shift_r10, levels=4, k_size=13)
frames = [ps4.normalize_and_scale(f) for f in frames]
combined = np.zeros((h * 2, w * 3), np.float32)
f_n = 0
for i in range(2):
for j in range(3):
combined[i * h:(i + 1) * h, j * w:(j + 1) * w] = frames[f_n]
f_n += 1
cv2.imwrite(os.path.join(output_dir, "ps4-5-a-1.png"), combined)
def part_4b():
urban_img_01 = cv2.imread(os.path.join(input_dir, 'Urban2', 'urban01.png'),
0) / 255.
urban_img_02 = cv2.imread(os.path.join(input_dir, 'Urban2', 'urban02.png'),
0) / 255.
levels = 1 # TODO: Define the number of levels
k_size = 0 # TODO: Select a kernel size
k_type = "" # TODO: Select a kernel type
sigma = 0 # TODO: Select a sigma value if you are using a gaussian kernel
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
u, v = ps4.hierarchical_lk(urban_img_01, urban_img_02, levels, k_size,
k_type, sigma, interpolation, border_mode)
u_v = quiver(u, v, scale=3, stride=10)
cv2.imwrite(os.path.join(output_dir, "ps4-4-b-1.png"), u_v)
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
urban_img_02_warped = ps4.warp(urban_img_02, u, v, interpolation,
border_mode)
diff_img = urban_img_01 - urban_img_02_warped
cv2.imwrite(os.path.join(output_dir, "ps4-4-b-2.png"),
ps4.normalize_and_scale(diff_img))
def part_3a_2():
yos_img_02 = cv2.imread(
os.path.join(input_dir, 'DataSeq1', 'yos_img_02.jpg'), 0) / 255.
yos_img_03 = cv2.imread(
os.path.join(input_dir, 'DataSeq1', 'yos_img_03.jpg'), 0) / 255.
levels = 1 # Define the number of pyramid levels
yos_img_02_g_pyr = ps4.gaussian_pyramid(yos_img_02, levels)
yos_img_03_g_pyr = ps4.gaussian_pyramid(yos_img_03, levels)
level_id = 3 # TODO: Select the level number (or id) you wish to use
k_size = 3 # TODO: Select a kernel size
k_type = "uniform" # TODO: Select a kernel type
sigma = 1 # TODO: Select a sigma value if you are using a gaussian kernel
u, v = ps4.optic_flow_lk(yos_img_02_g_pyr[level_id],
yos_img_03_g_pyr[level_id], k_size, k_type, sigma)
u, v = scale_u_and_v(u, v, level_id, yos_img_03_g_pyr)
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
yos_img_03_warped = ps4.warp(yos_img_03, u, v, interpolation, border_mode)
diff_yos_img = yos_img_02 - yos_img_03_warped
cv2.imwrite(os.path.join(output_dir, "ps4-3-a-2.png"),
ps4.normalize_and_scale(diff_yos_img))
def part_4b():
urban_img_01 = cv2.imread(os.path.join(input_dir, 'Urban2', 'urban01.png'),
0) / 255.
urban_img_02 = cv2.imread(os.path.join(input_dir, 'Urban2', 'urban02.png'),
0) / 255.
levels = 5
k_size = 51
k_type = "gaussian"
sigma = 3
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
u, v = ps4.hierarchical_lk(urban_img_01, urban_img_02, levels, k_size,
k_type, sigma, interpolation, border_mode)
u_v = quiver(u, v, scale=3, stride=10)
cv2.imwrite(os.path.join(output_dir, "ps4-4-b-1.png"), u_v)
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
urban_img_02_warped = ps4.warp(urban_img_02, u, v, interpolation,
border_mode)
diff_img = urban_img_01 - urban_img_02_warped
cv2.imwrite(os.path.join(output_dir, "ps4-4-b-2.png"),
ps4.normalize_and_scale(diff_img))
def part_3a_1():
yos_img_01 = cv2.imread(
os.path.join(input_dir, 'DataSeq1', 'yos_img_01.jpg'), 0) / 255.
yos_img_02 = cv2.imread(
os.path.join(input_dir, 'DataSeq1', 'yos_img_02.jpg'), 0) / 255.
levels = 2 # Define the number of pyramid levels
yos_img_01_g_pyr = ps4.gaussian_pyramid(yos_img_01, levels)
yos_img_02_g_pyr = ps4.gaussian_pyramid(yos_img_02, levels)
level_id = 1
k_size = 32
k_type = "uniform"
sigma = 0
u, v = ps4.optic_flow_lk(yos_img_01_g_pyr[level_id],
yos_img_02_g_pyr[level_id], k_size, k_type, sigma)
u, v = scale_u_and_v(u, v, level_id, yos_img_02_g_pyr)
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
yos_img_02_warped = ps4.warp(yos_img_02, u, v, interpolation, border_mode)
diff_yos_img = yos_img_01 - yos_img_02_warped
cv2.imwrite(os.path.join(output_dir, "ps4-3-a-1.png"),
ps4.normalize_and_scale(diff_yos_img))
def part_3a_2():
yos_img_02 = cv2.imread(
os.path.join(input_dir, 'DataSeq1', 'yos_img_02.jpg'), 0) / 255.
yos_img_03 = cv2.imread(
os.path.join(input_dir, 'DataSeq1', 'yos_img_03.jpg'), 0) / 255.
levels = 4
yos_img_02_g_pyr = ps4.gaussian_pyramid(yos_img_02, levels)
yos_img_03_g_pyr = ps4.gaussian_pyramid(yos_img_03, levels)
level_id = 0
k_size = 51
k_type = "gaussian"
sigma = 3
u, v = ps4.optic_flow_lk(yos_img_02_g_pyr[level_id],
yos_img_03_g_pyr[level_id], k_size, k_type, sigma)
u, v = scale_u_and_v(u, v, level_id, yos_img_03_g_pyr)
interpolation = cv2.INTER_CUBIC
border_mode = cv2.BORDER_REFLECT101
yos_img_03_warped = ps4.warp(yos_img_03, u, v, interpolation, border_mode)
diff_yos_img = yos_img_02 - yos_img_03_warped
cv2.imwrite(os.path.join(output_dir, "ps4-3-a-2.png"),
ps4.normalize_and_scale(diff_yos_img))
def part_3a_1():
yos_img_01 = cv2.imread(
os.path.join(input_dir, 'DataSeq1', 'yos_img_01.jpg'), 0) / 255.
yos_img_02 = cv2.imread(
os.path.join(input_dir, 'DataSeq1', 'yos_img_02.jpg'), 0) / 255.
levels = 4 # Define the number of pyramid levels
yos_img_01_g_pyr = ps4.gaussian_pyramid(yos_img_01, levels)
yos_img_02_g_pyr = ps4.gaussian_pyramid(yos_img_02, levels)
# k_size = "kSize"
# window = "Params"
# cv2.namedWindow(window)
# cv2.createTrackbar(k_size, window, 1, 100, nothing)
# while 1:
# k = cv2.waitKey(1) & 0xFF
# if k == 27:
# break
#
# level_id = 0 # TODO: Select the level number (or id) you wish to use
# # k_size = 11 # TODO: Select a kernel size
# k_size = cv2.getTrackbarPos('kSize', 'Params')
# k_type = 'uniform' # TODO: Select a kernel type
# sigma = 0 # TODO: Select a sigma value if you are using a gaussian kernel
# u, v = ps4.optic_flow_lk(yos_img_01_g_pyr[level_id],
# yos_img_02_g_pyr[level_id],
# k_size, k_type, sigma)
#
# u, v = scale_u_and_v(u, v, level_id, yos_img_02_g_pyr)
#
# interpolation = cv2.INTER_CUBIC # You may try different values
# border_mode = cv2.BORDER_REFLECT101 # You may try different values
# yos_img_02_warped = ps4.warp(yos_img_02, u, v, interpolation, border_mode)
#
# diff_yos_img_01_02 = yos_img_01 - yos_img_02_warped
#
# cv2.imshow("Params", diff_yos_img_01_02)
level_id = 1 # TODO: Select the level number (or id) you wish to use
k_size = 23 # TODO: Select a kernel size
k_type = 'uniform' # TODO: Select a kernel type
sigma = 0 # TODO: Select a sigma value if you are using a gaussian kernel
u, v = ps4.optic_flow_lk(yos_img_01_g_pyr[level_id],
yos_img_02_g_pyr[level_id], k_size, k_type, sigma)
u, v = scale_u_and_v(u, v, level_id, yos_img_02_g_pyr)
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
yos_img_02_warped = ps4.warp(yos_img_02, u, v, interpolation, border_mode)
diff_yos_img_01_02 = yos_img_01 - yos_img_02_warped
cv2.imwrite(os.path.join(output_dir, "ps4-3-a-1.png"),
ps4.normalize_and_scale(diff_yos_img_01_02))
def part_5b():
mc_01 = cv2.imread(os.path.join(input_dir, 'MiniCooper', 'mc01.png'),
0) / 255.
mc_02 = cv2.imread(os.path.join(input_dir, 'MiniCooper', 'mc02.png'),
0) / 255.
mc_03 = cv2.imread(os.path.join(input_dir, 'MiniCooper', 'mc03.png'),
0) / 255.
# Create a window
cv2.namedWindow('image')
u_v = np.zeros(mc_01.shape)
# create trackbars for color change
cv2.createTrackbar('levels', 'image', 1, 15, nothing)
cv2.createTrackbar('k_size', 'image', 3, 70, nothing)
cv2.createTrackbar('k_type', 'image', 0, 1, nothing)
cv2.createTrackbar('sigma', 'image', 1, 50, nothing)
while (1):
cv2.imshow('image', u_v)
k = cv2.waitKey(1) & 0xFF
if k == 27:
break
# Optional: smooth the images if LK doesn't work well on raw images
levels = cv2.getTrackbarPos('levels', 'image')
k_size = cv2.getTrackbarPos('k_size', 'image')
k_type = 'gaussian' if cv2.getTrackbarPos('k_type',
'image') == 1 else 'uniform'
sigma = cv2.getTrackbarPos('sigma', 'image')
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
u, v = ps4.hierarchical_lk(mc_01, mc_02, levels, k_size, k_type, sigma,
interpolation, border_mode)
u_v = experiment.quiver(u, v, scale=0.5, stride=10)
print levels, k_size, k_type, sigma
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
mc_02_warped = ps4.warp(mc_02, u, v, interpolation, border_mode)
diff_img = ps4.normalize_and_scale(mc_01 - mc_02_warped).astype(
np.uint8)
cv2.imshow('image2', diff_img)
cv2.destroyAllWindows()
print levels, k_size, k_type, sigma
def part_3():
yos_img_01 = cv2.imread(
os.path.join(input_dir, 'DataSeq1', 'yos_img_02.jpg'), 0) / 255.
yos_img_02 = cv2.imread(
os.path.join(input_dir, 'DataSeq1', 'yos_img_03.jpg'), 0) / 255.
levels = 10 # Define the number of pyramid levels
yos_img_01_g_pyr = ps4.gaussian_pyramid(yos_img_01, levels)
yos_img_02_g_pyr = ps4.gaussian_pyramid(yos_img_02, levels)
# Create a window
cv2.namedWindow('image')
diff_yos_img = np.zeros(yos_img_01.shape)
# create trackbars for color change
cv2.createTrackbar('level_id', 'image', 1, levels - 1, nothing)
cv2.createTrackbar('k_size', 'image', 3, 70, nothing)
cv2.createTrackbar('k_type', 'image', 0, 1, nothing)
cv2.createTrackbar('sigma', 'image', 1, 50, nothing)
while (1):
cv2.imshow('image', diff_yos_img)
k = cv2.waitKey(1) & 0xFF
if k == 27:
break
# Optional: smooth the images if LK doesn't work well on raw images
level_id = cv2.getTrackbarPos('level_id', 'image')
k_size = cv2.getTrackbarPos('k_size', 'image')
k_type = 'gaussian' if cv2.getTrackbarPos('k_type',
'image') == 1 else 'uniform'
sigma = cv2.getTrackbarPos('sigma', 'image')
u, v = ps4.optic_flow_lk(yos_img_01_g_pyr[level_id],
yos_img_02_g_pyr[level_id], k_size, k_type,
sigma)
u, v = experiment.scale_u_and_v(u, v, level_id, yos_img_02_g_pyr)
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
yos_img_02_warped = ps4.warp(yos_img_02, u, v, interpolation,
border_mode)
diff_yos_img = ps4.normalize_and_scale(yos_img_01 -
yos_img_02_warped).astype(
np.uint8)
cv2.destroyAllWindows()
print level_id, k_size, k_type, sigma
def part_4b():
urban_img_01 = cv2.imread(os.path.join(input_dir, 'Urban2', 'urban01.png'),
0) / 255.
urban_img_02 = cv2.imread(os.path.join(input_dir, 'Urban2', 'urban02.png'),
0) / 255.
levels = 4
k_size = 57
k_type = 'uniform'
sigma = 0 # TODO: Select a sigma value if you are using a gaussian kernel
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
# k_size = "kSize"
# window = "Params"
# cv2.namedWindow(window)
# cv2.createTrackbar(k_size, window, 1, 100, nothing)
# while 1:
# k = cv2.waitKey(1) & 0xFF
# if k == 27:
# break
#
# level_id = 1 # TODO: Select the level number (or id) you wish to use
# # k_size = 11 # TODO: Select a kernel size
# k_size = cv2.getTrackbarPos('kSize', 'Params')
# k_type = 'uniform' # TODO: Select a kernel type
#
# u, v = ps4.hierarchical_lk(urban_img_01, urban_img_02, levels, k_size,
# k_type, sigma, interpolation, border_mode)
#
# u_v = quiver(u, v, scale=3, stride=10)
# cv2.imshow("Params", u_v)
u, v = ps4.hierarchical_lk(urban_img_01, urban_img_02, levels, k_size,
k_type, sigma, interpolation, border_mode)
u_v = quiver(u, v, scale=3, stride=10)
cv2.imwrite(os.path.join(output_dir, "ps4-4-b-1.png"), u_v)
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
urban_img_02_warped = ps4.warp(urban_img_02, u, v, interpolation,
border_mode)
diff_img = urban_img_01 - urban_img_02_warped
cv2.imwrite(os.path.join(output_dir, "ps4-4-b-2.png"),
ps4.normalize_and_scale(diff_img))
def part_5a():
"""Frame interpolation
Follow the instructions in the problem set instructions.
Place all your work in this file and this section.
"""
shift_0 = cv2.imread(os.path.join(input_dir, 'TestSeq',
'Shift0.png'), 0) / 255.
shift_r10 = cv2.imread(os.path.join(input_dir, 'TestSeq',
'ShiftR10.png'), 0) / 255.
levels = 4 # TODO: Define the number of levels
k_size = 35 # TODO: Select a kernel size
k_type = "uniform" # TODO: Select a kernel type
sigma = 0 # TODO: Select a sigma value if you are using a gaussian kernel
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
u, v = ps4.hierarchical_lk(shift_0, shift_r10, levels, k_size, k_type,
sigma, interpolation, border_mode)
t = 0.2
shift_r10_wraped_1 = ps4.warp(shift_0, -t*u, -t*v, interpolation, border_mode)
t = 0.4
shift_r10_wraped_2 = ps4.warp(shift_0, -t*u, -t*v, interpolation, border_mode)
t = 0.6
shift_r10_wraped_3 = ps4.warp(shift_0, -t*u, -t*v, interpolation, border_mode)
t = 0.8
shift_r10_wraped_4 = ps4.warp(shift_0, -t*u, -t*v, interpolation, border_mode)
H, W = shift_0.shape
target = np.ones((2*H, 3*W), dtype = np.float64)
target[0 : H, 0 : W] = ps4.normalize_and_scale(shift_0)
target[0 : H, W : 2*W] = ps4.normalize_and_scale(shift_r10_wraped_1)
target[0 : H, 2*W : 3*W] = ps4.normalize_and_scale(shift_r10_wraped_2)
target[H : 2*H, 0 : W] = ps4.normalize_and_scale(shift_r10_wraped_3)
target[H : 2*H, W : 2*W] = ps4.normalize_and_scale(shift_r10_wraped_4)
target[H : 2*H, 2*W : 3*W] = ps4.normalize_and_scale(shift_r10)
cv2.imwrite(os.path.join(output_dir, "ps4-5-a-1.png"),
ps4.normalize_and_scale(target))
def part_5a():
"""Frame interpolation
Follow the instructions in the problem set instructions.
Place all your work in this file and this section.
"""
image_at_0 = cv2.imread(os.path.join(input_dir, 'TestSeq', 'Shift0.png'),
0) / 255
image_at_10 = cv2.imread(
os.path.join(input_dir, 'TestSeq', 'ShiftR10.png'), 0) / 255
levels, k_size, k_type, sigma = 5, 9, "uniform", 1
interpolation, border_mode = cv2.INTER_CUBIC, cv2.BORDER_REFLECT101
u, v = ps4.hierarchical_lk(image_at_0, image_at_10, levels, k_size, k_type,
sigma, interpolation, border_mode)
motion_frame = []
motion_frame.append(image_at_0)
motion_frame.append(
ps4.warp(image_at_0, -0.2 * u, -0.2 * v, interpolation, border_mode))
motion_frame.append(
ps4.warp(image_at_0, -0.4 * u, -0.4 * v, interpolation, border_mode))
motion_frame.append(
ps4.warp(image_at_0, -0.6 * u, -0.6 * v, interpolation, border_mode))
motion_frame.append(
ps4.warp(image_at_0, -0.8 * u, -0.8 * v, interpolation, border_mode))
motion_frame.append(image_at_10)
height, width = image_at_0.shape
motion_picture = np.ones((2 * height, 3 * width), dtype=np.float64)
for i in range(2):
for j in range(3):
motion_picture[i * height:(i + 1) * height,
j * width:(j + 1) * width] = motion_frame[3 * i + j]
cv2.imwrite(os.path.join(output_dir, "ps4-5-a-1.png"),
ps4.normalize_and_scale(motion_picture))
def part_5a():
"""Frame interpolation
Follow the instructions in the problem set instructions.
Place all your work in this file and this section.
"""
shift_0 = cv2.imread(os.path.join(input_dir, 'TestSeq', 'Shift0.png'),
0) / 255.
shift_r2 = cv2.imread(os.path.join(input_dir, 'TestSeq', 'ShiftR2.png'),
0) / 255.
k_size = 25 # TODO: Select a kernel size
k_type = "uniform" # TODO: Select a kernel type
sigma = 0.5 # TODO: Select a sigma value if you are using a gaussian kernel
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
u, v = ps4.optic_flow_lk(shift_0, shift_r2, k_size, k_type, sigma)
img_0 = ps4.normalize_and_scale(shift_0)
img_02 = ps4.warp(shift_0, -0.2 * u, -0.2 * v, interpolation, border_mode)
img_04 = ps4.warp(shift_0, -0.4 * u, -0.4 * v, interpolation, border_mode)
img_06 = ps4.warp(shift_0, -0.6 * u, -0.6 * v, interpolation, border_mode)
img_08 = ps4.warp(shift_0, -0.8 * u, -0.8 * v, interpolation, border_mode)
img_02 = ps4.normalize_and_scale(img_02)
img_04 = ps4.normalize_and_scale(img_04)
img_06 = ps4.normalize_and_scale(img_06)
img_08 = ps4.normalize_and_scale(img_08)
img_1 = ps4.normalize_and_scale(shift_r2)
img_row1 = np.concatenate((img_0, img_02, img_04), axis=1)
img_row2 = np.concatenate((img_06, img_08, img_1), axis=1)
img_all = np.concatenate((img_row1, img_row2), axis=0)
images = [img_0, img_02, img_04, img_06, img_08, img_1]
imageio.mimsave(os.path.join(output_dir, "ps4-5-1-a-1.gif"), images)
# Flow image
u_v = quiver(u, v, scale=3, stride=10)
#cv2.imwrite(os.path.join(output_dir, "ps4-5-1-a-00.png"), img_0)
#cv2.imwrite(os.path.join(output_dir, "ps4-5-1-a-02.png"), img_02)
#cv2.imwrite(os.path.join(output_dir, "ps4-5-1-a-04.png"), img_04)
#cv2.imwrite(os.path.join(output_dir, "ps4-5-1-a-06.png"), img_06)
#cv2.imwrite(os.path.join(output_dir, "ps4-5-1-a-08.png"), img_08)
#cv2.imwrite(os.path.join(output_dir, "ps4-5-1-a-10.png"), img_1)
cv2.imwrite(os.path.join(output_dir, "ps4-5-1-a-1.png"), img_all)
def part_5a():
"""Frame interpolation
Follow the instructions in the problem set instructions.
Place all your work in this file and this section.
"""
shift_0 = cv2.imread(os.path.join(input_dir, 'TestSeq', 'Shift0.png'),
0) / 255.
shift_r10 = cv2.imread(os.path.join(input_dir, 'TestSeq', 'ShiftR10.png'),
0) / 255.
# Optional: smooth the images if LK doesn't work well on raw images
levels = 5 # TODO: Define the number of levels
k_size = 15 # TODO: Select a kernel size
k_type = "uniform" # TODO: Select a kernel type
sigma = 0 # TODO: Select a sigma value if you are using a gaussian kernel
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
u, v = ps4.hierarchical_lk(shift_0, shift_r10, levels, k_size, k_type,
sigma, interpolation, border_mode)
# Flow image
shift_02 = ps4.warp(shift_r10, 0.8 * u, 0.8 * v, interpolation,
border_mode)
shift_04 = ps4.warp(shift_r10, 0.6 * u, 0.6 * v, interpolation,
border_mode)
shift_06 = ps4.warp(shift_r10, 0.4 * u, 0.4 * v, interpolation,
border_mode)
shift_08 = ps4.warp(shift_r10, 0.2 * u, 0.2 * v, interpolation,
border_mode)
u_v = np.vstack((np.hstack((shift_0, shift_02, shift_04)),
np.hstack((shift_06, shift_08, shift_r10))))
cv2.imwrite(os.path.join(output_dir, "ps4-5-a-1.png"),
ps4.normalize_and_scale(u_v))
def part_3a_1():
yos_img_01 = cv2.imread(
os.path.join(input_dir, 'DataSeq1', 'yos_img_01.jpg'), 0) / 255.
yos_img_02 = cv2.imread(
os.path.join(input_dir, 'DataSeq1', 'yos_img_02.jpg'), 0) / 255.
k = 11
sigma = 7
yos_img_01g = cv2.GaussianBlur(yos_img_01,
ksize=(k, k),
sigmaX=sigma,
sigmaY=sigma)
yos_img_02g = cv2.GaussianBlur(yos_img_02,
ksize=(k, k),
sigmaX=sigma,
sigmaY=sigma)
levels = 5 # Define the number of pyramid levels
yos_img_01_g_pyr = ps4.gaussian_pyramid(yos_img_01g, levels)
yos_img_02_g_pyr = ps4.gaussian_pyramid(yos_img_02g, levels)
level_id = 0 # TODO: Select the level number (or id) you wish to use
k_size = 20 # TODO: Select a kernel size
k_type = "uniform" # TODO: Select a kernel type
sigma = 10 # TODO: Select a sigma value if you are using a gaussian kernel
u, v = ps4.optic_flow_lk(yos_img_01_g_pyr[level_id],
yos_img_02_g_pyr[level_id], k_size, k_type, sigma)
u, v = scale_u_and_v(u, v, level_id, yos_img_02_g_pyr)
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
yos_img_02_warped = ps4.warp(yos_img_02, u, v, interpolation, border_mode)
diff_yos_img_01_02 = yos_img_01 - yos_img_02_warped
cv2.imwrite(os.path.join(output_dir, "ps4-3-a-1.png"),
ps4.normalize_and_scale(diff_yos_img_01_02))
def part_5b():
"""Frame interpolation
Follow the instructions in the problem set instructions.
Place all your work in this file and this section.
"""
## Load the data first
mc01 = cv2.imread(os.path.join(input_dir, 'MiniCooper', 'mc01.png'),
0) / 255
mc02 = cv2.imread(os.path.join(input_dir, 'MiniCooper', 'mc02.png'),
0) / 255
mc03 = cv2.imread(os.path.join(input_dir, 'MiniCooper', 'mc03.png'),
0) / 255
## Part_1
levels, k_size, k_type, sigma = 5, 35, "gaussian", 5
interpolation, border_mode = cv2.INTER_CUBIC, cv2.BORDER_REFLECT101
u_1, v_1 = ps4.hierarchical_lk(mc01, mc02, levels, k_size, k_type, sigma,
interpolation, border_mode)
motion_frame_1 = []
motion_frame_1.append(mc01)
motion_frame_1.append(
ps4.warp(mc01, -0.2 * u_1, -0.2 * v_1, interpolation, border_mode))
motion_frame_1.append(
ps4.warp(mc01, -0.4 * u_1, -0.4 * v_1, interpolation, border_mode))
motion_frame_1.append(
ps4.warp(mc01, -0.6 * u_1, -0.6 * v_1, interpolation, border_mode))
motion_frame_1.append(
ps4.warp(mc01, -0.8 * u_1, -0.8 * v_1, interpolation, border_mode))
motion_frame_1.append(mc02)
height, width = mc01.shape
motion_picture_1 = np.zeros((2 * height, 3 * width), dtype=np.float64)
for i in range(2):
for j in range(3):
motion_picture_1[i * height:(i + 1) * height, j * width:(j + 1) *
width] = motion_frame_1[3 * i + j]
cv2.imwrite(os.path.join(output_dir, "ps4-5-b-1.png"),
ps4.normalize_and_scale(motion_picture_1))
## Part_2
levels, k_size, k_type, sigma = 5, 29, "gaussian", 3
interpolation, border_mode = cv2.INTER_CUBIC, cv2.BORDER_REFLECT101
u_2, v_2 = ps4.hierarchical_lk(mc02, mc03, levels, k_size, k_type, sigma,
interpolation, border_mode)
motion_frame_2 = []
motion_frame_2.append(mc02)
motion_frame_2.append(
ps4.warp(mc02, -0.2 * u_2, -0.2 * v_2, interpolation, border_mode))
motion_frame_2.append(
ps4.warp(mc02, -0.4 * u_2, -0.4 * v_2, interpolation, border_mode))
motion_frame_2.append(
ps4.warp(mc02, -0.6 * u_2, -0.6 * v_2, interpolation, border_mode))
motion_frame_2.append(
ps4.warp(mc02, -0.8 * u_2, -0.8 * v_2, interpolation, border_mode))
motion_frame_2.append(mc03)
height, width = mc02.shape
motion_picture_2 = np.zeros((2 * height, 3 * width), dtype=np.float64)
for i in range(2):
for j in range(3):
motion_picture_2[i * height:(i + 1) * height, j * width:(j + 1) *
width] = motion_frame_2[3 * i + j]
cv2.imwrite(os.path.join(output_dir, "ps4-5-b-2.png"),
ps4.normalize_and_scale(motion_picture_2))
def part_5b():
"""Frame interpolation
Follow the instructions in the problem set instructions.
Place all your work in this file and this section.
"""
mc01 = cv2.imread(os.path.join(input_dir, 'MiniCooper', 'mc01.png'),
0) / 255.
mc02 = cv2.imread(os.path.join(input_dir, 'MiniCooper', 'mc02.png'),
0) / 255.
mc03 = cv2.imread(os.path.join(input_dir, 'MiniCooper', 'mc03.png'),
0) / 255.
mc01 = cv2.GaussianBlur(mc01, (45, 45), 0.05)
mc02 = cv2.GaussianBlur(mc02, (45, 45), 0.05)
mc03 = cv2.GaussianBlur(mc03, (45, 45), 0.05)
k_size = 15 # TODO: Select a kernel size
k_type = "uniform" # TODO: Select a kernel type
sigma = 0.5 # TODO: Select a sigma value if you are using a gaussian kernel
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
levels = 4
u, v = ps4.hierarchical_lk(mc01, mc02, levels, k_size, k_type, sigma,
interpolation, border_mode)
u_v = quiver(u, v, scale=3, stride=10)
cv2.imwrite(os.path.join(output_dir, "ps4-5-1-b-1-quiver.png"), u_v)
mc_001 = ps4.normalize_and_scale(mc01)
mc_002 = ps4.warp(mc01, -0.2 * u, -0.2 * v, interpolation, border_mode)
mc_004 = ps4.warp(mc01, -0.4 * u, -0.4 * v, interpolation, border_mode)
mc_006 = ps4.warp(mc01, -0.6 * u, -0.6 * v, interpolation, border_mode)
mc_008 = ps4.warp(mc01, -0.8 * u, -0.8 * v, interpolation, border_mode)
mc_200 = ps4.normalize_and_scale(mc02)
mc_002 = ps4.normalize_and_scale(mc_002)
mc_004 = ps4.normalize_and_scale(mc_004)
mc_006 = ps4.normalize_and_scale(mc_006)
mc_008 = ps4.normalize_and_scale(mc_008)
k_size = 10 # TODO: Select a kernel size
k_type = "uniform" # TODO: Select a kernel type
sigma = 2 # TODO: Select a sigma value if you are using a gaussian kernel
interpolation = cv2.INTER_CUBIC # You may try different values
border_mode = cv2.BORDER_REFLECT101 # You may try different values
levels = 6
u, v = ps4.hierarchical_lk(mc02, mc03, levels, k_size, k_type, sigma,
interpolation, border_mode)
#print "U shape:{}".format(u.shape)
#print "V shape:{}".format(v.shape)
#print "img shape: {}".format(mc01.shape)
u_v = quiver(u, v, scale=3, stride=10)
cv2.imwrite(os.path.join(output_dir, "ps4-5-1-b-2-quiver.png"), u_v)
mc_201 = ps4.normalize_and_scale(mc02)
mc_202 = ps4.warp(mc02, -0.2 * u, -0.2 * v, interpolation, border_mode)
mc_204 = ps4.warp(mc02, -0.4 * u, -0.4 * v, interpolation, border_mode)
mc_206 = ps4.warp(mc02, -0.6 * u, -0.6 * v, interpolation, border_mode)
mc_208 = ps4.warp(mc02, -0.8 * u, -0.8 * v, interpolation, border_mode)
mc_300 = ps4.normalize_and_scale(mc03)
mc_202 = ps4.normalize_and_scale(mc_202)
mc_204 = ps4.normalize_and_scale(mc_204)
mc_206 = ps4.normalize_and_scale(mc_206)
mc_208 = ps4.normalize_and_scale(mc_208)
mc01_02_row1 = np.concatenate((mc_001, mc_002, mc_004), axis=1)
mc01_02_row2 = np.concatenate((mc_006, mc_008, mc_200), axis=1)
mc01_02_all = np.concatenate((mc01_02_row1, mc01_02_row2), axis=0)
images_01_02 = [mc_001, mc_002, mc_004, mc_006, mc_008, mc_200]
cv2.imwrite(os.path.join(output_dir, "ps4-5-1-b-1.png"), mc01_02_all)
imageio.mimsave(os.path.join(output_dir, "ps4-5-1-b-1.gif"), images_01_02)
mc02_03_row1 = np.concatenate((mc_201, mc_202, mc_204), axis=1)
mc02_03_row2 = np.concatenate((mc_206, mc_208, mc_300), axis=1)
mc02_03_all = np.concatenate((mc02_03_row1, mc02_03_row2), axis=0)
images_02_03 = [mc_201, mc_202, mc_204, mc_206, mc_208, mc_300]
cv2.imwrite(os.path.join(output_dir, "ps4-5-1-b-2.png"), mc02_03_all)
imageio.mimsave(os.path.join(output_dir, "ps4-5-1-b-2.gif"), images_02_03)
