|
import cv2 |
|
import os |
|
from tqdm import tqdm |
|
import torch |
|
import numpy as np |
|
from extract import extract_method |
|
|
|
use_cuda = torch.cuda.is_available() |
|
device = torch.device('cuda' if use_cuda else 'cpu') |
|
|
|
methods = ['d2', 'lfnet', 'superpoint', 'r2d2', 'aslfeat', 'disk', |
|
'alike-n', 'alike-l', 'alike-n-ms', 'alike-l-ms'] |
|
names = ['D2-Net(MS)', 'LF-Net(MS)', 'SuperPoint', 'R2D2(MS)', 'ASLFeat(MS)', 'DISK', |
|
'ALike-N', 'ALike-L', 'ALike-N(MS)', 'ALike-L(MS)'] |
|
|
|
top_k = None |
|
n_i = 52 |
|
n_v = 56 |
|
cache_dir = 'hseq/cache' |
|
dataset_path = 'hseq/hpatches-sequences-release' |
|
|
|
|
|
def generate_read_function(method, extension='ppm'): |
|
def read_function(seq_name, im_idx): |
|
aux = np.load(os.path.join(dataset_path, seq_name, '%d.%s.%s' % (im_idx, extension, method))) |
|
if top_k is None: |
|
return aux['keypoints'], aux['descriptors'] |
|
else: |
|
assert ('scores' in aux) |
|
ids = np.argsort(aux['scores'])[-top_k:] |
|
return aux['keypoints'][ids, :], aux['descriptors'][ids, :] |
|
|
|
return read_function |
|
|
|
|
|
def mnn_matcher(descriptors_a, descriptors_b): |
|
device = descriptors_a.device |
|
sim = descriptors_a @ descriptors_b.t() |
|
nn12 = torch.max(sim, dim=1)[1] |
|
nn21 = torch.max(sim, dim=0)[1] |
|
ids1 = torch.arange(0, sim.shape[0], device=device) |
|
mask = (ids1 == nn21[nn12]) |
|
matches = torch.stack([ids1[mask], nn12[mask]]) |
|
return matches.t().data.cpu().numpy() |
|
|
|
|
|
def homo_trans(coord, H): |
|
kpt_num = coord.shape[0] |
|
homo_coord = np.concatenate((coord, np.ones((kpt_num, 1))), axis=-1) |
|
proj_coord = np.matmul(H, homo_coord.T).T |
|
proj_coord = proj_coord / proj_coord[:, 2][..., None] |
|
proj_coord = proj_coord[:, 0:2] |
|
return proj_coord |
|
|
|
|
|
def benchmark_features(read_feats): |
|
lim = [1, 5] |
|
rng = np.arange(lim[0], lim[1] + 1) |
|
|
|
seq_names = sorted(os.listdir(dataset_path)) |
|
|
|
n_feats = [] |
|
n_matches = [] |
|
seq_type = [] |
|
i_err = {thr: 0 for thr in rng} |
|
v_err = {thr: 0 for thr in rng} |
|
|
|
i_err_homo = {thr: 0 for thr in rng} |
|
v_err_homo = {thr: 0 for thr in rng} |
|
|
|
for seq_idx, seq_name in tqdm(enumerate(seq_names), total=len(seq_names)): |
|
keypoints_a, descriptors_a = read_feats(seq_name, 1) |
|
n_feats.append(keypoints_a.shape[0]) |
|
|
|
|
|
ref_img = cv2.imread(os.path.join(dataset_path, seq_name, '1.ppm')) |
|
ref_img_shape = ref_img.shape |
|
|
|
for im_idx in range(2, 7): |
|
keypoints_b, descriptors_b = read_feats(seq_name, im_idx) |
|
n_feats.append(keypoints_b.shape[0]) |
|
|
|
matches = mnn_matcher( |
|
torch.from_numpy(descriptors_a).to(device=device), |
|
torch.from_numpy(descriptors_b).to(device=device) |
|
) |
|
|
|
homography = np.loadtxt(os.path.join(dataset_path, seq_name, "H_1_" + str(im_idx))) |
|
|
|
pos_a = keypoints_a[matches[:, 0], : 2] |
|
pos_a_h = np.concatenate([pos_a, np.ones([matches.shape[0], 1])], axis=1) |
|
pos_b_proj_h = np.transpose(np.dot(homography, np.transpose(pos_a_h))) |
|
pos_b_proj = pos_b_proj_h[:, : 2] / pos_b_proj_h[:, 2:] |
|
|
|
pos_b = keypoints_b[matches[:, 1], : 2] |
|
|
|
dist = np.sqrt(np.sum((pos_b - pos_b_proj) ** 2, axis=1)) |
|
|
|
n_matches.append(matches.shape[0]) |
|
seq_type.append(seq_name[0]) |
|
|
|
if dist.shape[0] == 0: |
|
dist = np.array([float("inf")]) |
|
|
|
for thr in rng: |
|
if seq_name[0] == 'i': |
|
i_err[thr] += np.mean(dist <= thr) |
|
else: |
|
v_err[thr] += np.mean(dist <= thr) |
|
|
|
|
|
gt_homo = homography |
|
pred_homo, _ = cv2.findHomography(keypoints_a[matches[:, 0], : 2], keypoints_b[matches[:, 1], : 2], |
|
cv2.RANSAC) |
|
if pred_homo is None: |
|
homo_dist = np.array([float("inf")]) |
|
else: |
|
corners = np.array([[0, 0], |
|
[ref_img_shape[1] - 1, 0], |
|
[0, ref_img_shape[0] - 1], |
|
[ref_img_shape[1] - 1, ref_img_shape[0] - 1]]) |
|
real_warped_corners = homo_trans(corners, gt_homo) |
|
warped_corners = homo_trans(corners, pred_homo) |
|
homo_dist = np.mean(np.linalg.norm(real_warped_corners - warped_corners, axis=1)) |
|
|
|
for thr in rng: |
|
if seq_name[0] == 'i': |
|
i_err_homo[thr] += np.mean(homo_dist <= thr) |
|
else: |
|
v_err_homo[thr] += np.mean(homo_dist <= thr) |
|
|
|
seq_type = np.array(seq_type) |
|
n_feats = np.array(n_feats) |
|
n_matches = np.array(n_matches) |
|
|
|
return i_err, v_err, i_err_homo, v_err_homo, [seq_type, n_feats, n_matches] |
|
|
|
|
|
if __name__ == '__main__': |
|
errors = {} |
|
for method in methods: |
|
output_file = os.path.join(cache_dir, method + '.npy') |
|
read_function = generate_read_function(method) |
|
if os.path.exists(output_file): |
|
errors[method] = np.load(output_file, allow_pickle=True) |
|
else: |
|
extract_method(method) |
|
errors[method] = benchmark_features(read_function) |
|
np.save(output_file, errors[method]) |
|
|
|
for name, method in zip(names, methods): |
|
i_err, v_err, i_err_hom, v_err_hom, _ = errors[method] |
|
|
|
print(f"====={name}=====") |
|
print(f"MMA@1 MMA@2 MMA@3 MHA@1 MHA@2 MHA@3: ", end='') |
|
for thr in range(1, 4): |
|
err = (i_err[thr] + v_err[thr]) / ((n_i + n_v) * 5) |
|
print(f"{err * 100:.2f}%", end=' ') |
|
for thr in range(1, 4): |
|
err_hom = (i_err_hom[thr] + v_err_hom[thr]) / ((n_i + n_v) * 5) |
|
print(f"{err_hom * 100:.2f}%", end=' ') |
|
print('') |
|
|
