π 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 β area geomA: kornia.geometry.transform / grid / bbox / boxes / keypoints / subpix /
line / plane / ray / vector / pose."""
import math
import sys
import torch
from harness import case, run_cases
import kornia as K
import kornia.geometry.transform as T
from kornia.geometry.bbox import (
bbox_generator,
bbox_generator3d,
bbox_to_mask,
bbox_to_mask3d,
infer_bbox_shape,
infer_bbox_shape3d,
nms,
transform_bbox,
validate_bbox,
validate_bbox3d,
)
from kornia.geometry.boxes import Boxes, Boxes3D, VideoBoxes
from kornia.geometry.grid import create_meshgrid, create_meshgrid3d
from kornia.geometry.keypoints import Keypoints, Keypoints3D
from kornia.geometry.line import ParametrizedLine, fit_line
from kornia.geometry.plane import Hyperplane, fit_plane
from kornia.geometry.pose import NamedPose
from kornia.geometry.ray import Ray
from kornia.geometry.subpix import (
AdaptiveQuadInterp3d,
ConvQuadInterp3d,
ConvSoftArgmax2d,
ConvSoftArgmax3d,
IterativeQuadInterp3d,
NonMaximaSuppression2d,
NonMaximaSuppression3d,
SpatialSoftArgmax2d,
conv_quad_interp3d,
conv_soft_argmax2d,
conv_soft_argmax3d,
iterative_quad_interp3d,
nms2d,
nms3d,
nms3d_minmax,
render_gaussian2d,
spatial_expectation2d,
spatial_soft_argmax2d,
spatial_softmax2d,
)
from kornia.geometry.vector import Scalar, Vector2, Vector3
torch.manual_seed(0)
# ----------------------------------------------------------------------------- shared inputs
B, C, H, W = 1, 3, 32, 40
img = torch.rand(B, C, H, W)
img2 = torch.rand(2, 3, 48, 64)
vol = torch.rand(1, 1, 8, 16, 16)
# 2D transforms
center2d = torch.tensor([[W / 2.0, H / 2.0]])
angle = torch.tensor([15.0])
scale2 = torch.tensor([[1.1, 0.9]])
trans2 = torch.tensor([[3.0, -2.0]])
shear2 = torch.tensor([[0.1, 0.05]])
aff23 = T.get_affine_matrix2d(trans2, center2d, scale2, angle, sx=shear2[:, 0], sy=shear2[:, 1])[:, :2, :] # (1,2,3)
homo33 = T.get_affine_matrix2d(trans2, center2d, scale2, angle) # (1,3,3)
homo33_pert = homo33.clone()
homo33_pert[:, 2, 0] = 1e-3
homo33_pert[:, 2, 1] = -5e-4
# normalized homography (pixel -> normalized [-1,1] coordinates) for homography_warp with normalized_homography=True
homo_norm = K.geometry.conversions.normalize_homography(homo33_pert, (H, W), (H, W))
# 3D transforms
D3, H3, W3 = 8, 16, 16
center3d = torch.tensor([[W3 / 2.0, H3 / 2.0, D3 / 2.0]])
angles3 = torch.tensor([[10.0, -5.0, 8.0]])
scale3 = torch.tensor([[1.05, 0.95, 1.0]])
trans3 = torch.tensor([[0.5, -0.5, 0.3]])
aff44_3d = T.get_affine_matrix3d(trans3, center3d, scale3, angles3) # (1,4,4)
aff34_3d = aff44_3d[:, :3, :] # (1,3,4)
proj34 = T.get_projective_transform(center3d, angles3, scale3) # (1,3,4)
# points / corners
src_pts = torch.tensor([[[2.0, 3.0], [36.0, 2.0], [37.0, 29.0], [3.0, 28.0]]]) # (1,4,2)
dst_pts = torch.tensor([[[0.0, 0.0], [W - 1.0, 0.0], [W - 1.0, H - 1.0], [0.0, H - 1.0]]])
src_pts3d = torch.tensor(
[
[
[1.0, 1.0, 1.0],
[14.0, 1.0, 1.0],
[14.0, 14.0, 1.0],
[1.0, 14.0, 1.0],
[1.0, 1.0, 6.0],
[14.0, 1.0, 6.0],
[14.0, 14.0, 6.0],
[1.0, 14.0, 6.0],
]
]
) # (1,8,3)
dst_pts3d = torch.tensor(
[
[
[0.0, 0.0, 0.0],
[W3 - 1.0, 0.0, 0.0],
[W3 - 1.0, H3 - 1.0, 0.0],
[0.0, H3 - 1.0, 0.0],
[0.0, 0.0, D3 - 1.0],
[W3 - 1.0, 0.0, D3 - 1.0],
[W3 - 1.0, H3 - 1.0, D3 - 1.0],
[0.0, H3 - 1.0, D3 - 1.0],
]
]
)
# tps
tps_src = torch.tensor([[[-0.8, -0.8], [0.8, -0.8], [0.8, 0.8], [-0.8, 0.8], [0.0, 0.0]]]) # (1,5,2) normalized
tps_dst = tps_src + 0.05 * torch.randn(1, 5, 2)
tps_kernel_w, tps_affine_w = T.get_tps_transform(tps_src, tps_dst)
# remap maps (pixel coordinates)
grid_px = create_meshgrid(H, W, normalized_coordinates=False) # (1,H,W,2)
map_x = grid_px[..., 0] + 1.5
map_y = grid_px[..., 1] - 0.7
# boxes
boxes_xyxy = torch.tensor([[[2.0, 3.0, 20.0, 25.0], [10.0, 5.0, 35.0, 30.0]]]) # (1,2,4)
boxes_quad = Boxes.from_tensor(boxes_xyxy, mode="xyxy").data # (1,2,4,2)
boxes3d_xyzxyz = torch.tensor([[[1.0, 2.0, 1.0, 10.0, 12.0, 6.0], [3.0, 3.0, 2.0, 14.0, 14.0, 7.0]]]) # (1,2,6)
boxes3d_hexa = Boxes3D.from_tensor(boxes3d_xyzxyz, mode="xyzxyz").data # (1,2,8,3)
# depths, heights and widths all distinct, for the shape cases: a graph that swapped two of them would not match
boxes3d_hexa_shapes = Boxes3D.from_tensor(
torch.tensor([[[1.0, 2.0, 1.0, 10.0, 12.0, 6.0], [3.0, 3.0, 2.0, 14.0, 9.0, 9.0]]]), mode="xyzxyz"
).data # (1,2,8,3): (d, h, w) = (5, 10, 9) and (7, 6, 11)
nms_boxes = torch.tensor([[10.0, 10.0, 20.0, 20.0], [15.0, 5.0, 15.0, 25.0], [100.0, 100.0, 150.0, 150.0]])
nms_scores = torch.tensor([0.9, 0.8, 0.7])
kpts = torch.tensor([[[5.0, 6.0], [20.0, 10.0], [30.0, 25.0]]]) # (1,3,2)
kpts3d = torch.tensor([[[5.0, 6.0, 2.0], [10.0, 10.0, 4.0], [12.0, 3.0, 6.0]]]) # (1,3,3)
# subpix
heat = torch.rand(1, 2, 16, 24)
heat3d = torch.rand(1, 1, 5, 16, 24) # scale-space (B, C, D=levels, H, W)
# lines / planes
line_pts = torch.stack([torch.linspace(0, 5, 10), 2 * torch.linspace(0, 5, 10) + 1], -1)[None] + 0.01 * torch.randn(
1, 10, 2
)
plane_pts = torch.randn(20, 3)
plane_pts[:, 2] = 0.3 * plane_pts[:, 0] - 0.2 * plane_pts[:, 1] + 1.0 + 0.01 * torch.randn(20)
p3 = torch.tensor([1.0, 2.0, 3.0])
q3 = torch.tensor([4.0, 5.0, 7.0])
v3 = torch.randn(4, 3)
# pose
Rt = aff44_3d.clone() # not orthonormal (has scale) -> build a proper SE3 from axis-angle
so3 = K.geometry.liegroup.So3.exp(torch.tensor([[0.1, 0.2, -0.1]]))
pose44 = torch.eye(4)[None].repeat(1, 1, 1)
pose44[:, :3, :3] = so3.matrix()
pose44[:, :3, 3] = torch.tensor([[0.5, -1.0, 2.0]])
pts3 = torch.randn(1, 6, 3)
# ----------------------------------------------------------------------------- cases
G = "geometry.transform"
CASES = [
# ---- 2D warps
case(
"transform.warp_perspective", G, T.warp_perspective, [img, homo33_pert], {"dsize": (H, W)}, note="dsize baked"
),
case(
"transform.warp_perspective[nearest,border]",
G,
T.warp_perspective,
[img, homo33_pert],
{"dsize": (H, W), "mode": "nearest", "padding_mode": "border"},
note="dsize baked",
),
case(
"transform.warp_perspective[fill]",
G,
lambda x, M, fv: T.warp_perspective(x, M, dsize=(H, W), padding_mode="fill", fill_value=fv),
[img, homo33_pert, torch.tensor([0.2, 0.4, 0.6])],
note="padding_mode=fill; fill_value live input; dsize baked",
),
case(
"transform.warp_perspective[batch2,resize]",
G,
T.warp_perspective,
[img2, homo33_pert.repeat(2, 1, 1)],
{"dsize": (24, 30)},
tags=("batch>1",),
note="dsize != input size",
),
case("transform.warp_affine", G, T.warp_affine, [img, aff23], {"dsize": (H, W)}, note="dsize baked"),
case(
"transform.warp_affine[align_corners=False,reflection]",
G,
T.warp_affine,
[img, aff23],
{"dsize": (H, W), "align_corners": False, "padding_mode": "reflection"},
),
case(
"transform.warp_affine[fill]",
G,
lambda x, M, fv: T.warp_affine(x, M, dsize=(H, W), padding_mode="fill", fill_value=fv),
[img, aff23, torch.tensor([0.5, 0.5, 0.5])],
note="fill_value live input; dsize baked",
),
case(
"transform.warp_grid",
G,
T.warp_grid,
[create_meshgrid(H, W, normalized_coordinates=True), homo_norm],
note="grid is a live input (1,H,W,2)",
),
case("transform.remap", G, T.remap, [img, map_x, map_y], {"align_corners": True}),
case(
"transform.remap[normalized,nearest]",
G,
T.remap,
[img, (map_x / (W - 1)) * 2 - 1, (map_y / (H - 1)) * 2 - 1],
{"align_corners": True, "normalized_coordinates": True, "mode": "nearest"},
),
case(
"transform.homography_warp",
G,
T.homography_warp,
[img, homo_norm],
{"dsize": (H, W)},
note="normalized homography; dsize baked",
),
case(
"transform.homography_warp[pixel_homography]",
G,
T.homography_warp,
[img, homo33_pert],
{"dsize": (H, W), "normalized_coordinates": False, "normalized_homography": False},
),
case("transform.get_tps_transform", G, T.get_tps_transform, [tps_src, tps_dst], tags=("points",)),
case(
"transform.warp_points_tps",
G,
T.warp_points_tps,
[torch.rand(1, 7, 2) * 1.6 - 0.8, tps_src, tps_kernel_w, tps_affine_w],
tags=("points",),
note="query points distinct from kernel centers",
),
case(
"transform.warp_points_tps[at_centers]",
G,
T.warp_points_tps,
[tps_src.clone(), tps_src, tps_kernel_w, tps_affine_w],
tags=("points",),
note="query points == kernel centers (zero distance) -> exercises zero-distance handling in _kernel_distance",
),
case("transform.warp_image_tps", G, T.warp_image_tps, [img, tps_src, tps_kernel_w, tps_affine_w]),
case(
"transform.elastic_transform2d",
G,
T.elastic_transform2d,
[img, torch.rand(1, 2, H, W) * 2 - 1],
{"kernel_size": (31, 31), "sigma": (8.0, 8.0), "alpha": (1.0, 1.0)},
note="noise is live input; kernel/sigma/alpha baked",
),
case(
"transform.elastic_transform2d[tensor_sigma_alpha]",
G,
lambda x, n, s, a: T.elastic_transform2d(x, n, kernel_size=(31, 31), sigma=s, alpha=a),
[img, torch.rand(1, 2, H, W) * 2 - 1, torch.tensor([8.0, 8.0]), torch.tensor([1.0, 1.0])],
note="sigma/alpha as live tensors; kernel_size baked",
),
# ---- 2D affine family
case("transform.affine", G, T.affine, [img, aff23]),
case("transform.rotate", G, T.rotate, [img, angle]),
case("transform.rotate[center]", G, T.rotate, [img, angle, center2d]),
case("transform.translate", G, T.translate, [img, trans2]),
case("transform.scale", G, T.scale, [img, scale2]),
case("transform.scale[scalar]", G, T.scale, [img, torch.tensor([1.2])]),
case("transform.shear", G, T.shear, [img, shear2]),
case("transform.hflip", G, T.hflip, [img]),
case("transform.vflip", G, T.vflip, [img]),
case("transform.rot180", G, T.rot180, [img]),
case("transform.resize", G, T.resize, [img], {"size": (24, 30)}, note="size baked"),
case("transform.resize[int,side=short]", G, T.resize, [img], {"size": 16, "side": "short"}, note="size=int baked"),
case("transform.resize[nearest]", G, T.resize, [img], {"size": (24, 30), "interpolation": "nearest"}),
case(
"transform.resize[bicubic,align_corners]",
G,
T.resize,
[img],
{"size": (24, 30), "interpolation": "bicubic", "align_corners": True},
),
case("transform.resize[antialias,area]", G, T.resize, [img], {"size": (16, 20), "antialias": True}),
case(
"transform.resize_to_be_divisible",
G,
T.resize_to_be_divisible,
[img],
{"divisible_factor": 14},
note="factor baked; output size fixed at trace",
),
case("transform.rescale", G, T.rescale, [img], {"factor": 0.5}),
case("transform.rescale[tuple]", G, T.rescale, [img], {"factor": (1.5, 0.75)}),
# ---- pyramids
case("transform.pyrdown", G, T.pyrdown, [img]),
case("transform.pyrdown[factor=3]", G, T.pyrdown, [img], {"factor": 3.0}),
case("transform.pyrup", G, T.pyrup, [img]),
case(
"transform.build_pyramid",
G,
T.build_pyramid,
[img2],
{"max_level": 3},
tags=("batch>1",),
note="returns list of 3 tensors",
),
case(
"transform.build_laplacian_pyramid",
G,
T.build_laplacian_pyramid,
[img2],
{"max_level": 3},
tags=("batch>1",),
note="returns list of 3 tensors",
),
case("transform.PyrDown", G, T.PyrDown(), [img]),
case("transform.PyrUp", G, T.PyrUp(), [img]),
case(
"transform.ScalePyramid",
G,
T.ScalePyramid(n_levels=3, min_size=15),
[torch.rand(1, 1, 48, 64)],
note="returns (pyramid list, sigmas list, pixel_dists list) flattened",
),
case(
"transform.ScalePyramid[double_image]",
G,
T.ScalePyramid(n_levels=3, min_size=15, double_image=True),
[torch.rand(1, 1, 32, 40)],
),
# ---- 3D warps
case("transform.warp_affine3d", G, T.warp_affine3d, [vol, aff34_3d], {"dsize": (D3, H3, W3)}, tags=("3d",)),
case(
"transform.warp_affine3d[nearest]",
G,
T.warp_affine3d,
[vol, aff34_3d],
{"dsize": (D3, H3, W3), "flags": "nearest", "align_corners": False},
tags=("3d",),
),
case(
"transform.warp_perspective3d", G, T.warp_perspective3d, [vol, aff44_3d], {"dsize": (D3, H3, W3)}, tags=("3d",)
),
case(
"transform.warp_grid3d",
G,
T.warp_grid3d,
[
create_meshgrid3d(D3, H3, W3, normalized_coordinates=True),
K.geometry.conversions.normalize_homography3d(aff44_3d, (D3, H3, W3), (D3, H3, W3)),
],
tags=("3d",),
),
case(
"transform.homography_warp3d",
G,
T.homography_warp3d,
[vol, K.geometry.conversions.normalize_homography3d(aff44_3d, (D3, H3, W3), (D3, H3, W3))],
{"dsize": (D3, H3, W3)},
tags=("3d",),
),
case("transform.affine3d", G, T.affine3d, [vol, aff34_3d], tags=("3d",)),
case(
"transform.rotate3d",
G,
T.rotate3d,
[vol, torch.tensor([10.0]), torch.tensor([-5.0]), torch.tensor([8.0])],
tags=("3d",),
),
case(
"transform.rotate3d[center]",
G,
T.rotate3d,
[vol, torch.tensor([10.0]), torch.tensor([-5.0]), torch.tensor([8.0]), center3d],
tags=("3d",),
),
# ---- matrix helpers
case("transform.get_perspective_transform", G, T.get_perspective_transform, [src_pts, dst_pts], tags=("points",)),
case(
"transform.get_perspective_transform3d",
G,
T.get_perspective_transform3d,
[src_pts3d, dst_pts3d],
tags=("points", "3d"),
),
case(
"transform.get_projective_transform", G, T.get_projective_transform, [center3d, angles3, scale3], tags=("3d",)
),
case("transform.get_rotation_matrix2d", G, T.get_rotation_matrix2d, [center2d, angle, scale2]),
case("transform.get_translation_matrix2d", G, T.get_translation_matrix2d, [trans2]),
case("transform.get_shear_matrix2d", G, T.get_shear_matrix2d, [center2d, shear2[:, 0], shear2[:, 1]]),
case("transform.get_shear_matrix2d[sx_only]", G, T.get_shear_matrix2d, [center2d, shear2[:, 0]]),
case(
"transform.get_shear_matrix3d",
G,
T.get_shear_matrix3d,
[
center3d,
torch.tensor([0.1]),
torch.tensor([0.05]),
torch.tensor([-0.05]),
torch.tensor([0.02]),
torch.tensor([0.03]),
torch.tensor([-0.02]),
],
tags=("3d",),
),
case("transform.get_affine_matrix2d", G, T.get_affine_matrix2d, [trans2, center2d, scale2, angle]),
case(
"transform.get_affine_matrix2d[shear]",
G,
T.get_affine_matrix2d,
[trans2, center2d, scale2, angle, shear2[:, 0], shear2[:, 1]],
),
case("transform.get_affine_matrix3d", G, T.get_affine_matrix3d, [trans3, center3d, scale3, angles3], tags=("3d",)),
case(
"transform.get_affine_matrix3d[shear]",
G,
T.get_affine_matrix3d,
[
trans3,
center3d,
scale3,
angles3,
torch.tensor([0.1]),
torch.tensor([0.05]),
torch.tensor([-0.05]),
torch.tensor([0.02]),
torch.tensor([0.03]),
torch.tensor([-0.02]),
],
tags=("3d",),
),
case("transform.invert_affine_transform", G, T.invert_affine_transform, [aff23]),
case(
"transform.projection_from_Rt",
G,
T.projection_from_Rt,
[so3.matrix(), torch.tensor([[[0.5], [-1.0], [2.0]]])],
tags=("3d",),
),
# ---- crops 2D
case(
"transform.crop_by_indices",
G,
T.crop_by_indices,
[img, src_pts],
note="size inferred from box (data-dependent)",
),
case(
"transform.crop_by_indices[size]", G, T.crop_by_indices, [img, src_pts], {"size": (20, 24)}, note="size baked"
),
case("transform.crop_by_boxes", G, T.crop_by_boxes, [img, src_pts, dst_pts]),
case("transform.crop_by_transform_mat", G, T.crop_by_transform_mat, [img, homo33], {"out_size": (H, W)}),
case("transform.center_crop", G, T.center_crop, [img], {"size": (20, 24)}),
case("transform.crop_and_resize", G, T.crop_and_resize, [img, src_pts], {"size": (20, 24)}),
case("transform.CenterCrop2D", G, T.CenterCrop2D((20, 24)), [img]),
case("transform.CenterCrop2D[resample]", G, T.CenterCrop2D((20, 24), cropping_mode="resample"), [img]),
# ---- crops 3D
case("transform.crop_by_boxes3d", G, T.crop_by_boxes3d, [vol, src_pts3d, dst_pts3d], tags=("3d",)),
case(
"transform.crop_by_transform_mat3d",
G,
T.crop_by_transform_mat3d,
[vol, aff44_3d],
{"out_size": (D3, H3, W3)},
tags=("3d",),
),
case("transform.center_crop3d", G, T.center_crop3d, [vol], {"size": (6, 12, 12)}, tags=("3d",)),
case("transform.crop_and_resize3d", G, T.crop_and_resize3d, [vol, src_pts3d], {"size": (6, 12, 12)}, tags=("3d",)),
# ---- modules
case("transform.Rotate", G, T.Rotate(angle), [img], note="angle is a module constant"),
case("transform.Translate", G, T.Translate(trans2), [img]),
case("transform.Scale", G, T.Scale(scale2), [img]),
case("transform.Shear", G, T.Shear(shear2), [img]),
case("transform.Affine", G, T.Affine(angle=angle, translation=trans2, scale_factor=scale2, shear=shear2), [img]),
case("transform.Hflip", G, T.Hflip(), [img]),
case("transform.Vflip", G, T.Vflip(), [img]),
case("transform.Rot180", G, T.Rot180(), [img]),
case("transform.Resize", G, T.Resize((24, 30)), [img]),
case("transform.Resize[int]", G, T.Resize(24, side="long"), [img]),
case("transform.Rescale", G, T.Rescale(0.5), [img]),
case("transform.HomographyWarper", G, T.HomographyWarper(H, W), [img, homo_norm], note="normalized homography"),
case(
"transform.HomographyWarper[pixel]",
G,
T.HomographyWarper(H, W, normalized_coordinates=False),
[img, homo33_pert],
),
case(
"transform.HomographyWarper[precomputed]",
G,
None,
[],
skip="precompute_warp_grid path stores grid as state; "
"same graph as HomographyWarper with the homography folded into a constant",
),
case("transform.BaseWarper", G, None, [], skip="abstract base class"),
case("transform.ImageRegistrator", G, None, [], skip="optimizer loop (Adam over num_iterations) β not a graph"),
case(
"transform.image_registrator.Homography",
G,
lambda d: T.Homography()(),
[torch.zeros(1)],
note="parametric model; forward() takes no input, graph is fully constant",
),
case(
"transform.image_registrator.Similarity",
G,
lambda d: T.Similarity()(),
[torch.zeros(1)],
note="parametric model; forward() takes no input, graph is fully constant",
),
case(
"transform.image_registrator.Homography.forward_inverse",
G,
lambda d: T.Homography().forward_inverse(),
[torch.zeros(1)],
note="torch.inverse on 3x3 parameter",
),
case("transform.image_registrator.BaseModel", G, None, [], skip="abstract base class"),
]
# ----------------------------------------------------------------------------- grid
G = "geometry.grid"
CASES += [
case(
"grid.create_meshgrid",
G,
lambda d: create_meshgrid(16, 24, device=d.device, dtype=d.dtype),
[torch.zeros(1)],
note="H,W baked; graph is fully constant",
),
case(
"grid.create_meshgrid[pixel]",
G,
lambda d: create_meshgrid(16, 24, normalized_coordinates=False, device=d.device, dtype=d.dtype),
[torch.zeros(1)],
note="H,W baked",
),
case(
"grid.create_meshgrid3d",
G,
lambda d: create_meshgrid3d(4, 16, 24, device=d.device, dtype=d.dtype),
[torch.zeros(1)],
tags=("3d",),
note="D,H,W baked",
),
case(
"grid.create_meshgrid[dynamic_from_input]",
G,
lambda x: (
create_meshgrid(x.shape[-2], x.shape[-1], device=x.device, dtype=x.dtype) + 0 * x[:, :1].permute(0, 2, 3, 1)
),
[img],
note="H,W taken from input shape; still static under export",
),
]
# ----------------------------------------------------------------------------- bbox
G = "geometry.bbox"
CASES += [
case(
"bbox.bbox_generator",
G,
bbox_generator,
[torch.tensor([2.0, 5.0]), torch.tensor([3.0, 4.0]), torch.tensor([10.0, 12.0]), torch.tensor([8.0, 9.0])],
),
case(
"bbox.bbox_generator3d",
G,
bbox_generator3d,
[
torch.tensor([2.0]),
torch.tensor([3.0]),
torch.tensor([1.0]),
torch.tensor([10.0]),
torch.tensor([8.0]),
torch.tensor([4.0]),
],
tags=("3d",),
),
case(
"bbox.bbox_to_mask",
G,
bbox_to_mask,
[boxes_quad[0]],
{"size": (H, W)},
note="H,W baked; input (N,4,2)",
),
case(
"bbox.bbox_to_mask3d",
G,
bbox_to_mask3d,
[boxes3d_hexa[0]],
{"size": (D3, H3, W3)},
tags=("3d",),
note="size baked; input (N,8,3)",
),
case("bbox.infer_bbox_shape", G, infer_bbox_shape, [boxes_quad[0]]),
case("bbox.infer_bbox_shape3d", G, infer_bbox_shape3d, [boxes3d_hexa_shapes[0]], tags=("3d",)),
case("bbox.transform_bbox", G, transform_bbox, [homo33, boxes_xyxy], note="mode=xyxy default (B,N,4)"),
case(
"bbox.transform_bbox[xywh]",
G,
transform_bbox,
[homo33, torch.tensor([[[2.0, 3.0, 18.0, 22.0], [10.0, 5.0, 25.0, 25.0]]])],
{"mode": "xywh"},
),
case("bbox.transform_bbox[polygon]", G, transform_bbox, [homo33, boxes_quad], note="(B,N,4,2) polygon input"),
case(
"bbox.nms",
G,
nms,
[nms_boxes, nms_scores],
{"iou_threshold": 0.5},
note="data-dependent output size (keep indices); iou_threshold baked",
),
case("bbox.validate_bbox", G, validate_bbox, [boxes_quad[0]], note="returns Python bool"),
case("bbox.validate_bbox3d", G, validate_bbox3d, [boxes3d_hexa[0]], tags=("3d",), note="returns Python bool"),
]
# ----------------------------------------------------------------------------- boxes
G = "geometry.boxes"
CASES += [
case("boxes.Boxes.from_tensor[xyxy]", G, lambda b: Boxes.from_tensor(b, mode="xyxy").data, [boxes_xyxy]),
case(
"boxes.Boxes.from_tensor[xywh]",
G,
lambda b: Boxes.from_tensor(b, mode="xywh").data,
[torch.tensor([[[2.0, 3.0, 18.0, 22.0], [10.0, 5.0, 25.0, 25.0]]])],
),
case("boxes.Boxes.from_tensor[xyxy_plus]", G, lambda b: Boxes.from_tensor(b, mode="xyxy_plus").data, [boxes_xyxy]),
case("boxes.Boxes.from_tensor[vertices]", G, lambda b: Boxes.from_tensor(b, mode="vertices").data, [boxes_quad]),
case(
"boxes.Boxes.from_tensor[no_validate]",
G,
lambda b: Boxes.from_tensor(b, mode="xyxy", validate_boxes=False).data,
[boxes_xyxy],
note="validate_boxes=False skips the data-dependent assertion",
),
case("boxes.Boxes.to_tensor[xyxy]", G, lambda b: Boxes(b, mode="vertices_plus").to_tensor("xyxy"), [boxes_quad]),
case("boxes.Boxes.to_tensor[xywh]", G, lambda b: Boxes(b, mode="vertices_plus").to_tensor("xywh"), [boxes_quad]),
case(
"boxes.Boxes.to_tensor[vertices]",
G,
lambda b: Boxes(b, mode="vertices_plus").to_tensor("vertices"),
[boxes_quad],
),
case("boxes.Boxes.get_boxes_shape", G, lambda b: Boxes(b, mode="vertices_plus").get_boxes_shape(), [boxes_quad]),
case("boxes.Boxes.compute_area", G, lambda b: Boxes(b, mode="vertices_plus").compute_area(), [boxes_quad]),
case(
"boxes.Boxes.to_mask", G, lambda b: Boxes(b, mode="vertices_plus").to_mask(H, W), [boxes_quad], note="H,W baked"
),
case(
"boxes.Boxes.transform_boxes",
G,
lambda b, M: Boxes(b, mode="vertices_plus").transform_boxes(M).data,
[boxes_quad, homo33],
),
case(
"boxes.Boxes.transform_boxes_",
G,
lambda b, M: Boxes(b, mode="vertices_plus").transform_boxes_(M).data,
[boxes_quad, homo33],
),
case(
"boxes.Boxes.translate",
G,
lambda b, s: Boxes(b, mode="vertices_plus").translate(s).data,
[boxes_quad, torch.tensor([[3.0, -2.0]])],
),
case(
"boxes.Boxes.translate[fast]",
G,
None,
[],
skip="NotImplementedError stub (kornia/geometry/boxes.py:759, method='fast')",
),
case(
"boxes.Boxes.clamp[tuple]",
G,
None,
[],
skip="NotImplementedError stub for tuple bounds (kornia/geometry/boxes.py:391)",
),
case(
"boxes.Boxes.clamp[tensor]",
G,
lambda b, tl, br: Boxes(b, mode="vertices_plus").clamp(tl, br).data,
[boxes_quad, torch.tensor([[5.0, 5.0]]), torch.tensor([[30.0, 20.0]])],
note="bounds (B,2) tensors",
),
case(
"boxes.Boxes.pad",
G,
lambda b, p: Boxes(b, mode="vertices_plus").pad(p).data,
[boxes_quad, torch.tensor([[2, 2, 3, 3]])],
note="padding_size (B,4) int",
),
case(
"boxes.Boxes.unpad",
G,
lambda b, p: Boxes(b, mode="vertices_plus").unpad(p).data,
[boxes_quad, torch.tensor([[2, 2, 3, 3]])],
),
case("boxes.Boxes.trim", G, None, [], skip="NotImplementedError stub (kornia/geometry/boxes.py:442)"),
case(
"boxes.Boxes.filter_boxes_by_area",
G,
lambda b: Boxes(b, mode="vertices_plus").filter_boxes_by_area(min_area=100.0).data,
[boxes_quad],
note="zeros out boxes outside range",
),
case(
"boxes.Boxes.merge",
G,
lambda a, b: Boxes(a, mode="vertices_plus").merge(Boxes(b, mode="vertices_plus")).data,
[boxes_quad, boxes_quad + 1.0],
),
case(
"boxes.Boxes.index_put",
G,
lambda b, v: Boxes(b, mode="vertices_plus").index_put((torch.tensor([0]), torch.tensor([1])), v).data,
[boxes_quad, boxes_quad[0, :1]],
note="indices baked as constants",
),
case("boxes.Boxes.clone", G, lambda b: Boxes(b, mode="vertices_plus").clone().data, [boxes_quad]),
case("boxes.Boxes.type", G, lambda b: Boxes(b, mode="vertices_plus").type(torch.float64).data, [boxes_quad]),
case("boxes.Boxes.to_tensor[list_input]", G, None, [], skip="input is a Python list of tensors (ragged batch)"),
case(
"boxes.Boxes.to_tensor[as_padded_sequence]",
G,
None,
[],
skip="ragged list path; returns Python list of tensors",
),
case(
"boxes.Boxes3D.from_tensor[xyzxyz]",
G,
lambda b: Boxes3D.from_tensor(b, mode="xyzxyz").data,
[boxes3d_xyzxyz],
tags=("3d",),
),
case(
"boxes.Boxes3D.from_tensor[xyzwhd]",
G,
lambda b: Boxes3D.from_tensor(b, mode="xyzwhd").data,
[torch.tensor([[[1.0, 2.0, 1.0, 9.0, 10.0, 5.0]]])],
tags=("3d",),
),
case(
"boxes.Boxes3D.to_tensor[xyzxyz]",
G,
lambda b: Boxes3D(b, mode="xyzxyz_plus").to_tensor("xyzxyz"),
[boxes3d_hexa],
tags=("3d",),
),
case(
"boxes.Boxes3D.to_tensor[xyzwhd]",
G,
lambda b: Boxes3D(b, mode="xyzxyz_plus").to_tensor("xyzwhd"),
[boxes3d_hexa],
tags=("3d",),
),
case(
"boxes.Boxes3D.to_tensor[vertices]",
G,
lambda b: Boxes3D(b, mode="xyzxyz_plus").to_tensor("vertices"),
[boxes3d_hexa],
tags=("3d",),
),
case(
"boxes.Boxes3D.get_boxes_shape",
G,
lambda b: Boxes3D(b, mode="xyzxyz_plus").get_boxes_shape(),
[boxes3d_hexa_shapes],
tags=("3d",),
),
case(
"boxes.Boxes3D.to_mask",
G,
lambda b: Boxes3D(b, mode="xyzxyz_plus").to_mask(D3, H3, W3),
[boxes3d_hexa],
tags=("3d",),
note="D,H,W baked",
),
case(
"boxes.Boxes3D.transform_boxes",
G,
lambda b, M: Boxes3D(b, mode="xyzxyz_plus").transform_boxes(M).data,
[boxes3d_hexa, aff44_3d],
tags=("3d",),
),
case(
"boxes.Boxes3D.transform_boxes_",
G,
lambda b, M: Boxes3D(b, mode="xyzxyz_plus").transform_boxes_(M).data,
[boxes3d_hexa, aff44_3d],
tags=("3d",),
),
case(
"boxes.VideoBoxes.from_tensor",
G,
lambda b: VideoBoxes.from_tensor(b).data,
[boxes_quad[None].repeat(1, 2, 1, 1, 1)],
note="(B,T,N,4,2) vertices",
),
case(
"boxes.VideoBoxes.to_tensor",
G,
lambda b: VideoBoxes.from_tensor(b).to_tensor("xyxy"),
[boxes_quad[None].repeat(1, 2, 1, 1, 1)],
),
case(
"boxes.VideoBoxes.transform_boxes",
G,
lambda b, M: VideoBoxes.from_tensor(b).transform_boxes(M).data,
[boxes_quad[None].repeat(1, 2, 1, 1, 1), homo33.repeat(2, 1, 1)],
note="M must be (B*T,3,3): internal data is flattened to (B*T,N,4,2)",
),
]
# ----------------------------------------------------------------------------- keypoints
G = "geometry.keypoints"
CASES += [
case("keypoints.Keypoints.from_tensor", G, lambda k: Keypoints.from_tensor(k).data, [kpts], tags=("points",)),
case("keypoints.Keypoints.to_tensor", G, lambda k: Keypoints(k).to_tensor(), [kpts], tags=("points",)),
case(
"keypoints.Keypoints.transform_keypoints",
G,
lambda k, M: Keypoints(k).transform_keypoints(M).data,
[kpts, homo33],
tags=("points",),
),
case(
"keypoints.Keypoints.transform_keypoints_",
G,
lambda k, M: Keypoints(k).transform_keypoints_(M).data,
[kpts, homo33],
tags=("points",),
),
case(
"keypoints.Keypoints.pad",
G,
lambda k, p: Keypoints(k).pad(p).data,
[kpts, torch.tensor([[2, 2, 3, 3]])],
tags=("points",),
),
case(
"keypoints.Keypoints.unpad",
G,
lambda k, p: Keypoints(k).unpad(p).data,
[kpts, torch.tensor([[2, 2, 3, 3]])],
tags=("points",),
),
case(
"keypoints.Keypoints.index_put",
G,
lambda k, v: Keypoints(k).index_put((torch.tensor([0]), torch.tensor([1])), v).data,
[kpts, kpts[0, :1]],
tags=("points",),
note="indices baked",
),
case("keypoints.Keypoints.clone", G, lambda k: Keypoints(k).clone().data, [kpts], tags=("points",)),
case("keypoints.Keypoints.type", G, lambda k: Keypoints(k).type(torch.float64).data, [kpts], tags=("points",)),
case(
"keypoints.Keypoints3D.from_tensor",
G,
lambda k: Keypoints3D.from_tensor(k).data,
[kpts3d],
tags=("points", "3d"),
),
case("keypoints.Keypoints3D.to_tensor", G, lambda k: Keypoints3D(k).to_tensor(), [kpts3d], tags=("points", "3d")),
case(
"keypoints.Keypoints3D.transform_keypoints",
G,
None,
[],
skip="NotImplementedError stub (kornia/geometry/keypoints.py:377)",
),
case(
"keypoints.Keypoints3D.transform_keypoints_",
G,
None,
[],
skip="NotImplementedError stub (kornia/geometry/keypoints.py:377)",
),
case("keypoints.Keypoints3D.pad", G, None, [], skip="NotImplementedError stub (kornia/geometry/keypoints.py:355)"),
case(
"keypoints.Keypoints3D.unpad", G, None, [], skip="NotImplementedError stub (kornia/geometry/keypoints.py:364)"
),
case("keypoints.Keypoints3D.clone", G, lambda k: Keypoints3D(k).clone().data, [kpts3d], tags=("points", "3d")),
]
# ----------------------------------------------------------------------------- subpix
G = "geometry.subpix"
CASES += [
case("subpix.conv_soft_argmax2d", G, conv_soft_argmax2d, [heat]),
case(
"subpix.conv_soft_argmax2d[output_value,pixel,stride2]",
G,
conv_soft_argmax2d,
[heat],
{"output_value": True, "normalized_coordinates": False, "stride": (2, 2)},
),
case(
"subpix.conv_soft_argmax2d[tensor_temperature]",
G,
lambda x, t: conv_soft_argmax2d(x, temperature=t),
[heat, torch.tensor(0.5)],
note="temperature as live 0-d tensor; `if temperature <= 0` is a data-dependent guard",
),
case("subpix.conv_soft_argmax3d", G, conv_soft_argmax3d, [heat3d], tags=("3d",)),
case(
"subpix.conv_soft_argmax3d[normalized]",
G,
conv_soft_argmax3d,
[heat3d],
{"normalized_coordinates": True},
tags=("3d",),
),
case("subpix.conv_quad_interp3d", G, conv_quad_interp3d, [heat3d], tags=("3d",)),
case(
"subpix.conv_quad_interp3d[no_scale_steps]",
G,
conv_quad_interp3d,
[heat3d],
{"allow_scale_steps": False},
tags=("3d",),
),
case(
"subpix.conv_quad_interp3d[precomputed_mask]",
G,
lambda x: conv_quad_interp3d(x, precomputed_nms_mask=nms3d(x, (3, 3, 3), mask_only=True)),
[heat3d],
tags=("3d",),
),
case(
"subpix.iterative_quad_interp3d",
G,
iterative_quad_interp3d,
[heat3d],
tags=("3d",),
note="data-dependent candidate set",
),
case(
"subpix.iterative_quad_interp3d[max_candidates]",
G,
iterative_quad_interp3d,
[heat3d],
{"max_candidates": 32},
tags=("3d",),
),
case("subpix.spatial_softmax2d", G, spatial_softmax2d, [heat]),
case("subpix.spatial_softmax2d[temperature]", G, spatial_softmax2d, [heat, torch.tensor(0.5)]),
case("subpix.spatial_expectation2d", G, spatial_expectation2d, [spatial_softmax2d(heat)]),
case(
"subpix.spatial_expectation2d[pixel]",
G,
spatial_expectation2d,
[spatial_softmax2d(heat)],
{"normalized_coordinates": False},
),
case("subpix.spatial_soft_argmax2d", G, spatial_soft_argmax2d, [heat]),
case("subpix.spatial_soft_argmax2d[temperature]", G, spatial_soft_argmax2d, [heat, torch.tensor(0.5)]),
case(
"subpix.render_gaussian2d",
G,
render_gaussian2d,
[torch.tensor([[0.1, -0.2], [0.3, 0.4]]), torch.tensor([[0.2, 0.3], [0.1, 0.1]])],
{"size": (16, 24)},
note="size baked; mean/std (N,2) normalized",
),
case(
"subpix.render_gaussian2d[pixel]",
G,
render_gaussian2d,
[torch.tensor([[5.0, 8.0], [12.0, 20.0]]), torch.tensor([[2.0, 3.0], [1.0, 1.0]])],
{"size": (16, 24), "normalized_coordinates": False},
),
case("subpix.nms2d", G, nms2d, [heat], {"kernel_size": (3, 3)}),
case("subpix.nms2d[mask_only,5x5]", G, nms2d, [heat], {"kernel_size": (5, 5), "mask_only": True}),
case("subpix.nms3d", G, nms3d, [heat3d], {"kernel_size": (3, 3, 3)}, tags=("3d",)),
case("subpix.nms3d[mask_only]", G, nms3d, [heat3d], {"kernel_size": (3, 3, 3), "mask_only": True}, tags=("3d",)),
case("subpix.nms3d_minmax", G, nms3d_minmax, [heat3d], tags=("3d",)),
case("subpix.SpatialSoftArgmax2d", G, SpatialSoftArgmax2d(), [heat]),
case("subpix.ConvSoftArgmax2d", G, ConvSoftArgmax2d(), [heat]),
case("subpix.ConvSoftArgmax3d", G, ConvSoftArgmax3d(), [heat3d], tags=("3d",)),
case("subpix.ConvQuadInterp3d", G, ConvQuadInterp3d(), [heat3d], tags=("3d",)),
case("subpix.IterativeQuadInterp3d", G, IterativeQuadInterp3d(), [heat3d], tags=("3d",)),
case("subpix.AdaptiveQuadInterp3d", G, AdaptiveQuadInterp3d(), [heat3d], tags=("3d",), note="mode=auto"),
case("subpix.AdaptiveQuadInterp3d[conv]", G, AdaptiveQuadInterp3d(mode="conv"), [heat3d], tags=("3d",)),
case("subpix.AdaptiveQuadInterp3d[patch]", G, AdaptiveQuadInterp3d(mode="patch"), [heat3d], tags=("3d",)),
case("subpix.NonMaximaSuppression2d", G, NonMaximaSuppression2d((3, 3)), [heat]),
case("subpix.NonMaximaSuppression3d", G, NonMaximaSuppression3d((3, 3, 3)), [heat3d], tags=("3d",)),
]
# ----------------------------------------------------------------------------- line / plane / ray / vector / pose
G = "geometry.line"
CASES += [
case(
"line.fit_line", G, lambda p: (lambda ln: (ln.origin, ln.direction))(fit_line(p)), [line_pts], tags=("points",)
),
case(
"line.fit_line[weights]",
G,
lambda p, w: (lambda ln: (ln.origin, ln.direction))(fit_line(p, w)),
[line_pts, torch.rand(1, 10)],
tags=("points",),
),
case(
"line.ParametrizedLine.through",
G,
lambda a, b: (lambda ln: (ln.origin, ln.direction))(ParametrizedLine.through(a, b)),
[p3, q3],
),
case(
"line.ParametrizedLine.point_at",
G,
lambda a, b, t: ParametrizedLine.through(a, b).point_at(t),
[p3, q3, torch.tensor(0.3)],
),
case(
"line.ParametrizedLine.point_at[float]", G, lambda a, b: ParametrizedLine.through(a, b).point_at(0.3), [p3, q3]
),
case(
"line.ParametrizedLine.projection",
G,
lambda a, b, p: ParametrizedLine.through(a, b).projection(p),
[p3, q3, torch.tensor([0.0, 1.0, 0.0])],
),
case(
"line.ParametrizedLine.distance",
G,
lambda a, b, p: ParametrizedLine.through(a, b).distance(p),
[p3, q3, torch.tensor([0.0, 1.0, 0.0])],
),
case(
"line.ParametrizedLine.squared_distance",
G,
lambda a, b, p: ParametrizedLine.through(a, b).squared_distance(p),
[p3, q3, torch.tensor([0.0, 1.0, 0.0])],
),
case(
"line.ParametrizedLine.intersect",
G,
lambda a, b, n, e: ParametrizedLine.through(a, b).intersect(Hyperplane.from_vector(Vector3(n), Vector3(e))),
[p3, q3, torch.tensor([0.0, 0.0, 1.0]), torch.tensor([0.0, 0.0, 5.0])],
note="returns (lambda, point)",
),
case(
"line.ParametrizedLine.dim",
G,
lambda a, b: ParametrizedLine.through(a, b).dim(),
[p3, q3],
note="returns Python int",
),
case(
"ray.Ray",
G,
lambda a, b: (lambda r: (r.origin, r.direction))(Ray.through(a, b)),
[p3, q3],
note="Ray is an alias of ParametrizedLine",
),
]
G = "geometry.plane"
CASES += [
case(
"plane.fit_plane",
G,
lambda p: (lambda pl: (pl.normal.data, pl.offset.data))(fit_plane(Vector3(p))),
[plane_pts],
tags=("points",),
note="SVD",
),
case(
"plane.Hyperplane.through",
G,
lambda a, b, c: (lambda pl: (pl.normal.data, pl.offset.data))(Hyperplane.through(a, b, c)),
[p3, q3, torch.tensor([0.0, 1.0, 5.0])],
),
case(
"plane.Hyperplane.from_vector",
G,
lambda n, e: (lambda pl: (pl.normal.data, pl.offset.data))(Hyperplane.from_vector(Vector3(n), Vector3(e))),
[torch.tensor([0.0, 0.0, 1.0]), torch.tensor([0.0, 0.0, 5.0])],
),
case(
"plane.Hyperplane.signed_distance",
G,
lambda n, e, p: Hyperplane.from_vector(Vector3(n), Vector3(e)).signed_distance(Vector3(p)).data,
[torch.tensor([0.0, 0.0, 1.0]), torch.tensor([0.0, 0.0, 5.0]), v3],
),
case(
"plane.Hyperplane.abs_distance",
G,
lambda n, e, p: Hyperplane.from_vector(Vector3(n), Vector3(e)).abs_distance(Vector3(p)).data,
[torch.tensor([0.0, 0.0, 1.0]), torch.tensor([0.0, 0.0, 5.0]), v3],
),
case(
"plane.Hyperplane.projection",
G,
lambda n, e, p: Hyperplane.from_vector(Vector3(n), Vector3(e)).projection(Vector3(p)).data,
[torch.tensor([0.0, 0.0, 1.0]), torch.tensor([0.0, 0.0, 5.0]), v3],
),
]
G = "geometry.vector"
CASES += [
case("vector.Vector3.normalized", G, lambda v: Vector3(v).normalized().data, [v3]),
case("vector.Vector3.dot", G, lambda a, b: Vector3(a).dot(Vector3(b)).data, [v3, torch.randn(4, 3)]),
case("vector.Vector3.squared_norm", G, lambda v: Vector3(v).squared_norm().data, [v3]),
case(
"vector.Vector3.from_coords",
G,
lambda x, y, z: Vector3.from_coords(x, y, z).data,
[torch.randn(4), torch.randn(4), torch.randn(4)],
),
case("vector.Vector3.xyz", G, lambda v: (Vector3(v).x, Vector3(v).y, Vector3(v).z), [v3]),
case(
"vector.Vector3.arith",
G,
lambda a, b: (Vector3(a) + Vector3(b)).data * 2.0 - (Vector3(a) - Vector3(b)).data,
[v3, torch.randn(4, 3)],
note="TensorWrapper __add__/__sub__/__mul__",
),
case("vector.Vector2.normalized", G, lambda v: Vector2(v).normalized().data, [torch.randn(4, 2)]),
case("vector.Vector2.dot", G, lambda a, b: Vector2(a).dot(Vector2(b)).data, [torch.randn(4, 2), torch.randn(4, 2)]),
case("vector.Vector2.squared_norm", G, lambda v: Vector2(v).squared_norm().data, [torch.randn(4, 2)]),
case(
"vector.Vector2.from_coords", G, lambda x, y: Vector2.from_coords(x, y).data, [torch.randn(4), torch.randn(4)]
),
case("vector.Scalar", G, lambda s: (Scalar(s) * 2.0).data, [torch.randn(4)]),
case("vector.Vector3.random", G, None, [], skip="random constructor; no tensor input, non-deterministic"),
]
G = "geometry.pose"
CASES += [
case(
"pose.NamedPose.from_matrix.transform_points",
G,
lambda M, p: NamedPose.from_matrix(M, "a", "b").transform_points(p),
[pose44, pts3[0]],
tags=("points", "3d"),
note="points (N,3) with a batch-1 pose; (B,N,3) is rejected by So3.__mul__",
),
case(
"pose.NamedPose.from_matrix.pose",
G,
lambda M: NamedPose.from_matrix(M, "a", "b").pose.matrix(),
[pose44],
tags=("3d",),
),
case(
"pose.NamedPose.from_rt",
G,
lambda R, t: NamedPose.from_rt(R, t, "a", "b").pose.matrix(),
[so3.matrix(), torch.tensor([[0.5, -1.0, 2.0]])],
tags=("3d",),
note="rotation as (B,3,3) matrix",
),
case(
"pose.NamedPose.inverse",
G,
lambda M: NamedPose.from_matrix(M, "a", "b").inverse().pose.matrix(),
[pose44],
tags=("3d",),
),
case(
"pose.NamedPose.mul",
G,
lambda M: (NamedPose.from_matrix(M, "b", "c") * NamedPose.from_matrix(M, "a", "b")).pose.matrix(),
[pose44],
tags=("3d",),
),
case(
"pose.NamedPose.rotation_translation",
G,
lambda M: (lambda np_: (np_.rotation.matrix(), np_.translation))(NamedPose.from_matrix(M, "a", "b")),
[pose44],
tags=("3d",),
),
case(
"pose.NamedPose.from_matrix[se2]",
G,
lambda M, p: NamedPose.from_matrix(M, "a", "b").transform_points(p),
[
torch.tensor(
[[[math.cos(0.3), -math.sin(0.3), 1.0], [math.sin(0.3), math.cos(0.3), -2.0], [0.0, 0.0, 1.0]]]
),
torch.randn(5, 2),
],
tags=("points",),
note="3x3 -> Se2 path; points (N,2)",
),
case("pose._check_matrix_shape", G, None, [], skip="validation helper, returns None"),
case(
"pose.Quaternion/Se2/Se3/So2/So3",
G,
None,
[],
skip="re-exports of kornia.geometry.liegroup / quaternion β covered by the liegroup area",
),
]
if __name__ == "__main__":
run_cases(CASES, sys.argv[1], only=sys.argv[2:] or None)