def interpolate(img0, img1, levels, k_size, k_type, sigma, interpolation, border_mode): # Hierarchical Lucas-Kanade method forward and backward direction ufwd, vfwd = ps4.hierarchical_lk(img0, img1, levels, k_size, k_type, sigma, interpolation, border_mode) ubwd, vbwd = ps4.hierarchical_lk(img1, img0, levels, k_size, k_type, sigma, interpolation, border_mode) # Save the flows, including the first which is raw image #flowls = [ps4.warp(img0, -0.2*i*u, -0.2*i*v, interpolation, border_mode) for i in range(0,5)] flowlsfwd = [img0] flowlsbwd = [img1] for i in range(1, 3): flowlsfwd.append( ps4.warp(flowlsfwd[-1], -0.2 * ufwd, -0.2 * vfwd, interpolation, border_mode)) flowlsbwd.append( ps4.warp(flowlsbwd[-1], -0.2 * ubwd, -0.2 * vbwd, interpolation, border_mode)) #print(flowlsfwd[0].shape, flowlsbwd[0].shape) # Stack the image frames frames = np.vstack((np.hstack(flowlsfwd), np.hstack(flowlsbwd[::-1]))) return frames
def part_4a(): 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. shift_r20 = cv2.imread(os.path.join(input_dir, 'TestSeq', 'ShiftR20.png'), 0) / 255. shift_r40 = cv2.imread(os.path.join(input_dir, 'TestSeq', 'ShiftR40.png'), 0) / 255. levels = 5 k_type = "gaussian" interpolation = cv2.INTER_CUBIC # You may try different values border_mode = cv2.BORDER_REFLECT101 # You may try different values u10, v10 = ps4.hierarchical_lk(shift_0, shift_r10, levels, 25, k_type, 1, interpolation, border_mode) u_v = quiver(u10, v10, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-4-a-1.png"), u_v) # You may want to try different parameters for the remaining function # calls. u20, v20 = ps4.hierarchical_lk(shift_0, shift_r20, levels, 25, k_type, 2, interpolation, border_mode) u_v = quiver(u20, v20, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-4-a-2.png"), u_v) u40, v40 = ps4.hierarchical_lk(shift_0, shift_r40, levels, 45, k_type, 3, interpolation, border_mode) u_v = quiver(u40, v40, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-4-a-3.png"), u_v)
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_4a(): 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. shift_r20 = cv2.imread(os.path.join(input_dir, 'TestSeq', 'ShiftR20.png'), 0) / 255. shift_r40 = cv2.imread(os.path.join(input_dir, 'TestSeq', 'ShiftR40.png'), 0) / 255. levels = 3 # TODO: Define the number of levels 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 interpolation = cv2.INTER_CUBIC # You may try different values border_mode = cv2.BORDER_REFLECT101 # You may try different values u10, v10 = ps4.hierarchical_lk(shift_0, shift_r10, levels, k_size, k_type, sigma, interpolation, border_mode) u_v = quiver(u10, v10, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-4-a-1.png"), u_v) # You may want to try different parameters for the remaining function # calls. u20, v20 = ps4.hierarchical_lk(shift_0, shift_r20, levels, k_size, k_type, sigma, interpolation, border_mode) u_v = quiver(u20, v20, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-4-a-2.png"), u_v) u40, v40 = ps4.hierarchical_lk(shift_0, shift_r40, levels, k_size, k_type, sigma, interpolation, border_mode) u_v = quiver(u40, v40, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-4-a-3.png"), u_v)
def part_4a(): 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. shift_r20 = cv2.imread(os.path.join(input_dir, 'TestSeq', 'ShiftR20.png'), 0) / 255. shift_r40 = cv2.imread(os.path.join(input_dir, 'TestSeq', 'ShiftR40.png'), 0) / 255. levels = 2 # TODO: Define the number of levels k_size = 0 # TODO: Select a kernel size k_type = "gaussian" # TODO: Select a kernel type sigma = 30 # 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 shift_0 = cv2.GaussianBlur(shift_0, (35, 35), 10) shift_r10 = cv2.GaussianBlur(shift_r10, (35, 35), 10) u, v = ps4.hierarchical_lk(shift_0, shift_r10, levels, k_size, k_type, sigma, interpolation, border_mode) q = 5.0 u = u / q v = v / q # u_v = quiver(u, v, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-4-a-1.png"), u_v) # # # You may want to try different parameters for the remaining function # # calls. levels = 3 shift_r20 = cv2.GaussianBlur(shift_r20, (35, 35), 10) u, v = ps4.hierarchical_lk(shift_0, shift_r20, levels, k_size, k_type, sigma, interpolation, border_mode) q = 10.0 u = u / q v = v / q u_v = quiver(u, v, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-4-a-2.png"), u_v) # levels = 3 shift_r40 = cv2.GaussianBlur(shift_r40, (35, 35), 10) u, v = ps4.hierarchical_lk(shift_0, shift_r40, levels, k_size, k_type, sigma, interpolation, border_mode) q = 15.0 u = u / q v = v / q u_v = quiver(u, v, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-4-a-3.png"), u_v)
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_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_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_6(): """Challenge Problem Follow the instructions in the problem set instructions. Place all your work in this file and this section. """ k_size = 25 levels = 3 interpolation = cv2.INTER_CUBIC # You may try different values border_mode = cv2.BORDER_REFLECT101 # You may try different values input_video_path = os.path.join('input_videos', 'ps4-my-video.mp4') output_video_path = os.path.join(output_dir, 'ps4-6.mp4') video_in = video_frame_generator(input_video_path) prev_frame = video_in.next() h, w, d = prev_frame.shape fourcc = cv2.cv.CV_FOURCC(*'mp4v') video_out = cv2.VideoWriter(output_video_path, fourcc, 20, (w, h)) export_frames = [50, 100] n_export = 1 i = 0 while 1: print "processing: " + str(i) next_frame = video_in.next() if next_frame is None: break u, v = ps4.hierarchical_lk(to_gray_float(prev_frame), to_gray_float(next_frame), levels, k_size, 'uniform', 0, interpolation, border_mode) u_v = quiver(u, v, scale=3, stride=20) out_frame = prev_frame.copy() out_frame[u_v[:, :, 1] != 0] = (0, 255, 0) if i in export_frames: cv2.imwrite( os.path.join(output_dir, "ps4-6-a-{}.png".format(n_export)), out_frame) n_export += 1 video_out.write(out_frame) prev_frame = next_frame i += 1 video_out.release()
def helper_for_part_6(video_name, fps, frame_ids, output_prefix, counter_init): video = os.path.join(video_dir, video_name) image_gen = video_frame_generator(video) image_a = image_gen.next() # frame 1 image_b = image_gen.next() h, w, d = image_a.shape levels = 8 k_size = 41 k_type = 'uniform' interpolation = cv2.INTER_CUBIC # You may try different values border_mode = cv2.BORDER_REFLECT101 # You may try different values out_path = "output/ar_{}-{}".format(output_prefix[4:], video_name) video_out = mp4_video_writer(out_path, (w, h), fps) output_counter = counter_init frame_num = 1 output_counter = 0 output_frame = frame_ids[output_counter] while image_b is not None: a = cv2.cvtColor(image_a.copy(), cv2.COLOR_BGR2GRAY) b = cv2.cvtColor(image_b.copy(), cv2.COLOR_BGR2GRAY) u, v = ps4.hierarchical_lk(a, b, levels, k_size, k_type, 0, interpolation, border_mode) image = quiver(u, v, scale=3, stride=10, base_image=image_a) if output_counter < len(frame_ids) and frame_num == output_frame: print 'Saving image of {}'.format(frame_num) out_str = "frame-{}.png".format(frame_num) save_image(out_str, image) output_counter += 1 if output_counter < len(frame_ids): output_frame = frame_ids[output_counter] print 'Saving Next {} : Data of {} and {}'.format( output_frame, output_counter, len(frame_ids)) # video_out.write(image) image_a = image_b.copy() image_b = image_gen.next() # save_image('b.png', image_b) # image_b = cv2.imread('output/b.png', 0) / 1. frame_num += 1 print 'Frame: {}'.format(frame_num) video_out.release()
def part_6(): """Challenge Problem Follow the instructions in the problem set instructions. Place all your work in this file and this section. """ video = os.path.join(vid_dir, "ps4-my-video.mp4") frame_gen = video_frame_generator(video) #for i in range(150): frame1 = frame_gen.next() frame2 = frame_gen.next() h, w = frame1.shape[:2] out_path = os.path.join(output_dir, "video_out.mp4") video_out = mp4_video_writer(out_path, (w, h), fps=40) 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 = 5 print "img shape: {}".format(frame1.shape) cv2.imwrite(os.path.join(output_dir, "frame1.png"), frame1) frame_num = 1 while frame2 is not None and frame1 is not None and frame_num <= 1000: print "Processing Frame {}".format(frame_num) img1 = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY) / 255.0 img2 = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY) / 255.0 img1 = cv2.GaussianBlur(img1, (15, 15), 0.05) img2 = cv2.GaussianBlur(img2, (15, 15), 0.05) #img1 = ps4.normalize_and_scale(img1) #img2 = ps4.normalize_and_scale(img2) u, v = ps4.hierarchical_lk(img1, img2, levels, k_size, k_type, sigma, interpolation, border_mode) quiver_image = quiver_img(frame1, u, v, scale=3, stride=10) #print "u shape: {}".format(u.shape) #print "v shape: {}".format(v.shape) if frame_num == 50: u_v = quiver_img(frame1, u, v, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-6-a-1.png"), u_v) elif frame_num == 100: u_v = quiver_img(frame1, u, v, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-6-a-2.png"), u_v) frame1 = frame2 frame2 = frame_gen.next() video_out.write(quiver_image) frame_num += 1
def helper_for_part_6(video_name, fps, frame_ids, output_prefix, counter_init): video = os.path.join(VID_DIR, video_name) image_gen = video_frame_generator(video) image = image_gen.__next__() image_pre = image 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) output_counter = counter_init frame_num = 1 while image is not None: print("Processing fame {}".format(frame_num)) image_pre_grey = cv2.cvtColor(image_pre, cv2.COLOR_BGR2GRAY) image_grey = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) levels = 4 k_size = 75 k_type = "uniform" sigma = 0.1 interpolation = cv2.INTER_CUBIC border_mode = cv2.BORDER_REFLECT101 u, v = ps4.hierarchical_lk(image_pre_grey, image_grey, levels, k_size, k_type, sigma, interpolation, border_mode) u_v = quiver(u, v, scale=0.1, stride=20, color=(255, 255, 255)) res = np.copy(image) res = cv2.addWeighted(res,0.7, u_v, 1, 0.7) frame_id = frame_ids[(output_counter - 1) % 2] if frame_num == frame_id: out_str = output_prefix + "-{}.png".format(output_counter) save_image(out_str, res) output_counter += 1 video_out.write(res) image_pre = image image = image_gen.__next__() frame_num += 1 video_out.release()
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_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. # Optional: smooth the images if LK doesn't work well on raw images k_size = 91 # 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 levels = 4 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_r10, k_size, k_type, sigma) u10, v10 = ps4.hierarchical_lk(shift_0, shift_r10, levels, k_size, k_type, sigma, interpolation, border_mode) u_v = quiver(u10, v10, scale=3, stride=10) # cv2.imwrite(os.path.join(output_dir, "out/ps4-5-a-1.png"), u_v) # cv2.imwrite("out/I_0.png", shift_0*255) I_t_02 = interpolate_frames(shift_0, shift_r10, 0.2, u10, v10) # cv2.imwrite("out/I_t_02.png", ps4.normalize_and_scale(I_t_02.astype(np.float))) I_t_04 = interpolate_frames(shift_0, shift_r10, 0.4, u10, v10) # cv2.imwrite("out/I_t_04.png", ps4.normalize_and_scale(I_t_04.astype(np.float))) I_t_06 = interpolate_frames(shift_0, shift_r10, 0.6, u10, v10) # cv2.imwrite("out/I_t_06.png", I_t_06.astype(np.float) * 255) I_t_08 = interpolate_frames(shift_0, shift_r10, 0.8, u10, v10) # cv2.imwrite("out/I_t_08.png", I_t_08.astype(np.float) * 255) # cv2.imwrite("out/I_1.png", shift_r10*255) result = create_2_by_3_image(shift_0, I_t_02, I_t_04, I_t_06, I_t_08, shift_r10) cv2.imwrite("ps4-5-a-1.png", result * 255)
def interpolate_frames(img_a, img_b, levels=4, k_size=13, n_add=4): interpolation = cv2.INTER_CUBIC # You may try different values border_mode = cv2.BORDER_REFLECT101 # You may try different values u, v = ps4.hierarchical_lk(img_b, img_a, levels, k_size, 'uniform', 0, interpolation, border_mode) u = u / (n_add + 1) v = v / (n_add + 1) frames = [img_a] for i in range(n_add): f = ps4.warp(frames[i], u, v, interpolation, border_mode) frames.append(f) frames.append(img_b) return 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. 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_4a(): 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. shift_r20 = cv2.imread(os.path.join(input_dir, 'TestSeq', 'ShiftR20.png'), 0) / 255. shift_r40 = cv2.imread(os.path.join(input_dir, 'TestSeq', 'ShiftR40.png'), 0) / 255. # Create a window cv2.namedWindow('image') u_v = np.zeros(shift_0.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(shift_0, shift_r20, levels, k_size, k_type, sigma, interpolation, border_mode) u_v = experiment.quiver(u, v, scale=3, stride=10) cv2.destroyAllWindows() print levels, k_size, k_type, sigma
def test_optic_flow_HLK(self): for i in range(3): f1 = self.input_imgs_1[i] f2 = self.input_imgs_2[i] img1 = cv2.imread(INPUT_DIR + f1, 0) / 255. img2 = cv2.imread(INPUT_DIR + f2, 0) / 255. u, v = ps4.hierarchical_lk(img1.copy(), img2.copy(), 3, self.k_size, self.k_type, 1., cv2.INTER_CUBIC, cv2.BORDER_REFLECT101) r = self.r_val[i] c = self.c_val[i] d_c = self.delta_c[i] d_r = self.delta_r[i] center_box = self.cb[i] u_mean = np.mean(u[r:r + center_box[0], c:c + center_box[1]]) max_diff = abs(d_c) * .1 + .2 check_u = abs(u_mean - d_c) < max_diff error_msg = "Average of U values in the area where there is " \ "movement is greater than the allowed amount." self.assertTrue(check_u, error_msg) v_mean = np.mean(v[r:r + center_box[0], c:c + center_box[1]]) max_diff = abs(d_r) * .1 + .2 check_v = abs(v_mean - d_r) < max_diff error_msg = "Average of V values in the area where there is " \ "movement is greater than the allowed amount." self.assertTrue(check_v, error_msg)
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_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_6(): """Challenge Problem Follow the instructions in the problem set instructions. Place all your work in this file and this section. """ IMG_DIR = "input_images" VID_DIR = "input_videos" OUT_DIR = "output" if not os.path.isdir(OUT_DIR): os.makedirs(OUT_DIR) video_file = "ps4-my-video.mp4" fps = 40 counter_init = 1 output_prefix = 'part_6' # Todo: Complete this part on your own.' video = os.path.join(VID_DIR, video_file) image_gen = video_frame_generator(video) image1 = image_gen.__next__() image2 = image_gen.__next__() h, w, d = image1.shape out_path = "output/ar_{}-{}".format('part_6', 'quiver.mp4') video_out = mp4_video_writer(out_path, (w, h), fps) output_counter = counter_init frame_num = 1 interpolation = cv2.INTER_CUBIC # You may try different values border_mode = cv2.BORDER_REFLECT101 # You may try different values while image2 is not None: print("Processing fame {}".format(frame_num)) k = 15 sigma = 7 image1g = cv2.GaussianBlur(image1, ksize=(k, k), sigmaX=sigma, sigmaY=sigma) image2g = cv2.GaussianBlur(image2, ksize=(k, k), sigmaX=sigma, sigmaY=sigma) levels = 4 k_size = 30 u20, v20 = ps4.hierarchical_lk(image1g[:, :, 0] / 255., image2g[:, :, 0] / 255., 4, k_size, k_type, sigma, interpolation, border_mode) u_v = quiver_(u20, v20, image1, scale=3, stride=10) 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, u_v) output_counter += 1 video_out.write(u_v) image1 = image2.copy() image2 = image_gen.__next__() frame_num += 1 video_out.release()
def part_5a(): """Frame interpolation Follow the instructions in the problem set instructions. Place all your work in this file and this section. """ k_type = 'uniform' border_mode = cv2.BORDER_REFLECT101 # You may try different values interpolation = cv2.INTER_CUBIC images = [] # need intervals for 0.2, 0.4, 0.6, 0.8. arange is not end inclusive. intervals = np.arange(0.2, 1, 0.2) image_1 = cv2.imread('input_images/TestSeq/Shift0.png', 0) / 1. image_2 = cv2.imread('input_images/TestSeq/ShiftR10.png', 0) / 1. images.append(image_1) # add t0 cv2.imwrite(os.path.join(output_dir, '{}.png'.format(str(0))), image_1) k_size = 21 # loop over time intervals. counter = 1 img = image_1.copy() for i in intervals: U, V = ps4.hierarchical_lk(img, image_2, levels=4, k_size=k_size, k_type=k_type, sigma=0, interpolation=interpolation, border_mode=border_mode) # orientate and scale U = -U * i V = -V * i warped = ps4.warp(img, U, V, interpolation=interpolation, border_mode=border_mode) cv2.imwrite(os.path.join(output_dir, '{}.png'.format(str(counter))), warped) images.append(warped) img = warped counter += 1 images.append(image_2) # add t1 cv2.imwrite(os.path.join(output_dir, '{}.png'.format(str(counter))), image_2) # build output image # r1 0, 0.2, 0.4 # r2 0.6, 0.8, 1 row_1 = np.concatenate((images[0], images[1], images[2]), axis=1) row_2 = np.concatenate((images[3], images[4], images[5]), axis=1) output = np.concatenate((row_1, row_2), axis=0) cv2.imwrite(os.path.join(output_dir, 'ps4-5-1-a-1.png'), output)
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. """ k_type = 'uniform' border_mode = cv2.BORDER_REFLECT101 # You may try different values interpolation = cv2.INTER_CUBIC images = [] # need intervals for 0, 0.2, 0.4, 0.6, 0.8 and 1. arange is not end inclusive. intervals = np.arange(0.2, 1, 0.2) image_1 = cv2.imread('input_images/MiniCooper/mc01.png', 0) / 1. image_2 = cv2.imread('input_images/MiniCooper/mc02.png', 0) / 1. images.append(image_1) cv2.imwrite(os.path.join(output_dir, '{}.png'.format(str(10))), image_1) k_size = 45 # # loop over time intervals. counter = 11 img = image_1 for i in intervals: # from the current interval image to desired output. U, V = ps4.hierarchical_lk(img, image_2, levels=4, k_size=k_size, k_type=k_type, sigma=0, interpolation=interpolation, border_mode=border_mode) # orientate. U = -U # * i V = -V # * i warped = ps4.warp(img, U, V, interpolation=interpolation, border_mode=border_mode) img = warped # reset for next iteration cv2.imwrite(os.path.join(output_dir, '{}.png'.format(str(counter))), warped) images.append(warped) counter += 1 images.append(image_2) cv2.imwrite(os.path.join(output_dir, '{}.png'.format(str(counter))), image_2) # build output image # r1 0, 0.2, 0.4 # r2 0.6, 0.8, 1 row_1 = np.concatenate((images[0], images[1], images[2]), axis=1) row_2 = np.concatenate((images[3], images[4], images[5]), axis=1) output = np.concatenate((row_1, row_2), axis=0) cv2.imwrite(os.path.join(output_dir, 'ps4-5-1-b-1.png'), output) # part 2 images = [] image_1 = cv2.imread('input_images/MiniCooper/mc02.png', 0) / 1. image_2 = cv2.imread('input_images/MiniCooper/mc03.png', 0) / 1. images.append(image_1) k_size = 45 # # loop over time intervals. counter = 21 img = image_1 for i in intervals: # from the current interval image to desired output. U, V = ps4.hierarchical_lk(img, image_2, levels=4, k_size=k_size, k_type=k_type, sigma=0, interpolation=interpolation, border_mode=border_mode) # orientate. U = -U # * i V = -V # * i warped = ps4.warp(img, U, V, interpolation=interpolation, border_mode=border_mode) img = warped # reset for next iteration cv2.imwrite(os.path.join(output_dir, '{}.png'.format(str(counter))), warped) images.append(warped) counter += 1 images.append(image_2) cv2.imwrite(os.path.join(output_dir, '{}.png'.format(str(counter))), image_2) # build output image # r1 0, 0.2, 0.4 # r2 0.6, 0.8, 1 row_1 = np.concatenate((images[0], images[1], images[2]), axis=1) row_2 = np.concatenate((images[3], images[4], images[5]), axis=1) output = np.concatenate((row_1, row_2), axis=0) cv2.imwrite(os.path.join(output_dir, 'ps4-5-1-b-2.png'), output)
def part_5b(): """Frame interpolation Follow the instructions in the problem set instructions. Place all your work in this file and this section. """ I_0 = cv2.imread('input_images/MiniCooper/mc01.png', 0) / 1. I_1 = cv2.imread('input_images/MiniCooper/mc02.png', 0) / 1. # I_0 = cv2.blur(I_0, (15, 15)) # I_1 = cv2.blur(I_1, (15, 15)) k_size = 33 # 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 im_array = [] t_values = np.arange(0, 1.2, .2) # for i in range(15, 85, 2): # # U, V = ps4.hierarchical_lk(I_0, I_1, levels=4, k_size=i, k_type=k_type, sigma=sigma, # interpolation=interpolation, border_mode=border_mode) # # # print i # u_v = quiver(U, V, scale=3, stride=10) # cv2.imwrite(str(i)+'.png', u_v) # # return None I_temp = I_0 for val in t_values: U, V = ps4.hierarchical_lk(I_temp, I_1, levels=4, k_size=k_size, k_type=k_type, sigma=sigma, interpolation=interpolation, border_mode=border_mode) # Unew, Vnew = cv2.blur(U, (3,3)), cv2.blur(V, (3,3)) dst = ps4.warp(I_0, U=-U * val, V=-V * val, interpolation=interpolation, border_mode=border_mode) I_temp = dst # warped = warped.astype('uint8') # dst = cv2.fastNlMeansDenoising(warped, None, searchWindowSize=21, templateWindowSize=7, h=10) # warped = cv2.fastNlMeansDenoising(warped,10,10,10) # warped = cv2.blur(warped, (3,3)) im_array.append(dst) cv2.imwrite(str(val) + '.png', dst) im_array[-1] = I_1 r1 = np.concatenate((im_array[0], im_array[1], im_array[2]), axis=1) r2 = np.concatenate((im_array[3], im_array[4], im_array[5]), axis=1) complete = np.concatenate((r1, r2), axis=0) cv2.imwrite('output/ps4-5-1-b-1.png', complete) ## ##starting on mc2 --> mc3 ## I_0 = cv2.imread('input_images/MiniCooper/mc02.png', 0) / 1. I_1 = cv2.imread('input_images/MiniCooper/mc03.png', 0) / 1. # I_0 = cv2.blur(I_0, (15, 15)) # I_1 = cv2.blur(I_1, (15, 15)) k_size = 33 # 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 im_array = [] t_values = np.arange(0, 1.2, .2) I_temp = I_0 for val in t_values: U, V = ps4.hierarchical_lk(I_temp, I_1, levels=4, k_size=k_size, k_type=k_type, sigma=sigma, interpolation=interpolation, border_mode=border_mode) # Unew, Vnew = cv2.blur(U, (3,3)), cv2.blur(V, (3,3)) dst = ps4.warp(I_0, U=-U * val, V=-V * val, interpolation=interpolation, border_mode=border_mode) I_temp = dst # warped = warped.astype('uint8') # dst = cv2.fastNlMeansDenoising(warped, None, searchWindowSize=21, templateWindowSize=7, h=10) # warped = cv2.fastNlMeansDenoising(warped,10,10,10) # warped = cv2.blur(warped, (3,3)) im_array.append(dst) cv2.imwrite(str(val) + '.png', dst) im_array[-1] = I_1 r1 = np.concatenate((im_array[0], im_array[1], im_array[2]), axis=1) r2 = np.concatenate((im_array[3], im_array[4], im_array[5]), axis=1) complete = np.concatenate((r1, r2), axis=0) cv2.imwrite('output/ps4-5-1-b-2.png', complete.astype(np.int16))
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)