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_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_projecting_image(self): black_bg = np.zeros_like(self.test_grad_image) # Get the student's result ret_image = ps3.project_imageA_onto_imageB(self.test_grad_image.copy(), black_bg, self.homography) err_msg = "Output array shape should be same shape " \ "as 2nd parameter image." self.assertEqual(ret_image.shape, black_bg.shape, msg=err_msg) self.assertEqual(ret_image.dtype, black_bg.dtype, msg=err_msg) # Creates a comparison final image comparison_image = cv2.warpPerspective(self.test_grad_image, self.homography, (self.width, self.height)) # Test the entire image total value difference diff = ssim(ret_image, comparison_image, 1e-3, 1e-3) acceptable_ssim = 0.95 error_msg = "Warp is too far from expected result (diff={})".format( diff) self.assertTrue(diff >= acceptable_ssim, msg=error_msg)
def test_transform(): height, width = 200, 500 corner_positions = [(0, 0), (0, height - 1), (width - 1, 0), (width - 1, height - 1)] marker_positions = [(145, 54), (154, 150), (360, 70), (340, 130)] y = np.linspace(1, 255, height) x = np.linspace(1, 255, width) a, b = np.meshgrid(x, y) test_grad_image = cv2.merge((a, b, b[::-1])).astype('uint8') black_bg = np.zeros_like(test_grad_image) homography = cv2.getPerspectiveTransform( np.array(corner_positions, 'float32'), np.array(marker_positions, 'float32')) cv2.imshow('A', test_grad_image) cv2.imshow('B', black_bg) print 'homography:\n', homography ret_image = ps3.project_imageA_onto_imageB(test_grad_image, black_bg, homography) cv2.imshow('res', ret_image) true_image = cv2.warpPerspective(test_grad_image, homography, (width, height)) cv2.imshow('true', true_image) cv2.waitKey()
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 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()