commerge 2.0.0__py3-none-any.whl

commerge/__init__.py

@@ -0,0 +1,6 @@
+"""Commerge: communication-efficient multi-robot LiDAR map merging."""
+__version__ = "2.0.0"
+
+from .selection import STEPS, Selection, cosine_affinity, enhance_affinity, extract_regions, select  # noqa: E402,F401
+from .session import Session, read_pcd, write_pcd  # noqa: E402,F401
+from .merge import POLICIES, alignment_error, choose_regions, register, register_exchanged, register_grid  # noqa: E402,F401

commerge/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

commerge/baselines/automerge.py

@@ -0,0 +1,157 @@
+"""AutoMerge-style region selection (our re-implementation, for comparison).
+
+AutoMerge (P. Yin et al., "AutoMerge: A Framework for Map Assembling and Smoothing in City-Scale
+Environments", IEEE T-RO 2023) finds overlapping sequences with SeqSLAM. This module follows that
+idea on the same affinity matrix Commerge uses:
+
+1. local contrast enhancement of the difference matrix D = 1 - affinity (SeqSLAM);
+2. sequence matching along constant-velocity trajectories, with a ratio test;
+3. K-means on the good matches, a line RANSAC per cluster;
+4. each cluster's padded bounding box is a region; the best region is exchanged whole.
+
+It is not the authors' code. All scans of the chosen region are sent, which is what Commerge's
+selection is compared against.
+"""
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import List, Tuple
+
+import numpy as np
+
+from ..selection import Region, Selection
+
+
+@dataclass
+class AutoMergeParams:
+    min_area: int = 20000
+    contrast_r: int = 50          # rows of the local contrast window
+    ds: int = 50                  # sequence length
+    vmin: float = 0.8             # trajectory slopes searched
+    vmax: float = 1.2
+    r_window: int = 10            # window excluded around the best match for the ratio test
+    ratio: float = 0.8            # keep matches with best / second-best below this
+    n_clusters: int = 5
+    ransac_iters: int = 100
+    padding: int = 20             # region padding (keyframes)
+    best_only: bool = True        # exchange only the best region (as AutoMerge does)
+    seed: int = 0
+
+
+def enhance_contrast(D: np.ndarray, r: int) -> np.ndarray:
+    """SeqSLAM local contrast enhancement along the rows (reference keyframes)."""
+    DD = np.empty_like(D, dtype=float)
+    n = D.shape[0]
+    for i in range(n):
+        a, b = max(0, i - r // 2), min(n, i + r // 2 + 1)
+        v = D[a:b]
+        std = v.std(axis=0, ddof=1) if b - a > 1 else np.ones(D.shape[1])
+        std[std == 0] = 1.0
+        DD[i] = (D[i] - v.mean(axis=0)) / std
+    return DD - DD.min()
+
+
+def sequence_matches(DD: np.ndarray, p: AutoMergeParams) -> np.ndarray:
+    """(Nb, 2): for each query column, the best reference row and the ratio to the second best."""
+    ds = p.ds + (p.ds % 2)
+    rows, cols = DD.shape
+    matches = np.full((cols, 2), np.nan)
+    move = np.arange(int(p.vmin * ds), int(p.vmax * ds) + 1)
+    v = move / ds
+    steps = np.floor(np.arange(ds + 1)[None, :] * v[:, None]).astype(int)  # (V, ds+1)
+    padded = np.vstack([DD, np.full((1, cols), np.inf)])                     # out-of-bounds row
+    starts = np.arange(rows)
+    for n in range(ds // 2, cols - ds // 2):
+        x = np.arange(n - ds // 2, n + ds // 2 + 1)                          # ds+1 query columns
+        y = np.minimum(starts[:, None, None] + steps[None], rows)            # (S, V, ds+1)
+        scores = padded[y, x[None, None, :]].sum(axis=2).min(axis=1)         # (S,)
+        if not np.isfinite(scores).any():
+            continue
+        k = int(np.argmin(scores))
+        mask = np.ones(rows, bool)
+        mask[max(0, k - p.r_window // 2): min(rows, k + p.r_window // 2)] = False
+        second = scores[mask].min() if mask.any() else np.inf
+        matches[n] = (k + ds // 2, scores[k] / second if second > 0 else 1.0)
+    return matches
+
+
+def _kmeans(points: np.ndarray, k: int, seed: int) -> np.ndarray:
+    try:
+        from sklearn.cluster import KMeans
+
+        return KMeans(n_clusters=k, random_state=seed, n_init=10).fit_predict(points)
+    except ImportError:
+        from scipy.cluster.vq import kmeans2
+
+        return kmeans2(points.astype(float), k, seed=seed, minit="++")[1]
+
+
+def _ransac_line(pts: np.ndarray, iters: int, rng: np.random.Generator) -> np.ndarray:
+    if len(pts) < 4:
+        return np.arange(len(pts))
+    best = np.arange(0)
+    tol = max(10.0, 0.1 * len(pts))
+    for _ in range(iters):
+        i, j = rng.choice(len(pts), 2, replace=False)
+        if abs(pts[j, 0] - pts[i, 0]) < 1e-6:
+            continue
+        a = (pts[j, 1] - pts[i, 1]) / (pts[j, 0] - pts[i, 0])
+        b = pts[i, 1] - a * pts[i, 0]
+        inl = np.nonzero(np.abs(pts[:, 1] - (a * pts[:, 0] + b)) < tol)[0]
+        if len(inl) > len(best):
+            best = inl
+    return best if len(best) else np.arange(len(pts))
+
+
+def automerge_regions(affinity: np.ndarray, p: AutoMergeParams = AutoMergeParams()
+                      ) -> List[Tuple[Tuple[int, int, int, int], float]]:
+    """Regions (a0, a1, b0, b1) with their mean match ratio, best first."""
+    DD = enhance_contrast(np.clip(1.0 - affinity, 0, 1), p.contrast_r)
+    m = sequence_matches(DD, p)
+    good = [(int(m[q, 0]), q, m[q, 1]) for q in range(len(m)) if np.isfinite(m[q, 0]) and m[q, 1] < p.ratio]
+    if not good:
+        return []
+    pts = np.array([(a, b) for a, b, _ in good], dtype=float)
+    k = max(2, min(p.n_clusters, len(good) // 10))
+    labels = _kmeans(pts, k, p.seed) if len(good) >= k else np.zeros(len(good), int)
+    rng = np.random.default_rng(p.seed)
+    regions = []
+    for c in range(labels.max() + 1):
+        idx = np.nonzero(labels == c)[0]
+        if len(idx) <= 2:
+            continue
+        idx = idx[_ransac_line(pts[idx], p.ransac_iters, rng)]
+        if len(idx) < 3:
+            continue
+        a0, a1 = pts[idx, 0].min(), pts[idx, 0].max()
+        b0, b1 = pts[idx, 1].min(), pts[idx, 1].max()
+        box = (int(max(0, a0 - p.padding)), int(min(affinity.shape[0], a1 + p.padding)),
+               int(max(0, b0 - p.padding)), int(min(affinity.shape[1], b1 + p.padding)))
+        if (box[1] - box[0]) * (box[3] - box[2]) >= p.min_area:
+            regions.append((box, float(np.mean([good[i][2] for i in idx]))))
+
+    def score(r):  # as in our comparison: similar sequences and large overlap first
+        (a0, a1, b0, b1), ratio = r
+        sim = float(affinity[a0:a1, b0:b1].mean())
+        return 0.7 * sim + 0.3 * min((a1 - a0) * (b1 - b0) / 50000.0, 1.0)
+
+    return sorted(regions, key=score, reverse=True)
+
+
+def automerge_select(affinity: np.ndarray, p: AutoMergeParams = AutoMergeParams(), log=print) -> Selection:
+    """The chosen region(s), every keyframe of which is exchanged."""
+    t = time.perf_counter()
+    regions = automerge_regions(affinity, p)
+    if p.best_only:
+        regions = regions[:1]
+    out = []
+    for (a0, a1, b0, b1), _ in regions:
+        r = Region((a0, a1, b0, b1))
+        r.scans_a, r.scans_b = list(range(a0, a1)), list(range(b0, b1))
+        r.candidates = int((affinity[a0:a1, b0:b1] > 0).sum())
+        r.seconds["automerge"] = time.perf_counter() - t
+        out.append(r)
+    log(f"[automerge] {len(out)} region(s), {sum(len(r.keyframes_a) + len(r.keyframes_b) for r in out)} scans "
+        f"in {time.perf_counter() - t:.2f} s")
+    return Selection(out, "", "-")

commerge/cli.py

@@ -0,0 +1,178 @@
+"""commerge: select the scans two robots exchange to merge their maps.
+
+    commerge <session A> <session B> --out merged/ [--threshold 0.94 --min-area 10000]
+
+Sessions are SOLiD outputs (LT-mapper format: Scans/, SOLiDs/, *_poses.txt). The affinity is
+the cosine similarity of their SOLiD descriptors, or any (Na, Nb) matrix given with --affinity.
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+
+from . import __version__
+from .selection import STEPS, cosine_affinity, enhance_affinity, select
+from .merge import POLICIES, alignment_error, choose_regions, register_exchanged
+from .session import Session, read_kitti_poses
+from .solvers import SOLVERS
+from .submap import build_submap, save_submap
+
+
+def parse_args(argv=None) -> argparse.Namespace:
+    p = argparse.ArgumentParser(prog="commerge", description=__doc__,
+                                formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("session_a", type=Path, help="robot A: SOLiD session folder")
+    p.add_argument("session_b", type=Path, help="robot B: SOLiD session folder")
+    p.add_argument("--out", type=Path, required=True, help="output folder")
+    g = p.add_argument_group("affinity")
+    g.add_argument("--affinity", type=Path, help="(Na, Nb) .npy instead of the SOLiD descriptors")
+    g.add_argument("--descriptor", choices=("rsolid", "asolid", "both"), default="rsolid",
+                   help="SOLiD part used for the cosine affinity (default: rsolid)")
+    g.add_argument("--poses", default="auto", help="auto | optimized | odom: keyframe poses to use")
+    g = p.add_argument_group("selection")
+    g.add_argument("--threshold", type=float, required=True, help="affinity threshold of a candidate pair")
+    g.add_argument("--enhance", type=int, default=0, metavar="L",
+                   help="sequence-enhance the affinity over L keyframes before step (A) (row/column z-scores, "
+                        "diagonal and anti-diagonal average; thresholds become z-scores, ~3), e.g. for "
+                        "heterogeneous LiDARs; 0: off (default)")
+    g.add_argument("--min-area", type=int, required=True, help="smallest region (cells of its bounding box)")
+    g.add_argument("--consistency", type=float, default=3.0,
+                   help="largest distance mismatch (m) between two consistent pairs (default: 3)")
+    g.add_argument("--steps", default="ABC",
+                   help="steps to run, any subset of ABC (default): (A) " + STEPS["A"] + ", (B) " + STEPS["B"]
+                   + ", (C) " + STEPS["C"])
+    g.add_argument("--solver", choices=SOLVERS, default="auto",
+                   help="gurobi (paper, needs a license) | highs (SciPy, no license) | auto (default)")
+    g.add_argument("--time-limit", type=float, default=0.0, help="per-problem solver time limit, s (0: none)")
+    g = p.add_argument_group("exchange and merging")
+    g.add_argument("--policy", choices=POLICIES, default="score",
+                   help="region(s) whose scans are exchanged: score (largest step-(C) clique weight, default), "
+                        "area, candidates or all")
+    g.add_argument("--no-register", action="store_true",
+                   help="do not register the exchanged submaps (registration needs kiss-matcher, small-gicp)")
+    g.add_argument("--reg-voxel", type=float, default=0.5, help="registration voxel size (m)")
+    g.add_argument("--registration", choices=("kiss", "grid"), default="kiss",
+                   help="kiss: KISS-Matcher + GICP (default); grid: yaw and x-y search around the best selected "
+                        "pair + ICP, for heterogeneous LiDARs")
+    g.add_argument("--gt-a", type=Path, help="ground-truth keyframe poses of A (KITTI, common frame): report the error")
+    g.add_argument("--gt-b", type=Path, help="ground-truth keyframe poses of B (same frame as --gt-a)")
+    g = p.add_argument_group("output")
+    g.add_argument("--no-submaps", action="store_true", help="only write the selection")
+    g.add_argument("--min-range", type=float, default=3.0, help="drop points closer than this (m)")
+    g.add_argument("--voxel", type=float, default=0.0, help="submap voxel size (m, 0: none)")
+    g.add_argument("--plot", action="store_true", help="save the affinity with regions and pairs")
+    g.add_argument("--verbose", action="store_true", help="solver logs")
+    p.add_argument("--version", action="version", version=f"commerge {__version__}")
+    return p.parse_args(argv)
+
+
+def descriptor(s: Session, which: str) -> np.ndarray:
+    if s.rsolid is None:
+        raise SystemExit(f"{s.name}: no SOLiDs/ folder; give the affinity with --affinity")
+    if which == "rsolid":
+        return s.rsolid
+    if s.asolid is None:
+        raise SystemExit(f"{s.name}: SOLiDs/ has no A-SOLiD line")
+    return s.asolid if which == "asolid" else np.c_[s.rsolid, s.asolid]
+
+
+def main(argv=None) -> int:
+    args = parse_args(argv)
+    out = args.out
+    out.mkdir(parents=True, exist_ok=True)
+
+    A = Session.load(args.session_a, args.poses)
+    B = Session.load(args.session_b, args.poses)
+    print(f"[commerge] {A.name}: {len(A)} keyframes | {B.name}: {len(B)} keyframes")
+    if args.affinity:
+        aff = np.load(args.affinity)
+    else:
+        t = time.perf_counter()
+        aff = cosine_affinity(descriptor(A, args.descriptor), descriptor(B, args.descriptor))
+        print(f"[commerge] affinity {aff.shape} from {args.descriptor} in {time.perf_counter() - t:.2f} s")
+        np.save(out / "affinity.npy", aff.astype(np.float32))
+
+    if args.enhance:
+        aff = enhance_affinity(aff, args.enhance)
+        print(f"[commerge] affinity sequence-enhanced over {args.enhance} keyframes")
+    sel = select(aff, A.positions, B.positions, args.threshold, args.min_area, args.consistency,
+                 args.steps, args.solver, args.time_limit, args.verbose)
+
+    with open(out / "pairs.csv", "w", newline="") as f:
+        w = csv.writer(f)
+        w.writerow(["region", "keyframe_a", "keyframe_b", "affinity"])
+        for k, r in enumerate(sel.regions):
+            for a, b in r.pairs:
+                w.writerow([k, a, b, f"{aff[a, b]:.6f}"])
+
+    summary = {
+        "session_a": str(args.session_a), "session_b": str(args.session_b),
+        "keyframes": [len(A), len(B)], "threshold": args.threshold, "min_area": args.min_area,
+        "consistency": args.consistency, "steps": sel.steps, "solver": sel.solver,
+        "selected_scans": [len(sel.keyframes_a), len(sel.keyframes_b)],
+        "regions": [{"box_a": [r.box[0], r.box[1]], "box_b": [r.box[2], r.box[3]],
+                     "A_candidates": r.candidates, "B_cover": [len(r.cover_a), len(r.cover_b)],
+                     "C_pairs": len(r.pairs), "keyframes_a": r.keyframes_a, "keyframes_b": r.keyframes_b,
+                     "seconds": r.seconds} for r in sel.regions],
+    }
+    # exchange policy: the region(s) whose selected scans the robots actually send
+    chosen = choose_regions(sel, aff, A.positions, B.positions, args.policy, args.consistency)
+    ka = sorted({a for k in chosen for a in sel.regions[k].keyframes_a})
+    kb = sorted({b for k in chosen for b in sel.regions[k].keyframes_b})
+    summary["exchange"] = {"policy": args.policy, "regions": chosen, "keyframes_a": ka, "keyframes_b": kb}
+    if ka and kb and not (args.no_submaps and args.no_register):
+        sub_a = build_submap(A, ka, args.min_range, args.voxel)
+        sub_b = build_submap(B, kb, args.min_range, args.voxel)
+        if not args.no_submaps:
+            save_submap(out / "submap_A.pcd", sub_a)
+            save_submap(out / "submap_B.pcd", sub_b)
+        if not args.no_register:
+            try:
+                reg = register_exchanged(sub_a, sub_b, A.poses, B.poses,
+                                         [p for k in chosen for p in sel.regions[k].pairs], aff,
+                                         args.registration, args.reg_voxel)
+            except ImportError as e:
+                reg = False
+                print(f"[commerge] registration skipped: {e}")
+            if reg is False:
+                pass
+            elif reg is None:
+                print("[commerge] registration failed (too few inliers); try another --policy")
+            else:
+                np.savetxt(out / "T_a_b.txt", reg.T_a_b, fmt="%.9f")
+                merged = np.einsum("ij,njk->nik", reg.T_a_b, B.poses)[:, :3, :4].reshape(len(B), 12)
+                np.savetxt(out / "poses_b_in_a.txt", merged, fmt="%.9f")
+                summary["registration"] = {"inliers": reg.inliers, "gicp_error": reg.fitness, "seconds": reg.seconds}
+                msg = (f"[commerge] registered B to A: {reg.inliers} KISS-Matcher inliers, GICP in {reg.seconds:.1f} s"
+                       if args.registration == "kiss" else
+                       f"[commerge] registered B to A (grid + ICP): fit {reg.fitness:.2f} in {reg.seconds:.1f} s")
+                if args.gt_a and args.gt_b:
+                    et, er, em = alignment_error(reg.T_a_b, A.poses, B.poses, read_kitti_poses(args.gt_a),
+                                                 read_kitti_poses(args.gt_b))
+                    summary["registration"]["error"] = {"trans_m": et, "rot_deg": er, "merged_mean_m": em}
+                    msg += f"; vs ground truth: {et:.2f} m, {er:.2f} deg (B keyframes {em:.2f} m off on average)"
+                print(msg)
+    (out / "selection.json").write_text(json.dumps(summary, indent=1))
+
+    if args.plot:
+        from .viz import plot_selection
+
+        plot_selection(aff, sel, out / "selection.png", args.threshold)
+
+    total = len(A) + len(B)
+    sent = len(ka) + len(kb)
+    mb = sum(A.scans[k].stat().st_size for k in ka) / 1e6 + sum(B.scans[k].stat().st_size for k in kb) / 1e6 \
+        if A.scans and B.scans else float("nan")
+    print(f"[commerge] exchanged {len(ka)} A + {len(kb)} B scans ({100.0 * sent / max(total, 1):.1f} % of {total}, "
+          f"{mb:.1f} MB) from region(s) {chosen} of {len(sel.regions)} -> {out}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

commerge/compare.py

@@ -0,0 +1,135 @@
+"""commerge-compare: Commerge, its ablations (without step (B) or (C), step (A) only) and AutoMerge
+on the same two sessions.
+
+    commerge-compare <session A> <session B> --threshold 0.96 --min-area 2000 --out cmp/
+                     [--gt-a gt_a.txt --gt-b gt_b.txt]
+
+Reports, per method, the scans each robot sends (count, share of all keyframes, megabytes of the
+keyframe clouds) and the run time. With ground-truth keyframe poses in a common frame
+(KITTI format, one row per keyframe), it also reports the share of selected pairs that are
+really the same place (within --gt-radius meters).
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+
+from .baselines.automerge import AutoMergeParams, automerge_select
+from .cli import descriptor
+from .merge import alignment_error, choose_regions, register
+from .selection import select
+from .submap import build_submap
+from .session import Session, read_kitti_poses
+from .solvers import SOLVERS
+
+METHODS = {
+    "Commerge (A+B+C)": "ABC",
+    "w/o (B)": "AC",
+    "w/o (C)": "AB",
+    "(A) only": "A",
+}
+
+
+def parse_args(argv=None):
+    p = argparse.ArgumentParser(prog="commerge-compare", description=__doc__,
+                                formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("session_a", type=Path)
+    p.add_argument("session_b", type=Path)
+    p.add_argument("--out", type=Path, required=True)
+    p.add_argument("--affinity", type=Path, help="(Na, Nb) .npy instead of SOLiD descriptors")
+    p.add_argument("--descriptor", choices=("rsolid", "asolid", "both"), default="rsolid")
+    p.add_argument("--poses", default="auto")
+    p.add_argument("--threshold", type=float, required=True)
+    p.add_argument("--min-area", type=int, required=True)
+    p.add_argument("--consistency", type=float, default=3.0)
+    p.add_argument("--solver", choices=SOLVERS, default="auto")
+    p.add_argument("--time-limit", type=float, default=60.0,
+                   help="per-problem solver limit, s (default 60: the ablations without the cover can be huge)")
+    p.add_argument("--automerge-min-area", type=int, help="AutoMerge region size (default: --min-area)")
+    p.add_argument("--gt-a", type=Path, help="ground-truth keyframe poses of A (KITTI, common frame)")
+    p.add_argument("--gt-b", type=Path, help="ground-truth keyframe poses of B (same frame as --gt-a)")
+    p.add_argument("--gt-radius", type=float, default=5.0)
+    p.add_argument("--policy", default="score", help="exchange policy of the Commerge variants (see commerge --help)")
+    p.add_argument("--no-register", action="store_true", help="skip registering each method's exchanged scans")
+    return p.parse_args(argv)
+
+
+def scan_megabytes(s: Session, keyframes) -> float:
+    return sum(s.scans[k].stat().st_size for k in keyframes) / 1e6 if s.scans else float("nan")
+
+
+def main(argv=None) -> int:
+    args = parse_args(argv)
+    args.out.mkdir(parents=True, exist_ok=True)
+    A, B = Session.load(args.session_a, args.poses), Session.load(args.session_b, args.poses)
+    aff = np.load(args.affinity) if args.affinity else \
+        __import__("commerge").cosine_affinity(descriptor(A, args.descriptor), descriptor(B, args.descriptor))
+    gt = gtT = None
+    if args.gt_a and args.gt_b:
+        gtT = (read_kitti_poses(args.gt_a), read_kitti_poses(args.gt_b))
+        gt = (gtT[0][:, :3, 3], gtT[1][:, :3, 3])
+
+    rows, selections = [], {}
+    quiet = lambda *a: None  # noqa: E731
+    for name, steps in METHODS.items():
+        t = time.perf_counter()
+        sel = select(aff, A.positions, B.positions, args.threshold, args.min_area, args.consistency,
+                     steps, args.solver, args.time_limit, log=quiet)
+        selections[name] = (sel, time.perf_counter() - t)
+    t = time.perf_counter()
+    am = AutoMergeParams(min_area=args.automerge_min_area or args.min_area)
+    selections["AutoMerge"] = (automerge_select(aff, am, log=quiet), time.perf_counter() - t)
+
+    total = len(A) + len(B)
+    for name, (sel, sec) in selections.items():
+        # what is actually exchanged: the chosen region (AutoMerge keeps its best region already)
+        chosen = choose_regions(sel, aff, A.positions, B.positions, args.policy if name != "AutoMerge" else "all")
+        ka = sorted({a for k in chosen for a in sel.regions[k].keyframes_a})
+        kb = sorted({b for k in chosen for b in sel.regions[k].keyframes_b})
+        pairs = [p for k in chosen for p in sel.regions[k].pairs]
+        row = {"method": name, "scans_a": len(ka), "scans_b": len(kb),
+               "share": 100.0 * (len(ka) + len(kb)) / total,
+               "megabytes": scan_megabytes(A, ka) + scan_megabytes(B, kb),
+               "pairs": len(pairs), "seconds": sec}
+        if gt is not None and pairs:
+            d = np.array([np.linalg.norm(gt[0][a] - gt[1][b]) for a, b in pairs])
+            row["pair_precision"] = float((d <= args.gt_radius).mean())
+        if not args.no_register and ka and kb:
+            try:
+                reg = register(build_submap(A, ka), build_submap(B, kb))
+            except ImportError:
+                args.no_register = True
+                print("[compare] kiss-matcher not installed: registration skipped")
+                reg = None
+            row["registered"] = reg is not None
+            if reg is not None and gtT is not None:
+                et, er, em = alignment_error(reg.T_a_b, A.poses, B.poses, *gtT)
+                row.update(trans_err=et, rot_err=er, merged_err=em)
+        rows.append(row)
+
+    print("| method | scans A + B | share of keyframes | data (MB) | pairs | pair precision | merge error | time (s) |")
+    print("| --- | --- | --- | --- | --- | --- | --- | --- |")
+    for r in rows:
+        prec = f"{100 * r['pair_precision']:.1f} %" if "pair_precision" in r else "-"
+        if "trans_err" in r:
+            err = f"{r['trans_err']:.2f} m, {r['rot_err']:.2f} deg"
+        else:
+            err = "failed" if r.get("registered") is False else "-"
+        print(f"| {r['method']} | {r['scans_a']} + {r['scans_b']} | {r['share']:.1f} % | {r['megabytes']:.1f} | "
+              f"{r['pairs'] or '-'} | {prec} | {err} | {r['seconds']:.2f} |")
+    (args.out / "comparison.json").write_text(json.dumps(rows, indent=1))
+
+    from .viz import plot_comparison
+
+    plot_comparison(aff, {k: v[0] for k, v in selections.items()}, args.out / "comparison.png", args.threshold, rows)
+    print(f"-> {args.out}/comparison.json, comparison.png")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())