About matching score

[reacher-l]

Hello, your work is excellent. I would like to follow your work, Can you open your test code about matching score?

[santelelle]

same interest here, I cannot reproduce the results stated in the paper

[reacher-l]

-- coding: utf-8 --

""" Spyder Editor

This is a temporary script file. """

import matplotlib import matplotlib.pyplot as plt import numpy as np import os import torch from scipy.io import loadmat from tqdm import tqdm_notebook as tqdm

%matplotlib inline

use_cuda = torch.cuda.is_available() device = torch.device('cuda:0' if use_cuda else 'cpu') top_k = None

n_i = 52 n_v = 56

dataset_path = 'hpatches-sequences-release'

dataset_path = '/hpatch/hpatches_sequences/hpatches-sequences-release'

lim = [1, 15] rng = np.arange(lim[0], lim[1] + 1)

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]])
matches = torch.stack([ids1, nn12])
return matches.t().data.cpu().numpy()

import pdb

def benchmark_features(read_feats): seq_names = sorted(os.listdir(dataset_path))

n_feats = []
n_matches = []
match_score = 0
match_score_count = 0

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])

    for im_idx in range(2, 7):
        keypoints_b, descriptors_b = read_feats(seq_name, im_idx)
        # pdb.set_trace()
        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)
        )
        # pdb.set_trace()
        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)) #2713

        n_matches.append(matches.shape[0])#2713, 2
        # pdb.set_trace()
        match_score += sum(dist<=5)/dist.shape[0]
        match_score_count+=1

return match_score, match_score_count

def summary(stats): seq_type, n_feats, n_matches = stats print('# Features: {:f} - [{:d}, {:d}]'.format(np.mean(n_feats), np.min(n_feats), np.max(n_feats))) print('# Matches: Overall {:f}, Illumination {:f}, Viewpoint {:f}'.format( np.sum(n_matches) / ((n_i + n_v) 5), np.sum(n_matches[seq_type == 'i']) / (n_i 5), np.sum(n_matches[seq_type == 'v']) / (n_v * 5)) )

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

errors = {} method = 'r2d2_fuxian' read_function = generate_read_function(method) match_score,match_score_count = benchmark_features(read_function) print(match_score/match_score_count)

I used the code above to get a similar matching score！