def __init__(self, num_features=2000, do_tf_logging=False): print('Using LfNetFeature2D') self.lock = RLock() self.model_base_path = kLfNetBasePath self.model_path = kLfNetModelPath self.lfnet_config = build_lfnet_config() print_options(self.lfnet_config, 'LFNET CONFIG') self.num_features = num_features self.lfnet_config.top_k = self.num_features set_tf_logging(do_tf_logging) print('==> Loading pre-trained network.') # Build Networks tf.reset_default_graph() self.photo_ph = tf.placeholder( tf.float32, [1, None, None, 1]) # input grayscale image, normalized by 0~1 is_training = tf.constant(False) # Always False in testing self.ops = build_networks(self.lfnet_config, self.photo_ph, is_training) tf_config = tf.ConfigProto() tf_config.gpu_options.allow_growth = True self.session = tf.Session(config=tf_config) self.session.run(tf.global_variables_initializer()) # load model saver = tf.train.Saver() print('Load trained models...') if os.path.isdir(self.lfnet_config.model): checkpoint = tf.train.latest_checkpoint(self.lfnet_config.model) model_dir = self.lfnet_config.model else: checkpoint = self.lfnet_config.model model_dir = os.path.dirname(self.lfnet_config.model) if checkpoint is not None: print('Checkpoint', os.path.basename(checkpoint)) print("[{}] Resuming...".format(time.asctime())) saver.restore(self.session, checkpoint) else: raise ValueError('Cannot load model from {}'.format(model_dir)) print('==> Successfully loaded pre-trained network.') self.pts = [] self.kps = [] self.des = [] self.frame = None self.keypoint_size = 20. # just a representative size for visualization and in order to convert extracted points to cv2.KeyPoint
def __init__(self, num_features=2000, n_sample=2048, # Maximum number of sampled keypoints per octave dense_desc=False, # Whether to use dense descriptor model model_type='pb', do_tf_logging=False): print('Using ContextDescFeature2D') self.lock = RLock() self.model_base_path= config.cfg.root_folder + '/thirdparty/contextdesc/' set_tf_logging(do_tf_logging) self.num_features = num_features self.n_sample = n_sample self.model_type = model_type self.dense_desc = dense_desc self.quantize = ContextDescFeature2D.quantize self.loc_model_path = self.model_base_path + 'pretrained/contextdesc++' self.reg_model_path = self.model_base_path + 'pretrained/retrieval_model' if self.model_type == 'pb': reg_model_path = os.path.join(self.reg_model_path, 'reg.pb') loc_model_path = os.path.join(self.loc_model_path, 'loc.pb') aug_model_path = os.path.join(self.loc_model_path, 'aug.pb') elif self.model_type == 'ckpt': reg_model_path = os.path.join(self.reg_model_path, 'model.ckpt-550000') loc_model_path = os.path.join(self.loc_model_path, 'model.ckpt-400000') aug_model_path = os.path.join(self.loc_model_path, 'model.ckpt-400000') else: raise NotImplementedError self.keypoint_size = 10 # just a representative size for visualization and in order to convert extracted points to cv2.KeyPoint self.pts = [] self.kps = [] self.des = [] self.scales = [] self.scores = [] self.frame = None print('==> Loading pre-trained network.') self.ref_model = RegModel(reg_model_path) #get_model('reg_model')(reg_model_path) #RegModel(reg_model_path) self.loc_model = LocModel(loc_model_path, **{'sift_desc': False, # compute or not SIFT descriptor (we do not need them here!) 'n_feature': self.num_features, 'n_sample': self.n_sample, 'peak_thld': 0.04, 'dense_desc': self.dense_desc, 'upright': False}) self.aug_model = AugModel(aug_model_path, **{'quantz': self.quantize}) print('==> Successfully loaded pre-trained network.')
def __init__(self, num_features=1000, score_threshold=100, do_tf_logging=False): print('Using DelfFeature2D') self.lock = RLock() set_tf_logging(do_tf_logging) # Parse DelfConfig proto. self.delf_config = delf_config_pb2.DelfConfig() with tf.gfile.FastGFile(delf_config_file, 'r') as f: text_format.Merge(f.read(), self.delf_config) self.delf_config.model_path = delf_model_path self.delf_config.delf_local_config.pca_parameters.mean_path = delf_mean_path self.delf_config.delf_local_config.pca_parameters.projection_matrix_path = delf_projection_matrix_path self.delf_config.delf_local_config.max_feature_num = num_features self.delf_config.delf_local_config.score_threshold = score_threshold print('DELF CONFIG\n:', self.delf_config) self.keypoint_size = 30 # just a representative size for visualization and in order to convert extracted points to cv2.KeyPoint self.image_scales = list(self.delf_config.image_scales) #print('image scales: ',self.image_scales) try: self.scale_factor = self.image_scales[1] / self.image_scales[0] except: self.scale_factor = np.sqrt( 2) # according to default config and the paper #print('scale_factor: ',self.scale_factor) #self.image_levels = np.round(-np.log(self.image_scales)/np.log(self.scale_factor)).astype(np.int32) #print('image levels: ',self.image_levels) self.session = None self.pts = [] self.kps = [] self.des = [] self.scales = [] self.scores = [] self.frame = None print('==> Loading pre-trained network.') self.load_model() print('==> Successfully loaded pre-trained network.')
def __init__(self, net_name, do_tf_logging=True, flagCS=False): set_tf_logging(do_tf_logging) # from https://kobkrit.com/using-allow-growth-memory-option-in-tensorflow-and-keras-dc8c8081bc96 config = tf.ConfigProto() config.gpu_options.allow_growth = True # dynamically grow the memory used on the GPU #config.log_device_placement = True # to log device placement (on which device the operation ran) sess = tf.Session(config=config) set_session( sess ) # set this TensorFlow session as the default session for Keras model, model_cen, pix_mean, pix_mean_cen = build_L2_net(net_name) self.flagCS = flagCS self.model = model self.model_cen = model_cen self.pix_mean = pix_mean self.pix_mean_cen = pix_mean_cen
def __init__( self, num_features=2000, num_levels=5, # The number of downsample levels in the pyramid. scale_factor=2, # The scale factor to extract patches before descriptor. scale_factor_levels=np.sqrt( 2), # The scale factor between the pyramid levels. do_cuda=True, do_tf_logging=False): print('Using KeyNetDescFeature2D') self.lock = RLock() self.model_base_path = config.cfg.root_folder + '/thirdparty/keynet/' set_tf_logging(do_tf_logging) self.do_cuda = do_cuda & torch.cuda.is_available() print('cuda:', self.do_cuda) device = torch.device("cuda:0" if self.do_cuda else "cpu") self.session = None self.keypoint_size = 8 # just a representative size for visualization and in order to convert extracted points to cv2.KeyPoint self.pts = [] self.kps = [] self.des = [] self.scales = [] self.scores = [] self.frame = None keynet_config = build_keynet_config(self.model_base_path) self.keynet_config = keynet_config keynet_config.num_points = num_features keynet_config.pyramid_levels = num_levels keynet_config.scale_factor = scale_factor keynet_config.scale_factor_levels = scale_factor_levels print_options(self.keynet_config, 'KEYNET CONFIG') print('==> Loading pre-trained network.') self.load_model() print('==> Successfully loaded pre-trained network.')
def __init__(self, do_tf_logging=False): print('Using GeodescFeature2D') # mag_factor is how many times the original keypoint scale # is enlarged to generate a patch from a keypoint self.mag_factor = 3 # inference batch size self.batch_size = 512 self.process_all = True # process all the patches at once self.model_base_path = config.cfg.root_folder + '/thirdparty/geodesc/' self.model_path = self.model_base_path + 'model/geodesc.pb' set_tf_logging(do_tf_logging) print('==> Loading pre-trained network.') # create deep feature extractor. self.graph = load_frozen_model(self.model_path, print_nodes=False) #sess = tf.Session(graph=graph) print('==> Successfully loaded pre-trained network.')