o oit@sddlZddlmZmZmZddlZddlmZddlm Z m Z m Z m Z ddl mZddlmZddlmZddlmZd d lmZmZmZmZmZgd Zd e d e fddZd e d e fddZde de d e fddZde de de de d e f ddZde d e fddZ de de d e fdd Z!d!e d e fd"d#Z" $ % &dYd e d'e d(e#d)e#d*e$d e f d+d,Z% $ % -dZd e d'e d(e#d)e#d*e$d e f d.d/Z&  $ % &d[d e de dede fd(e#d)e#d*e$d e fd0d1Z'  $ % -d\d e de de de dede fd(e#d)e#d*e$d e fd2d3Z( $ % &dYd e de d(e#d)e#d*e$d e f d4d5Z)  $ % &d[d e d6e dede fd(e#d)e#d*e$d e fd7dZ* $ % -dZd e d!e d(e#d)e#d*e$d e f d8d!Z+d]d:e,d;e-dZ.e $  9 -d^d?e d@ee,ee,e,ffdAe#d*ee$d>> 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]) r<rrIrSr*) ndimensionr3rKexpandr0rsqueeze) r%rDrarbrc is_unbatchedr4r5warpedr9r9r:rs   rFc Cs~|dk}|rtj|dd}||jddd}|jd}|jd}|jd}t|||||f|||} |r=tj| 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(rrIrSr>r*)rdr3rKrer0rrf) r%rDrarbrcrgr?r4r5rhr9r9r:rs    rcCst|tstdt|t|tstdt||dur.t|ts.tdt|t|jdvr=td|j|durEt|}||jd}||jdd}t ||}t ||d dd dd f|||S) aWRotate the tensor anti-clockwise about the center. .. image:: _static/img/rotate.png Args: tensor: The image tensor to be warped in shapes of :math:`(B, C, H, W)`. 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 shape as input. .. note:: See a working example `here `__. 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 Tensor. Got z&Input angle type is not a Tensor. Got N'Input center type is not a Tensor. Got r<r(7Invalid tensor shape, we expect CxHxW or BxCxHxW. Got: rrS.r'r<) isinstancer TypeErrortyper/r0 ValueErrorr;rerEr)r%rBr8rarbrcrotation_matrixr9r9r:r s '  "r c Cs4t|tstdt|t|tstdt|t|ts*tdt|t|ts8tdt||durJt|tsJtdt|t|jdvrYtd|j|durat|}||jd }||jd }||jd }||jd d }t ||||}t ||d dd dd f|||S)aRotate 3D the tensor anti-clockwise about the centre. Args: tensor: The image tensor to be warped in shapes of :math:`(B, C, D, H, W)`. yaw: The yaw angle through which to rotate. The tensor must have a shape of (B), where B is batch size. pitch: The pitch angle through which to rotate. The tensor must have a shape of (B), where B is batch size. roll: The roll 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: Tensor: The rotated tensor with shape as input. rizyaw is not a Tensor. Got zpitch is not a Tensor. Got zroll is not a Tensor. Got Nrj)r(r=z;Invalid tensor shape, we expect CxDxHxW or BxCxDxHxW. Got: rrS.r<r() rmrrnror/r0rprArerOr) r%rFrGrHr8rarbrcrqr9r9r:r!6s( !   "r!cCt|tstdt|t|tstdt|t|jdvr+td|jt|}t||dddddf|||S) aTranslate the tensor in pixel units. .. image:: _static/img/translate.png Args: tensor: The image tensor to be warped in shapes of :math:`(B, C, H, W)`. 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 shape as input. Example: >>> 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]) riz,Input translation type is not a Tensor. Got rkrl.Nr'r<) rmrrnror/r0rprZr)r%rPrarbrctranslation_matrixr9r9r:r$y ! "r$ scale_factorcCst|tstdt|t|tstdt|t|jdkr)|dd}|dur1t|}||jdd}||jdd}t ||}t ||ddddd f|||S) afScale the tensor by a factor. .. image:: _static/img/scale.png Args: tensor: The image tensor to be warped in shapes of :math:`(B, C, H, W)`. 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(img, scale_factor) >>> print(out.shape) torch.Size([1, 3, 4, 4]) riz-Input scale_factor type is not a Tensor. Got rr'NrrS.r<) rmrrnror/r0repeatr;rer\r)r%rur8rarbrcscaling_matrixr9r9r:r"s &   "cCrr) a}Shear the tensor. .. image:: _static/img/shear.png Args: tensor: The image tensor to be skewed with shape of :math:`(B, C, H, W)`. 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 shape same as the input. Example: >>> 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]) riz&Input shear type is not a Tensor. Got rkrl.Nr'r<) rmrrnror/r0rpr_r)r%r#rarbrc shear_matrixr9r9r:r#rtshort side_size aspect_ratiosidecCsx|dvr td|d|dkr|t||fS|dkr$t|||fS|dk|dkAr4|t||fSt|||fS)N)rylongverthorzz=side can be one of 'short', 'long', 'vert', and 'horz'. Got ''r~rry?)rpint)rzr{r|r9r9r:_side_to_image_sizesrinputsize interpolation antialiascCst|tstdt|t|jdkrtdt|j|jdd}\}}t|trEtj r;t j ddd||} t || |}tj sP||krP|S||d ||df} |oct| dk}|rt| d d d d t| dd d d f} ttd | d dttd | ddf} | d dd kr| d d| df} | ddd kr| d | ddf} t|| | }tjjj||||d} | S)aResize the input Tensor to the given size. .. image:: _static/img/resize.png Args: input: 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]) rir'z4Input tensor must have at least two dimensions. Got r*NzPPlease pass the size with a tuple when exporting to ONNX to correct the tracing.r) stacklevelrrg@gMbP?g@r<)rrarc)rmrrnror/r0rprr3onnxis_in_onnx_exportwarningswarnrmaxr nn functional interpolate)rrrrcr|r input_sizehwr{factorssigmasksoutputr9r9r:r%s6 &    ,, rdivisible_factorcCst|trt|jdkr|jd|jd}}t|tr.t|jdkr.|jd|jd}}t|||}t|||}t|||f||||S)aResize the input tensor to be divisible by a certain factor. Args: input (Tensor): Input tensor to be resized. divisible_factor (int): The factor to which the image should be divisible. interpolation (str, optional): Interpolation flag. Defaults to "bilinear". align_corners (Optional[bool], optional): whether to align the corners of the input and output. Defaults to None. side (str, optional): Side to resize. Defaults to "short". antialias (bool, optional): If True, then image will be filtered with Gaussian before downscaling. Defaults to False. Returns: Tensor: The resized tensor. r(r'r<r)rmrr/r0roundr)rrrrcr|rr4r5r9r9r:r{srfactorc CsZt|tr |}}n|\}}|dd\}}t||t||f} t|| |||dS)aRescale the input 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)rrcr)rmr2rrr) rrrrcr factor_vert factor_horzr4r5rr9r9r:rs ! rc sjeZdZdZ    ddeeeeeffdedee d ed e d df fd d Z de d e fddZ Z S)ravResize the input 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]) .. raw:: html r`NryFrrrcr|rr&c,t||_||_||_||_||_dSN)super__init__rrrcr|r)selfrrrcr|r __class__r9r:r  zResize.__init__rcCst||j|j|j|j|jdS)N)rcr|r)rrrrcr|rrrr9r9r:forwardszResize.forwardr`NryF)__name__ __module__ __qualname____doc__rrrstrrboolrrr __classcell__r9r9rr:rs(!rcs~eZdZdZ        ddeedeedeed eed eed ed ed eddffdd ZdedefddZ Z S)raaApply 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]) Nr`r TrBrPrur#r8rarbrcr&c sdd||||fD} | sd} t| | dtfdd| ddDs-td| |_tt|||g\} } |durIt| | d }||_|durXtd | | d }||_|durgt d | | d }||_ ||_ ||_ ||_ ||_||_dS) NcSs g|] }|dur|dqS)Nr)r).0argr9r9r: 0s 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|]}|kVqdSrr9)rother batch_sizer9r: 9sz"Affine.__init__..rz3The batch sizes of the affine parameters mismatch: r+r') RuntimeErrorall _batch_sizerrr r rBrPrrur#r8rarbrc) rrBrPrur#r8rarbrc batch_sizesmsgr,r-rrr:r%s2   zAffine.__init__rcCs|jdur d}}n |jd|jd}}|jdur't||dd}n|j}t|j||j|j ||d}t ||dddddf|j |j |j S) N).r).rrrS)sxsy.r'r<) r#r8r;rerrrPrurBrrarbrc)rrrrr8rDr9r9r:rSs   (zAffine.forward)NNNNNr`r T) rrrrrrrrrrrr9r9rr:rs<%  .rc s`eZdZdZ   ddeeeeeffdededed d f fd d Z d e d e fddZ Z S)raRescale the input 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]) r`TFrrrcrr&Nc&t||_||_||_||_dSr)rrrrrcr)rrrrcrrr9r:r{s  zRescale.__init__rcCst||j|j|j|jdS)N)rcr)rrrrcrrr9r9r:rszRescale.forward)r`TF) rrrrrr2rrrrrrrr9r9rr:rbs" rc ^eZdZdZ    ddededefded ed ed df fd d Zded efddZ Z S)razRotate 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]) Nr`r TrBr8rarbrcr&crr)rrrBr8rarbrc)rrBr8rarbrcrr9r:rrzRotate.__init__rcCt||j|j|j|j|jSr)r rBr8rarbrcrr9r9r:rzRotate.forwardNr`r T rrrrrrrrrrrr9r9rr:rs( rc LeZdZdZ ddedededed d f fd d Zd ed efddZZ S)ra3Translate 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]) r`r TrPrarbrcr&Ncrr)rrrPrarbrc)rrPrarbrcrr9r:r  zTranslate.__init__rcCst||j|j|j|jSr)r$rPrarbrcrr9r9r:rzTranslate.forwardr`r T rrrrrrrrrrr9r9rr:r rc r)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]) Nr`r Trur8rarbrcr&crr)rrrur8rarbrc)rrur8rarbrcrr9r:rrzScale.__init__rcCrr)r"rur8rarbrcrr9r9r:rrz Scale.forwardrrr9r9rr:rs( rc r)ra Shear 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]) r`r Tr#rarbrcr&Ncrr)rrr#rarbrc)rr#rarbrcrr9r:r+rzShear.__init__rcCst||j|j|j|jSr)r#rarbrcrr9r9r:r4rz Shear.forwardrrr9r9rr:rrrr)r`r Fr)Nr`r F)ryr)r`NF)9rtypingrrrr3 kornia.corerModulerrrr kornia.filtersr kornia.utilsr kornia.utils.imager kornia.utils.miscr imgwarprrrrr__all__r;rArErOrZr\r_rrrrr r!r$r"r#rr2rrrrrrrrrrrr9r9r9r:s         7 ;  F  F 4  A $1  X % +9a,.&0