3j^USSKJr SSKJrJrJrJr SSKJr SSK r SSK J s J r SSK J r SSKJr \\\\\4r\\\\4\4r\\\4rSS\S\S \4S jjrS S \\\\\44S \\\\\44S \\\\\\44S \4Sjjr"SS\ R.5r"SS\ R.5rS \\\4S \\\4S \\\4S \4SjrS!S\ R6S \\\\\44S \\\\\44S \\\\\44S\S\S\S \ R64SjjrS\ R6S\\S4S\\S4S \ R64SjrS"S\ R6S \\\\\44S \\\\\44S\S\S \ R64 Sjjrg)#)ceil)OptionalTupleUnioncast)warnN)nn)_pairpadding unpaddingreturnc[[[U55n[U5S;a[ U(aSOSS35e[U5S:Xa[US5n[US5nO USSnUSSn[[ X2-5nU$) zCreate argument for padding op.) UnpaddingPaddingz? must be either an int, tuple of two ints or tuple of four intsrrN)r TuplePadTyper lenAssertionError FullPadType)r r pad_vertpad_horzs X/home/wildlama/miniconda3/lib/python3.13/site-packages/kornia/contrib/extract_patches.pycreate_padding_tupler s<w0G 7|6!'{Y77v w   7|q$$2A;12;; 34G N original_size window_sizestridec\[[[[4[U55n[[[[4[U55nUcUn[[[[4[U55nUSUS- US-nUSUS- US-nUS:wa USU- nOSnUS:wa USU- nOSnUS-S:XaUS-=pxOUS-n[ US- 5nUS-S:XaUS-=pOUS-n [ US- 5n [U5[U5[U 5[U 54n U $)a/Compute 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 torch.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. rrr)rrintr r) rrrremainder_verticalremainder_horizontalvertical_paddinghorizontal_padding top_paddingbottom_padding left_padding right_paddingr s rcompute_paddingr*4sc>sCx% *>?MuS#Xk(:;K ~ %S/5= 1F'*[^;vayH)!,{1~=JQ!!9'99q #AY)==!q '71'<< n&!+ .23A"'9Q'>> })Q. /!34 +N 3S5FMHZZG Nrc ^\rSrSrSrS S\\\\\44S\\\\\44S\S\ SS4 U4S jjjr S \ RS\ R4S jr S rU=r$)ExtractTensorPatchesxa nn.Module that extract patches from tensors and torch.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 torch.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 torch.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: torch.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 torch.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.]]]]) rrr allow_auto_paddingr NcR>[TU]5 XlX lX0lX@lgN)super__init__rrr r.)selfrrr r. __class__s rr2ExtractTensorPatches.__init__s& 8C39 ' (:rinputcl[UURURURURS9$)aExtract sliding-window patches from a batched image tensor. Args: input: Input tensor with shape :math:`(B, C, H, W)`, where: - ``B`` is the batch size (number of images), - ``C`` is the number of channels, - ``H`` is height, - ``W`` is width. Returns: A tensor containing stacked patches with shape :math:`(B, N, C, H_{out}, W_{out})`, where: - ``N`` is the number of extracted windows per image, - ``H_{out}`` and ``W_{out}`` are patch height and patch width. )rr r.)extract_tensor_patchesrrr r.r3r6s rforwardExtractTensorPatches.forwards4 &    ;;LL#66   r)r.r rrrrF)__name__ __module__ __qualname____firstlineno____doc__rr!rPadTypeboolr2torchTensorr:__static_attributes__ __classcell__r4s@rr,r,xs<B/0#( ;3c3h/0 ;c5c?*+ ; ; ! ;  ; ; U\\ ell  rr,c ^\rSrSrSrSS\\\4S\\\\\44S\\\\\\44S\ S\ S S4 U4S jjjr S \ RS \ R4S jrS rU=r$)CombineTensorPatchesa nn.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 torch.Tensor patches and defines the shape of the output patch. * :attr:`window_size` is the size of the sliding window used while extracting torch.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 torch.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 torch.Tensor with shape :math:`(B, N, C, H_{out}, W_{out})`. original_size: the size of the original torch.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`. Nrrrr allow_auto_unpaddingr cj>[TU]5 XlX lUbUOUUlX@lXPlgr0)r1r2rrrr rL)r3rrrr rLr4s rr2CombineTensorPatches.__init__!s6 .;8C=C=O6U` "+*>!rr6c [UURURURURUR S9$)aReconstruct full images from extracted patches. Args: input: Patch tensor with shape :math:`(B, N, C, H_{out}, W_{out})`, where: - ``B`` is the batch size, - ``N`` is the number of patches, - ``C`` is the number of channels, - ``H_{out}`` and ``W_{out}`` are patch height and width. Returns: A reconstructed tensor with shape :math:`(B, C, H, W)`, where ``H`` and ``W`` correspond to ``original_size`` after optional unpadding. )rr rL)combine_tensor_patchesrrrr rLr9s rr:CombineTensorPatches.forward0s=&       ;;nn!%!:!:   r)rLrrr r)NrF)r=r>r?r@rArr!rrrBrCr2rDrEr:rFrGrHs@rrJrJsAN9=%* ?S#X ?3c3h/0 ?sE#s(O345 ?  ? # ?  ? ? U\\ ell  rrJcbUSUS- US-nUSUS- US-nUS:wdUS:wagg)NrrFT)rrrr"r#s r_check_patch_fitrTHsT'*[^;vayH)!,{1~=J !'9Q'> rpatchesrLepsc URS:wa[SUR35e[[[ [ 4[ U55n[[[ [ 4[ U55n[[[ [ 4[ U55nUSUS:USUS:-(a[SUSUS35eU(d7[XU5(d&U(d[SUS US US 3SS 9 O [XUS 9nU(a [U5n[R"URSURSUSUSURURS9nU(a[ R""XuS9nURSSnUR%SSSSS5nUR'URSSURS5nSn [R("U5(d.Sn URn UR+5nUR+5n[ R,"XrUS9n [ R."XX#S9n U(a'[ R""XV s/sHo*PM sn 5n [ R."XX#S9nU(a'[ R""XV s/sHo*PM sn 5nXU-- nU (aUR1W 5nU$s sn fs sn f)aRestore input from patches. See :class:`~kornia.contrib.CombineTensorPatches` for details. Args: patches: patched torch.Tensor with shape :math:`(B, N, C, H_{out}, W_{out})`. original_size: the size of the original torch.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 torch.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)padNr) kernel_sizer)r6 output_sizerdr)ndim ValueErrorshaperrr!r rrTrr*rrDonesr_r`Frapermutereshapeis_floating_pointfloatunfoldfoldto)rUrrrrLr rV ones_tensor restored_sizeint_flagr` unfold_onesnorm_mapisaturated_restored_tensorrestored_tensors rrPrPUsL||qJ7==/Z[[sCx% *>?MuS#Xk(:;K %S/5= 1Fq KN"vay;q>'ABfXJ;-Wo p    FCC'Mk]Zdekdlm##0/2gg !,-iop (3 ** a aaa~~mm KeeK7 %%ab)MooaAq!,GoogmmA.GMM"4EFGH  " "7 + + --/!'') ((;OKvvKP[kH55 #: 1B #:;!"W]h x$%EE*CR[E\R[QbR[E\$]!0c>BO),,U3 $; F]s " K % K r6 window_sizes.stridesc:^UR5SSup4[SUR55m[TX5HupVnUR XVU5nM UR "S/TQSPU4SjT5Q76R 5nUR"USU/UQ76$)Nrrrc3>># UHo[T5-v M g7fr0)r).0dimdimss r ,_extract_tensor_patchesnd..s(IDSs4yDsrc)sizerangerziprork contiguousview) r6rzr{ batch_size num_channelsr patch_sizerrs @r_extract_tensor_patchesndrs %zz|BQ/J EIIK D#&t\#C Sf5$D MM! Jd JA J(ID(I J U U WE ::j"l B\ BBrr.c [R"U5(d[S[U535e[ UR 5S:wa[ SUR 35e[[[[4[U55n[[[[4[U55nUR SUR S4nU(d7[XQU5(d&U(d[SUSUSUS 3S S 9 O [XQUS 9nU(a![U5n[R "X5n[#XU5$) aExtract patches from tensors and stacks them. See :class:`~kornia.contrib.ExtractTensorPatches` for details. Args: input: torch.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 torch.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 torch.Tensor. Got rz-Invalid input shape, we expect BxCxHxW. Got: rcrYrZr[z 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.rr\r^)rD is_tensor TypeErrortyperrhrgrrr!r rTrr*rrjrar)r6rrr r.rs rr8r8s B ??5 ! !FtE{mTUU 5;;1H VWWuS#Xk(:;K %S/5= 1F[[_ekk"o6M  FCC%Mk]Zdekdlm##0/2MM ! * gmn&w/e% $U @@r)Fr0)Frg:0yE>r<) mathrtypingrrrrwarningsrrDtorch.nn.functionalr functionalrjtorch.nn.modules.utilsr r!rrrBrCrr*Moduler,rJrTrErnrPrr8rSrrrs$// (Cc3&' U38_k12 \! "'d{.59AeCHo-.AsE#s(O+,A U3c3h/0 1A AHb 299b Jh 299h V E#s(O %S/ [`adfiai[j os $"'l \\leCHo-.lsE#s(O+,l #uS#X& ' l  l  l l \\l^C <<C',S#XCAFsCxC \\C+,$ @A <<@AsE#s(O+,@A #uS#X& '@A @A  @A  \\ @Ar