def normalize_homography(dst_pix_trans_src_pix: torch.Tensor,
dsize_src: Tuple[int, int], dsize_dst: Tuple[int, int]) -> torch.Tensor:
r"""Normalize a given homography in pixels to [-1, 1].
Args:
dst_pix_trans_src_pix (torch.Tensor): homography/ies from source to destiantion to be
normalized. :math:`(B, 3, 3)`
dsize_src (tuple): size of the source image (height, width).
dsize_dst (tuple): size of the destination image (height, width).
Returns:
torch.Tensor: the normalized homography of shape :math:`(B, 3, 3)`.
"""
check_is_tensor(dst_pix_trans_src_pix)
if not (len(dst_pix_trans_src_pix.shape) == 3 or dst_pix_trans_src_pix.shape[-2:] == (3, 3)):
raise ValueError("Input dst_pix_trans_src_pix must be a Bx3x3 tensor. Got {}"
.format(dst_pix_trans_src_pix.shape))
# source and destination sizes
src_h, src_w = dsize_src
dst_h, dst_w = dsize_dst
# compute the transformation pixel/norm for src/dst
src_norm_trans_src_pix: torch.Tensor = normal_transform_pixel(
src_h, src_w).to(dst_pix_trans_src_pix)
src_pix_trans_src_norm = torch.inverse(src_norm_trans_src_pix)
dst_norm_trans_dst_pix: torch.Tensor = normal_transform_pixel(
dst_h, dst_w).to(dst_pix_trans_src_pix)
# compute chain transformations
dst_norm_trans_src_norm: torch.Tensor = (
dst_norm_trans_dst_pix @ (dst_pix_trans_src_pix @ src_pix_trans_src_norm)
)
return dst_norm_trans_src_norm
def transform_points(trans_01: torch.Tensor,
points_1: torch.Tensor) -> torch.Tensor:
r"""Function that applies transformations to a set of points.
Args:
trans_01 (torch.Tensor): tensor for transformations of shape
:math:`(B, D+1, D+1)`.
points_1 (torch.Tensor): tensor of points of shape :math:`(B, N, D)`.
Returns:
torch.Tensor: tensor of N-dimensional points.
Shape:
- Output: :math:`(B, N, D)`
Examples:
>>> points_1 = torch.rand(2, 4, 3) # BxNx3
>>> trans_01 = torch.eye(4).view(1, 4, 4) # Bx4x4
>>> points_0 = transform_points(trans_01, points_1) # BxNx3
"""
check_is_tensor(trans_01)
check_is_tensor(points_1)
if not (trans_01.device == points_1.device
and trans_01.dtype == points_1.dtype):
raise TypeError(
"Tensor must be in the same device and dtype. "
f"Got trans_01 with ({trans_01.dtype}, {points_1.dtype}) and "
f"points_1 with ({points_1.dtype}, {points_1.dtype})")
if not trans_01.shape[0] == points_1.shape[0] and trans_01.shape[0] != 1:
raise ValueError(
"Input batch size must be the same for both tensors or 1")
if not trans_01.shape[-1] == (points_1.shape[-1] + 1):
raise ValueError("Last input dimensions must differ by one unit")
# We reshape to BxNxD in case we get more dimensions, e.g., MxBxNxD
shape_inp = list(points_1.shape)
points_1 = points_1.reshape(-1, points_1.shape[-2], points_1.shape[-1])
trans_01 = trans_01.reshape(-1, trans_01.shape[-2], trans_01.shape[-1])
# We expand trans_01 to match the dimensions needed for bmm
trans_01 = torch.repeat_interleave(trans_01,
repeats=points_1.shape[0] //
trans_01.shape[0],
dim=0)
# to homogeneous
points_1_h = convert_points_to_homogeneous(points_1) # BxNxD+1
# transform coordinates
points_0_h = torch.bmm(points_1_h, trans_01.permute(0, 2, 1))
points_0_h = torch.squeeze(points_0_h, dim=-1)
# to euclidean
points_0 = convert_points_from_homogeneous(points_0_h) # BxNxD
# reshape to the input shape
shape_inp[-2] = points_0.shape[-2]
shape_inp[-1] = points_0.shape[-1]
points_0 = points_0.reshape(shape_inp)
return points_0
def warp_perspective(src: torch.Tensor,
M: torch.Tensor,
dsize: Tuple[int, int],
flags: str = 'bilinear',
border_mode: str = 'zeros',
align_corners: bool = False) -> torch.Tensor:
r"""Applies a perspective transformation to an image.
The function warp_perspective transforms the source image using
the specified matrix:
.. math::
\text{dst} (x, y) = \text{src} \left(
\frac{M_{11} x + M_{12} y + M_{13}}{M_{31} x + M_{32} y + M_{33}} ,
\frac{M_{21} x + M_{22} y + M_{23}}{M_{31} x + M_{32} y + M_{33}}
\right )
Args:
src (torch.Tensor): input image.
M (Tensor): transformation matrix.
dsize (tuple): size of the output image (height, width).
flags (str): interpolation mode to calculate output values
'bilinear' | 'nearest'. Default: 'bilinear'.
border_mode (str): padding mode for outside grid values
'zeros' | 'border' | 'reflection'. Default: 'zeros'.
align_corners(bool): interpolation flag. Default: False. See
https://pytorch.org/docs/stable/nn.functional.html#torch.nn.functional.interpolate for detail
Returns:
Tensor: the warped input image.
Shape:
- Input: :math:`(B, C, H, W)` and :math:`(B, 3, 3)`
- Output: :math:`(B, C, H, W)`
.. note::
See a working example `here <https://kornia.readthedocs.io/en/latest/
tutorials/warp_perspective.html>`_.
"""
check_is_tensor(src)
check_is_tensor(M)
if not len(src.shape) == 4:
raise ValueError("Input src must be a BxCxHxW tensor. Got {}".format(
src.shape))
if not (len(M.shape) == 3 or M.shape[-2:] == (3, 3)):
raise ValueError("Input M must be a Bx3x3 tensor. Got {}".format(
M.shape))
# launches the warper
h, w = src.shape[-2:]
return transform_warp_impl(src, M, (h, w), dsize, flags, border_mode,
align_corners)
def warp_perspective3d(
src: torch.Tensor,
M: torch.Tensor,
dsize: Tuple[int, int, int],
flags: str = 'bilinear',
border_mode: str = 'zeros',
align_corners: bool = False,
) -> torch.Tensor:
r"""Applies a perspective transformation to an image.
The function warp_perspective transforms the source image using
the specified matrix:
.. math::
\text{dst} (x, y) = \text{src} \left(
\frac{M_{11} x + M_{12} y + M_{13}}{M_{31} x + M_{32} y + M_{33}} ,
\frac{M_{21} x + M_{22} y + M_{23}}{M_{31} x + M_{32} y + M_{33}}
\right )
Args:
src: input image with shape :math:`(B, C, D, H, W)`.
M: transformation matrix with shape :math:`(B, 4, 4)`.
dsize: size of the output image (height, width).
flags: interpolation mode to calculate output values
``'bilinear'`` | ``'nearest'``.
border_mode: padding mode for outside grid values
``'zeros'`` | ``'border'`` | ``'reflection'``.
align_corners: interpolation flag.
Returns:
the warped input image :math:`(B, C, D, H, W)`.
.. note::
This function is often used in conjuntion with :func:`get_perspective_transform3d`.
"""
check_is_tensor(src)
check_is_tensor(M)
if not len(src.shape) == 5:
raise ValueError("Input src must be a BxCxDxHxW tensor. Got {}".format(
src.shape))
if not (len(M.shape) == 3 or M.shape[-2:] == (4, 4)):
raise ValueError("Input M must be a Bx4x4 tensor. Got {}".format(
M.shape))
# launches the warper
d, h, w = src.shape[-3:]
return transform_warp_impl3d(src, M, (d, h, w), dsize, flags, border_mode,
align_corners)
def normalize_homography3d(dst_pix_trans_src_pix: torch.Tensor,
dsize_src: Tuple[int, int, int],
dsize_dst: Tuple[int, int, int]) -> torch.Tensor:
r"""Normalize a given homography in pixels to [-1, 1].
Args:
dst_pix_trans_src_pix: homography/ies from source to destination to be
normalized. :math:`(B, 4, 4)`
dsize_src: size of the source image (depth, height, width).
dsize_src: size of the destination image (depth, height, width).
Returns:
the normalized homography.
Shape:
Output: :math:`(B, 4, 4)`
"""
check_is_tensor(dst_pix_trans_src_pix)
if not (len(dst_pix_trans_src_pix.shape) == 3
or dst_pix_trans_src_pix.shape[-2:] == (4, 4)):
raise ValueError(
f"Input dst_pix_trans_src_pix must be a Bx3x3 tensor. Got {dst_pix_trans_src_pix.shape}"
)
# source and destination sizes
src_d, src_h, src_w = dsize_src
dst_d, dst_h, dst_w = dsize_dst
# compute the transformation pixel/norm for src/dst
src_norm_trans_src_pix: torch.Tensor = normal_transform_pixel3d(
src_d, src_h, src_w).to(dst_pix_trans_src_pix)
src_pix_trans_src_norm = _torch_inverse_cast(src_norm_trans_src_pix)
dst_norm_trans_dst_pix: torch.Tensor = normal_transform_pixel3d(
dst_d, dst_h, dst_w).to(dst_pix_trans_src_pix)
# compute chain transformations
dst_norm_trans_src_norm: torch.Tensor = dst_norm_trans_dst_pix @ (
dst_pix_trans_src_pix @ src_pix_trans_src_norm)
return dst_norm_trans_src_norm
def denormalize_homography(dst_pix_trans_src_pix: torch.Tensor,
dsize_src: Tuple[int, int],
dsize_dst: Tuple[int, int]) -> torch.Tensor:
r"""De-normalize a given homography in pixels from [-1, 1] to actual height and width.
Args:
dst_pix_trans_src_pix: homography/ies from source to destination to be
denormalized. :math:`(B, 3, 3)`
dsize_src: size of the source image (height, width).
dsize_dst: size of the destination image (height, width).
Returns:
the denormalized homography of shape :math:`(B, 3, 3)`.
"""
check_is_tensor(dst_pix_trans_src_pix)
if not (len(dst_pix_trans_src_pix.shape) == 3
or dst_pix_trans_src_pix.shape[-2:] == (3, 3)):
raise ValueError(
f"Input dst_pix_trans_src_pix must be a Bx3x3 tensor. Got {dst_pix_trans_src_pix.shape}"
)
# source and destination sizes
src_h, src_w = dsize_src
dst_h, dst_w = dsize_dst
# compute the transformation pixel/norm for src/dst
src_norm_trans_src_pix: torch.Tensor = normal_transform_pixel(
src_h, src_w).to(dst_pix_trans_src_pix)
dst_norm_trans_dst_pix: torch.Tensor = normal_transform_pixel(
dst_h, dst_w).to(dst_pix_trans_src_pix)
dst_denorm_trans_dst_pix = _torch_inverse_cast(dst_norm_trans_dst_pix)
# compute chain transformations
dst_norm_trans_src_norm: torch.Tensor = dst_denorm_trans_dst_pix @ (
dst_pix_trans_src_pix @ src_norm_trans_src_pix)
return dst_norm_trans_src_norm
def transform_points(trans_01: torch.Tensor,
points_1: torch.Tensor) -> torch.Tensor:
r"""Function that applies transformations to a set of points.
Args:
trans_01 (torch.Tensor): tensor for transformations of shape
:math:`(B, D+1, D+1)`.
points_1 (torch.Tensor): tensor of points of shape :math:`(B, N, D)`.
Returns:
torch.Tensor: tensor of N-dimensional points.
Shape:
- Output: :math:`(B, N, D)`
Examples:
>>> points_1 = torch.rand(2, 4, 3) # BxNx3
>>> trans_01 = torch.eye(4).view(1, 4, 4) # Bx4x4
>>> points_0 = kornia.transform_points(trans_01, points_1) # BxNx3
"""
check_is_tensor(trans_01)
check_is_tensor(points_1)
if not trans_01.device == points_1.device:
raise TypeError("Tensor must be in the same device")
if not trans_01.shape[0] == points_1.shape[0] and trans_01.shape[0] != 1:
raise ValueError(
"Input batch size must be the same for both tensors or 1")
if not trans_01.shape[-1] == (points_1.shape[-1] + 1):
raise ValueError("Last input dimensions must differe by one unit")
# to homogeneous
points_1_h = convert_points_to_homogeneous(points_1) # BxNxD+1
# transform coordinates
points_0_h = torch.matmul(trans_01.unsqueeze(1), points_1_h.unsqueeze(-1))
points_0_h = torch.squeeze(points_0_h, dim=-1)
# to euclidean
points_0 = convert_points_from_homogeneous(points_0_h) # BxNxD
return points_0
def _validate_batched_image_tensor_input(tensor):
check_is_tensor(tensor)
if not len(tensor.shape) == 4:
raise ValueError(
"Invalid input shape, we expect BxCxHxW. Got: {}".format(
tensor.shape))
def filter2D(input: torch.Tensor, kernel: torch.Tensor,
border_type: str = 'reflect',
normalized: bool = False) -> torch.Tensor:
r"""Function that convolves a tensor with a 2d kernel.
The function applies a given kernel to a tensor. The kernel is applied
independently at each depth channel of the tensor. Before applying the
kernel, the function applies padding according to the specified mode so
that the output remains in the same shape.
Args:
input (torch.Tensor): the input tensor with shape of
:math:`(B, C, H, W)`.
kernel (torch.Tensor): the kernel to be convolved with the input
tensor. The kernel shape must be :math:`(1, kH, kW)`.
border_type (str): the padding mode to be applied before convolving.
The expected modes are: ``'constant'``, ``'reflect'``,
``'replicate'`` or ``'circular'``. Default: ``'reflect'``.
normalized (bool): If True, kernel will be L1 normalized.
Return:
torch.Tensor: the convolved tensor of same size and numbers of channels
as the input with shape :math:`(B, C, H, W)`.
Example:
>>> input = torch.tensor([[[
... [0., 0., 0., 0., 0.],
... [0., 0., 0., 0., 0.],
... [0., 0., 5., 0., 0.],
... [0., 0., 0., 0., 0.],
... [0., 0., 0., 0., 0.],]]])
>>> kernel = torch.ones(1, 3, 3)
>>> kornia.filter2D(input, kernel)
torch.tensor([[[[0., 0., 0., 0., 0.]
[0., 5., 5., 5., 0.]
[0., 5., 5., 5., 0.]
[0., 5., 5., 5., 0.]
[0., 0., 0., 0., 0.]]]])
"""
testing.check_is_tensor(input)
testing.check_is_tensor(kernel)
if not isinstance(border_type, str):
raise TypeError("Input border_type is not string. Got {}"
.format(type(kernel)))
if not len(input.shape) == 4:
raise ValueError("Invalid input shape, we expect BxCxHxW. Got: {}"
.format(input.shape))
if not len(kernel.shape) == 3 and kernel.shape[0] != 1:
raise ValueError("Invalid kernel shape, we expect 1xHxW. Got: {}"
.format(kernel.shape))
# prepare kernel
b, c, h, w = input.shape
tmp_kernel: torch.Tensor = kernel[None].type_as(input)
if normalized:
tmp_kernel = normalize_kernel2d(tmp_kernel)
# pad the input tensor
height, width = tmp_kernel.shape[-2:]
padding_shape: List[int] = compute_padding([height, width])
input_pad: torch.Tensor = F.pad(input, padding_shape, mode=border_type)
return F.conv2d(input_pad, tmp_kernel.expand(c, -1, -1, -1), groups=c, padding=0, stride=1)
def filter3D(input: torch.Tensor,
kernel: torch.Tensor,
border_type: str = 'replicate',
normalized: bool = False) -> torch.Tensor:
r"""Convolve a tensor with a 3d kernel.
The function applies a given kernel to a tensor. The kernel is applied
independently at each depth channel of the tensor. Before applying the
kernel, the function applies padding according to the specified mode so
that the output remains in the same shape.
Args:
input (torch.Tensor): the input tensor with shape of
:math:`(B, C, D, H, W)`.
kernel (torch.Tensor): the kernel to be convolved with the input
tensor. The kernel shape must be :math:`(1, kD, kH, kW)` or :math:`(B, kD, kH, kW)`.
border_type (str): the padding mode to be applied before convolving.
The expected modes are: ``'constant'``,
``'replicate'`` or ``'circular'``. Default: ``'replicate'``.
normalized (bool): If True, kernel will be L1 normalized.
Return:
torch.Tensor: the convolved tensor of same size and numbers of channels
as the input with shape :math:`(B, C, D, H, W)`.
Example:
>>> input = torch.tensor([[[
... [[0., 0., 0., 0., 0.],
... [0., 0., 0., 0., 0.],
... [0., 0., 0., 0., 0.],
... [0., 0., 0., 0., 0.],
... [0., 0., 0., 0., 0.]],
...
... [[0., 0., 0., 0., 0.],
... [0., 0., 0., 0., 0.],
... [0., 0., 5., 0., 0.],
... [0., 0., 0., 0., 0.],
... [0., 0., 0., 0., 0.]],
...
... [[0., 0., 0., 0., 0.],
... [0., 0., 0., 0., 0.],
... [0., 0., 0., 0., 0.],
... [0., 0., 0., 0., 0.],
... [0., 0., 0., 0., 0.]]]])
>>> kernel = torch.ones(1, 3, 3, 3)
>>> kornia.filter3D(input, kernel)
torch.tensor([[[[[0., 0., 0., 0., 0.],
[0., 5., 5., 5., 0.],
[0., 5., 5., 5., 0.],
[0., 5., 5., 5., 0.],
[0., 0., 0., 0., 0.]],
[[0., 0., 0., 0., 0.],
[0., 5., 5., 5., 0.],
[0., 5., 5., 5., 0.],
[0., 5., 5., 5., 0.],
[0., 0., 0., 0., 0.]],
[[0., 0., 0., 0., 0.],
[0., 5., 5., 5., 0.],
[0., 5., 5., 5., 0.],
[0., 5., 5., 5., 0.],
[0., 0., 0., 0., 0.]]]])
"""
testing.check_is_tensor(input)
testing.check_is_tensor(kernel)
if not isinstance(border_type, str):
raise TypeError("Input border_type is not string. Got {}".format(
type(kernel)))
if not len(input.shape) == 5:
raise ValueError(
"Invalid input shape, we expect BxCxDxHxW. Got: {}".format(
input.shape))
if not len(kernel.shape) == 4 and kernel.shape[0] != 1:
raise ValueError(
"Invalid kernel shape, we expect 1xDxHxW. Got: {}".format(
kernel.shape))
# prepare kernel
b, c, d, h, w = input.shape
tmp_kernel: torch.Tensor = kernel.unsqueeze(1).to(input)
if normalized:
bk, dk, hk, wk = kernel.shape
tmp_kernel = normalize_kernel2d(tmp_kernel.view(
bk, dk, hk * wk)).view_as(tmp_kernel)
tmp_kernel = tmp_kernel.expand(-1, c, -1, -1, -1)
# pad the input tensor
depth, height, width = tmp_kernel.shape[-3:]
padding_shape: List[int] = compute_padding([depth, height, width])
input_pad: torch.Tensor = F.pad(input, padding_shape, mode=border_type)
# kernel and input tensor reshape to align element-wise or batch-wise params
tmp_kernel = tmp_kernel.reshape(-1, 1, depth, height, width)
input_pad = input_pad.view(-1, tmp_kernel.size(0), input_pad.size(-3),
input_pad.size(-2), input_pad.size(-1))
# convolve the tensor with the kernel.
output = F.conv3d(input_pad,
tmp_kernel,
groups=tmp_kernel.size(0),
padding=0,
stride=1)
return output.view(b, c, d, h, w)