| """Evaluate camera relocalization on the mall localization benchmark (shipped as eval.py in the package; numpy + pandas only). |
| |
| python eval.py --root <benchmark dir> --estimates <dir> your poses |
| python eval.py --root <benchmark dir> --baseline the shipped hloc baseline (reproduces benchmark.md) |
| |
| <dir>/<walk>/<section>/poses_<map>to<query>.txt, one line per query image: `name qw qx qy qz tx ty tz`, world->camera |
| (COLMAP / hloc convention) in the frame of <walk>/<section>/reference/, whose unit is the metre. A query missing from the file |
| counts as a failure. Scored: the directions sections.parquet marks scored, and inside them the frames whose two references |
| agree (frames.parquet pgt_ok). Recall at (0.1 m, 1 deg), (0.25 m, 2 deg), (0.5 m, 5 deg), (1 m, 5 deg), (5 m, 10 deg). |
| """ |
| import argparse |
| import pathlib |
|
|
| import numpy as np |
| import pandas as pd |
|
|
| THRESHOLDS = [(0.1, 1.0), (0.25, 2.0), (0.5, 5.0), (1.0, 5.0), (5.0, 10.0)] |
|
|
|
|
| def qvec2rot(q): |
| w, x, y, z = q |
| return np.array([[1 - 2 * (y * y + z * z), 2 * (x * y - w * z), 2 * (x * z + w * y)], |
| [2 * (x * y + w * z), 1 - 2 * (x * x + z * z), 2 * (y * z - w * x)], |
| [2 * (x * z - w * y), 2 * (y * z + w * x), 1 - 2 * (x * x + y * y)]]) |
|
|
|
|
| def read_poses(path: pathlib.Path) -> dict: |
| """name -> (R world->cam, camera centre).""" |
| out = {} |
| if not path.exists(): |
| return out |
| for line in path.read_text().splitlines(): |
| p = line.split() |
| if len(p) != 8 or line.startswith("#"): |
| continue |
| R = qvec2rot(np.array(p[1:5], float)); t = np.array(p[5:8], float) |
| out[p[0]] = (R, -R.T @ t) |
| return out |
|
|
|
|
| def read_reference(images_txt: pathlib.Path) -> dict: |
| """COLMAP images.txt -> name -> (R, centre); every other line is the 2D points.""" |
| out, lines = {}, [l for l in images_txt.read_text().splitlines() if not l.startswith("#")] |
| for l in lines[::2]: |
| p = l.split() |
| if len(p) >= 10: |
| R = qvec2rot(np.array(p[1:5], float)); t = np.array(p[5:8], float) |
| out[p[9]] = (R, -R.T @ t) |
| return out |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--root", required=True, type=pathlib.Path) |
| g = ap.add_mutually_exclusive_group(required=True) |
| g.add_argument("--estimates", type=pathlib.Path) |
| g.add_argument("--baseline", action="store_true") |
| ap.add_argument("--all", action="store_true", help="every query of every localized direction, not only the scored ones") |
| a = ap.parse_args() |
| S = pd.read_parquet(a.root / "sections.parquet") |
| S = S[S.direction.notna()] if a.all else S[S.scored] |
| rows = [] |
| for _, s in S.iterrows(): |
| d = a.root / s.walk / s.section |
| m, q = s.direction.split("->") |
| est_file = (d / "baseline" if a.baseline else a.estimates / s.walk / s.section) / f"poses_{m}to{q}.txt" |
| est, gt = read_poses(est_file), read_reference(d / "reference" / "images.txt") |
| F = pd.read_parquet(d / "frames.parquet") |
| F = F[(F.visit == int(q)) & F.registered & (True if a.all else F.pgt_ok)] |
| for n in F.name: |
| Rg, cg = gt[n] |
| if n in est: |
| Re, ce = est[n] |
| dt = float(np.linalg.norm(ce - cg)); dr = float(np.degrees(np.arccos(np.clip((np.trace(Re @ Rg.T) - 1) / 2, -1, 1)))) |
| else: |
| dt = dr = np.inf |
| rows.append({"walk": s.walk, "section": s.section, "direction": s.direction, "query": n, "t_err_m": dt, "r_err_deg": dr}) |
| E = pd.DataFrame(rows) |
| if E.empty: |
| raise SystemExit("nothing to evaluate") |
| rec = lambda X: {f"{T} m, {R:g} deg": float(((X.t_err_m <= T) & (X.r_err_deg <= R)).mean()) for T, R in THRESHOLDS} |
| print(f"{len(E)} queries over {E.groupby(['walk', 'section', 'direction']).ngroups} directions " |
| f"({'all' if a.all else 'scored'}; {'baseline' if a.baseline else a.estimates})") |
| for k, v in rec(E).items(): |
| print(f" {k:>14}: {v:6.1%}") |
| fin = E[np.isfinite(E.t_err_m)] |
| print(f" median error of localized queries: {fin.t_err_m.median() * 100:.1f} cm, {fin.r_err_deg.median():.2f} deg") |
| per = E.groupby(["walk", "section", "direction"]).apply(lambda X: pd.Series({"queries": len(X), **rec(X)}), include_groups=False) |
| print(per.to_string(float_format=lambda x: f"{x:.2f}")) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
