
    3j[                     2   % S SK JrJrJrJrJr  S SKrS SKJs  J	r
  S SKJr  S SKJr  S SKJrJr  S SKJr  S SKJr  Sr\\S	'   S
S/r\\   \S'   / SQr\\   \S'   / SQr\\   \S'   \\\S.r\\\\   4   \S'   S V s0 s H
  n U SU  S3_M     sn r\\\4   \S'   S0S\S\\\R<                  4   4S jjrS\S\S\R<                  4S jr  " S S\RB                  5      r" " S S \RB                  5      r# " S! S"\RB                  5      r$S#\S$\\\R<                  4   S\R<                  4S% jr% " S& S'\RB                  5      r& " S( S)\RB                  5      r' " S* S+\RB                  5      r(S#\S,\S\\\4   4S- jr) " S. S/\RB                  5      r*gs  sn f )1    )AnyDictListTupleUnionN)nn)pi)GaussianBlur2dSpatialGradient)cart2pol)create_meshgridg;f?sqrt2gpu?g "?COEFFS_N1_K1)"g#[?x@ٔ+?K'"?COEFFS_N2_K8)r   r   r   gˈfF?COEFFS_N3_K8)xyrhophithetaCOEFFS)cartpolarconcatzChttps://github.com/manyids2/mkd_pytorch/raw/master/mkd_pytorch/mkd-z-64.pthurls
patch_sizereturnc                 r    [        X SS9nUSSS2SS2S4   nUSSS2SS2S4   n[        X#5      u  pEX#XES.nU$ )z1Get cartesian and polar parametrizations of grid.Theightwidthnormalized_coordinatesr   N   )xyrhophi)r   r   )r   kgridr%   r&   r'   r(   	grid_dicts          L/home/wildlama/miniconda3/lib/python3.13/site-packages/kornia/feature/mkd.pyget_grid_dictr,   *   sN    :X\]EaAqjAaAqjA~HC8I    d1d2c                    [         R                  " [         R                  " U 5      [         R                  " U5      SS9u  p#[         R                  " X#/SS9R	                  SS5      nUR                  [         R                  5      $ )z&Get order for doing kronecker product.ij)indexing   dim)torchmeshgridarangestackreshapetoint64)r.   r/   grid_d1grid_d2
kron_orders        r+   get_kron_orderrA   4   s]    ~~ell2&6R8HSWXGg/Q7??AFJ==%%r-   c                   x   ^  \ rS rSrSrS	U 4S jjrS\R                  S\R                  4S jrS\	4S jr
SrU =r$ )
MKDGradients;   a[  nn.Module, which computes gradients of given patches, stacked as [magnitudes, orientations].

Given gradients $g_x$, $g_y$ with respect to $x$, $y$ respectively,
  - $\mathbox{mags} = $\sqrt{g_x^2 + g_y^2 + eps}$
  - $\mathbox{oris} = $\mbox{torch.tan}^{-1}(\nicefrac{g_y}{g_x})$.

Args:
    patch_size: Input patch size in pixels.

Returns:
    gradients of given patches.

Shape:
    - Input: (B, 1, patch_size, patch_size)
    - Output: (B, 2, patch_size, patch_size)

Example:
    >>> patches = torch.rand(23, 1, 32, 32)
    >>> gradient = MKDGradients()
    >>> g = gradient(patches) # 23x2x32x32

r   c                 P   > [         TU ]  5         SU l        [        SSSS9U l        g )N:0yE>diffr$   F)modeorder
normalized)super__init__epsr   grad)self	__class__s    r+   rL   MKDGradients.__init__S   s%    #qUK	r-   r%   c                    [        U[        R                  5      (       d  [        S[	        U5       35      e[        UR                  5      S:X  d  [        SUR                   35      eU R                  U5      * nUS S 2S S 2SS S 2S S 24   nUS S 2S S 2SS S 2S S 24   n[        R                  " [        X4U R                  5      SS9nU$ )N&Input type is not a torch.Tensor. Got    -Invalid input shape, we expect Bx1xHxW. Got: r   r$   r4   )
isinstancer7   Tensor	TypeErrortypelenshape
ValueErrorrN   catr   rM   )rO   r%   grads_xygxgyr&   s         r+   forwardMKDGradients.forwardY   s    !U\\**DT!WINOO177|q LQWWIVWWIIaL=aAq!m$aAq!m$IIhrtxx0a8r-   c                 .    U R                   R                  $ N)rP   __name__rO   s    r+   __repr__MKDGradients.__repr__e   s    ~~&&&r-   )rM   rN   r   N)re   
__module____qualname____firstlineno____doc__rL   r7   rW   ra   strrg   __static_attributes____classcell__rP   s   @r+   rC   rC   ;   s:    .L
 
%,, 
'# ' 'r-   rC   c            	          ^  \ rS rSrSrS\S\\\\\4      \	\\\4   S4   4   SS4U 4S jjr
S	\R                  S\R                  4S
 jrS\4S jrSrU =r$ )VonMisesKerneli   a  nn.Module, which computes parameters of Von Mises kernel given coefficients, and embeds given patches.

Args:
    patch_size: Input patch size in pixels.
    coeffs: List of coefficients. Some examples are hardcoded in COEFFS,

Returns:
    Von Mises embedding of given parametrization.

Shape:
    - Input: (B, 1, patch_size, patch_size)
    - Output: (B, d, patch_size, patch_size)

Examples:
    >>> oris = torch.rand(23, 1, 32, 32)
    >>> vm = VonMisesKernel(patch_size=32,
    ...                     coeffs=[0.14343168,
    ...                             0.268285,
    ...                             0.21979234])
    >>> emb = vm(oris) # 23x7x32x32

r   coeffs.r   Nc                   > [         TU ]  5         Xl        [        R                  " U5      nU R                  SU5        [        U5      S-
  nX@l        SU-  S-   U l        [        R                  " SSX/5      n[        R                  " U5      S-   nUR                  SSS5      n[        R                  " SU-  S-   /5      n[        R                  " U5      US US-   & [        R                  " USS  5      XtS-   S & UR                  SSS5      nU R                  SU5        U R                  SU5        U R                  SU5        g )Nru   r$   r3   r6   emb0frangeweights)rK   rL   r   r7   tensorregister_bufferrZ   ndonesr9   r;   zerossqrt)	rO   r   ru   b_coeffsr|   rw   rx   ry   rP   s	           r+   rL   VonMisesKernel.__init__   s   $<<'Xx0 K!OQ zz1a89a1$Aq)++q1uqyk* ::h/!a% ::hqrl3A//"a+VT*Xv.Y0r-   r%   c                    [        U[        R                  5      (       d  [        S[	        U5       35      e[        UR                  5      S:X  a  UR                  S   S:w  a  [        SUR                   35      e[        U R                  [        R                  5      (       d  [        S[	        U5       35      eU R                  R                  U5      R                  UR                  S5      SSS5      nU R                  R                  U5      U-  n[        R                  " U5      n[        R                  " U5      n[        R                  " X$U/SS9nU R                   U-  nU$ )NrS   rT   r$   rU   z%Emb0 type is not a torch.Tensor. Got r   r4   )rV   r7   rW   rX   rY   rZ   r[   r\   rw   r<   repeatsizerx   cossinr]   ry   )rO   r%   rw   rx   emb1emb2	embeddings          r+   ra   VonMisesKernel.forward   s   !U\\**DT!WINOO177|q AGGAJ!OLQWWIVWW$))U\\22CDG9MNNyy||A%%affQiAq9"Q&yy yy IIt40a8	LL9,	r-   c           
          U R                   R                   SU R                   SU R                   SU R                   SU R
                   S3
$ )N(patch_size=z, n=z, d=z	, coeffs=))rP   re   r   r|   r}   ru   rf   s    r+   rg   VonMisesKernel.__repr__   sN    ..))*,t6GtDFF8SWX\X^X^W__himitithuuvwwr-   )r}   r|   r   )re   rj   rk   rl   rm   intr   r   floatr   rL   r7   rW   ra   rn   rg   ro   rp   rq   s   @r+   rs   rs   i   s    .13 1d5;L6MuUZ[`be[eUfhkUkOl6l0m 1rv 10 %,, $x# x xr-   rs   c                      ^  \ rS rSrSrSS\S\SS4U 4S jjjrS\R                  S\R                  4S	 jr
S
\R                  S\R                  4S jrS\4S jrSrU =r$ )EmbedGradients   a  nn.Module that computes gradient embedding, weighted by sqrt of magnitudes of given patches.

Args:
    patch_size: Input patch size in pixels.
    relative: absolute or relative gradients.

Returns:
    Gradient embedding.

Shape:
    - Input: (B, 2, patch_size, patch_size)
    - Output: (B, 7, patch_size, patch_size)

Examples:
    >>> grads = torch.rand(23, 2, 32, 32)
    >>> emb_grads = EmbedGradients(patch_size=32,
    ...                            relative=False)
    >>> emb = emb_grads(grads) # 23x7x32x32

r   relativer   Nc                    > [         TU ]  5         Xl        X l        SU l        [        U[        S   S9U l        [        XSS9n[        US S 2S S 2S S 2S4   US S 2S S 2S S 2S4   5      u  pEU R                  SU5        g )	NrF   r   r   ru   Tr    r   r$   r(   )rK   rL   r   r   rM   rs   r   kernelr   r   r{   )rO   r   r   r)   _r(   rP   s         r+   rL   EmbedGradients.__init__   sz    $  %
6'?S  z\`a%1a
+U1aA:->?UC(r-   magsc                 J    [         R                  " XR                  -   5      nU$ )z@Embed square roots of magnitudes with eps for numerical reasons.)r7   r   rM   )rO   r   s     r+   emb_magsEmbedGradients.emb_mags   s    zz$/*r-   gradsc                    [        U[        R                  5      (       d  [        S[	        U5       35      e[        UR                  5      S:X  d  [        SUR                   35      eUS S 2S S2S S 2S S 24   nUS S 2SS 2S S 2S S 24   nU R                  (       a  X0R                  R                  U5      -
  nU R                  U5      U R                  U5      -  nU$ )NrS   rT   z-Invalid input shape, we expect Bx2xHxW. Got: r$   )rV   r7   rW   rX   rY   rZ   r[   r\   r   r(   r<   r   r   )rO   r   r   orisr&   s        r+   ra   EmbedGradients.forward   s    %..DT%[MRSS5;;1$LU[[MZ[[QAq[!QAq[!==((++d++DKKd 33r-   c                 h    U R                   R                   SU R                   SU R                   S3$ )Nr   z, relative=r   )rP   re   r   r   rf   s    r+   rg   EmbedGradients.__repr__   s4    ..))*,t6G{SWS`S`Raabccr-   )rM   r   r   r   )    F)re   rj   rk   rl   rm   r   boolrL   r7   rW   r   ra   rn   rg   ro   rp   rq   s   @r+   r   r      sq    *)3 )t ) ) )U\\ ell 

U\\ 
ell 
d# d dr-   r   kernel_typegridsc                 4   S[         [        -  [         S-  [         S-  S.nU S:X  a  SnSS/nOU S:X  a  S	nS
S/n[        UR                  5       5      nXS      R                  S   nUR                  5        VVs0 s H  u  pxXxX'   -  _M     n	nnU	R                  5        VVs0 s H3  u  pxXxR                  S5      R                  S5      R                  5       _M5     n	nn[        U[        W   S9n
[        U[        U   S9nU
" U	WS      5      R                  5       nU" XS      5      R                  5       n[        U
R                  UR                  5      nUR                  SUSS2S4   5      UR                  SUSS2S4   5      -  nU$ s  snnf s  snnf )z<Compute embeddings for cartesian and polar parametrizations.      ?r3   )r(   r'   r%   r&   r   r   r%   r&   r   r   r(   r'   r   r6   r   r$   N)r	   r   listkeysr[   items	unsqueezer   rs   r   squeezerA   r}   index_select)r   r   factorscoeffs_params_r   r   kvgrids_normedvm_avm_bemb_aemb_br@   spatial_kernels                   r+   spatial_kernel_embeddingr      s   "u*26QGGf*		%. 

DAw%%b)J 38++-@-$!A7:~%-L@GSGYGYG[\G[tqA{{1~//288::G[L\ ZwHDZwHDgaj)*224Eaj)*224E  /J'':ad+;<u?Q?QRSU_`acd`dUe?ffN A\s   :F#:Fc                     ^  \ rS rSrSr     SS\S\S\S\S\SS	4U 4S
 jjjrS\	S\
R                  4S jrS\\
R                  \
R                  4   4S jrS\
R                  S\
R                  4S jrS\4S jrSrU =r$ )ExplicitSpacialEncodingi  a=  nn.Module that computes explicit cartesian or polar embedding.

Args:
    kernel_type: Parametrization of kernel ``'polar'`` or ``'cart'``.
    fmap_size: Input feature map size in pixels.
    in_dims: Dimensionality of input feature map.
    do_gmask: Apply gaussian mask.
    do_l2: Apply l2-normalization.

Returns:
    Explicit cartesian or polar embedding.

Shape:
    - Input: (B, in_dims, fmap_size, fmap_size)
    - Output: (B, out_dims, fmap_size, fmap_size)

Example:
    >>> emb_ori = torch.rand(23, 7, 32, 32)
    >>> ese = ExplicitSpacialEncoding(kernel_type='polar',
    ...                               fmap_size=32,
    ...                               in_dims=7,
    ...                               do_gmask=True,
    ...                               do_l2=True)
    >>> desc = ese(emb_ori) # 23x175x32x32

r   	fmap_sizein_dimsdo_gmaskdo_l2r   Nc                   > [         T	U ]  5         US;  a  [        U S35      eXl        X l        X0l        X@l        XPl        [        U5      U l	        S U l
        [        U R                  U R                  5      nU R                  (       a"  U R                  SS9U l
        X`R                  -  nU R                  SUR                  S5      5        UR                  S   U l        U R
                  U R                   -  U l        U R"                  U l        U R'                  5       u  pxU R                  SU5        U R                  SU5        g )	N)r   r   z" is not valid, use polar or cart).r   )sigmaembr   r   idx1)rK   rL   NotImplementedErrorr   r   r   r   r   r,   gridgmaskr   	get_gmaskr{   r   r[   d_embout_dimsodims	init_kron)
rO   r   r   r   r   r   r   r   r   rP   s
            r+   rL    ExplicitSpacialEncoding.__init__#  s    	//%5W&XYY&" 
!),	
 't'7'7C ==c2DJ

"C 	UCMM!$45))A,
!\\DJJ6--
 ^^%
VT*VT*r-   r   c                     U R                   S   U R                   S   R                  5       -  n[        R                  " SUS-  -  US-  -  5      nU$ )zCompute Gaussian mask.r'   r6   r3   )r   maxr7   exp)rO   r   norm_rhor   s       r+   r   !ExplicitSpacialEncoding.get_gmaskK  sL    99U#dii&6&:&:&<<		"x{*UAX56r-   c                    [        U R                  U R                  5      n[        R                  R                  [        R                  U R                  5      n[        R                  " USUSS2S4   5      nX1SS2S4   4$ )z3Initialize helper variables to calculate kronecker.r$   Nr   )	rA   r   r   r7   jitannotaterW   r   r   )rO   kron_embr   s       r+   r   !ExplicitSpacialEncoding.init_kronQ  sa    dllDJJ7yy!!%,,9!!$41:6!Q$Zr-   r%   c                 V   [        U[        R                  5      (       d  [        S[	        U5       35      e[        UR                  5      S:H  UR                  S   U R                  :H  -  (       d%  [        SU R                   SUR                   35      e[        R                  R                  [        R                  U R                  5      n[        R                  " USU5      nX0R                  -  nUR                  SS9nU R                  (       a  [         R"                  " USS9nU$ )NrS   rT   r$   z!Invalid input shape, we expect BxzxHxW. Got: )r3      r4   )rV   r7   rW   rX   rY   rZ   r[   r   r\   r   r   r   r   r   sumr   F	normalize)rO   r%   r   r   outputs        r+   ra   ExplicitSpacialEncoding.forwardX  s    !U\\**DT!WINOOQWW"qwwqzT\\'AB@kZ[ZaZaYbcddyy!!%,,		:!!!Q-		!'::[[Q/Fr-   c                     U R                   R                   SU R                   SU R                   SU R                   SU R
                   SU R                   SU R                   S3$ )Nz(kernel_type=z, fmap_size=
, in_dims=z, out_dims=z, do_gmask=z, do_l2=r   )rP   re   r   r   r   r   r   r   rf   s    r+   rg    ExplicitSpacialEncoding.__repr__e  sv    ~~&&' (++, -( )||n % ' 'ZZL#	
r-   )
r   r   r   r   r   r   r   r   r   r   )r   r      TT)re   rj   rk   rl   rm   rn   r   r   rL   r   r7   rW   r   r   r   ra   rg   ro   rp   rq   s   @r+   r   r     s    : #&+&+ &+ 	&+
 &+ &+ 
&+ &+Pu   5u||!;<   %,, 	
# 	
 	
r-   r   c                   2  ^  \ rS rSrSr   SS\S\\\\\\R                  4   4   S4   S\
S\
S\
S	\S
S4U 4S jjjrS\\\\\R                  4   4   S
S4S jrSS jrSS jrSS jrSS jrS\R                  S
\R                  4S jrS
\4S jrSrU =r$ )	Whiteningiq  a  nn.Module, performs supervised or unsupervised whitening.

This is based on the paper "Understanding and Improving Kernel Local Descriptors".
See :cite:`mukundan2019understanding` for more details.

Args:
    xform: Variant of whitening to use. None, 'lw', 'pca', 'pcaws', 'pcawt'.
    whitening_model: Dictionary with keys 'mean', 'eigvecs', 'eigvals' holding Tensors.
    in_dims: Dimensionality of input descriptors.
    output_dims: (int) Dimensionality reduction.
    keval: Shrinkage parameter.
    t: Attenuation parameter.

Returns:
    l2-normalized, whitened descriptors.

Shape:
    - Input: (B, in_dims, fmap_size, fmap_size)
    - Output: (B, out_dims, fmap_size, fmap_size)

Examples:
    >>> descs = torch.rand(23, 238)
    >>> whitening_model = {'pca': {'mean': torch.zeros(238),
    ...                            'eigvecs': torch.eye(238),
    ...                            'eigvals': torch.ones(238)}}
    >>> whitening = Whitening(xform='pcawt',
    ...                       whitening_model=whitening_model,
    ...                       in_dims=238,
    ...                       output_dims=128,
    ...                       keval=40,
    ...                       t=0.7)
    >>> wdescs = whitening(descs) # 23x128

xformwhitening_modelNr   output_dimskevaltr   c                   > [         TU ]  5         Xl        X0l        XPl        X`l        SU l        [        XC5      nX@l        [        R                  " [        R                  " U5      SS9U l        [        R                  " [        R                  " U5      S S 2S U24   SS9U l        [        R                  " [        R                   " U5      S U SS9U l        Ub  U R%                  U5        g g )Nr   T)requires_grad)rK   rL   r   r   r   r   pvalminr   r   	Parameterr7   r   meaneyeevecsr~   evalsload_whitening_parameters)rO   r   r   r   r   r   r   rP   s          r+   rL   Whitening.__init__  s     	

	 +/& LLW!5TJ	\\%))G"4Q_"EUYZ
\\%**W"5l{"CSWX
&**?; 'r-   c                 p   U R                   S:X  a  SOSnX   nUS   U R                  l        US   S S 2S U R                  24   U R                  l        US   S U R                   U R
                  l        U R                  U R                  U R                  U R                  S.nX@R                      " 5         g )Nlwpcar   eigvecseigvals)r   r   pcawspcawt)
r   r   datar   r   r   _modify_pca
_modify_lw_modify_pcaws_modify_pcawt)rO   r   algowh_modelmodificationss        r+   r   #Whitening.load_whitening_parameters  s    zzT)tu"(!&)		"9-a1C43C3C1C.CD

"9-.@0@0@A

 ##//''''	
 	jj!#r-   c                     SU l         g)zModify powerlaw parameter.g      ?N)r   rf   s    r+   r   Whitening._modify_pca  s	    	r-   c                     g)zNo modification required.N rf   s    r+   r  Whitening._modify_lw  s    r-   c                     U R                   U R                     nSU-
  U R                   -  U-   nU R                  [        R                  " [        R
                  " US5      5      -  U R                  l        g)zShrinkage for eigenvalues.r$         N)r   r   r   r7   diagpowr   )rO   alphar   s      r+   r  Whitening._modify_pcaws  sS    

4::&e)tzz)U2**uzz%))E42H'II

r-   c                     SU R                   -  nU R                  [        R                  " [        R                  " U R
                  U5      5      -  U R                  l        g)zAttenuation for eigenvalues.r  N)r   r   r7   r  r  r   r   )rO   ms     r+   r  Whitening._modify_pcawt  s;    466M**uzz%))DJJ2J'KK

r-   r%   c                    [        U[        R                  5      (       d  [        S[	        U5       35      e[        UR                  5      S:X  d  [        SUR                   35      eXR                  -
  nXR                  -  n[        R                  " U5      [        R                  " [        R                  " U5      U R                  5      -  n[        R                  " USS9$ )NrS   r3   z)Invalid input shape, we expect NxD. Got: r$   r4   )rV   r7   rW   rX   rY   rZ   r[   r\   r   r   signr  absr   r   r   rO   r%   s     r+   ra   Whitening.forward  s    !U\\**DT!WINOO177|q H	RSS		M

NJJqMEIIeiilDII>>{{1!$$r-   c                     U R                   R                   SU R                   SU R                   SU R                   S3$ )Nz(xform=r   , output_dims=r   )rP   re   r   r   r   rf   s    r+   rg   Whitening.__repr__  s>    ..))*'$**Z~Ucdhdtdtcuuvwwr-   )	r   r   r   r   r   r   r   r   r   )   (   gffffff?ri   )re   rj   rk   rl   rm   rn   r   r   r7   rW   r   r   rL   r   r   r  r  r  ra   rg   ro   rp   rq   s   @r+   r   r   q  s    !P << tCc5<<.?)@$@A4GH< 	<
 < < < 
< <:$c4U\\HYCZ>Z9[ $`d $"(JL
% %%,, %x# x xr-   r   c                      ^  \ rS rSrSr     SS\S\S\S\S\SS	4U 4S
 jjjrS\R                  S\R                  4S jr
S\4S jrSrU =r$ )MKDDescriptori  aC  nn.Module that computes Multiple Kernel local descriptors.

This is based on the paper "Understanding and Improving Kernel Local Descriptors".
See :cite:`mukundan2019understanding` for more details.

Args:
    patch_size: Input patch size in pixels.
    kernel_type: Parametrization of kernel ``'concat'``, ``'cart'``, ``'polar'``.
    whitening: Whitening transform to apply ``None``, ``'lw'``, ``'pca'``, ``'pcawt'``, ``'pcaws'``.
    training_set: Set that model was trained on ``'liberty'``, ``'notredame'``, ``'yosemite'``.
    output_dims: Dimensionality reduction.

Returns:
    Explicit cartesian or polar embedding.

Shape:
    - Input: :math:`(B, in_{dims}, fmap_{size}, fmap_{size})`.
    - Output: :math:`(B, out_{dims}, fmap_{size}, fmap_{size})`,

Examples:
    >>> patches = torch.rand(23, 1, 32, 32)
    >>> mkd = MKDDescriptor(patch_size=32,
    ...                     kernel_type='concat',
    ...                     whitening='pcawt',
    ...                     training_set='liberty',
    ...                     output_dims=128)
    >>> desc = mkd(patches) # 23x128

r   r   	whiteningtraining_setr   r   Nc                   > [         TU ]  5         Xl        X l        X0l        X@l        SUS-  -  U l        [        SU R                  U R                  4S5      U l        [        5       U l
        SnSnU R                  S:X  a  Xg/OU R                  /U l        SU l        US	US
0n0 U l        U R                   Ho  n	[        XU	   S9n
[        XU
R                   R"                  S9n[$        R&                  " X5      U R                  U	'   U =R                  UR                  -  sl        Mq     [)        XPR                  5      U l        U R                  b|  [,        R.                  R1                  [2        U R                     [,        R4                  " S5      S9nX   n[7        X=U R                  U R*                  S9U l        U R*                  U l        U R;                  5         g )Nffffff?@      r(  	replicater   r   r   r   TFr   r   r   r   r   cpumap_locationr   r   )rK   rL   r   r   r"  r#  r   r
   	smoothingrC   	gradientsparametrizationsr   featsr   r   r   r}   r   
Sequentialr   r   r7   hubload_state_dict_from_urlr   devicer   whitening_layereval)rO   r   r   r"  r#  r   polar_scart_srelative_orientationsparametrizationgradient_embeddingspatial_encodingwhitening_modelsr   rP   s                 r+   rL   MKDDescriptor.__init__  s    	) +'!-JO,
'TZZ0H+V%595E5E5Q 1X\XhXhWi 
!($ >
#44O!/:fuPv!w6+K]KdKdKfKf  +---8J*]DJJ'JJ*000J  5 !$K < >>%$yyAAT%%&U\\%5H  B   /<O#,DJJDL\L\$D  ))DJ		r-   patchesc                 j   [        U[        R                  5      (       d  [        S[	        U5       35      e[        UR                  5      S:X  d  [        SUR                   35      eU R                  U5      nU R                  U5      n/ nU R                   HO  nU R                  U   R                  UR                  5        UR                  U R                  U   " U5      5        MQ     [        R                  " USS9n[         R"                  " USS9nU R$                  b  U R'                  U5      nU$ )NrS   rT   rU   r$   r4   )rV   r7   rW   rX   rY   rZ   r[   r\   r0  r1  r2  r3  r<   r7  appendr]   r   r   r"  r8  )rO   rB  gfeaturesr=  r&   s         r+   ra   MKDDescriptor.forward4  s    '5<<00DT']OTUU7==!Q&LW]]O\]]NN7#NN1 #44OJJ'**1884OODJJ7:;  5
 IIhA& KKq! >>%$$Q'Ar-   c                     U R                   R                   SU R                   SU R                   SU R                   SU R
                   SU R                   S3$ )Nr   z, kernel_type=z, whitening=z, training_set=r  r   )rP   re   r   r   r"  r#  r   rf   s    r+   rg   MKDDescriptor.__repr__O  so    ~~&&' (//* +++, -( ) --. /++,A/	
r-   )r3  r1  r   r   r   r2  r   r   r0  r#  r"  r8  )r   r   r   libertyr  )re   rj   rk   rl   rm   r   rn   rL   r7   rW   ra   rg   ro   rp   rq   s   @r+   r!  r!    s    @ # %00 0 	0
 0 0 
0 0du||  6
# 
 
r-   r!  r#  c                     [         R                  R                  [        U    [         R                  " S5      S9nX!   nU$ )zLoad whitening model.r,  r-  )r7   r5  r6  r   r7  )r   r#  r@  r   s       r+   load_whitening_modelrL  Z  s<    yy99${:KZ_ZfZfglZm9n&4Or-   c                      ^  \ rS rSrSr     SS\S\S\S\S\SS	4U 4S
 jjjrS\R                  S\R                  4S jr
SrU =r$ )SimpleKDia  z+Example to write custom Kernel Descriptors.r   r   r"  r#  r   r   Nc                 >  > [         TU ]  5         US:H  nSUS-  -  nXl        [        SXw4S5      n[	        5       n	[        XS9n
[        X!U
R                  R                  S9n[        U[        X$5      UR                  US9n[        R                  " XXU5      U l        g )	Nr   r%  r&  r'  r)  r*  r+  r/  )rK   rL   r   r
   rC   r   r   r   r}   r   rL  r   r   r4  rF  )rO   r   r   r"  r#  r   r   r   r0  r1  oriesewhrP   s                r+   rL   SimpleKD.__init__d  s     	$/j2o.$"6E>;G	 N	
F%+]`]g]g]i]ij+KFPSPYPYgr
 iCbIr-   r%   c                 $    U R                  U5      $ rd   )rF  r  s     r+   ra   SimpleKD.forward|  s    }}Qr-   )rF  r   )r   r   r   rJ  r  )re   rj   rk   rl   rm   r   rn   rL   r7   rW   ra   ro   rp   rq   s   @r+   rN  rN  a  s    5 " %JJ J 	J
 J J 
J J0   %,,    r-   rN  )r   )+typingr   r   r   r   r   r7   torch.nn.functionalr   
functionalr   kornia.constantsr	   kornia.filtersr
   r   kornia.geometry.conversionsr   kornia.geometry.gridr   r   r   __annotations__r   r   r   r   rn   r   r   rW   r,   rA   ModulerC   rs   r   r   r   r   r!  rL  rN  )r   s   0r+   <module>r_     s  $ 1 0      : 0 0 "u !'4d5k 4>d5k >Jd5k J(4Wc!dS$u+ d )( 	LQCwWW(d38n c 4U\\0A+B &s & & &+'299 +'\CxRYY CxL6dRYY 6dr# d3;L6M RWR^R^ >g
bii g
Tox		 oxdt
BII t
nc  c3h  ryy  {s   ?F