o oiO@s0ddlmZddlmZmZmZmZddlmZddl Z ddl m m Z ddlmZddlmZmZmZeeeeefZeeeefefZeeefZd(ded ed efd d Z d)d eeeeeffdeeeeeffdeeeeeeffd efddZGdddeZGdddeZd eeefdeeefdeeefd efddZ  d*ded eeeeeffdeeeeeffdeeeeeffded eded efddZdedeed fd!eed fd efd"d#Z $ d+dedeeeeeffdeeeeeffded%ed ef d&d'Z!dS),)ceil)OptionalTupleUnioncast)warnN)_pair)ModuleTensorpadFpadding unpaddingreturncCsttt|}t|dvrt|rdnddt|dkr+t|d}t|d}n |dd}|dd}tt||}|S) zCreate argument for padding op.) UnpaddingPaddingz? must be either an int, tuple of two ints or tuple of four intsrrN)r TuplePadTyperlenAssertionError FullPadType)r r pad_vertpad_horzrR/home/ubuntu/.local/lib/python3.10/site-packages/kornia/contrib/extract_patches.pycreate_padding_tuple!s     r original_size window_sizestridec Cs.ttttft|}ttttft|}|dur|}ttttft|}|d|d|d}|d|d|d}|dkrJ|d|}nd}|dkrW|d|}nd}|ddkrf|d}}n |d}t|d}|ddkr}|d} } n |d} t|d} t|t|t| t| f} | S)ayCompute required padding to ensure chaining of :func:`extract_tensor_patches` and :func:`combine_tensor_patches` produces expected result. Args: original_size: the size of the original tensor. window_size: the size of the sliding window used while extracting patches. stride: The stride of the sliding window. Optional: if not specified, window_size will be used. Return: The required padding as a tuple of four ints: (top, bottom, left, right) Example: >>> image = torch.arange(12).view(1, 1, 4, 3) >>> padding = compute_padding((4,3), (3,3)) >>> out = extract_tensor_patches(image, window_size=(3, 3), stride=(3, 3), padding=padding) >>> combine_tensor_patches(out, original_size=(4, 3), window_size=(3, 3), stride=(3, 3), unpadding=padding) tensor([[[[ 0, 1, 2], [ 3, 4, 5], [ 6, 7, 8], [ 9, 10, 11]]]]) .. note:: This function will be implicitly used in :func:`extract_tensor_patches` and :func:`combine_tensor_patches` if `allow_auto_(un)padding` is set to True. Nrrr)rrintrr) rrrremainder_verticalremainder_horizontalvertical_paddinghorizontal_padding top_paddingbottom_padding left_padding right_paddingr rrrcompute_padding5s.    r)c speZdZdZ   ddeeeeeffdeeeeeffdeded d f fd d Z d e d e fddZ Z S)ExtractTensorPatchesa< Module that extract patches from tensors and stack them. In the simplest case, the output value of the operator with input size :math:`(B, C, H, W)` is :math:`(B, N, C, H_{out}, W_{out})`. where - :math:`B` is the batch size. - :math:`N` denotes the total number of extracted patches stacked in - :math:`C` denotes the number of input channels. - :math:`H`, :math:`W` the input height and width of the input in pixels. - :math:`H_{out}`, :math:`W_{out}` denote to denote to the patch size defined in the function signature. left-right and top-bottom order. * :attr:`window_size` is the size of the sliding window and controls the shape of the output tensor and defines the shape of the output patch. * :attr:`stride` controls the stride to apply to the sliding window and regulates the overlapping between the extracted patches. * :attr:`padding` controls the amount of implicit zeros-paddings on both sizes at each dimension. * :attr:`allow_auto_padding` allows automatic calculation of the padding required to fit the window and stride into the image. The parameters :attr:`window_size`, :attr:`stride` and :attr:`padding` can be either: - a single ``int`` -- in which case the same value is used for the height and width dimension. - a ``tuple`` of two ints -- in which case, the first `int` is used for the height dimension, and the second `int` for the width dimension. :attr:`padding` can also be a ``tuple`` of four ints -- in which case, the first two ints are for the height dimension while the last two ints are for the width dimension. Args: input: tensor image where to extract the patches with shape :math:`(B, C, H, W)`. window_size: the size of the sliding window and the output patch size. stride: stride of the sliding window. padding: Zero-padding added to both side of the input. allow_auto_adding: whether to allow automatic padding if the window and stride do not fit into the image. Shape: - Input: :math:`(B, C, H, W)` - Output: :math:`(B, N, C, H_{out}, W_{out})` Returns: the tensor with the extracted patches. Examples: >>> input = torch.arange(9.).view(1, 1, 3, 3) >>> patches = extract_tensor_patches(input, (2, 3)) >>> input tensor([[[[0., 1., 2.], [3., 4., 5.], [6., 7., 8.]]]]) >>> patches[:, -1] tensor([[[[3., 4., 5.], [6., 7., 8.]]]]) rrFrrr allow_auto_paddingrNcs&t||_||_||_||_dSN)super__init__rrr r+)selfrrr r+ __class__rrr.s  zExtractTensorPatches.__init__inputcCst||j|j|j|jdS)N)rr r+)extract_tensor_patchesrrr r+r/r2rrrforwardszExtractTensorPatches.forwardrrF) __name__ __module__ __qualname____doc__rr rPadTypeboolr.r r5 __classcell__rrr0rr*ys"A r*c seZdZdZ   ddeeefdeeeeeffdeeeeeeffded e d df fd d Z d e d e fddZ Z S)CombineTensorPatchesaJ Module that combines patches back into full tensors. In the simplest case, the output value of the operator with input size :math:`(B, N, C, H_{out}, W_{out})` is :math:`(B, C, H, W)`. where - :math:`B` is the batch size. - :math:`N` denotes the total number of extracted patches stacked in - :math:`C` denotes the number of input channels. - :math:`H`, :math:`W` the input height and width of the input in pixels. - :math:`H_{out}`, :math:`W_{out}` denote to denote to the patch size defined in the function signature. left-right and top-bottom order. * :attr:`original_size` is the size of the original image prior to extracting tensor patches and defines the shape of the output patch. * :attr:`window_size` is the size of the sliding window used while extracting tensor patches. * :attr:`stride` controls the stride to apply to the sliding window and regulates the overlapping between the extracted patches. * :attr:`unpadding` is the amount of padding to be removed. If specified, this value must be the same as padding used while extracting tensor patches. * :attr:`allow_auto_unpadding` allows automatic calculation of the padding required to fit the window and stride into the image. This must be used if the `allow_auto_padding` flag was used for extracting the patches. The parameters :attr:`original_size`, :attr:`window_size`, :attr:`stride`, and :attr:`unpadding` can be either: - a single ``int`` -- in which case the same value is used for the height and width dimension. - a ``tuple`` of two ints -- in which case, the first `int` is used for the height dimension, and the second `int` for the width dimension. :attr:`unpadding` can also be a ``tuple`` of four ints -- in which case, the first two ints are for the height dimension while the last two ints are for the width dimension. Args: patches: patched tensor with shape :math:`(B, N, C, H_{out}, W_{out})`. original_size: the size of the original tensor and the output size. window_size: the size of the sliding window used while extracting patches. stride: stride of the sliding window. unpadding: remove the padding added to both side of the input. allow_auto_unpadding: whether to allow automatic unpadding of the input if the window and stride do not fit into the original_size. eps: small value used to prevent division by zero. Shape: - Input: :math:`(B, N, C, H_{out}, W_{out})` - Output: :math:`(B, C, H, W)` Example: >>> out = extract_tensor_patches(torch.arange(16).view(1, 1, 4, 4), window_size=(2, 2), stride=(2, 2)) >>> combine_tensor_patches(out, original_size=(4, 4), window_size=(2, 2), stride=(2, 2)) tensor([[[[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11], [12, 13, 14, 15]]]]) .. note:: This function is supposed to be used in conjunction with :class:`ExtractTensorPatches`. NrFrrrr allow_auto_unpaddingrcs8t||_||_|dur|n||_||_||_dSr,)r-r.rrrr r?)r/rrrr r?r0rrr.s  zCombineTensorPatches.__init__r2cCst||j|j|j|j|jdS)N)rr r?)combine_tensor_patchesrrrr r?r4rrrr5"szCombineTensorPatches.forward)NrF)r7r8r9r:rr rrr;r<r.r r5r=rrr0rr>s&G r>cCsH|d|d|d}|d|d|d}|dks |dkr"dSdS)NrrFTr)rrrr!r"rrr_check_patch_fit-s rA:0yE>patchesr?epscCs|jdkr td|jttttft|}ttttft|}ttttft|}|d|dk|d|dkBrItd|d|d|skt|||sk|sdt d|d |d |d dd nt |||d }|rqt |}t j |jd|jd|d|d|j|jd}|rt||d}|jdd}|ddddd}||jdd|jd}d} t |sd} |j} |}|}tj|||d} tj| |||d} |rt| dd|D} tj||||d} |rt| dd|D} | | |}| r|| }|S)aRestore input from patches. See :class:`~kornia.contrib.CombineTensorPatches` for details. Args: patches: patched tensor with shape :math:`(B, N, C, H_{out}, W_{out})`. original_size: the size of the original tensor and the output size. window_size: the size of the sliding window used while extracting patches. stride: stride of the sliding window. unpadding: remove the padding added to both side of the input. allow_auto_unpadding: whether to allow automatic unpadding of the input if the window and stride do not fit into the original_size. eps: small value used to prevent division by zero. Return: The combined patches in an image tensor with shape :math:`(B, C, H, W)`. Example: >>> out = extract_tensor_patches(torch.arange(16).view(1, 1, 4, 4), window_size=(2, 2), stride=(2, 2)) >>> combine_tensor_patches(out, original_size=(4, 4), window_size=(2, 2), stride=(2, 2)) tensor([[[[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11], [12, 13, 14, 15]]]]) .. note:: This function is supposed to be used in conjunction with :func:`extract_tensor_patches`. z/Invalid input shape, we expect BxNxCxHxW. Got: rrzStride=z- should be less than or equal to Window size=z, information is missing6The window will not fit into the image. Window size: Stride: Image size: aH This means we probably cannot correctly recombine patches. By enabling `allow_auto_unpadding`, the input will be unpadded to fit the window and stride. If the patches have been obtained through `extract_tensor_patches` with the correct padding or the argument `allow_auto_padding`, this will result in a correct reconstruction. stacklevelrrrr)devicedtype)r Nr) kernel_sizer)r2 output_sizerPrcSg|]}| qSrr.0irrr z*combine_tensor_patches..cSrRrrrSrrrrVrW)ndim ValueErrorshaperrr rrrArr)rtorchonesrLrMr permutereshapeis_floating_pointfloatFunfoldfoldto)rCrrrr?r rDr\ restored_sizeint_flagrM unfold_onesnorm_mapsaturated_restored_tensorrestored_tensorrrrr@:sf &       r@r2 window_sizes.stridescs|dd\}}td|t||D] \}}}||||}q|jdgdfddDR}|j|d|g|RS)Nrrrc3s|] }|tVqdSr,)r)rTdimdimsrr sz,_extract_tensor_patchesnd..rO)sizerangermziprbr] contiguousview)r2rkrl batch_size num_channelsrm patch_sizerrrnr_extract_tensor_patchesnds ,ryrr+cCst|stdt|t|jdkrtd|jttt t ft |}ttt t ft |}|jd|jdf}|s_t |||s_|sXt d|d|d|d d d nt |||d }|rjt|}t||}t|||S) aExtract patches from tensors and stacks them. See :class:`~kornia.contrib.ExtractTensorPatches` for details. Args: input: tensor image where to extract the patches with shape :math:`(B, C, H, W)`. window_size: the size of the sliding window and the output patch size. stride: stride of the sliding window. padding: Zero-padding added to both side of the input. allow_auto_padding: whether to allow automatic padding if the window and stride do not fit into the image. Returns: the tensor with the extracted patches with shape :math:`(B, N, C, H_{out}, W_{out})`. Examples: >>> input = torch.arange(9.).view(1, 1, 3, 3) >>> patches = extract_tensor_patches(input, (2, 3)) >>> input tensor([[[[0., 1., 2.], [3., 4., 5.], [6., 7., 8.]]]]) >>> patches[:, -1] tensor([[[[3., 4., 5.], [6., 7., 8.]]]]) z&Input input type is not a Tensor. Got rz-Invalid input shape, we expect BxCxHxW. Got: rOrFrGrHz This means that the final incomplete patches will be dropped. By enabling `allow_auto_padding`, the input will be padded to fit the window and stride.rrIrK)r[ is_tensor TypeErrortyperrZrYrrr rrArr)rr ry)r2rrr r+rrrrr3s* !   r3)Fr,)FrrBr6)"mathrtypingrrrrwarningsrr[torch.nn.functionalnn functionalratorch.nn.modules.utilsr kornia.corer r r r rrr;r<rr)r*r>rAr`r@ryr3rrrrsz     DV2^ *o