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 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 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_7(input_video, input_image, output_video, output_prefix,
frame_ids, fps, aruco_dict):
# read a video
vs = cv2.VideoCapture(os.path.join(VID_DIR, input_video))
writer = None
# read an image and find corner coordinates
image = cv2.imread(os.path.join(IMG_DIR, input_image))
src_points = ps3.get_corners_list(image)
# iterate each frame of the video
frame_num = 0
output_counter = 0
while True:
frame_num += 1
print("processing frame {}...".format(frame_num))
# grab the next frame from the video
(grabbed, frame) = vs.read()
if not grabbed:
break
# detect all ArUco markers and their ID in the frame
markers, ids = ps3.find_aruco_markers(frame, aruco_dict)
if len(markers) == 4:
# find the centers of four ArUco markers
centers = ps3.find_aruco_center(markers, ids)
# project the input image onto a wall image with ArUco markers
homography = ps3.find_four_point_transform(src_points, centers)
frame = ps3.project_imageA_onto_imageB(image, frame, homography)
# mark the center and place an ID string of each ArUco marker
for center, id in zip(centers, ids):
cv2.circle(frame, center, 4, (0, 255, 0), -1)
cv2.putText(frame, "id=" + str(id), center,
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
# check for video writer and if there is none, initialize one
if writer is None:
writer = mp4_video_writer(output_video,
(frame.shape[1], frame.shape[0]), fps)
# save frames according to the given frame ID list
frame_id = frame_ids[output_counter % len(frame_ids)]
if frame_num == frame_id:
output_counter += 1
out_str = output_prefix + "-{}.png".format(output_counter)
save_image(out_str, frame)
# write the output frame to disk
writer.write(frame)
print("releasing the file pointers...")
writer.release()
vs.release()
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_get_corners_list(self):
clist = ps3.get_corners_list(np.zeros((self.height, self.width)))
self.assertEqual(len(clist), 4, msg="List should have a length of 4.")
lengthError = "Each item in the marker list should have length of 2."
self.assertEqual(len(clist[0]), 2, msg=lengthError)
ValueIndexError = "%s value at index %d off by %f"
for i, (a, b) in enumerate(zip(clist, self.corner_positions)):
self.assertEqual(a[0],
b[0],
msg=ValueIndexError % ('X', i, abs(a[0] - b[0])))
self.assertEqual(a[1],
b[1],
msg=ValueIndexError % ('Y', i, abs(a[1] - b[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()
