vismatch 1.1.1__py3-none-any.whl

vismatch/third_party/gim/gluefactory/models/matchers/nearest_neighbor_matcher.py

@@ -0,0 +1,97 @@
+"""
+Nearest neighbor matcher for normalized descriptors.
+Optionally apply the mutual check and threshold the distance or ratio.
+"""
+
+import logging
+
+import torch
+import torch.nn.functional as F
+
+from ..base_model import BaseModel
+from ..utils.metrics import matcher_metrics
+
+
+@torch.no_grad()
+def find_nn(sim, ratio_thresh, distance_thresh):
+    sim_nn, ind_nn = sim.topk(2 if ratio_thresh else 1, dim=-1, largest=True)
+    dist_nn = 2 * (1 - sim_nn)
+    mask = torch.ones(ind_nn.shape[:-1], dtype=torch.bool, device=sim.device)
+    if ratio_thresh:
+        mask = mask & (dist_nn[..., 0] <= (ratio_thresh**2) * dist_nn[..., 1])
+    if distance_thresh:
+        mask = mask & (dist_nn[..., 0] <= distance_thresh**2)
+    matches = torch.where(mask, ind_nn[..., 0], ind_nn.new_tensor(-1))
+    return matches
+
+
+def mutual_check(m0, m1):
+    inds0 = torch.arange(m0.shape[-1], device=m0.device)
+    inds1 = torch.arange(m1.shape[-1], device=m1.device)
+    loop0 = torch.gather(m1, -1, torch.where(m0 > -1, m0, m0.new_tensor(0)))
+    loop1 = torch.gather(m0, -1, torch.where(m1 > -1, m1, m1.new_tensor(0)))
+    m0_new = torch.where((m0 > -1) & (inds0 == loop0), m0, m0.new_tensor(-1))
+    m1_new = torch.where((m1 > -1) & (inds1 == loop1), m1, m1.new_tensor(-1))
+    return m0_new, m1_new
+
+
+class NearestNeighborMatcher(BaseModel):
+    default_conf = {
+        "ratio_thresh": None,
+        "distance_thresh": None,
+        "mutual_check": True,
+        "loss": None,
+    }
+    required_data_keys = ["descriptors0", "descriptors1"]
+
+    def _init(self, conf):
+        if conf.loss == "N_pair":
+            temperature = torch.nn.Parameter(torch.tensor(1.0))
+            self.register_parameter("temperature", temperature)
+
+    def _forward(self, data):
+        sim = torch.einsum("bnd,bmd->bnm", data["descriptors0"], data["descriptors1"])
+        matches0 = find_nn(sim, self.conf.ratio_thresh, self.conf.distance_thresh)
+        matches1 = find_nn(
+            sim.transpose(1, 2), self.conf.ratio_thresh, self.conf.distance_thresh
+        )
+        if self.conf.mutual_check:
+            matches0, matches1 = mutual_check(matches0, matches1)
+        b, m, n = sim.shape
+        la = sim.new_zeros(b, m + 1, n + 1)
+        la[:, :-1, :-1] = F.log_softmax(sim, -1) + F.log_softmax(sim, -2)
+        mscores0 = (matches0 > -1).float()
+        mscores1 = (matches1 > -1).float()
+        return {
+            "matches0": matches0,
+            "matches1": matches1,
+            "matching_scores0": mscores0,
+            "matching_scores1": mscores1,
+            "similarity": sim,
+            "log_assignment": la,
+        }
+
+    def loss(self, pred, data):
+        losses = {}
+        if self.conf.loss == "N_pair":
+            sim = pred["similarity"]
+            if torch.any(sim > (1.0 + 1e-6)):
+                logging.warning(f"Similarity larger than 1, max={sim.max()}")
+            scores = torch.sqrt(torch.clamp(2 * (1 - sim), min=1e-6))
+            scores = self.temperature * (2 - scores)
+            assert not torch.any(torch.isnan(scores)), torch.any(torch.isnan(sim))
+            prob0 = torch.nn.functional.log_softmax(scores, 2)
+            prob1 = torch.nn.functional.log_softmax(scores, 1)
+
+            assignment = data["gt_assignment"].float()
+            num = torch.max(assignment.sum((1, 2)), assignment.new_tensor(1))
+            nll0 = (prob0 * assignment).sum((1, 2)) / num
+            nll1 = (prob1 * assignment).sum((1, 2)) / num
+            nll = -(nll0 + nll1) / 2
+            losses["n_pair_nll"] = losses["total"] = nll
+            losses["num_matchable"] = num
+            losses["n_pair_temperature"] = self.temperature[None]
+        else:
+            raise NotImplementedError
+        metrics = {} if self.training else matcher_metrics(pred, data)
+        return losses, metrics

vismatch/third_party/gim/gluefactory/models/triplet_pipeline.py

@@ -0,0 +1,99 @@
+"""
+A two-view sparse feature matching pipeline on triplets.
+
+If a triplet is found, runs the extractor on three images and
+then runs matcher/filter/solver for all three pairs.
+
+Losses and metrics get accumulated accordingly.
+
+If no triplet is found, this falls back to two_view_pipeline.py
+"""
+
+import torch
+
+from ..utils.misc import get_twoview, stack_twoviews, unstack_twoviews
+from .two_view_pipeline import TwoViewPipeline
+
+
+def has_triplet(data):
+    # we already check for image0 and image1 in required_keys
+    return "view2" in data.keys()
+
+
+class TripletPipeline(TwoViewPipeline):
+    default_conf = {"batch_triplets": True, **TwoViewPipeline.default_conf}
+
+    def _forward(self, data):
+        if not has_triplet(data):
+            return super()._forward(data)
+        # the two-view outputs are stored in
+        # pred['0to1'],pred['0to2'], pred['1to2']
+
+        assert not self.conf.run_gt_in_forward
+        pred0 = self.extract_view(data, "0")
+        pred1 = self.extract_view(data, "1")
+        pred2 = self.extract_view(data, "2")
+
+        pred = {}
+        pred = {
+            **{k + "0": v for k, v in pred0.items()},
+            **{k + "1": v for k, v in pred1.items()},
+            **{k + "2": v for k, v in pred2.items()},
+        }
+
+        def predict_twoview(pred, data):
+            # forward pass
+            if self.conf.matcher.name:
+                pred = {**pred, **self.matcher({**data, **pred})}
+
+            if self.conf.filter.name:
+                pred = {**pred, **self.filter({**m_data, **pred})}
+
+            if self.conf.solver.name:
+                pred = {**pred, **self.solver({**m_data, **pred})}
+            return pred
+
+        if self.conf.batch_triplets:
+            B = data["image1"].shape[0]
+            # stack on batch dimension
+            m_data = stack_twoviews(data)
+            m_pred = stack_twoviews(pred)
+
+            # forward pass
+            m_pred = predict_twoview(m_pred, m_data)
+
+            # unstack
+            pred = {**pred, **unstack_twoviews(m_pred, B)}
+        else:
+            for idx in ["0to1", "0to2", "1to2"]:
+                m_data = get_twoview(data, idx)
+                m_pred = get_twoview(pred, idx)
+                pred[idx] = predict_twoview(m_pred, m_data)
+        return pred
+
+    def loss(self, pred, data):
+        if not has_triplet(data):
+            return super().loss(pred, data)
+        if self.conf.batch_triplets:
+            m_data = stack_twoviews(data)
+            m_pred = stack_twoviews(pred)
+            losses, metrics = super().loss(m_pred, m_data)
+        else:
+            losses = {}
+            metrics = {}
+            for idx in ["0to1", "0to2", "1to2"]:
+                data_i = get_twoview(data, idx)
+                pred_i = pred[idx]
+                losses_i, metrics_i = super().loss(pred_i, data_i)
+                for k, v in losses_i.items():
+                    if k in losses.keys():
+                        losses[k] = losses[k] + v
+                    else:
+                        losses[k] = v
+                for k, v in metrics_i.items():
+                    if k in metrics.keys():
+                        metrics[k] = torch.cat([metrics[k], v], 0)
+                    else:
+                        metrics[k] = v
+
+        return losses, metrics

vismatch/third_party/gim/gluefactory/models/two_view_pipeline.py

@@ -0,0 +1,114 @@
+"""
+A two-view sparse feature matching pipeline.
+
+This model contains sub-models for each step:
+    feature extraction, feature matching, outlier filtering, pose estimation.
+Each step is optional, and the features or matches can be provided as input.
+Default: SuperPoint with nearest neighbor matching.
+
+Convention for the matches: m0[i] is the index of the keypoint in image 1
+that corresponds to the keypoint i in image 0. m0[i] = -1 if i is unmatched.
+"""
+
+from omegaconf import OmegaConf
+
+from . import get_model
+from .base_model import BaseModel
+
+to_ctr = OmegaConf.to_container  # convert DictConfig to dict
+
+
+class TwoViewPipeline(BaseModel):
+    default_conf = {
+        "extractor": {
+            "name": None,
+            "trainable": False,
+        },
+        "matcher": {"name": None},
+        "filter": {"name": None},
+        "solver": {"name": None},
+        "ground_truth": {"name": None},
+        "allow_no_extract": False,
+        "run_gt_in_forward": False,
+    }
+    required_data_keys = ["view0", "view1"]
+    strict_conf = False  # need to pass new confs to children models
+    components = [
+        "extractor",
+        "matcher",
+        "filter",
+        "solver",
+        "ground_truth",
+    ]
+
+    def _init(self, conf):
+        if conf.extractor.name:
+            self.extractor = get_model(conf.extractor.name)(to_ctr(conf.extractor))
+
+        if conf.matcher.name:
+            self.matcher = get_model(conf.matcher.name)(to_ctr(conf.matcher))
+
+        if conf.filter.name:
+            self.filter = get_model(conf.filter.name)(to_ctr(conf.filter))
+
+        if conf.solver.name:
+            self.solver = get_model(conf.solver.name)(to_ctr(conf.solver))
+
+        if conf.ground_truth.name:
+            self.ground_truth = get_model(conf.ground_truth.name)(
+                to_ctr(conf.ground_truth)
+            )
+
+    def extract_view(self, data, i):
+        data_i = data[f"view{i}"]
+        pred_i = data_i.get("cache", {})
+        skip_extract = len(pred_i) > 0 and self.conf.allow_no_extract
+        if self.conf.extractor.name and not skip_extract:
+            pred_i = {**pred_i, **self.extractor(data_i)}
+        elif self.conf.extractor.name and not self.conf.allow_no_extract:
+            pred_i = {**pred_i, **self.extractor({**data_i, **pred_i})}
+        return pred_i
+
+    def _forward(self, data):
+        pred0 = self.extract_view(data, "0")
+        pred1 = self.extract_view(data, "1")
+        pred = {
+            **{k + "0": v for k, v in pred0.items()},
+            **{k + "1": v for k, v in pred1.items()},
+        }
+
+        if self.conf.matcher.name:
+            pred = {**pred, **self.matcher({**data, **pred})}
+        if self.conf.filter.name:
+            pred = {**pred, **self.filter({**data, **pred})}
+        if self.conf.solver.name:
+            pred = {**pred, **self.solver({**data, **pred})}
+
+        if self.conf.ground_truth.name and self.conf.run_gt_in_forward:
+            gt_pred = self.ground_truth({**data, **pred})
+            pred.update({f"gt_{k}": v for k, v in gt_pred.items()})
+        return pred
+
+    def loss(self, pred, data):
+        losses = {}
+        metrics = {}
+        total = 0
+
+        # get labels
+        if self.conf.ground_truth.name and not self.conf.run_gt_in_forward:
+            gt_pred = self.ground_truth({**data, **pred})
+            pred.update({f"gt_{k}": v for k, v in gt_pred.items()})
+
+        for k in self.components:
+            apply = True
+            if "apply_loss" in self.conf[k].keys():
+                apply = self.conf[k].apply_loss
+            if self.conf[k].name and apply:
+                try:
+                    losses_, metrics_ = getattr(self, k).loss(pred, {**pred, **data})
+                except NotImplementedError:
+                    continue
+                losses = {**losses, **losses_}
+                metrics = {**metrics, **metrics_}
+                total = losses_["total"] + total
+        return {**losses, "total": total}, metrics

vismatch/third_party/gim/gluefactory/models/utils/losses.py

@@ -0,0 +1,73 @@
+import torch
+import torch.nn as nn
+from omegaconf import OmegaConf
+
+
+def weight_loss(log_assignment, weights, gamma=0.0):
+    b, m, n = log_assignment.shape
+    m -= 1
+    n -= 1
+
+    loss_sc = log_assignment * weights
+
+    num_neg0 = weights[:, :m, -1].sum(-1).clamp(min=1.0)
+    num_neg1 = weights[:, -1, :n].sum(-1).clamp(min=1.0)
+    num_pos = weights[:, :m, :n].sum((-1, -2)).clamp(min=1.0)
+
+    nll_pos = -loss_sc[:, :m, :n].sum((-1, -2))
+    nll_pos /= num_pos.clamp(min=1.0)
+
+    nll_neg0 = -loss_sc[:, :m, -1].sum(-1)
+    nll_neg1 = -loss_sc[:, -1, :n].sum(-1)
+
+    nll_neg = (nll_neg0 + nll_neg1) / (num_neg0 + num_neg1)
+
+    return nll_pos, nll_neg, num_pos, (num_neg0 + num_neg1) / 2.0
+
+
+class NLLLoss(nn.Module):
+    default_conf = {
+        "nll_balancing": 0.5,
+        "gamma_f": 0.0,  # focal loss
+    }
+
+    def __init__(self, conf):
+        super().__init__()
+        self.conf = OmegaConf.merge(self.default_conf, conf)
+        self.loss_fn = self.nll_loss
+
+    def forward(self, pred, data, weights=None):
+        log_assignment = pred["log_assignment"]
+        if weights is None:
+            weights = self.loss_fn(log_assignment, data)
+        nll_pos, nll_neg, num_pos, num_neg = weight_loss(
+            log_assignment, weights, gamma=self.conf.gamma_f
+        )
+        nll = (
+            self.conf.nll_balancing * nll_pos + (1 - self.conf.nll_balancing) * nll_neg
+        )
+
+        return (
+            nll,
+            weights,
+            {
+                "assignment_nll": nll,
+                "nll_pos": nll_pos,
+                "nll_neg": nll_neg,
+                "num_matchable": num_pos,
+                "num_unmatchable": num_neg,
+            },
+        )
+
+    def nll_loss(self, log_assignment, data):
+        m, n = data["gt_matches0"].size(-1), data["gt_matches1"].size(-1)
+        positive = data["gt_assignment"].float()
+        neg0 = (data["gt_matches0"] == -1).float()
+        neg1 = (data["gt_matches1"] == -1).float()
+
+        weights = torch.zeros_like(log_assignment)
+        weights[:, :m, :n] = positive
+
+        weights[:, :m, -1] = neg0
+        weights[:, -1, :n] = neg1
+        return weights

vismatch/third_party/gim/gluefactory/models/utils/metrics.py

@@ -0,0 +1,50 @@
+import torch
+
+
+@torch.no_grad()
+def matcher_metrics(pred, data, prefix="", prefix_gt=None):
+    def recall(m, gt_m):
+        mask = (gt_m > -1).float()
+        return ((m == gt_m) * mask).sum(1) / (1e-8 + mask.sum(1))
+
+    def accuracy(m, gt_m):
+        mask = (gt_m >= -1).float()
+        return ((m == gt_m) * mask).sum(1) / (1e-8 + mask.sum(1))
+
+    def precision(m, gt_m):
+        mask = ((m > -1) & (gt_m >= -1)).float()
+        return ((m == gt_m) * mask).sum(1) / (1e-8 + mask.sum(1))
+
+    def ranking_ap(m, gt_m, scores):
+        p_mask = ((m > -1) & (gt_m >= -1)).float()
+        r_mask = (gt_m > -1).float()
+        sort_ind = torch.argsort(-scores)
+        sorted_p_mask = torch.gather(p_mask, -1, sort_ind)
+        sorted_r_mask = torch.gather(r_mask, -1, sort_ind)
+        sorted_tp = torch.gather(m == gt_m, -1, sort_ind)
+        p_pts = torch.cumsum(sorted_tp * sorted_p_mask, -1) / (
+            1e-8 + torch.cumsum(sorted_p_mask, -1)
+        )
+        r_pts = torch.cumsum(sorted_tp * sorted_r_mask, -1) / (
+            1e-8 + sorted_r_mask.sum(-1)[:, None]
+        )
+        r_pts_diff = r_pts[..., 1:] - r_pts[..., :-1]
+        return torch.sum(r_pts_diff * p_pts[:, None, -1], dim=-1)
+
+    if prefix_gt is None:
+        prefix_gt = prefix
+    rec = recall(pred[f"{prefix}matches0"], data[f"gt_{prefix_gt}matches0"])
+    prec = precision(pred[f"{prefix}matches0"], data[f"gt_{prefix_gt}matches0"])
+    acc = accuracy(pred[f"{prefix}matches0"], data[f"gt_{prefix_gt}matches0"])
+    ap = ranking_ap(
+        pred[f"{prefix}matches0"],
+        data[f"gt_{prefix_gt}matches0"],
+        pred[f"{prefix}matching_scores0"],
+    )
+    metrics = {
+        f"{prefix}match_recall": rec,
+        f"{prefix}match_precision": prec,
+        f"{prefix}accuracy": acc,
+        f"{prefix}average_precision": ap,
+    }
+    return metrics

vismatch/third_party/gim/gluefactory/models/utils/misc.py

@@ -0,0 +1,70 @@
+import math
+from typing import List, Optional, Tuple
+
+import torch
+
+
+def to_sequence(map):
+    return map.flatten(-2).transpose(-1, -2)
+
+
+def to_map(sequence):
+    n = sequence.shape[-2]
+    e = math.isqrt(n)
+    assert e * e == n
+    assert e * e == n
+    sequence.transpose(-1, -2).unflatten(-1, [e, e])
+
+
+def pad_to_length(
+    x,
+    length: int,
+    pad_dim: int = -2,
+    mode: str = "zeros",  # zeros, ones, random, random_c
+    bounds: Tuple[int] = (None, None),
+):
+    shape = list(x.shape)
+    d = x.shape[pad_dim]
+    assert d <= length
+    if d == length:
+        return x
+    shape[pad_dim] = length - d
+
+    low, high = bounds
+
+    if mode == "zeros":
+        xn = torch.zeros(*shape, device=x.device, dtype=x.dtype)
+    elif mode == "ones":
+        xn = torch.ones(*shape, device=x.device, dtype=x.dtype)
+    elif mode == "random":
+        low = low if low is not None else x.min()
+        high = high if high is not None else x.max()
+        xn = torch.empty(*shape, device=x.device).uniform_(low, high)
+    elif mode == "random_c":
+        low, high = bounds  # we use the bounds as fallback for empty seq.
+        xn = torch.cat(
+            [
+                torch.empty(*shape[:-1], 1, device=x.device).uniform_(
+                    x[..., i].min() if d > 0 else low,
+                    x[..., i].max() if d > 0 else high,
+                )
+                for i in range(shape[-1])
+            ],
+            dim=-1,
+        )
+    else:
+        raise ValueError(mode)
+    return torch.cat([x, xn], dim=pad_dim)
+
+
+def pad_and_stack(
+    sequences: List[torch.Tensor],
+    length: Optional[int] = None,
+    pad_dim: int = -2,
+    **kwargs,
+):
+    if length is None:
+        length = max([x.shape[pad_dim] for x in sequences])
+
+    y = torch.stack([pad_to_length(x, length, pad_dim, **kwargs) for x in sequences], 0)
+    return y

vismatch/third_party/gim/gluefactory/robust_estimators/__init__.py

@@ -0,0 +1,15 @@
+import inspect
+
+from .base_estimator import BaseEstimator
+
+
+def load_estimator(type, estimator):
+    module_path = f"{__name__}.{type}.{estimator}"
+    module = __import__(module_path, fromlist=[""])
+    classes = inspect.getmembers(module, inspect.isclass)
+    # Filter classes defined in the module
+    classes = [c for c in classes if c[1].__module__ == module_path]
+    # Filter classes inherited from BaseModel
+    classes = [c for c in classes if issubclass(c[1], BaseEstimator)]
+    assert len(classes) == 1, classes
+    return classes[0][1]

vismatch/third_party/gim/gluefactory/robust_estimators/base_estimator.py

@@ -0,0 +1,33 @@
+from copy import copy
+
+from omegaconf import OmegaConf
+
+
+class BaseEstimator:
+    base_default_conf = {
+        "name": "???",
+        "ransac_th": "???",
+    }
+    test_thresholds = [1.0]
+    required_data_keys = []
+
+    strict_conf = False
+
+    def __init__(self, conf):
+        """Perform some logic and call the _init method of the child model."""
+        default_conf = OmegaConf.merge(
+            self.base_default_conf, OmegaConf.create(self.default_conf)
+        )
+        if self.strict_conf:
+            OmegaConf.set_struct(default_conf, True)
+
+        if isinstance(conf, dict):
+            conf = OmegaConf.create(conf)
+        self.conf = conf = OmegaConf.merge(default_conf, conf)
+        OmegaConf.set_readonly(conf, True)
+        OmegaConf.set_struct(conf, True)
+        self.required_data_keys = copy(self.required_data_keys)
+        self._init(conf)
+
+    def __call__(self, data):
+        return self._forward(data)

vismatch/third_party/gim/gluefactory/robust_estimators/homography/homography_est.py

@@ -0,0 +1,74 @@
+import numpy as np
+import torch
+from homography_est import (
+    LineSegment,
+    ransac_line_homography,
+    ransac_point_homography,
+    ransac_point_line_homography,
+)
+
+from ...utils.tensor import batch_to_numpy
+from ..base_estimator import BaseEstimator
+
+
+def H_estimation_hybrid(kpts0=None, kpts1=None, lines0=None, lines1=None, tol_px=5):
+    """Estimate a homography from points and lines with hybrid RANSAC.
+    All features are expected in x-y convention
+    """
+    # Check that we have at least 4 features
+    n_features = 0
+    if kpts0 is not None:
+        n_features += len(kpts0) + len(kpts1)
+    if lines0 is not None:
+        n_features += len(lines0) + len(lines1)
+    if n_features < 4:
+        return None
+
+    if lines0 is None:
+        # Point-only RANSAC
+        H = ransac_point_homography(kpts0, kpts1, tol_px, False, [])
+    elif kpts0 is None:
+        # Line-only RANSAC
+        ls0 = [LineSegment(line[0], line[1]) for line in lines0]
+        ls1 = [LineSegment(line[0], line[1]) for line in lines1]
+        H = ransac_line_homography(ls0, ls1, tol_px, False, [])
+    else:
+        # Point-lines RANSAC
+        ls0 = [LineSegment(line[0], line[1]) for line in lines0]
+        ls1 = [LineSegment(line[0], line[1]) for line in lines1]
+        H = ransac_point_line_homography(kpts0, kpts1, ls0, ls1, tol_px, False, [], [])
+    if np.abs(H[-1, -1]) > 1e-8:
+        H /= H[-1, -1]
+    return H
+
+
+class PointLineHomographyEstimator(BaseEstimator):
+    default_conf = {"ransac_th": 2.0, "options": {}}
+
+    required_data_keys = ["m_kpts0", "m_kpts1", "m_lines0", "m_lines1"]
+
+    def _init(self, conf):
+        pass
+
+    def _forward(self, data):
+        feat = data["m_kpts0"] if "m_kpts0" in data else data["m_lines0"]
+        data = batch_to_numpy(data)
+        m_features = {
+            "kpts0": data["m_kpts1"] if "m_kpts1" in data else None,
+            "kpts1": data["m_kpts0"] if "m_kpts0" in data else None,
+            "lines0": data["m_lines1"] if "m_lines1" in data else None,
+            "lines1": data["m_lines0"] if "m_lines0" in data else None,
+        }
+        M = H_estimation_hybrid(**m_features, tol_px=self.conf.ransac_th)
+        success = M is not None
+        if not success:
+            M = torch.eye(3, device=feat.device, dtype=feat.dtype)
+        else:
+            M = torch.from_numpy(M).to(feat)
+
+        estimation = {
+            "success": success,
+            "M_0to1": M,
+        }
+
+        return estimation

vismatch/third_party/gim/gluefactory/robust_estimators/homography/opencv.py

@@ -0,0 +1,53 @@
+import cv2
+import torch
+
+from ..base_estimator import BaseEstimator
+
+
+class OpenCVHomographyEstimator(BaseEstimator):
+    default_conf = {
+        "ransac_th": 3.0,
+        "options": {"method": "ransac", "max_iters": 3000, "confidence": 0.995},
+    }
+
+    required_data_keys = ["m_kpts0", "m_kpts1"]
+
+    def _init(self, conf):
+        self.solver = {
+            "ransac": cv2.RANSAC,
+            "lmeds": cv2.LMEDS,
+            "rho": cv2.RHO,
+            "usac": cv2.USAC_DEFAULT,
+            "usac_fast": cv2.USAC_FAST,
+            "usac_accurate": cv2.USAC_ACCURATE,
+            "usac_prosac": cv2.USAC_PROSAC,
+            "usac_magsac": cv2.USAC_MAGSAC,
+        }[conf.options.method]
+
+    def _forward(self, data):
+        pts0, pts1 = data["m_kpts0"], data["m_kpts1"]
+
+        try:
+            M, mask = cv2.findHomography(
+                pts0.numpy(),
+                pts1.numpy(),
+                self.solver,
+                self.conf.ransac_th,
+                maxIters=self.conf.options.max_iters,
+                confidence=self.conf.options.confidence,
+            )
+            success = M is not None
+        except cv2.error:
+            success = False
+        if not success:
+            M = torch.eye(3, device=pts0.device, dtype=pts0.dtype)
+            inl = torch.zeros_like(pts0[:, 0]).bool()
+        else:
+            M = torch.tensor(M).to(pts0)
+            inl = torch.tensor(mask).bool().to(pts0.device)
+
+        return {
+            "success": success,
+            "M_0to1": M,
+            "inliers": inl,
+        }