---
kind: concept
slug: point-cloud-registration
title: Point cloud registration
summary: >-
  Point cloud registration finds the rigid transform that aligns two 3D point sets. Correspondence-based methods propose matches, filter the wrong ones and fit a transform. Maximal-clique filtering with SVD fitting is training-free and reports high recall on 3DMatch, but its clique search grows costly as the number of matches rises.
tags: [point-cloud, registration, correspondence, outlier-rejection, 3d-vision]
papers: ["2305.10854"]
related: [iterative-closest-point, correspondence, outlier-rejection, maximal-clique-search, local-feature-matching]
status: draft
updated_at: 2026-11-08
---

## Overview

Registration asks for the rotation and translation that bring one 3D point set
onto another [arxiv:2305.10854 §1]. A common pipeline proposes correspondences
between the two sets from per-point descriptors, removes the wrong ones, and
fits a rigid transform to the rest. Most proposed matches are wrong, so the
hard part is the filtering step [arxiv:2305.10854 §1].

The filter relies on one fact about rigid motion. For two true
correspondences, the distance between their points is the same in both sets,
up to noise [arxiv:2305.10854 §3.2]. Pairs of matches that agree on this
distance can be checked against each other without knowing the transform.

This page currently covers one compiled paper. Other families, such as
[iterative closest point](/concepts/iterative-closest-point) for refinement
from a coarse start, are not yet compared here.

## Variants

### Maximal-clique filtering, training-free

Each putative match is a node. Two nodes are joined when their distance
mismatch is small under a Gaussian score [arxiv:2305.10854 §3.2 eq. 1-2]. The
second-order graph keeps an edge only when the two nodes also share compatible
neighbours, which makes the graph sparser [arxiv:2305.10854 §3.2 eq. 3].

The method enumerates maximal cliques, scores each by its summed edge weight,
and keeps the heaviest clique that contains each node [arxiv:2305.10854 §3.3
eq. 4]. An SVD fit gives one transform per kept clique [arxiv:2305.10854 §3.4].
The paper is [3D Registration with Maximal Cliques](/papers/2305.10854).

With FCGF matches, the authors report 93.72% registration recall on 3DMatch and
59.85% on 3DLoMatch [arxiv:2305.10854 tab. 1, tab. 2]. With FPFH matches they
report 84.10% and 40.88% on the same sets [arxiv:2305.10854 tab. 1, tab. 2].

### Boosting a learned matcher

The same back-end can filter matches from a learned model. The authors report
3DMatch recall with 5000 correspondences rising from 92.0 to 95.7 for
GeoTransformer, from 85.1 to 91.3 for FCGF, and from 88.6 to 95.3 for SpinNet
[arxiv:2305.10854 tab. 3]. These are the authors' own baselines.

### Hypothesis scoring

After the cliques give candidate transforms, one must be chosen. The default
scores each hypothesis with a mean-absolute-error measure. The paper gives no
inlier threshold for it [arxiv:2305.10854 §3.4]. In the authors' FPFH ablation
on 3DMatch, ranking by inlier count gives 83.86% recall and the default scoring
gives 84.10% [arxiv:2305.10854 tab. 5].

## When to use which

| Situation | Use | Why |
|---|---|---|
| No training data, or a learned matcher does not transfer | Maximal-clique filtering on FPFH or FCGF matches | Training-free; the authors report 84.10% on 3DMatch with FPFH [arxiv:2305.10854 tab. 1] |
| A strong learned descriptor is already in use | Clique filtering as a post-filter | Authors report gains on 3DMatch with 5000 matches for three learned matchers [arxiv:2305.10854 tab. 3] |
| Thousands of matches and a tight time budget | Cut the match count first, or choose another method | Time grows from 7.08 ms at 250 matches to 3265.42 ms at 5000, and clique search takes 48.37% of the time at 5000 [arxiv:2305.10854 tab. 8] |
| Low overlap, few inliers | Measure on your own data before relying on it | On 3DLoMatch with FCGF the margin over the SC2-PCR baseline is 1.12 points (59.85 vs 58.73) [arxiv:2305.10854 tab. 2] |
| Need a single maximum clique | Prefer maximal cliques | Ablation: maximum clique 74.06%, maximal clique 83.86% on 3DMatch with FPFH [arxiv:2305.10854 tab. 5] |

The margins over the strongest baseline are small for FCGF on 3DMatch (0.56
points) and largest for the boosted and FPFH settings [arxiv:2305.10854 tab. 1,
tab. 2, tab. 3].

## Implementation sketch

The core of the maximal-clique variant. Descriptor matching runs before this
step, and the per-clique hypothesis score is left as a black box.

```pseudocode
# Maximal-clique registration  [arxiv:2305.10854 §3]
# Input:  src, tgt (N, 3): N putative matches; d_cmp, t_cmp
# Output: rigid transform (R, t)

def register(src, tgt, d_cmp, t_cmp):
    # Pairwise compatibility from distance mismatch  [§3.2 eq. 1-2]
    w1 = first_order_weights(src, tgt, d_cmp, t_cmp)
    # Second-order weights: keep edges with shared neighbours  [§3.2 eq. 3]
    w2 = w1 * (w1 @ w1)
    # Enumerate maximal cliques of at least three nodes  [§3.3]
    cliques = maximal_cliques(w2, min_size=3)
    # Clique weight is its summed edge weight; keep the heaviest per node  [§3.3 eq. 4]
    selected = node_guided_selection(cliques, w2)
    # One SVD fit per selected clique  [§3.4]
    hyps = [svd_fit(src[c], tgt[c]) for c in selected]
    # Return the hypothesis with the best score  [§3.4]
    return max(hyps, key=lambda h: score(h, src, tgt))
```

The paper's Gaussian kernel uses a width d_cmp tied to the point-cloud
resolution, and the threshold t_cmp removes weak edges [arxiv:2305.10854 §3.2
§4.1]. Both need the input's resolution, which the paper leaves to an external
reference [arxiv:2305.10854 §4.1].

## Contradictions

- **Compatibility threshold.** The paper gives 0.99, rising to 0.999 above 5000
  matches [arxiv:2305.10854 §4.1]. The authors' C++ code uses 0.999 for FCGF and
  0.995 for FPFH on 3DMatch whatever the match count [arxiv:2305.10854 Paper vs code].
- **Kernel form.** The paper gives one Gaussian kernel [arxiv:2305.10854 §3.2 eq. 2].
  The authors' Python demos use a linear kernel with a 0.1 m width, and the C++
  KITTI path uses a linear kernel with width 0.6 [arxiv:2305.10854 Paper vs code].
- **Refinement.** The paper's text describes no post-refinement. The C++ code
  runs up to 20 MAE-based refinement steps [arxiv:2305.10854 Paper vs code].
- **Clique size.** The paper uses a minimum of three [arxiv:2305.10854 §4.1].
  The code call uses three, but its comment says four for 3DMatch [arxiv:2305.10854 Paper vs code].
- **Timing at 5000 matches.** The two timing tables give 3265.42 ms and
  3259.38 ms. The paper does not explain the gap [arxiv:2305.10854 tab. 8, tab. 12].

## Papers

- [3D Registration with Maximal Cliques](/papers/2305.10854): training-free
  maximal-clique filtering of correspondences with SVD fitting per clique; the
  same back-end can boost learned matchers.
