vismatch 1.1.1__py3-none-any.whl

vismatch/third_party/imatch-toolbox/immatch/utils/hpatches_helper.py

@@ -0,0 +1,242 @@
+import os
+import numpy as np
+import glob
+import time
+import pydegensac
+import cv2
+from tqdm import tqdm
+
+from immatch.utils.metrics import (
+    cal_error_auc,
+    check_data_hist,
+    cal_reproj_dists_H
+)
+
+
+def eval_summary_homography(dists_sa, dists_si, dists_sv, thres):
+    correct_sa = np.mean(
+        [[float(dist <= t) for t in thres] for dist in dists_sa], axis=0
+    )
+    correct_si = np.mean(
+        [[float(dist <= t) for t in thres] for dist in dists_si], axis=0
+    )
+    correct_sv = np.mean(
+        [[float(dist <= t) for t in thres] for dist in dists_sv], axis=0
+    )
+
+    # Compute aucs
+    auc_sa = cal_error_auc(dists_sa, thresholds=thres)
+    auc_si = cal_error_auc(dists_si, thresholds=thres)
+    auc_sv = cal_error_auc(dists_sv, thresholds=thres)    
+
+    # Generate summary
+    summary = f'Hest Correct: a={correct_sa}\ni={correct_si}\nv={correct_sv}\n'
+    summary += f'Hest AUC: a={auc_sa}\ni={auc_si}\nv={auc_sv}\n'
+    return summary
+
+def eval_summary_matching(results, thres=[1, 3, 5, 10], save_npy=None):
+    np.set_printoptions(precision=2)
+    summary = ''
+    n_i = 52
+    n_v = 56      
+    i_err, v_err, stats = results
+    seq_type, n_feats, n_matches = stats
+
+    if save_npy:
+        print(f'Save results to {save_npy}')
+        np.save(save_npy, np.array(results, dtype=object))
+        
+    summary += '#Features: mean={:.0f} min={:d} max={:d}\n'.format(np.mean(n_feats), np.min(n_feats), np.max(n_feats))
+    summary += '#(Old)Matches: a={:.0f}, i={:.0f}, v={:.0f}\n'.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)
+                )
+    summary += '#Matches: a={:.0f}, i={:.0f}, v={:.0f}\n'.format(
+                    np.mean(n_matches),
+                    np.mean(n_matches[seq_type == 'i']),
+                    np.mean(n_matches[seq_type == 'v'])
+                )
+
+    thres = np.array(thres)
+    ierr = np.array([i_err[th] / (n_i * 5) for th in thres ])
+    verr = np.array([v_err[th] / (n_v * 5) for th in thres])
+    aerr = np.array([(i_err[th] + v_err[th]) / ((n_i + n_v) * 5) for th in thres])
+    summary += 'MMA@{} px:\na={}\ni={}\nv={}\n'.format(thres, aerr, ierr, verr)
+    return summary
+
+def scale_homography(sw, sh):
+    return np.array([[sw,  0, 0],
+                     [ 0, sh, 0],
+                     [ 0,  0, 1]])
+
+def eval_hpatches(
+    matcher,
+    data_root,
+    method='',
+    task='both',
+    scale_H=False,
+    h_solver='degensac',
+    ransac_thres=2,
+    thres=[1, 3, 5, 10],
+    lprint_=print,
+    print_out=False,
+    save_npy=None,
+    debug=False,
+):
+    """Evaluate a matcher on HPatches sequences for image matching and homogray estimation.
+    The matching metric is adopted from D2Net paper, i.e., the precentage of correctly matched
+    keypoints at the given re-projection error thresholds. 
+    For homography estimation, the average distances between the corners transformed using 
+    the estimated and GT homographies are computed. Both percentage of the corner distance at
+    the given thresholds and the area under the cumulative error curve (AUC) at those thresholds
+    are reported.
+    
+    Args:
+        - matcher: the matching function that inputs an image pair paths and 
+                   outputs the matches and keypoints. 
+        - data_root: the folder directory of HPatches dataset.
+        - method: the description of the evaluated method.
+        - task: the target task, options = [matching|homography|both]
+        - ransac_thres: the set of ransac thresholds used by the solver to estimate homographies.
+                        Results under each ransac threshold are printed per line.
+        - thres: error thresholds in pixels to compute the metrics.
+        - lprint: the printing function. If needed it can be implemented to outstream to a log file.
+        - print_out: when set to True, per-pair results are printed during the evaluation.
+    """
+
+    np.set_printoptions(precision=2)
+    from PIL import Image
+
+    if task == 'both':
+        task = 'matching+homography'
+    seq_dirs = sorted(glob.glob('{}/*'.format(data_root)))
+    lprint_(f'\n>>>>Eval hpatches: task={task} method={method} scale_H={scale_H} rthres={ransac_thres} thres={thres} ')
+    
+    # Matching
+    if 'matching' in task:
+        thres_range = np.arange(1, 16)
+        i_err = {thr: 0 for thr in thres_range}
+        v_err = {thr: 0 for thr in thres_range}
+        n_feats = []
+        seq_type = []
+
+    # Homography
+    if 'homography' in task:
+        inlier_ratio = []
+        h_failed = 0
+        dists_sa = []
+        dists_si = []
+        dists_sv = []
+
+    match_failed = 0
+    n_matches = []
+    match_time = []
+    start_time = time.time()
+    match_errs = []
+    for seq_idx, seq_dir in tqdm(enumerate(seq_dirs[::-1]), total=len(seq_dirs), smoothing=.5):
+        if debug and seq_idx > 10:
+            break
+        sname = seq_dir.split('/')[-1]
+        im1_path = os.path.join(seq_dir, '1.ppm')
+
+        # Eval on composed pairs within seq
+        for im_idx in range(2, 7):
+            im2_path = os.path.join(seq_dir, '{}.ppm'.format(im_idx))
+            H_gt = np.loadtxt(os.path.join(seq_dir, 'H_1_{}'.format(im_idx)))
+            scale = np.ones(4)
+
+            # Predict matches
+            try:
+                t0 = time.time()
+                match_res = matcher(im1_path, im2_path)
+                match_time.append(time.time() - t0)
+                matches, p1s, p2s = match_res[0:3]
+                if scale_H:
+                    # scale = (wo / wt, ho / ht) for im1 & im2
+                    scale = match_res[4]
+
+                    # Scale gt homoragphies
+                    H_scale_im1 = scale_homography(scale[0], scale[1])
+                    H_scale_im2 = scale_homography(scale[2], scale[3])
+                    H_gt = np.linalg.inv(H_scale_im2) @ H_gt @ H_scale_im1
+            except Exception as e:
+                print(e)
+                p1s = p2s = matches = []
+                match_failed += 1
+            n_matches.append(len(matches))
+            
+            if 'matching' in task:
+                n_feats.append(len(p1s))
+                n_feats.append(len(p2s))
+                seq_type.append(sname[0])
+                if len(matches) == 0:
+                    dist = np.array([float("inf")])
+                else:
+                    dist = cal_reproj_dists_H(matches[:, :2], matches[:, 2:], H_gt)
+                match_errs.append(dist)
+                for thr in thres_range:
+                    if sname[0] == 'i':
+                        i_err[thr] += np.mean(dist <= thr)
+                    else:
+                        v_err[thr] += np.mean(dist <= thr)
+
+            if 'homography' in task:
+                try:
+                    if h_solver == 'cv':
+                        # By default ransac
+                        H_pred, inliers = cv2.findHomography(matches[:, :2], matches[:, 2:4], cv2.RANSAC, ransac_thres)
+                    elif h_solver == 'magsac':
+                        H_pred, inliers = cv2.findHomography(matches[:, :2], matches[:, 2:4], cv2.USAC_MAGSAC, ransac_thres)
+
+                    else:
+                        H_pred, inliers = pydegensac.findHomography(matches[:, :2], matches[:, 2:4], ransac_thres)
+                except:
+                    H_pred = None
+
+                if H_pred is None:
+                    corner_dist = np.nan
+                    irat = 0
+                    h_failed += 1
+                    inliers = []
+                else:
+                    im = Image.open(im1_path)
+                    w, h = im.size
+                    w, h = w / scale[0], h / scale[1]
+                    corners = np.array([[0, 0, 1],
+                                        [0, h - 1, 1],
+                                        [w - 1, 0, 1],
+                                        [w - 1, h - 1, 1]])
+                    real_warped_corners = np.dot(corners, np.transpose(H_gt))
+                    real_warped_corners = real_warped_corners[:, :2] / real_warped_corners[:, 2:]
+                    warped_corners = np.dot(corners, np.transpose(H_pred))
+                    warped_corners = warped_corners[:, :2] / warped_corners[:, 2:]
+                    corner_dist = np.mean(np.linalg.norm(real_warped_corners - warped_corners, axis=1))
+                    irat = np.mean(inliers)
+                inlier_ratio.append(irat)
+                dists_sa.append(corner_dist)
+                if sname[0] == 'i':
+                    dists_si.append(corner_dist)
+                if sname[0] == 'v':
+                    dists_sv.append(corner_dist)
+                    
+            if print_out:
+                print(f'Scene {sname}, pair:1-{im_idx} matches:{len(matches)}')
+                if 'matching' in task:
+                    print(f'Median matching dist:{np.median(dist):.2f} <1px:{np.mean(dist <= 1):.3f}')
+                if 'homography' in task:
+                    print(f'Corner dist:{corner_dist:.2f} inliers:{np.sum(inliers)}')
+
+    lprint_(f'>>Finished, pairs={len(match_time)} match_failed={match_failed} matches={np.mean(n_matches):.1f} match_time={np.mean(match_time):.2f}s')
+
+    if 'matching' in task:
+        results = i_err, v_err, [np.array(seq_type), np.array(n_feats), np.array(n_matches)]
+        lprint_('==== Image Matching ====')
+        lprint_(eval_summary_matching(results, thres, save_npy=save_npy))
+    if 'homography' in task:
+        lprint_('==== Homography Estimation ====')        
+        lprint_(f'Hest solver={h_solver} est_failed={h_failed} ransac_thres={ransac_thres} inlier_rate={np.mean(inlier_ratio):.2f}')
+        lprint_(eval_summary_homography(dists_sa, dists_si, dists_sv, thres))
+
+    # Measure distributions
+    print(check_data_hist(match_errs, bins=[0, 1, 3, 5, 10, 50, 100, 1000], tag='Matching '))

vismatch/third_party/imatch-toolbox/immatch/utils/localize_sfm_helper.py

@@ -0,0 +1,403 @@
+import numpy as np
+import time
+import logging
+from tqdm import tqdm
+import h5py
+import os
+from pathlib import Path
+
+def names_to_pair(name0, name1):
+    return '_'.join((name0.replace('/', '-'), name1.replace('/', '-')))
+
+def load_pairs(args):
+    args.pair_dir = Path(args.pair_dir, args.benchmark_name)
+    args.db_pairs_path = args.pair_dir / args.pairs[0]
+    args.query_pairs_path = args.pair_dir / args.pairs[1]
+    if not args.db_pairs_path.exists():
+        print(f'{args.db_pairs_path} does not exist!!')
+        return None
+    if not args.db_pairs_path.exists():
+        print(f'{args.query_pairs_path} does not exist!!')
+        return None
+    
+    # Load pairs
+    print(f'Pair list: {args.pairs}')
+    db_pairs = []
+    query_pairs = []
+    with open(args.db_pairs_path) as f:
+        db_pairs += f.readlines()
+    with open(args.query_pairs_path) as f:
+        query_pairs += f.readlines()    
+    print(f'Loaded pairs db:{len(db_pairs)} query:{len(query_pairs)}')
+    pair_list = db_pairs + query_pairs
+    return pair_list
+
+def init_paths(args):
+    # Define experiment tags
+    if args.qt_psize > 0:
+        args.qt_tag = f'qt{args.qt_psize}d{args.qt_dthres}sc{args.sc_thres}'
+        if args.qt_unique:
+                args.qt_tag += 'uni'
+    else:
+        args.qt_tag = f'sc{args.sc_thres}'    
+    
+    db_pair_tag = args.pairs[0].replace('db-pairs-', '').replace('.txt', '')
+    query_pair_tag = args.pairs[1].replace('pairs-query-', '').replace('.txt', '')
+    args.pair_tag = db_pair_tag + query_pair_tag
+    
+    # Output paths 
+    output_dir = Path('outputs', args.benchmark_name, args.model_tag, args.conf_tag)
+    if not output_dir.exists():
+        os.makedirs(output_dir)
+    args.output_dir = output_dir
+    args.empty_sfm = Path('outputs', args.benchmark_name, 'empty_sfm')
+    
+    # Result dir for sfm models and localization results
+    result_dir = output_dir / f'{args.pair_tag}_{args.qt_tag}'
+    if not result_dir.exists():
+        os.makedirs(result_dir)
+    logging.info(f'Result folder: {result_dir}')
+    args.result_dir = result_dir
+    args.result_sfm = result_dir / 'sfm_final'
+    return args
+
+def init_empty_sfm(args):
+    from immatch.utils.colmap.data_parsing import (
+        create_empty_model_from_nvm_and_database, create_empty_model_from_reference_model
+    )
+    
+    if args.empty_sfm.exists():
+        logging.info('Empty sfm existed.')
+        return
+    dataset_dir = args.dataset_dir
+    
+    if args.benchmark_name == 'robotcar':
+        create_empty_model_from_nvm_and_database(
+            dataset_dir / '3D-models/all-merged/all.nvm',
+            dataset_dir / '3D-models/overcast-reference.db',
+            args.empty_sfm
+        )
+    elif args.benchmark_name in ['aachen']: 
+        # Original Aachen  
+        logging.info('Init empty sfm from nvm for aachen...')
+        create_empty_model_from_nvm_and_database(
+            dataset_dir  / '3D-models/aachen_cvpr2018_db.nvm',
+            dataset_dir  / 'database.db',
+            args.empty_sfm,
+            dataset_dir / '3D-models/database_intrinsics.txt',    
+        )
+    elif args.benchmark_name in ['aachen_v1.1']:
+        # Aachen v1.1
+        logging.info('Init empty sfm from bins for aachenv1.1...')                
+        create_empty_model_from_reference_model(
+            dataset_dir / '3D-models/aachen_v_1_1',
+            args.empty_sfm
+        )
+    else:
+        logging.error(f'Invalid benchmark {args.benchmark_name}!!')
+    
+def reconstruct_database_pairs(args):
+    from third_party.hloc.hloc import triangulation
+    
+    # Reconstruct database pairs
+    if (args.result_sfm / 'model' / 'images.bin').exists():
+        logging.info('Reconstruction existed.')
+        return    
+    logging.info('\nReconstructing database images....')
+    triangulation.main(
+        args.result_sfm,
+        args.empty_sfm,
+        args.im_dir,
+        args.db_pairs_path,
+        args.result_dir / 'keypoints.h5',
+        args.result_dir /'matches.h5',
+        colmap_path=args.colmap)
+    logging.info('Finished reconstruction.')
+    
+def localize_queries(args):
+    from third_party.hloc.hloc import localize_sfm
+    
+    # Localize query pairs
+    for ransac_thresh in args.ransac_thres:
+        localize_txt = f'{args.model_tag}_{args.conf_tag}.{args.pair_tag}.{args.qt_tag}.r{ransac_thresh}.txt'
+        if args.covis_cluster:
+            localize_txt = localize_txt.replace('txt', 'covis.txt')
+        logging.info(f'Localize queries...')
+        print('>>>>', localize_txt)        
+        localize_sfm.main(
+            args.result_sfm / 'model',
+            args.dataset_dir / 'queries/*_queries_with_intrinsics.txt',
+            args.query_pairs_path,
+            args.result_dir / 'keypoints.h5',
+            args.result_dir / 'matches.h5',
+            args.result_dir / localize_txt,
+            ransac_thresh=ransac_thresh,
+            covisibility_clustering=args.covis_cluster,
+            changed_format=True,
+            benchmark=args.benchmark_name
+        )
+
+def get_grouped_ids(array):
+    # Group array indices based on its values
+    # all duplicates are grouped as a set
+    idx_sort = np.argsort(array)
+    sorted_array = array[idx_sort]
+    vals, ids, count = np.unique(sorted_array, return_counts=True, return_index=True)
+    res = np.split(idx_sort, ids[1:])
+    return res
+
+def get_unique_matches_ids(match_ids, scores):
+    if len(match_ids.shape) == 1:
+        return [0]
+
+    k1s = match_ids[:, 0]
+    k2s = match_ids[:, 1]
+    isets1 = get_grouped_ids(k1s)
+    isets2 = get_grouped_ids(k2s)
+    
+    uid1s = []
+    for ids in isets1:
+        if len(ids) == 1:
+            uid1s.append(ids[0])  # Unique
+        else:        
+            uid1s.append(ids[scores[ids].argmax()])
+    uid2s = []
+    for ids in isets2:
+        if len(ids) == 1:
+            uid2s.append(ids[0])  # Unique
+        else:    
+            uid2s.append(ids[scores[ids].argmax()])            
+    uids = list(set(uid1s).intersection(uid2s))    
+    return uids  
+
+def quantize_keypoints(fpts, kp_data, psize=48, dthres=4):
+    """Keypoints quantization algorithm.
+    The image is divided into cells, where each cell represents a psize*psize local patch.
+    Each input point has its linked coarse point (patch region).
+    For all points inside a patch region, those points with distances smaller than the given 
+    threshold will be merged and represented by their mean pixel.
+    
+    Args:
+        - fpts: the set of input keypoint coordinates, shape (N, 2)
+        - kp_data: the keypoint data dict linked to an image
+        - psize: the size to divide an image into multiple patch regions
+        - dthres: the distance threshold (in pixels) for merging points within the same patch region        
+    Return:
+        - fpt_ids: the keypoint ids of the input points
+    """
+    
+    # kp_data: {'kps':[], 'kp_means': kp_dict}
+    fpt_ids = []
+    cpts = fpts // psize * psize   # Point coordinates (x, y)      
+    for cpt, fpt in zip(cpts, fpts):
+        cpt = tuple(cpt) 
+        kps = kp_data['kps']
+        kp_dict = kp_data['kp_means']  # {cpt : {'means':[], 'kids':[]}}
+        if cpt not in kp_dict:
+            kid = len(kps)
+            kps.append(fpt)  # Insert another keypoint
+            kp_dict[cpt] = {'means':[fpt], 'kids':[kid]}  # Init 1st center        
+        else:
+            kids = kp_dict[cpt]['kids']
+            centers = kp_dict[cpt]['means']  # N, 2 
+            dist = np.linalg.norm(fpt - np.array(centers), axis=1)
+            cid = np.argmin(dist)        
+            if dist[cid] < dthres:
+                centers[cid] = (centers[cid] + fpt) / 2   # Update center
+                kid = kids[cid]
+                kps[kid] = centers[cid]  # Update key point value
+            else:
+                kid = len(kps)
+                kps.append(fpt)  # Insert another keypoint
+                centers.append(fpt)  # Insert as a new center
+                kids.append(kid)
+        fpt_ids.append(kid)    
+    return fpt_ids
+
+def compute_keypoints(pts, kp_data):
+    kps = kp_data['kps']
+    kp_dict = kp_data['kpids']
+    pt_ids = []
+    for pt in pts:
+        key = tuple(pt)        
+        if key not in kp_dict:
+            kid = len(kps)   # 0-based, the next inserting index            
+            kps.append(pt)
+            kp_dict[key] = kid
+        else:
+            kid = kp_dict[key]            
+        pt_ids.append(kid)
+    return pt_ids
+
+def match_pairs_with_keys_exporth5(matcher, pairs, pair_keys, match_file, debug=False):
+    # Pairwise matching
+    num_matches = []
+    match_times = []
+    start_time = time.time()
+
+    with h5py.File(match_file, 'a') as fmatch:
+        matched = list(fmatch.keys())
+        print(f'\nLoad match file, existing matches {len(matched)}')
+        print(f'Start matching, total {len(pairs)} pairs...')
+        for pair, key in tqdm(zip(pairs, pair_keys), total=len(pairs), smoothing=.1):
+            im1_path, im2_path = pair
+            if key in matched:
+                num_matches.append(len(fmatch[key]['matches']))
+                continue
+
+            try:
+                t0 = time.time()
+                match_res = matcher(im1_path, im2_path)
+                match_times.append(time.time() - t0)
+            except:
+                print(f'##Failed matching on {key}')
+                continue
+
+            matches = match_res[0]
+            scores = match_res[3]
+            N = len(matches)
+            num_matches.append(N)
+
+            # Add print for easy debugging
+            if debug:
+                print(f'{pair} matches: {N}')
+
+            # Save matches
+            grp = fmatch.create_group(key)
+            grp.create_dataset('matches', data=matches)
+            grp.create_dataset('scores', data=scores)
+        total_time = time.time() - start_time
+        mean_time = np.mean(match_times) if len(match_times) > 0 else 0.0
+        print(f'Finished matched pairs: {len(fmatch)} num_matches:{np.mean(num_matches):.2f} '
+              f'match_time/pair:{mean_time:.2f}s time:{total_time:.2f}s.')
+
+def match_pairs_exporth5(pair_list, matcher, im_dir, output_dir, debug=False):
+    # Construct pairs and pair keys
+    pairs = []
+    pair_keys = []
+    pair_keys_set = set()
+    for pair_line in tqdm(pair_list, smoothing=.1):
+        name0, name1 = pair_line.split()
+        key = names_to_pair(name0, name1)
+        key_inv = names_to_pair(name1, name0)
+        if key_inv in pair_keys_set:
+            continue
+
+        pair_keys.append(key)
+        pair_keys_set.add(key)
+        pair = (str(im_dir / name0), str(im_dir / name1))
+        pairs.append(pair)
+
+    match_file = output_dir/'matches_raw.h5'
+    match_pairs_with_keys_exporth5(matcher, pairs, pair_keys, match_file, debug=debug)
+
+def process_matches_and_keypoints_exporth5(pair_list, output_dir, result_dir,    
+                                           sc_thres=0.25, qt_dthres=4, qt_psize=48, 
+                                           qt_unique=True):
+    """
+    This function should be executed after running match_pairs_exporth5(), which save the 
+    precomputed the raw matches and their scores in a hdf5.
+    This function first filters out the less confident matches based on the given score threshold.
+    Then the keypoints are computed accordingly from the filtered matches by finding the unique set
+    of points that have been matched for each image.
+    Afterwards, matches are represented by pairs of keypoint ids.
+    We further provide an option to quantize keypoints, where keypoints are closer than 
+    a given distance will be merged into one.
+    For the methods that directly obtain pixel-level matches without having an explicit keypoint 
+    detection stage, such quantization could be helpful or necessary to enable proper stability
+    for the triangulation step of a localization pipeline. 
+    Notice, such quantization sacrifices the pixel-wise accuracy, so the methods with 
+    specific keypoint detection (SuperPoint, D2Net, ..etc) or the methods that produce 
+    patch-level matches (NCNet, SparseNCNet) should not use it.
+    
+    Args:
+        - pair_list: list of pair strings
+        - output_dir: the directory where matches_raw.h5 is saved
+        - result_dir: the output directory to save processed matches and keypoints
+        - sc_thres: the score threshold to filter less confident matches
+        - qt_dthres, qt_psize: args for quantization, set qt_psize as 0 can skip the quantization.
+        - qt_unique: flag to maintain the uniqueness of matches after quantization
+
+    Nothing is returned. The processed keypoints are saved as keypoints.h5 and matches (represented by the 
+    keypoints ids) are saved as matches.h5 in the result directory.
+    """
+    # Select matches from the raw matches and quantize keypoints   
+    if (result_dir/'keypoints.h5').exists():
+        logging.info('Result matches and keypoints already existed, skip')
+        return
+        
+    match_file = h5py.File(output_dir/'matches_raw.h5', 'r')
+    all_kp_data = {}
+    logging.info('Start parse matches and quantize keypoints ...')
+    with h5py.File(result_dir/'matches.h5', 'w') as res_fmatch:
+        for pair in tqdm(pair_list, smoothing=.1):
+            name0, name1 = pair.split()
+            pair = names_to_pair(name0, name1)
+
+            if pair not in match_file:
+                continue            
+
+            matches = match_file[pair]['matches'].__array__()
+            scores = match_file[pair]['scores'].__array__()
+            valid = np.where(scores >= sc_thres)[0]
+            matches = matches[valid]
+            scores = scores[valid]
+            
+            # Compute match ids and quantize keypoints
+            match_ids = matches_to_keypoint_ids(
+                matches, scores, name0, name1, all_kp_data,
+                qt_dthres, qt_psize, qt_unique
+            )
+
+            # Save matches
+            grp = res_fmatch.create_group(pair)
+            grp.create_dataset('matches0', data=match_ids)
+        num_pairs = len(res_fmatch.keys())
+        
+    # Save keypoints
+    with h5py.File(result_dir/'keypoints.h5', 'w') as res_fkp:    
+        logging.info(f'Save keypoints from {len(all_kp_data)} images...')
+        for name in tqdm(all_kp_data, smoothing=.1):
+            kps = np.array(all_kp_data[name]['kps'], dtype=np.float32)
+            kgrp = res_fkp.create_group(name)
+            kgrp.create_dataset('keypoints', data=kps)
+    logging.info(f'Finished quantization, match pairs:{num_pairs}')
+    match_file.close()
+    
+def matches_to_keypoint_ids(matches, scores, name0, name1, all_kp_data,
+                            qt_dthres=-1, qt_psize=-1, qt_unique=True):
+    if len(matches) == 0:
+        return np.empty([0, 2], dtype=np.int32)
+
+    if qt_psize > 0 and qt_dthres > 0:
+        # Compute keypoints jointly with quantization
+        if name0 not in all_kp_data:
+            all_kp_data[name0] = {'kps':[], 'kp_means':{}}
+        if name1 not in all_kp_data:
+            all_kp_data[name1] = {'kps':[], 'kp_means':{}}
+
+        id1s = quantize_keypoints(matches[:, 0:2], all_kp_data[name0],
+                                  psize=qt_psize, dthres=qt_dthres)
+        id2s = quantize_keypoints(matches[:, 2:4], all_kp_data[name1],
+                                  psize=qt_psize, dthres=qt_dthres)
+        match_ids = np.dstack([id1s, id2s]).reshape(-1, 2) # N, 2
+
+        # Remove n-to-1 matches after quantization
+        if qt_unique and len(match_ids) > 1:
+            uids = get_unique_matches_ids(match_ids, scores)
+            match_ids = match_ids[uids]
+            uids = get_unique_matches_ids(match_ids, scores)
+            match_ids = match_ids[uids]
+    else:
+        # Compute keypoints without quantization
+        if name0 not in all_kp_data:
+            all_kp_data[name0] = {'kps':[], 'kpids':{}}
+        if name1 not in all_kp_data:
+            all_kp_data[name1] = {'kps':[], 'kpids':{}}
+
+        id1s = compute_keypoints(matches[:, 0:2], all_kp_data[name0])
+        id2s = compute_keypoints(matches[:, 2:4], all_kp_data[name1])
+        match_ids = np.dstack([id1s, id2s]).reshape(-1, 2)
+
+    return match_ids
+