def match(args):
"""Compute all matches for a single image"""
im1, candidates, i, n, ctx = args
logger.info('Matching {} - {} / {}'.format(im1, i + 1, n))
config = ctx.data.config
robust_matching_min_match = config['robust_matching_min_match']
preemptive_threshold = config['preemptive_threshold']
lowes_ratio = config['lowes_ratio']
preemptive_lowes_ratio = config['preemptive_lowes_ratio']
im1_matches = {}
for im2 in candidates:
# preemptive matching
if preemptive_threshold > 0:
t = time.time()
config['lowes_ratio'] = preemptive_lowes_ratio
matches_pre = matching.match_lowe_bf(ctx.f_pre[im1], ctx.f_pre[im2], config)
config['lowes_ratio'] = lowes_ratio
logger.debug("Preemptive matching {0}, time: {1}s".format(len(matches_pre), time.time() - t))
if len(matches_pre) < preemptive_threshold:
logger.debug("Discarding based of preemptive matches {0} < {1}".format(len(matches_pre), preemptive_threshold))
continue
# symmetric matching
t = time.time()
p1, f1, c1 = ctx.data.load_features(im1)
i1 = ctx.data.load_feature_index(im1, f1)
p2, f2, c2 = ctx.data.load_features(im2)
i2 = ctx.data.load_feature_index(im2, f2)
matches = matching.match_symmetric(f1, i1, f2, i2, config)
logger.debug('{} - {} has {} candidate matches'.format(im1, im2, len(matches)))
if len(matches) < robust_matching_min_match:
im1_matches[im2] = []
continue
# robust matching
t_robust_matching = time.time()
camera1 = ctx.cameras[ctx.exifs[im1]['camera']]
camera2 = ctx.cameras[ctx.exifs[im2]['camera']]
rmatches = matching.robust_match(p1, p2, camera1, camera2, matches, config)
if len(rmatches) < robust_matching_min_match:
im1_matches[im2] = []
continue
im1_matches[im2] = rmatches
logger.debug('Robust matching time : {0}s'.format( time.time() - t_robust_matching))
logger.debug("Full matching {0} / {1}, time: {2}s".format( len(rmatches), len(matches), time.time() - t))
ctx.data.save_matches(im1, im1_matches)
def match(args):
"""Compute all matches for a single image"""
log.setup()
im1, candidates, i, n, ctx = args
#cv2.imshow('123',im1)
print("....................1%s" % im1)
print("....................2%s" % candidates)
logger.info('Matching {} - {} / {}'.format(im1, i + 1, n))
config = ctx.data.config
robust_matching_min_match = config['robust_matching_min_match']
preemptive_threshold = config['preemptive_threshold']
lowes_ratio = config['lowes_ratio']
preemptive_lowes_ratio = config['preemptive_lowes_ratio']
im1_matches = {}
for im2 in candidates:
# preemptive matching
if preemptive_threshold > 0:
t = timer()
config['lowes_ratio'] = preemptive_lowes_ratio
matches_pre = matching.match_lowe_bf(ctx.f_pre[im1],
ctx.f_pre[im2], config)
config['lowes_ratio'] = lowes_ratio
logger.debug("Preemptive matching {0}, time: {1}s".format(
len(matches_pre),
timer() - t))
if len(matches_pre) < preemptive_threshold:
logger.debug(
"Discarding based of preemptive matches {0} < {1}".format(
len(matches_pre), preemptive_threshold))
continue
# symmetric matching
t = timer()
p1, f1, c1 = ctx.data.load_features(im1)
p2, f2, c2 = ctx.data.load_features(im2)
if config['matcher_type'] == 'FLANN':
print('.....................using FLANN step 1')
i1 = ctx.data.load_feature_index(im1, f1)
i2 = ctx.data.load_feature_index(im2, f2)
else:
i1 = None
i2 = None
matches = matching.match_symmetric(
f1, i1, f2, i2,
config) #, p1, p2, im1, im2)#add keypoints and images qli
# Apply ratio test
"""
matchesMask = [[0,0] for ii in range(len(matches))]
for ii,(m,n) in enumerate(matches):
if 0.55*n.distance<m.distance < 0.80*n.distance:
matchesMask[ii]=[1,0]
draw_params=dict(matchesMask=matchesMask)
"""
siftQ = cv2.xfeatures2d.SIFT_create()
print('loading image 1 ..................%s' % im1)
print('loading image 2 ..................%s' % im2)
img1 = cv2.imread(
'/home/qli/workspace/OpenSfM/data/MattGPS/images/%s' % im1)
img2 = cv2.imread(
'/home/qli/workspace/OpenSfM/data/MattGPS/images/%s' % im2)
kp1, des1 = siftQ.detectAndCompute(img1, None)
kp2, des2 = siftQ.detectAndCompute(img2, None)
# BFMatcher with default params
bf = cv2.BFMatcher()
matchesQ = bf.knnMatch(des1, des2, k=2)
matchesMask = [[0, 0] for i in range(len(matchesQ))]
for i, (m, n) in enumerate(matchesQ):
if 0.55 * n.distance < m.distance < 0.80 * n.distance:
matchesMask[i] = [1, 0]
# cv2.drawMatchesKnn expects list of lists as matches.
draw_params = dict(matchesMask=matchesMask)
img3 = None
img3 = cv2.drawMatchesKnn(img1,
kp1,
img2,
kp2,
matchesQ,
None,
flags=2,
**draw_params)
#namestr= '/home/qli/workspace/OpenSfM/data/MattGPS/images/'+str(im1)+str(im2)
#cv2.imwrite(namestr,img3)
#plt.figure(str(im1)+str(im2))
#plt.imshow(img3)
savefigname = "/home/qli/workspace/OpenSfM/data/MattGPS/GPS%s%s.jpg" % (
str(im1), str(im2))
#plt.savefig(savefigname)
cv2.imwrite(savefigname, img3)
#plt.show()
#plt.close()
#return
logger.debug('{} - {} has {} candidate matches'.format(
im1, im2, len(matches)))
if len(matches) < robust_matching_min_match:
im1_matches[im2] = []
continue
# robust matching
t_robust_matching = timer()
camera1 = ctx.cameras[ctx.exifs[im1]['camera']]
camera2 = ctx.cameras[ctx.exifs[im2]['camera']]
rmatches = matching.robust_match(p1, p2, camera1, camera2, matches,
config)
if len(rmatches) < robust_matching_min_match:
im1_matches[im2] = []
continue
im1_matches[im2] = rmatches
logger.debug('Robust matching time : {0}s'.format(timer() -
t_robust_matching))
logger.debug("Full matching {0} / {1}, time: {2}s".format(
len(rmatches), len(matches),
timer() - t))
ctx.data.save_matches(im1, im1_matches)
def match(args):
'''
Compute all matches for a single image
'''
im1, candidates, i, n, ctx = args
logger.info('Matching {} - {} / {}'.format(im1, i + 1, n))
config = ctx.data.config
robust_matching_min_match = config['robust_matching_min_match']
preemptive_threshold = config['preemptive_threshold']
lowes_ratio = config['lowes_ratio']
preemptive_lowes_ratio = config['preemptive_lowes_ratio']
if ctx.data.matches_exists(im1):
im1_matches = ctx.data.load_matches(im1)
else:
im1_matches = {}
for im2 in candidates:
if im2 in im1_matches:
continue
# preemptive matching
if preemptive_threshold > 0:
t = time.time()
config['lowes_ratio'] = preemptive_lowes_ratio
matches_pre = matching.match_lowe_bf(ctx.f_pre[im1],
ctx.f_pre[im2], config)
config['lowes_ratio'] = lowes_ratio
logger.debug("Preemptive matching {0}, time: {1}s".format(
len(matches_pre),
time.time() - t))
if len(matches_pre) < preemptive_threshold:
logger.debug(
"Discarding based of preemptive matches {0} < {1}".format(
len(matches_pre), preemptive_threshold))
continue
# symmetric matching
t = time.time()
p1, f1, c1 = ctx.data.load_features(im1)
# if we are using bruteforce matching, the loaded index will simplily be False.
i1 = ctx.data.load_feature_index(im1, f1)
p2, f2, c2 = ctx.data.load_features(im2)
i2 = ctx.data.load_feature_index(im2, f2)
matches = matching.match_symmetric(f1, i1, f2, i2, config)
logger.debug('{} - {} has {} candidate matches'.format(
im1, im2, len(matches)))
if len(matches) < robust_matching_min_match:
im1_matches[im2] = []
continue
# robust matching
t_robust_matching = time.time()
camera1 = ctx.cameras[ctx.exifs[im1]['camera']]
camera2 = ctx.cameras[ctx.exifs[im2]['camera']]
# add extra matches on the road with homography method
# filter the candidate points by semantic segmentation
rmatches = matching.robust_match(p1, p2, camera1, camera2, matches,
config)
if len(rmatches) < robust_matching_min_match:
im1_matches[im2] = []
continue
im1_matches[im2] = rmatches
logger.debug('Robust matching time : {0}s'.format(time.time() -
t_robust_matching))
logger.debug("Full matching {0} / {1}, time: {2}s".format(
len(rmatches), len(matches),
time.time() - t))
ctx.data.save_matches(im1, im1_matches)
def match(args):
"""Compute all matches for a single image"""
log.setup()
im1, candidates, i, n, ctx = args
logger.info('Matching {} - {} / {}'.format(im1, i + 1, n))
config = ctx.data.config
robust_matching_min_match = config['robust_matching_min_match']
preemptive_threshold = config['preemptive_threshold']
lowes_ratio = config['lowes_ratio']
preemptive_lowes_ratio = config['preemptive_lowes_ratio']
im1_matches = {}
for im2 in candidates:
# preemptive matching
if preemptive_threshold > 0:
t = timer()
config['lowes_ratio'] = preemptive_lowes_ratio
matches_pre = matching.match_lowe_bf(
ctx.f_pre[im1], ctx.f_pre[im2], config)
config['lowes_ratio'] = lowes_ratio
logger.debug("Preemptive matching {0}, time: {1}s".format(
len(matches_pre), timer() - t))
if len(matches_pre) < preemptive_threshold:
logger.debug(
"Discarding based of preemptive matches {0} < {1}".format(
len(matches_pre), preemptive_threshold))
continue
# symmetric matching
t = timer()
p1, f1, c1 = ctx.data.load_features(im1)
p2, f2, c2 = ctx.data.load_features(im2)
if config['matcher_type'] == 'FLANN':
i1 = ctx.data.load_feature_index(im1, f1)
i2 = ctx.data.load_feature_index(im2, f2)
else:
i1 = None
i2 = None
matches = matching.match_symmetric(f1, i1, f2, i2, config)
logger.debug('{} - {} has {} candidate matches'.format(
im1, im2, len(matches)))
if len(matches) < robust_matching_min_match:
im1_matches[im2] = []
continue
# robust matching
t_robust_matching = timer()
camera1 = ctx.cameras[ctx.exifs[im1]['camera']]
camera2 = ctx.cameras[ctx.exifs[im2]['camera']]
rmatches = matching.robust_match(p1, p2, camera1, camera2, matches,
config)
if len(rmatches) < robust_matching_min_match:
im1_matches[im2] = []
continue
im1_matches[im2] = rmatches
logger.debug('Robust matching time : {0}s'.format(
timer() - t_robust_matching))
logger.debug("Full matching {0} / {1}, time: {2}s".format(
len(rmatches), len(matches), timer() - t))
ctx.data.save_matches(im1, im1_matches)
def match(args):
'''
Compute all matches for a single image
'''
im1, candidates, i, n, ctx = args
logger.info('Matching {} - {} / {}'.format(im1, i + 1, n))
config = ctx.data.config
robust_matching_min_match = config['robust_matching_min_match']
preemptive_threshold = config['preemptive_threshold']
lowes_ratio = config['lowes_ratio']
preemptive_lowes_ratio = config['preemptive_lowes_ratio']
path_seg = ctx.data.data_path + "/images/output/results/frontend_vgg/" + os.path.splitext(
im1)[0] + '.png'
file_name = Path(path_seg)
if file_name.is_file():
im1_seg = Image.open(path_seg)
im1_seg = np.array(im1_seg)
p1, f1, c1 = ctx.data.load_features(im1)
# if we are using bruteforce matching, the loaded index will simplily be False.
i1 = ctx.data.load_feature_index(im1, f1)
if file_name.is_file():
idx_u1 = im1_seg.shape[1] * (p1[:, 0] + 0.5)
idx_v1 = im1_seg.shape[0] * (p1[:, 1] + 0.5)
im1_seg = im1_seg[idx_v1.astype(np.int), idx_u1.astype(np.int)]
else:
im1_seg = None
if ctx.data.matches_exists(im1):
im1_matches = ctx.data.load_matches(im1)
else:
im1_matches = {}
for im2 in candidates:
if im2 in im1_matches:
continue
path_seg = ctx.data.data_path + "/images/output/results/frontend_vgg/" + os.path.splitext(
im2)[0] + '.png'
file_name = Path(path_seg)
if file_name.is_file():
im2_seg = Image.open(path_seg)
im2_seg = np.array(im2_seg)
p2, f2, c2 = ctx.data.load_features(im2)
i2 = ctx.data.load_feature_index(im2, f2)
if file_name.is_file():
idx_u2 = im2_seg.shape[1] * (p2[:, 0] + 0.5)
idx_v2 = im2_seg.shape[0] * (p2[:, 1] + 0.5)
im2_seg = im2_seg[idx_v2.astype(np.int), idx_u2.astype(np.int)]
else:
im2_seg = None
# preemptive matching
if preemptive_threshold > 0:
t = time.time()
config['lowes_ratio'] = preemptive_lowes_ratio
matches_pre = matching.match_lowe_bf(ctx.f_pre[im1],
ctx.f_pre[im2], config,
im1_seg, im2_seg)
config['lowes_ratio'] = lowes_ratio
logger.debug("Preemptive matching {0}, time: {1}s".format(
len(matches_pre),
time.time() - t))
if len(matches_pre) < preemptive_threshold:
logger.debug(
"Discarding based of preemptive matches {0} < {1}".format(
len(matches_pre), preemptive_threshold))
continue
# symmetric matching
t = time.time()
matches = matching.match_symmetric(f1, i1, f2, i2, config, im1_seg,
im2_seg)
logger.debug('{} - {} has {} candidate matches'.format(
im1, im2, len(matches)))
if len(matches) < robust_matching_min_match:
im1_matches[im2] = []
continue
# robust matching
t_robust_matching = time.time()
camera1 = ctx.cameras[ctx.exifs[im1]['camera']]
camera2 = ctx.cameras[ctx.exifs[im2]['camera']]
# add extra matches on the road with homography method
# filter the candidate points by semantic segmentation
rmatches = matching.robust_match(p1, p2, camera1, camera2, matches,
config)
if len(rmatches) < robust_matching_min_match:
im1_matches[im2] = []
continue
im1_matches[im2] = rmatches
logger.debug('Robust matching time : {0}s'.format(time.time() -
t_robust_matching))
logger.debug("Full matching {0} / {1}, time: {2}s".format(
len(rmatches), len(matches),
time.time() - t))
ctx.data.save_matches(im1, im1_matches)
def match(args):
"""Compute all matches for a single image"""
log.setup()
im1, candidates, i, n, ctx = args
logger.info('Matching {} - {} / {}'.format(im1, i + 1, n))
config = ctx.data.config
robust_matching_min_match = config['robust_matching_min_match']
preemptive_threshold = config['preemptive_threshold']
lowes_ratio = config['lowes_ratio']
preemptive_lowes_ratio = config['preemptive_lowes_ratio']
im1_matches = {}
im1_all_matches = {}
im1_all_robust_matches = {}
im1_valid_rmatches = {}
im1_T = {}
im1_F = {}
im1_valid_inliers = {}
im1_calibration_flag = {}
im1_unthresholded_matches = {}
for im2 in candidates:
# preemptive matching
if preemptive_threshold > 0:
t = timer()
config['lowes_ratio'] = preemptive_lowes_ratio
matches_pre = matching.match_lowe_bf(
ctx.f_pre[im1], ctx.f_pre[im2], config)
config['lowes_ratio'] = lowes_ratio
logger.debug("Preemptive matching {0}, time: {1}s".format(
len(matches_pre), timer() - t))
if len(matches_pre) < preemptive_threshold:
logger.debug(
"Discarding based of preemptive matches {0} < {1}".format(
len(matches_pre), preemptive_threshold))
im1_all_matches[im2] = matches_pre
im1_all_robust_matches[im2] = []
im1_valid_rmatches[im2] = -1
continue
# symmetric matching
t = timer()
p1, f1, c1 = ctx.data.load_features(im1)
p2, f2, c2 = ctx.data.load_features(im2)
if config['matcher_type'] == 'FLANN':
i1 = ctx.data.load_feature_index(im1, f1)
i2 = ctx.data.load_feature_index(im2, f2)
else:
i1 = None
i2 = None
matches_all = classifier.unthresholded_match_symmetric(f1, i1, f2, i2, config)
if config['matcher_type'] == 'FLANN':
# Flann returns squared L2 distances
ri = np.where((matches_all[:,2] <= config['lowes_ratio']**2) & (matches_all[:,3] <= config['lowes_ratio']**2))[0]
else:
ri = np.where((matches_all[:,2] <= config['lowes_ratio']) & (matches_all[:,3] <= config['lowes_ratio']))[0]
matches = matches_all[ri,:]
logger.debug('{} - {} has {} candidate matches'.format(
im1, im2, len(matches)))
if len(matches) < robust_matching_min_match:
im1_matches[im2] = []
im1_all_matches[im2] = matches
im1_unthresholded_matches[im2] = matches_all
im1_all_robust_matches[im2] = []
im1_valid_rmatches[im2] = 0
continue
# robust matching
t_robust_matching = timer()
camera1 = ctx.cameras[ctx.exifs[im1]['camera']]
camera2 = ctx.cameras[ctx.exifs[im2]['camera']]
[rmatches, T, F, validity], calibration_flag = matching.robust_match(p1, p2, camera1, camera2, matches,
config)
im1_all_matches[im2] = matches
im1_unthresholded_matches[im2] = matches_all
im1_all_robust_matches[im2] = rmatches
im1_valid_rmatches[im2] = 1
im1_T[im2] = T.tolist()
im1_F[im2] = F.tolist()
im1_valid_inliers[im2] = validity
im1_calibration_flag[im2] = calibration_flag
if len(rmatches) < robust_matching_min_match:
im1_matches[im2] = []
continue
im1_matches[im2] = rmatches
logger.debug('Robust matching time : {0}s'.format(
timer() - t_robust_matching))
logger.debug("Full matching {0} / {1}, time: {2}s".format(
len(rmatches), len(matches), timer() - t))
ctx.data.save_matches(im1, im1_matches)
ctx.data.save_unthresholded_matches(im1, im1_unthresholded_matches)
ctx.data.save_all_matches(im1, im1_all_matches, im1_valid_rmatches, im1_all_robust_matches)
ctx.data.save_pairwise_results(im1, im1_T, im1_F, im1_valid_inliers, im1_calibration_flag)