π Geometric Computer Vision Library for Spatial AI
Python artificial-intelligencecomputer-visiondeep-learninghacktoberfestimage-processingmachine-learningneural-networkpythonpytorchroboticsspatial-ai
# LICENSE HEADER MANAGED BY add-license-header
#
# Copyright 2018 Kornia Team
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
"""ONNX export survey cases for kornia.feature (survey v2)."""
from __future__ import annotations
import sys
import traceback
import torch
import torch.nn.functional as F
from harness import case, err_str, run_cases
import kornia.feature as KF
torch.manual_seed(0)
# ----------------------------------------------------------------------------- shared inputs
IMG = torch.rand(1, 1, 32, 40) # gray
IMG3 = torch.rand(1, 3, 32, 40)
IMG_BIG = torch.rand(1, 1, 64, 80) # detectors need a pyramid
IMG3_BIG = torch.rand(1, 3, 64, 80)
IMG3_96 = torch.rand(1, 3, 64, 96) # divisible by 16 and 32 (DISK / XFeat)
IMG3_DEDODE = torch.rand(1, 3, 56, 84) # divisible by 14
# 8-pixel checkerboard: strong corners, so the Harris response (~1e-3 on noise) is large against the default atol
IMG_CORNERS = ((torch.arange(32)[:, None] // 8 + torch.arange(40)[None, :] // 8) % 2).float()[None, None]
PATCH32 = torch.rand(2, 1, 32, 32)
PATCH41 = torch.rand(2, 1, 41, 41)
PATCH19 = torch.rand(2, 1, 19, 19)
def make_lafs(B: int = 1, N: int = 5, H: int = 32, W: int = 40, scale: float = 4.0, seed: int = 0) -> torch.Tensor:
g = torch.Generator().manual_seed(seed)
xy = torch.stack([torch.rand(B, N, generator=g) * (W - 16) + 8, torch.rand(B, N, generator=g) * (H - 16) + 8], -1)
sc = torch.full((B, N, 1, 1), scale) * (0.75 + 0.5 * torch.rand(B, N, 1, 1, generator=g))
ori = torch.rand(B, N, 1, generator=g) * 360.0 - 180.0
return KF.laf_from_center_scale_ori(xy, sc, ori)
LAF = make_lafs() # (1, 5, 2, 3) inside 32x40
LAF_BIG = make_lafs(1, 8, 64, 80, 6.0, seed=1)
XY = LAF[..., :, 2].clone() # (1, 5, 2)
SCALE = KF.get_laf_scale(LAF) # (1, 5, 1, 1)
ORI = KF.get_laf_orientation(LAF) # (1, 5, 1)
ANGLES = torch.rand(1, 5, 1) * 90.0
# ellipse (x, y, a, b, c) with [a b; b c] positive definite
_s = torch.tensor([1 / 16.0, 1 / 25.0, 1 / 9.0, 1 / 20.0, 1 / 12.0])
ELLS = torch.stack([XY[0, :, 0], XY[0, :, 1], _s, 0.1 * _s, 1.3 * _s], -1)[None] # (1, 5, 5)
H_01 = torch.tensor([[[1.02, 0.05, 1.5], [-0.03, 0.98, -1.0], [1e-4, -2e-4, 1.0]]]) # (1, 3, 3)
# descriptors: desc2 = perturbed desc1 (+ 2 distractors) so mutual/ratio tests actually match
_g = torch.Generator().manual_seed(3)
DESC1 = F.normalize(torch.randn(10, 128, generator=_g), dim=1)
DESC2 = torch.cat([DESC1 + 0.05 * torch.randn(10, 128, generator=_g), torch.randn(2, 128, generator=_g)])
DESC2 = F.normalize(DESC2[torch.randperm(12, generator=_g)], dim=1)
LAFS1 = make_lafs(1, 10, 64, 80, 5.0, seed=5)
LAFS2 = make_lafs(1, 12, 64, 80, 5.0, seed=6)
KPTS0 = KF.get_laf_center(LAFS1) # (1, 10, 2)
KPTS1 = KF.get_laf_center(LAFS2) # (1, 12, 2)
IMG_SIZE = torch.tensor([[80.0, 64.0]]) # (1, 2) as (W, H)
class DictPair(torch.nn.Module):
"""Wrap a model taking {"image0", "image1"} so the model is a registered submodule (torch.export requirement)."""
def __init__(self, m):
super().__init__()
self.m = m
def forward(self, a, b):
return self.m({"image0": a, "image1": b})
class LGWrap(torch.nn.Module):
def __init__(self, m):
super().__init__()
self.m = m
def forward(self, k0, d0, k1, d1, s):
return self.m(
{
"image0": {"keypoints": k0, "descriptors": d0, "image_size": s},
"image1": {"keypoints": k1, "descriptors": d1, "image_size": s},
}
)
class DISKWrap(torch.nn.Module):
def __init__(self, m, **kw):
super().__init__()
self.m = m
self.kw = kw
def forward(self, im):
feats = self.m(im, **self.kw)
return tuple(t for f in feats for t in (f.keypoints, f.descriptors, f.detection_scores))
class ALIKEDWrap(torch.nn.Module):
def __init__(self, m):
super().__init__()
self.m = m
def forward(self, im):
feats = self.m(im)
return tuple(t for f in feats for t in (f.keypoints, f.descriptors, f.keypoint_scores))
def try_build(name: str, fn):
"""Construct a pretrained model; return (model, None) or (None, reason)."""
try:
return fn(), None
except Exception as e:
traceback.print_exc()
# the root cause: a loader that tries several sources reports the last one's error only as its cause
return None, f"could not build/download {name}: {err_str(e)}"
def pcase(name, group, builder, inputs, kwargs=None, **kw):
"""Case whose target is a pretrained model built lazily; skip with the download error if it fails."""
target, reason = try_build(name, builder)
if target is None:
return case(name, group, None, inputs, kwargs, skip=reason, **kw)
return case(name, group, target, inputs, kwargs, **kw)
CASES: list = []
# ----------------------------------------------------------------------------- responses
R = "feature.responses"
CASES += [
case("feature.harris_response", R, KF.harris_response, [IMG_CORNERS]),
case("feature.harris_response[sigmas]", R, KF.harris_response, [IMG, torch.tensor([1.5])], note="sigmas (B,) live"),
case("feature.harris_response[diff]", R, KF.harris_response, [IMG], {"grads_mode": "diff"}),
case("feature.gftt_response", R, KF.gftt_response, [IMG]),
case("feature.hessian_response", R, KF.hessian_response, [IMG]),
case(
"feature.dog_response",
R,
KF.dog_response,
[torch.rand(1, 1, 4, 32, 40)],
note="input is (B, C, L, H, W) scale levels",
tags=("3d",),
),
case("feature.dog_response_single", R, KF.dog_response_single, [IMG], {"sigma1": 1.0, "sigma2": 1.6}),
case("feature.CornerHarris", R, KF.CornerHarris(0.04), [IMG_CORNERS]),
case("feature.CornerGFTT", R, KF.CornerGFTT(), [IMG]),
case("feature.BlobHessian", R, KF.BlobHessian(), [IMG]),
case(
"feature.BlobDoG",
R,
KF.BlobDoG(),
[torch.rand(1, 1, 4, 32, 40)],
tags=("3d",),
note="docstring says (B,C,H,W) but dog_response requires 5-D",
),
case("feature.BlobDoGSingle", R, KF.BlobDoGSingle(), [IMG]),
case("feature.BlobHessian[batch2,rgb]", R, KF.BlobHessian(), [torch.rand(2, 3, 32, 40)], tags=("batch>1",)),
]
# ----------------------------------------------------------------------------- laf.py
L = "feature.laf"
CASES += [
case("feature.laf_from_center_scale_ori", L, KF.laf_from_center_scale_ori, [XY, SCALE, ORI]),
case("feature.laf_from_center_scale_ori[xy-only]", L, KF.laf_from_center_scale_ori, [XY], note="scale/ori default"),
case("feature.get_laf_scale", L, KF.get_laf_scale, [LAF]),
case("feature.get_laf_center", L, KF.get_laf_center, [LAF]),
case("feature.get_laf_orientation", L, KF.get_laf_orientation, [LAF]),
case("feature.set_laf_orientation", L, KF.set_laf_orientation, [LAF, ANGLES]),
case("feature.rotate_laf", L, KF.rotate_laf, [LAF, ANGLES]),
case("feature.scale_laf", L, KF.scale_laf, [LAF], {"scale_coef": 2.0}, note="scale_coef float baked"),
case(
"feature.scale_laf[tensor]",
L,
KF.scale_laf,
[LAF, torch.rand(1, 5, 1, 1) + 0.5],
note="scale_coef (B,N,1,1) live",
),
case("feature.make_upright", L, KF.make_upright, [LAF]),
case("feature.ellipse_to_laf", L, KF.ellipse_to_laf, [ELLS]),
case("feature.laf_to_boundary_points", L, KF.laf_to_boundary_points, [LAF], {"n_pts": 12}, note="n_pts baked"),
case(
"feature.get_laf_pts_to_draw",
L,
KF.laf.get_laf_pts_to_draw,
[LAF],
{"img_idx": 0},
note="returns two Python lists -> not exportable by design",
),
case("feature.denormalize_laf", L, KF.denormalize_laf, [KF.normalize_laf(LAF, IMG), IMG]),
case("feature.normalize_laf", L, KF.normalize_laf, [LAF, IMG]),
case(
"feature.laf.generate_patch_grid_from_normalized_LAF",
L,
KF.laf.generate_patch_grid_from_normalized_LAF,
[IMG, KF.normalize_laf(LAF, IMG)],
{"PS": 16},
note="PS baked",
),
case("feature.extract_patches_simple", L, KF.extract_patches_simple, [IMG, LAF], {"PS": 16}, note="PS baked"),
case(
"feature.extract_patches_simple[rgb,batch2]",
L,
KF.extract_patches_simple,
[torch.rand(2, 3, 32, 40), make_lafs(2, 5)],
{"PS": 16},
tags=("batch>1",),
),
case(
"feature.extract_patches_from_pyramid",
L,
KF.extract_patches_from_pyramid,
[IMG_BIG, LAF_BIG],
{"PS": 16},
note="PS baked",
),
case(
"feature.laf_is_valid",
L,
KF.laf_is_valid,
[LAF * torch.tensor([1.0, 1.0, 0.0, 1.0, 0.0])[None, :, None, None]],
note="bool (B,N) output; LAFs 2 and 4 zeroed, so invalid",
),
case(
"feature.laf_is_inside_image",
L,
KF.laf_is_inside_image,
[torch.cat([LAF, LAF_BIG], 1), IMG],
{"border": 2},
note="bool output; the LAFs placed in 64x80 fall outside the 32x40 image",
),
case("feature.laf_to_three_points", L, KF.laf_to_three_points, [LAF]),
case("feature.laf_from_three_points", L, KF.laf_from_three_points, [KF.laf_to_three_points(LAF)]),
case("feature.perspective_transform_lafs", L, KF.perspective_transform_lafs, [H_01, LAF]),
case("feature.KORNIA_CHECK_LAF", L, KF.KORNIA_CHECK_LAF, [LAF], note="validation helper; returns bool/None"),
]
# ----------------------------------------------------------------------------- orientation / affine shape
O = "feature.orientation_affine"
CASES += [
case("feature.PassLAF", O, KF.PassLAF(), [LAF, IMG]),
case("feature.PatchDominantGradientOrientation", O, KF.PatchDominantGradientOrientation(32), [PATCH32]),
pcase(
"feature.OriNet",
O,
lambda: KF.OriNet(pretrained=True),
[PATCH32],
tags=("model", "pretrained"),
note="weights: OriNet.pth",
),
case("feature.LAFOrienter", O, KF.LAFOrienter(19), [LAF_BIG, IMG_BIG], note="patch_size=19 (default PDGO)"),
pcase(
"feature.LAFOrienter[OriNet]",
O,
lambda: KF.LAFOrienter(32, angle_detector=KF.OriNet(pretrained=True)),
[LAF_BIG, IMG_BIG],
tags=("model", "pretrained"),
),
case("feature.PatchAffineShapeEstimator", O, KF.PatchAffineShapeEstimator(19), [PATCH19]),
case("feature.LAFAffineShapeEstimator", O, KF.LAFAffineShapeEstimator(19), [LAF_BIG, IMG_BIG]),
pcase(
"feature.LAFAffNetShapeEstimator",
O,
lambda: KF.LAFAffNetShapeEstimator(pretrained=True),
[LAF_BIG, IMG_BIG],
tags=("model", "pretrained"),
note="weights: AffNet.pth",
),
]
# ----------------------------------------------------------------------------- descriptors
D = "feature.descriptors"
CASES += [
case("feature.SIFTDescriptor", D, KF.SIFTDescriptor(41), [PATCH41], note="patch_size=41 default; rootsift"),
case("feature.SIFTDescriptor[32,no-rootsift]", D, KF.SIFTDescriptor(32, rootsift=False), [PATCH32]),
case("feature.siftdesc.sift_describe", D, KF.siftdesc.sift_describe, [PATCH32], {"patch_size": 32}),
case(
"feature.siftdesc.get_sift_pooling_kernel",
D,
lambda d: KF.siftdesc.get_sift_pooling_kernel(25).to(d.device),
[torch.zeros(1)],
note="ksize baked; fully constant graph",
),
case("feature.DenseSIFTDescriptor", D, KF.DenseSIFTDescriptor(), [IMG]),
pcase(
"feature.MKDDescriptor",
D,
lambda: KF.MKDDescriptor(patch_size=32),
[PATCH32],
tags=("pretrained",),
note="whitening weights mkd-concat-64.pth; patch_size=32",
),
pcase("feature.MKDDescriptor[no-whitening]", D, lambda: KF.MKDDescriptor(patch_size=32, whitening=None), [PATCH32]),
pcase(
"feature.HardNet",
D,
lambda: KF.HardNet(pretrained=True),
[PATCH32],
tags=("model", "pretrained"),
note="weights: checkpoint_liberty_with_aug.pth",
),
pcase(
"feature.HardNet8",
D,
lambda: KF.HardNet8(pretrained=True),
[PATCH32],
tags=("model", "pretrained"),
note="weights: hardnet8v2.pt",
),
pcase(
"feature.HyNet",
D,
lambda: KF.HyNet(pretrained=True),
[PATCH32],
tags=("model", "pretrained"),
note="weights: HyNet_LIB.pth",
),
pcase(
"feature.TFeat",
D,
lambda: KF.TFeat(pretrained=True),
[PATCH32],
tags=("model", "pretrained"),
note="weights: tfeat-liberty.params",
),
pcase(
"feature.SOSNet",
D,
lambda: KF.SOSNet(pretrained=True),
[PATCH32],
tags=("model", "pretrained"),
note="weights: sosnet_32x32_liberty.pth",
),
case("feature.FilterResponseNorm2d", D, KF.FilterResponseNorm2d(8), [torch.rand(1, 8, 16, 20)]),
case("feature.TLU", D, KF.TLU(8), [torch.rand(1, 8, 16, 20)]),
pcase(
"feature.LAFDescriptor",
D,
lambda: KF.LAFDescriptor(KF.HardNet(pretrained=True), patch_size=32),
[IMG_BIG, LAF_BIG],
tags=("model", "pretrained"),
),
case(
"feature.LAFDescriptor[SIFT,rgb]",
D,
KF.LAFDescriptor(KF.SIFTDescriptor(32), patch_size=32),
[IMG3_BIG, LAF_BIG],
note="grayscale_descriptor=True converts rgb",
),
case(
"feature.get_laf_descriptors",
D,
KF.get_laf_descriptors,
[IMG_BIG, LAF_BIG],
{"patch_descriptor": KF.SIFTDescriptor(32), "patch_size": 32},
),
case(
"feature.steerers.DiscreteSteerer",
D,
KF.steerers.DiscreteSteerer(torch.linalg.qr(torch.randn(128, 128))[0]),
[DESC1],
),
case(
"feature.steerers.DiscreteSteerer.steer_descriptions",
D,
KF.steerers.DiscreteSteerer(torch.linalg.qr(torch.randn(128, 128))[0]),
[DESC1],
{"steerer_power": 3, "normalize": True},
method="steer_descriptions",
),
]
# ----------------------------------------------------------------------------- detectors / pipelines (classical)
T = "feature.detectors"
CASES += [
case(
"feature.ScaleSpaceDetector",
T,
KF.ScaleSpaceDetector(num_features=32),
[IMG_BIG],
note="num_features=32 baked; default ScalePyramid(3,1.6,15) + BlobHessian + ConvQuadInterp3d",
),
case(
"feature.ScaleSpaceDetector[mask]",
T,
KF.ScaleSpaceDetector(num_features=32),
[IMG_BIG, (torch.rand(1, 1, 64, 80) > 0.3).float()],
note="mask live",
),
case(
"feature.MultiResolutionDetector",
T,
KF.MultiResolutionDetector(KF.BlobHessian(), num_features=32),
[IMG_BIG],
note="BlobHessian response; num_features=32",
),
pcase(
"feature.KeyNet",
T,
lambda: KF.KeyNet(pretrained=True),
[IMG],
tags=("model", "pretrained"),
note="weights: keynet_pytorch.pth; dense response map",
),
pcase(
"feature.KeyNetDetector",
T,
lambda: KF.KeyNetDetector(pretrained=True, num_features=32),
[IMG_BIG],
tags=("model", "pretrained"),
),
case("feature.SIFTFeature", T, KF.SIFTFeature(num_features=32), [IMG_BIG], note="num_features=32"),
case(
"feature.SIFTFeature[upright]",
T,
KF.SIFTFeature(num_features=32, upright=True),
[IMG_BIG],
note="RGB input is rejected eagerly ('model must return one response map'); gray only",
),
case("feature.SIFTFeatureScaleSpace", T, KF.SIFTFeatureScaleSpace(num_features=32), [IMG_BIG]),
pcase(
"feature.GFTTAffNetHardNet",
T,
lambda: KF.GFTTAffNetHardNet(num_features=32),
[IMG_BIG],
tags=("model", "pretrained"),
),
pcase(
"feature.HesAffNetHardNet",
T,
lambda: KF.HesAffNetHardNet(num_features=32),
[IMG_BIG],
tags=("model", "pretrained"),
),
pcase(
"feature.KeyNetHardNet", T, lambda: KF.KeyNetHardNet(num_features=32), [IMG_BIG], tags=("model", "pretrained")
),
pcase(
"feature.KeyNetAffNetHardNet",
T,
lambda: KF.KeyNetAffNetHardNet(num_features=32),
[IMG_BIG],
tags=("model", "pretrained"),
),
case(
"feature.LocalFeature",
T,
KF.LocalFeature(KF.ScaleSpaceDetector(num_features=32), KF.LAFDescriptor(KF.SIFTDescriptor(32), 32)),
[IMG_BIG],
note="ScaleSpaceDetector + SIFT",
),
]
# ----------------------------------------------------------------------------- deep detectors / describers
M = "feature.models"
_disk, _disk_err = try_build("DISK", lambda: KF.DISK.from_pretrained("depth"))
CASES += [
case(
"feature.DISK",
M,
DISKWrap(_disk, n=64, window_size=5) if _disk else None,
[IMG3_96],
skip=_disk_err,
tags=("model", "pretrained"),
note="weights depth-save.pth; n=64 top-k; H,W %16",
),
case(
"feature.DISK[n=None]",
M,
DISKWrap(_disk, n=None, window_size=5) if _disk else None,
[IMG3_96],
skip=_disk_err,
tags=("model", "pretrained"),
note="all NMS maxima (data-dependent count)",
),
case(
"feature.DISK.heatmap_and_dense_descriptors",
M,
_disk,
[IMG3_96],
skip=_disk_err,
method="heatmap_and_dense_descriptors",
tags=("model", "pretrained"),
note="dense head only",
),
]
_dedode, _dedode_err = try_build(
"DeDoDe", lambda: KF.DeDoDe.from_pretrained("L-upright", "B-upright", amp_dtype=torch.float32)
)
CASES += [
case(
"feature.DeDoDe",
M,
_dedode,
[IMG3_DEDODE],
{"n": 64},
skip=_dedode_err,
tags=("model", "pretrained"),
note="detector L-upright + descriptor B-upright (VGG19), float32; n=64",
),
case(
"feature.DeDoDe[no-imagenet-norm]",
M,
_dedode,
[IMG3_DEDODE],
{"n": 64, "apply_imagenet_normalization": False},
skip=_dedode_err,
tags=("model", "pretrained"),
note="bypasses kornia.enhance.Normalize ONNX guard",
),
case(
"feature.DeDoDe.detect",
M,
_dedode,
[IMG3_DEDODE],
{"n": 64},
skip=_dedode_err,
method="detect",
tags=("model", "pretrained"),
),
case(
"feature.DeDoDe.detect[no-imagenet-norm]",
M,
_dedode,
[IMG3_DEDODE],
{"n": 64, "apply_imagenet_normalization": False},
skip=_dedode_err,
method="detect",
tags=("model", "pretrained"),
),
case(
"feature.DeDoDe.describe",
M,
_dedode,
[IMG3_DEDODE, torch.rand(1, 64, 2) * 2 - 1],
skip=_dedode_err,
method="describe",
tags=("model", "pretrained"),
note="keypoints normalised [-1,1]",
),
case(
"feature.DeDoDe.describe[no-imagenet-norm]",
M,
_dedode,
[IMG3_DEDODE, torch.rand(1, 64, 2) * 2 - 1],
{"apply_imagenet_normalization": False},
skip=_dedode_err,
method="describe",
tags=("model", "pretrained"),
),
]
_aliked, _aliked_err = try_build("ALIKED", lambda: KF.ALIKED.from_pretrained("aliked-t16", max_num_keypoints=64))
CASES += [
case(
"feature.ALIKED",
M,
ALIKEDWrap(_aliked) if _aliked else None,
[IMG3_96],
skip=_aliked_err,
tags=("model", "pretrained"),
note="aliked-t16; max_num_keypoints=64",
),
case(
"feature.ALIKED.forward_laf",
M,
_aliked,
[IMG3_96],
skip=_aliked_err,
method="forward_laf",
tags=("model", "pretrained"),
),
case(
"feature.ALIKED.extract_dense_map",
M,
_aliked,
[IMG3_96],
skip=_aliked_err,
method="extract_dense_map",
tags=("model", "pretrained"),
note="dense backbone incl. deformable conv",
),
]
_xfeat, _xfeat_err = try_build("XFeat", lambda: KF.XFeat.from_pretrained(top_k=64))
CASES += [
case(
"feature.XFeatModel",
M,
_xfeat.net if _xfeat else None,
[IMG3_96],
skip=_xfeat_err,
tags=("model", "pretrained"),
note="dense backbone (feats, keypoints, heatmap); H,W %32",
),
case(
"feature.XFeat.detectAndCompute",
M,
_xfeat,
[IMG3_96],
skip=_xfeat_err,
method="detectAndCompute",
tags=("model", "pretrained"),
note="top_k=64",
),
case(
"feature.XFeat.detectAndComputeDense",
M,
_xfeat,
[IMG3_96],
{"multiscale": False},
skip=_xfeat_err,
method="detectAndComputeDense",
tags=("model", "pretrained"),
),
case(
"feature.XFeat.match_xfeat",
M,
_xfeat,
[IMG3_96, torch.rand(1, 3, 64, 96)],
skip=_xfeat_err,
method="match_xfeat",
tags=("model", "pretrained"),
),
case(
"feature.XFeat.match_xfeat_star",
M,
_xfeat,
[IMG3_96, torch.rand(1, 3, 64, 96)],
skip=_xfeat_err,
method="match_xfeat_star",
tags=("model", "pretrained"),
),
case(
"feature.InterpolateSparse2d",
M,
KF.InterpolateSparse2d("bicubic"),
[torch.rand(1, 8, 16, 20), torch.rand(1, 6, 2) * torch.tensor([19.0, 15.0])],
{"H": 16, "W": 20},
note="H,W baked",
),
]
_sold2d, _sold2d_err = try_build("SOLD2_detector", lambda: KF.SOLD2_detector(pretrained=True))
_sold2, _sold2_err = try_build("SOLD2", lambda: KF.SOLD2(pretrained=True))
CASES += [
case(
"feature.SOLD2_detector",
M,
_sold2d,
[IMG_BIG],
skip=_sold2d_err,
tags=("model", "pretrained"),
note="weights sold2_wireframe.pth; returns list of line segments + heatmaps",
),
case("feature.SOLD2", M, _sold2, [IMG_BIG], skip=_sold2_err, tags=("model", "pretrained")),
]
_defmo, _defmo_err = try_build("DeFMO", lambda: KF.DeFMO(pretrained=True))
CASES += [
case(
"feature.DeFMO",
M,
_defmo,
[torch.rand(1, 6, 64, 96)],
skip=_defmo_err,
tags=("model", "pretrained"),
note="weights encoder_best.pt + rendering_best.pt",
),
]
# ----------------------------------------------------------------------------- matchers
X = "feature.matching"
CASES += [
case("feature.match_nn", X, KF.match_nn, [DESC1, DESC2]),
case(
"feature.match_nn[dm]",
X,
KF.match_nn,
[DESC1, DESC2, torch.cdist(DESC1, DESC2)],
note="dm passed live (bypasses torch.cdist)",
),
case("feature.match_mnn", X, KF.match_mnn, [DESC1, DESC2]),
case("feature.match_mnn[dm]", X, KF.match_mnn, [DESC1, DESC2, torch.cdist(DESC1, DESC2)], note="dm passed live"),
case("feature.match_snn", X, KF.match_snn, [DESC1, DESC2], {"th": 0.8}),
case("feature.match_smnn", X, KF.match_smnn, [DESC1, DESC2], {"th": 0.8}),
case("feature.match_fginn", X, KF.match_fginn, [DESC1, DESC2, LAFS1, LAFS2], {"th": 0.8, "spatial_th": 10.0}),
case(
"feature.match_fginn[mutual]",
X,
KF.match_fginn,
[DESC1, DESC2, LAFS1, LAFS2],
{"th": 0.8, "spatial_th": 10.0, "mutual": True},
),
case(
"feature.match_adalam",
X,
KF.match_adalam,
[DESC1, DESC2, LAFS1, LAFS2],
{"hw1": (64, 80), "hw2": (64, 80)},
note="hw baked",
),
case("feature.DescriptorMatcher[nn]", X, KF.DescriptorMatcher("nn"), [DESC1, DESC2]),
case("feature.DescriptorMatcher[snn]", X, KF.DescriptorMatcher("snn", 0.8), [DESC1, DESC2]),
case("feature.DescriptorMatcher[smnn]", X, KF.DescriptorMatcher("smnn", 0.8), [DESC1, DESC2]),
case(
"feature.GeometryAwareDescriptorMatcher[fginn]",
X,
KF.GeometryAwareDescriptorMatcher("fginn"),
[DESC1, DESC2, LAFS1, LAFS2],
),
case(
"feature.GeometryAwareDescriptorMatcher[adalam]",
X,
KF.GeometryAwareDescriptorMatcher("adalam"),
[DESC1, DESC2, LAFS1, LAFS2],
),
case(
"feature.matching.DescriptorMatcherWithSteerer[global]",
X,
KF.matching.DescriptorMatcherWithSteerer(
KF.steerers.DiscreteSteerer(torch.linalg.qr(torch.randn(128, 128))[0]), 4, "global", "smnn", 0.98
),
[DESC1, DESC2],
{"normalize": True},
),
case(
"feature.matching.DescriptorMatcherWithSteerer[local]",
X,
KF.matching.DescriptorMatcherWithSteerer(
KF.steerers.DiscreteSteerer(torch.linalg.qr(torch.randn(128, 128))[0]), 4, "local", "smnn", 0.98
),
[DESC1, DESC2],
{"normalize": True},
),
]
_loftr, _loftr_err = try_build("LoFTR", lambda: KF.LoFTR(pretrained="outdoor"))
CASES += [
case(
"feature.LoFTR",
X,
DictPair(_loftr) if _loftr else None,
[IMG_BIG, torch.rand(1, 1, 64, 80)],
skip=_loftr_err,
tags=("model", "pretrained"),
note="weights loftr_outdoor.ckpt; gray 1x1x64x80 pair",
),
]
_lg, _lg_err = try_build("LightGlue", lambda: KF.LightGlue("disk").eval())
_lg_np, _lg_np_err = try_build(
"LightGlue[no-prune]", lambda: KF.LightGlue("disk", depth_confidence=-1, width_confidence=-1, flash=False).eval()
)
def _lg_call(m):
return lambda k0, d0, k1, d1, s: m(
{
"image0": {"keypoints": k0, "descriptors": d0, "image_size": s},
"image1": {"keypoints": k1, "descriptors": d1, "image_size": s},
}
)
CASES += [
case(
"feature.LightGlue",
X,
LGWrap(_lg) if _lg else None,
[KPTS0, DESC1[None], KPTS1, DESC2[None], IMG_SIZE],
skip=_lg_err,
tags=("model", "pretrained"),
note="disk weights; default conf (depth/width confidence early-exit)",
),
case(
"feature.LightGlue[no-prune]",
X,
LGWrap(_lg_np) if _lg_np else None,
[KPTS0, DESC1[None], KPTS1, DESC2[None], IMG_SIZE],
skip=_lg_np_err,
tags=("model", "pretrained"),
note="depth_confidence=-1, width_confidence=-1, flash=False",
),
]
_lgm, _lgm_err = try_build("LightGlueMatcher", lambda: KF.LightGlueMatcher("disk").eval())
CASES += [
case(
"feature.LightGlueMatcher",
X,
_lgm,
[DESC1, DESC2, LAFS1, LAFS2],
{"hw1": (64, 80), "hw2": (64, 80)},
skip=_lgm_err,
tags=("model", "pretrained"),
note="hw baked",
),
]
_lfm, _lfm_err = try_build(
"LocalFeatureMatcher",
lambda: KF.LocalFeatureMatcher(KF.SIFTFeature(num_features=32), KF.DescriptorMatcher("snn", 0.9)),
)
CASES += [
case(
"feature.LocalFeatureMatcher",
X,
DictPair(_lfm) if _lfm else None,
[IMG_BIG, torch.rand(1, 1, 64, 80)],
skip=_lfm_err,
note="SIFTFeature(32) + snn matcher; dict in/out",
),
case(
"feature.OnnxLightGlue",
X,
None,
[],
skip="already an onnxruntime wrapper (loads fabio-sim LightGlue-ONNX *_fused.onnx graphs); not a torch module",
),
case("feature.DISKFeatures", M, None, [], skip="dataclass output container (no forward)"),
case("feature.ALIKEDFeatures", M, None, [], skip="dataclass output container (no forward)"),
case("feature.scale_space_detector.get_default_detector_config", T, None, [], skip="returns a Python dict"),
]
if __name__ == "__main__":
run_cases(CASES, sys.argv[1], only=sys.argv[2:] or None)