a d @s&ddlmZmZmZddlZddlmZddlmZddl m Z ddl m Z ddl mZmZmZmZmZgdZejejd d d Zejejd d d ZejejejdddZejejejejejdddZejejdddZejejejdddZejejdddZdMejejeeeejd d!d"ZdNejejeeeejd d$d%ZdOejejedejfeeeejd&d'd(Z dPejejejejedejfeeeejd) d*d+Z!dQejejeeeejd,d-d.Z"dRejejedejfeeeejd/d0d1Z#dSejejeeeejd2d3d4Z$dTe%e&eee%e%fd6d7d8Z'e dUejee%ee%e%ffeeeeeejd9d:d;Z(dVejee&ee&e&ffeeeeejd<d=d>Z)Gd?d@d@ej*Z+GdAdBdBej*Z,GdCdDdDej*Z-GdEdFdFej*Z.GdGdHdHej*Z/GdIdJdJej*Z0GdKdLdLej*Z1dS)W)OptionalTupleUnionN)gaussian_blur2d)_extract_device_dtype)perform_keep_shape_image)get_affine_matrix2dget_projective_transformget_rotation_matrix2d warp_affine warp_affine3d)affineaffine3dscalerotaterotate3d translateshearresizerescaleScaleRotate TranslateShearResizeRescaleAffine)tensorreturncCs|dt|jkrdks.ntd|jd|jdd\}}t|dd}t|dd}tj||g|j|jd}|S) zJCompute the center of tensor plane for (H, W), (C, H, W) and (B, C, H, W).z-Must be a 3D tensor as HW, CHW and BCHW. Got .NrdevicedtypelenshapeAssertionErrorfloattorchrr%r&)rheightwidthcenter_xcenter_ycenterr2j/var/www/html/stable-diffusion-webui/venv/lib/python3.9/site-packages/kornia/geometry/transform/affwarp.py_compute_tensor_center"sr4cCsdt|jkrdks.ntd|jd|jdd\}}}t|dd}t|dd}t|dd}tj|||g|j|jd }|S) zSCompute the center of tensor plane for (D, H, W), (C, D, H, W) and (B, C, D, H, W).z0Must be a 3D tensor as DHW, CDHW and BCDHW. Got r"Nrr r$r')rdepthr-r.r/r0Zcenter_zr1r2r2r3_compute_tensor_center3d-sr9)angler1rcCst|}t|||}|S)&Compute a pure affine rotation matrix.)r, ones_liker )r:r1rmatrixr2r2r3_compute_rotation_matrix9s  r>)yawpitchrollr1rcCs4t|jt|jkr0t|jkr0dkrXnn$|jdd}|jdd}|jdd}t|jt|jkrt|jkrdkrnn$|jdd}|jdd}|jdd}t|jt|jkrt|jkrdksntd|jd|jd|jdtj|||gdd}t|}t|||}|S)r;rdimrr z,Expected yaw, pitch, roll to be (B, 1). Got z, r")r(r) unsqueezer*r,catr<r )r?r@rAr1ZanglesZscalesr=r2r2r3_compute_rotation_matrix3d@s4   4   4"  rF) translationrcCsttjd|j|jd}||jddd}tj|ddd\}}|ddddf|7<|ddddf|7<|S) z&Compute affine matrix for translation.r5r$rrr chunksrC.r,Zeyer%r&repeatr)chunk)rGr=ZdxZdyr2r2r3_compute_translation_matrixWs rN)rr1rcCs.tj|jdd|j|jd}t|||}|S)z"Compute affine matrix for scaling.Nrr$)r,zerosr)r%r&r )rr1r:r=r2r2r3_compute_scaling_matrixbs rP)rrcCsttjd|j|jd}||jddd}tj|ddd\}}|ddddf|7<|ddddf|7<|S) z#Compute affine matrix for shearing.r5r$rrr rHrI.rK)rr=Zshxshyr2r2r3_compute_shear_matrixis rRbilinearrOT)rr=mode padding_mode align_cornersrc Csr|dk}|rtj|dd}||jddd}|jd}|jd}t||||f|||}|rntj|dd}|S)a%Apply an affine transformation to the image. .. image:: _static/img/warp_affine.png Args: tensor: The image tensor to be warped in shapes of :math:`(H, W)`, :math:`(D, H, W)` and :math:`(B, C, H, W)`. matrix: The 2x3 affine transformation matrix. mode: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``. padding_mode: padding mode for outside grid values ``'zeros'`` | ``'border'`` | ``'reflection'``. align_corners: interpolation flag. Returns: The warped image with the same shape as the input. Example: >>> img = torch.rand(1, 2, 3, 5) >>> aff = torch.eye(2, 3)[None] >>> out = affine(img, aff) >>> print(out.shape) torch.Size([1, 2, 3, 5]) r5rrBrHr#) ndimensionr,rDexpandr)r squeeze) rr=rTrUrV is_unbatchedr-r.warpedr2r2r3rxs   rFc Cs~|dk}|rtj|dd}||jddd}|jd}|jd}|jd}t|||||f|||} |rztj| dd} | S)aApply an affine transformation to the 3d volume. Args: tensor: The image tensor to be warped in shapes of :math:`(D, H, W)`, :math:`(C, D, H, W)` and :math:`(B, C, D, H, W)`. matrix: The affine transformation matrix with shape :math:`(B, 3, 4)`. mode: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``. padding_mode: padding mode for outside grid values `` 'zeros'`` | ``'border'`` | ``'reflection'``. align_corners: interpolation flag. Returns: The warped image. Example: >>> img = torch.rand(1, 2, 4, 3, 5) >>> aff = torch.eye(3, 4)[None] >>> out = affine3d(img, aff) >>> print(out.shape) torch.Size([1, 2, 4, 3, 5]) r!rrBrHr7r#)rWr,rDrXr)r rY) rr=rTrUrVrZr8r-r.r[r2r2r3rs    r)rr:r1rTrUrVrcCst|tjstdt|t|tjs`__. Example: >>> img = torch.rand(1, 3, 4, 4) >>> angle = torch.tensor([90.]) >>> out = rotate(img, angle) >>> print(out.shape) torch.Size([1, 3, 4, 4]) -Input tensor type is not a torch.Tensor. Got z,Input angle type is not a torch.Tensor. Got N-Input center type is not a torch.Tensor. Got r5r!9Invalid tensor shape, we expect CxHxW or BxCxHxW. Got: {}rrH.r r5) isinstancer,Tensor TypeErrortyper(r) ValueErrorformatr4rXr>r)rr:r1rTrUrVrotation_matrixr2r2r3rs'   r) rr?r@rAr1rTrUrVrc Cs>t|tjstdt|t|tjs>> img = torch.rand(1, 3, 4, 4) >>> translation = torch.tensor([[1., 0.]]) >>> out = translate(img, translation) >>> print(out.shape) torch.Size([1, 3, 4, 4]) r\z2Input translation type is not a torch.Tensor. Got r^r_.Nr r5) r`r,rarbrcr(r)rdrerNr)rrGrTrUrVZtranslation_matrixr2r2r3res  r)r scale_factorr1rTrUrVrcCst|tjstdt|t|tjs>> img = torch.rand(1, 3, 4, 4) >>> scale_factor = torch.tensor([[2., 2.]]) >>> out = scale(img, scale_factor) >>> print(out.shape) torch.Size([1, 3, 4, 4]) r\z3Input scale_factor type is not a torch.Tensor. Got rr NrrH.r5) r`r,rarbrcr(r)rLr4rXrPr)rrgr1rTrUrVZscaling_matrixr2r2r3rs%    r)rrrTrUrVrcCst|tjstdt|t|tjs>> img = torch.rand(1, 3, 4, 4) >>> shear_factor = torch.tensor([[0.5, 0.0]]) >>> out = shear(img, shear_factor) >>> print(out.shape) torch.Size([1, 3, 4, 4]) r\z,Input shear type is not a torch.Tensor. Got r^r_.Nr r5) r`r,rarbrcr(r)rdrerRr)rrrTrUrVZ shear_matrixr2r2r3rs  rshort) side_size aspect_ratiosidercCsx|dvrtd|d|dkr0|t||fS|dkrHt|||fS|dk|dkArh|t||fSt|||fS)N)rhlongverthorzz=side can be one of 'short', 'long', 'vert', and 'horz'. Got ''rmrnrh?)rdint)rirjrkr2r2r3_side_to_image_sizesrr)inputsize interpolationrVrk antialiasrcCsxt|tjstdt|t|jdkr@tdt|j|jdd}\}}t|trt||} t || |}||kr|S||d||df} |ot | dk}|r^t | ddd d t | ddd d f} tt d | dd tt d | dd f} | dddkr,| dd| df} | dddkrR| d| ddf} t || | }tj j j||||d } | S)aResize the input torch.Tensor to the given size. .. image:: _static/img/resize.png Args: tensor: The image tensor to be skewed with shape of :math:`(..., H, W)`. `...` means there can be any number of dimensions. size: Desired output size. If size is a sequence like (h, w), output size will be matched to this. If size is an int, smaller edge of the image will be matched to this number. i.e, if height > width, then image will be rescaled to (size * height / width, size) interpolation: algorithm used for upsampling: ``'nearest'`` | ``'linear'`` | ``'bilinear'`` | 'bicubic' | 'trilinear' | 'area'. align_corners: interpolation flag. side: Corresponding side if ``size`` is an integer. Can be one of ``'short'``, ``'long'``, ``'vert'``, or ``'horz'``. antialias: if True, then image will be filtered with Gaussian before downscaling. No effect for upscaling. Returns: The resized tensor with the shape as the specified size. Example: >>> img = torch.rand(1, 3, 4, 4) >>> out = resize(img, (6, 8)) >>> print(out.shape) torch.Size([1, 3, 6, 8]) r\r z4Input tensor must have at least two dimensions. Got r#Nrrrpg@gMbP?g@r5)rtrTrV)r`r,rarbrcr(r)rdrqrrmaxrnnZ functionalZ interpolate)rsrtrurVrkrvZ input_sizehwrjZfactorsZsigmasksoutputr2r2r3rs,%   ,, r)rsfactorrurVrvrc CsZt|tr|}}n|\}}|dd\}}t||t||f} t|| |||dS)aRescale the input torch.Tensor with the given factor. .. image:: _static/img/rescale.png Args: input: The image tensor to be scale with shape of :math:`(B, C, H, W)`. factor: Desired scaling factor in each direction. If scalar, the value is used for both the x- and y-direction. interpolation: algorithm used for upsampling: ``'nearest'`` | ``'linear'`` | ``'bilinear'`` | ``'bicubic'`` | ``'trilinear'`` | ``'area'``. align_corners: interpolation flag. side: Corresponding side if ``size`` is an integer. Can be one of ``'short'``, ``'long'``, ``'vert'``, or ``'horz'``. antialias: if True, then image will be filtered with Gaussian before downscaling. No effect for upscaling. Returns: The rescaled tensor with the shape as the specified size. Example: >>> img = torch.rand(1, 3, 4, 4) >>> out = rescale(img, (2, 3)) >>> print(out.shape) torch.Size([1, 3, 8, 12]) r#N)rurVrv)r`r+rtrqr) rsr}rurVrvZ factor_vertZ factor_horzr-r.rtr2r2r3r]s  rcsZeZdZdZd eeeeeffeee ee ddfdd Z e j e j d d d Z ZS) ra Resize the input torch.Tensor to the given size. Args: size: Desired output size. If size is a sequence like (h, w), output size will be matched to this. If size is an int, smaller edge of the image will be matched to this number. i.e, if height > width, then image will be rescaled to (size * height / width, size) interpolation: algorithm used for upsampling: ``'nearest'`` | ``'linear'`` | ``'bilinear'`` | 'bicubic' | 'trilinear' | 'area'. align_corners: interpolation flag. side: Corresponding side if ``size`` is an integer. Can be one of ``'short'``, ``'long'``, ``'vert'``, or ``'horz'``. antialias: if True, then image will be filtered with Gaussian before downscaling. No effect for upscaling. Returns: The resized tensor with the shape of the given size. Example: >>> img = torch.rand(1, 3, 4, 4) >>> out = Resize((6, 8))(img) >>> print(out.shape) torch.Size([1, 3, 6, 8]) rSNrhF)rtrurVrkrvrcs,t||_||_||_||_||_dSN)super__init__rtrurVrkrv)selfrtrurVrkrv __class__r2r3rs  zResize.__init__rsrcCst||j|j|j|j|jdS)N)rVrkrv)rrtrurVrkrvrrsr2r2r3forwardszResize.forward)rSNrhF)__name__ __module__ __qualname____doc__rrqrstrrboolrr,rar __classcell__r2r2rr3rsrc sjeZdZdZd eejeejeejeejeejeeedd fdd Z ejejd d d Z Z S) ra`Apply multiple elementary affine transforms simultaneously. Args: angle: Angle in degrees for counter-clockwise rotation around the center. The tensor must have a shape of (B), where B is the batch size. translation: Amount of pixels for translation in x- and y-direction. The tensor must have a shape of (B, 2), where B is the batch size and the last dimension contains dx and dy. scale_factor: Factor for scaling. The tensor must have a shape of (B), where B is the batch size. shear: Angles in degrees for shearing in x- and y-direction around the center. The tensor must have a shape of (B, 2), where B is the batch size and the last dimension contains sx and sy. center: Transformation center in pixels. The tensor must have a shape of (B, 2), where B is the batch size and the last dimension contains cx and cy. Defaults to the center of image to be transformed. mode: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``. padding_mode: padding mode for outside grid values ``'zeros'`` | ``'border'`` | ``'reflection'``. align_corners: interpolation flag. Raises: RuntimeError: If not one of ``angle``, ``translation``, ``scale_factor``, or ``shear`` is set. Returns: The transformed tensor with same shape as input. Example: >>> img = torch.rand(1, 2, 3, 5) >>> angle = 90. * torch.rand(1) >>> out = Affine(angle)(img) >>> print(out.shape) torch.Size([1, 2, 3, 5]) NrSrOT) r:rGrgrr1rTrUrVrc sdd||||fD} | s&d} t| | dtfdd| ddDsZtd| |_tt|||g\} } |durtj| | d }||_|durtjd | | d }||_ |durtj d | | d }||_ ||_ ||_ ||_||_||_dS) NcSs g|]}|dur|dqS)Nr)rt).0argr2r2r3 z#Affine.__init__..zzAffine was created without any affine parameter. At least one of angle, translation, scale_factor, or shear has to be set.rc3s|]}|kVqdSr~r2)rotherZ batch_sizer2r3 rz"Affine.__init__..rz3The batch sizes of the affine parameters mismatch: r$r ) RuntimeErrorallZ _batch_sizerrrr,rOr:rGZonesrgrr1rTrUrV) rr:rGrgrr1rTrUrVZ batch_sizesmsgr%r&rrr3rs2  zAffine.__init__rcCs|jdurd}}n|jd|jd}}|jdurNt||dd}n|j}t|j||j|j ||d}t ||dddddf|j |j |j S) N).r).rrrH)sxsy.r r5) rr1r4rXrtr rGrgr:rrTrUrV)rrsrrr1r=r2r2r3r s   zAffine.forward)NNNNNrSrOT) rrrrrr,rarrrrrr2r2rr3rs*$.rcsTeZdZdZd eeeeeffeeeddfdd Z e j e j d d d Z Z S) raRescale the input torch.Tensor with the given factor. Args: factor: Desired scaling factor in each direction. If scalar, the value is used for both the x- and y-direction. interpolation: algorithm used for upsampling: ``'nearest'`` | ``'linear'`` | ``'bilinear'`` | ``'bicubic'`` | ``'trilinear'`` | ``'area'``. align_corners: interpolation flag. side: Corresponding side if ``size`` is an integer. Can be one of ``'short'``, ``'long'``, ``'vert'``, or ``'horz'``. antialias: if True, then image will be filtered with Gaussian before downscaling. No effect for upscaling. Returns: The rescaled tensor with the shape according to the given factor. Example: >>> img = torch.rand(1, 3, 4, 4) >>> out = Rescale((2, 3))(img) >>> print(out.shape) torch.Size([1, 3, 8, 12]) rSTFN)r}rurVrvrcs&t||_||_||_||_dSr~)rrr}rurVrv)rr}rurVrvrr2r3r3s  zRescale.__init__rcCst||j|j|j|jdS)N)rVrv)rr}rurVrvrr2r2r3r@szRescale.forward)rSTF)rrrrrr+rrrrr,rarrr2r2rr3rs rcsReZdZdZd ejedejfeeeddfdd Z ejejd d d Z Z S) rayRotate the tensor anti-clockwise about the centre. Args: angle: The angle through which to rotate. The tensor must have a shape of (B), where B is batch size. center: The center through which to rotate. The tensor must have a shape of (B, 2), where B is batch size and last dimension contains cx and cy. mode: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``. padding_mode: padding mode for outside grid values ``'zeros'`` | ``'border'`` | ``'reflection'``. align_corners: interpolation flag. Returns: The rotated tensor with the same shape as the input. Example: >>> img = torch.rand(1, 3, 4, 4) >>> angle = torch.tensor([90.]) >>> out = Rotate(angle)(img) >>> print(out.shape) torch.Size([1, 3, 4, 4]) NrSrOT)r:r1rTrUrVrcs,t||_||_||_||_||_dSr~)rrr:r1rTrUrV)rr:r1rTrUrVrr2r3r`s  zRotate.__init__rcCst||j|j|j|j|jSr~)rr:r1rTrUrVrr2r2r3roszRotate.forward)NrSrOT rrrrr,rarrrrrrr2r2rr3rFs rcsFeZdZdZd ejeeeddfdd Zejejd d d Z Z S) ra2Translate the tensor in pixel units. Args: translation: tensor containing the amount of pixels to translate in the x and y direction. The tensor must have a shape of (B, 2), where B is batch size, last dimension contains dx dy. mode: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``. padding_mode: padding mode for outside grid values ``'zeros'`` | ``'border'`` | ``'reflection'``. align_corners: interpolation flag. Returns: The translated tensor with the same shape as the input. Example: >>> img = torch.rand(1, 3, 4, 4) >>> translation = torch.tensor([[1., 0.]]) >>> out = Translate(translation)(img) >>> print(out.shape) torch.Size([1, 3, 4, 4]) rSrOTN)rGrTrUrVrcs&t||_||_||_||_dSr~)rrrGrTrUrV)rrGrTrUrVrr2r3rs  zTranslate.__init__rcCst||j|j|j|jSr~)rrGrTrUrVrr2r2r3rszTranslate.forward)rSrOT rrrrr,rarrrrrr2r2rr3rss  rcsReZdZdZd ejedejfeeeddfdd Z ejejd d d Z Z S) raScale the tensor by a factor. Args: scale_factor: The scale factor apply. The tensor must have a shape of (B) or (B, 2), where B is batch size. If (B), isotropic scaling will perform. If (B, 2), x-y-direction specific scaling will perform. center: The center through which to scale. The tensor must have a shape of (B, 2), where B is batch size and last dimension contains cx and cy. mode: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``. padding_mode: padding mode for outside grid values ``'zeros'`` | ``'border'`` | ``'reflection'``. align_corners: interpolation flag. Returns: The scaled tensor with the same shape as the input. Example: >>> img = torch.rand(1, 3, 4, 4) >>> scale_factor = torch.tensor([[2., 2.]]) >>> out = Scale(scale_factor)(img) >>> print(out.shape) torch.Size([1, 3, 4, 4]) NrSrOT)rgr1rTrUrVrcs,t||_||_||_||_||_dSr~)rrrgr1rTrUrV)rrgr1rTrUrVrr2r3rs  zScale.__init__rcCst||j|j|j|j|jSr~)rrgr1rTrUrVrr2r2r3rsz Scale.forward)NrSrOTrr2r2rr3rs rcsFeZdZdZd ejeeeddfdd Zejejd d d Z Z S) raShear the tensor. Args: shear: tensor containing the angle to shear in the x and y direction. The tensor must have a shape of (B, 2), where B is batch size, last dimension contains shx shy. mode: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``. padding_mode: padding mode for outside grid values ``'zeros'`` | ``'border'`` | ``'reflection'``. align_corners: interpolation flag. Returns: The skewed tensor with the same shape as the input. Example: >>> img = torch.rand(1, 3, 4, 4) >>> shear_factor = torch.tensor([[0.5, 0.0]]) >>> out = Shear(shear_factor)(img) >>> print(out.shape) torch.Size([1, 3, 4, 4]) rSrOTN)rrTrUrVrcs&t||_||_||_||_dSr~)rrrrTrUrV)rrrTrUrVrr2r3rs  zShear.__init__rcCst||j|j|j|jSr~)rrTrUrVrr2r2r3rsz Shear.forward)rSrOTrr2r2rr3rs  r)rSrOT)rSrOF)NrSrOT)NrSrOF)rSrOT)NrSrOT)rSrOF)rh)rSNrhF)rSNF)2typingrrrr,Ztorch.nnrxZkornia.filtersrZ kornia.utilsrZkornia.utils.imagerZimgwarpr r r r r __all__rar4r9r>rFrNrPrRrrrrrrrrrrqr+rrrrModulerrrrrrrr2r2r2r3s          6 :  F  E 3  @ 0 Q *4`+-%/