def main(unused_argv):
tf.logging.set_verbosity(tf.logging.INFO)
start = time.time()
# Read features.
locations_1, _, descriptors_1, _, _ = feature_io.ReadFromFile(
cmd_args.features_1_path)
num_features_1 = locations_1.shape[0]
tf.logging.info("Loaded image 1's %d features" % num_features_1)
locations_2, _, descriptors_2, _, _ = feature_io.ReadFromFile(
cmd_args.features_2_path)
num_features_2 = locations_2.shape[0]
tf.logging.info("Loaded image 2's %d features" % num_features_2)
# Find nearest-neighbor matches using a KD tree.
d1_tree = spatial.cKDTree(descriptors_1)
_, indices = d1_tree.query(
descriptors_2, distance_upper_bound=_DISTANCE_THRESHOLD)
print('>> feature match elapsed time: {}'.format(htime(time.time() - start)))
# Select feature locations for putative matches.
locations_2_to_use = np.array([
locations_2[i,]
for i in range(num_features_2)
if indices[i] != num_features_1
])
locations_1_to_use = np.array([
locations_1[indices[i],]
for i in range(num_features_2)
if indices[i] != num_features_1
])
# Perform geometric verification using RANSAC.
_, inliers = measure.ransac((locations_1_to_use, locations_2_to_use),
transform.AffineTransform,
min_samples=3,
residual_threshold=20,
max_trials=1000)
tf.logging.info('Found %d inliers' % sum(inliers))
# Visualize correspondences, and save to file.
_, ax = plt.subplots()
img_1 = mpimg.imread(cmd_args.image_1_path)
img_2 = mpimg.imread(cmd_args.image_2_path)
inlier_idxs = np.nonzero(inliers)[0]
feature.plot_matches(
ax,
img_1,
img_2,
locations_1_to_use,
locations_2_to_use,
np.column_stack((inlier_idxs, inlier_idxs)),
matches_color='b')
ax.axis('off')
ax.set_title('DELF correspondences')
plt.savefig(cmd_args.output_image)
def checklandmark(landmark_features):
feats =[]
for root, dirs, files in os.walk(landmark_features): # loop through startfolders
for f in files:
feats.append(f)
i = iter(feats)
labeldelf = mainpath + 'data/lk_features/' + i.next()
print (labeldelf)
testdelf = mainpath + 'data/lk_features/' + i.next()
print (testdelf)
locations_1, _, descriptors_1, _, _ = feature_io.ReadFromFile(labeldelf)
num_features_1 = locations_1.shape[0]
#print("Loaded trainimage number of features:",num_features_1)
locations_2, _, descriptors_2, _, _ = feature_io.ReadFromFile(testdelf)
num_features_2 = locations_2.shape[0]
#print("Loaded testimage number of features",num_features_2)
# Find nearest-neighbor matches using a KD tree.
d1_tree = cKDTree(descriptors_1)
_, indices = d1_tree.query(
descriptors_2, distance_upper_bound=_DISTANCE_THRESHOLD)
# Select feature locations for putative matches.
locations_2_to_use = np.array([
locations_2[i,]
for i in range(num_features_2)
if indices[i] != num_features_1
])
locations_1_to_use = np.array([
locations_1[indices[i],]
for i in range(num_features_2)
if indices[i] != num_features_1
])
# Perform geometric verification using RANSAC.
try:
_, inliers = ransac(
(locations_1_to_use, locations_2_to_use),
AffineTransform,
min_samples=3,
residual_threshold=20,
max_trials=1000)
inlier_idxs = np.nonzero(inliers)[0]
#print(inlier_idxs)
#print(len(inlier_idxs))
return len(inlier_idxs)
except:
return 0
def main(unused_argv):
tf.logging.set_verbosity(tf.logging.INFO)
# Read features.
locations_1, _, descriptors_1, _, _ = feature_io.ReadFromFile(
cmd_args.features_1_path)
locations_2, _, descriptors_2, _, _ = feature_io.ReadFromFile(
cmd_args.features_2_path)
img_1 = mpimg.imread(cmd_args.image_1_path)
img_2 = mpimg.imread(cmd_args.image_2_path)
get_ransac_image_byte(img_1, locations_1, descriptors_1, img_2, locations_2, descriptors_2, cmd_args.output_image)
def main(*args):
args = parse_args()
# Read features.
locations_1, _, descriptors_1, attention_1, _ = feature_io.ReadFromFile(
args.features_1_path)
locations_2, _, descriptors_2, attention_2, _ = feature_io.ReadFromFile(
args.features_2_path)
num_features_1 = locations_1.shape[0]
num_features_2 = locations_2.shape[0]
d1_tree = cKDTree(descriptors_1)
distances, indices = d1_tree.query(
descriptors_2, distance_upper_bound=args.distance_threshold)
has_match = distances != np.inf
locations_1_to_use = locations_1[indices[has_match]]
locations_2_to_use = locations_2[has_match]
_, inliers = ransac((locations_1_to_use, locations_2_to_use),
AffineTransform,
min_samples=3,
residual_threshold=20,
max_trials=1000)
if inliers is None:
raise Exception('match_images.py: inliers is None')
else:
print('number of inliers -> %d' % len(inliers))
# --
# Plot
fig, ax = plt.subplots()
inlier_idxs = np.nonzero(inliers)[0]
plot_matches(ax,
mpimg.imread(args.image_1_path),
mpimg.imread(args.image_2_path),
locations_1_to_use,
locations_2_to_use,
np.column_stack((inlier_idxs, inlier_idxs)),
matches_color='b')
ax.axis('off')
ax.set_title('DELF correspondences')
plt.savefig(args.output_image)
def build_cls_KDtree(self, pred_cls):
db_delfs = self.get_db_paths(pred_cls, self.train_delf_root)
db_delfs = [
i[:-4] + ".delf"
for i in db_delfs[:min(_MAXIMUM_MATCH, len(db_delfs))]
]
results_dict = {
'loc': [],
'descriptor': [],
'boundaries': []
} # Stores the locations and their descriptors for each image
for delf_path in db_delfs:
if not os.path.exists(delf_path):
continue
locations_1, _, descriptors_1, _, _ = feature_io.ReadFromFile(
delf_path)
results_dict['loc'].append(locations_1)
results_dict['descriptor'].append(descriptors_1)
results_dict['boundaries'].append(locations_1.shape[0])
try:
locations_agg = np.concatenate(results_dict['loc'])
descriptors_agg = np.concatenate(results_dict['descriptor'])
accumulated_indexes_boundaries = np.cumsum(
results_dict['boundaries'])
except ValueError as e:
print(e)
return None
# build the KD tree
d_tree = cKDTree(descriptors_agg)
return d_tree, (locations_agg, descriptors_agg,
accumulated_indexes_boundaries)
def get_item_pos(self, idx, pos):
self.num_loaded += 1
if isinstance(idx, int):
file_name = self.list_file_names[idx]
elif isinstance(idx, str):
file_name = idx
else:
raise TypeError('idx must be int or str')
target_path = os.path.join(self.dir_images,
'{}.delf'.format(file_name))
try:
locations_1, scales_1, descriptors, _, _ = feature_io.ReadFromFile(
target_path)
num_features_1 = locations_1.shape[0]
except ValueError:
# not enough values to unpack (expected 5, got 4)
return torch.randn(41, 1000).float()
descriptors = np.swapaxes(descriptors, 0, 1)
zeros = np.zeros((41, 1000))
zeros[:40, :num_features_1] = descriptors
zeros[40, :num_features_1] = (scales_1 - 0.5) / 10.0
return torch.FloatTensor(zeros)
def match_landmark(self, query_feat_path, pred_cls):
result = self.build_cls_KDtree(pred_cls=pred_cls)
if result is None:
return
d_tree, (locations_agg, descriptors_agg,
accumulated_indexes_boundaries) = result
# query
if not os.path.exists(query_feat_path):
return
query_image_locations, _, query_image_descriptors, _, _ = feature_io.ReadFromFile(
query_feat_path)
# k-nearest neighbors
try:
distances, indices = d_tree.query(
query_image_descriptors,
distance_upper_bound=_DISTANCE_THRESHOLD,
k=K_NEAREST,
n_jobs=-1)
except ValueError as e:
print(e)
return
# Find the list of unique accumulated/aggregated indexes
unique_indices = np.sort(np.unique(indices))
if unique_indices[-1] == descriptors_agg.shape[0]:
unique_indices = unique_indices[:-1]
unique_image_indexes = np.unique([
np.argmax(np.array(accumulated_indexes_boundaries) > index)
for index in unique_indices
])
# Array to keep track of all candidates in database.
inliers_counts = []
for index in unique_image_indexes:
locations_2_use_query, locations_2_use_db = \
get_locations_2_use(query_image_locations, locations_agg,
index, indices, accumulated_indexes_boundaries)
# Perform geometric verification using RANSAC.
_, inliers = ransac(
(locations_2_use_db,
locations_2_use_query), # source and destination coordinates
AffineTransform,
min_samples=3,
residual_threshold=20,
max_trials=1000)
# If no inlier is found for a database candidate image, we continue on to the next one.
if inliers is None or len(inliers) == 0:
continue
# the number of inliers as the score for retrieved images.
inliers_counts.append({"index": index, "inliers": sum(inliers)})
inliers_list = []
for inl in inliers_counts:
inliers_list.append(inl['inliers'])
return inliers_list
def testWriteAndReadToFileEmptyFile(self):
filename = os.path.join(FLAGS.test_tmpdir, 'test.delf')
feature_io.WriteToFile(filename, np.array([]), np.array([]),
np.array([]), np.array([]), np.array([]))
data_read = feature_io.ReadFromFile(filename)
self.assertAllEqual(np.array([]), data_read[0])
self.assertAllEqual(np.array([]), data_read[1])
self.assertAllEqual(np.array([]), data_read[2])
self.assertAllEqual(np.array([]), data_read[3])
self.assertAllEqual(np.array([]), data_read[4])
def testWriteAndReadToFileEmptyFile(self):
tmpdir = tf.compat.v1.test.get_temp_dir()
filename = os.path.join(tmpdir, 'test.delf')
feature_io.WriteToFile(filename, np.array([]), np.array([]), np.array([]),
np.array([]), np.array([]))
data_read = feature_io.ReadFromFile(filename)
self.assertAllEqual(np.array([]), data_read[0])
self.assertAllEqual(np.array([]), data_read[1])
self.assertAllEqual(np.array([]), data_read[2])
self.assertAllEqual(np.array([]), data_read[3])
self.assertAllEqual(np.array([]), data_read[4])
def match_image(features_1_path, features_2_path):
# Read features.
locations_1, _, descriptors_1, _, _ = feature_io.ReadFromFile(
features_1_path)
num_features_1 = locations_1.shape[0]
print(f"Loaded image 1's {num_features_1} features")
locations_2, _, descriptors_2, _, _ = feature_io.ReadFromFile(
features_2_path)
num_features_2 = locations_2.shape[0]
print(f"Loaded image 2's {num_features_2} features")
# Find nearest-neighbor matches using a KD tree.
d1_tree = spatial.cKDTree(descriptors_1)
_, indices = d1_tree.query(descriptors_2,
distance_upper_bound=_DISTANCE_THRESHOLD)
# Select feature locations for putative matches.
locations_2_to_use = np.array([
locations_2[i, ] for i in range(num_features_2)
if indices[i] != num_features_1
])
locations_1_to_use = np.array([
locations_1[indices[i], ] for i in range(num_features_2)
if indices[i] != num_features_1
])
# Perform geometric verification using RANSAC.
if max(len(locations_1_to_use), len(locations_2_to_use)) > 0:
_, inliers = measure.ransac((locations_1_to_use, locations_2_to_use),
transform.AffineTransform,
min_samples=3,
residual_threshold=20,
max_trials=1000)
print(f'Found {sum(inliers)} inliers')
return sum(inliers)
else:
print('Found 0 inliers')
return 0
def testWriteAndReadToFile(self):
locations, scales, descriptors, attention, orientations = create_data()
filename = os.path.join(FLAGS.test_tmpdir, 'test.delf')
feature_io.WriteToFile(filename, locations, scales, descriptors,
attention, orientations)
data_read = feature_io.ReadFromFile(filename)
self.assertAllEqual(locations, data_read[0])
self.assertAllEqual(scales, data_read[1])
self.assertAllEqual(descriptors, data_read[2])
self.assertAllEqual(attention, data_read[3])
self.assertAllEqual(orientations, data_read[4])
def get_num_inlier(locations_2, descriptors_2, path1):
num_features_2 = locations_2.shape[0]
try:
locations_1, _, descriptors_1, _, _ = feature_io.ReadFromFile(path1)
num_features_1 = locations_1.shape[0]
except:
# print('Warning: Failed to load index feature')
return -1
# Find nearest-neighbor matches using a KD tree.
d1_tree = cKDTree(descriptors_1)
_, indices = d1_tree.query(descriptors_2,
distance_upper_bound=_DISTANCE_THRESHOLD)
# Select feature locations for putative matches.
locations_2_to_use = np.array([
locations_2[i, ] for i in range(num_features_2)
if indices[i] != num_features_1
])
locations_1_to_use = np.array([
locations_1[indices[i], ] for i in range(num_features_2)
if indices[i] != num_features_1
])
if len(locations_1_to_use) == 0 or len(locations_2_to_use) == 0:
return 0
try:
with warnings.catch_warnings():
warnings.simplefilter("ignore")
# Perform geometric verification using RANSAC.
_, inliers = ransac((locations_1_to_use, locations_2_to_use),
AffineTransform,
min_samples=3,
residual_threshold=80,
max_trials=40)
except:
return 0
if inliers is None:
return 0
return sum(inliers)
def load_image(self, file_name):
target_path = os.path.join(self.dir_images, file_name)
try:
locations_1, scales_1, descriptors, _, _ = feature_io.ReadFromFile(target_path)
num_features_1 = locations_1.shape[0]
except:
return torch.randn(1, 40, 1000)
descriptors = np.swapaxes(descriptors, 0, 1)
zeros = np.zeros((1, 40, 1000))
zeros[:, :, :num_features_1] = descriptors
return torch.FloatTensor(zeros)
def get_list_inliers(path1, list_images):
try:
locations_t, _, descriptors_t, _, _ = feature_io.ReadFromFile(path1)
except:
# print('Warning: Failed to load test feature')
return range(len(list_images), 0, -1)
list_inliers = list()
for img in list_images:
path2 = os.path.join('../../input_large_delf/index', img + '.delf')
list_inliers.append(get_num_inlier(locations_t, descriptors_t, path2))
return list_inliers
def careful_search(self,image_path, k=10, multiple=4,DELFFile=None):
'''
精挑图片
:param image_path: 图片路径名
:param k: 返回多少张
:param multiple:候选者的倍数
:return: 最像的10张图片,不含后缀;以及相似度的平均分数
'''
similar_list = self.filter_search(image_path,int(k*multiple))
if DELFFile:
candidate_feature_path = DELFFile
# Read features.
try:
locations_out, _, descriptors_out, _, _ = feature_io.ReadFromFile(candidate_feature_path)
except:
return similar_list[0:10],0
else:
locations_out, descriptors_out, feature_scales_out, attention_out = self.attention_model.get_single_attention(image_path)
similar_list_new = careful_select(locations_out, descriptors_out, similar_list, k)
average_similarity = self.count_average_similarity(similar_list_new)
# if similar_list_new[9]['similarity'] > 20: #注意力网络需要比较图像有较多的相似度
# similar_list = similar_list_new
# similar_list = [s["image"] for s in similar_list]
# else:
# similar_list = similar_list[0:k]
similar_list_final = []
for s in similar_list_new:
if s['similarity'] > 20:
similar_list_final.append(s['image'])
if len(similar_list_final) == 10:
break
for s in similar_list:
if len(similar_list_final) >= 10:
break
if s not in similar_list_final:
similar_list_final.append(s)
print(similar_list_final)
return similar_list_final,average_similarity
def main(argv):
if len(argv) > 1:
raise RuntimeError('Too many command-line arguments.')
# Process output directory.
if tf.io.gfile.exists(cmd_args.output_cluster_dir):
raise RuntimeError(
'output_cluster_dir = %s already exists. This may indicate that a '
'previous run already wrote checkpoints in this directory, which would '
'lead to incorrect training. Please re-run this script by specifying an'
' inexisting directory.' % cmd_args.output_cluster_dir)
else:
tf.io.gfile.makedirs(cmd_args.output_cluster_dir)
# Read list of index images from dataset file.
print('Reading list of index images from dataset file...')
_, index_list, _ = dataset.ReadDatasetFile(cmd_args.dataset_file_path)
num_images = len(index_list)
print('done! Found %d images' % num_images)
# Loop over list of index images and collect DELF features.
features_for_clustering = []
start = time.clock()
print('Starting to collect features from index images...')
for i in range(num_images):
if i > 0 and i % _STATUS_CHECK_ITERATIONS == 0:
elapsed = (time.clock() - start)
print('Processing index image %d out of %d, last %d '
'images took %f seconds' %
(i, num_images, _STATUS_CHECK_ITERATIONS, elapsed))
start = time.clock()
features_filename = index_list[i] + _DELF_EXTENSION
features_fullpath = os.path.join(cmd_args.features_dir,
features_filename)
_, _, features, _, _ = feature_io.ReadFromFile(features_fullpath)
if features.size != 0:
assert features.shape[1] == _DELF_DIM
for feature in features:
features_for_clustering.append(feature)
features_for_clustering = np.array(features_for_clustering,
dtype=np.float32)
print('All features were loaded! There are %d features, each with %d '
'dimensions' %
(features_for_clustering.shape[0], features_for_clustering.shape[1]))
# Run K-means clustering.
def _get_input_fn():
"""Helper function to create input function and hook for training.
Returns:
input_fn: Input function for k-means Estimator training.
init_hook: Hook used to load data during training.
"""
init_hook = _IteratorInitHook()
def _input_fn():
"""Produces tf.data.Dataset object for k-means training.
Returns:
Tensor with the data for training.
"""
features_placeholder = tf.compat.v1.placeholder(
tf.float32, features_for_clustering.shape)
delf_dataset = tf.data.Dataset.from_tensor_slices(
(features_placeholder))
delf_dataset = delf_dataset.shuffle(1000).batch(
features_for_clustering.shape[0])
iterator = tf.compat.v1.data.make_initializable_iterator(
delf_dataset)
def _initializer_fn(sess):
"""Initialize dataset iterator, feed in the data."""
sess.run(
iterator.initializer,
feed_dict={features_placeholder: features_for_clustering})
init_hook.iterator_initializer_fn = _initializer_fn
return iterator.get_next()
return _input_fn, init_hook
input_fn, init_hook = _get_input_fn()
kmeans = tf.compat.v1.estimator.experimental.KMeans(
num_clusters=cmd_args.num_clusters,
model_dir=cmd_args.output_cluster_dir,
use_mini_batch=False,
)
print('Starting K-means clustering...')
start = time.clock()
for i in range(cmd_args.num_iterations):
kmeans.train(input_fn, hooks=[init_hook])
average_sum_squared_error = kmeans.evaluate(
input_fn, hooks=[init_hook
])['score'] / features_for_clustering.shape[0]
elapsed = (time.clock() - start)
print('K-means iteration %d (out of %d) took %f seconds, '
'average-sum-of-squares: %f' %
(i, cmd_args.num_iterations, elapsed, average_sum_squared_error))
start = time.clock()
print('K-means clustering finished!')
datasets = ['Oxford5k', 'Paris6k', 'Holidays', 'Landmarks']
for dataset in datasets:
query_dir = './result/' + dataset + '/query'
query_list = natsort.natsorted(os.listdir(query_dir))
result_dir = './delf/' + dataset + '/query'
for q in query_list:
# a = feature_io.ReadFromFile(query_dir + '/' + q)
# print(len(a))
# print(a[0].shape)
# print(a[1].shape)
# print(a[2].shape)
# print(a[3].shape)
query_l, _, query_d, _, _ = feature_io.ReadFromFile(query_dir + '/' +
q)
mat_name = result_dir + '/' + q
sio.savemat(mat_name, {'delf': query_d})
print(mat_name)
# break
base_dir = './result/' + dataset + '/base'
base_list = natsort.natsorted(os.listdir(base_dir))
result_dir = './delf/' + dataset + '/base'
for b in base_list:
# a = feature_io.ReadFromFile(base_dir + '/' + b)
# print(len(a))
# print(a[0].shape)
# print(a[1].shape)
# print(a[2].shape)
def ExtractAggregatedRepresentationsToFiles(image_names, features_dir,
aggregation_config_path,
mapping_path,
output_aggregation_dir):
"""Extracts aggregated feature representations, saving them to files.
It checks if the aggregated representation for an image already exists,
and skips computation for those.
Args:
image_names: List of image names. These are used to compose input file names
for the feature files, and the output file names for aggregated
representations.
features_dir: Directory where DELF features are located.
aggregation_config_path: Path to AggregationConfig proto text file with
configuration to be used for extraction.
mapping_path: Optional CSV file which maps each .delf file name to the index
image ID and detected box ID. If regional aggregation is performed, this
should be set. Otherwise, this is ignored.
output_aggregation_dir: Directory where aggregation output will be written
to.
Raises:
ValueError: If AggregationConfig is malformed, or `mapping_path` is
missing.
"""
num_images = len(image_names)
# Parse AggregationConfig proto, and select output extension.
config = aggregation_config_pb2.AggregationConfig()
with tf.io.gfile.GFile(aggregation_config_path, 'r') as f:
text_format.Merge(f.read(), config)
output_extension = '.'
if config.use_regional_aggregation:
output_extension += 'r'
if config.aggregation_type == _VLAD:
output_extension += _VLAD_EXTENSION_SUFFIX
elif config.aggregation_type == _ASMK:
output_extension += _ASMK_EXTENSION_SUFFIX
elif config.aggregation_type == _ASMK_STAR:
output_extension += _ASMK_STAR_EXTENSION_SUFFIX
else:
raise ValueError('Invalid aggregation type: %d' %
config.aggregation_type)
# Read index mapping path, if provided.
if mapping_path:
images_to_box_feature_files = _ReadMappingBasenameToBoxNames(
mapping_path, image_names)
# Create output directory if necessary.
if not tf.io.gfile.exists(output_aggregation_dir):
tf.io.gfile.makedirs(output_aggregation_dir)
with tf.compat.v1.Session() as sess:
extractor = feature_aggregation_extractor.ExtractAggregatedRepresentation(
sess, config)
start = time.clock()
for i in range(num_images):
if i == 0:
print('Starting to extract aggregation from images...')
elif i % _STATUS_CHECK_ITERATIONS == 0:
elapsed = (time.clock() - start)
print('Processing image %d out of %d, last %d '
'images took %f seconds' %
(i, num_images, _STATUS_CHECK_ITERATIONS, elapsed))
start = time.clock()
image_name = image_names[i]
# Compose output file name, skip extraction for this image if it already
# exists.
output_aggregation_filename = os.path.join(
output_aggregation_dir, image_name + output_extension)
if tf.io.gfile.exists(output_aggregation_filename):
print('Skipping %s' % image_name)
continue
# Load DELF features.
if config.use_regional_aggregation:
if not mapping_path:
raise ValueError(
'Requested regional aggregation, but mapping_path was not '
'provided')
descriptors_list = []
num_features_per_box = []
for box_feature_file in images_to_box_feature_files[
image_name]:
delf_filename = os.path.join(
features_dir, box_feature_file + _DELF_EXTENSION)
_, _, box_descriptors, _, _ = feature_io.ReadFromFile(
delf_filename)
# If `box_descriptors` is empty, reshape it such that it can be
# concatenated with other descriptors.
if not box_descriptors.shape[0]:
box_descriptors = np.reshape(
box_descriptors,
[0, config.feature_dimensionality])
descriptors_list.append(box_descriptors)
num_features_per_box.append(box_descriptors.shape[0])
descriptors = np.concatenate(descriptors_list)
else:
input_delf_filename = os.path.join(
features_dir, image_name + _DELF_EXTENSION)
_, _, descriptors, _, _ = feature_io.ReadFromFile(
input_delf_filename)
# If `descriptors` is empty, reshape it to avoid extraction failure.
if not descriptors.shape[0]:
descriptors = np.reshape(
descriptors, [0, config.feature_dimensionality])
num_features_per_box = None
# Extract and save aggregation. If using VLAD, only
# `aggregated_descriptors` needs to be saved.
(aggregated_descriptors,
feature_visual_words) = extractor.Extract(descriptors,
num_features_per_box)
if config.aggregation_type == _VLAD:
datum_io.WriteToFile(aggregated_descriptors,
output_aggregation_filename)
else:
datum_io.WritePairToFile(aggregated_descriptors,
feature_visual_words.astype('uint32'),
output_aggregation_filename)
def count_i(land_name):
data = land_name.split('/')[-1].split('.')[0]
#file1 = open('txt_file_m18_m/'+data+'.txt','w')
maxNum = 0
maxName = ''
for name in glob(feature_dir+'/*'):
#print (name)
name2 = name.split('/')
number = name2[-1].split('.')[0]
# Read features.
locations_1, _, descriptors_1, _, _ = feature_io.ReadFromFile(land_name)
#cmd_args.features_1_path)
num_features_1 = locations_1.shape[0]
#tf.logging.info("Loaded image 1's %d features" % num_features_1)
locations_2, _, descriptors_2, _, _ = feature_io.ReadFromFile(name)
#cmd_args.features_2_path)
num_features_2 = locations_2.shape[0]
#tf.logging.info("Loaded image 2's %d features" % num_features_2)
# Find nearest-neighbor matches using a KD tree.
d1_tree = cKDTree(descriptors_1)
_, indices = d1_tree.query(
descriptors_2, distance_upper_bound=_DISTANCE_THRESHOLD)
# Select feature locations for putative matches.
locations_2_to_use = np.array([
locations_2[i,]
for i in range(num_features_2)
if indices[i] != num_features_1
])
locations_1_to_use = np.array([
locations_1[indices[i],]
for i in range(num_features_2)
if indices[i] != num_features_1
])
# Perform geometric verification using RANSAC.
try:
_, inliers = ransac(
(locations_1_to_use, locations_2_to_use),
AffineTransform,
min_samples=3,
residual_threshold=20,
max_trials=1000)
tf.logging.info('Found %d inliers' % sum(inliers))
#print(sum(inliers))
#print(maxNum)
score = int(sum(inliers))
#file1.write(name+'\t'+str(sum(inliers))+'\n')
num = name.split('/')[-1].split('.')[0]
if score>35 and score>maxNum:
maxNum = score
maxName = num2name[number]
#print (maxName)
#print (maxNum)
#break
except:
#print('fail')
a=0
#print (maxName)
#result_dic[data] = maxName
return maxName
def main(unused_argv):
tf.logging.set_verbosity(tf.logging.INFO)
query_image_paths = _ReadImageList(cmd_args.query_list_images_path)
train_image_paths = _ReadImageList(cmd_args.train_list_images_path)
output_fh = open(cmd_args.output_file, 'w')
for query in query_image_paths:
# Read features.
locations_1, _, descriptors_1, _, _ = feature_io.ReadFromFile(query)
num_features_1 = locations_1.shape[0]
#tf.logging.info("Loaded image 1's %d features" % num_features_1)
best_f = ""
best_inliers = 0
for train in train_image_paths:
locations_2, _, descriptors_2, _, _ = feature_io.ReadFromFile(
train)
num_features_2 = locations_2.shape[0]
#tf.logging.info("Loaded image 2's %d features" % num_features_2)
# Find nearest-neighbor matches using a KD tree.
d1_tree = cKDTree(descriptors_1)
_, indices = d1_tree.query(
descriptors_2, distance_upper_bound=_DISTANCE_THRESHOLD)
# Select feature locations for putative matches.
locations_2_to_use = np.array([
locations_2[i, ] for i in range(num_features_2)
if indices[i] != num_features_1
])
locations_1_to_use = np.array([
locations_1[indices[i], ] for i in range(num_features_2)
if indices[i] != num_features_1
])
# Perform geometric verification using RANSAC.
try:
_, inliers = ransac((locations_1_to_use, locations_2_to_use),
AffineTransform,
min_samples=3,
residual_threshold=20,
max_trials=100)
sum_inliers = sum(inliers)
if (sum_inliers > best_inliers):
best_inliers = sum_inliers
best_label = train
#print(best_label, train, query)
except:
continue
#print(best_label, train, query)
#tf.logging.info('Found %d inliers' % sum(inliers))
if (best_inliers > 20):
output_fh.write(query.split('data/query_features/')[1]\
+ ","+best_label.split('data/train_features/')[1]+"\n")
else:
output_fh.write(query + "\n")
output_fh.close()
def _RerankByGeometricVerification(input_ranks, initial_scores, query_name,
index_names, query_features_dir,
index_features_dir, junk_ids):
"""Re-ranks retrieval results using geometric verification.
Args:
input_ranks: 1D NumPy array with indices of top-ranked index images, sorted
from the most to the least similar.
initial_scores: 1D NumPy array with initial similarity scores between query
and index images. Entry i corresponds to score for image i.
query_name: Name for query image (string).
index_names: List of names for index images (strings).
query_features_dir: Directory where query local feature file is located
(string).
index_features_dir: Directory where index local feature files are located
(string).
junk_ids: Set with indices of junk images which should not be considered
during re-ranking.
Returns:
output_ranks: 1D NumPy array with index image indices, sorted from the most
to the least similar according to the geometric verification and initial
scores.
Raises:
ValueError: If `input_ranks`, `initial_scores` and `index_names` do not have
the same number of entries.
"""
num_index_images = len(index_names)
if len(input_ranks) != num_index_images:
raise ValueError(
'input_ranks and index_names have different number of '
'elements: %d vs %d' % (len(input_ranks), len(index_names)))
if len(initial_scores) != num_index_images:
raise ValueError(
'initial_scores and index_names have different number of '
'elements: %d vs %d' % (len(initial_scores), len(index_names)))
# Filter out junk images from list that will be re-ranked.
input_ranks_for_gv = []
for ind in input_ranks:
if ind not in junk_ids:
input_ranks_for_gv.append(ind)
num_to_rerank = min(_NUM_TO_RERANK, len(input_ranks_for_gv))
# Load query image features.
query_features_path = os.path.join(query_features_dir,
query_name + _DELF_EXTENSION)
query_locations, _, query_descriptors, _, _ = feature_io.ReadFromFile(
query_features_path)
# Initialize list containing number of inliers and initial similarity scores.
inliers_and_initial_scores = []
for i in range(num_index_images):
inliers_and_initial_scores.append([0, initial_scores[i]])
# Loop over top-ranked images and get results.
print('Starting to re-rank')
for i in range(num_to_rerank):
if i > 0 and i % _STATUS_CHECK_GV_ITERATIONS == 0:
print('Re-ranking: i = %d out of %d' % (i, num_to_rerank))
index_image_id = input_ranks_for_gv[i]
# Load index image features.
index_image_features_path = os.path.join(
index_features_dir, index_names[index_image_id] + _DELF_EXTENSION)
(index_image_locations, _, index_image_descriptors, _,
_) = feature_io.ReadFromFile(index_image_features_path)
inliers_and_initial_scores[index_image_id][0] = _MatchFeatures(
query_locations, query_descriptors, index_image_locations,
index_image_descriptors)
# Sort based on (inliers_score, initial_score).
def _InliersInitialScoresSorting(k):
"""Helper function to sort list based on two entries.
Args:
k: Index into `inliers_and_initial_scores`.
Returns:
Tuple containing inlier score and initial score.
"""
return (inliers_and_initial_scores[k][0],
inliers_and_initial_scores[k][1])
output_ranks = sorted(range(num_index_images),
key=_InliersInitialScoresSorting,
reverse=True)
return output_ranks
_DISTANCE_THRESHOLD = 0.8
_INLIER_THRESHOLD = 30
tf.logging.set_verbosity(tf.logging.INFO)
features_output_dir = '/media/iap205/Data4T/Export_temp/GLD-v2_DELF_features'
for i in range(ranks.shape[1]):
# Read features.
features_1_path = os.path.join(features_output_dir,
df_train['id'][query_idx[i]] + '.delf')
image_1_path = os.path.join(
train_img_path, '/'.join(list(df_train['id'][query_idx[i]])[:3]),
df_train['id'][query_idx[i]] + '.jpg')
locations_1, _, descriptors_1, _, _ = feature_io.ReadFromFile(
features_1_path)
num_features_1 = locations_1.shape[0]
# tf.logging.info("Loaded qurey image {}'s %d features".format(i) % num_features_1)
d1_tree = spatial.cKDTree(descriptors_1)
img_1 = mpimg.imread(image_1_path)
for j in range(ranks.shape[0]):
features_2_path = os.path.join(features_output_dir,
knn_imgs[j] + '.delf')
image_2_path = os.path.join(train_img_path,
'/'.join(list(knn_imgs[j])[:3]),
knn_imgs[j] + '.jpg')
locations_2, _, descriptors_2, _, _ = feature_io.ReadFromFile(
features_2_path)
num_features_2 = locations_2.shape[0]
# tf.logging.info("Loaded image 2's %d features" % num_features_2)
def main(unused_argv):
# Read features.
locations_1, _, descriptors_1, _, _ = feature_io.ReadFromFile(
cmd_args.features_1_path)
num_features_1 = locations_1.shape[0]
print(f"Loaded image 1's {num_features_1} features")
locations_2, _, descriptors_2, _, _ = feature_io.ReadFromFile(
cmd_args.features_2_path)
num_features_2 = locations_2.shape[0]
print(f"Loaded image 2's {num_features_2} features")
# Find nearest-neighbor matches using a KD tree.
d1_tree = spatial.cKDTree(descriptors_1)
_, indices = d1_tree.query(descriptors_2,
distance_upper_bound=_DISTANCE_THRESHOLD)
# Select feature locations for putative matches.
locations_2_to_use = np.array([
locations_2[i, ] for i in range(num_features_2)
if indices[i] != num_features_1
])
locations_1_to_use = np.array([
locations_1[indices[i], ] for i in range(num_features_2)
if indices[i] != num_features_1
])
# Perform geometric verification using RANSAC.
_, inliers = measure.ransac((locations_1_to_use, locations_2_to_use),
transform.AffineTransform,
min_samples=3,
residual_threshold=20,
max_trials=1000)
print(f'Found {sum(inliers)} inliers')
# Visualize correspondences, and save to file.
_, ax = plt.subplots()
img1_ext = os.path.splitext(cmd_args.image_1_path)[1]
if img1_ext == '.exr':
img_1 = (utils.loadEXRImage(cmd_args.image_1_path))
img_1_min = np.min(img_1)
img_1 = ((img_1 - img_1_min) / (np.max(img_1) - img_1_min))
else:
img_1 = mpimg.imread(cmd_args.image_1_path)
img2_ext = os.path.splitext(cmd_args.image_2_path)[1]
if img2_ext == '.exr':
img_2 = (utils.loadEXRImage(cmd_args.image_2_path))
print("max", np.max(img_2))
img_2_min = np.min(img_2)
img_2 = ((img_2 - img_2_min) / (np.max(img_2) - img_2_min))
else:
img_2 = mpimg.imread(cmd_args.image_2_path)
inlier_idxs = np.nonzero(inliers)[0]
feature.plot_matches(ax,
img_1[:, :, :3],
img_2[:, :, :3],
locations_1_to_use,
locations_2_to_use,
np.column_stack((inlier_idxs, inlier_idxs)),
matches_color='b',
only_matches=False)
ax.axis('off')
ax.set_title('DELF correspondences')
plt.savefig(cmd_args.output_image, dpi=600)
# Perform geometric verification using RANSAC.
_, inliers = ransac((locations_2_to_use, locations_1_to_use),
AffineTransform,
min_samples=3,
residual_threshold=20,
max_trials=1000)
if type(inliers) == type(None):
return 3
#tf.logging.info('Found %d inliers' % sum(inliers))
return sum(inliers)
if __name__ == '__main__':
features_1_path = "test_features/1.delf"
features_2_path = "test_features/2.delf"
# Read features.
locations_1, features_out_1, descriptors_1, attention_out_1, _ = feature_io.ReadFromFile(
features_1_path)
num_features_1 = locations_1.shape[0]
tf.logging.info("Loaded image 1's %d features" % num_features_1)
locations_2, features_out_2, descriptors_2, attention_out_2, _ = feature_io.ReadFromFile(
features_2_path)
num_features_2 = locations_2.shape[0]
tf.logging.info("Loaded image 2's %d features" % num_features_2)
# evaluate_similarity(locations_1, descriptors_1, locations_2, descriptors_2)
print(locations_1.shape)
print(features_out_1)
print(descriptors_1.shape)
print(attention_out_1)
if n%1000 == 0:
print(n/len(l)*100)
n += 1
# Here I extract DELF features from the images
l = os.listdir(TRAIN_IMAGE_DIR)
for i in range(0, len(l),RESET):
with open('list_images.txt', 'w') as f:
[f.write(os.path.join(os.getcwd(), TRAIN_IMAGE_DIR, file)+'\n') for file in l[i:i+RESET]]
p = mp.Process(target=fetex, args=(TRAIN_FET_DIR,))
p.start()
p.join()
for file in l[i:i+RESET]:
_, _, desc, _, _ = feature_io.ReadFromFile(TRAIN_FET_DIR+'/'+file.split('.')[0]+'.delf')
np.save(TRAIN_FET_DIR+'/'+file.split('.')[0]+'.npy', desc)
# Next, loaded the features of all images into a spark rdd. This takes a long time
findspark.init()
conf = SparkConf().setAppName("App")
conf = (conf.setMaster('local[*]')
.set('spark.executor.memory', '1G')
.set('spark.driver.memory', '12G'))
sc = SparkContext(conf=conf)
spark = SparkSession \
.builder \
.appName("Python Spark SQL basic example") \
def DelfReadSingleImage(self, features_path=None):
locations, _, descriptors, _, _ = feature_io.ReadFromFile(
features_path)
name = features_path.split('/')[-1]
name = name.split('.')[0]
return (name, locations, descriptors)
def RerankByGeometricVerification(input_ranks,
initial_scores,
query_name,
index_names,
query_features_dir,
index_features_dir,
junk_ids,
local_feature_type='delf',
local_feature_extension=_DELF_EXTENSION,
ransac_seed=None,
descriptor_matching_threshold=0.9,
ransac_residual_threshold=10.0,
use_ratio_test=False):
"""Re-ranks retrieval results using geometric verification.
Args:
input_ranks: 1D NumPy array with indices of top-ranked index images, sorted
from the most to the least similar.
initial_scores: 1D NumPy array with initial similarity scores between query
and index images. Entry i corresponds to score for image i.
query_name: Name for query image (string).
index_names: List of names for index images (strings).
query_features_dir: Directory where query local feature file is located
(string).
index_features_dir: Directory where index local feature files are located
(string).
junk_ids: Set with indices of junk images which should not be considered
during re-ranking.
local_feature_extension: String, extension to use for loading local feature
files.
ransac_seed: Seed used by RANSAC. If None (default), no seed is provided.
descriptor_matching_threshold: Threshold used for local descriptor matching.
ransac_residual_threshold: Residual error threshold for considering matches
as inliers, used in RANSAC algorithm.
use_ratio_test: If True, descriptor matching is performed via ratio test,
instead of distance-based threshold.
Returns:
output_ranks: 1D NumPy array with index image indices, sorted from the most
to the least similar according to the geometric verification and initial
scores.
Raises:
ValueError: If `input_ranks`, `initial_scores` and `index_names` do not have
the same number of entries.
"""
num_index_images = len(index_names)
if len(input_ranks) != num_index_images:
raise ValueError(
'input_ranks and index_names have different number of '
'elements: %d vs %d' % (len(input_ranks), len(index_names)))
if len(initial_scores) != num_index_images:
raise ValueError(
'initial_scores and index_names have different number of '
'elements: %d vs %d' % (len(initial_scores), len(index_names)))
# Filter out junk images from list that will be re-ranked.
input_ranks_for_gv = []
for ind in input_ranks:
if ind not in junk_ids:
input_ranks_for_gv.append(ind)
num_to_rerank = min(_NUM_TO_RERANK, len(input_ranks_for_gv))
print("Rerank ", num_to_rerank, " instances")
# Load query image features.
query_features_path = os.path.join(query_features_dir,
query_name + local_feature_extension)
if local_feature_type == 'delf':
query_locations, _, query_descriptors, _, _ = feature_io.ReadFromFile(
query_features_path)
print("Shape of query_locations and query_descriptors",
query_locations.shape, query_descriptors.shape)
else:
data = np.load(query_features_path)
query_locations = data['keypoint'].reshape(data['keypoint'].shape[0],
2)
query_descriptors = data['feature']
print("Shape of query_locations and query_descriptors",
query_locations.shape, query_descriptors.shape)
# Initialize list containing number of inliers and initial similarity scores.
inliers_and_initial_scores = []
for i in range(num_index_images):
inliers_and_initial_scores.append([0, initial_scores[i]])
# Loop over top-ranked images and get results.
print('Starting to re-rank')
for i in range(num_to_rerank):
if i > 0 and i % _STATUS_CHECK_GV_ITERATIONS == 0:
print('Re-ranking: i = %d out of %d' % (i, num_to_rerank))
index_image_id = input_ranks_for_gv[i]
# Load index image features.
index_image_features_path = os.path.join(
index_features_dir,
index_names[index_image_id] + local_feature_extension)
# (index_image_locations, _, index_image_descriptors, _,
# _) = feature_io.ReadFromFile(index_image_features_path)
data = np.load(query_features_path)
index_image_locations = data['keypoint'].reshape(
data['keypoint'].shape[0], 2)
index_image_descriptors = data['feature']
inliers_and_initial_scores[index_image_id][0], _ = MatchFeatures(
query_locations,
query_descriptors,
index_image_locations,
index_image_descriptors,
ransac_seed=ransac_seed,
descriptor_matching_threshold=descriptor_matching_threshold,
ransac_residual_threshold=ransac_residual_threshold,
use_ratio_test=use_ratio_test)
# Sort based on (inliers_score, initial_score).
def _InliersInitialScoresSorting(k):
"""Helper function to sort list based on two entries.
Args:
k: Index into `inliers_and_initial_scores`.
Returns:
Tuple containing inlier score and initial score.
"""
return (inliers_and_initial_scores[k][0],
inliers_and_initial_scores[k][1])
output_ranks = sorted(range(num_index_images),
key=_InliersInitialScoresSorting,
reverse=True)
return output_ranks
def main(argv):
if len(argv) > 1:
raise RuntimeError('Too many command-line arguments.')
# Read list of images from dataset file.
print('Reading list of images from dataset file...')
query_list, index_list, _ = dataset.ReadDatasetFile(
cmd_args.dataset_file_path)
if cmd_args.use_query_images:
image_list = query_list
else:
image_list = index_list
num_images = len(image_list)
print('done! Found %d images' % num_images)
# Parse AggregationConfig proto, and select output extension.
config = aggregation_config_pb2.AggregationConfig()
with tf.gfile.GFile(cmd_args.aggregation_config_path, 'r') as f:
text_format.Merge(f.read(), config)
output_extension = '.'
if config.use_regional_aggregation:
output_extension += 'r'
if config.aggregation_type == _VLAD:
output_extension += _VLAD_EXTENSION_SUFFIX
elif config.aggregation_type == _ASMK:
output_extension += _ASMK_EXTENSION_SUFFIX
elif config.aggregation_type == _ASMK_STAR:
output_extension += _ASMK_STAR_EXTENSION_SUFFIX
else:
raise ValueError('Invalid aggregation type: %d' %
config.aggregation_type)
# Read index mapping path, if provided.
if cmd_args.index_mapping_path:
images_to_box_feature_files = _ReadMappingBasenameToBoxNames(
cmd_args.index_mapping_path, image_list)
# Create output directory if necessary.
if not os.path.exists(cmd_args.output_aggregation_dir):
os.makedirs(cmd_args.output_aggregation_dir)
with tf.Session() as sess:
extractor = feature_aggregation_extractor.ExtractAggregatedRepresentation(
sess, config)
start = time.clock()
for i in range(num_images):
if i == 0:
print('Starting to extract aggregation from images...')
elif i % _STATUS_CHECK_ITERATIONS == 0:
elapsed = (time.clock() - start)
print('Processing image %d out of %d, last %d '
'images took %f seconds' %
(i, num_images, _STATUS_CHECK_ITERATIONS, elapsed))
start = time.clock()
image_name = image_list[i]
# Compose output file name, skip extraction for this image if it already
# exists.
output_aggregation_filename = os.path.join(
cmd_args.output_aggregation_dir, image_name + output_extension)
if tf.io.gfile.exists(output_aggregation_filename):
print('Skipping %s' % image_name)
continue
# Load DELF features.
if config.use_regional_aggregation:
if not cmd_args.index_mapping_path:
raise ValueError(
'Requested regional aggregation, but index_mapping_path was not '
'provided')
descriptors_list = []
num_features_per_box = []
for box_feature_file in images_to_box_feature_files[
image_name]:
delf_filename = os.path.join(
cmd_args.features_dir,
box_feature_file + _DELF_EXTENSION)
_, _, box_descriptors, _, _ = feature_io.ReadFromFile(
delf_filename)
# If `box_descriptors` is empty, reshape it such that it can be
# concatenated with other descriptors.
if not box_descriptors.shape[0]:
box_descriptors = np.reshape(
box_descriptors,
[0, config.feature_dimensionality])
descriptors_list.append(box_descriptors)
num_features_per_box.append(box_descriptors.shape[0])
descriptors = np.concatenate(descriptors_list)
else:
input_delf_filename = os.path.join(
cmd_args.features_dir, image_name + _DELF_EXTENSION)
_, _, descriptors, _, _ = feature_io.ReadFromFile(
input_delf_filename)
num_features_per_box = None
# Extract and save aggregation. If using VLAD, only
# `aggregated_descriptors` needs to be saved.
(aggregated_descriptors,
feature_visual_words) = extractor.Extract(descriptors,
num_features_per_box)
if config.aggregation_type == _VLAD:
datum_io.WriteToFile(aggregated_descriptors,
output_aggregation_filename)
else:
datum_io.WritePairToFile(aggregated_descriptors,
feature_visual_words.astype('uint32'),
output_aggregation_filename)
