Spaces:
Running
Running
| import numpy as np | |
| import sys | |
| import os | |
| ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "..")) | |
| sys.path.insert(0, ROOT_DIR) | |
| from utils import evaluation_utils, metrics, fm_utils | |
| import cv2 | |
| class auc_eval: | |
| def __init__(self, config): | |
| self.config = config | |
| self.err_r, self.err_t, self.err = [], [], [] | |
| self.ms = [] | |
| self.precision = [] | |
| def run(self, info): | |
| E, r_gt, t_gt = info["e"], info["r_gt"], info["t_gt"] | |
| K1, K2, img1, img2 = info["K1"], info["K2"], info["img1"], info["img2"] | |
| corr1, corr2 = info["corr1"], info["corr2"] | |
| corr1, corr2 = evaluation_utils.normalize_intrinsic( | |
| corr1, K1 | |
| ), evaluation_utils.normalize_intrinsic(corr2, K2) | |
| size1, size2 = max(img1.shape), max(img2.shape) | |
| scale1, scale2 = self.config["rescale"] / size1, self.config["rescale"] / size2 | |
| # ransac | |
| ransac_th = 4.0 / ( | |
| (K1[0, 0] + K1[1, 1]) * scale1 + (K2[0, 0] + K2[1, 1]) * scale2 | |
| ) | |
| R_hat, t_hat, E_hat = self.estimate(corr1, corr2, ransac_th) | |
| # get pose error | |
| err_r, err_t = metrics.evaluate_R_t(r_gt, t_gt, R_hat, t_hat) | |
| err = max(err_r, err_t) | |
| if len(corr1) > 1: | |
| inlier_mask = metrics.compute_epi_inlier( | |
| corr1, corr2, E, self.config["inlier_th"] | |
| ) | |
| precision = inlier_mask.mean() | |
| ms = inlier_mask.sum() / len(info["x1"]) | |
| else: | |
| ms = precision = 0 | |
| return { | |
| "err_r": err_r, | |
| "err_t": err_t, | |
| "err": err, | |
| "ms": ms, | |
| "precision": precision, | |
| } | |
| def res_inqueue(self, res): | |
| self.err_r.append(res["err_r"]), self.err_t.append( | |
| res["err_t"] | |
| ), self.err.append(res["err"]) | |
| self.ms.append(res["ms"]), self.precision.append(res["precision"]) | |
| def estimate(self, corr1, corr2, th): | |
| num_inlier = -1 | |
| if corr1.shape[0] >= 5: | |
| E, mask_new = cv2.findEssentialMat( | |
| corr1, corr2, method=cv2.RANSAC, threshold=th, prob=1 - 1e-5 | |
| ) | |
| if E is None: | |
| E = [np.eye(3)] | |
| for _E in np.split(E, len(E) / 3): | |
| _num_inlier, _R, _t, _ = cv2.recoverPose( | |
| _E, corr1, corr2, np.eye(3), 1e9, mask=mask_new | |
| ) | |
| if _num_inlier > num_inlier: | |
| num_inlier = _num_inlier | |
| R = _R | |
| t = _t | |
| E = _E | |
| else: | |
| E, R, t = np.eye(3), np.eye(3), np.zeros(3) | |
| return R, t, E | |
| def parse(self): | |
| ths = np.arange(7) * 5 | |
| approx_auc = metrics.approx_pose_auc(self.err, ths) | |
| exact_auc = metrics.pose_auc(self.err, ths) | |
| mean_pre, mean_ms = np.mean(np.asarray(self.precision)), np.mean( | |
| np.asarray(self.ms) | |
| ) | |
| print("auc th: ", ths[1:]) | |
| print("approx auc: ", approx_auc) | |
| print("exact auc: ", exact_auc) | |
| print("mean match score: ", mean_ms * 100) | |
| print("mean precision: ", mean_pre * 100) | |
| class FMbench_eval: | |
| def __init__(self, config): | |
| self.config = config | |
| self.pre, self.pre_post, self.sgd = [], [], [] | |
| self.num_corr, self.num_corr_post = [], [] | |
| def run(self, info): | |
| corr1, corr2 = info["corr1"], info["corr2"] | |
| F = info["f"] | |
| img1, img2 = info["img1"], info["img2"] | |
| if len(corr1) > 1: | |
| pre_bf = fm_utils.compute_inlier_rate( | |
| corr1, | |
| corr2, | |
| np.flip(img1.shape[:2]), | |
| np.flip(img2.shape[:2]), | |
| F, | |
| th=self.config["inlier_th"], | |
| ).mean() | |
| F_hat, mask_F = cv2.findFundamentalMat( | |
| corr1, | |
| corr2, | |
| method=cv2.FM_RANSAC, | |
| ransacReprojThreshold=1, | |
| confidence=1 - 1e-5, | |
| ) | |
| if F_hat is None: | |
| F_hat = np.ones([3, 3]) | |
| mask_F = np.ones([len(corr1)]).astype(bool) | |
| else: | |
| mask_F = mask_F.squeeze().astype(bool) | |
| F_hat = F_hat[:3] | |
| pre_af = fm_utils.compute_inlier_rate( | |
| corr1[mask_F], | |
| corr2[mask_F], | |
| np.flip(img1.shape[:2]), | |
| np.flip(img2.shape[:2]), | |
| F, | |
| th=self.config["inlier_th"], | |
| ).mean() | |
| num_corr_af = mask_F.sum() | |
| num_corr = len(corr1) | |
| sgd = fm_utils.compute_SGD( | |
| F, F_hat, np.flip(img1.shape[:2]), np.flip(img2.shape[:2]) | |
| ) | |
| else: | |
| pre_bf, pre_af, sgd = 0, 0, 1e8 | |
| num_corr, num_corr_af = 0, 0 | |
| return { | |
| "pre": pre_bf, | |
| "pre_post": pre_af, | |
| "sgd": sgd, | |
| "num_corr": num_corr, | |
| "num_corr_post": num_corr_af, | |
| } | |
| def res_inqueue(self, res): | |
| self.pre.append(res["pre"]), self.pre_post.append( | |
| res["pre_post"] | |
| ), self.sgd.append(res["sgd"]) | |
| self.num_corr.append(res["num_corr"]), self.num_corr_post.append( | |
| res["num_corr_post"] | |
| ) | |
| def parse(self): | |
| for seq_index in range(len(self.config["seq"])): | |
| seq = self.config["seq"][seq_index] | |
| offset = seq_index * 1000 | |
| pre = np.asarray(self.pre)[offset : offset + 1000].mean() | |
| pre_post = np.asarray(self.pre_post)[offset : offset + 1000].mean() | |
| num_corr = np.asarray(self.num_corr)[offset : offset + 1000].mean() | |
| num_corr_post = np.asarray(self.num_corr_post)[ | |
| offset : offset + 1000 | |
| ].mean() | |
| f_recall = ( | |
| np.asarray(self.sgd)[offset : offset + 1000] | |
| < self.config["sgd_inlier_th"] | |
| ).mean() | |
| print(seq, "results:") | |
| print("F_recall: ", f_recall) | |
| print("precision: ", pre) | |
| print("precision_post: ", pre_post) | |
| print("num_corr: ", num_corr) | |
| print("num_corr_post: ", num_corr_post, "\n") | |