def optik_flowlk_write(img0, img1, iname, k_size, k_type, sigma, gks, gksd): #Try blurring your images or smoothing your results img0 = cv2.GaussianBlur(img0, (gks, gks), gksd) img1 = cv2.GaussianBlur(img1, (gks, gks), gksd) U, V = ps4.optic_flow_lk(img0, img1, k_size, k_type, sigma) # Flow image u_v = quiver(U, V, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, iname), 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. 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_1a(): 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. shift_r5_u5 = cv2.imread( os.path.join(input_dir, 'TestSeq', 'ShiftR5U5.png'), 0) / 255. # Optional: smooth the images if LK doesn't work well on raw images k_size = 55 k_type = "" sigma = 5 u, v = ps4.optic_flow_lk(shift_0, shift_r2, k_size, k_type, sigma) q = 0.5 u = u / q v = v / q # Flow image u_v = quiver(u, v, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-1-a-1.png"), u_v) # Now let's try with ShiftR5U5. You may want to try smoothing the # input images first. k_size = 81 k_type = "" sigma = 0 u, v = ps4.optic_flow_lk(shift_0, shift_r5_u5, k_size, k_type, sigma) q = .5 u = u / q v = v / q # Flow image u_v = quiver(u, v, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-1-a-2.png"), u_v)
def part_1(): 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. shift_r5_u5 = cv2.imread( os.path.join(input_dir, 'TestSeq', 'ShiftR5U5.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 black image, a window u_v = np.zeros(shift_0.shape, np.uint8) cv2.namedWindow('image') # create trackbars for color change cv2.createTrackbar('k_size', 'image', 3, 70, nothing) cv2.createTrackbar('k_type', 'image', 0, 1, nothing) cv2.createTrackbar('sigma', 'image', 1, 50, nothing) cv2.createTrackbar('blur', 'image', 0, 1, nothing) cv2.createTrackbar('blur_size', 'image', 1, 20, 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 k_size = cv2.getTrackbarPos('k_size', 'image') k_type = 'gaussian' if cv2.getTrackbarPos('k_type', 'image') == 1 else 'uniform' sigma = cv2.getTrackbarPos('sigma', 'image') blur = cv2.getTrackbarPos('blur', 'image') blur_size = cv2.getTrackbarPos('blur_size', 'image') img_1 = blur_img(shift_0, blur_size, blur) img_2 = blur_img(shift_r10, blur_size, blur) u, v = ps4.optic_flow_lk(img_1, img_2, k_size, k_type, sigma) # Flow image u_v = experiment.quiver(u, v, scale=3, stride=10) cv2.destroyAllWindows() print k_size, k_type, sigma, blur_size, blur
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_5a(): """Frame interpolation Follow the instructions in the problem set instructions. Place all your work in this file and this section. """ #I1(x0) = I0(x0 - tu0) I_0 = cv2.imread('input_images/TestSeq/Shift0.png', 0) / 1. I_1 = cv2.imread('input_images/TestSeq/ShiftR10.png', 0) / 1. 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 im_array = [] t_values = np.arange(0, 1.2, .2) U, V = ps4.optic_flow_lk(I_0, I_1, k_size=k_size, k_type=k_type, sigma=sigma) for val in t_values: print val scaled_U = U * val scaled_V = V * val warped = ps4.warp(I_0, U=-scaled_U, V=-scaled_V, interpolation=interpolation, border_mode=border_mode) cv2.imwrite(str(val) + '.png', warped) im_array.append(warped) 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-a-1.png', complete.astype(np.int16)) print 'FINISHED PART_5A'
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 test_optic_flow_LK(self): for i in range(3): print i 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.optic_flow_lk(img1.copy(), img2.copy(), self.k_size, self.k_type, 1.) 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]]) check_u = abs(u_mean - d_c) <= 0.5 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]]) check_v = abs(v_mean - d_r) <= 0.5 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_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. k = 11 sigma = 7 yos_img_02g = cv2.GaussianBlur(yos_img_02, ksize=(k, k), sigmaX=sigma, sigmaY=sigma) yos_img_03g = cv2.GaussianBlur(yos_img_03, ksize=(k, k), sigmaX=sigma, sigmaY=sigma) levels = 5 # Define the number of pyramid levels yos_img_02_g_pyr = ps4.gaussian_pyramid(yos_img_02g, levels) yos_img_03_g_pyr = ps4.gaussian_pyramid(yos_img_03g, levels) level_id = 0 # TODO: Select the level number (or id) you wish to use 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 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_1b(): """Performs the same operations applied in part_1a using the images ShiftR10, ShiftR20 and ShiftR40. You will compare the base image Shift0.png with the remaining images located in the directory TestSeq: - ShiftR10.png - ShiftR20.png - ShiftR40.png Make sure you explore different parameters and/or pre-process the input images to improve your results. In this part you should save the following images: - ps4-1-b-1.png - ps4-1-b-2.png - ps4-1-b-3.png Returns: None """ 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. # blur images gkernel = (25, 25) gsigma = 15 shift_0_blur = cv2.GaussianBlur(shift_0, gkernel, gsigma) shift_r10_blur = cv2.GaussianBlur(shift_r10, gkernel, gsigma) Shift_r20_blur = cv2.GaussianBlur(shift_r20, gkernel, gsigma) Shift_r40_blur = cv2.GaussianBlur(shift_r40, gkernel, gsigma) k_type = "uniform" sigma = 1 # shift_r10 k_size = 71 u, v = ps4.optic_flow_lk(shift_0_blur, shift_r10_blur, k_size, k_type, sigma) # Flow image u_v = quiver(u, v, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-1-b-1.png"), u_v) k_size = 71 u, v = ps4.optic_flow_lk(shift_0_blur, Shift_r20_blur, k_size, k_type, sigma) # Flow image u_v = quiver(u, v, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-1-b-2.png"), u_v) # shift_r40 k_size = 71 u, v = ps4.optic_flow_lk(shift_0_blur, Shift_r40_blur, k_size, k_type, sigma) # Flow image u_v = quiver(u, v, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-1-b-3.png"), u_v)
def part_1b(): """Performs the same operations applied in part_1a using the images ShiftR10, ShiftR20 and ShiftR40. You will compare the base image Shift0.png with the remaining images located in the directory TestSeq: - ShiftR10.png - ShiftR20.png - ShiftR40.png Make sure you explore different parameters and/or pre-process the input images to improve your results. In this part you should save the following images: - ps4-1-b-1.png - ps4-1-b-2.png - ps4-1-b-3.png Returns: None """ 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. # Optional: smooth the images if LK doesn't work well on raw images k = 31 sigma = 9 shift_0g = cv2.GaussianBlur(shift_0, ksize=(k, k), sigmaX=sigma, sigmaY=sigma) shift_r10g = cv2.GaussianBlur(shift_r10, ksize=(k, k), sigmaX=sigma, sigmaY=sigma) k_size = 65 # 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(shift_0g, shift_r10g, k_size, k_type, sigma) # Flow image u_v = quiver(u, v, scale=0.6, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-1-b-1.png"), u_v) # Now let's try with ShiftR5U5. You may want to try smoothing the k = 31 sigma = 15 shift_0g = cv2.GaussianBlur(shift_0, ksize=(k, k), sigmaX=sigma, sigmaY=sigma) shift_r20g = cv2.GaussianBlur(shift_r20, ksize=(k, k), sigmaX=sigma, sigmaY=sigma) k_size = 90 # 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(shift_0g, shift_r20g, k_size, k_type, sigma) # Flow image u_v = quiver(u, v, scale=0.5, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-1-b-2.png"), u_v) # Now let's try with ShiftR5U5. You may want to try smoothing the k = 61 sigma = 15 shift_0g = cv2.GaussianBlur(shift_0, ksize=(k, k), sigmaX=sigma, sigmaY=sigma) shift_r40g = cv2.GaussianBlur(shift_r40, ksize=(k, k), sigmaX=sigma, sigmaY=sigma) k_size = 120 # 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(shift_0g, shift_r40g, k_size, k_type, sigma) # Flow image u_v = quiver(u, v, scale=0.25, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-1-b-3.png"), u_v)
def part_1b(): """Performs the same operations applied in part_1a using the images ShiftR10, ShiftR20 and ShiftR40. You will compare the base image Shift0.png with the remaining images located in the directory TestSeq: - ShiftR10.png - ShiftR20.png - ShiftR40.png Make sure you explore different parameters and/or pre-process the input images to improve your results. In this part you should save the following images: - ps4-1-b-1.png - ps4-1-b-2.png - ps4-1-b-3.png Returns: None """ 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. # r10 img1 = blur_img(shift_0, blur_size=6) img2 = blur_img(shift_r10, blur_size=6) k_size = 56 k_type = "uniform" sigma = 0 u, v = ps4.optic_flow_lk(img1, img2, k_size, k_type, sigma) # Flow image u_v = quiver(u, v, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-1-b-1.png"), u_v) # r20 img1 = blur_img(shift_0, blur_size=10) img2 = blur_img(shift_r20, blur_size=10) k_size = 38 k_type = "uniform" sigma = 0 u, v = ps4.optic_flow_lk(img1, img2, k_size, k_type, sigma) # Flow image u_v = quiver(u, v, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-1-b-2.png"), u_v) # r40 img1 = blur_img(shift_0, blur_size=12) img2 = blur_img(shift_r40, blur_size=12) k_size = 47 k_type = "uniform" sigma = 0 u, v = ps4.optic_flow_lk(img1, img2, k_size, k_type, sigma) # Flow image u_v = quiver(u, v, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-1-b-3.png"), u_v)
def scale_u_and_v(u, v, level, pyr): """Scales up U and V arrays to match the image dimensions assigned to the first pyramid level: pyr[0]. You will use this method in part 3. In this section you are asked to select a level in the gaussian pyramid which contains images that are smaller than the one located in pyr[0]. This function should take the U and V arrays computed from this lower level and expand them to match a the size of pyr[0]. This function consists of a sequence of ps4.expand_image operations based on the pyramid level used to obtain both U and V. Multiply the result of expand_image by 2 to scale the vector values. After each expand_image operation you should adjust the resulting arrays to match the current level shape i.e. U.shape == pyr[current_level].shape and V.shape == pyr[current_level].shape. In case they don't, adjust the U and V arrays by removing the extra rows and columns. Hint: create a for loop from level-1 to 0 inclusive. Both resulting arrays' shapes should match pyr[0].shape. Args: u: U array obtained from ps4.optic_flow_lk v: V array obtained from ps4.optic_flow_lk level: level value used in the gaussian pyramid to obtain U and V (see part_3) pyr: gaussian pyramid used to verify the shapes of U and V at each iteration until the level 0 has been met. Returns: tuple: two-element tuple containing: u (numpy.array): scaled U array of shape equal to pyr[0].shape v (numpy.array): scaled V array of shape equal to pyr[0].shape """ # TODO: Your code here """ (uh, uw) = u.shape[:2] (vh, vw) = v.shape[:2] (h, w) = pyr[level].shape[:2] if not uh == h: U = U[:h-uh, :] if not uw == w: U = U[:, :w-uw] if not vh == h: V = V[:h-vh, :] if not vw == w: V = V[:, :w-vw] """ for lev in range(level, 0, -1): img = pyr[lev] (uh, uw) = u.shape[:2] (vh, vw) = v.shape[:2] (h, w) = img.shape[:2] if not uh == h: u = u[:h - uh, :] if not uw == w: u = u[:, :w - uw] if not vh == h: v = v[:h - vh, :] if not vw == w: v = v[:, :w - vw] u, v = ps4.optic_flow_lk(ps4.expand_image(img) * 2) img = pyr[0] (uh, uw) = u.shape[:2] (vh, vw) = v.shape[:2] (h, w) = img.shape[:2] if not uh == h: u = u[:h - uh, :] if not uw == w: u = u[:, :w - uw] if not vh == h: v = v[:h - vh, :] if not vw == w: v = v[:, :w - vw] return 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. """ video = os.path.join("input_videos", "ps4-my-video.mp4") image_gen = ps4.video_frame_generator(video) current = image_gen.__next__() current_resized = cv2.resize(current, (380, 760)) next = image_gen.__next__() fourcc = cv2.VideoWriter_fourcc(*'MP4V') video_out = cv2.VideoWriter("output.mp4", fourcc, 20, (380, 760)) frame_num = 1 while next is not None: # print("Processing fame {}".format(frame_num)) next_resized = cv2.resize(next, (380, 760)) k_size = 25 k_type = "" gray_current = cv2.cvtColor(current_resized, cv2.COLOR_BGR2GRAY) / 255 gray_next = cv2.cvtColor(next_resized, cv2.COLOR_BGR2GRAY) / 255 if frame_num > 20: cv2.imwrite("out/current.png", current_resized) cv2.imwrite("out/next.png", next_resized) gray_current = cv2.GaussianBlur(gray_current, (35, 35), 10) gray_next = cv2.GaussianBlur(gray_next, (35, 35), 10) u, v = ps4.optic_flow_lk(gray_current, gray_next, k_size, k_type, 0) u_abs = abs(u) v_abs = abs(v) # m = np.max([u_abs.max(), v_abs.max()]) m = np.max([np.average(u_abs), np.average(v_abs)]) print("Processing fame {}".format(frame_num), np.average(u), u.max(), np.average(v), v.max()) u = u / (m) v = v / (m) u_v = quiver(u, v, scale=3, stride=10) cv2.imwrite("out/video/quiver_" + str(frame_num) + ".png", u_v) red = current_resized[:, :, 2] red[u_v[:, :, 1] > 254] = 255 current_resized[:, :, 2] = red cv2.imwrite("out/frame/frame" + str(frame_num) + ".png", current_resized) video_out.write(current_resized) current_resized = next_resized next = image_gen.__next__() if next is not None: next_resized = cv2.resize(next, (380, 760)) frame_num += 1 video_out.release()
def part_1b(): """Performs the same operations applied in part_1a using the images ShiftR10, ShiftR20 and ShiftR40. You will compare the base image Shift0.png with the remaining images located in the directory TestSeq: - ShiftR10.png - ShiftR20.png - ShiftR40.png Make sure you explore different parameters and/or pre-process the input images to improve your results. In this part you should save the following images: - ps4-1-b-1.png - ps4-1-b-2.png - ps4-1-b-3.png Returns: None """ 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. k_size = 171 k_type = "gaussian" sigma = 60 shift_0 = cv2.GaussianBlur(shift_0, (35, 35), 10) shift_r10 = cv2.GaussianBlur(shift_r10, (35, 35), 10) u, v = ps4.optic_flow_lk(shift_0, shift_r10, k_size, k_type, sigma) q = 4.0 u = u / q v = v / q # Flow image u_v = quiver(u, v, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-1-b-1.png"), u_v) k_size = 181 k_type = "gaussian" sigma = 60 shift_r20 = cv2.GaussianBlur(shift_r20, (35, 35), 10) u, v = ps4.optic_flow_lk(shift_0, shift_r20, k_size, k_type, sigma) q = 3.5 u = u / q v = v / q # Flow image u_v = quiver(u, v, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-1-b-2.png"), u_v) k_size = 181 k_type = "ave" sigma = 60 shift_0 = cv2.GaussianBlur(shift_0, (25, 25), 15) shift_r40 = cv2.GaussianBlur(shift_r40, (25, 25), 15) shift_r40 = cv2.GaussianBlur(shift_r40, (25, 25), 15) u, v = ps4.optic_flow_lk(shift_0, shift_r40, k_size, k_type, sigma) q = 2.0 u = u / q v = v / q # Flow image u_v = quiver(u, v, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-1-b-3.png"), u_v)
def part_1b(): """Performs the same operations applied in part_1a using the images ShiftR10, ShiftR20 and ShiftR40. You will compare the base image Shift0.png with the remaining images located in the directory TestSeq: - ShiftR10.png - ShiftR20.png - ShiftR40.png Make sure you explore different parameters and/or pre-process the input images to improve your results. In this part you should save the following images: - ps4-1-b-1.png - ps4-1-b-2.png - ps4-1-b-3.png Returns: None """ 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. k_type = 'uniform' sigma = 0.5 # 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 # # k_size = cv2.getTrackbarPos('kSize', 'Params') # u, v = ps4.optic_flow_lk(shift_0, shift_r20, k_size, k_type, sigma) # u_v = quiver(u, v, scale=3, stride=10) # cv2.imshow("Params", u_v) # change k size per thing to see impact. k_size = 41 u, v = ps4.optic_flow_lk(shift_0, shift_r10, k_size, k_type, sigma) u_v = quiver(u, v, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-1-b-1.png"), u_v) k_size = 63 u, v = ps4.optic_flow_lk(shift_0, shift_r20, k_size, k_type, sigma) u_v = quiver(u, v, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-1-b-2.png"), u_v) k_size = 63 u, v = ps4.optic_flow_lk(shift_0, shift_r40, k_size, k_type, sigma) u_v = quiver(u, v, scale=3, stride=10) cv2.imwrite(os.path.join(output_dir, "ps4-1-b-3.png"), u_v)