π 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.
#
import itertools
import math
import warnings
import numpy as np
import pytest
import torch
import kornia
from kornia.core.check import are_checks_enabled, disable_checks, enable_checks
from kornia.core.exceptions import DeviceError, ShapeError, TypeCheckError
from testing.base import DYNAMO_UNAVAILABLE_REASON, BaseTester, dynamo_is_available, supports_reflect_padding
class TestResize(BaseTester):
@pytest.mark.parametrize(
"shape, divisible_factor, expected",
[
((10, 14), 24, (24, 24)),
((1, 3, 10, 14), 32, (1, 3, 32, 32)),
((3, 10, 14), 4, (3, 8, 16)),
((3, 14, 10), 4, (3, 16, 8)),
((3, 10, 14), 24, (3, 24, 24)),
((1, 3, 10, 14), 24, (1, 3, 24, 24)),
((2, 1, 3, 10, 14), 24, (2, 1, 3, 24, 24)),
],
)
def test_resize_to_be_divisible_short_sides(self, shape, divisible_factor, expected, device, dtype):
inp = torch.rand(*shape, device=device, dtype=dtype)
out = kornia.geometry.transform.resize_to_be_divisible(inp, divisible_factor)
assert out.shape == expected
@pytest.mark.parametrize("kwargs", [{}, {"side": None}])
def test_resize_to_be_divisible_default_side(self, kwargs, device, dtype):
inp = torch.rand(1, 1, 6, 12, device=device, dtype=dtype)
with warnings.catch_warnings():
warnings.simplefilter("error", DeprecationWarning)
out = kornia.geometry.transform.resize_to_be_divisible(inp, 5, **kwargs)
assert out.shape == (1, 1, 5, 10)
@pytest.mark.parametrize("shape", [(1, 1, 6, 12), (2, 3, 17, 9), (1, 1, 5, 10), (1, 1, 0, 12)])
@pytest.mark.parametrize("side", ["short", "long", "vert", "horz", "bogus"])
def test_resize_to_be_divisible_deprecated_side(self, shape, side, device, dtype):
inp = torch.rand(*shape, device=device, dtype=dtype)
expected = kornia.geometry.transform.resize_to_be_divisible(inp, 5)
with pytest.warns(DeprecationWarning, match="side.*has no effect") as records:
out = kornia.geometry.transform.resize_to_be_divisible(inp, 5, side=side)
assert len(records) == 1
assert records[0].filename == __file__
self.assert_close(out, expected, rtol=0, atol=0)
@pytest.mark.parametrize("side", ["short", "long", "vert", "horz", "bogus"])
@pytest.mark.skipif(not dynamo_is_available(), reason=DYNAMO_UNAVAILABLE_REASON)
def test_resize_to_be_divisible_compile_fullgraph(self, side, device, dtype, torch_optimizer, optimizer_backend):
if not optimizer_backend or optimizer_backend == "jit":
pytest.skip("Fullgraph requires a torch.compile backend, not TorchScript or the no-op optimizer.")
inp = torch.rand(1, 1, 6, 12, device=device, dtype=dtype)
expected = kornia.geometry.transform.resize_to_be_divisible(inp, 5)
op = torch_optimizer(kornia.geometry.transform.resize_to_be_divisible, fullgraph=True)
with warnings.catch_warnings():
warnings.filterwarnings("error", message=r".*resize_to_be_divisible.*side", category=DeprecationWarning)
out = op(inp, 5, side=side)
self.assert_close(out, expected)
def test_resize_to_be_divisible_numpy_factor_and_empty_side(self, device, dtype):
resize_to_be_divisible = kornia.geometry.transform.resize_to_be_divisible
inp = torch.rand(1, 3, 10, 14, device=device, dtype=dtype)
assert resize_to_be_divisible(inp, np.int64(4)).shape == (1, 3, 8, 16)
# An empty side is already divisible and stays empty, as in resize.
empty = torch.zeros(1, 3, 0, 14, device=device, dtype=dtype)
assert resize_to_be_divisible(empty, 4).shape == (1, 3, 0, 16)
assert resize_to_be_divisible(empty.transpose(-1, -2), 4).shape == (1, 3, 16, 0)
def test_resize_to_be_divisible_rejects_invalid_inputs(self, device, dtype):
resize_to_be_divisible = kornia.geometry.transform.resize_to_be_divisible
with pytest.raises(TypeError, match="is not a torch"):
resize_to_be_divisible([[0.0, 1.0]], 4)
with pytest.raises(ValueError, match="at least two dimensions"):
resize_to_be_divisible(torch.rand(4, device=device, dtype=dtype), 4)
inp = torch.rand(4, 4, device=device, dtype=dtype)
for divisible_factor in (0, -1, 2.5):
with pytest.raises(ValueError, match="positive integer"):
resize_to_be_divisible(inp, divisible_factor)
def test_smoke(self, device, dtype):
inp = torch.rand(1, 3, 3, 4, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, (3, 4), align_corners=False)
self.assert_close(inp, out, atol=1e-4, rtol=1e-4)
# 2D
inp = torch.rand(3, 4, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, (3, 4), align_corners=False)
self.assert_close(inp, out, atol=1e-4, rtol=1e-4)
# 3D
inp = torch.rand(3, 3, 4, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, (3, 4), align_corners=False)
self.assert_close(inp, out, atol=1e-4, rtol=1e-4)
# arbitrary dim
inp = torch.rand(1, 2, 3, 2, 1, 3, 3, 4, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, (3, 4), align_corners=False)
self.assert_close(inp, out, atol=1e-4, rtol=1e-4)
def test_upsize(self, device, dtype):
inp = torch.rand(1, 3, 3, 4, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, (6, 8), align_corners=False)
assert out.shape == (1, 3, 6, 8)
# 2D
inp = torch.rand(3, 4, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, (6, 8), align_corners=False)
assert out.shape == (6, 8)
# 3D
inp = torch.rand(3, 3, 4, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, (6, 8), align_corners=False)
assert out.shape == (3, 6, 8)
# arbitrary dim
inp = torch.rand(1, 2, 3, 2, 1, 3, 3, 4, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, (6, 8), align_corners=False)
assert out.shape == (1, 2, 3, 2, 1, 3, 6, 8)
def test_downsize(self, device, dtype):
inp = torch.rand(1, 3, 5, 2, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, (3, 1), align_corners=False)
assert out.shape == (1, 3, 3, 1)
# 2D
inp = torch.rand(5, 2, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, (3, 1), align_corners=False)
assert out.shape == (3, 1)
# 3D
inp = torch.rand(3, 5, 2, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, (3, 1), align_corners=False)
assert out.shape == (3, 3, 1)
# arbitrary dim
inp = torch.rand(1, 2, 3, 2, 1, 3, 5, 2, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, (3, 1), align_corners=False)
assert out.shape == (1, 2, 3, 2, 1, 3, 3, 1)
def test_zero_output_size(self, device, dtype):
# A zero output side gives an empty image, matching warp_affine,
# warp_perspective and center_crop on the same argument.
inp = torch.rand(1, 3, 4, 4, device=device, dtype=dtype)
assert kornia.geometry.transform.resize(inp, (0, 4)).shape == (1, 3, 0, 4)
assert kornia.geometry.transform.resize(inp, (4, 0)).shape == (1, 3, 4, 0)
assert kornia.geometry.transform.resize(inp, (0, 0)).shape == (1, 3, 0, 0)
assert kornia.geometry.transform.resize(inp, 0).shape == (1, 3, 0, 0)
assert kornia.geometry.transform.Resize((0, 4))(inp).shape == (1, 3, 0, 4)
assert kornia.geometry.transform.resize(inp, (0, 4), antialias=True).shape == (1, 3, 0, 4)
eye = torch.eye(2, 3, device=device, dtype=dtype)[None]
assert kornia.geometry.transform.warp_affine(inp, eye, (0, 4)).shape == (1, 3, 0, 4)
# The empty result stays attached to the graph, as it does for the warping ops:
# _empty_warp_output_2d builds a connected tensor precisely so a batch that
# degenerates to a zero-sized output still contributes a zero gradient.
grad_inp = torch.rand(1, 3, 4, 4, device=device, dtype=dtype, requires_grad=True)
empty = kornia.geometry.transform.resize(grad_inp, (0, 4))
assert empty.requires_grad
assert empty.dtype == grad_inp.dtype
empty.sum().backward()
assert grad_inp.grad is not None
# 2D
inp_2d = torch.rand(4, 4, device=device, dtype=dtype)
assert kornia.geometry.transform.resize(inp_2d, (0, 4)).shape == (0, 4)
# 3D
inp_3d = torch.rand(3, 4, 4, device=device, dtype=dtype)
assert kornia.geometry.transform.resize(inp_3d, (0, 4)).shape == (3, 0, 4)
# arbitrary dim
inp_nd = torch.rand(2, 1, 3, 4, 4, device=device, dtype=dtype)
assert kornia.geometry.transform.resize(inp_nd, (0, 4)).shape == (2, 1, 3, 0, 4)
def test_zero_input_size(self, device, dtype):
# A degenerate input is rejected with the message the warping ops already
# use, instead of a bare ZeroDivisionError out of the aspect-ratio division.
inp = torch.rand(1, 3, 0, 4, device=device, dtype=dtype)
with pytest.raises(ValueError, match="Input image size must be positive"):
kornia.geometry.transform.resize(inp, (2, 2))
with pytest.raises(ValueError, match="Input image size must be positive"):
kornia.geometry.transform.resize(inp, 2)
# Empty in and empty out is not undefined, so it comes back empty rather than
# raising -- the same answer warp_affine and center_crop give.
assert kornia.geometry.transform.resize(inp, (0, 4)).shape == (1, 3, 0, 4)
assert kornia.geometry.transform.resize(inp, (0, 2)).shape == (1, 3, 0, 2)
eye = torch.eye(2, 3, device=device, dtype=dtype)[None]
assert kornia.geometry.transform.warp_affine(inp, eye, (0, 4)).shape == (1, 3, 0, 4)
assert kornia.geometry.transform.center_crop(inp, (0, 4)).shape == (1, 3, 0, 4)
def test_downsizeAA(self, device, dtype):
inp = torch.rand(1, 3, 10, 8, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, (5, 3), align_corners=False, antialias=True)
assert out.shape == (1, 3, 5, 3)
inp = torch.rand(1, 1, 20, 10, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, (15, 8), align_corners=False, antialias=True)
assert out.shape == (1, 1, 15, 8)
# 2D
inp = torch.rand(10, 8, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, (5, 3), align_corners=False, antialias=True)
assert out.shape == (5, 3)
# 3D
inp = torch.rand(3, 10, 8, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, (5, 3), align_corners=False, antialias=True)
assert out.shape == (3, 5, 3)
# arbitrary dim
inp = torch.rand(1, 2, 3, 2, 1, 3, 10, 8, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, (5, 3), align_corners=False, antialias=True)
assert out.shape == (1, 2, 3, 2, 1, 3, 5, 3)
@pytest.mark.parametrize("leading_shape", [(), (2,), (2, 3), (2, 1, 3)])
@pytest.mark.parametrize("transpose", [False, True])
@pytest.mark.parametrize("singleton_output", [1, 3])
def test_antialias_singleton_axis(self, leading_shape, transpose, singleton_output, device, dtype):
if not supports_reflect_padding(device, dtype):
pytest.skip(f"this torch build has no reflect padding kernel for {dtype} on {device.type}")
# Repeating a row cannot change its horizontal antialiasing. The repeated image also
# supplies a reference that the old reflect-padding path can process.
row = torch.arange(8, device=device, dtype=dtype).reshape(*([1] * len(leading_shape)), 1, 8)
image = row.expand(*leading_shape, 1, 8)
repeated = image.expand(*leading_shape, 3, 8)
size = (singleton_output, 4)
reference_size = (3, 4)
if transpose:
image = image.transpose(-1, -2)
repeated = repeated.transpose(-1, -2)
size = size[::-1]
reference_size = reference_size[::-1]
expected = kornia.geometry.transform.resize(repeated, reference_size, antialias=True)
if transpose:
expected = expected[..., :1].expand(*leading_shape, 4, singleton_output)
else:
expected = expected[..., :1, :].expand(*leading_shape, singleton_output, 4)
actual = kornia.geometry.transform.resize(image, size, antialias=True)
assert actual.shape == (*leading_shape, *size)
assert actual.dtype == dtype
assert actual.device == device
self.assert_close(actual, expected)
# The downscaled axis is still filtered, including at its reflected endpoints.
unfiltered = kornia.geometry.transform.resize(image, size)
assert not torch.allclose(actual, unfiltered)
@pytest.mark.parametrize("transpose", [False, True])
@pytest.mark.parametrize("rows", [2, 3])
def test_antialias_blurs_a_two_or_three_pixel_axis(self, rows, transpose, device, dtype):
if not supports_reflect_padding(device, dtype):
pytest.skip(f"this torch build has no reflect padding kernel for {dtype} on {device.type}")
# Only a singleton axis skips the Gaussian. Two or three rows shrunk to one are blurred with sigma
# (rows - 1) / 2 over taps -(rows - 1) .. rows - 1, reflected at the border; the columns keep their size, so
# their kernel is the identity. Nearest keeps row 0 of the blurred rows, and row i is row 0 + 8 i.
image = torch.arange(rows * 8, device=device, dtype=dtype).reshape(1, 1, rows, 8)
taps = torch.arange(1 - rows, rows, dtype=torch.float64)
weights = torch.exp(-(taps**2) / (2 * ((rows - 1) / 2) ** 2))
offset = 8 * float((weights * taps.abs()).sum() / weights.sum())
expected = torch.arange(8, dtype=torch.float64).add(offset).reshape(1, 1, 1, 8)
size = (1, 8)
if transpose:
image, expected, size = image.transpose(-1, -2), expected.transpose(-1, -2), size[::-1]
actual = kornia.geometry.transform.resize(image, size, interpolation="nearest", antialias=True)
self.assert_close(actual, expected.to(device, dtype))
@pytest.mark.parametrize("transpose", [False, True])
def test_antialias_singleton_wrappers(self, transpose, device, dtype):
if not supports_reflect_padding(device, dtype):
pytest.skip(f"this torch build has no reflect padding kernel for {dtype} on {device.type}")
image = torch.arange(8, device=device, dtype=dtype).reshape(1, 1, 1, 8)
size, factor = (1, 4), (1.0, 0.5)
if transpose:
image = image.transpose(-1, -2)
size, factor = size[::-1], factor[::-1]
expected = kornia.geometry.transform.resize(image, size, antialias=True)
self.assert_close(kornia.geometry.transform.Resize(size, antialias=True)(image), expected)
self.assert_close(kornia.geometry.transform.rescale(image, factor, antialias=True), expected)
@pytest.mark.parametrize("transpose", [False, True])
def test_antialias_singleton_gradcheck(self, transpose, device):
image = torch.arange(8, device=device, dtype=torch.float64).reshape(1, 1, 1, 8).requires_grad_()
size = (1, 4)
if transpose:
image, size = image.transpose(-1, -2), size[::-1]
self.gradcheck(lambda x: kornia.geometry.transform.resize(x, size, antialias=True), (image,))
def test_dynamo_singleton_antialias(self, device, dtype, torch_optimizer):
if not supports_reflect_padding(device, dtype):
pytest.skip(f"this torch build has no reflect padding kernel for {dtype} on {device.type}")
image = torch.arange(8, device=device, dtype=dtype).reshape(1, 1, 1, 8)
op = torch_optimizer(kornia.geometry.transform.resize, fullgraph=True)
expected = kornia.geometry.transform.resize(image, (1, 4), antialias=True)
self.assert_close(op(image, (1, 4), antialias=True), expected)
def test_one_param(self, device, dtype):
inp = torch.rand(1, 3, 5, 2, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, 10, align_corners=False)
assert out.shape == (1, 3, 25, 10)
# 2D
inp = torch.rand(5, 2, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, 10, align_corners=False)
assert out.shape == (25, 10)
# 3D
inp = torch.rand(3, 5, 2, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, 10, align_corners=False)
assert out.shape == (3, 25, 10)
# arbitrary dim
inp = torch.rand(1, 2, 3, 2, 1, 3, 5, 2, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, 10, align_corners=False)
assert out.shape == (1, 2, 3, 2, 1, 3, 25, 10)
def test_one_param_long(self, device, dtype):
inp = torch.rand(1, 3, 5, 2, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, 10, align_corners=False, side="long")
assert out.shape == (1, 3, 10, 4)
# 2D
inp = torch.rand(5, 2, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, 10, align_corners=False, side="long")
assert out.shape == (10, 4)
# 3D
inp = torch.rand(3, 5, 2, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, 10, align_corners=False, side="long")
assert out.shape == (3, 10, 4)
# arbitrary dim
inp = torch.rand(1, 2, 3, 2, 1, 3, 5, 2, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, 10, align_corners=False, side="long")
assert out.shape == (1, 2, 3, 2, 1, 3, 10, 4)
def test_one_param_vert(self, device, dtype):
inp = torch.rand(1, 3, 5, 2, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, 10, align_corners=False, side="vert")
assert out.shape == (1, 3, 10, 4)
# 2D
inp = torch.rand(5, 2, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, 10, align_corners=False, side="vert")
assert out.shape == (10, 4)
# 3D
inp = torch.rand(3, 5, 2, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, 10, align_corners=False, side="vert")
assert out.shape == (3, 10, 4)
# arbitrary dim
inp = torch.rand(1, 2, 3, 2, 1, 3, 5, 2, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, 10, align_corners=False, side="vert")
assert out.shape == (1, 2, 3, 2, 1, 3, 10, 4)
def test_one_param_horz(self, device, dtype):
inp = torch.rand(1, 3, 2, 5, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, 10, align_corners=False, side="horz")
assert out.shape == (1, 3, 4, 10)
# 2D
inp = torch.rand(1, 3, 2, 5, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, 10, align_corners=False, side="horz")
assert out.shape == (1, 3, 4, 10)
# 3D
inp = torch.rand(1, 3, 2, 5, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, 10, align_corners=False, side="horz")
assert out.shape == (1, 3, 4, 10)
# arbitrary dim
inp = torch.rand(1, 3, 2, 5, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(inp, 10, align_corners=False, side="horz")
assert out.shape == (1, 3, 4, 10)
def test_convention_align_corners_default_none(self, device, dtype):
# resize's bare default align_corners=None behaves like align_corners=False (no test in the
# suite exercises the bare default; every other call here passes align_corners=False explicitly).
if dtype in (torch.float16, torch.bfloat16):
pytest.skip("hardcoded-literal pin only reliable at float32/float64 precision")
# Snippet used to generate expected:
# inp_x = torch.arange(20, dtype=torch.float32) / 20.0
# inp = inp_x[None].T @ inp_x[None]
# inp = inp[None, None]
# expected = kornia.geometry.transform.resize(inp, (5, 5), antialias=False) # no align_corners passed
inp_x = torch.arange(20, device=device, dtype=dtype) / 20.0
inp = inp_x[None].T @ inp_x[None]
inp = inp[None, None]
out = kornia.geometry.transform.resize(inp, (5, 5), antialias=False)
expected = torch.tensor(
[
[
[
[0.0056, 0.0206, 0.0356, 0.0506, 0.0656],
[0.0206, 0.0756, 0.1306, 0.1856, 0.2406],
[0.0356, 0.1306, 0.2256, 0.3206, 0.4156],
[0.0506, 0.1856, 0.3206, 0.4556, 0.5906],
[0.0656, 0.2406, 0.4156, 0.5906, 0.7656],
]
]
],
device=device,
dtype=dtype,
)
self.assert_close(out, expected, atol=1e-3, rtol=1e-3)
# the output above cannot distinguish None from False (they interpolate identically), so
# the documented default is additionally pinned on the signature itself
import inspect
assert inspect.signature(kornia.geometry.transform.resize).parameters["align_corners"].default is None
def test_gradcheck(self, device):
# test parameters
new_size = 4
inp = torch.rand(1, 2, 3, 4, device=device, dtype=torch.float64)
self.gradcheck(kornia.geometry.transform.Resize(new_size, align_corners=False), (inp,))
@pytest.mark.parametrize("anti_alias", [True, False])
def test_dynamo(self, device, dtype, anti_alias, torch_optimizer):
new_size = (5, 6)
inp = torch.rand(1, 2, 3, 4, device=device, dtype=dtype)
op = torch_optimizer(kornia.geometry.transform.resize)
out = op(inp, new_size, align_corners=False, antialias=anti_alias)
assert out.shape == (1, 2, 5, 6)
expected = op(inp, new_size, align_corners=False, antialias=anti_alias)
self.assert_close(out, expected)
@pytest.mark.parametrize("interpolation", ["linear", "trilinear"])
@pytest.mark.parametrize("shape", [(3, 16, 20), (2, 3, 16, 20), (2, 3, 4, 16, 20)])
@pytest.mark.parametrize("api", ["resize", "Resize", "rescale", "Rescale"])
def test_one_and_three_dimensional_modes_raise_6012(self, interpolation, shape, api, device, dtype):
# Every input is resampled as a 4-D batch, which F.interpolate rejects for these modes; this used to
# surface as its raw "Got 4D input" NotImplementedError although the docstrings listed both modes.
image = torch.rand(shape, device=device, dtype=dtype)
T = kornia.geometry.transform
calls = {
"resize": lambda: T.resize(image, (8, 10), interpolation=interpolation),
"Resize": lambda: T.Resize((8, 10), interpolation=interpolation)(image),
"rescale": lambda: T.rescale(image, 0.5, interpolation=interpolation),
"Rescale": lambda: T.Rescale(0.5, interpolation=interpolation, align_corners=None)(image),
}
with pytest.raises(ValueError, match=f"interpolation='{interpolation}' is not supported: resize resamples"):
calls[api]()
@pytest.mark.parametrize("interpolation", ["nearest", "nearest-exact", "bilinear", "bicubic", "area"])
def test_documented_modes_resize_6012(self, interpolation, device, dtype):
# Each mode the docstrings list resamples a (B, C, H, W) batch.
image = torch.rand(2, 3, 16, 20, device=device, dtype=dtype)
out = kornia.geometry.transform.resize(image, (8, 10), interpolation=interpolation)
assert out.shape == (2, 3, 8, 10)
@pytest.mark.parametrize("interpolation", ["linear", "trilinear"])
@pytest.mark.parametrize("api", ["resize_empty_output", "resize_to_be_divisible", "crop_by_indices"])
def test_one_and_three_dimensional_modes_raise_in_resize_callers_6012(self, interpolation, api, device, dtype):
# An empty output side used to skip interpolate and return an empty tensor; resize_to_be_divisible, and
# crop_by_indices when a crop has to be resized, reach these modes through resize.
image = torch.zeros(2, 3, 16, 20, device=device, dtype=dtype)
box = torch.tensor([[[1, 1], [10, 1], [10, 8], [1, 8]]], device=device, dtype=dtype).repeat(2, 1, 1)
T = kornia.geometry.transform
calls = {
"resize_empty_output": lambda: T.resize(image, (0, 10), interpolation=interpolation),
"resize_to_be_divisible": lambda: T.resize_to_be_divisible(image, 7, interpolation=interpolation),
"crop_by_indices": lambda: T.crop_by_indices(image, box, size=(5, 6), interpolation=interpolation),
}
with pytest.raises(ValueError, match=f"interpolation='{interpolation}' is not supported: resize resamples"):
calls[api]()
class TestRescale(BaseTester):
def test_smoke(self, device, dtype):
input = torch.rand(1, 3, 3, 4, device=device, dtype=dtype)
output = kornia.geometry.transform.rescale(input, (1.0, 1.0), align_corners=False)
self.assert_close(input, output, atol=1e-4, rtol=1e-4)
def test_upsize(self, device, dtype):
input = torch.rand(1, 3, 3, 4, device=device, dtype=dtype)
output = kornia.geometry.transform.rescale(input, (3.0, 2.0), align_corners=False)
assert output.shape == (1, 3, 9, 8)
def test_downsize(self, device, dtype):
input = torch.rand(1, 3, 9, 8, device=device, dtype=dtype)
output = kornia.geometry.transform.rescale(input, (1.0 / 3.0, 1.0 / 2.0), align_corners=False)
assert output.shape == (1, 3, 3, 4)
def test_zero_factor(self, device, dtype):
# A zero factor asks for a zero-sized output, which gives an empty image
# rather than a ZeroDivisionError.
inp = torch.rand(1, 3, 4, 4, device=device, dtype=dtype)
assert kornia.geometry.transform.rescale(inp, 0.0).shape == (1, 3, 0, 0)
assert kornia.geometry.transform.rescale(inp, (0.0, 1.0)).shape == (1, 3, 0, 4)
assert kornia.geometry.transform.Rescale(0.0)(inp).shape == (1, 3, 0, 0)
def test_downscale_values(self, device, dtype):
inp_x = torch.arange(20, device=device, dtype=dtype) / 20.0
inp = inp_x[None].T @ inp_x[None]
inp = inp[None, None]
out = kornia.geometry.transform.rescale(inp, (0.25, 0.25), antialias=False, align_corners=False)
expected = torch.tensor(
[
[
[
[0.0056, 0.0206, 0.0356, 0.0506, 0.0656],
[0.0206, 0.0756, 0.1306, 0.1856, 0.2406],
[0.0356, 0.1306, 0.2256, 0.3206, 0.4156],
[0.0506, 0.1856, 0.3206, 0.4556, 0.5906],
[0.0656, 0.2406, 0.4156, 0.5906, 0.7656],
]
]
],
device=device,
dtype=dtype,
)
self.assert_close(out, expected, atol=1e-3, rtol=1e-3)
def test_downscale_values_AA(self, device, dtype):
inp_x = torch.arange(20, device=device, dtype=dtype) / 20.0
inp = inp_x[None].T @ inp_x[None]
inp = inp[None, None]
out = kornia.geometry.transform.rescale(inp, (0.25, 0.25), antialias=True, align_corners=False)
expected = torch.tensor(
[
[
[
[0.0074, 0.0237, 0.0409, 0.0581, 0.0743],
[0.0237, 0.0756, 0.1306, 0.1856, 0.2376],
[0.0409, 0.1306, 0.2256, 0.3206, 0.4104],
[0.0581, 0.1856, 0.3206, 0.4556, 0.5832],
[0.0743, 0.2376, 0.4104, 0.5832, 0.7464],
]
]
],
device=device,
dtype=dtype,
)
self.assert_close(out, expected, atol=1e-3, rtol=1e-3)
def test_one_param(self, device, dtype):
input = torch.rand(1, 3, 3, 4, device=device, dtype=dtype)
output = kornia.geometry.transform.rescale(input, 2.0, align_corners=False)
assert output.shape == (1, 3, 6, 8)
def test_gradcheck(self, device):
input = torch.rand(1, 2, 3, 4, device=device, dtype=torch.float64)
self.gradcheck(kornia.geometry.transform.Rescale(2.0, align_corners=False), (input,), nondet_tol=1e-8)
@pytest.mark.parametrize("interpolation", ["nearest", "nearest-exact", "area"])
@pytest.mark.parametrize("factor", [0.5, 2.0])
def test_non_interpolating_modes_ignore_align_corners_5998(self, interpolation, factor, device, dtype):
# The module's default align_corners=True used to reach F.interpolate, which rejects it for these modes.
input = torch.rand(2, 3, 4, 6, device=device, dtype=dtype)
out = kornia.geometry.transform.Rescale(factor, interpolation=interpolation)(input)
expected = kornia.geometry.transform.rescale(input, factor, interpolation=interpolation)
self.assert_close(out, expected, rtol=0.0, atol=0.0)
explicit = kornia.geometry.transform.Rescale(factor, interpolation=interpolation, align_corners=False)(input)
self.assert_close(explicit, expected, rtol=0.0, atol=0.0)
@pytest.mark.parametrize("interpolation", ["bilinear", "bicubic"])
def test_interpolating_modes_keep_align_corners_default_5998(self, interpolation, device, dtype):
# The interpolating modes still use the module's default align_corners=True.
input = torch.rand(2, 3, 4, 6, device=device, dtype=dtype)
out = kornia.geometry.transform.Rescale(0.5, interpolation=interpolation)(input)
expected = kornia.geometry.transform.rescale(input, 0.5, interpolation=interpolation, align_corners=True)
self.assert_close(out, expected, rtol=0.0, atol=0.0)
class TestUnbatchedTransforms(BaseTester):
@pytest.mark.parametrize("operation", ["rotate", "Rotate", "scale", "Scale", "rotate3d", "Affine"])
@pytest.mark.parametrize("channels", [1, 3])
@pytest.mark.parametrize("custom_center", [False, True])
def test_matches_singleton_batch(self, device, dtype, operation, channels, custom_center):
shape = (channels, 4, 5, 7) if operation == "rotate3d" else (channels, 5, 7)
image = torch.arange(math.prod(shape), device=device, dtype=dtype).reshape(shape) / math.prod(shape)
image.requires_grad_()
value = 1.2 if operation in ("scale", "Scale") else 23.0
parameter = torch.tensor([value], device=device, dtype=dtype, requires_grad=True)
center = None
if custom_center:
dimensions = 3 if operation == "rotate3d" else 2
center = torch.full((1, dimensions), 1.3, device=device, dtype=dtype, requires_grad=True)
if operation == "rotate3d":
def fn(x: torch.Tensor) -> torch.Tensor:
return kornia.geometry.transform.rotate3d(x, parameter, parameter, parameter, center)
elif operation in ("scale", "Scale"):
fn = kornia.geometry.transform.Scale(parameter, center)
if operation == "scale":
def fn(x: torch.Tensor) -> torch.Tensor:
return kornia.geometry.transform.scale(x, parameter, center)
elif operation == "Affine":
fn = kornia.geometry.transform.Affine(angle=parameter, center=center)
else:
fn = kornia.geometry.transform.Rotate(parameter, center)
if operation == "rotate":
def fn(x: torch.Tensor) -> torch.Tensor:
return kornia.geometry.transform.rotate(x, parameter, center)
actual = fn(image)
expected = fn(image.unsqueeze(0)).squeeze(0)
assert actual.shape == image.shape
self.assert_close(actual, expected)
inputs = (image, parameter) if center is None else (image, parameter, center)
actual_grads = torch.autograd.grad(actual.sum(), inputs)
expected_grads = torch.autograd.grad(expected.sum(), inputs)
for actual_grad, expected_grad in zip(actual_grads, expected_grads):
self.assert_close(actual_grad, expected_grad)
class TestRotate(BaseTester):
@pytest.mark.parametrize("align_corners", [False, True])
@pytest.mark.parametrize("center_shape", [None, (2,), (1, 2), (3, 2)])
@pytest.mark.parametrize("train_transform", [False, True])
def test_shared_angle_values_and_gradients(self, device, dtype, align_corners, center_shape, train_transform):
image = torch.rand(3, 2, 5, 7, device=device, dtype=dtype, requires_grad=True)
angle = torch.tensor([23.0], device=device, dtype=dtype, requires_grad=train_transform)
center = None
if center_shape is not None:
center = torch.full(center_shape, 1.3, device=device, dtype=dtype, requires_grad=train_transform)
actual = kornia.geometry.transform.rotate(image, angle, center, align_corners=align_corners)
expanded_center = None if center is None else center.expand(3, -1)
expected = kornia.geometry.transform.rotate(
image, angle.expand(3), expanded_center, align_corners=align_corners
)
self.assert_close(actual, expected)
inputs = tuple(t for t in (image, angle, center) if t is not None and t.requires_grad)
weights = torch.rand_like(actual)
actual_grads = torch.autograd.grad(actual, inputs, weights)
expected_grads = torch.autograd.grad(expected, inputs, weights)
for actual_grad, expected_grad in zip(actual_grads, expected_grads):
self.assert_close(actual_grad, expected_grad)
def test_independent_equal_angles_gradients(self, device, dtype):
image = torch.rand(3, 1, 5, 7, device=device, dtype=dtype)
angle = torch.full((3,), 23.0, device=device, dtype=dtype, requires_grad=True)
actual = kornia.geometry.transform.rotate(image, angle)
expected = torch.cat([kornia.geometry.transform.rotate(image[i : i + 1], angle[i : i + 1]) for i in range(3)])
self.assert_close(actual, expected)
self.assert_close(torch.autograd.grad(actual.sum(), angle)[0], torch.autograd.grad(expected.sum(), angle)[0])
@pytest.mark.skipif(not dynamo_is_available(), reason=DYNAMO_UNAVAILABLE_REASON)
def test_shared_angle_export(self, device, dtype):
image = torch.rand(3, 2, 5, 7, device=device, dtype=dtype)
angle = torch.tensor([23.0], device=device, dtype=dtype)
module = kornia.geometry.transform.Rotate(angle)
exported = torch.export.export(module, (image,)).module()
self.assert_close(exported(image), module(image))
def test_shared_angle_trace(self, device, dtype):
image = torch.rand(3, 2, 5, 7, device=device, dtype=dtype)
angle = torch.tensor([23.0], device=device, dtype=dtype)
traced = torch.jit.trace(kornia.geometry.transform.rotate, (image, angle), check_trace=False)
if dtype in (torch.float16, torch.bfloat16):
# Tracing uses affine_grid rather than the eager grid expression. Their rounding already
# differs on CUDA half on the baseline, so compare with the same traced per-image path.
def expanded_rotation(image, angle):
return kornia.geometry.transform.rotate(image, angle.expand(image.shape[0]))
reference = torch.jit.trace(expanded_rotation, (image, angle), check_trace=False)
expected = reference(image, angle)
else:
expected = kornia.geometry.transform.rotate(image, angle)
self.assert_close(traced(image, angle), expected)
def test_trace_generalizes_over_image_and_angle_batches(self, device, dtype):
image = torch.rand(1, 1, 5, 7, device=device, dtype=dtype)
angle = torch.tensor([23.0], device=device, dtype=dtype)
traced = torch.jit.trace(kornia.geometry.transform.rotate, (image, angle), check_trace=False)
image = torch.rand(4, 1, 5, 7, device=device, dtype=dtype)
angle = torch.tensor([0.0, 10.0, 20.0, 30.0], device=device, dtype=dtype)
if dtype in (torch.float16, torch.bfloat16):
# See test_shared_angle_trace: compare two traced affine_grid paths at reduced precision.
def expanded_rotation(image, angle):
return kornia.geometry.transform.rotate(image, angle.expand(image.shape[0]))
expected = torch.jit.trace(expanded_rotation, (image[:1], angle[:1]), check_trace=False)(image, angle)
else:
expected = kornia.geometry.transform.rotate(image, angle)
self.assert_close(traced(image, angle), expected)
@pytest.mark.parametrize("op", ["rotate", "Rotate", "affine"])
def test_shared_trace_generalizes_over_batch(self, device, dtype, op):
# A trace (and the TorchScript ONNX export built on it) recorded at batch 1 must not bake in the batch.
angle = torch.tensor([23.0], device=device, dtype=dtype)
matrix = torch.tensor([[[0.9, 0.2, 1.0], [-0.1, 1.1, -0.5]]], device=device, dtype=dtype)
fns = {
"rotate": lambda x: kornia.geometry.transform.rotate(x, angle),
"Rotate": kornia.geometry.transform.Rotate(angle),
"affine": lambda x: kornia.geometry.transform.affine(x, matrix),
}
fn = fns[op]
traced = torch.jit.trace(fn, torch.rand(1, 2, 5, 7, device=device, dtype=dtype), check_trace=False)
image = torch.rand(4, 2, 5, 7, device=device, dtype=dtype)
if dtype in (torch.float16, torch.bfloat16):
# Tracing builds the grid with affine_grid; compare shapes only, see test_shared_angle_trace.
assert traced(image).shape == image.shape
else:
self.assert_close(traced(image), fn(image))
def test_angle90(self, device, dtype):
# prepare input data
inp = torch.tensor([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]]], device=device, dtype=dtype)
expected = torch.tensor([[[0.0, 0.0], [4.0, 6.0], [3.0, 5.0], [0.0, 0.0]]], device=device, dtype=dtype)
# prepare transformation
angle = torch.tensor([90.0], device=device, dtype=dtype)
transform = kornia.geometry.transform.Rotate(angle, align_corners=True)
self.assert_close(transform(inp), expected, atol=1e-4, rtol=1e-4)
def test_angle90_batch2(self, device, dtype):
# prepare input data
inp = torch.tensor([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]]], device=device, dtype=dtype).repeat(
2, 1, 1, 1
)
expected = torch.tensor(
[[[[0.0, 0.0], [4.0, 6.0], [3.0, 5.0], [0.0, 0.0]]], [[[0.0, 0.0], [5.0, 3.0], [6.0, 4.0], [0.0, 0.0]]]],
device=device,
dtype=dtype,
)
# prepare transformation
angle = torch.tensor([90.0, -90.0], device=device, dtype=dtype)
transform = kornia.geometry.transform.Rotate(angle, align_corners=True)
self.assert_close(transform(inp), expected, atol=1e-4, rtol=1e-4)
def test_angle90_batch2_broadcast(self, device, dtype):
# prepare input data
inp = torch.tensor([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]]], device=device, dtype=dtype).repeat(
2, 1, 1, 1
)
expected = torch.tensor(
[[[[0.0, 0.0], [4.0, 6.0], [3.0, 5.0], [0.0, 0.0]]], [[[0.0, 0.0], [4.0, 6.0], [3.0, 5.0], [0.0, 0.0]]]],
device=device,
dtype=dtype,
)
# prepare transformation
angle = torch.tensor([90.0], device=device, dtype=dtype)
transform = kornia.geometry.transform.Rotate(angle, align_corners=True)
self.assert_close(transform(inp), expected, atol=1e-4, rtol=1e-4)
def test_convention_align_corners_default_true(self, device, dtype):
# rotate/Rotate's bare default align_corners=True (every other test in this class passes
# align_corners=True explicitly to Rotate; this exercises the bare default).
if dtype in (torch.float16, torch.bfloat16):
pytest.skip("hardcoded-literal pin only reliable at float32/float64 precision")
# Snippet used to generate expected:
# inp = torch.tensor([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]]])
# angle = torch.tensor([90.0])
# expected = kornia.geometry.transform.Rotate(angle)(inp) # no align_corners passed
inp = torch.tensor([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]]], device=device, dtype=dtype)
expected = torch.tensor([[[0.0, 0.0], [4.0, 6.0], [3.0, 5.0], [0.0, 0.0]]], device=device, dtype=dtype)
angle = torch.tensor([90.0], device=device, dtype=dtype)
transform = kornia.geometry.transform.Rotate(angle)
self.assert_close(transform(inp), expected, atol=1e-4, rtol=1e-4)
# the function's own bare default must match (class and function defaults can diverge
# in this module β see Rescale vs rescale β so both APIs are pinned independently)
self.assert_close(kornia.geometry.transform.rotate(inp, angle), expected, atol=1e-4, rtol=1e-4)
def test_gradcheck(self, device):
# test parameters
angle = torch.tensor([90.0], device=device, dtype=torch.float64)
# evaluate function gradient
input = torch.rand(1, 2, 3, 4, device=device, dtype=torch.float64)
self.gradcheck(kornia.geometry.transform.rotate, (input, angle))
@pytest.mark.skip("Need deep look into it since crashes everywhere.")
@pytest.mark.skip(reason="turn off all jit for a while")
def test_jit(self, device, dtype):
angle = torch.tensor([90.0], device=device, dtype=dtype)
batch_size, channels, height, width = 2, 3, 64, 64
img = torch.ones(batch_size, channels, height, width, device=device, dtype=dtype)
rot = kornia.geometry.transform.Rotate(angle)
rot_traced = torch.jit.trace(kornia.geometry.transform.Rotate(angle), img)
self.assert_close(rot(img), rot_traced(img))
class TestTranslate(BaseTester):
def test_dxdy(self, device, dtype):
# prepare input data
inp = torch.tensor([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]]], device=device, dtype=dtype)
expected = torch.tensor([[[0.0, 1.0], [0.0, 3.0], [0.0, 5.0], [0.0, 7.0]]], device=device, dtype=dtype)
# prepare transformation
translation = torch.tensor([[1.0, 0.0]], device=device, dtype=dtype)
transform = kornia.geometry.transform.Translate(translation, align_corners=True)
self.assert_close(transform(inp), expected, atol=1e-4, rtol=1e-4)
def test_dxdy_batch(self, device, dtype):
# prepare input data
inp = torch.tensor([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]]], device=device, dtype=dtype).repeat(
2, 1, 1, 1
)
expected = torch.tensor(
[[[[0.0, 1.0], [0.0, 3.0], [0.0, 5.0], [0.0, 7.0]]], [[[0.0, 0.0], [0.0, 1.0], [0.0, 3.0], [0.0, 5.0]]]],
device=device,
dtype=dtype,
)
# prepare transformation
translation = torch.tensor([[1.0, 0.0], [1.0, 1.0]], device=device, dtype=dtype)
transform = kornia.geometry.transform.Translate(translation, align_corners=True)
self.assert_close(transform(inp), expected, atol=1e-4, rtol=1e-4)
def test_dxdy_batch_broadcast(self, device, dtype):
# prepare input data
inp = torch.tensor([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]]], device=device, dtype=dtype).repeat(
2, 1, 1, 1
)
expected = torch.tensor(
[[[[0.0, 1.0], [0.0, 3.0], [0.0, 5.0], [0.0, 7.0]]], [[[0.0, 1.0], [0.0, 3.0], [0.0, 5.0], [0.0, 7.0]]]],
device=device,
dtype=dtype,
)
# prepare transformation
translation = torch.tensor([[1.0, 0.0]], device=device, dtype=dtype)
transform = kornia.geometry.transform.Translate(translation, align_corners=True)
self.assert_close(transform(inp), expected, atol=1e-4, rtol=1e-4)
@pytest.mark.parametrize("image_shape", [(0, 2, 4, 5), (1, 2, 4, 5), (2, 4, 5), (2, 2, 4, 5), (3, 2, 4, 5)])
def test_unbatched_translation_is_shared_6521(self, device, dtype, image_shape):
# A (2,) translation serves every image, as (1, 2) does. Its 2 components used to be read as a batch of 2,
# which returned one image twice and raised for 3 images.
image = torch.rand(image_shape, device=device, dtype=dtype)
translation = torch.tensor([1.0, -0.5], device=device, dtype=dtype)
out = kornia.geometry.transform.translate(image, translation)
assert out.shape == image.shape
self.assert_close(out, kornia.geometry.transform.translate(image, translation[None]), atol=0, rtol=0)
self.assert_close(kornia.geometry.transform.Translate(translation)(image), out, atol=0, rtol=0)
def test_gradcheck(self, device):
# test parameters
translation = torch.tensor([[1.0, 0.0]], device=device, dtype=torch.float64)
# evaluate function gradient
input = torch.rand(1, 2, 3, 4, device=device, dtype=torch.float64)
self.gradcheck(kornia.geometry.transform.translate, (input, translation), requires_grad=(True, False))
@pytest.mark.skip("Need deep look into it since crashes everywhere.")
@pytest.mark.skip(reason="turn off all jit for a while")
def test_jit(self, device, dtype):
translation = torch.tensor([[1.0, 0.0]], device=device, dtype=dtype)
batch_size, channels, height, width = 2, 3, 64, 64
img = torch.ones(batch_size, channels, height, width, device=device, dtype=dtype)
trans = kornia.geometry.transform.Translate(translation)
trans_traced = torch.jit.trace(kornia.geometry.transform.Translate(translation), img)
self.assert_close(trans(img), trans_traced(img), atol=1e-4, rtol=1e-4)
class TestScale(BaseTester):
def test_scale_factor_2(self, device, dtype):
# prepare input data
inp = torch.tensor(
[[[0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 1.0, 0.0], [0.0, 1.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0]]],
device=device,
dtype=dtype,
)
# prepare transformation
scale_factor = torch.tensor([[2.0, 2.0]], device=device, dtype=dtype)
transform = kornia.geometry.transform.Scale(scale_factor)
self.assert_close(transform(inp).sum().item(), 12.25, atol=1e-4, rtol=1e-4)
def test_scale_factor_05(self, device, dtype):
# prepare input data
inp = torch.tensor(
[[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]],
device=device,
dtype=dtype,
)
expected = torch.tensor(
[[[0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 1.0, 0.0], [0.0, 1.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0]]],
device=device,
dtype=dtype,
)
# prepare transformation
scale_factor = torch.tensor([[0.5, 0.5]], device=device, dtype=dtype)
transform = kornia.geometry.transform.Scale(scale_factor)
self.assert_close(transform(inp), expected, atol=1e-4, rtol=1e-4)
def test_scale_factor_05_batch2(self, device, dtype):
# prepare input data
inp = torch.tensor(
[[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]],
device=device,
dtype=dtype,
).repeat(2, 1, 1, 1)
expected = torch.tensor(
[[[0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 1.0, 0.0], [0.0, 1.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0]]],
device=device,
dtype=dtype,
).repeat(2, 1, 1, 1)
# prepare transformation
scale_factor = torch.tensor([[0.5, 0.5]], device=device, dtype=dtype)
transform = kornia.geometry.transform.Scale(scale_factor)
self.assert_close(transform(inp), expected, atol=1e-4, rtol=1e-4)
def test_scale_factor_05_batch2_broadcast(self, device, dtype):
# prepare input data
inp = torch.tensor(
[[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]],
device=device,
dtype=dtype,
).repeat(2, 1, 1, 1)
expected = torch.tensor(
[[[0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 1.0, 0.0], [0.0, 1.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0]]],
device=device,
dtype=dtype,
).repeat(2, 1, 1, 1)
# prepare transformation
scale_factor = torch.tensor([[0.5, 0.5]], device=device, dtype=dtype)
transform = kornia.geometry.transform.Scale(scale_factor)
self.assert_close(transform(inp), expected, atol=1e-4, rtol=1e-4)
@pytest.mark.parametrize("batch_size, num_factors", [(1, 1), (2, 2), (3, 3), (3, 1)])
@pytest.mark.parametrize("as_module", [False, True])
def test_isotropic_scale_factor(self, device, dtype, batch_size, num_factors, as_module):
image = torch.arange(batch_size * 35, device=device, dtype=dtype).reshape(batch_size, 1, 5, 7) / 35
scale_factor = torch.tensor([0.6, 1.0, 1.4], device=device, dtype=dtype)[:num_factors]
# Isotropic factors apply equally to x and y, independently for each image.
expected = kornia.geometry.transform.scale(image, torch.stack([scale_factor, scale_factor], dim=-1))
if as_module:
actual = kornia.geometry.transform.Scale(scale_factor)(image)
else:
actual = kornia.geometry.transform.scale(image, scale_factor)
self.assert_close(actual, expected)
def test_isotropic_scale_factor_gradcheck(self, device):
image = torch.arange(48, device=device, dtype=torch.float64).reshape(2, 1, 4, 6) / 48
scale_factor = torch.tensor([0.8, 1.3], device=device, dtype=torch.float64)
# CUDA's grid_sample backward accumulates with atomics, so repeated backward passes differ by roundoff.
self.gradcheck(kornia.geometry.transform.scale, (image, scale_factor), nondet_tol=1e-8)
def test_gradcheck(self, device):
# test parameters
scale_factor = torch.tensor([[0.5, 0.5]], device=device, dtype=torch.float64)
# evaluate function gradient
input = torch.rand(1, 2, 3, 4, device=device, dtype=torch.float64)
self.gradcheck(kornia.geometry.transform.scale, (input, scale_factor), requires_grad=(True, False))
@pytest.mark.skip("Need deep look into it since crashes everywhere.")
@pytest.mark.skip(reason="turn off all jit for a while")
def test_jit(self, device, dtype):
scale_factor = torch.tensor([[0.5, 0.5]], device=device, dtype=dtype)
batch_size, channels, height, width = 2, 3, 64, 64
img = torch.ones(batch_size, channels, height, width, device=device, dtype=dtype)
trans = kornia.geometry.transform.Scale(scale_factor)
trans_traced = torch.jit.trace(kornia.Scale(scale_factor), img)
self.assert_close(trans(img), trans_traced(img), atol=1e-4, rtol=1e-4)
class TestShear(BaseTester):
def test_shear_x(self, device, dtype):
# prepare input data
inp = torch.tensor(
[[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]],
device=device,
dtype=dtype,
)
# x-shear by 0.5 about the origin: dst[x, y] samples src[x - 0.5 * y, y], so row y=1
# samples x=-0.5 (half outside, zero padding -> 0.5), row y=2 samples x=-1 (fully
# outside -> 0), row y=3 samples x=-1.5 and x=-0.5 -> 0, 0.5.
# Snippet used to generate expected (identical to the call under test):
# inp = torch.ones(1, 4, 4); shear = torch.tensor([[0.5, 0.0]])
# expected = kornia.geometry.transform.Shear(shear, align_corners=False)(inp)
# Pre-#3945 literal from the same snippet, when warp_affine(align_corners=False) still
# normalized against a corner-aligned grid (the 0.75 / 0.25 are that sub-pixel artifact):
# [[[0.75, 1.0, 1.0, 1.0], [0.25, 1.0, 1.0, 1.0], [0.0, 0.75, 1.0, 1.0], [0.0, 0.25, 1.0, 1.0]]]
expected = torch.tensor(
[[[1.0, 1.0, 1.0, 1.0], [0.5, 1.0, 1.0, 1.0], [0.0, 1.0, 1.0, 1.0], [0.0, 0.5, 1.0, 1.0]]],
device=device,
dtype=dtype,
)
# prepare transformation
shear = torch.tensor([[0.5, 0.0]], device=device, dtype=dtype)
transform = kornia.geometry.transform.Shear(shear, align_corners=False)
self.assert_close(transform(inp), expected, atol=1e-4, rtol=1e-4)
def test_shear_y(self, device, dtype):
# prepare input data
inp = torch.tensor(
[[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]],
device=device,
dtype=dtype,
)
# y-shear by 0.5 about the origin: the transpose of the test_shear_x case above.
# Pre-#3945 literal (shear = [[0.0, 0.5]], otherwise the test_shear_x snippet):
# [[[0.75, 0.25, 0.0, 0.0], [1.0, 1.0, 0.75, 0.25], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]]
expected = torch.tensor(
[[[1.0, 0.5, 0.0, 0.0], [1.0, 1.0, 1.0, 0.5], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]],
device=device,
dtype=dtype,
)
# prepare transformation
shear = torch.tensor([[0.0, 0.5]], device=device, dtype=dtype)
transform = kornia.geometry.transform.Shear(shear, align_corners=False)
self.assert_close(transform(inp), expected, atol=1e-4, rtol=1e-4)
def test_shear_batch2(self, device, dtype):
# prepare input data
inp = torch.tensor(
[[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]],
device=device,
dtype=dtype,
).repeat(2, 1, 1, 1)
# the test_shear_x and test_shear_y expectations, stacked; the pre-#3945 literals
# recorded in those two tests stack the same way
expected = torch.tensor(
[
[[[1.0, 1.0, 1.0, 1.0], [0.5, 1.0, 1.0, 1.0], [0.0, 1.0, 1.0, 1.0], [0.0, 0.5, 1.0, 1.0]]],
[[[1.0, 0.5, 0.0, 0.0], [1.0, 1.0, 1.0, 0.5], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]],
],
device=device,
dtype=dtype,
)
# prepare transformation
shear = torch.tensor([[0.5, 0.0], [0.0, 0.5]], device=device, dtype=dtype)
transform = kornia.geometry.transform.Shear(shear, align_corners=False)
self.assert_close(transform(inp), expected, atol=1e-4, rtol=1e-4)
def test_shear_batch2_broadcast(self, device, dtype):
# prepare input data
inp = torch.tensor(
[[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]],
device=device,
dtype=dtype,
).repeat(2, 1, 1, 1)
# the test_shear_x expectation broadcast over the batch (pre-#3945 literal recorded there)
expected = torch.tensor(
[[[[1.0, 1.0, 1.0, 1.0], [0.5, 1.0, 1.0, 1.0], [0.0, 1.0, 1.0, 1.0], [0.0, 0.5, 1.0, 1.0]]]],
device=device,
dtype=dtype,
).repeat(2, 1, 1, 1)
# prepare transformation
shear = torch.tensor([[0.5, 0.0]], device=device, dtype=dtype)
transform = kornia.geometry.transform.Shear(shear, align_corners=False)
self.assert_close(transform(inp), expected, atol=1e-4, rtol=1e-4)
@pytest.mark.parametrize("image_shape", [(0, 2, 4, 5), (1, 2, 4, 5), (2, 4, 5), (2, 2, 4, 5), (3, 2, 4, 5)])
def test_unbatched_shear_is_shared_6521(self, device, dtype, image_shape):
# A (2,) pair of factors serves every image, as (1, 2) does. Its 2 factors used to be read as a batch of 2,
# which returned one image twice and raised for 3 images.
image = torch.rand(image_shape, device=device, dtype=dtype)
shear = torch.tensor([0.5, -0.25], device=device, dtype=dtype)
out = kornia.geometry.transform.shear(image, shear)
assert out.shape == image.shape
self.assert_close(out, kornia.geometry.transform.shear(image, shear[None]), atol=0, rtol=0)
self.assert_close(kornia.geometry.transform.Shear(shear, align_corners=False)(image), out, atol=0, rtol=0)
def test_gradcheck(self, device):
# test parameters
shear = torch.tensor([[0.5, 0.0]], device=device, dtype=torch.float64)
# evaluate function gradient
input = torch.rand(1, 2, 3, 4, device=device, dtype=torch.float64)
self.gradcheck(kornia.geometry.transform.shear, (input, shear), requires_grad=(True, False))
@pytest.mark.skip("Need deep look into it since crashes everywhere.")
@pytest.mark.skip(reason="turn off all jit for a while")
def test_jit(self, device, dtype):
shear = torch.tensor([[0.5, 0.0]], device=device, dtype=dtype)
batch_size, channels, height, width = 2, 3, 64, 64
img = torch.ones(batch_size, channels, height, width, device=device, dtype=dtype)
trans = kornia.geometry.transform.Shear(shear, align_corners=False)
trans_traced = torch.jit.trace(kornia.geometry.transform.Shear(shear), img)
self.assert_close(trans(img), trans_traced(img), atol=1e-4, rtol=1e-4)
class TestAffine2d(BaseTester):
@pytest.mark.parametrize("image_batch,matrix_batch", [(3, 1), (1, 3), (0, 1)])
def test_function_batch_broadcast(self, device, dtype, image_batch, matrix_batch):
image = torch.rand(image_batch, 2, 5, 7, device=device, dtype=dtype)
matrix = torch.tensor([[1.0, 0.1, 0.3], [0.2, 1.0, -0.4]], device=device, dtype=dtype)
matrix = matrix.expand(matrix_batch, -1, -1)
batch = 0 if image_batch == 0 else max(image_batch, matrix_batch)
expected = kornia.geometry.transform.warp_affine(
image.expand(batch, -1, -1, -1), matrix.expand(batch, -1, -1), (5, 7)
)
self.assert_close(kornia.geometry.transform.affine(image, matrix), expected)
def test_function_invalid_batch(self, device, dtype):
image = torch.rand(3, 2, 5, 7, device=device, dtype=dtype)
matrix = torch.eye(2, 3, device=device, dtype=dtype).expand(2, -1, -1)
with pytest.raises(RuntimeError):
kornia.geometry.transform.affine(image, matrix)
@pytest.mark.parametrize("image_shape", [(0, 2, 5, 7), (1, 2, 5, 7), (2, 5, 7), (3, 2, 5, 7)])
@pytest.mark.parametrize("checks", [True, False])
def test_function_shares_unbatched_matrix_6462(self, device, dtype, image_shape, checks):
# A (2, 3) matrix serves every image, as (1, 2, 3) does. Read as a batch of 2, it used to warp one image,
# (1, C, H, W) or (C, H, W), twice; with checks disabled too, since the unbatched matrix is not a check.
image = torch.rand(image_shape, device=device, dtype=dtype)
matrix = torch.tensor([[0.9, 0.2, 1.0], [-0.1, 1.1, -0.5]], device=device, dtype=dtype)
was_enabled = are_checks_enabled()
if not checks:
disable_checks()
try:
out = kornia.geometry.transform.affine(image, matrix)
finally:
if was_enabled:
enable_checks()
assert out.shape == image.shape
self.assert_close(out, kornia.geometry.transform.affine(image, matrix[None]), atol=0, rtol=0)
def test_function_rejects_matrix_of_other_rank(self, device, dtype):
image = torch.rand(1, 2, 5, 7, device=device, dtype=dtype)
with pytest.raises(ShapeError):
kornia.geometry.transform.affine(image, torch.ones(1, 1, 2, 3, device=device, dtype=dtype))
def test_affine_no_args(self):
with pytest.raises(RuntimeError):
kornia.geometry.transform.Affine()
def test_affine_batch_size_mismatch(self, device, dtype):
angle = torch.rand(1, device=device, dtype=dtype)
translation = torch.rand(2, 2, device=device, dtype=dtype)
with pytest.raises(RuntimeError):
kornia.geometry.transform.Affine(angle, translation)
def test_affine_rotate(self, device, dtype):
torch.manual_seed(0)
angle = torch.rand(1, device=device, dtype=dtype) * 90.0
input = torch.rand(1, 2, 3, 4, device=device, dtype=dtype)
transform = kornia.geometry.transform.Affine(angle=angle).to(device=device, dtype=dtype)
actual = transform(input)
expected = kornia.geometry.transform.rotate(input, angle)
self.assert_close(actual, expected, atol=1e-4, rtol=1e-4)
def test_affine_translate(self, device, dtype):
torch.manual_seed(0)
translation = torch.rand(1, 2, device=device, dtype=dtype) * 2.0
input = torch.rand(1, 2, 3, 4, device=device, dtype=dtype)
transform = kornia.geometry.transform.Affine(translation=translation).to(device=device, dtype=dtype)
actual = transform(input)
expected = kornia.geometry.transform.translate(input, translation)
self.assert_close(actual, expected, atol=1e-4, rtol=1e-4)
def test_affine_scale(self, device, dtype):
torch.manual_seed(0)
_scale_factor = torch.rand(1, device=device, dtype=dtype) * 2.0
scale_factor = torch.stack([_scale_factor, _scale_factor], dim=1)
input = torch.rand(1, 2, 3, 4, device=device, dtype=dtype)
transform = kornia.geometry.transform.Affine(scale_factor=scale_factor).to(device=device, dtype=dtype)
actual = transform(input)
expected = kornia.geometry.transform.scale(input, scale_factor)
self.assert_close(actual, expected, atol=1e-4, rtol=1e-4)
@pytest.mark.parametrize("batch_size", [1, 3])
def test_affine_shear_only_5662(self, device, dtype, batch_size):
shear = torch.tensor([[0.1, -0.2]], device=device, dtype=dtype).repeat(batch_size, 1)
image = torch.arange(batch_size * 30, device=device, dtype=dtype).reshape(batch_size, 1, 5, 6) / 30
# Explicit identity components define the same shear without relying on constructor defaults.
expected = kornia.geometry.transform.Affine(
angle=torch.zeros(batch_size, device=device, dtype=dtype),
translation=torch.zeros(batch_size, 2, device=device, dtype=dtype),
scale_factor=torch.ones(batch_size, 2, device=device, dtype=dtype),
shear=shear,
)(image)
actual = kornia.geometry.transform.Affine(shear=shear)(image)
self.assert_close(actual, expected)
def test_affine_shear_checked_with_other_parameters_5662(self, device, dtype):
# shear takes part in the constructor's device and dtype check, as angle, translation and scale_factor do.
shear = torch.tensor([[0.1, -0.2]], device=device, dtype=dtype)
other = torch.float16 if dtype != torch.float16 else torch.float32 # float64 is unavailable on MPS
with pytest.raises(TypeCheckError):
kornia.geometry.transform.Affine(angle=torch.zeros(1, device=device, dtype=other), shear=shear)
with pytest.raises(DeviceError):
kornia.geometry.transform.Affine(angle=torch.zeros(1, device="meta", dtype=dtype), shear=shear)
@staticmethod
def _affine_parameters(kind, batch_size, device, dtype):
torch.manual_seed(0)
if kind == "angle":
value = 60.0 * torch.rand(batch_size)
elif kind == "scale_factor":
value = 1.0 + 0.3 * torch.rand(batch_size, 2)
else: # translation in pixels, shear in radians
value = 0.3 * torch.rand(batch_size, 2)
return {kind: value.to(device, dtype)}
@pytest.mark.parametrize("kind", ["angle", "translation", "scale_factor", "shear"])
@pytest.mark.parametrize("with_center", [False, True])
def test_affine_batch1_parameters_warp_every_image_6395(self, device, dtype, kind, with_center):
# One parameter set warps every image of a batch, with or without center, as Rotate and Translate do.
params = self._affine_parameters(kind, 1, device, dtype)
center = torch.tensor([[3.0, 2.0]], device=device, dtype=dtype) if with_center else None
torch.manual_seed(1)
images = torch.rand(3, 2, 5, 7).to(device, dtype)
transform = kornia.geometry.transform.Affine(**params, center=center)
expected = torch.cat([transform(image[None]) for image in images])
self.assert_close(transform(images), expected)
@pytest.mark.parametrize("unbatched", [False, True])
def test_affine_parameter_sets_warp_one_image_without_center_6395(self, device, dtype, unbatched):
# Without center, B parameter sets warp one image into (B, C, H, W), as they do with the image centre given.
params = self._affine_parameters("angle", 3, device, dtype)
params.update(self._affine_parameters("translation", 3, device, dtype))
torch.manual_seed(1)
image = torch.rand(1, 2, 5, 7).to(device, dtype)
image = image[0] if unbatched else image
image_centre = torch.tensor([[3.0, 2.0]], device=device, dtype=dtype).expand(3, -1)
actual = kornia.geometry.transform.Affine(**params)(image)
expected = kornia.geometry.transform.Affine(**params, center=image_centre)(image)
assert actual.shape == (3, 2, 5, 7)
self.assert_close(actual, expected)
@pytest.mark.parametrize("with_center", [False, True])
def test_affine_parameter_and_input_batch_mismatch_raises_6395(self, device, dtype, with_center):
# Two parameter sets for three images pair in no sensible way: the error names both batch sizes.
params = self._affine_parameters("angle", 2, device, dtype)
center = torch.tensor([[3.0, 2.0]], device=device, dtype=dtype).expand(2, -1) if with_center else None
images = torch.zeros(3, 2, 5, 7, device=device, dtype=dtype)
with pytest.raises(ValueError, match="Affine has 2 parameter sets for an input batch of 3"):
kornia.geometry.transform.Affine(**params, center=center)(images)
@pytest.mark.parametrize("as_module", [False, True])
def test_convention_shear_raw_factors_5661(self, device, dtype, as_module):
# Both off-diagonal factors act on the original coordinates, about pixel (0, 0).
shear = torch.tensor([[0.5, 0.25]], device=device, dtype=dtype)
image = torch.arange(81, device=device, dtype=dtype).reshape(1, 1, 9, 9) / 80
matrix = torch.tensor([[[1.0, 0.5, 0.0], [0.25, 1.0, 0.0]]], device=device, dtype=dtype)
expected = kornia.geometry.transform.warp_affine(image, matrix, (9, 9), align_corners=True)
if as_module:
actual = kornia.geometry.transform.Shear(shear, align_corners=True)(image)
else:
actual = kornia.geometry.transform.shear(image, shear, align_corners=True)
self.assert_close(actual, expected)
@pytest.mark.parametrize("custom_center", [False, True])
def test_convention_affine_shear_radians_5661(self, device, dtype, custom_center):
# tan(sx) = 1 and tan(sy) = 2: x' = x - (y - cy), then y' = y - 2 (x' - cx).
shear = torch.tensor([[math.pi / 4, math.atan(2.0)]], device=device, dtype=dtype)
center = torch.tensor([[2.0, 3.0] if custom_center else [4.0, 4.0]], device=device, dtype=dtype)
cx, cy = (2.0, 3.0) if custom_center else (4.0, 4.0)
matrix = torch.tensor(
[[[1.0, -1.0, cy], [-2.0, 3.0, 2.0 * (cx - cy)], [0.0, 0.0, 1.0]]], device=device, dtype=dtype
)
angle = torch.zeros(1, device=device, dtype=dtype)
translation = torch.zeros(1, 2, device=device, dtype=dtype)
scale = torch.ones(1, 2, device=device, dtype=dtype)
# Float16 rounds the angles before tan (versus errors >= 1 for a wrong order or swapped angles).
tolerance = {"atol": 5e-3, "rtol": 1e-3} if dtype == torch.float16 else {}
self.assert_close(
kornia.geometry.transform.get_shear_matrix2d(center, shear[:, 0], shear[:, 1]), matrix, **tolerance
)
self.assert_close(
kornia.geometry.transform.get_affine_matrix2d(translation, center, scale, angle, shear[:, 0], shear[:, 1]),
matrix,
**tolerance,
)
image = torch.zeros(1, 1, 9, 9, device=device, dtype=dtype)
image[0, 0, 6, 5] = 1
expected = torch.zeros_like(image)
row, col = (6, 2) if custom_center else (8, 3)
expected[0, 0, row, col] = 1
transform = kornia.geometry.transform.Affine(
shear=shear, center=center if custom_center else None, mode="nearest", align_corners=True
)
self.assert_close(transform(image), expected)
def test_wart_shear_and_affine_shear_the_other_way_5661(self, device, dtype):
# One pixel at row 8, column 4. shear() reads 0.5 as a factor about pixel (0, 0) and moves it to column
# 4 + 0.5 * 8 = 8; Affine reads it as an angle about the centre and moves it to 4 - tan(0.5) * (8 - 4) = 1.8.
shear = torch.tensor([[0.5, 0.0]], device=device, dtype=dtype)
image = torch.zeros(1, 1, 9, 9, device=device, dtype=dtype)
image[0, 0, 8, 4] = 1
sheared = kornia.geometry.transform.shear(image, shear, mode="nearest", align_corners=True)
affine = kornia.geometry.transform.Affine(shear=shear, mode="nearest", align_corners=True)
assert sheared[0, 0, 8].argmax().item() == 8
assert affine(image)[0, 0, 8].argmax().item() == 2
def test_affine_rotate_translate(self, device, dtype):
batch_size = 2
input = torch.tensor(
[[[0.0, 0.0, 0.0, 1.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]],
device=device,
dtype=dtype,
).repeat(batch_size, 1, 1, 1)
angle = torch.tensor(180.0, device=device, dtype=dtype).repeat(batch_size)
translation = torch.tensor([1.0, 0.0], device=device, dtype=dtype).repeat(batch_size, 1)
expected = torch.tensor(
[[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 1.0, 0.0, 0.0]]],
device=device,
dtype=dtype,
).repeat(batch_size, 1, 1, 1)
transform = kornia.geometry.transform.Affine(angle=angle, translation=translation, align_corners=True).to(
device=device, dtype=dtype
)
actual = transform(input)
# The half dtypes round the 180-degree rotation and the bilinear weights: the output is off by up to 3.9e-3
# in float16 and 2.3e-2 in bfloat16 on CPU and CUDA, against 1.0 for a dropped translation.
tol = {torch.float16: 1e-2, torch.bfloat16: 5e-2}.get(dtype, 1e-4)
self.assert_close(actual, expected, atol=tol, rtol=tol)
def test_compose_affine_matrix_3x3(self, device, dtype):
"""To get parameters:
import torchvision as tv
from PIL import Image
from torch import Tensor as T
import math
import random
img_size = (96,96)
seed = 42
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed) # if you are using multi-GPU.
np.random.seed(seed) # Numpy module.
random.seed(seed) # Python random module.
torch.manual_seed(seed)
tfm = tv.transforms.RandomAffine(degrees=(-25.0,25.0),
scale=(0.6, 1.4) ,
translate=(0, 0.1),
shear=(-25., 25., -20., 20.))
angle, translations, scale, shear = tfm.get_params(tfm.degrees, tfm.translate,
tfm.scale, tfm.shear, img_size)
print (angle, translations, scale, shear)
output_size = img_size
center = (img.size[0] * 0.5 + 0.5, img.size[1] * 0.5 + 0.5)
matrix = tv.transforms.functional._get_inverse_affine_matrix(center, angle, translations, scale, shear)
matrix = np.array(matrix).reshape(2,3)
print (matrix)
"""
import math
from torch import Tensor as T
batch_size, _, height, width = 1, 1, 96, 96
angle, translations = 6.971339922894188, (0.0, -4.0)
scale, shear = [0.7785685905190581, 0.7785685905190581], [11.8235607082617, 7.06797949691645]
matrix_expected = T([[1.27536969, 4.26828945e-01, -3.2349e01], [2.18297196e-03, 1.29424165e00, -9.1996e00]])
center = T([float(width), float(height)]).view(1, 2) / 2.0 + 0.5
center = center.expand(batch_size, -1)
matrix_kornia = kornia.geometry.transform.get_affine_matrix2d(
T(translations).view(-1, 2),
center,
T([scale]).view(-1, 2),
T([angle]).view(-1),
T([math.radians(shear[0])]).view(-1, 1),
T([math.radians(shear[1])]).view(-1, 1),
)
matrix_kornia = matrix_kornia.inverse()[0, :2].detach().cpu()
self.assert_close(matrix_kornia, matrix_expected, atol=1e-4, rtol=1e-4)
def test_broadcasting_issue_3176(self, device, dtype):
# Issue 3176: RandomRotation with multi-channel masks caused crash
# Scenario: Tensor is (B=1, C, H, W) but Matrix is (B=8, 2, 3)
# This implies applying N different transformations to a single image
B_mat, B_ten = 8, 1
C, H, W = 3, 64, 64
input_tensor = torch.rand(B_ten, C, H, W, device=device, dtype=dtype)
matrix = torch.rand(B_mat, 2, 3, device=device, dtype=dtype)
output = kornia.geometry.transform.affine(input_tensor, matrix, mode="bilinear")
assert output.shape == (B_mat, C, H, W)
def test_warp_affine_fill_value(self, device, dtype):
# Feature: Support padding_mode="fill" with custom fill_value
# Scenario: 1-channel mask, fill with 1.0
B, C, H, W = 1, 1, 10, 10
src = torch.zeros(B, C, H, W, device=device, dtype=dtype)
M = torch.eye(2, 3, device=device, dtype=dtype).unsqueeze(0)
M[..., 0, 2] = 5.0
# Fill with 1.0
fill_val = torch.tensor([1.0], device=device, dtype=dtype)
out = kornia.geometry.transform.warp_affine(src, M, (H, W), padding_mode="fill", fill_value=fill_val)
assert out[0, 0, 0, 0] == 1.0
assert out[0, 0, 0, 9] == 0.0
@pytest.mark.parametrize("op", ["rotate", "scale", "Affine"])
def test_default_center_takes_parameter_dtype_6545(self, device, op):
# float32 parameters with a float64 image sample in float64, as warp_affine documents. The default center was
# built in the image dtype and failed the matrix's same-dtype check, while an explicit center worked.
if device.type == "mps":
pytest.skip("MPS has no float64")
image = torch.rand(2, 3, 6, 7, device=device, dtype=torch.float64)
angle = torch.tensor([30.0, -15.0], device=device, dtype=torch.float32)
factor = torch.tensor([[1.5, 0.75], [0.5, 2.0]], device=device, dtype=torch.float32)
center = torch.tensor([[3.0, 2.5]], device=device, dtype=torch.float32).expand(2, -1)
if op == "rotate":
out = kornia.geometry.transform.rotate(image, angle)
expected = kornia.geometry.transform.rotate(image, angle, center)
elif op == "scale":
out = kornia.geometry.transform.scale(image, factor)
expected = kornia.geometry.transform.scale(image, factor, center)
else:
out = kornia.geometry.transform.Affine(angle)(image)
expected = kornia.geometry.transform.Affine(angle, center=center)(image)
assert out.dtype == torch.float64
self.assert_close(out, expected, atol=0, rtol=0)
class TestWarpByBuiltMatrixAutocast(BaseTester):
"""rotate, scale and rotate3d build their matrix and warp by it, both outside a caller's autocast region (#6573)."""
# Exact: in and out of the region run the same arithmetic on one device.
@staticmethod
def _skip_unsupported(device, autocast_dtype):
if device.type not in ("cpu", "cuda", "mps"):
pytest.skip("CPU, CUDA and MPS autocast")
if device.type == "cuda" and autocast_dtype == "bfloat16" and not torch.cuda.is_bf16_supported():
pytest.skip("this CUDA device does not support bfloat16")
@staticmethod
def _call(op_name, device, dtype):
transform = kornia.geometry.transform
generator = torch.Generator().manual_seed(0)
if op_name == "rotate3d":
volume = torch.rand(1, 1, 32, 32, 32, generator=generator).to(device=device, dtype=dtype)
yaw, pitch, roll = (torch.tensor([value], device=device, dtype=dtype) for value in (25.0, 12.5, 8.0))
return transform.rotate3d(volume, yaw, pitch, roll)
image = torch.rand(1, 3, 256, 256, generator=generator).to(device=device, dtype=dtype)
if op_name == "rotate":
return transform.rotate(image, torch.tensor([25.0], device=device, dtype=dtype))
return transform.scale(image, torch.tensor([[1.13, 1.13]], device=device, dtype=dtype))
@pytest.mark.parametrize("op_name", ["rotate", "scale", "rotate3d"])
@pytest.mark.parametrize("src_dtype", [torch.float32, torch.float16, torch.bfloat16])
@pytest.mark.parametrize("autocast_dtype", ["bfloat16", "float16"])
def test_region_does_not_change_the_warp_6573(self, op_name, src_dtype, autocast_dtype, device):
# In bfloat16, float32 rotate, scale and rotate3d of [0, 1] inputs were off by 0.11, 0.36 and 0.14.
self._skip_unsupported(device, autocast_dtype)
if (
device.type == "cpu"
and src_dtype in (torch.float16, torch.bfloat16)
and src_dtype != getattr(torch, autocast_dtype)
):
pytest.skip("CPU autocast rejects a half tensor of the other half dtype in torch.stack and torch.cat")
expected = self._call(op_name, device, src_dtype)
with torch.autocast(device.type, dtype=getattr(torch, autocast_dtype)):
actual = self._call(op_name, device, src_dtype)
assert actual.dtype == src_dtype
self.assert_close(actual, expected, rtol=0, atol=0)
class TestGetAffineMatrix(BaseTester):
def test_smoke(self, device, dtype):
H, W = 5, 5
translation = torch.tensor([[0.0, 0.0]], device=device, dtype=dtype)
# NOTE: ideally the center should be [W * 0.5, H * 0.5]
center = torch.tensor([[W // 2, H // 2]], device=device, dtype=dtype)
zoom1 = torch.ones([1, 1], device=device, dtype=dtype) * 0.5
zoom2 = torch.ones([1, 1], device=device, dtype=dtype) * 1.0
zoom = torch.cat([zoom1, zoom2], -1)
angle = torch.zeros([1], device=device, dtype=dtype)
affine_mat = kornia.geometry.get_affine_matrix2d(translation, center, zoom, angle)
img = torch.ones(1, 1, H, W, device=device, dtype=dtype)
expected = torch.zeros_like(img)
expected[..., 1:4] = 1.0
out = kornia.geometry.transform.warp_affine(img, affine_mat[:, :2], (H, W))
self.assert_close(out, expected)
class TestGetShearMatrix(BaseTester):
def test_get_shear_matrix2d_with_controlled_values(self, device, dtype):
# Define controlled values for shear angles and center
sx = torch.tensor([0.5], device=device, dtype=dtype)
sy = torch.tensor([0.25], device=device, dtype=dtype)
center = torch.tensor([[0.0, 0.0]], device=device, dtype=dtype)
# Calculate the shear matrix using your function
out = kornia.geometry.transform.get_shear_matrix2d(center, sx=sx, sy=sy)
# Define the expected shear matrix with controlled numbers
expected = torch.tensor(
[[[1.0, -0.5463, 0.0], [-0.2553, 1.1395, 0.0], [0.0, 0.0, 1.0]]], device=device, dtype=dtype
)
self.assert_close(out, expected, atol=1e-4, rtol=1e-4)
def test_get_shear_matrix2d_default_params_device_dtype(self, device, dtype):
# When sx and sy are None, the defaults should inherit device and dtype from center.
center = torch.tensor([[128.0, 128.0]], device=device, dtype=dtype)
out = kornia.geometry.transform.get_shear_matrix2d(center, sx=None, sy=None)
assert out.device.type == center.device.type, "Output device must match center device"
assert out.dtype == center.dtype, "Output dtype must match center dtype"
def test_get_shear_matrix3d_default_params_device_dtype(self, device, dtype):
# When shear params are None, the defaults should inherit device and dtype from center.
center = torch.tensor([[64.0, 64.0, 32.0]], device=device, dtype=dtype)
out = kornia.geometry.transform.get_shear_matrix3d(
center, sxy=None, sxz=None, syx=None, syz=None, szx=None, szy=None
)
assert out.device.type == center.device.type, "Output device must match center device"
assert out.dtype == center.dtype, "Output dtype must match center dtype"
def test_get_shear_matrix3d_keeps_center_for_every_shear_subset(self, device, dtype):
# The translation used to come from the positive-tangent matrix while the returned linear part uses the
# negated tangents, so shears that meet in a product term moved the center (#6302). The center is asymmetric
# so that no coordinate can stand in for another.
names = ("sxy", "sxz", "syx", "syz", "szx", "szy")
values = (0.3, -0.25, 0.2, 0.15, -0.35, 0.1)
center = torch.tensor([[7.0, 23.0, 41.0]], device=device, dtype=dtype)
center_h = torch.tensor([7.0, 23.0, 41.0, 1.0], device=device, dtype=dtype)
# bfloat16 rounds near 41 in steps of 0.25, while the smallest displacement the bug caused here is 1.24 px.
tol = 0.5 if dtype in (torch.float16, torch.bfloat16) else None
for size in range(1, 7):
for subset in itertools.combinations(range(6), size):
shears = {names[i]: torch.tensor([values[i]], device=device, dtype=dtype) for i in subset}
out = kornia.geometry.transform.get_shear_matrix3d(center, **shears)
self.assert_close(out[0] @ center_h, center_h, rtol=tol and 0.0, atol=tol)
class TestTransformModuleBuffers(BaseTester):
@pytest.mark.parametrize(
"module_name,with_center",
[(name, center) for name in ("Rotate", "Scale", "Affine") for center in (False, True)]
+ [("Translate", False), ("Shear", False)],
)
def test_module_to(self, device, dtype, module_name, with_center):
initial_dtype = torch.float64 if dtype == torch.float32 else torch.float32
values = {
"Rotate": {"angle": [23.0]},
"Scale": {"scale_factor": [[0.8, 1.2]]},
"Affine": {
"angle": [23.0],
"translation": [[0.4, -0.2]],
"scale_factor": [[0.8, 1.2]],
"shear": [[0.1, -0.05]],
},
"Translate": {"translation": [[0.4, -0.2]]},
"Shear": {"shear": [[0.1, -0.05]]},
}[module_name]
if with_center and module_name in ("Rotate", "Scale", "Affine"):
values["center"] = [[1.5, 2.0]]
kwargs = {name: torch.tensor(value, dtype=initial_dtype) for name, value in values.items()}
constructor = getattr(kornia.geometry.transform, module_name)
transform = constructor(**kwargs).to(device=device, dtype=dtype)
# Reference constructs directly on the destination, without calling Module.to.
expected_transform = constructor(
**{name: value.to(device=device, dtype=dtype) for name, value in kwargs.items()}
)
image = torch.arange(30, device=device, dtype=dtype).reshape(1, 1, 5, 6) / 30
self.assert_close(transform(image), expected_transform(image))
for name in kwargs:
assert getattr(transform, name).device == image.device
assert getattr(transform, name).dtype == image.dtype
# These fixed constructor values have never been trainable parameters or checkpoint entries.
assert not list(transform.parameters())
assert not transform.state_dict()
def test_constructor_gradient_after_to(self, device, dtype):
angle = torch.tensor([17.0], requires_grad=True)
transform = kornia.geometry.transform.Rotate(angle).to(device=device, dtype=dtype)
image = torch.arange(30, device=device, dtype=dtype).reshape(1, 1, 5, 6) / 30
weights = image.flip(-1)
actual = torch.autograd.grad((transform(image) * weights).sum(), angle)[0]
reference_angle = angle.detach().to(device=device, dtype=dtype).requires_grad_()
expected = torch.autograd.grad(
(kornia.geometry.transform.rotate(image, reference_angle) * weights).sum(), reference_angle
)[0]
self.assert_close(actual.to(expected), expected)
@pytest.mark.parametrize(
"module_name,name,value",
[
("Rotate", "angle", [17.0]),
("Scale", "scale_factor", [[0.8, 1.2]]),
("Affine", "angle", [17.0]),
("Affine", "shear", [[0.1, -0.05]]),
("Translate", "translation", [[0.4, -0.2]]),
("Shear", "shear", [[0.1, -0.05]]),
],
)
def test_trainable_constructor_parameter(self, device, dtype, module_name, name, value):
parameter = torch.nn.Parameter(torch.tensor(value))
transform = getattr(kornia.geometry.transform, module_name)(**{name: parameter})
transform = transform.to(device=device, dtype=dtype)
stored = getattr(transform, name)
assert isinstance(stored, torch.nn.Parameter)
assert dict(transform.named_parameters())[name] is stored
assert set(transform.state_dict()) == {name}
image = torch.arange(30, device=device, dtype=dtype).reshape(1, 1, 5, 6) / 30
gradient = torch.autograd.grad((transform(image) * image.flip(-1)).sum(), stored)[0]
assert torch.isfinite(gradient).all()
assert gradient.abs().sum() > 0