def warp_affine(src: torch.Tensor, M: torch.Tensor,
dsize: Tuple[int, int], flags: str = 'bilinear',
padding_mode: str = 'zeros',
align_corners: bool = False) -> torch.Tensor:
r"""Applies an affine transformation to a tensor.
The function warp_affine transforms the source tensor using
the specified matrix:
.. math::
\text{dst}(x, y) = \text{src} \left( M_{11} x + M_{12} y + M_{13} ,
M_{21} x + M_{22} y + M_{23} \right )
Args:
src (torch.Tensor): input tensor of shape :math:`(B, C, H, W)`.
M (torch.Tensor): affine transformation of shape :math:`(B, 2, 3)`.
dsize (Tuple[int, int]): size of the output image (height, width).
mode (str): interpolation mode to calculate output values
'bilinear' | 'nearest'. Default: 'bilinear'.
padding_mode (str): padding mode for outside grid values
'zeros' | 'border' | 'reflection'. Default: 'zeros'.
align_corners (bool): mode for grid_generation. Default: False.
Returns:
torch.Tensor: the warped tensor with shape :math:`(B, C, H, W)`.
.. note::
See a working example `here <https://kornia.readthedocs.io/en/latest/
tutorials/warp_affine.html>`__.
"""
if not isinstance(src, torch.Tensor):
raise TypeError("Input src type is not a torch.Tensor. Got {}"
.format(type(src)))
if not isinstance(M, torch.Tensor):
raise TypeError("Input M type is not a torch.Tensor. Got {}"
.format(type(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:] == (2, 3)):
raise ValueError("Input M must be a Bx2x3 tensor. Got {}"
.format(M.shape))
B, C, H, W = src.size()
dsize_src = (H, W)
out_size = dsize
# we generate a 3x3 transformation matrix from 2x3 affine
M_3x3: torch.Tensor = convert_affinematrix_to_homography(M)
dst_norm_trans_src_norm: torch.Tensor = normalize_homography(
M_3x3, dsize_src, out_size)
src_norm_trans_dst_norm = torch.inverse(dst_norm_trans_src_norm)
grid = F.affine_grid(src_norm_trans_dst_norm[:, :2, :],
[B, C, out_size[0], out_size[1]],
align_corners=align_corners)
return F.grid_sample(src, grid,
align_corners=align_corners,
mode=flags,
padding_mode=padding_mode)
def transform_warp_impl(src: torch.Tensor, dst_pix_trans_src_pix: torch.Tensor,
dsize_src: Tuple[int, int], dsize_dst: Tuple[int, int],
grid_mode: str, padding_mode: str,
align_corners: bool) -> torch.Tensor:
"""Compute the transform in normalized cooridnates and perform the warping.
"""
dst_norm_trans_src_norm: torch.Tensor = normalize_homography(
dst_pix_trans_src_pix, dsize_src, dsize_dst)
src_norm_trans_dst_norm = torch.inverse(dst_norm_trans_src_norm)
return homography_warp(src, src_norm_trans_dst_norm, dsize_dst, grid_mode, padding_mode, align_corners)
