def compute(image_file_path: str, config: Dict, model: Any) -> np.array: """Computes descriptors from keypoints saved in a file.""" img = cv2.imread(image_file_path, 0) img = io_utils.smart_scale( img, config['max_size'], prevent_upscaling=True) if config['max_size'] is not None else img # Infer the path to the corresponding csv file for the keypoints. collection_name, set_name, image_name, _ = io_utils.get_path_components( image_file_path) # find path to keypoints file keypoints_file_path = io_utils.build_output_path( config['output_dir'], collection_name, set_name, 'keypoints', config['detector_name'], image_name, max_size=config['max_size'], max_num_keypoints=config['max_num_keypoints']) if not os.path.isfile(keypoints_file_path): print('Could not find keypoints in path: {}\n.Skip'.format( keypoints_file_path)) return None # Load keypoints from csv file as numpy array. kpts_numpy = io_utils.get_keypoints_from_csv(keypoints_file_path) # Convert numpy array to List of cv2.KeyPoint list kpts_cv2 = io_utils.numpy_to_cv2_kp(kpts_numpy) # Create iamge patches for each keypoint patches = create_patches(img, kpts_cv2, 42) # Save patches in tmp dir path_to_desc = os.path.join(config['tmp_dir_doap'], 'descriptors.csv') path_to_patches = os.path.join(config['tmp_dir_doap'], 'patches.csv') io_utils.save_patches_list(patches, path_to_patches) # Compute descritpors in matlab. Save result in tmp_dir # TODO: file paths for vlfeat, matconvnet and the model must be parameters subprocess.check_call([ 'matlab', '-nosplash', '-r', "use_doap_with_file('vlfeat-0.9.21', 'matconvnet-1.0-beta25', 'HPatches_ST_LM_128d.mat', '.', '{}', '{}');quit" .format(path_to_patches, path_to_desc) ]) # Load matlab results and return. desc = np.loadtxt(path_to_desc, delimiter=',') return desc
def compute(image_file_path: str, config: Dict, model: Any) -> np.array: """Computes descriptors from keypoints saved in a file.""" # Load image and scale appropiately. Image is later used to create patch, # which in turn is used to create the descriptor. img = cv2.imread(image_file_path, 0) img = io_utils.smart_scale( img, config['max_size'], prevent_upscaling=True) if config['max_size'] is not None else img # Infer the path to the corresponding csv file for the keypoints. collection_name, set_name, image_name, _ = io_utils.get_path_components( image_file_path) # find path to keypoints file keypoints_file_path = io_utils.build_output_path( config['output_dir'], collection_name, set_name, 'keypoints', config['detector_name'], image_name, max_size=config['max_size'], max_num_keypoints=config['max_num_keypoints']) if not os.path.isfile(keypoints_file_path): print('Could not find keypoints in path: {}\n.Skip'.format( keypoints_file_path)) return None # Load keypoints from csv file as numpy array. kpts_numpy = io_utils.get_keypoints_from_csv(keypoints_file_path) # Convert numpy array to List of cv2.KeyPoint list kpts_cv2 = io_utils.numpy_to_cv2_kp(kpts_numpy) # Create image patches for each keypoint patches = rectify_patches(img, kpts_cv2, 32, 3) #Compute descriptors desc = compute_descriptors(model, patches, use_gpu=False) return desc
def main(args): # Get necessary directories output_dir = args.output_dir image_dir = args.image_dir data_dir = args.data_dir tensorflow_dir = os.path.join(data_dir, args.tensorflow_dir) stats_dir = os.path.join(data_dir, args.stats_dir) train_name = args.train_name stats_name = args.stats_name save_feature_name = args.save_feature # Create list of file names. file_list = args.file_list.split(' ') # Parameters alpha = args.alpha patch_size = args.patch_size batch_size = args.batch_size descriptor_dim = args.descriptor_dim stats_path = os.path.join(stats_dir, 'stats_{}.pkl'.format(stats_name)) print('Loading training stats:') with open(stats_path, 'rb') as src: mean, std = pickle.load(src, encoding='utf-8') print('Training data loaded:\nMean: {}\nStd: {}'.format(mean, std)) CNNConfig = { 'patch_size': patch_size, 'descriptor_dim': descriptor_dim, 'batch_size': batch_size, 'alpha': alpha, 'train_flag': False } cnn_model = patch_cnn.PatchCNN(CNNConfig) saver = tf.train.Saver() gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.8) with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess: try: saver.restore( sess, os.path.join(tensorflow_dir, '{}_model.ckpt'.format(train_name))) # saver.restore(sess, '../tensorflow_model/'+train_name+'_model.ckpt') print('Model restored.') except: print('No model found .Exit.') exit() for file_path in file_list: collection_name, set_name, file_base, extension = io_utils.get_path_components( file_path) file_name = '{}.{}'.format(file_base, extension) save_dir = os.path.join(output_dir, save_feature_name, collection_name, set_name) io_utils.create_dir( save_dir) # Create folder if it does not exists output_list = [] if extension in ['.ppm', '.pgm', '.png', '.jpg']: save_file = file_base + '.mat' save_name = os.path.join(save_dir, save_file) #read image img, ratio = read_image_from_name(file_path) if img.shape[2] == 1: img = np.repeat(img, 3, axis=2) #build image pyramid pyramid = pyramid_gaussian(img, max_layer=4, downscale=np.sqrt(2)) #predict transformation for (j, resized) in enumerate(pyramid): fetch = {'o1': cnn_model.o1} resized = np.asarray(resized) resized = (resized - mean) / std resized = resized.reshape( (1, resized.shape[0], resized.shape[1], resized.shape[2])) result = sess.run(fetch, feed_dict={cnn_model.patch: resized}) result_mat = result['o1'].reshape( (result['o1'].shape[1], result['o1'].shape[2], result['o1'].shape[3])) output_list.append(result_mat) sio.savemat(save_name, {'output_list': output_list})
def compute(image_file_path: str, config: Dict, model: Any) -> np.array: """ Computes the descriptors for all keypoints in a keypoint .csv file. 1) Check if keypoint file exisits. 2) Load and scale image. 2b) Save image in tmp dir. 3) Load .csv file mit keypoints as cv2.KeyPoint list. 4) ...and convert it with correct format for LIFT. 5) Save keypoint list to text in `tmp` dir as .txt 6) Compute orientation 7) compute descriptors 8) Load descriptors as numpy """ # Build paths lift_path = os.path.join(config['root_dir_lift'], 'tf-lift') path_tmp_img = os.path.join(config['tmp_dir_lift'], 'tmp_img.png') path_tmp_kpts = os.path.join(config['tmp_dir_lift'], 'tmp_kpts.txt') path_tmp_ori = os.path.join(config['tmp_dir_lift'], 'tmp_ori.txt') path_tmp_desc = os.path.join(config['tmp_dir_lift'], 'tmp_desc.h5') # Infer the path to the corresponding csv file for the keypoints. collection_name, set_name, image_name, _ = io_utils.get_path_components( image_file_path) # find path to keypoints file keypoints_file_path = io_utils.build_output_path( config['output_dir'], collection_name, set_name, 'keypoints', config['detector_name'], image_name, max_size=config['max_size'], max_num_keypoints=config['max_num_keypoints']) # 1) Check if keypoint file exists. if not os.path.isfile(keypoints_file_path): print('Could not find keypoints in path: {}\n.Skip'.format( keypoints_file_path)) return None # 2) Load and scale image img = cv2.imread(image_file_path, 0) img = io_utils.smart_scale( img, config['max_size'], prevent_upscaling=config['prevent_upscaling'] ) if config['max_size'] is not None else img # 2b) Write image in tmp dir cv2.imwrite(path_tmp_img, img) # 3) Load .csv file mit keypoints as cv2.KeyPoint list. kpts_numpy = io_utils.get_keypoints_from_csv(keypoints_file_path) # Convert numpy array to List of cv2.KeyPoint list kpts_cv2 = io_utils.numpy_to_cv2_kp(kpts_numpy) # 4) Convert to LIFT format kpts_lift = opencv_kp_list_2_kp_list(kpts_cv2) # 5) Save keypoint list as .txt file for LIFT saveKpListToTxt(kpts_lift, None, path_tmp_kpts) try: # 6) Orientation subprocess.check_call([ 'python', 'main.py', '--subtask=ori', '--test_img_file={}'.format(path_tmp_img), '--test_out_file={}'.format(path_tmp_ori), '--test_kp_file={}'.format(path_tmp_kpts) ], cwd=lift_path) # 7) Descriptors subprocess.check_call([ 'python', 'main.py', '--subtask=desc', '--test_img_file={}'.format(path_tmp_img), '--test_out_file={}'.format(path_tmp_desc), '--test_kp_file={}'.format(path_tmp_ori) ], cwd=lift_path) except Exception: print( 'Could not compute descriptros for image {} at max_size {}. Skip.'. format(image_file_path, config['max_size'])) return None # 8) f = h5py.File(path_tmp_desc, 'r') descriptors = np.array(list(f['descriptors'])) return descriptors
def detect_bulk(file_list: List[str], config: Dict) -> None: """Computes keypoints for all files in `file_list`. Additionally for each file, create an image with the corresponding keypoints drawn into it. All results will be saved within the `tmp` folder for this module. Arguments: file_list {List[str]} -- List of all images for which to compute keypoints. config {Dict} -- General configuration object. See config_run_detectors.py for more information. Returns: None -- All results here are saved within the `tmp` dir specified within the `config` object. """ try: # Create feature map for each image in 'covariant_points' folder subprocess.check_call([ 'python', 'patch_network_point_test.py', '--save_feature', 'covariant_points', '--output_dir', config['tmp_dir_tcovdet'], '--file_list', ' '.join(file_list), ]) except Exception as e: print('TCovDet: Covariant feature map creation failed.') print(e) raise e try: collection_names = [] set_names = [] image_names = [] for file_path in file_list: collection_name, set_name, file_base, extension = io_utils.get_path_components( file_path) collection_names.append(collection_name) set_names.append(set_name) image_names.append(file_base) # The path to this file matlab_config_path = os.path.join(config['tmp_dir_tcovdet'], 'filelist.mat') # Where to save the keypoints dir_output = os.path.join(config['tmp_dir_tcovdet'], 'feature_points') io_utils.create_dir(dir_output) # Create on the fly if not existent # Where the .mat files of the covariant step lie dir_data = os.path.join(config['tmp_dir_tcovdet'], 'covariant_points') # Set maxinal number of keypoints to find point_number = 1000 if config['max_num_keypoints'] is None else config[ 'max_num_keypoints'] savemat( matlab_config_path, { 'file_list': file_list, 'collection_names': collection_names, 'set_names': set_names, 'image_names': image_names, 'dir_output': dir_output, 'dir_data': dir_data, 'point_number': point_number }) subprocess.check_call([ 'matlab', '-nosplash', '-r', "point_extractor('vlfeat-0.9.21', '{}');quit".format( matlab_config_path) ]) except Exception as e: print('TCovDet: Keypoint feature map creation failed.') print(e) raise e # Load each created .mat file, extract the keypoints (Column 2 and 5), # create list of cv2.KeyPoint. # Then load the image, scale it, draw the keypoints in it and save everything for i in tqdm(range(len(file_list))): file = file_list[i] mat_path = os.path.join(config['tmp_dir_tcovdet'], 'feature_points', collection_names[i], set_names[i], image_names[i] + '.mat') kpts_numpy = loadmat(mat_path)['feature'][:, [2, 5]] # numpy array scores = loadmat(mat_path)['score'] if len(kpts_numpy): kpts_cv2 = [ cv2.KeyPoint(x[0], x[1], 1.0, _response=scores[idx]) for idx, x in enumerate(kpts_numpy) ] # list of cv2.KeyPoint img = cv2.imread(file, 0) if (img.shape[0] * img.shape[1]) > (1024 * 768): ratio = (1024 * 768 / float(img.shape[0] * img.shape[1]))**(0.5) img = cv2.resize( img, (int(img.shape[1] * ratio), int(img.shape[0] * ratio)), interpolation=cv2.INTER_CUBIC) img_kp = io_utils.draw_keypoints(img, kpts_cv2, config) # Save everything. io_utils.save_detector_output(file, config['detector_name'], config, kpts_cv2, img_kp, None) else: print('Warning: Did not find any keypoints!')