def part_3():
print("\nPart 3:")
input_images = ['ps3-3-a_base.jpg', 'ps3-3-b_base.jpg', 'ps3-3-c_base.jpg']
output_images = ['ps3-3-a-1.png', 'ps3-3-a-2.png', 'ps3-3-a-3.png']
# Advertisement image
advert = cv2.imread(os.path.join(IMG_DIR, "img-3-a-1.png"))
src_points = ps3.get_corners_list(advert)
# Optional template image
template = cv2.imread(os.path.join(IMG_DIR, "template.jpg"))
for img_in, img_out in zip(input_images, output_images):
print("Input image: {}".format(img_in))
# Open image and identify the four marker positions
scene = cv2.imread(os.path.join(IMG_DIR, img_in))
markers = ps3.find_markers(scene, template)
homography = ps3.find_four_point_transform(src_points, markers)
projected_img = ps3.project_imageA_onto_imageB(advert, scene,
homography)
save_image(img_out, projected_img)
def part_1():
print("\nPart 1:")
input_images = [
'sim_clear_scene.jpg', 'sim_noisy_scene_1.jpg', 'sim_noisy_scene_2.jpg'
]
output_images = ['ps3-1-a-1.png', 'ps3-1-a-2.png', 'ps3-1-a-3.png']
# input_images = ['sim_noisy_scene_1.jpg']
# output_images = ['ps3-1-a-2.png']
# Optional template image
template = cv2.imread(os.path.join(IMG_DIR, "template.jpg"))
for img_in, img_out in zip(input_images, output_images):
print("Input image: {}".format(img_in))
# Open image and identify the four marker positions
scene = cv2.imread(os.path.join(IMG_DIR, img_in))
marker_positions = ps3.find_markers(scene, template)
for marker in marker_positions:
mark_location(scene, marker)
save_image(img_out, scene)
def part_2():
print("\nPart 2:")
input_images = [
'ps3-2-a_base.jpg', 'ps3-2-b_base.jpg', 'ps3-2-c_base.jpg',
'ps3-2-d_base.jpg', 'ps3-2-e_base.jpg'
]
output_images = [
'ps3-2-a-1.png', 'ps3-2-a-2.png', 'ps3-2-a-3.png', 'ps3-2-a-4.png',
'ps3-2-a-5.png'
]
# input_images = ['ps3-3-c_base.jpg']
# output_images = ['ps3-3-c_base_test.png']
# Optional template image
template = cv2.imread(os.path.join(IMG_DIR, "template.jpg"))
for img_in, img_out in zip(input_images, output_images):
print("Input image: {}".format(img_in))
# Open image and identify the four marker positions
scene = cv2.imread(os.path.join(IMG_DIR, img_in))
markers = ps3.find_markers(scene, template)
image_with_box = ps3.draw_box(scene, markers, 3)
save_image(img_out, image_with_box)
def helper_for_part_6(video_name1, video_name2, fps, frame_ids, output_prefix,
counter_init, is_part6):
video1 = os.path.join(VID_DIR, video_name1)
video2 = os.path.join(VID_DIR, video_name2)
image_gen1 = ps3.video_frame_generator(video1)
image_gen2 = ps3.video_frame_generator(video2)
image1 = image_gen1.next()
h1, w1, d1 = image1.shape
image2 = image_gen2.next()
h2, w2, d2 = image2.shape
#corners = get_corners_list(image2)
out_path = "output/ar_{}-{}".format(output_prefix[4:], video_name1)
video_out = mp4_video_writer(out_path, (w1, h1), fps)
# Optional template image
template = cv2.imread(os.path.join(IMG_DIR, "template.jpg"))
#if is_part6:
# advert = image2
# src_points = ps3.get_corners_list(advert)
# image2 = image_gen2.next()
output_counter = counter_init
frame_num = 1
while image1 is not None:
print "Processing fame {}".format(frame_num)
advert = image2
src_points = ps3.get_corners_list(advert)
image2 = image_gen2.next()
markers = ps3.find_markers(image1, template)
homography = ps3.find_four_point_transform(src_points, markers)
image1 = ps3.project_imageA_onto_imageB(advert, image1, homography)
frame_id = frame_ids[(output_counter - 1) % 3]
if frame_num == frame_id:
out_str = output_prefix + "-{}.png".format(output_counter)
save_image(out_str, image1)
output_counter += 1
video_out.write(image1)
image1 = image_gen1.next()
frame_num += 1
video_out.release()
def test_find_markers_wall_image(self):
file_names = [
'rectangle_wall.png', 'rectangle_wall_noisy.png',
'rectangle_wall_noisy_gaussian.png'
]
template = cv2.imread("input_images/template.jpg")
markers_pos = [(197, 288), (283, 640), (979, 99), (1062, 465)]
thresh = 1
for f in file_names:
test_image = cv2.imread(INPUT_DIR + f)
ret_markers = ps3.find_markers(test_image, template)
for act_pt, ret_pt in zip(markers_pos, ret_markers):
x_dist_test = abs(ret_pt[0] - act_pt[0]) <= thresh
self.assertTrue(x_dist_test,
msg='X point is too far from reference. '
'Expected: {}. Returned: {}'
''.format(ret_pt[0], act_pt[0]))
y_dist_test = abs(ret_pt[1] - act_pt[1]) <= thresh
self.assertTrue(y_dist_test,
msg='Y point is too far from reference. '
'Expected: {}. Returned: {}'
''.format(ret_pt[1], act_pt[1]))
def helper_for_part_4_and_5(video_name, fps, frame_ids, output_prefix,
counter_init, is_part5):
video = os.path.join(VID_DIR, video_name)
image_gen = ps3.video_frame_generator(video)
image = image_gen.__next__()
h, w, d = image.shape
out_path = "output/ar_{}-{}".format(output_prefix[4:], video_name)
video_out = mp4_video_writer(out_path, (w, h), fps)
# Optional template image
template = cv2.imread(os.path.join(IMG_DIR, "template.jpg"))
if is_part5:
advert = cv2.imread(os.path.join(IMG_DIR, "img-3-a-1.png"))
src_points = ps3.get_corners_list(advert)
output_counter = counter_init
frame_num = 1
while image is not None:
print("Processing fame {}".format(frame_num))
# start_time = time.time()
markers = ps3.find_markers(image, template)
# elapsed_time = time.time() - start_time
# print("FindMarkers : ", elapsed_time)
if is_part5:
homography = ps3.find_four_point_transform(src_points, markers)
# start_time = time.time()
image = ps3.project_imageA_onto_imageB(advert, image, homography)
# elapsed_time = time.time() - start_time
# print("Project : ", elapsed_time)
else:
for marker in markers:
mark_location(image, marker)
frame_id = frame_ids[(output_counter - 1) % 3]
if frame_num == frame_id:
out_str = output_prefix + "-{}.png".format(output_counter)
save_image(out_str, image)
output_counter += 1
video_out.write(image)
image = image_gen.__next__()
frame_num += 1
video_out.release()
def part_6():
print "\nPart 6:"
video_file = "ps3-4-a.mp4"
my_video = "my-ad.mp4" # Place your video in the input_video directory
frame_ids = [355, 555, 725]
fps = 40
output_counter = 1
video = os.path.join(VID_DIR, video_file)
image_gen = ps3.video_frame_generator(video)
image = image_gen.next()
h, w, d = image.shape
out_path = "output/ar_6.mp4"
video_out = mp4_video_writer(out_path, (w, h), fps)
# Optional template image
template = cv2.imread(os.path.join(IMG_DIR, "template.jpg"))
advert_video = os.path.join(VID_DIR, my_video)
ad_img_gen = ps3.video_frame_generator(advert_video)
advert = ad_img_gen.next()
src_points = ps3.get_corners_list(advert)
frame_num = 1
while image is not None:
print "Processing fame {}".format(frame_num)
markers = ps3.find_markers(image, template)
homography = ps3.find_four_point_transform(src_points, markers)
image = ps3.project_imageA_onto_imageB(advert, image, homography)
frame_id = frame_ids[(output_counter - 1) % 3]
if frame_num == frame_id:
out_str = "ps3-6-{}.png".format(output_counter)
save_image(out_str, image)
output_counter += 1
video_out.write(image)
image = image_gen.next()
advert = ad_img_gen.next()
frame_num += 1
video_out.release()
while advert is not None:
advert = ad_img_gen.next()
def helper_for_part_6(video_name_base, video_name_top, fps, frame_ids, output_prefix, counter_init):
video_base = os.path.join(VID_DIR, video_name_base)
image_gen_base = ps3.video_frame_generator(video_base)
video_top = os.path.join(VID_DIR, video_name_top)
image_gen_top = ps3.video_frame_generator(video_top)
image_base = image_gen_base.__next__()
h, w, d = image_base.shape
image_top = image_gen_top.__next__()
out_path = "output/ar_{}-{}".format(output_prefix[4:], video_name_base)
video_out = mp4_video_writer(out_path, (w, h), fps)
# Optional template image
template = cv2.imread(os.path.join(IMG_DIR, "template.jpg"))
src_points = ps3.get_corners_list(image_top)
output_counter = counter_init
frame_num = 1
while image_base is not None:
# for i in range(10):
print("Processing fame {}".format(frame_num))
markers = ps3.find_markers(image_base, template)
homography = ps3.find_four_point_transform(src_points, markers)
image_base = ps3.project_imageA_onto_imageB(image_top, image_base, homography)
frame_id = frame_ids[(output_counter - 1) % 3]
if frame_num == frame_id:
out_str = output_prefix + "-{}.png".format(output_counter)
save_image(out_str, image_base)
output_counter += 1
video_out.write(image_base)
# video_out.write(image_top)
image_base = image_gen_base.__next__()
image_top = image_gen_top.__next__()
frame_num += 1
video_out.release()
def helper_for_part_6(video_name, my_video_name, fps, frame_ids, output_prefix,
counter_init):
my_video = os.path.join(VID_DIR, my_video_name)
my_image_gen = ps3.video_frame_generator(my_video)
video = os.path.join(VID_DIR, video_name)
image_gen = ps3.video_frame_generator(video)
image = image_gen.next()
h, w, d = image.shape
out_path = "output/ar_{}-{}".format(output_prefix[4:], video_name)
video_out = mp4_video_writer(out_path, (w, h), fps)
# Optional template image
template = cv2.imread(os.path.join(IMG_DIR, "template.jpg"))
output_counter = counter_init
frame_num = 1
while image is not None:
try:
next_img = my_image_gen.next()
except:
#my_image_gen.release()
my_image_gen = ps3.video_frame_generator(my_video)
print('Replay!.')
if next_img is not None:
advert = np.copy(next_img)
src_points = ps3.get_corners_list(advert)
print "Processing fame {}".format(frame_num)
markers = ps3.find_markers(image, template)
homography = ps3.find_four_point_transform(src_points, markers)
image = ps3.project_imageA_onto_imageB(advert, image, homography)
frame_id = frame_ids[(output_counter - 1) % 3]
if frame_num == frame_id:
out_str = output_prefix + "-{}.png".format(output_counter)
save_image(out_str, image)
output_counter += 1
video_out.write(image)
image = image_gen.next()
frame_num += 1
video_out.release()
def part_6():
print "\nPart 6:"
video_file = "ps3-4-a.mp4"
my_video = "my-ad.mp4" # Place your video in the input_video directory
frame_ids = [355, 555, 725]
fps = 40
# Todo: Complete this part on your own.
base_video = os.path.join(VID_DIR, video_file)
image_gen = ps3.video_frame_generator(base_video)
image = image_gen.next()
h, w, d = image.shape
my_video = os.path.join(VID_DIR, my_video)
my_image_gen = ps3.video_frame_generator(my_video)
my_image = my_image_gen.next()
out_path = "output/ar_{}-{}.avi".format("ps3-6", video_file)
video_out = mp4_video_writer(out_path, (w, h), fps)
output_counter = 1
frame_num = 1
src_points = ps3.get_corners_list(my_image)
while image is not None:
print "Processing frame {}".format(frame_num)
markers = ps3.find_markers(image, None)
homography = ps3.find_four_point_transform(src_points, markers)
image = ps3.project_imageA_onto_imageB(my_image, image, homography)
frame_id = frame_ids[(output_counter - 1) % 3]
if frame_num == frame_id:
out_str = "ps3-6" + "-{}.png".format(output_counter)
save_image(out_str, image)
output_counter += 1
video_out.write(image)
image = image_gen.next()
my_image = my_image_gen.next()
frame_num += 1
video_out.release()
def test_find_markers_simple_rectangle(self):
file_names = [
'extra_simple_rectangle.png', 'simple_rectangle_noisy.png',
'simple_rectangle_noisy_gaussian.png'
]
file_names = ['simple_rectangle_noisy_gaussian.png']
template = cv2.imread("input_images/template.jpg")
markers_pos = [(100, 40), (100, 150), (400, 40), (400, 150)]
thresh = 1
for f in file_names:
test_image = cv2.imread(INPUT_DIR + f)
ret_markers = ps3.find_markers(test_image, template)
self.assertTrue(len(markers_pos) == len(ret_markers),
msg='Not found exact number of markers. '
'Returned: {}. Expected: {}'
''.format(len(ret_markers), len(markers_pos)))
for act_pt, ret_pt in zip(markers_pos, ret_markers):
x_dist_test = abs(ret_pt[0] - act_pt[0]) <= thresh
self.assertTrue(x_dist_test,
msg='X point is too far from reference. '
'Returned: {}. Expected: {}'
''.format(ret_pt[0], act_pt[0]))
y_dist_test = abs(ret_pt[1] - act_pt[1]) <= thresh
self.assertTrue(y_dist_test,
msg='Y point is too far from reference. '
'Returned: {}. Expected: {}'
''.format(ret_pt[1], act_pt[1]))
def test_find_markers_simple_rectangle(self):
file_names = [
'simple_rectangle.png', 'simple_rectangle_noisy.png',
'simple_rectangle_noisy_gaussian.png'
]
template = cv2.imread("input_images/template.jpg")
markers_pos = [(100, 40), (100, 150), (400, 40), (400, 150)]
thresh = 1
for f in file_names:
test_image = cv2.imread(INPUT_DIR + f)
ret_markers = ps3.find_markers(test_image, template)
for act_pt, ret_pt in zip(markers_pos, ret_markers):
#print act_pt, ret_pt
#cv2.circle(test_image, act_pt, 1, (0,255,0), 2)
#cv2.circle(test_image, ret_pt, 1, (0,0,255), 2)
#cv2.imshow('res.png',test_image)
#cv2.waitKey(0)
x_dist_test = abs(ret_pt[0] - act_pt[0]) <= thresh
self.assertTrue(x_dist_test,
msg='X point is too far from reference. '
'Expected: {}. Returned: {}'
''.format(ret_pt[0], act_pt[0]))
y_dist_test = abs(ret_pt[1] - act_pt[1]) <= thresh
self.assertTrue(y_dist_test,
msg='Y point is too far from reference. '
'Expected: {}. Returned: {}'
''.format(ret_pt[1], act_pt[1]))
def part_6():
print("\nPart 6:")
video_file = "ps3-4-a.mp4"
my_video = "my-ad.mp4" # Place your video in the input_video directory
frame_ids = [355, 555, 725]
fps = 40
# Todo: Complete this part on your own.
video = os.path.join(VID_DIR, video_file)
image_gen = ps3.video_frame_generator(video)
embedded_video = os.path.join(VID_DIR, my_video)
embedded_gen = ps3.video_frame_generator(embedded_video)
image = image_gen.__next__()
h, w, d = image.shape
output_prefix = "ps3-6-a"
out_path = "ar_{}-{}".format(output_prefix[4:], video_file)
video_out = mp4_video_writer(out_path, (w, h), fps)
# video_frame_to_embed = embedded_gen.__next__()
# frame_num = 1
# while video_frame_to_embed is not None:
# frame_num += 1
# # todo remove
# video_frame_to_embed = embedded_gen.__next__()
# cv2.imwrite('out/frame_in/fram' + str(frame_num) + '.png', video_frame_to_embed)
# print("Processing fame {}".format(frame_num))
# Optional template image
template = cv2.imread(os.path.join(IMG_DIR, "template.jpg"))
first = embedded_gen.__next__()
video_frame_to_embed = first
is_repeat = False
output_counter = 1
frame_num = 1
while image is not None:
# todo remove
cv2.imwrite('out/frame_in/fram' + str(frame_num) + '.png', image)
print("Processing fame {}".format(frame_num))
if video_frame_to_embed is not None and not is_repeat:
video_frame_to_embed = embedded_gen.__next__()
if video_frame_to_embed is None:
video_frame_to_embed = first
is_repeat = True
src_points = ps3.get_corners_list(video_frame_to_embed)
markers = ps3.find_markers(image, template, fram_num=frame_num)
homography = ps3.find_four_point_transform(src_points, markers)
image = ps3.project_imageA_onto_imageB(video_frame_to_embed, image,
homography)
# for marker in markers:
# mark_location(image, marker)
frame_id = frame_ids[(output_counter - 1) % 3]
if frame_num == frame_id:
out_str = output_prefix + "-{}.png".format(output_counter)
save_image(out_str, image)
output_counter += 1
video_out.write(image)
image = image_gen.__next__()
frame_num += 1
video_out.release()
