def compare_AEM_with_MMM(model_path, img_path='/Data/Latent/NISTSD27/image/', output_path='/AutomatedLatentRecognition/Results/minutiae/NISTSD27_latents_Contrast/', minu_path='/Data/Latent/NISTSD27/ManMinu', processing=None, thr=0.01): minu_model = ImportGraph(model_path) img_files = glob.glob(img_path + '*.bmp') img_files.sort() manu_files = glob.glob(minu_path + '*.txt') manu_files.sort() for i, img_file in enumerate(img_files): img = misc.imread(img_file, mode='L') if processing == 'contrast': img = LP.local_constrast_enhancement(img) elif processing == 'STFT': img = LP.STFT(img) elif processing == 'texture': img = LP.FastCartoonTexture(img) elif processing == 'texture_STFT': img = LP.FastCartoonTexture(img) img = LP.STFT(img) mnt = minu_model.run_whole_image(img, minu_thr=thr) img_name = os.path.basename(img_file) fname = output_path + os.path.splitext(img_name)[0] + '_minu.jpeg' minutiae_set = [] minutiae_set.append(mnt) input_minu = np.loadtxt(manu_files[i]) input_minu[:, 2] = input_minu[:, 2] / 180.0 * np.pi minutiae_set.append(input_minu) print i show.show_minutiae_sets(img, minutiae_set, mask=None, block=False, fname=fname) print fname
def get_maps_STFT(img, patch_size=64, block_size=16, preprocess=False): assert len(img.shape) == 2 nrof_dirs = 16 ovp_size = (patch_size - block_size) // 2 if preprocess: img = preprocessing.FastCartoonTexture(img, sigma=2.5, show=False) h0, w0 = img.shape img = np.lib.pad(img, (ovp_size, ovp_size), 'symmetric') h, w = img.shape blkH = (h - patch_size) // block_size + 1 blkW = (w - patch_size) // block_size + 1 local_info = np.empty((blkH, blkW), dtype=object) x, y = np.meshgrid(range(-patch_size / 2, patch_size / 2), range(-patch_size / 2, patch_size / 2)) x = x.astype(np.float32) y = y.astype(np.float32) r = np.sqrt(x * x + y * y) + 0.0001 # if preprocess: # ------------------------- # Bandpass filter # ------------------------- RMIN = 3 # min allowable ridge spacing RMAX = 18 # maximum allowable ridge spacing FLOW = patch_size / RMAX FHIGH = patch_size / RMIN dRLow = 1. / (1 + (r / FHIGH)**4) # low pass butterworth filter dRHigh = 1. / (1 + (FLOW / r)**4) # high pass butterworth filter dBPass = dRLow * dRHigh # bandpass dir = np.arctan2(y, x) dir[dir < 0] = dir[dir < 0] + math.pi dir_ind = np.floor(dir / (math.pi / nrof_dirs)) dir_ind = dir_ind.astype(np.int, copy=False) dir_ind[dir_ind == nrof_dirs] = 0 dir_ind_list = [] for i in range(nrof_dirs): tmp = np.argwhere(dir_ind == i) dir_ind_list.append(tmp) sigma = patch_size / 3 weight = np.exp(-(x * x + y * y) / (sigma * sigma)) for i in range(0, blkH): for j in range(0, blkW): patch = img[i * block_size:i * block_size + patch_size, j * block_size:j * block_size + patch_size].copy() local_info[i, j] = local_STFT(patch, weight, dBPass) local_info[i, j].analysis(r, dir_ind_list) # get the ridge flow from the local information dir_map, fre_map = get_ridge_flow_top(local_info) dir_map = smooth_dir_map(dir_map) return dir_map, fre_map
def feature_extraction_longitudinal(self, img_file): block_size = 16 img = io.imread(img_file) #print img.shape img = preprocessing.adjust_image_size(img, block_size) h, w = img.shape texture_img = preprocessing.FastCartoonTexture(img, sigma=2.5, show=False) contrast_img_guassian = preprocessing.local_constrast_enhancement_gaussian( img) mask = get_maps.get_quality_map_intensity(img) #show.show_mask(mask, img, fname=None, block=True) quality_map, dir_map, fre_map = get_maps.get_quality_map_dict( texture_img, self.dict_all, self.dict_ori, self.dict_spacing, block_size=16, process=False) enh_constrast_img = filtering.gabor_filtering_pixel( contrast_img_guassian, dir_map + math.pi / 2, fre_map, mask=np.ones((h, w), np.int), block_size=16, angle_inc=3) mnt = self.minu_model.run(img, minu_thr=0.2) #show.show_minutiae(img,mnt) des = descriptor.minutiae_descriptor_extraction(img, mnt, self.patch_types, self.des_models, self.patchIndexV, batch_size=128) blkH, blkW = dir_map.shape minu_template = template.MinuTemplate(h=h, w=w, blkH=blkH, blkW=blkW, minutiae=mnt, des=des, oimg=dir_map, mask=mask) rolled_template = template.Template() rolled_template.add_minu_template(minu_template) return rolled_template, texture_img, enh_constrast_img
def get_quality_map_ori_dict(img, dict, spacing, dir_map=None, block_size=16): if img.dtype == 'uint8': img = img.astype(np.float) img = preprocessing.FastCartoonTexture(img) h, w = img.shape blkH, blkW = dir_map.shape quality_map = np.zeros((blkH, blkW), dtype=np.float) fre_map = np.zeros((blkH, blkW), dtype=np.float) ori_num = len(dict) #dir_map = math.pi/2 - dir_map dir_ind = dir_map * ori_num / math.pi dir_ind = dir_ind.astype(np.int) dir_ind = dir_ind % ori_num patch_size = np.sqrt(dict[0].shape[1]) patch_size = patch_size.astype(np.int) pad_size = (patch_size - block_size) // 2 img = np.lib.pad(img, (pad_size, pad_size), 'symmetric') for i in range(0, blkH): for j in range(0, blkW): ind = dir_ind[i, j] patch = img[i * block_size:i * block_size + patch_size, j * block_size:j * block_size + patch_size] patch = patch.reshape(patch_size * patch_size, ) patch = patch - np.mean(patch) patch = patch / (np.linalg.norm(patch) + 0.0001) patch[patch > 0.05] = 0.05 patch[patch < -0.05] = -0.05 # if ind==0: # simi = np.dot(np.concatenate((dict[-1],dict[ind],dict[ind+1]),axis=0),patch) # elif ind == len(dict)-1: # simi = np.dot(np.concatenate((dict[ind - 1], dict[ind], dict[0]), axis=0), patch) # else: # simi = np.dot(np.concatenate((dict[ind - 1], dict[ind], dict[ind + 1]), axis=0), patch) simi = np.dot(dict[ind], patch) similar_ind = np.argmax(abs(simi)) quality_map[i, j] = np.max(abs(simi)) fre_map[i, j] = 1. / spacing[ind][similar_ind] # print np.max(abs(simi)) # print j # plt.subplot(121), plt.imshow(patch.reshape(patch_size, patch_size), cmap='gray') # plt.subplot(122), plt.imshow(dict[ind][similar_ind, :].reshape(patch_size, patch_size), cmap='gray') # plt.show(block=True) # plt.close() quality_map = gaussian(quality_map, sigma=2) # plt.imshow(quality_map,cmap='gray') # plt.show(block=True) return quality_map, fre_map
def demo_minutiae_extraction(img_path,minu_model_dir): img_files = glob.glob(img_path+'*.bmp') img_files.sort() minu_model = (minutiae_AEC.ImportGraph(minu_model_dir)) block = True for i, img_file in enumerate(img_files): if i<11: continue img = io.imread(img_file) name = os.path.basename(img_file) h, w = img.shape mask = np.ones((h,w),dtype=np.uint8) minu_thr = 0.3 texture_img = preprocessing.FastCartoonTexture(img) contrast_img = preprocessing.local_constrast_enhancement_gaussian(img) dir_map, fre_map = get_maps.get_maps_STFT(contrast_img, patch_size=64, block_size=16, preprocess=True) dict, spacing,_ = get_maps.construct_dictionary(ori_num=60) quality_map, fre_map = get_maps.get_quality_map_ori_dict(contrast_img, dict, spacing, dir_map=dir_map, block_size=16) enh_texture_img = filtering.gabor_filtering_pixel(contrast_img, dir_map + math.pi / 2, fre_map, mask=mask, block_size=16, angle_inc=3) mnt = minu_model.run(contrast_img, minu_thr=0.1) #mnt = minu_model.remove_spurious_minutiae(mnt, mask) #minutiae_sets.append(mnt) #fname = output_path + os.path.splitext(name)[0] + '_texture_img.jpeg' show.show_minutiae(contrast_img, mnt, block=block, fname=None) mnt = minu_model.run(texture_img, minu_thr=0.1) # mnt = minu_model.remove_spurious_minutiae(mnt, mask) # minutiae_sets.append(mnt) # fname = output_path + os.path.splitext(name)[0] + '_texture_img.jpeg' show.show_minutiae(texture_img, mnt, block=block, fname=None) print(i)
def get_quality_map_ori_dict(img, dict, spacing, dir_map=None, block_size=16): if img.dtype == 'uint8': img = img.astype(np.float) img = preprocessing.FastCartoonTexture(img) h, w = img.shape blkH, blkW = dir_map.shape quality_map = np.zeros((blkH, blkW), dtype=np.float) fre_map = np.zeros((blkH, blkW), dtype=np.float) ori_num = len(dict) dir_ind = dir_map * ori_num / math.pi dir_ind = dir_ind.astype(np.int) dir_ind = dir_ind % ori_num patch_size = np.sqrt(dict[0].shape[1]) patch_size = patch_size.astype(np.int) pad_size = (patch_size - block_size) // 2 img = np.lib.pad(img, (pad_size, pad_size), 'symmetric') for i in range(0, blkH): for j in range(0, blkW): ind = dir_ind[i, j] patch = img[i * block_size:i * block_size + patch_size, j * block_size:j * block_size + patch_size] patch = patch.reshape(patch_size * patch_size, ) patch = patch - np.mean(patch) patch = patch / (np.linalg.norm(patch) + 0.0001) patch[patch > 0.05] = 0.05 patch[patch < -0.05] = -0.05 simi = np.dot(dict[ind], patch) similar_ind = np.argmax(abs(simi)) quality_map[i, j] = np.max(abs(simi)) fre_map[i, j] = 1. / spacing[ind][similar_ind] quality_map = gaussian(quality_map, sigma=2) return quality_map, fre_map
def minutiae_extraction_latent(model_path, sample_path, imgs, output_name='reconstruction/gen:0', block=True): imgs = glob.glob('/Data/Latent/DB/NIST27/image/' + '*.bmp') minu_files = glob.glob('/Data/Latent/DB/ManualInformation/NIST27/ManMinu/*.txt') minu_files.sort() imgs.sort() import os if not os.path.isdir(sample_path): os.makedirs(sample_path) weight = get_weights(opt.SHAPE, opt.SHAPE, 12) with tf.Graph().as_default(): with TowerContext('', is_training=False): with tf.Session() as sess: is_training = get_current_tower_context().is_training load_model(model_path) images_placeholder = tf.get_default_graph().get_tensor_by_name('QueueInput/input_deque:0') # sub:0 minutiae_cylinder_placeholder = tf.get_default_graph().get_tensor_by_name(output_name) for k, file in enumerate(imgs): print file img = cv2.imread(file, cv2.IMREAD_GRAYSCALE) u, texture = LP.FastCartoonTexture(img) img = texture / 128.0 - 1 h, w = img.shape x = [] y = [] nrof_samples = len(range(0, h, opt.SHAPE // 2)) * len(range(0, w, opt.SHAPE // 2)) patches = np.zeros((nrof_samples, opt.SHAPE, opt.SHAPE, 1)) n = 0 for i in range(0, h - opt.SHAPE + 1, opt.SHAPE // 2): for j in range(0, w - opt.SHAPE + 1, opt.SHAPE // 2): print j patch = img[i:i + opt.SHAPE, j:j + opt.SHAPE, np.newaxis] x.append(j) y.append(i) patches[n, :, :, :] = patch n = n + 1 # print x[-1] feed_dict = {images_placeholder: patches} minutiae_cylinder_array = sess.run(minutiae_cylinder_placeholder, feed_dict=feed_dict) minutiae_cylinder = np.zeros((h, w, 12)) minutiae_cylinder_array[:, -10:, :, :] = 0 minutiae_cylinder_array[:, :10, :, :] = 0 minutiae_cylinder_array[:, :, -10:, :] = 0 minutiae_cylinder_array[:, :, 10, :] = 0 for i in range(n): minutiae_cylinder[y[i]:y[i] + opt.SHAPE, x[i]:x[i] + opt.SHAPE, :] = minutiae_cylinder[y[i] :y[i] + opt.SHAPE, x[i]:x[i] + opt.SHAPE, :] + minutiae_cylinder_array[i] * weight minutiae = prepare_data.get_minutiae_from_cylinder(minutiae_cylinder, thr=0.05) minutiae = prepare_data.refine_minutiae(minutiae, dist_thr=10, ori_dist=np.pi / 4) minutiae_sets = [] minutiae_sets.append(minutiae) manu_minutiae = np.loadtxt(minu_files[k]) manu_minutiae[:, 2] = manu_minutiae[:, 2] / 180 * np.pi minutiae_sets.append(manu_minutiae) fname = sample_path + os.path.basename(file)[:-4] + '.jpeg' prepare_data.show_minutiae_sets(img, minutiae_sets, ROI=None, fname=fname, block=block) fname = sample_path + os.path.basename(file)[:-4] + '.txt' np.savetxt(fname, minutiae_sets[0]) print(n)
def get_quality_map_dict(img, dict, ori, spacing, block_size=16, process=False): if img.dtype == 'uint8': img = img.astype(np.float) if process: img = preprocessing.FastCartoonTexture(img) h, w = img.shape blkH, blkW = h // block_size, w // block_size quality_map = np.zeros((blkH, blkW), dtype=np.float) dir_map = np.zeros((blkH, blkW), dtype=np.float) fre_map = np.zeros((blkH, blkW), dtype=np.float) patch_size = np.sqrt(dict.shape[0]) patch_size = patch_size.astype(np.int) pad_size = (patch_size - block_size) // 2 img = np.lib.pad(img, (pad_size, pad_size), 'symmetric') # pixel_list = [] # for i in range(0,blkH): # for j in range(0,blkW): # pixel_list.append((i,j)) # # def apply_filter(src_arr, dir_arr, fre_arr, quality_arr, idx_list): # for p, i, j in idx_list: # patch = src_arr[i * block_size:i * block_size + patch_size, j * block_size:j * block_size + patch_size] # patch = patch.reshape(patch_size * patch_size, ) # patch = patch - np.mean(patch) # patch = patch / (np.linalg.norm(patch) + 0.0001) # patch[patch > 0.05] = 0.05 # patch[patch < -0.05] = -0.05 # # if ind==0: # # simi = np.dot(np.concatenate((dict[-1],dict[ind],dict[ind+1]),axis=0),patch) # # elif ind == len(dict)-1: # # simi = np.dot(np.concatenate((dict[ind - 1], dict[ind], dict[0]), axis=0), patch) # # else: # # simi = np.dot(np.concatenate((dict[ind - 1], dict[ind], dict[ind + 1]), axis=0), patch) # # simi = np.dot(dict, patch) # similar_ind = np.argmax(abs(simi)) # quality_arr[p] = np.max(abs(simi)) # dir_arr[p] = ori[similar_ind] # fre_arr[p] = spacing[similar_ind] # # return # # # from threading import Thread # # from multiprocessing import Process, Array # # threads = [] # thread_num = 5 # candi_num = blkH*blkW # pixels_per_thread = candi_num // thread_num # dir_arr = Array('f', candi_num) # fre_arr = Array('f', candi_num) # quality_arr = Array('f', candi_num) # for k in xrange(0, thread_num): # idx_list = [] # for n in xrange(0, pixels_per_thread): # p = k * pixels_per_thread + n # if p >= candi_num: # break # idx_list.append((p, pixel_list[p][0], pixel_list[p][1])) # t = Process(target=apply_filter, args=(img, dir_arr, fre_arr, quality_arr, idx_list)) # t.daemon = True # t.start() # threads.append(t) # # for t in threads: # t.join() # # for k in xrange(candi_num): # i = pixel_list[k][0] # j = pixel_list[k][1] # quality_map[i, j] =quality_arr[k] # dir_map[i, j] = dir_arr[k] # fre_map[i, j] = fre_arr[k] patches = [] pixel_list = [] for i in range(0, blkH - 0): for j in range(0, blkW - 0): pixel_list.append((i, j)) patch = img[i * block_size:i * block_size + patch_size, j * block_size:j * block_size + patch_size] patch = patch.reshape(patch_size * patch_size, ) patch = patch - np.mean(patch) patch = patch / (np.linalg.norm(patch) + 0.0001) patches.append(patch) # if ind==0: # simi = np.dot(np.concatenate((dict[-1],dict[ind],dict[ind+1]),axis=0),patch) # elif ind == len(dict)-1: # simi = np.dot(np.concatenate((dict[ind - 1], dict[ind], dict[0]), axis=0), patch) # else: # simi = np.dot(np.concatenate((dict[ind - 1], dict[ind], dict[ind + 1]), axis=0), patch) # simi = np.dot(dict, patch) # similar_ind = np.argmax(abs(simi)) # quality_map[i,j] = np.max(abs(simi)) # dir_map[i,j] = ori[similar_ind] # fre_map[i,j] = spacing[similar_ind] # print np.max(abs(simi)) # print j # print ori[similar_ind] # plt.subplot(121), plt.imshow(patch.reshape(patch_size, patch_size), cmap='gray') # plt.subplot(122), plt.imshow(dict[similar_ind, :].reshape(patch_size, patch_size), cmap='gray') # R = 5 # x1 = 16 - R * math.cos(ori[similar_ind]) # x2 = 16 + R * math.cos(ori[similar_ind]) # y1 = 16 - R * math.sin(ori[similar_ind]) # y2 = 16 + R * math.sin(ori[similar_ind]) # plt.plot([x1, x2], [y1, y2], 'r-', lw=2) # plt.show(block=True) # plt.close() patches = np.asarray(patches) patches[patches > 0.05] = 0.05 patches[patches < -0.05] = -0.05 simi = abs(np.dot(patches, dict)) similar_ind = np.argmax(simi, axis=1) n = 0 for i in range(0, blkH - 0): for j in range(0, blkW - 0): quality_map[i, j] = simi[n, similar_ind[n]] dir_map[i, j] = ori[similar_ind[n]] fre_map[i, j] = spacing[similar_ind[n]] n += 1 # plt.imshow(quality_map,cmap='gray') # plt.show(block=True) quality_map = cv2.GaussianBlur(quality_map, (3, 3), 1) dir_map = smooth_dir_map(dir_map, sigma=1) fre_map = cv2.GaussianBlur(fre_map, (3, 3), 1) return quality_map, dir_map, fre_map
def get_quality_map_dict_coarse(img, dict, ori, spacing, block_size=16, process=False, R=500.0, t=0.5): if img.dtype == 'uint8': img = img.astype(np.float) if process: img = preprocessing.FastCartoonTexture(img) h, w = img.shape blkH, blkW = h // block_size, w // block_size quality_map = np.zeros((blkH, blkW), dtype=np.float) dir_map = np.zeros((blkH, blkW), dtype=np.float) fre_map = np.zeros((blkH, blkW), dtype=np.float) patch_size = np.sqrt(dict.shape[0]) patch_size = patch_size.astype(np.int) pad_size = (patch_size - block_size) // 2 img = np.lib.pad(img, (pad_size, pad_size), 'symmetric') patches = [] pixel_list = [] r = 1 x, y = np.meshgrid(range(-patch_size / 2, patch_size / 2), range(-patch_size / 2, patch_size / 2)) x = x.astype(np.float32) y = y.astype(np.float32) weight = np.exp(-(x * x + y * y) / (patch_size * patch_size / 3.0)) # t = 0.02 for i in range(r, blkH - r): for j in range(r, blkW - r): pixel_list.append((i, j)) patch = img[i * block_size:i * block_size + patch_size, j * block_size:j * block_size + patch_size].copy() patch = patch - np.median(patch) patch = patch / (np.linalg.norm(patch) + R) patch[patch > t] = 0.0 patch[patch < -t] = 0. patch = patch * weight patch = patch.reshape(patch_size * patch_size, ) patches.append(patch) patches = np.asarray(patches) simi = abs(np.dot(patches, dict)) similar_ind = np.argmax(simi, axis=1) n = 0 # blks_in_patch = patch_size / block_size for i in range(r, blkH - r): for j in range(r, blkW - r): quality_map[i, j] = simi[n, similar_ind[n]] dir_map[i, j] = -math.atan2(ori[32 + 64, similar_ind[n]], ori[32, similar_ind[n]]) / 2.0 fre_map[i, j] = spacing[32, similar_ind[n]] n += 1 for i in range(r): fre_map[i] = fre_map[r] dir_map[i] = dir_map[r] fre_map[-(r - i) - 1] = fre_map[-r - 1] dir_map[-(r - i) - 1] = fre_map[-r - 1] fre_map[:, i] = fre_map[:, r] dir_map[:, i] = dir_map[:, r] fre_map[:, -(r - i) - 1] = fre_map[:, -r - 1] dir_map[:, -(r - i) - 1] = fre_map[:, -r - 1] quality_map = cv2.GaussianBlur(quality_map, (5, 5), 2) dir_map = smooth_dir_map(dir_map, sigma=1.5) fre_map = cv2.GaussianBlur(fre_map, (3, 3), 1) return quality_map, dir_map, fre_map
def get_quality_map_dict(img, dict, ori, spacing, block_size=16, process=False, R=500.0, t=0.05): if img.dtype == 'uint8': img = img.astype(np.float) if process: img = preprocessing.FastCartoonTexture(img) h, w = img.shape blkH, blkW = h // block_size, w // block_size quality_map = np.zeros((blkH, blkW), dtype=np.float) dir_map = np.zeros((blkH, blkW), dtype=np.float) fre_map = np.zeros((blkH, blkW), dtype=np.float) patch_size = np.sqrt(dict.shape[0]) patch_size = patch_size.astype(np.int) pad_size = (patch_size - block_size) // 2 img = np.lib.pad(img, (pad_size, pad_size), 'symmetric') patches = [] pixel_list = [] r = 1 for i in range(r, blkH - r): for j in range(r, blkW - r): pixel_list.append((i, j)) patch = img[i * block_size:i * block_size + patch_size, j * block_size:j * block_size + patch_size].copy() patch = patch.reshape(patch_size * patch_size, ) patch = patch - np.mean(patch) patch = patch / (np.linalg.norm(patch) + R) patch[patch > t] = 0.0 patch[patch < -t] = -0.0 patches.append(patch) patches = np.asarray(patches) simi = abs(np.dot(patches, dict)) similar_ind = np.argmax(simi, axis=1) n = 0 for i in range(r, blkH - r): for j in range(r, blkW - r): quality_map[i, j] = simi[n, similar_ind[n]] dir_map[i, j] = ori[similar_ind[n]] fre_map[i, j] = spacing[similar_ind[n]] n += 1 for i in range(r): fre_map[i] = fre_map[r] dir_map[i] = dir_map[r] fre_map[-(r - i) - 1] = fre_map[-r - 1] dir_map[-(r - i) - 1] = fre_map[-r - 1] fre_map[:, i] = fre_map[:, r] dir_map[:, i] = dir_map[:, r] fre_map[:, -(r - i) - 1] = fre_map[:, -r - 1] dir_map[:, -(r - i) - 1] = fre_map[:, -r - 1] quality_map = cv2.GaussianBlur(quality_map, (5, 5), 0) dir_map = smooth_dir_map(dir_map, sigma=1.5) fre_map = cv2.GaussianBlur(fre_map, (3, 3), 1) return quality_map, dir_map, fre_map
def feature_extraction_single_latent(raw_img_file, AEC_img_file, mask_file, patch_types=None, des_models=None): ### # input: # raw_img, original latent image # AEC_img, enhanced latent image by Autoencoder # mask: ROI # main idea: # 1) Use AEC_img to estimate ridge flow and ridge spacing # 2) use AEC_image and raw_img to extract two different minutiae set ### raw_img = io.imread(raw_img_file) AEC_img = io.imread(AEC_img_file) mask = io.imread(mask_file) #mask = mask_dilation(mask, block_size=16) texture_img = preprocessing.FastCartoonTexture(raw_img, sigma=2.5, show=False) dir_map, fre_map, rec_img = get_maps.get_maps_STFT(AEC_img, patch_size=64, block_size=16, preprocess=True) descriptor_img = filtering.gabor_filtering_pixel(texture_img, dir_map + math.pi / 2, fre_map, mask=mask, block_size=16, angle_inc=3) bin_img = binarization.binarization(texture_img, dir_map, block_size=16, mask=mask) enhanced_img = filtering.gabor_filtering_block(bin_img, dir_map + math.pi / 2, fre_map, patch_size=64, block_size=16) enhanced_img = filtering.gabor_filtering_block(enhanced_img, dir_map + math.pi / 2, fre_map, patch_size=64, block_size=16) # plt.subplot(131), plt.imshow(raw_img, cmap='gray') # plt.title('Input image'), plt.xticks([]), plt.yticks([]) # plt.subplot(132), plt.imshow(descriptor_img, cmap='gray') # plt.title('Feature image'), plt.xticks([]), plt.yticks([]) # # plt.subplot(133), plt.imshow(enhanced_img, cmap='gray') # plt.title('Feature image'), plt.xticks([]), plt.yticks([]) # plt.show(block=True) # plt.close() enhanced_AEC_img = filtering.gabor_filtering_block(AEC_img, dir_map + math.pi / 2, fre_map, patch_size=64, block_size=16) bin_img = binarization.binarization(enhanced_AEC_img, dir_map, block_size=16, mask=mask) # plt.imshow(AEC_img,cmap='gray') # plt.show() # plt.close() bin_img2 = 1 - bin_img thin_img = skeletonize(bin_img2) # thin_img2 = thin_img.astype(np.uint8) # thin_img2[thin_img2 > 0] = 255 mnt, thin_img2 = crossnumber.extract_minutiae(1 - thin_img, mask=mask, R=10) crossnumber.show_minutiae(thin_img, mnt) patchSize = 160 oriNum = 64 patchIndexV = descriptor.get_patch_index(patchSize, patchSize, oriNum, isMinu=1) if len(descriptor_img.shape) == 2: h, w = descriptor_img.shape ret = np.empty((h, w, 3), dtype=np.float) ret[:, :, :] = descriptor_img[:, :, np.newaxis] descriptor_img = ret if len(enhanced_AEC_img.shape) == 2: h, w = enhanced_AEC_img.shape ret = np.empty((h, w, 3), dtype=np.float) ret[:, :, :] = enhanced_AEC_img[:, :, np.newaxis] enhanced_AEC_img = ret des = descriptor.minutiae_descriptor_extraction(enhanced_AEC_img, mnt, patch_types, des_models, patchIndexV, batch_size=128) h, w = mask.shape blkH, blkW = dir_map.shape minu_template = template.MinuTemplate(h=h, w=w, blkH=blkH, blkW=blkW, minutiae=mnt, des=des, oimg=dir_map, mask=mask) latent_template = template.Template() latent_template.add_minu_template(minu_template) print des
def get_maps_STFT(img, patch_size=64, block_size=16, preprocess=False): assert len(img.shape) == 2 nrof_dirs = 16 ovp_size = (patch_size - block_size) // 2 if preprocess: img = preprocessing.FastCartoonTexture(img, sigma=2.5, show=False) h0, w0 = img.shape img = np.lib.pad(img, (ovp_size, ovp_size), 'symmetric') #img = cv2.copyMakeBorder(img, ovp_size, ovp_size, ovp_size, ovp_size, cv2.BORDER_CONSTANT, value=0) h, w = img.shape blkH = (h - patch_size) // block_size + 1 blkW = (w - patch_size) // block_size + 1 local_info = np.empty((blkH, blkW), dtype=object) x, y = np.meshgrid(range(-patch_size / 2, patch_size / 2), range(-patch_size / 2, patch_size / 2)) x = x.astype(np.float32) y = y.astype(np.float32) r = np.sqrt(x * x + y * y) + 0.0001 #if preprocess: #------------------------- # Bandpass filter # ------------------------- RMIN = 3 # min allowable ridge spacing RMAX = 18 # maximum allowable ridge spacing FLOW = patch_size / RMAX FHIGH = patch_size / RMIN dRLow = 1. / (1 + (r / FHIGH)**4) # low pass butterworth filter dRHigh = 1. / (1 + (FLOW / r)**4) # high pass butterworth filter dBPass = dRLow * dRHigh # bandpass dir = np.arctan2(y, x) dir[dir < 0] = dir[dir < 0] + math.pi dir_ind = np.floor(dir / (math.pi / nrof_dirs)) dir_ind = dir_ind.astype(np.int, copy=False) dir_ind[dir_ind == nrof_dirs] = 0 dir_ind_list = [] for i in range(nrof_dirs): tmp = np.argwhere(dir_ind == i) dir_ind_list.append(tmp) sigma = patch_size / 3 weight = np.exp(-(x * x + y * y) / (sigma * sigma)) #plt.imshow(weight,cmap='gray') #plt.show() for i in range(0, blkH): for j in range(0, blkW): patch = img[i * block_size:i * block_size + patch_size, j * block_size:j * block_size + patch_size].copy() local_info[i, j] = local_STFT(patch, weight, dBPass) local_info[i, j].analysis(r, dir_ind_list) # plt.subplot(221), plt.imshow(patch, cmap='gray') # plt.title('Input Image'), plt.xticks([]), plt.yticks([]) # plt.subplot(222), plt.imshow(magnitude_spectrum, cmap='gray') # plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([]) # plt.subplot(223), plt.imshow(rec_patch, cmap='gray') # plt.title('reconstructed patch'), plt.xticks([]), plt.yticks([]) # plt.subplot(224), plt.imshow(dBPass, cmap='gray') # plt.title('reconstructed patch'), plt.xticks([]), plt.yticks([]) # plt.show() # get the ridge flow from the local information dir_map, fre_map = get_ridge_flow_top(local_info) #dir_map = get_ridge_flow_optimal_N(local_info, N=2) dir_map = smooth_dir_map(dir_map) #show_orientation_field(img,dir_map) # # first around enhancement # rec_img = np.zeros((h, w)) # for i in range(0, blkH): # for j in range(0, blkW): # if fre_map[i,j] < 0: # continue # rec_patch = local_info[i, j].gabor_filtering(dir_map[i,j],fre_map[i,j], weight=weight) # rec_img[i * block_size:i * block_size + patch_size, j * block_size:j * block_size + patch_size] += rec_patch # # # rec_img = rec_img[ovp_size:ovp_size + h0, ovp_size:ovp_size + w0] # rec_img = (rec_img - np.min(rec_img)) / (np.max(rec_img) - np.min(rec_img)) * 255 return dir_map, fre_map #, rec_img
def extract_minutiae_cylinder(img_input, minutiae_input, ROI=None, num_ori=12, angle=None, processing=None): # for the latent or the low quality rolled print minutiae = minutiae_input.copy() img = img_input.copy() if processing == 'STFT': img = LP.STFT(img) elif processing == 'contrast': img = LP.local_constrast_enhancement(img) elif processing == 'texture': img = LP.FastCartoonTexture(img) sigma = 5**2 if ROI is not None: h, w = ROI.shape for i in range(h): for j in range(w): if ROI[i, j] == 0: img[i, j] = 255 h, w = ROI.shape col_sum = np.sum(ROI, axis=0) ind = [x for x in range(len(col_sum)) if col_sum[x] > 0] min_x = np.max([np.min(ind) - 32, 0]) max_x = np.min([np.max(ind) + 32, w]) row_sum = np.sum(ROI, axis=1) ind = [x for x in range(len(row_sum)) if row_sum[x] > 0] min_y = np.max([np.min(ind) - 32, 0]) max_y = np.min([np.max(ind) + 32, h]) ROI = ROI[min_y:max_y, min_x:max_x] img = img[min_y:max_y, min_x:max_x] minutiae[:, 0] = minutiae[:, 0] - min_x minutiae[:, 1] = minutiae[:, 1] - min_y else: h, w = img.shape[0:2] ROI = np.ones((h, w)) # rotate the image and ROI, and also update minutiae points h0, w0 = ROI.shape if angle is not None: h02 = (h0 + 1) / 2 w02 = (w0 + 1) / 2 img = rotate(img, angle) ROI = rotate(ROI, angle) h, w = ROI.shape h2 = (h + 1) / 2 w2 = (w + 1) / 2 angle = -angle / 180.0 * math.pi cosTheta = math.cos(angle) sinTheta = math.sin(angle) xx = (minutiae[:, 0] - w02) * cosTheta - (minutiae[:, 1] - h02) * sinTheta + w2 yy = (minutiae[:, 0] - w02) * sinTheta + (minutiae[:, 1] - h02) * cosTheta + h2 ori = minutiae[:, 2] - angle # minutiae[:, 0] = xx minutiae[:, 1] = yy minutiae[:, 2] = ori show = 0 if show: minu_num = minutiae.shape[0] fig, ax = plt.subplots(1) ax.set_aspect('equal') R = 10 arrow_len = 15 ax.imshow(img, cmap='gray') for i in range(0, minu_num): xx = minutiae[i, 0] yy = minutiae[i, 1] circ = Circle((xx, yy), R, color='r', fill=False) ax.add_patch(circ) ori = -minutiae[i, 2] dx = math.cos(ori) * arrow_len dy = math.sin(ori) * arrow_len ax.arrow(xx, yy, dx, dy, head_width=0.05, head_length=0.1, fc='r', ec='r') plt.show() h, w = ROI.shape minutiae_cylinder = np.zeros((h, w, num_ori), dtype=float) cylinder_ori = np.asarray(range(num_ori)) * math.pi * 2 / num_ori Y, X = np.mgrid[0:h, 0:w] minu_num = minutiae.shape[0] for i in range(0, minu_num): xx = minutiae[i, 0] yy = minutiae[i, 1] if yy < 0 or xx < 0: continue print xx, yy minu_num = minutiae.shape[0] fig, ax = plt.subplots(1) ax.set_aspect('equal') R = 10 arrow_len = 15 ax.imshow(img, cmap='gray') for i in range(0, minu_num): xx = minutiae[i, 0] yy = minutiae[i, 1] circ = Circle((xx, yy), R, color='r', fill=False) ax.add_patch(circ) ori = -minutiae[i, 2] dx = math.cos(ori) * arrow_len dy = math.sin(ori) * arrow_len ax.arrow(xx, yy, dx, dy, head_width=0.05, head_length=0.1, fc='r', ec='r') plt.show() weight = np.exp(-((X - xx) * (X - xx) + (Y - yy) * (Y - yy)) / sigma) ori = minutiae[i, 2] if ori < 0: ori += np.pi * 2 if ori > np.pi * 2: ori -= np.pi * 2 for j in range(num_ori): ori_diff = np.fabs(ori - cylinder_ori[j]) if ori_diff > np.pi * 2: ori_diff = ori_diff - np.pi * 2 ori_diff = np.min([ori_diff, np.pi * 2 - ori_diff]) minutiae_cylinder[:, :, j] += weight * np.exp(-ori_diff / np.pi * 6) show = 0 if show: fig, ax = plt.subplots(1) ax.set_aspect('equal') R = 10 arrow_len = 15 ax.imshow(img, cmap='gray') for i in range(0, minu_num): xx = minutiae[i, 0] yy = minutiae[i, 1] circ = Circle((xx, yy), R, color='r', fill=False) ax.add_patch(circ) ori = -minutiae[i, 2] dx = math.cos(ori) * arrow_len dy = math.sin(ori) * arrow_len ax.arrow(xx, yy, dx, dy, head_width=0.05, head_length=0.1, fc='r', ec='r') plt.show() return img, ROI, minutiae_cylinder
# # minutiae = prepare_data.refine_minutiae(minutiae, dist_thr=10, ori_dist=np.pi / 4) # # return minutiae if __name__ == '__main__': model_dir = '/media/kaicao/data2/AutomatedLatentRecognition/models/OF/facenet/20171229-120921/' OF_center_file = 'OriCenter.mat' os.environ['CUDA_VISIBLE_DEVICES'] = '0' img_path = '../../../../../Data/Latent/NISTSD27/image/' mask_path = '../../../../../Data/Latent/NISTSD27/maskNIST27/' img_files = glob.glob(img_path + '*.bmp') img_files.sort() mask_files = glob.glob(mask_path + '*.bmp') mask_files.sort() for i in range(250, len(img_files)): img = io.imread(img_files[i]) mask = io.imread(mask_files[i]) img = preprocessing.FastCartoonTexture(img) img[mask == 0] = 0 model = ImportGraph(model_dir, OF_center_file) dir_map = model.run(img, mask=mask)
def feature_extraction_single_latent_evaluation(self,img_file, mask_file, AEC_img_file,output_path = None ): img = io.imread(img_file) name = os.path.basename(img_file) AEC_img = io.imread(AEC_img_file) mask = io.imread(mask_file) h,w = mask.shape #mask = mask_dilation(mask, block_size=16) latent_template = template.Template() block = False minu_thr = 0.3 contrast_img = preprocessing.local_constrast_enhancement(img) # Two ways for orientation field estimation # Use the AEC_img and STFT on texture image dir_map_sets = [] texture_img = preprocessing.FastCartoonTexture(img, sigma=2.5, show=False) dir_map, fre_map = get_maps.get_maps_STFT(texture_img, patch_size=64, block_size=16, preprocess=True) dir_map_sets.append(dir_map) blkH, blkW = dir_map.shape dir_map, fre_map = get_maps.get_maps_STFT(AEC_img, patch_size=64, block_size=16, preprocess=True) dir_map_sets.append(dir_map) #dir_map, fre_map = get_maps.get_maps_STFT(contrast_img, patch_size=64, block_size=16, preprocess=True) #dir_map_sets.append(dir_map) # based on the OF, we can use texture image and AEC image for frequency field estimation fre_map_sets = [] quality_map, fre_map = get_maps.get_quality_map_ori_dict(AEC_img, self.dict, self.spacing, dir_map=dir_map_sets[0], block_size=16) fre_map_sets.append(fre_map) quality_map, fre_map = get_maps.get_quality_map_ori_dict(contrast_img, self.dict, self.spacing, dir_map=dir_map_sets[1], block_size=16) fre_map_sets.append(fre_map) descriptor_imgs = [texture_img] descriptor_imgs.append(contrast_img) enh_texture_img = filtering.gabor_filtering_pixel(texture_img, dir_map + math.pi / 2, fre_map_sets[0], mask=mask, block_size=16, angle_inc=3) descriptor_imgs.append(enh_texture_img) enh_contrast_img = filtering.gabor_filtering_pixel(contrast_img, dir_map + math.pi / 2, fre_map_sets[1], mask=mask, block_size=16, angle_inc=3) descriptor_imgs.append(enh_contrast_img) minutiae_sets = [] mnt = self.minu_model.run(texture_img, minu_thr=0.1) mnt = self.remove_spurious_minutiae(mnt, mask) minutiae_sets.append(mnt) fname = output_path + os.path.splitext(name)[0] + '_texture_img.jpeg' show.show_minutiae(texture_img, mnt, block=block, fname=fname) mnt = self.minu_model.run(contrast_img, minu_thr=0.1) mnt = self.remove_spurious_minutiae(mnt, mask) minutiae_sets.append(mnt) fname = output_path + os.path.splitext(name)[0] + '_contrast_img.jpeg' show.show_minutiae(contrast_img, mnt, block=block, fname=fname) mnt = self.minu_model.run(enh_texture_img, minu_thr=minu_thr) mnt = self.remove_spurious_minutiae(mnt, mask) minutiae_sets.append(mnt) fname = output_path + os.path.splitext(name)[0] + '_enh_texture_img.jpeg' show.show_minutiae(enh_texture_img, mnt, block=block, fname=fname) mnt = self.minu_model.run(enh_contrast_img, minu_thr=minu_thr) mnt = self.remove_spurious_minutiae(mnt, mask) minutiae_sets.append(mnt) fname = output_path + os.path.splitext(name)[0] + '_enh_contrast_img.jpeg' show.show_minutiae(enh_contrast_img, mnt, block=block, fname=fname) mnt = self.minu_model.run(AEC_img, minu_thr=minu_thr) mnt = self.remove_spurious_minutiae(mnt, mask) minutiae_sets.append(mnt) fname = output_path + os.path.splitext(name)[0] + '_AEC_img.jpeg' show.show_minutiae(AEC_img, mnt, block=block, fname=fname) for mnt in minutiae_sets: for des_img in descriptor_imgs: des = descriptor.minutiae_descriptor_extraction(des_img, mnt, self.patch_types, self.des_models, self.patchIndexV,batch_size=128) minu_template = template.MinuTemplate(h=h, w=w, blkH=blkH, blkW=blkW, minutiae=mnt, des=des, oimg=dir_map_sets[1], mask=mask) latent_template.add_minu_template(minu_template) return latent_template
def feature_extraction_single_latent(self,img_file, output_path = None, show_processes=False ): #block = True img = io.imread(img_file) name = os.path.basename(img_file) mask_CNN,_ = self.ROI_model.run(img) h,w = mask_CNN.shape #mask = mask_dilation(mask, block_size=16) latent_template = template.Template() minu_thr = 0.3 # template set 1: no ROI and enhancement are required # texture image is used for coase segmentation descriptor_imgs = [] texture_img = preprocessing.FastCartoonTexture(img, sigma=2.5, show=False) descriptor_imgs.append(texture_img) contrast_img_guassian = preprocessing.local_constrast_enhancement_gaussian(img) quality_map, _, _ = get_maps.get_quality_map_dict(texture_img, self.dict_all, self.dict_ori, self.dict_spacing, block_size=16, process=False) quality_map_pixel = cv2.resize(quality_map, (0, 0), fx=16, fy=16) #plt.imshow(quality_map_pixel,cmap='gray') #plt.show() mask_coarse = quality_map_pixel > 0.3 mask_coarse = mask_coarse.astype(np.int) mask = mask_coarse * mask_CNN # show.show_mask(mask_CNN, img, fname='mask_RCNN.jpeg',block=block) # show.show_mask(mask_coarse,img,fname = 'mask_coarse.jpeg',block=block) # show.show_mask(mask, img, fname='mask.jpeg',block=block) #show.show_mask(mask, AEC_img, fname='mask_AEC.jpeg',block=block) # plt.imshow(AEC_img,cmap = 'gray') # plt.show(block=block) # plt.close() #show.show_mask(mask_CNN, img, fname='mask_RCNN.jpeg',block=block) # AEC_img[mask == 0] = 128 # plt.imshow(AEC_img, cmap='gray') # plt.show(block=block) # plt.close() AEC_img = self.enhancement_model.run(texture_img) quality_map, dir_map, fre_map = get_maps.get_quality_map_dict(AEC_img, self.dict_all, self.dict_ori,self.dict_spacing, block_size=16, process=False) blkH, blkW = dir_map.shape if show_processes: show.show_orientation_field(img, dir_map,mask = mask,fname='OF.jpeg') # mnt = self.minu_model.run(contrast_img_mean, minu_thr=0.1) # mnt = self.remove_spurious_minutiae(mnt, mask) # minutiae_sets.append(mnt) # # fname = output_path + os.path.splitext(name)[0] + '_contrast_img_mean.jpeg' # show.show_minutiae(contrast_img_mean, mnt, block=block, fname=fname) enh_contrast_img = filtering.gabor_filtering_pixel(contrast_img_guassian, dir_map + math.pi / 2, fre_map, mask=mask, block_size=16, angle_inc=3) enh_texture_img = filtering.gabor_filtering_pixel(texture_img, dir_map + math.pi / 2, fre_map, mask=mask, block_size=16, angle_inc=3) if show_processes: show.show_image(texture_img, mask=mask, block=True, fname='cropped_texture_image.jpeg') show.show_image(AEC_img, mask=mask, block=True, fname='cropped_AEC_image.jpeg') show.show_image(enh_contrast_img, mask=mask, block=True, fname='cropped_enh_image.jpeg') #np.ones((h, w), np.int) descriptor_imgs.append(enh_contrast_img) quality_map2, _ , _ = get_maps.get_quality_map_dict(enh_contrast_img, self.dict_all,self.dict_ori,self.dict_spacing, block_size=16, process=False) quality_map_pixel2 = cv2.resize(quality_map2, (0, 0), fx=16, fy=16) mask2 = quality_map_pixel2 > 0.50 #mask = mask*mask2 minutiae_sets = [] mnt = self.minu_model.run(contrast_img_guassian, minu_thr=0.05) mnt = self.remove_spurious_minutiae(mnt, mask) minutiae_sets.append(mnt) if show_processes: fname = 'minutiae_texture_img.jpeg' show.show_minutiae(texture_img, mnt, mask=mask,block=block, fname=fname) mnt = self.minu_model.run(AEC_img, minu_thr=0.3) mnt = self.remove_spurious_minutiae(mnt, mask2) minutiae_sets.append(mnt) if show_processes: fname = 'minutiae_AEC_img.jpeg' show.show_minutiae(AEC_img, mnt, mask=mask, block=block, fname=fname) mnt = self.minu_model.run(enh_contrast_img, minu_thr=0.3) mnt = self.remove_spurious_minutiae(mnt, mask2) minutiae_sets.append(mnt) if show_processes: fname = 'minutiae_enh_contrast_img.jpeg' show.show_minutiae(enh_contrast_img, mnt, mask=mask,block=block, fname=fname) mnt = self.minu_model.run(enh_texture_img, minu_thr=0.3) mnt = self.remove_spurious_minutiae(mnt, mask2) minutiae_sets.append(mnt) # minutiae template 1 des = descriptor.minutiae_descriptor_extraction(texture_img, minutiae_sets[0], self.patch_types, self.des_models, self.patchIndexV, batch_size=128) minu_template = template.MinuTemplate(h=h, w=w, blkH=blkH, blkW=blkW, minutiae=minutiae_sets[0], des=des, oimg=dir_map, mask=mask) latent_template.add_minu_template(minu_template) # minutiae template 2 des = descriptor.minutiae_descriptor_extraction(texture_img, minutiae_sets[1], self.patch_types, self.des_models, self.patchIndexV, batch_size=128) minu_template = template.MinuTemplate(h=h, w=w, blkH=blkH, blkW=blkW, minutiae=minutiae_sets[1], des=des, oimg=dir_map, mask=mask) latent_template.add_minu_template(minu_template) # minutiae template 3 des = descriptor.minutiae_descriptor_extraction(enh_texture_img, minutiae_sets[2], self.patch_types, self.des_models, self.patchIndexV, batch_size=128) minu_template = template.MinuTemplate(h=h, w=w, blkH=blkH, blkW=blkW, minutiae=minutiae_sets[2], des=des, oimg=dir_map, mask=mask) latent_template.add_minu_template(minu_template) # minutiae template 4 des = descriptor.minutiae_descriptor_extraction(enh_texture_img, minutiae_sets[3], self.patch_types, self.des_models, self.patchIndexV, batch_size=128) minu_template = template.MinuTemplate(h=h, w=w, blkH=blkH, blkW=blkW, minutiae=minutiae_sets[3], des=des, oimg=dir_map, mask=mask) latent_template.add_minu_template(minu_template) return latent_template
def feature_extraction_single_latent_evaluation_AEM18T(self,img_file, mask_file, AEC_img_file,output_path = None ): img = io.imread(img_file) name = os.path.basename(img_file) AEC_img = io.imread(AEC_img_file) mask_CNN = io.imread(mask_file) h,w = mask_CNN.shape #mask = mask_dilation(mask, block_size=16) latent_template = template.Template() block = False minu_thr = 0.3 # template set 1: no ROI and enhancement are required # texture image is used for coase segmentation descriptor_imgs = [] texture_img = preprocessing.FastCartoonTexture(img, sigma=2.5, show=False) descriptor_imgs.append(texture_img) contrast_img_mean = preprocessing.local_constrast_enhancement(img) contrast_img_guassian = preprocessing.local_constrast_enhancement_gaussian(img) quality_map, dir_map, fre_map = get_maps.get_quality_map_dict(texture_img, self.dict_all, self.dict_ori, self.dict_spacing, block_size=16, process=False) quality_map_pixel = cv2.resize(quality_map, (0, 0), fx=16, fy=16) mask_coarse = quality_map_pixel > 0.3 mask_coarse = mask_coarse.astype(np.int) quality_map, dir_map, fre_map = get_maps.get_quality_map_dict(AEC_img, self.dict_all, self.dict_ori,self.dict_spacing, block_size=16, process=False) minutiae_sets = [] mnt = self.minu_model.run(texture_img, minu_thr=0.1) mnt = self.remove_spurious_minutiae(mnt, mask_coarse) minutiae_sets.append(mnt) fname = output_path + os.path.splitext(name)[0] + '_texture_img.jpeg' show.show_minutiae(texture_img, mnt, block=block, fname=fname) mnt = self.minu_model.run(contrast_img_mean, minu_thr=0.1) mnt = self.remove_spurious_minutiae(mnt, mask_coarse) minutiae_sets.append(mnt) fname = output_path + os.path.splitext(name)[0] + '_contrast_img_mean.jpeg' show.show_minutiae(contrast_img_mean, mnt, block=block, fname=fname) mnt = self.minu_model.run(contrast_img_guassian, minu_thr=0.1) mnt = self.remove_spurious_minutiae(mnt, mask_coarse) minutiae_sets.append(mnt) fname = output_path + os.path.splitext(name)[0] + '_contrast_img_guassian.jpeg' show.show_minutiae(contrast_img_guassian, mnt, block=block, fname=fname) #show.show_orientation_field(AEC_img,dir_map) enh_texture_img = filtering.gabor_filtering_pixel(texture_img, dir_map + math.pi / 2, fre_map, mask=np.ones((h, w), np.int), block_size=16, angle_inc=3) descriptor_imgs.append(enh_texture_img) enh_constrast_img = filtering.gabor_filtering_pixel(contrast_img_guassian, dir_map + math.pi / 2, fre_map, mask=np.ones((h,w),np.int), block_size=16, angle_inc=3) descriptor_imgs.append(enh_constrast_img) quality_map2, _ , _ = get_maps.get_quality_map_dict(enh_texture_img, self.dict_all,self.dict_ori,self.dict_spacing, block_size=16, process=False) quality_map_pixel2 = cv2.resize(quality_map2, (0, 0), fx=16, fy=16) mask = quality_map_pixel2 > 0.55 mask = mask.astype(np.int) mask = mask_coarse * mask mask = mask * mask_CNN mnt = self.minu_model.run(AEC_img, minu_thr=0.3) mnt = self.remove_spurious_minutiae(mnt, mask) minutiae_sets.append(mnt) fname = output_path + os.path.splitext(name)[0] + '_AEC_img.jpeg' show.show_minutiae(AEC_img, mnt, block=block, fname=fname) mnt = self.minu_model.run(enh_texture_img, minu_thr=0.3) mnt = self.remove_spurious_minutiae(mnt, mask) minutiae_sets.append(mnt) fname = output_path + os.path.splitext(name)[0] + '_enh_texture_img.jpeg' show.show_minutiae(enh_texture_img, mnt, block=block, fname=fname) mnt = self.minu_model.run(enh_constrast_img, minu_thr=0.3) mnt = self.remove_spurious_minutiae(mnt, mask) minutiae_sets.append(mnt) fname = output_path + os.path.splitext(name)[0] + '_enh_constrast_img.jpeg' show.show_minutiae(enh_constrast_img, mnt, block=block, fname=fname) blkH, blkW = dir_map.shape for mnt in minutiae_sets: for des_img in descriptor_imgs: des = descriptor.minutiae_descriptor_extraction(des_img, mnt, self.patch_types, self.des_models, self.patchIndexV, batch_size=128) minu_template = template.MinuTemplate(h=h, w=w, blkH=blkH, blkW=blkW, minutiae=mnt, des=des, oimg=dir_map, mask=mask) latent_template.add_minu_template(minu_template) return latent_template
def feature_extraction_single_latent(self, img_file, output_dir=None, ppi=500, show_processes=False, show_minutiae=False, minu_file=None): block = False block_size = 16 img0 = io.imread(img_file, mode='L') # / 255.0 img = img0.copy() if ppi != 500: img = cv2.resize(img, (0, 0), fx=500.0 / ppi, fy=500.0 / ppi) img = preprocessing.adjust_image_size(img, block_size) name = os.path.basename(img_file) start = timer() h, w = img.shape if h > 1000 and w > 1000: return None, None # cropping using two dictionary based approach if minu_file is not None: manu_minu = np.loadtxt(minu_file) # # # remove low quality minutiae points input_minu = np.array(manu_minu) input_minu[:, 2] = input_minu[:, 2] / 180.0 * np.pi else: input_minu = [] descriptor_imgs = [] texture_img = preprocessing.FastCartoonTexture(img, sigma=2.5, show=False) STFT_texture_img = preprocessing.STFT(texture_img) contrast_img_guassian = preprocessing.local_constrast_enhancement_gaussian( img) STFT_img = preprocessing.STFT(img) constrast_STFT_img = preprocessing.STFT(contrast_img_guassian) # step 1: enhance the latent based on our autoencoder AEC_img = self.enhancement_model.run_whole_image(STFT_texture_img) quality_map_AEC, dir_map_AEC, fre_map_AEC = get_maps.get_quality_map_dict( AEC_img, self.dict_all, self.dict_ori, self.dict_spacing, R=500.0) blkmask_AEC = quality_map_AEC > 0.45 blkmask_AEC = binary_closing(blkmask_AEC, np.ones( (3, 3))).astype(np.int) blkmask_AEC = binary_opening(blkmask_AEC, np.ones( (3, 3))).astype(np.int) blkmask_SSIM = get_maps.SSIM(STFT_texture_img, AEC_img, thr=0.2) blkmask = blkmask_SSIM * blkmask_AEC blkH, blkW = blkmask.shape mask = cv2.resize(blkmask.astype(float), (block_size * blkW, block_size * blkH), interpolation=cv2.INTER_LINEAR) mask[mask > 0] = 1 minutiae_sets = [] mnt_STFT = self.minu_model[0].run_whole_image(STFT_img, minu_thr=0.05) minutiae_sets.append(mnt_STFT) if show_minutiae: fname = output_dir + os.path.splitext(name)[0] + '_STFT_img.jpeg' show.show_minutiae_sets(STFT_img, [input_minu, mnt_STFT], mask=None, block=block, fname=fname) mnt_STFT = self.minu_model[0].run_whole_image(constrast_STFT_img, minu_thr=0.1) minutiae_sets.append(mnt_STFT) mnt_AEC = self.minu_model[1].run_whole_image(AEC_img, minu_thr=0.25) mnt_AEC = self.remove_spurious_minutiae(mnt_AEC, mask) minutiae_sets.append(mnt_AEC) if show_minutiae: fname = output_dir + os.path.splitext(name)[0] + '_AEC_img.jpeg' show.show_minutiae_sets(AEC_img, [input_minu, mnt_AEC], mask=mask, block=block, fname=fname) enh_contrast_img = filtering.gabor_filtering_pixel2( contrast_img_guassian, dir_map_AEC + math.pi / 2, fre_map_AEC, mask=np.ones((h, w)), block_size=16, angle_inc=3) mnt_contrast = self.minu_model[1].run_whole_image(enh_contrast_img, minu_thr=0.25) mnt_contrast = self.remove_spurious_minutiae(mnt_contrast, mask) minutiae_sets.append(mnt_contrast) enh_texture_img = filtering.gabor_filtering_pixel2( texture_img, dir_map_AEC + math.pi / 2, fre_map_AEC, mask=np.ones((h, w)), block_size=16, angle_inc=3) mnt_texture = self.minu_model[1].run_whole_image(enh_texture_img, minu_thr=0.25) mnt_texture = self.remove_spurious_minutiae(mnt_texture, mask) minutiae_sets.append(mnt_texture) h, w = img.shape latent_template = template.Template() # template set 1: no ROI and enhancement are required # texture image is used for coase segmentation descriptor_imgs = [] descriptor_imgs.append(STFT_img) descriptor_imgs.append(texture_img) descriptor_imgs.append(enh_texture_img) descriptor_imgs.append(enh_contrast_img) mnt2 = self.get_common_minutiae(minutiae_sets, thr=2) mnt3 = self.get_common_minutiae(minutiae_sets, thr=3) minutiae_sets.append(mnt3) minutiae_sets.append(mnt2) if show_minutiae: fname = output_dir + os.path.splitext(name)[0] + '_common_2.jpeg' show.show_minutiae_sets(img, [input_minu, mnt2], mask=mask, block=block, fname=fname) end = timer() print('Time for minutiae extraction: %f' % (end - start)) start = timer() for mnt in minutiae_sets: for des_img in descriptor_imgs: des = descriptor.minutiae_descriptor_extraction( des_img, mnt, self.patch_types, self.des_models, self.patchIndexV, batch_size=128) minu_template = template.MinuTemplate(h=h, w=w, blkH=blkH, blkW=blkW, minutiae=mnt, des=des, oimg=dir_map_AEC, mask=mask) latent_template.add_minu_template(minu_template) end = timer() print('Time for minutiae descriptor generation: %f' % (end - start)) start = timer() # texture templates stride = 16 x = np.arange(24, w - 24, stride) y = np.arange(24, h - 24, stride) virtual_minutiae = [] distFromBg = scipy.ndimage.morphology.distance_transform_edt(mask) for y_i in y: for x_i in x: if (distFromBg[y_i][x_i] <= 16): continue ofY = int(y_i / 16) ofX = int(x_i / 16) ori = -dir_map_AEC[ofY][ofX] virtual_minutiae.append([x_i, y_i, ori]) virtual_minutiae.append([x_i, y_i, math.pi + ori]) virtual_minutiae = np.asarray(virtual_minutiae) texture_template = [] if len(virtual_minutiae) > 3: virtual_des = descriptor.minutiae_descriptor_extraction( enh_contrast_img, virtual_minutiae, self.patch_types, self.des_models, self.patchIndexV, batch_size=128, patch_size=96) texture_template = template.TextureTemplate( h=h, w=w, minutiae=virtual_minutiae, des=virtual_des, mask=None) latent_template.add_texture_template(texture_template) end = timer() print('Time for texture template generation: %f' % (end - start)) return latent_template, texture_template
def feature_extraction_single_latent(raw_img_file, AEC_img_file, mask_file, patch_types=None, des_models=None): raw_img = io.imread(raw_img_file) AEC_img = io.imread(AEC_img_file) mask = io.imread(mask_file) texture_img = preprocessing.FastCartoonTexture(raw_img, sigma=2.5, show=False) dir_map, fre_map, rec_img = get_maps.get_maps_STFT(AEC_img, patch_size=64, block_size=16, preprocess=True) descriptor_img = filtering.gabor_filtering_pixel(texture_img, dir_map + math.pi / 2, fre_map, mask=mask, block_size=16, angle_inc=3) bin_img = binarization.binarization(texture_img, dir_map, block_size=16, mask=mask) enhanced_img = filtering.gabor_filtering_block(bin_img, dir_map + math.pi / 2, fre_map, patch_size=64, block_size=16) enhanced_img = filtering.gabor_filtering_block(enhanced_img, dir_map + math.pi / 2, fre_map, patch_size=64, block_size=16) enhanced_AEC_img = filtering.gabor_filtering_block(AEC_img, dir_map + math.pi / 2, fre_map, patch_size=64, block_size=16) bin_img = binarization.binarization(enhanced_AEC_img, dir_map, block_size=16, mask=mask) bin_img2 = 1 - bin_img thin_img = skeletonize(bin_img2) mnt, thin_img2 = crossnumber.extract_minutiae(1 - thin_img, mask=mask, R=10) crossnumber.show_minutiae(thin_img, mnt) patchSize = 160 oriNum = 64 patchIndexV = descriptor.get_patch_index(patchSize, patchSize, oriNum, isMinu=1) if len(descriptor_img.shape) == 2: h, w = descriptor_img.shape ret = np.empty((h, w, 3), dtype=np.float) ret[:, :, :] = descriptor_img[:, :, np.newaxis] descriptor_img = ret if len(enhanced_AEC_img.shape) == 2: h, w = enhanced_AEC_img.shape ret = np.empty((h, w, 3), dtype=np.float) ret[:, :, :] = enhanced_AEC_img[:, :, np.newaxis] enhanced_AEC_img = ret des = descriptor.minutiae_descriptor_extraction(enhanced_AEC_img, mnt, patch_types, des_models, patchIndexV, batch_size=128) h, w = mask.shape blkH, blkW = dir_map.shape minu_template = template.MinuTemplate(h=h, w=w, blkH=blkH, blkW=blkW, minutiae=mnt, des=des, oimg=dir_map, mask=mask) latent_template = template.Template() latent_template.add_minu_template(minu_template) print des
def feature_extraction_single_rolled(self, img_file, output_dir=None, ppi=500): block_size = 16 if not os.path.exists(img_file): return None img = io.imread(img_file, s_grey=True) if ppi != 500: img = cv2.resize(img, (0, 0), fx=500.0 / ppi, fy=500.0 / ppi) img = preprocessing.adjust_image_size(img, block_size) if len(img.shape) > 2: img = rgb2gray(img) h, w = img.shape start = timeit.default_timer() mask = get_maps.get_quality_map_intensity(img) stop = timeit.default_timer() print('time for cropping : %f' % (stop - start)) start = timeit.default_timer() contrast_img = preprocessing.local_constrast_enhancement(img) texture_img = preprocessing.FastCartoonTexture(img, sigma=2.5, show=False) mnt = self.minu_model.run_whole_image(texture_img, minu_thr=0.15) stop = timeit.default_timer() print('time for minutiae : %f' % (stop - start)) start = timeit.default_timer() des = descriptor.minutiae_descriptor_extraction( img, mnt, self.patch_types, self.des_models, self.patchIndexV, batch_size=256, patch_size=self.patch_size) stop = timeit.default_timer() print('time for descriptor : %f' % (stop - start)) dir_map, _ = get_maps.get_maps_STFT(img, patch_size=64, block_size=block_size, preprocess=True) blkH = h // block_size blkW = w // block_size minu_template = template.MinuTemplate(h=h, w=w, blkH=blkH, blkW=blkW, minutiae=mnt, des=des, oimg=dir_map, mask=mask) rolled_template = template.Template() rolled_template.add_minu_template(minu_template) start = timeit.default_timer() # texture templates stride = 16 x = np.arange(24, w - 24, stride) y = np.arange(24, h - 24, stride) virtual_minutiae = [] distFromBg = scipy.ndimage.morphology.distance_transform_edt(mask) for y_i in y: for x_i in x: if (distFromBg[y_i][x_i] <= 24): continue ofY = int(y_i / 16) ofX = int(x_i / 16) ori = -dir_map[ofY][ofX] virtual_minutiae.append([x_i, y_i, ori]) virtual_minutiae = np.asarray(virtual_minutiae) if len(virtual_minutiae) > 1000: virtual_minutiae = virtual_minutiae[:1000] print len(virtual_minutiae) if len(virtual_minutiae) > 3: virtual_des = descriptor.minutiae_descriptor_extraction( contrast_img, virtual_minutiae, self.patch_types, self.des_models, self.patchIndexV, batch_size=128) texture_template = template.TextureTemplate( h=h, w=w, minutiae=virtual_minutiae, des=virtual_des, mask=mask) rolled_template.add_texture_template(texture_template) stop = timeit.default_timer() print('time for texture : %f' % (stop - start)) return rolled_template