a d^ @s*ddlmZmZmZddlZddlmmZddlm Z ddl m Z m Z ddl mZmZmZmZmZmZmZmZddlmZddlmZmZddlmZmZmZdd lm Z m!Z!gd Z"d d d e#dfej ej ee$e$fe%e%e&ej ej dddZ'd d d e#dfej ej ee$e$fe%e%e&ej ej dddZ(ej ej e%e&ej ej dddZ)ej ej ej dddZ*ej ej ej dddZ+e e e dddZ,ej ej ej ej dd d!Z-dRe e e e%e%ee&e&e d#d$d%Z.ej ej d&d'd(Z/dSej ej ej ej eej eej ej d)d*d+Z0dTej eej eej d,d-d.Z1dUej ej ej ej eej eej eej eej eej eej ej d/ d0d1Z2dVej eej eej eej eej eej eej d2d3d4Z3d5d6Z4dWej ej ee$e$e$fe%e%e&ej d7d8d9Z5ej ej ej d:d;d<Z6ej ej ej ej d=d>d?Z7ej ej ej d@dAdBZ8ej ej e%ej dCdDdEZ9dXej ej ee$e$e$fe%e%e&ej dFdGdHZ:dYej ej ee$e$fe%e%e&e&e&ej dI dJdKZ;ej ej ee$e$e$fee$e$e$fe%e%e&ej dLdMdNZ>> 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 torch.Tensor. Got (Input M type is not a torch.Tensor. Got (Input src must be a BxCxHxW tensor. Got r-Nr-r-z$Input M must be a Bx3x3 tensor. Got fill2Padding_tensor only supported for 3 channels. Got Tnormalized_coordinatesdevicer3r1r4r3r1r2) isinstancetorchr TypeErrortypelenshape ValueErrorSizesizer rrr@todtyperepeatr_fill_and_warpFr)r.r/r0r1r2r3r4B_HWZh_outZw_outdst_norm_trans_src_normsrc_norm_trans_dst_normgridrYj/var/www/html/stable-diffusion-webui/venv/lib/python3.9/site-packages/kornia/geometry/transform/imgwarp.pyr.s(0   $ rcCsJt|tjstdt|t|tjs`__. 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]) r6r7r8r9r-r:Nr-z$Input M must be a Bx2x3 tensor. Got r<r=r\rrAr3rBrC)rDrErrFrGrHrIrJrKrLr r rrQ affine_gridrPr)r.r/r0r1r2r3r4rRCrTrUZM_3x3rVrWrXrYrYrZrs$/   6 r)r.rXr1r3r4r5cCs\t|}||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)`. NrAr,rC)rE ones_likerMrQr)r.rXr1r3r4Z ones_maskZ inv_ones_maskZinv_color_maskrYrYrZrPs  rP)rX src_homo_dstr5cCsh|d}|\}}}}||ddd}t|jdkrH||ddd}t|||}||||dS)aCompute the grid to warp the coordinates grid by the homography/ies. Args: grid: Unwrapped grid of the shape :math:`(1, N, 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)`. rr-rAr\rLexpandrHrIviewrrM)rXra batch_sizerSheightwidthflowrYrYrZr's r'cCsn|d}|\}}}}}||dddd}t|jdkrL||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)`. rrbr-rAr8rc)rXrarfrSdepthrgrhrirYrYrZr(s r() points_src points_dstr5c Cst|gdt|gdt|j|jkdt|j|jkd|jd}tj|dd|j|jd}tj||j|jd}tj||j|jd}t dD]}|d|df|d|d f}}|d|df|d|d f} } t ||||||| | | | gd |d d d |f<t ||||||| | | | gd |d d d |d f<q| 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) )rR42z4Source data shape must match Destination data shape.z2Source data type must match Destination data type.rr@rNr8.rArbNr\ .r.rbr-)rrrIrNrEemptyr@r,onesrangerrerfill_)rkrlrRAr,ruix1y1Zx2y2bXr/rYrYrZrs&-  6< r)centeranglescaler5c Csbt|tjstdt|t|tjs>> center = torch.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 torch.Tensor. Got z,Input angle type is not a torch.Tensor. Got z,Input scale type is not a torch.Tensor. Got r\rAz'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 rzPInputs must have same batch size dimension. Got center {}, angle {} and scale {}zSInputs must have same device Got center ({}, {}), angle ({}, {}) and scale ({}, {})r-N) rDrErrFrGrHrIrJformatr@rNrr )rrrZshift_mZ shift_m_invZscale_mZrotat_mZaffine_mrYrYrZrtsF+   * B   && rF)imagemap_xmap_yr1r2r3r?r5c Csxt|gdt|gdt|gd|j\}}} } t||gd} |sVt| | | } | |ddd} t|| |||dS)a0Apply 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`. )rRr_rTrU)rRrTrUrbr1r2r3)rrIrrrdr) rrrr1r2r3r?rfrSrgrhZmap_xyrYrYrZrs1 r)matrixr5cCstt|tjstdt|t|jdkr>|jdddksNtd|jt|}t |}|dddddfS) ukInvert an affine transformation. The function computes an inverse affine transformation represented by 2×3 matrix: .. math:: \begin{bmatrix} a_{11} & a_{12} & b_{1} \\ a_{21} & a_{22} & b_{2} \\ \end{bmatrix} The result is also a 2×3 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 torch.Tensor. Got r-r:Nr[z)Input matrix must be a Bx2x3 tensor. Got .r\) rDrErrFrGrHrIrJr r)rZ matrix_tmpZ matrix_invrYrYrZrs  r) translationsrrrsxsyr5c CsTt|| |}|d|7<t|}tdd||fDrPt|||}||}|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`. ).r\css|]}|duVqdSNrY.0srYrYrZ Wz&get_affine_matrix2d..)rr anyr ) rrrrrr transform transform_h shear_matrYrYrZr9s r)rrrc Cs|dur tdg|dn|}|durDtdg|dn|}tj|ddd\}}|d|d}}t|}t|}t|}tj|| ||| |||||||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 degree along x axis. sy: shearing degree along y axis. 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`. NrrArbZdimr\r-) rEtensorrOrLsplitretanr`rr ) rrrxyZsx_tanZsy_tanrurrYrYrZr ^s!$$   ,r ) rrranglessxysxzsyxsyzszxszyr5c Csdt|| |} | d|7<t| } tdd|||||| fDr`t||||||| } | | } | 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)`. angle: angle axis 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`. ).r-css|]}|duVqdSrrYrrYrYrZrrz&get_affine_matrix3d..)r#r rr!) rrrrrrrrrrrrrrYrYrZrs"r)rrrrrrrc Cs@|dur tdg|dn|}|durDtdg|dn|}|durhtdg|dn|}|durtdg|dn|}|durtdg|dn|}|durtdg|dn|}tj|ddd\}}} |d|d| d}}} t|} t|} t|} t|} t|}t|}t| | | | ||\ }}}}}}}}}|||| }|||||| |}|||||| | }| | | | | | f\} } } } }}t| | | | ||\ }}}}}}}}}tj||||||||||||g ddddd}t |}|S) a Compose 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 degree along x axis, towards y plane. sxz: shearing degree along x axis, towards z plane. syx: shearing degree along y axis, towards x plane. syz: shearing degree along y axis, towards z plane. szx: shearing degree along z axis, towards x plane. szy: shearing degree along z axis, towards y plane. 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`. NrrrArbrr-r8) rErrOrLrrer_compute_shear_matrix_3drr )rrrrrrrrrzsxy_tansxz_tansyx_tansyz_tanszx_tanszy_tanm00m10m20m01m11m21m02m12m22Zm03Zm13Zm23rrYrYrZr!s68$$$$$$"       ( 0r!c Cst|}|||}}} |||||||} } } |||} |||| }|||| |}||| | | | | ||f Sr)rEr`)rrrrrrrurrrrrrrrrrYrYrZrs   r)r.r/r0flagsr2r3r5cCst|jdkrt|jt|jdkr8|jdddksBt|jt|dkrVt||\}}}} } || | f} |} t|} t| | | }t|}|ddddf}||gt| }tj j j |||d}tj j j |||||dS)aHApply 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). 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. Returns: torch.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`. r-r:N)r-r8r]rC) rHrIAssertionErrorrLr rrlistrEnn functionalr^r)r.r/r0rr2r3rRr_DrTrUZsize_srcZsize_outZM_4x4rVrWZP_normZ dsize_outrXrYrYrZr"'s$       r")rmattvecr5cCsft|jdkr |jdddks*t|jt|jdkrJ|jdddksTt|jtj||gddS)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)`. r\r:Nr;)r-rArbr)rHrIrrEcat)rrrYrYrZr$_s     r$)rrscalesr5c CsDt|jdkr|jddks&t|jt|jdkrB|jddksLt|j|j|jkrft|j|j|j|jkrt|j|jt|}t|}td|}||jdd}|| |}t dd |jddd |}|d dddf|7<|}t|}t|t |d }t|}|||}|d ddddfS) aKCalculate 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: angle axis 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`. r\rbr-rArr8Nr.).N)rHrIrr@rNr rrZ unsqueezerMrEZeyerOZtype_asclonerr$ zeros_liker ) rrrZangle_axis_radrZscaling_matrixZfrom_origin_matZ to_origin_matZproj_matrYrYrZr#vs*     $ r#)r.dstr5c Cst|tjstdt|t|tjs>> 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]) tPatch and homography must be on the same device. Got patch.device: {} src_H_dst.device: {}.)r?r@rNrr+T) r@rFrrrNr'rQrr) rrar0r1r2r3r?rrgrhrX warped_gridrYrYrZr)s )   r))r.dst_pix_trans_src_pix dsize_src dsize_dst grid_moder2r3r5c Cs*t|||}t|}t||||||dS)zHCompute the transform in normalized coordinates and perform the warping.T)rrEZinverser*) r.rrrrr2r3rVrWrYrYrZrs  r)rrar0r1r2r3r?r5c Cs\|j|jks td|j|j|\}}} 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)) rr>r)r@rFrrr(rQr) rrar0r1r2r3r?rjrgrhrXrrYrYrZr*s    r*)r+r,NF)NN)NN)NNNNNN)NNNNNN)r+r,T)r+r,F)r+r,FTT)r+r,FT)>typingrrrrEZtorch.nn.functionalrrrQrZ kornia.corerrZkornia.geometry.conversionsrr r r r r rrZkornia.geometry.linalgrZkornia.testingrrZ kornia.utilsrrrZkornia.utils.helpersrr__all__r,intstrboolrrrPr'r(rrrrrr rr!rr"r$r#r%rr&r)rr*rYrYrYrZs^ (   X  Q U` E) %"7 0 ^  86M  8  >