o oi/@s&ddlmZddlmZddlZddlmmZddl m Z m Z m Z m Z mZmZmZmZddlmZmZddlmZmZmZmZmZmZmZmZddlmZddl m!Z!m"Z"m#Z#dd l$m%Z%m&Z&gd Z' dzd{ddZ( dzd{ddZ)d|d d!Z*d}d#d$Z+d}d%d&Z,d~d)d*Z-dd.d/Z.  0ddd6d7Z/dd9d:Z0  ddd>d?Z1dd@dAZ2dddBdCZ3      dddKdLZ4      dddMdNZ5ddVdWZ6 dddZd[Z7dd^d_Z8ddadbZ9ddddeZ:ddidjZ; 0dddldmZ< 0 dddpdqZ=ddvdwZ> 0 dddxdyZ?dS)) annotations)OptionalN)Tensor concatenateones ones_likestacktantensorzeros) KORNIA_CHECKKORNIA_CHECK_SHAPE)angle_to_rotation_matrixaxis_angle_to_rotation_matrix"convert_affinematrix_to_homography$convert_affinematrix_to_homography3ddeg2radnormalize_homographynormalize_homography3dnormalize_pixel_coordinates)transform_points)create_meshgridcreate_meshgrid3deye_like)_torch_inverse_cast_torch_solve_cast)get_affine_matrix2dget_affine_matrix3dget_perspective_transformget_perspective_transform3dget_projective_transformget_rotation_matrix2dget_shear_matrix2dget_shear_matrix3dget_translation_matrix2dhomography_warphomography_warp3dinvert_affine_transformprojection_from_Rtremap warp_affine warp_affine3d warp_grid warp_grid3dwarp_perspectivewarp_perspective3dbilinearr TsrcrMdsizetuple[int, int]modestr padding_mode align_cornersbool fill_valueOptional[Tensor]returncCs`t|tstdt|t|tstdt|t|jdks+td|jt|jdkr;|jdddksCtd |j|durKtd}|d kr`|jt dgkr`td |j| \}}} } |\} } t || | f| | f} t | }t | | d |jd |j|| | d}t|ddddf|}|d krt|||||dStj|||||dS)aApply 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^{-1}_{11} x + M^{-1}_{12} y + M^{-1}_{13}}{M^{-1}_{31} x + M^{-1}_{32} y + M^{-1}_{33}} , \frac{M^{-1}_{21} x + M^{-1}_{22} y + M^{-1}_{23}}{M^{-1}_{31} x + M^{-1}_{32} y + M^{-1}_{33}} \right ) Args: src: input image with shape :math:`(B, C, H, W)`. M: transformation matrix with shape :math:`(B, 3, 3)`. dsize: size of the output image (height, width). mode: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``. padding_mode: padding mode for outside grid values ``'zeros'`` | ``'border'`` | ``'reflection'`` | ``'fill'``. align_corners: interpolation flag. fill_value: tensor of shape :math:`(3)` that fills the padding area. Only supported for RGB. Returns: the warped input image :math:`(B, C, H, W)`. Example: >>> img = torch.rand(1, 4, 5, 6) >>> H = torch.eye(3)[None] >>> out = warp_perspective(img, H, (4, 2), align_corners=True) >>> print(out.shape) torch.Size([1, 4, 4, 2]) .. note:: This function is often used in conjunction with :func:`get_perspective_transform`. .. note:: See a working example `here `_. $Input src type is not a Tensor. Got "Input M type is not a Tensor. Got (Input src must be a BxCxHxW tensor. Got NrArAz$Input M must be a Bx3x3 tensor. Got fillz2Padding_tensor only supported for 3 channels. Got Tnormalized_coordinatesdevicer8r5r:r8r5r7) isinstancer TypeErrortypelenshape ValueErrorr torchSizesizerrrrGtodtypeexpandr_fill_and_warpF grid_sample)r1r2r3r5r7r8r:B_HWh_outw_outdst_norm_trans_src_normsrc_norm_trans_dst_normgridrcU/home/ubuntu/.local/lib/python3.10/site-packages/kornia/geometry/transform/imgwarp.pyr.As0 .   r.cCs*t|tstdt|t|tstdt|t|jdks+td|jt|jdksC|jdddksCtd |j|\}}} } t|} t | | | f|} t | } t j | dddd ddf|||d |d g|d }|dkr|durt d}t|||||dSt j|||||dS)aApply an affine transformation to a tensor. .. image:: _static/img/warp_affine.png 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: input tensor of shape :math:`(B, C, H, W)`. M: affine transformation of shape :math:`(B, 2, 3)`. dsize: size of the output image (height, width). mode: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``. padding_mode: padding mode for outside grid values ``'zeros'`` | ``'border'`` | ``'reflection'`` | ``'fill'``. align_corners : mode for grid_generation. fill_value: tensor of shape :math:`(3)` that fills the padding area. Only supported for RGB. Returns: the warped tensor with shape :math:`(B, C, H, W)`. .. note:: This function is often used in conjunction with :func:`get_rotation_matrix2d`, :func:`get_shear_matrix2d`, :func:`get_affine_matrix2d`, :func:`invert_affine_transform`. .. note:: See a working example `here `__. Example: >>> img = torch.rand(1, 4, 5, 6) >>> A = torch.eye(2, 3)[None] >>> out = warp_affine(img, A, (4, 2), align_corners=True) >>> print(out.shape) torch.Size([1, 4, 4, 2]) r=r>r?r@rArBNrHrAz$Input M must be a Bx2x3 tensor. Got rHrr8rDrIrJ)rKrrLrMrNrOrPrSrrrrX affine_gridr rWrY)r1r2r3r5r7r8r:rZCr\r]M_3x3r`rarbrcrcrdr*s$ /  6r*rbcCsZt|}||dddddf}dtj||||dd}||}tj||||dd|S)aWarp a mask of ones, then multiple with fill_value and add to default warp. Args: src: input tensor of shape :math:`(B, 3, H, W)`. grid: grid tensor from `transform_points`. mode: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``. align_corners: interpolation flag. fill_value: tensor of shape :math:`(3)` that fills the padding area. Only supported for RGB. Returns: the warped and filled tensor with shape :math:`(B, 3, H, W)`. Nrfr rJ)rrTrXrY)r1rbr5r8r: ones_mask inv_ones_maskinv_color_maskrcrcrdrWs rW src_homo_dstcCsh|d}|\}}}}||ddd}t|jdkr$||ddd}t|||}||||dS)aCompute the grid to warp the coordinates grid by the homography/ies. Args: grid: Unwrapped grid of the shape :math:`(1, H, W, 2)`. src_homo_dst: Homography or homographies (stacked) to transform all points in the grid. Shape of the homography has to be :math:`(1, 3, 3)` or :math:`(N, 1, 3, 3)`. Returns: the transformed grid of shape :math:`(N, H, W, 2)`. rrArfrHrSrVrNrOviewrrT)rbrn batch_sizer[heightwidthflowrcrcrdr,s r,cCsn|d}|\}}}}}||dddd}t|jdkr&||ddd}t|||}|||||dS)aCompute the grid to warp the coordinates grid by the homography/ies. Args: grid: Unwrapped grid of the shape :math:`(1, D, H, W, 3)`. src_homo_dst: Homography or homographies (stacked) to transform all points in the grid. Shape of the homography has to be :math:`(1, 4, 4)` or :math:`(N, 1, 4, 4)`. Returns: the transformed grid of shape :math:`(N, H, W, 3)`. rrorArfr?rp)rbrnrrr[depthrsrtrurcrcrdr-s r- points_src points_dstc Cst|gdt|gdt|j|jkdt|j|jkd|jd}tj|dd|j|jd}t||j|jd}t||j|jd}t dD]X}|d|df|d|d f}}|d|df|d|d f} } t ||||||| | | | gd |d d d |f<t ||||||| | | | gd |d d d |d f<qG| d dd } t || } tj|d |j|jd} | d| dd df<| d d | d ddS)a^Calculate a perspective transform from four pairs of the corresponding points. The algorithm is a vanilla implementation of the Direct Linear transform (DLT). See more: https://www.cs.cmu.edu/~16385/s17/Slides/10.2_2D_Alignment__DLT.pdf The function calculates the matrix of a perspective transform that maps from the source to destination points: .. math:: \begin{bmatrix} x^{'} \\ y^{'} \\ 1 \\ \end{bmatrix} = \begin{bmatrix} h_1 & h_2 & h_3 \\ h_4 & h_5 & h_6 \\ h_7 & h_8 & h_9 \\ \end{bmatrix} \cdot \begin{bmatrix} x \\ y \\ 1 \\ \end{bmatrix} Args: points_src: coordinates of quadrangle vertices in the source image with shape :math:`(B, 4, 2)`. points_dst: coordinates of the corresponding quadrangle vertices in the destination image with shape :math:`(B, 4, 2)`. Returns: the perspective transformation with shape :math:`(B, 3, 3)`. .. note:: This function is often used in conjunction with :func:`warp_perspective`. Example: >>> x1 = torch.tensor([[[0., 0.], [1., 0.], [1., 1.], [0., 1.]]]) >>> x2 = torch.tensor([[[1., 0.], [0., 0.], [0., 1.], [1., 1.]]]) >>> x2_trans_x1 = get_perspective_transform(x1, x2) )rZ42z4Source data shape must match Destination data shape.z2Source data type must match Destination data type.rrGrUr?.rfroNrH .r.rorA)r r rOrUrQemptyrGr rrangerrqrfill_)rwrxrZA_zeros_onesix1y1x2y2bXr2rcrcrdr3s&.  6< rcenteranglescalecCspt|tstdt|t|tstdt|t|ts*tdt|t|jdkr8|jddks@td|jt|jdksOtd|jt|jdkr]|jddksetd|j|jd |jd krx|jd ksntd |jd |jd |j|j|jkr|jkrnn|j|jkr|jksntd |jd|jd|jd|jd|jd|jd t d|}||dddddf<t d|}| |dddddf<t d|}|ddd d f|ddd f9<|ddddf|dddf9<t d|}t ||ddddddf<||||}|ddddddfS)aCalculate an affine matrix of 2D rotation. The function calculates the following matrix: .. math:: \begin{bmatrix} \alpha & \beta & (1 - \alpha) \cdot \text{x} - \beta \cdot \text{y} \\ -\beta & \alpha & \beta \cdot \text{x} + (1 - \alpha) \cdot \text{y} \end{bmatrix} where .. math:: \alpha = \text{scale} \cdot cos(\text{angle}) \\ \beta = \text{scale} \cdot sin(\text{angle}) The transformation maps the rotation center to itself If this is not the target, adjust the shift. Args: center: center of the rotation in the source image with shape :math:`(B, 2)`. angle: rotation angle in degrees. Positive values mean counter-clockwise rotation (the coordinate origin is assumed to be the top-left corner) with shape :math:`(B)`. scale: scale factor for x, y scaling with shape :math:`(B, 2)`. Returns: the affine matrix of 2D rotation with shape :math:`(B, 2, 3)`. Example: >>> center = zeros(1, 2) >>> scale = torch.ones((1, 2)) >>> angle = 45. * torch.ones(1) >>> get_rotation_matrix2d(center, angle, scale) tensor([[[ 0.7071, 0.7071, 0.0000], [-0.7071, 0.7071, 0.0000]]]) .. note:: This function is often used in conjunction with :func:`warp_affine`. z'Input center type is not a Tensor. Got z&Input angle type is not a Tensor. Got z&Input scale type is not a Tensor. Got rHrfz'Input center must be a Bx2 tensor. Got z$Input angle must be a B tensor. Got z&Input scale must be a Bx2 tensor. Got rz7Inputs must have same batch size dimension. Got center z, angle z and scale z)Inputs must have same device Got center (, z ), angle (z ) and scale ()rAN) rKrrLrMrNrOrPrGrUrr)rrrshift_m shift_m_invscale_mrotat_maffine_mrcrcrdr!sN ,  (:   && r!Fimagemap_xmap_yOptional[bool]rFc Cszt|gdt|gdt|gd|j\}}} } t||gd} |s+t| | | } | |ddd} tj|| |||dS)a1Apply a generic geometrical transformation to an image tensor. .. image:: _static/img/remap.png The function remap transforms the source tensor using the specified map: .. math:: \text{dst}(x, y) = \text{src}(map_x(x, y), map_y(x, y)) Args: image: the tensor to remap with shape (B, C, H, W). Where C is the number of channels. map_x: the flow in the x-direction in pixel coordinates. The tensor must be in the shape of (B, H, W). map_y: the flow in the y-direction in pixel coordinates. The tensor must be in the shape of (B, H, W). mode: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``. padding_mode: padding mode for outside grid values ``'zeros'`` | ``'border'`` | ``'reflection'``. align_corners: mode for grid_generation. normalized_coordinates: whether the input coordinates are normalized in the range of [-1, 1]. Returns: the warped tensor with same shape as the input grid maps. Example: >>> import torch >>> from kornia.utils import create_meshgrid >>> grid = create_meshgrid(2, 2, False) # 1x2x2x2 >>> grid += 1 # apply offset in both directions >>> input = torch.ones(1, 1, 2, 2) >>> remap(input, grid[..., 0], grid[..., 1], align_corners=True) # 1x1x2x2 tensor([[[[1., 0.], [0., 0.]]]]) .. note:: This function is often used in conjunction with :func:`kornia.utils.create_meshgrid`. )rZrir\r])rZr\r]ror5r7r8)r rOrrrVrXrY) rrrr5r7r8rFrrr[rsrtmap_xyrcrcrdr)s2 r)matrixcCsrt|tstdt|t|jdkr|jdddks&td|jt|}t|}|dddddfS) ajInvert an affine transformation. The function computes an inverse affine transformation represented by 2x3 matrix: .. math:: \begin{bmatrix} a_{11} & a_{12} & b_{1} \\ a_{21} & a_{22} & b_{2} \\ \end{bmatrix} The result is also a 2x3 matrix of the same type as M. Args: matrix: original affine transform. The tensor must be in the shape of :math:`(B, 2, 3)`. Return: the reverse affine transform with shape :math:`(B, 2, 3)`. .. note:: This function is often used in conjunction with :func:`warp_affine`. z'Input matrix type is not a Tensor. Got rArBNrez)Input matrix must be a Bx2x3 tensor. Got .rH) rKrrLrMrNrOrPrr)r matrix_tmp matrix_invrcrcrdr'*s  r' translationssxsyc CsTt|| |}|d|7<t|}tdd||fDr(t|||}||}|S)aCompose affine matrix from the components. Args: translations: tensor containing the translation vector with shape :math:`(B, 2)`. center: tensor containing the center vector with shape :math:`(B, 2)`. scale: tensor containing the scale factor with shape :math:`(B, 2)`. angle: tensor of angles in degrees :math:`(B)`. sx: tensor containing the shear factor in the x-direction with shape :math:`(B)`. sy: tensor containing the shear factor in the y-direction with shape :math:`(B)`. Returns: the affine transformation matrix :math:`(B, 3, 3)`. .. note:: This function is often used in conjunction with :func:`warp_affine`, :func:`warp_perspective`. .rHcs|]}|duVqdSNrc.0srcrcrd nz&get_affine_matrix2d..)r!ranyr") rrrrrr transform transform_h shear_matrcrcrdrOs rcCs<td|ddddddf}|d|7<t|}|S)aZCompose translation matrix from the components. Args: translations: tensor containing the translation vector with shape :math:`(B, 2)`. Returns: the affine transformation matrix :math:`(B, 3, 3)`. .. note:: This function is often used in conjunction with :func:`warp_affine`, :func:`warp_perspective`. rANrHr)rr)rrrrcrcrdr$us r$c Cs|durtdg|dn|}|dur tdg|dn|}tj|ddd\}}|d|d}}t|}t|}t|}t|| ||| |||||||gddddd}t |}|S) aCompose shear matrix Bx4x4 from the components. Note: Ordered shearing, shear x-axis then y-axis. .. math:: \begin{bmatrix} 1 & b \\ a & ab + 1 \\ \end{bmatrix} Args: center: shearing center coordinates of (x, y). sx: shearing angle along x axis in radiants. sy: shearing angle along y axis in radiants Returns: params to be passed to the affine transformation with shape :math:`(B, 3, 3)`. Examples: >>> rng = torch.manual_seed(0) >>> sx = torch.randn(1) >>> sx tensor([1.5410]) >>> center = torch.tensor([[0., 0.]]) # Bx2 >>> get_shear_matrix2d(center, sx=sx) tensor([[[ 1.0000, -33.5468, 0.0000], [ -0.0000, 1.0000, 0.0000], [ 0.0000, 0.0000, 1.0000]]]) .. note:: This function is often used in conjunction with :func:`warp_affine`, :func:`warp_perspective`. NrrfrodimrHrA) r repeatrSrQsplitrqr rrr) rrrxysx_tansy_tanrrrcrcrdr"s""", r"anglessxysxzsyxsyzszxszyc Csdt|| |} | d|7<t| } tdd|||||| fDr0t||||||| } | | } | S)aCompose 3d affine matrix from the components. Args: translations: tensor containing the translation vector (dx,dy,dz) with shape :math:`(B, 3)`. center: tensor containing the center vector (x,y,z) with shape :math:`(B, 3)`. scale: tensor containing the scale factor with shape :math:`(B)`. angles: axis angle vector containing the rotation angles in degrees in the form of (rx, ry, rz) with shape :math:`(B, 3)`. Internally it calls Rodrigues to compute the rotation matrix from axis-angle. sxy: tensor containing the shear factor in the xy-direction with shape :math:`(B)`. sxz: tensor containing the shear factor in the xz-direction with shape :math:`(B)`. syx: tensor containing the shear factor in the yx-direction with shape :math:`(B)`. syz: tensor containing the shear factor in the yz-direction with shape :math:`(B)`. szx: tensor containing the shear factor in the zx-direction with shape :math:`(B)`. szy: tensor containing the shear factor in the zy-direction with shape :math:`(B)`. Returns: the 3d affine transformation matrix :math:`(B, 3, 3)`. .. note:: This function is often used in conjunction with :func:`warp_perspective`. ).rAcsrrrcrrcrcrdrrz&get_affine_matrix3d..)r rrr#) rrrrrrrrrrrrrrcrcrdrs#rc Cs$|durtdg|dn|}|dur tdg|dn|}|dur1tdg|dn|}|durBtdg|dn|}|durStdg|dn|}|durdtdg|dn|}tj|ddd\}}} |d|d| d}}} t|} t|} t|} t|} t|}t|}t| | | | ||\ }}}}}}}}}|||| }|||||| |}|||||| | }| | | | | | f\} } } } }}t| | | | ||\ }}}}}}}}}t||||||||||||g dddd}t |}|S) aOCompose shear matrix Bx4x4 from the components. Note: Ordered shearing, shear x-axis then y-axis then z-axis. .. math:: \begin{bmatrix} 1 & o & r & oy + rz \\ m & p & s & mx + py + sz -y \\ n & q & t & nx + qy + tz -z \\ 0 & 0 & 0 & 1 \\ \end{bmatrix} Where: m = S_{xy} n = S_{xz} o = S_{yx} p = S_{xy}S_{yx} + 1 q = S_{xz}S_{yx} + S_{yz} r = S_{zx} + S_{yx}S_{zy} s = S_{xy}S_{zx} + (S_{xy}S_{yx} + 1)S_{zy} t = S_{xz}S_{zx} + (S_{xz}S_{yx} + S_{yz})S_{zy} + 1 Params: center: shearing center coordinates of (x, y, z). sxy: shearing angle along x axis, towards y plane in radiants. sxz: shearing angle along x axis, towards z plane in radiants. syx: shearing angle along y axis, towards x plane in radiants. syz: shearing angle along y axis, towards z plane in radiants. szx: shearing angle along z axis, towards x plane in radiants. szy: shearing angle along z axis, towards y plane in radiants. Returns: params to be passed to the affine transformation. Examples: >>> rng = torch.manual_seed(0) >>> sxy, sxz, syx, syz = torch.randn(4, 1) >>> sxy, sxz, syx, syz (tensor([1.5410]), tensor([-0.2934]), tensor([-2.1788]), tensor([0.5684])) >>> center = torch.tensor([[0., 0., 0.]]) # Bx3 >>> get_shear_matrix3d(center, sxy=sxy, sxz=sxz, syx=syx, syz=syz) tensor([[[ 1.0000, -1.4369, 0.0000, 0.0000], [-33.5468, 49.2039, 0.0000, 0.0000], [ 0.3022, -1.0729, 1.0000, 0.0000], [ 0.0000, 0.0000, 0.0000, 1.0000]]]) .. note:: This function is often used in conjunction with :func:`warp_perspective3d`. NrrrfrorrAr?) r rrSrQrrqr _compute_shear_matrix_3drr)rrrrrrrrrzsxy_tansxz_tansyx_tansyz_tanszx_tanszy_tanm00m10m20m01m11m21m02m12m22m03m13m23rrcrcrdr#s6":"""""" ( ,r#rrrrrrtuple[Tensor, ...]c Cs~t|}|||}}} |||||||} } } |||} |||| }|||| |}||| | | | | ||f Sr)r)rrrrrrrrrrrrrrrrrcrcrdrMs  rtuple[int, int, int]flagscCst|jdkr t|jt|jdkr|jdddks!t|jt|dkr+t||\}}}} } || | f} |} t|} t| | | }t|}|ddddf}||gt| }tj |||d}tj |||||dS)aDApply a projective transformation a to 3d tensor. .. warning:: This API signature it is experimental and might suffer some changes in the future. Args: src : input tensor of shape :math:`(B, C, D, H, W)`. M: projective transformation matrix of shape :math:`(B, 3, 4)`. dsize: size of the output image (depth, height, width). flags: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``. padding_mode: padding mode for outside grid values ``'zeros'`` | ``'border'`` | ``'reflection'``. align_corners : mode for grid_generation. Returns: Tensor: the warped 3d tensor with shape :math:`(B, C, D, H, W)`. .. note:: This function is often used in conjunction with :func:`get_perspective_transform3d`. rArBN)rAr?rgrJ) rNrOAssertionErrorrSrrrlistrXrhrY)r1r2r3rr7r8rZriDr\r]size_srcsize_outM_4x4r`raP_norm dsize_outrbrcrcrdr+Zs       r+rmattveccCsbt|jdkr|jdddkst|jt|jdkr%|jdddks*t|jt||gdS)aCompute the projection matrix from Rotation and translation. .. warning:: This API signature it is experimental and might suffer some changes in the future. Concatenates the batch of rotations and translations such that :math:`P = [R | t]`. Args: rmat: the rotation matrix with shape :math:`(*, 3, 3)`. tvec: the translation vector with shape :math:`(*, 3, 1)`. Returns: the projection matrix with shape :math:`(*, 3, 4)`. rHrBNrC)rArfro)rNrOrr)rrrcrcrdr(s    r(scalesc Cs.t|jdkr|jddkst|jt|jdkr!|jddks&t|j|j|jkr3t|j|j|j|jkr@t|j|jt|}t|}td|}||jdd}|| |}td|dd}|d d ddf|7<| }t |}t |t |d }t|}|||}|d d dd d fS) aLCalculate the projection matrix for a 3D rotation. .. warning:: This API signature it is experimental and might suffer some changes in the future. The function computes the projection matrix given the center and angles per axis. Args: center: center of the rotation (x,y,z) in the source with shape :math:`(B, 3)`. angles: axis angle vector containing the rotation angles in degrees in the form of (rx, ry, rz) with shape :math:`(B, 3)`. Internally it calls Rodrigues to compute the rotation matrix from axis-angle. scales: scale factor for x-y-z-directions with shape :math:`(B, 3)`. Returns: the projection matrix of 3D rotation with shape :math:`(B, 3, 4)`. .. note:: This function is often used in conjunction with :func:`warp_affine3d`. rHrorArfrr?F) shared_memory.N).N)rNrOrrGrUrrr unsqueezerTclonerr(rQ zeros_liker) rrraxis_angle_radrscaling_matrixfrom_origin_mat to_origin_matproj_matrcrcrdr s*      r dstc Cs t|tstdt|t|tstdt||jdddks-td|j|j|jks;td|j|jd|jdksQtd|jd |j|j|jkr]|j|jksrtd |jd |jd |jd |jd g}dD]A}| t |dd|f|dd|fd| t |dd|f|dd|fd| t |dd|f|dd|fdqvt |d}t |dddddf|dddddf|dddddf|dddddf|dddddf|dddddf|dddddf|dddddf|dddddf|dddddf|dddddf|dddddf|dddddf|dddddf|dddddfgd}t ||}|jd}t j|d|j|jd}|d|dddf<|dd|dd d S)!a Calculate a 3d perspective transform from four pairs of the corresponding points. The function calculates the matrix of a perspective transform so that: .. math:: \begin{bmatrix} t_{i}x_{i}^{'} \\ t_{i}y_{i}^{'} \\ t_{i}z_{i}^{'} \\ t_{i} \\ \end{bmatrix} = \textbf{map_matrix} \cdot \begin{bmatrix} x_{i} \\ y_{i} \\ z_{i} \\ 1 \\ \end{bmatrix} where .. math:: dst(i) = (x_{i}^{'},y_{i}^{'},z_{i}^{'}), src(i) = (x_{i}, y_{i}, z_{i}), i = 0,1,2,5,7 Concrete math is as below: .. math:: \[ u_i =\frac{c_{00} * x_i + c_{01} * y_i + c_{02} * z_i + c_{03}} {c_{30} * x_i + c_{31} * y_i + c_{32} * z_i + c_{33}} \] \[ v_i =\frac{c_{10} * x_i + c_{11} * y_i + c_{12} * z_i + c_{13}} {c_{30} * x_i + c_{31} * y_i + c_{32} * z_i + c_{33}} \] \[ w_i =\frac{c_{20} * x_i + c_{21} * y_i + c_{22} * z_i + c_{23}} {c_{30} * x_i + c_{31} * y_i + c_{32} * z_i + c_{33}} \] .. math:: \begin{pmatrix} x_0 & y_0 & z_0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -x_0*u_0 & -y_0*u_0 & -z_0 * u_0 \\ x_1 & y_1 & z_1 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -x_1*u_1 & -y_1*u_1 & -z_1 * u_1 \\ x_2 & y_2 & z_2 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -x_2*u_2 & -y_2*u_2 & -z_2 * u_2 \\ x_5 & y_5 & z_5 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -x_5*u_5 & -y_5*u_5 & -z_5 * u_5 \\ x_7 & y_7 & z_7 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -x_7*u_7 & -y_7*u_7 & -z_7 * u_7 \\ 0 & 0 & 0 & 0 & x_0 & y_0 & z_0 & 1 & 0 & 0 & 0 & 0 & -x_0*v_0 & -y_0*v_0 & -z_0 * v_0 \\ 0 & 0 & 0 & 0 & x_1 & y_1 & z_1 & 1 & 0 & 0 & 0 & 0 & -x_1*v_1 & -y_1*v_1 & -z_1 * v_1 \\ 0 & 0 & 0 & 0 & x_2 & y_2 & z_2 & 1 & 0 & 0 & 0 & 0 & -x_2*v_2 & -y_2*v_2 & -z_2 * v_2 \\ 0 & 0 & 0 & 0 & x_5 & y_5 & z_5 & 1 & 0 & 0 & 0 & 0 & -x_5*v_5 & -y_5*v_5 & -z_5 * v_5 \\ 0 & 0 & 0 & 0 & x_7 & y_7 & z_7 & 1 & 0 & 0 & 0 & 0 & -x_7*v_7 & -y_7*v_7 & -z_7 * v_7 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & x_0 & y_0 & z_0 & 1 & -x_0*w_0 & -y_0*w_0 & -z_0 * w_0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & x_1 & y_1 & z_1 & 1 & -x_1*w_1 & -y_1*w_1 & -z_1 * w_1 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & x_2 & y_2 & z_2 & 1 & -x_2*w_2 & -y_2*w_2 & -z_2 * w_2 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & x_5 & y_5 & z_5 & 1 & -x_5*w_5 & -y_5*w_5 & -z_5 * w_5 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & x_7 & y_7 & z_7 & 1 & -x_7*w_7 & -y_7*w_7 & -z_7 * w_7 \\ \end{pmatrix} Args: src: coordinates of quadrangle vertices in the source image with shape :math:`(B, 8, 3)`. dst: coordinates of the corresponding quadrangle vertices in the destination image with shape :math:`(B, 8, 3)`. Returns: the perspective transformation with shape :math:`(B, 4, 4)`. .. note:: This function is often used in conjunction with :func:`warp_perspective3d`. z Input type is not a Tensor. Got rBN)r{rAz#Inputs must be a Bx8x3 tensor. Got z%Inputs must have the same shape. Got rz3Inputs must have same batch size dimension. Expect z but got z5Expect `src` and `dst` to be in the same device (Got rz) with the same dtype (Got z).)rrfrHrrrrrfrHrArrr{r|r~.rror?)rKrrLrMrOrPrGrUrappend_build_perspective_param3drrrQrrrq) r1rprrrrrrr2rcrcrdrsb F  **,   rrqaxiscCst|dddf}t|dddf}|dkrt|ddddf|ddddf|ddddf||||||||||ddddf |ddddf|ddddf |ddddf|ddddf |ddddfgdS|dkrt|||||ddddf|ddddf|ddddf||||||ddddf |ddddf|ddddf |ddddf|ddddf |ddddfgdS|dkrRt|||||||||ddddf|ddddf|ddddf||ddddf |ddddf|ddddf |ddddf|ddddf |ddddfgdStd |d ) N.rrfrrHrArrzperspective params for axis `z` is not implemented.)rQrrrNotImplementedError)rrrrr rcrcrdrns~(((((( (((r border_modec Cst|tstdt|t|tstdt|t|jdks+td|jt|jdksC|jdddksCtd |j|jd d\}}}t|||||f||||S) aApply 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 conjunction with :func:`get_perspective_transform3d`. r=r>rz*Input src must be a BxCxDxHxW tensor. Got rArBN)r?r?z$Input M must be a Bx4x4 tensor. Got )rKrrLrMrNrOrP_transform_warp_impl3d) r1r2r3rrr8dhwrcrcrdr/s $  r/ patch_srcnormalized_homographyc Csz|j|jkstd|jd|jd|r3|\}} t|| ||j|jd} t| |} tj|| |||dSt|||d|ddS)aWarp image patches or tensors by normalized 2D homographies. See :class:`~kornia.geometry.warp.HomographyWarper` for details. Args: patch_src: The image or tensor to warp. Should be from source of shape :math:`(N, C, H, W)`. src_homo_dst: The homography or stack of homographies from destination to source of shape :math:`(N, 3, 3)`. dsize: if homography normalized: The height and width of the image to warp. if homography not normalized: size of the output image (height, width). mode: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``. padding_mode: padding mode for outside grid values ``'zeros'`` | ``'border'`` | ``'reflection'``. align_corners: interpolation flag. normalized_coordinates: Whether the homography assumes [-1, 1] normalized coordinates or not. normalized_homography: show is homography normalized. Return: Patch sampled at locations from source to destination. Example: >>> input = torch.rand(1, 3, 32, 32) >>> homography = torch.eye(3).view(1, 3, 3) >>> output = homography_warp(input, homography, (32, 32)) Example: >>> img = torch.rand(1, 4, 5, 6) >>> H = torch.eye(3)[None] >>> out = homography_warp(img, H, (4, 2), align_corners=True, normalized_homography=False) >>> print(out.shape) torch.Size([1, 4, 4, 2]) CPatch and homography must be on the same device. Got patch.device:  src_H_dst.device: .)rFrGrUrr0T)rGrLrrUr,rXrYr.) rrnr3r5r7r8rFrrsrtrb warped_gridrcrcrdr%s *   r%dst_pix_trans_src_pix dsize_src dsize_dst grid_modec Cs,t|||}tj|}t||||||dS)zHCompute the transform in normalized coordinates and perform the warping.T)rrQlinalginvr&) r1rrrrr7r8r`rarcrcrdr(s rc Csb|j|jkstd|jd|jd|\}}} t||| ||jd} t| |} tj|| |||dS)aWarp image patches or tensors by normalized 3D homographies. Args: patch_src: The image or tensor to warp. Should be from source of shape :math:`(N, C, D, H, W)`. src_homo_dst: The homography or stack of homographies from destination to source of shape :math:`(N, 4, 4)`. dsize: The height and width of the image to warp. mode: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``. padding_mode: padding mode for outside grid values ``'zeros'`` | ``'border'`` | ``'reflection'``. align_corners: interpolation flag. normalized_coordinates: Whether the homography assumes [-1, 1] normalized coordinates or not. Return: Patch sampled at locations from source to destination. Example: >>> input = torch.rand(1, 3, 32, 32) >>> homography = torch.eye(3).view(1, 3, 3) >>> output = homography_warp(input, homography, (32, 32)) rrrrEr)rGrLrr-rXrY) rrnr3r5r7r8rFrvrsrtrbrrcrcrdr&8s     r&)r0r TN)r1rr2rr3r4r5r6r7r6r8r9r:r;r<r) r1rrbrr5r6r8r9r:rr<r)rbrrnrr<r)rwrrxrr<r)rrrrrrr<r)r0r NF)rrrrrrr5r6r7r6r8rrFr9r<r)rrr<r)NN)rrrrrrrrrr;rr;r<r)rrr<r)rrrr;rr;r<r)NNNNNN)rrrrrrrrrr;rr;rr;rr;rr;rr;r<r)rrrr;rr;rr;rr;rr;rr;r<r)rrrrrrrrrrrrr<r)r0r T)r1rr2rr3rrr6r7r6r8r9r<r)rrrrr<r)rrrrrrr<r)r1rrrr<r)rrrrrr6r<r)r0r F)r1rr2rr3rrr6rr6r8r9r<r)r0r FTT)rrrnrr3r4r5r6r7r6r8r9rFr9rr9r<r)r1rrrrrrrrr6r7r6r8r9r<r)r0r FT)rrrnrr3rr5r6r7r6r8r9rFr9r<r)@ __future__rtypingrrQtorch.nn.functionalnn functionalrX kornia.corerrrrrr r r kornia.core.checkr r kornia.geometry.conversionsrrrrrrrrkornia.geometry.linalgr kornia.utilsrrrkornia.utils.helpersrr__all__r.r*rWr,r-rr!r)r'rr$r"rr#rr+r(r rrr/r%rr&rcrcrcrds  ((  Z N   V_ F* & 8 1 ` 7  7 M 9 <