Vincentqyw
fix: roma
c74a070
raw
history blame
6.13 kB
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])
# =========== compute homography
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)
# =========== compute homography
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("")