def test_fast_homography(): img = rgb2gray(data.lena()).astype(np.uint8) img = img[:, :100] theta = np.deg2rad(30) scale = 0.5 tx, ty = 50, 50 H = np.eye(3) S = scale * np.sin(theta) C = scale * np.cos(theta) H[:2, :2] = [[C, -S], [S, C]] H[:2, 2] = [tx, ty] for mode in ('constant', 'mirror', 'wrap'): print 'Transform mode:', mode p0 = homography(img, H, mode=mode, order=1) p1 = fast_homography(img, H, mode=mode) p1 = np.round(p1) ## import matplotlib.pyplot as plt ## f, (ax0, ax1, ax2, ax3) = plt.subplots(1, 4) ## ax0.imshow(img) ## ax1.imshow(p0, cmap=plt.cm.gray) ## ax2.imshow(p1, cmap=plt.cm.gray) ## ax3.imshow(np.abs(p0 - p1), cmap=plt.cm.gray) ## plt.show() d = np.mean(np.abs(p0 - p1)) print "delta=", d assert d < 0.2
def phog(image, bin, angle, L, roi): """ phog -- Function that prepares data structures and histogram indexing and then calls other functions to execute the pryamidal histogram of gradient code. inputs: image -- String that names the file path to the image to compute on. bin -- Number of components to use for each subwindow histogram angle -- 180 or 360 if you want half-circle or whole-circle angles, respectively. L -- Number of pyramid levels to use. roi -- List with 4 entries, [top_y, bottom_y, left_x, right_x], that bounds the image region for which you want to compute the HoG feature. outputs: p -- A long vector that contains the pHoG descriptor. """ Img = imread(image) if len(Img.shape) == 3: G = clr.rgb2gray(Img) else: G = Img if np.sum(G) > 100: E = canny(G) GradientX, GradientY = np.gradient(np.double(G)) Gr = np.sqrt(GradientX**2 + GradientY**2) GradientX[GradientX == 0] = 1 * 10**(-5) YX = np.divide(GradientY, GradientX) if angle == 180: A = (np.arctan(YX + np.pi / 2.0) * 180) / np.pi if angle == 360: A = (np.arctan2(GradientY, GradientX) + np.pi) * 180 / np.pi # Function call bh, bv = binMatrix(A, E, Gr, angle, bin) else: bh = np.zeros((G.shape[0], G.shape[1])) bv = np.zeros((G.shape[0], G.shape[1])) bh_roi = bh[roi[0]:roi[1], roi[2]:roi[3]] bv_roi = bv[roi[0]:roi[1], roi[2]:roi[3]] # Function call to actually extract the HoG vector. p = phogDescriptor(bh_roi, bv_roi, L, bin) return p
def phog(image, bin, angle, L, roi): """ phog -- Function that prepares data structures and histogram indexing and then calls other functions to execute the pryamidal histogram of gradient code. inputs: image -- String that names the file path to the image to compute on. bin -- Number of components to use for each subwindow histogram angle -- 180 or 360 if you want half-circle or whole-circle angles, respectively. L -- Number of pyramid levels to use. roi -- List with 4 entries, [top_y, bottom_y, left_x, right_x], that bounds the image region for which you want to compute the HoG feature. outputs: p -- A long vector that contains the pHoG descriptor. """ Img = imread(image) if len(Img.shape) == 3: G = clr.rgb2gray(Img) else: G = Img if np.sum(G) > 100: E = canny(G) GradientX, GradientY = np.gradient(np.double(G)) Gr = np.sqrt(GradientX**2 + GradientY**2) GradientX[GradientX==0] = 1*10**(-5) YX = np.divide(GradientY,GradientX) if angle == 180: A = (np.arctan(YX + np.pi/2.0)*180)/np.pi if angle == 360: A = (np.arctan2(GradientY,GradientX)+np.pi)*180/np.pi # Function call bh, bv = binMatrix(A,E,Gr,angle,bin) else: bh = np.zeros((G.shape[0],G.shape[1])) bv = np.zeros((G.shape[0],G.shape[1])) bh_roi = bh[roi[0]:roi[1], roi[2]:roi[3]] bv_roi = bv[roi[0]:roi[1], roi[2]:roi[3]] # Function call to actually extract the HoG vector. p = phogDescriptor(bh_roi,bv_roi,L,bin) return p
def test_tv_denoise_2d(self): """ Apply the TV denoising algorithm on the lena image provided by scipy """ # lena image lena = color.rgb2gray(data.lena()) # add noise to lena lena += 0.5 * lena.std()*np.random.randn(*lena.shape) # denoise denoised_lena = filter.tv_denoise(lena, weight=60.0) # which dtype? assert denoised_lena.dtype in [np.float, np.float32, np.float64] from scipy import ndimage grad = ndimage.morphological_gradient(lena, size=((3,3))) grad_denoised = ndimage.morphological_gradient(denoised_lena, size=((3,3))) # test if the total variation has decreased assert np.sqrt((grad_denoised**2).sum()) < np.sqrt((grad**2).sum()) / 2 denoised_lena_int = filter.tv_denoise(lena.astype(np.int32), \ weight=60.0, keep_type=True) assert denoised_lena_int.dtype is np.dtype('int32')
norm of the gradient of the image, and minimizing the total variation typically produces "posterized" images with flat domains separated by sharp edges. It is possible to change the degree of posterization by controlling the tradeoff between denoising and faithfulness to the original image. """ import numpy as np import matplotlib.pyplot as plt from scikits.image import data, color, img_as_ubyte from scikits.image.filter import tv_denoise l = img_as_ubyte(color.rgb2gray(data.lena())) l = l[230:290, 220:320] noisy = l + 0.4 * l.std() * np.random.random(l.shape) tv_denoised = tv_denoise(noisy, weight=10) plt.figure(figsize=(12,2.8)) plt.subplot(131) plt.imshow(noisy, cmap=plt.cm.gray, vmin=40, vmax=220) plt.axis('off') plt.title('noisy', fontsize=20) plt.subplot(132) plt.imshow(tv_denoised, cmap=plt.cm.gray, vmin=40, vmax=220) plt.axis('off')
# Select a random number K of features, then sample K features from the annotations for this image. # Form the smallest bounding box that encompasses those features (slightly enlarged) and that will be the seed patch. num_features_to_use = random.choice(range(2, 11)) rand_sample_vector = np.random.permutation( np.hstack( (np.ones(num_features_to_use), np.zeros(len(key_vals) - num_features_to_use)))).astype(np.int32) keypoints_to_use = [ elem for i, elem in enumerate(key_vals) if rand_sample_vector[i] == 1 ] seed_patch = obtain_bounding_patch(keypoints_to_use, M, N) if len(random_image.shape) == 3: seed_patch_im = clr.rgb2gray(random_image) else: seed_patch_im = np.copy(random_image) seed_patch_im = 255 * seed_patch_im[seed_patch[0]:seed_patch[1], seed_patch[2]:seed_patch[3]] im_out = open( "/home/ely/projects/faces/data/poselets/seed_patches/seed_" + str(num_poselets_trained) + ".png", 'w') im_writer = png.Writer(seed_patch_im.shape[1], seed_patch_im.shape[0], greyscale=True) im_writer.write(im_out, np.asarray(seed_patch_im)) im_out.close() cur_poselet_dir = "/home/ely/projects/faces/data/poselets/close_training_patches/poselet_" + str(
M = random_image.shape[0]; N = random_image.shape[1]; annotations = retrieve_annotations(random_file, data_entries, url_list, training_directory) key_vals = [(float(annotations[elem]),float(annotations[elem+1]), int(annotations[elem+2])) for elem in range(2,len(annotations),3)] # Select a random number K of features, then sample K features from the annotations for this image. # Form the smallest bounding box that encompasses those features (slightly enlarged) and that will be the seed patch. num_features_to_use = random.choice(range(2,11)) rand_sample_vector = np.random.permutation(np.hstack( (np.ones(num_features_to_use), np.zeros(len(key_vals) - num_features_to_use)))).astype(np.int32) keypoints_to_use = [elem for i,elem in enumerate(key_vals) if rand_sample_vector[i] == 1] seed_patch = obtain_bounding_patch(keypoints_to_use,M,N) if len(random_image.shape) == 3: seed_patch_im = clr.rgb2gray(random_image) else: seed_patch_im = np.copy(random_image) seed_patch_im = 255 * seed_patch_im[seed_patch[0]:seed_patch[1],seed_patch[2]:seed_patch[3]] im_out = open("/home/ely/projects/faces/data/poselets/seed_patches/seed_"+str(num_poselets_trained)+".png",'w') im_writer = png.Writer(seed_patch_im.shape[1], seed_patch_im.shape[0], greyscale=True) im_writer.write(im_out, np.asarray(seed_patch_im)) im_out.close() cur_poselet_dir = "/home/ely/projects/faces/data/poselets/close_training_patches/poselet_"+str(num_poselets_trained)+"/" cmd = "mkdir "+cur_poselet_dir os.system(cmd)
# Loop over all of the images. num_file_success = 0 num_images_to_test = 10 while num_file_success < num_images_to_test: found_file = 0 while not(found_file): test_indx = random.choice(range(len(url_list))) cur_file_name = get_local_file_name_from_url(test_indx,url_list,training_directory) if os.path.isfile(cur_file_name): found_file = 1 original_image = imread(cur_file_name) if len(original_image.shape) == 3: original_image = clr.rgb2gray(original_image) height, width = original_image.shape binary_output = np.zeros((height,width)) score_output = np.zeros((height,width)) angles = original_image.ravel().astype(np.float32) hog_output = np.zeros((1,81)).ravel().astype(np.float32) angles_device = cu.mem_alloc(angles.nbytes) cu.memcpy_htod( angles_device, angles ) output_hog_device = cu.mem_alloc(hog_output.nbytes) cu.memcpy_htod( output_hog_device, hog_output)
img_prefix = "/home/ely/projects/faces/src/demo_" img_names = ["medium.jpg", "large.jpg", "big.jpg", "huge.jpg", "mega.jpg"] img_sizes = [64, 128, 256, 512, 1024] # Set HoG parameters, number of bins, maximum angle, and number of pyramid levels bins = 9; angle = 180; L = 3; num_spatial_bins = 3; phog_times = []; vhog_times = []; triggs_times = []; gpu_keypoint_times = []; gpu_patch_times = []; num_plots = 5 # Get timing info for each of the patch-based CPU versions print "Timing the CPU versions ..." for indx in range(len(img_sizes)): cur_image = imread(img_prefix+img_names[indx]) if len(cur_image.shape) == 3: cur_image = clr.rgb2gray(cur_image) height, width = cur_image.shape st_time = time.time() p = phog.phog(img_prefix+img_names[indx], bins, angle, L, [0,height,0,width]) ed_time = time.time() - st_time phog_times.append(ed_time) st_time = time.time() v = vhog.hog(cur_image, bins, num_spatial_bins, angle, [0,height,0,width]) ed_time = time.time() - st_time vhog_times.append(ed_time) # Get timing info for the Dalal and Triggs CPU C-code version. # For this, only use the huge demo image and increase the size of the
angle = 180 L = 3 num_spatial_bins = 3 phog_times = [] vhog_times = [] triggs_times = [] gpu_keypoint_times = [] gpu_patch_times = [] num_plots = 5 # Get timing info for each of the patch-based CPU versions print "Timing the CPU versions ..." for indx in range(len(img_sizes)): cur_image = imread(img_prefix + img_names[indx]) if len(cur_image.shape) == 3: cur_image = clr.rgb2gray(cur_image) height, width = cur_image.shape st_time = time.time() p = phog.phog(img_prefix + img_names[indx], bins, angle, L, [0, height, 0, width]) ed_time = time.time() - st_time phog_times.append(ed_time) st_time = time.time() v = vhog.hog(cur_image, bins, num_spatial_bins, angle, [0, height, 0, width]) ed_time = time.time() - st_time vhog_times.append(ed_time) # Get timing info for the Dalal and Triggs CPU C-code version.
# Loop over all of the images. num_file_success = 0 num_images_to_test = 10 while num_file_success < num_images_to_test: found_file = 0 while not (found_file): test_indx = random.choice(range(len(url_list))) cur_file_name = get_local_file_name_from_url( test_indx, url_list, training_directory) if os.path.isfile(cur_file_name): found_file = 1 original_image = imread(cur_file_name) if len(original_image.shape) == 3: original_image = clr.rgb2gray(original_image) height, width = original_image.shape binary_output = np.zeros((height, width)) score_output = np.zeros((height, width)) angles = original_image.ravel().astype(np.float32) hog_output = np.zeros((1, 81)).ravel().astype(np.float32) angles_device = cu.mem_alloc(angles.nbytes) cu.memcpy_htod(angles_device, angles) output_hog_device = cu.mem_alloc(hog_output.nbytes) cu.memcpy_htod(output_hog_device, hog_output)