def main(): """function to helps debug your image filtering algorithm. """ main_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) img_path = os.path.join(main_path, 'data', 'cat.bmp') test_image = mpimg.imread(img_path) test_image = imresize(test_image, 0.7, interp='bilinear') test_image = test_image.astype(np.float32) / 255 plt.figure('Image') plt.imshow(test_image) identity_filter = np.array([[0, 0, 0], [0, 1, 0], [0, 0, 0]], dtype=np.float32) identity_image = my_imfilter(test_image, identity_filter) identity_image_gt = ground_truth_imfilter(test_image, identity_filter) print('identity test') check(identity_image, identity_image_gt) ### Small blur with a box filter ### # This filter should remove some high frequencies blur_filter = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]], dtype=np.float64) blur_filter = blur_filter.astype(np.float) / np.sum( blur_filter) # making the filter sum to 1 blur_filter = np.ones((3, 3)) / 9 blur_image = my_imfilter(test_image, blur_filter) blur_image_gt = ground_truth_imfilter(test_image, blur_filter) print('blur test') check(blur_image, blur_image_gt) ### Large blur ### #This blur would be slow to do directly, so we instead use the fact that #Gaussian blurs are separable and blur sequentially in each direction. large_2d_blur_filter = gauss2D(shape=(25, 25), sigma=10) large_blur_image = my_imfilter(test_image, large_2d_blur_filter) large_blur_image_gt = ground_truth_imfilter(test_image, large_2d_blur_filter) print('large_2d_blur test') check(large_blur_image, large_blur_image_gt) ### Oriented filter (Sobel Operator) ### sobel_filter = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]) sobel_image = my_imfilter(test_image, sobel_filter) sobel_image_gt = ground_truth_imfilter(test_image, sobel_filter) #0.5 added because the output image is centered around zero otherwise and mostly black print('sobel test') check(sobel_image, sobel_image_gt) ### High pass filter (Discrete Laplacian) ### laplacian_filter = np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]]) laplacian_image = my_imfilter(test_image, laplacian_filter) laplacian_image_gt = ground_truth_imfilter(test_image, laplacian_filter) #0.5 added because the output image is centered around zero otherwise and mostly black print('laplacian test') check(laplacian_image, laplacian_image_gt) ### High pass "filter" alternative ### high_pass_image = test_image - blur_image #simply subtract the low frequency content high_pass_image_gt = test_image - blur_image_gt print('high pass test') check(high_pass_image, high_pass_image_gt)
def gaussian(): global image_cache cutoff_frequency = 2 gaussian_filter = gauss2D(shape=(cutoff_frequency * 4 + 1, cutoff_frequency * 4 + 1), sigma=cutoff_frequency) image_cache = my_imfilter(image_cache, gaussian_filter) show(image_cache)
def compute_LoG(image, LOG_type): imOut = np.zeros(shape=image.shape) if LOG_type == 1: gaussian = signal.convolve2d(image,gauss2D(0.5,5), mode="same") imOut = cv2.Laplacian(gaussian, ddepth=-1) plt.imshow(imOut,cmap='gray') plt.title('Method 1: Smoothing by Gaussian followed by Laplacian') plt.axis('off') #plt.show() plt.savefig('./log_results/method_1.pdf') elif LOG_type == 2: # computing the LoG kernel from scratch LoG_exact = compute_LoG_kernel(5,0.5) # take LoG kernel from internet #Log_internet = $$$ # deprecated, not correct #LoG = signal.convolve2d(gauss2D(0.5,5),np.array([[0,1,0],[1,-4,1],[0,1,0]]),mode="same") # compute for exact kernel imOut = signal.convolve2d(image,LoG_exact, mode="same") # compute for internet kernel #imOut = signal.convolve2d(image,LoG_internet, mode="same") plt.imshow(imOut,cmap='gray') plt.title('Method 2: Directly with LoG kernel') plt.axis('off') plt.savefig('./log_results/method_2.pdf') #plt.show() elif LOG_type == 3: DoG = gauss2D(0.5*np.sqrt(2),5)-gauss2D(0.5/np.sqrt(2),5) imOut = signal.convolve2d(image,DoG,mode="same") plt.imshow(imOut,cmap='gray') plt.title('Method 3: Difference of two Gaussians (DoG)') plt.axis('off') plt.savefig('./log_results/method_3.pdf') #plt.show() return imOut
def Gaussian(): global im_choose, imtk, lb2, lb7, choice, save_str Reset() gauss_filter = gauss2D(shape = (25, 25), sigma = 10) im_choose = np.squeeze(my_imfilter(im_choose, gauss_filter), axis = 2) if choice == 1: save_str = 'lena_gauss.bmp' else: save_str = 'babo_gauss.bmp' lb7 = tk.Label(window, text='- Done Gaussian -', width=20, height=1).place(x=362, y=60) Show_im()
plt.figure('Identity') plt.imshow(identity_image) ''' Small blur with a box filter ''' # This filter should remove some high frequencies blur_filter = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]]) blur_filter = blur_filter.astype(np.float) / np.sum(blur_filter) # making the filter sum to 1 blur_image = my_imfilter(test_image, blur_filter) plt.figure('Box filter') plt.imshow(normalize(blur_image)) plt.imsave(main_path + '/results/blur_image.png', normalize(blur_image + 0.5), 'quality', 95) ''' Large blur ''' #This blur would be slow to do directly, so we instead use the fact that #Gaussian blurs are separable and blur sequentially in each direction. large_2d_blur_filter = gauss2D(shape=(25, 25), sigma=10) large_blur_image = my_imfilter(test_image, large_2d_blur_filter) plt.figure('Gauss filter') plt.imshow(normalize(large_blur_image)) plt.imsave(main_path + '/results/large_blur_image.png', normalize(large_blur_image + 0.5), 'quality', 95) ''' Oriented filter (Sobel Operator) ''' sobel_filter = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]) sobel_image = my_imfilter(test_image, sobel_filter) #0.5 added because the output image is centered around zero otherwise and mostly black plt.figure('Sobel filter') plt.imshow(normalize(sobel_image + 0.5)) plt.imsave(main_path + '/results/sobel_image.png', normalize(sobel_image + 0.5), 'quality', 95) ''' High pass filter (Discrete Laplacian) '''
def main(): """function to helps debug your image filtering algorithm. """ # NOTE: __file__ has some problems in jupyter notebook main_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) img_path = os.path.join(main_path, 'data', 'cat.bmp') #main_path = '/Users/jimmyyuan/JimmyYuan/Computer Vision/homework-1' #img_path = '/Users/jimmyyuan/JimmyYuan/Computer Vision/homework-1/data/cat.bmp' test_image = mpimg.imread(img_path) test_image = imresize(test_image, 0.7, interp='bilinear') test_image = test_image.astype(np.float32) / 255 plt.figure('Image') plt.title('Image') plt.imshow(test_image) ### Identify filter ### # This filter should do nothing regardless of the padding method you use. identity_filter = np.array([[0, 0, 0], [0, 1, 0], [0, 0, 0]], dtype=np.float32) identity_image = my_imfilter(test_image, identity_filter) plt.figure('Identity') plt.title('Identity') plt.imshow(identity_image) ### Small blur with a box filter ### # This filter should remove some high frequencies blur_filter = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]]) # making the filter sum to 1 blur_filter = blur_filter.astype(np.float) / np.sum(blur_filter) blur_image = my_imfilter(test_image, blur_filter) plt.figure('Box filter') plt.title('Box filter') plt.imshow(normalize(blur_image)) plt.imsave(os.path.join(main_path, 'results', 'blur_image.png'), normalize(blur_image + 0.5), dpi=95) ### Large blur ### #This blur would be slow to do directly, so we instead use the fact that #Gaussian blurs are separable and blur sequentially in each direction. large_2d_blur_filter = gauss2D(shape=(25, 25), sigma=10) large_blur_image = my_imfilter(test_image, large_2d_blur_filter) plt.figure('Gauss filter') plt.title('Gauss filter') plt.imshow(normalize(large_blur_image)) plt.imsave(os.path.join(main_path, 'results', 'large_blur_image.png'), normalize(large_blur_image + 0.5), dpi=95) ### Oriented filter (Sobel Operator) ### sobel_filter = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]) sobel_image = my_imfilter(test_image, sobel_filter) #0.5 added because the output image is centered around zero otherwise and mostly black plt.figure('Sobel filter') plt.title('Sobel filter') plt.imshow(normalize(sobel_image + 0.5)) plt.imsave(os.path.join(main_path, 'results', 'sobel_image.png'), normalize(sobel_image + 0.5), dpi=95) ### High pass filter (Discrete Laplacian) ### laplacian_filter = np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]]) laplacian_image = my_imfilter(test_image, laplacian_filter) #0.5 added because the output image is centered around zero otherwise and mostly black plt.figure('Laplacian filter') plt.title('Laplacian filter') plt.imshow(normalize(laplacian_image + 0.5)) plt.imsave(os.path.join(main_path, 'results', 'laplacian_image.png'), normalize(laplacian_image + 0.5), dpi=95) ### High pass "filter" alternative ### high_pass_image = test_image - blur_image #simply subtract the low frequency content plt.figure('High pass filter') plt.title('High pass filter') plt.imshow(normalize(high_pass_image + 0.5)) plt.imsave(os.path.join(main_path, 'results', 'high_pass_image.png'), normalize(high_pass_image + 0.5), dpi=95) plt.show()
image1 = image1.astype(np.single) / 255 image2 = image2.astype(np.single) / 255 # Several additional test cases are provided for you, but feel free to make # your own (you'll need to align the images in a photo editor such as # Photoshop). The hybrid images will differ depending on which image you # assign as image1 (which will provide the low frequencies) and which image # you asign as image2 (which will provide the high frequencies) ''' Filtering and Hybrid Image construction ''' cutoff_frequency = 4 # This is the standard deviation, in pixels, of the # Gaussian blur that will remove the high frequencies from one image and # remove the low frequencies from another image (by subtracting a blurred # version from the original version). You will want to tune this for every # image pair to get the best results. gaussian_filter = gauss2D(shape=(cutoff_frequency * 4 + 1, cutoff_frequency * 4 + 1), sigma=cutoff_frequency) ######################################################################### # TODO: Use my_imfilter create 'low_frequencies' and # # 'high_frequencies' and then combine them to create 'hybrid_image' # ######################################################################### ######################################################################### # Remove the high frequencies from image1 by blurring it. The amount of # # blur that works best will vary with different image pairs # ######################################################################### low_frequencies = my_imfilter(image1, gaussian_filter) ############################################################################ # Remove the low frequencies from image2. The easiest way to do this is to # # subtract a blurred version of image2 from the original version of image2.#
def main(): """ function to create hybrid images """ # read images and convert to floating point format main_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) image1 = mpimg.imread(os.path.join(main_path, 'data', 'fish.bmp')) image2 = mpimg.imread(os.path.join(main_path, 'data', 'submarine.bmp')) image1 = image1.astype(np.float32) / 255 image2 = image2.astype(np.float32) / 255 # Several additional test cases are provided for you, but feel free to make # your own (you'll need to align the images in a photo editor such as # Photoshop). The hybrid images will differ depending on which image you # assign as image1 (which will provide the low frequencies) and which image # you asign as image2 (which will provide the high frequencies) ### Filtering and Hybrid Image construction ### cutoff_frequency = 7 # This is the standard deviation, in pixels, of the # Gaussian blur that will remove the high frequencies from one image and # remove the low frequencies from another image (by subtracting a blurred # version from the original version). You will want to tune this for every # image pair to get the best results. gaussian_filter = gauss2D(shape=(cutoff_frequency * 4 + 1, cutoff_frequency * 4 + 1), sigma=cutoff_frequency) ######################################################################### # TODO: Use my_imfilter create 'low_frequencies' and # # 'high_frequencies' and then combine them to create 'hybrid_image' # ######################################################################### ######################################################################### # Remove the high frequencies from image1 by blurring it. The amount of # # blur that works best will vary with different image pairs # ######################################################################### low_frequencies = my_imfilter(image1, gaussian_filter) ############################################################################ # Remove the low frequencies from image2. The easiest way to do this is to # # subtract a blurred version of image2 from the original version of image2.# # This will give you an image centered at zero with negative values. # ############################################################################ high_frequencies = image2 - my_imfilter(image2, gaussian_filter) ############################################################################ # Combine the high frequencies and low frequencies # ############################################################################ hybrid_image = high_frequencies + low_frequencies ### Visualize and save outputs ### plt.figure(1) plt.imshow(low_frequencies) plt.figure(2) plt.imshow(high_frequencies + 0.5) vis = vis_hybrid_image(hybrid_image) plt.figure(3) plt.imshow(vis) plt.imsave(os.path.join(main_path, 'results', 'fish_frequencies.png'), low_frequencies, dpi=95) plt.imsave(os.path.join(main_path, 'results', 'submarine_high_frequencies.png'), high_frequencies + 0.5, dpi=95) plt.imsave(os.path.join(main_path, 'results', 'fish_submarine_hybrid_image.png'), hybrid_image, dpi=95) plt.imsave(os.path.join(main_path, 'results', 'fish_submarine_hybrid_image_scales.png'), vis, dpi=95) plt.show()
# assign as image1 (which will provide the low frequencies) and which image # you asign as image2 (which will provide the high frequencies) ''' Filtering and Hybrid Image construction ''' cutoff_frequency = 7 cutoff_frequency_2 = 4 cutoff_frequency_3 = 6 cutoff_frequency_4 = 5.5 cutoff_frequency_5 = 5.5 cutoff_frequency_6 = 4.5 # This is the standard deviation, in pixels, of the # Gaussian blur that will remove the high frequencies from one image and # remove the low frequencies from another image (by subtracting a blurred # version from the original version). You will want to tune this for every # image pair to get the best results. gaussian_filter = gauss2D(shape=(cutoff_frequency * 4 + 1, cutoff_frequency * 4 + 1), sigma=cutoff_frequency) gaussian_filter_2 = gauss2D(shape=(cutoff_frequency_2 * 4 + 1, cutoff_frequency_2 * 4 + 1), sigma=cutoff_frequency_2) gaussian_filter_3 = gauss2D(shape=(cutoff_frequency_3 * 4 + 1, cutoff_frequency_3 * 4 + 1), sigma=cutoff_frequency_3) gaussian_filter_4 = gauss2D(shape=(cutoff_frequency_4 * 4 + 1, cutoff_frequency_4 * 4 + 1), sigma=cutoff_frequency_4) gaussian_filter_5 = gauss2D(shape=(cutoff_frequency_5 * 4 + 1, cutoff_frequency_5 * 4 + 1), sigma=cutoff_frequency_5) gaussian_filter_6 = gauss2D(shape=(cutoff_frequency_6 * 4 + 1, cutoff_frequency_6 * 4 + 1),