+
    åûjûy  ã                   ó„  a€ R( t)0 t ^ RIt^ RIHtHtHtHtHt ^ RIt^ RIH	t	 ^ RI
Ht ^ RIHt ^ RIHt ^ RIHtHt ^ RIHt ^ R	IHt R
t] ^ k RR.t] ^k . R)Ot] ^k . R*Ot] ^k R]R]R]/t] ^k R+ U u/ uF
  p V RV  R2bK  	  up t] ^k R,R R lltR R lt ! R R]	P>                  4      t  ! R R]	P>                  4      t! ! R R]	P>                  4      t"R R lt# ! R R]	P>                  4      t$ ! R  R!]	P>                  4      t% ! R" R#]	P>                  4      t&R$ R% lt' ! R& R']	P>                  4      t(R# u up i )-é    N)ÚAnyÚDictÚListÚTupleÚUnion)Únn)ÚKORNIA_CHECK_SHAPE)Úload_state_dict_from_url)Ú_l2_normalize)ÚGaussianBlur2dÚSpatialGradient)Úcart2pol)Úcreate_meshgridgÍ;fž ö?gp©ßuØ?g ·"ÇÞ?ÚxyÚrhophiÚthetazChttps://github.com/manyids2/mkd_pytorch/raw/master/mkd_pytorch/mkd-z-64.pthc                óf   € V ^8„  d   QhR\         R\        \        \        P                  3,          /# )é   Ú
patch_sizeÚreturn)Úintr   ÚstrÚtorchÚTensor)Úformats   "ÚNC:\Ai_Coding\apps\studio\ComfyUI\.venv\Lib\site-packages\kornia\feature\mkd.pyÚ__annotate__r   ,   s(   € ÷ 4ñ 4œcð 4¬4´´U·\±\Ð0AÕ+Bñ 4ó    c                ón   € \        W RR7      pVR,          pVR,          p\        W#4      w  rERVRVRVRV/# )	z1Get cartesian and polar parametrizations of grid.T©ÚheightÚwidthÚnormalized_coordinatesÚxÚyÚrhoÚphi)r   ºNNNr(   r   )r   r(   r(   é   )r   r   )r   Úkgridr$   r%   r&   r'   s   &     r   Úget_grid_dictr+   ,   sE   € ä :ÐX\Ô]€EØˆjÕ€AØˆjÕ€AÜ˜‹~�H€CØ��C˜˜E 3¨¨sÐ3Ð3r   c                óP   € V ^8„  d   QhR\         R\         R\        P                  /# )r   Úd1Úd2r   )r   r   r   )r   s   "r   r   r   5   s%   € ÷ &ñ &”sð &¤ð &¬¯©ñ &r   c                ó  € \         P                  ! \         P                  ! V 4      \         P                  ! V4      RR7      w  r#\         P                  ! W#.^R7      P	                  R^4      pVP                  \         P                  4      # )z&Get order for doing kronecker product.Úij)Úindexing©Údiméÿÿÿÿ)r   ÚmeshgridÚarangeÚstackÚreshapeÚtoÚint64)r-   r.   Úgrid_d1Úgrid_d2Ú
kron_orders   &&   r   Úget_kron_orderr>   5   s]   € ä—~’~¤e§l¢l°2Ó&6¼¿ºÀRÓ8HÐSWÔXÑ€GÜ—’˜gÐ/°QÔ7×?Ñ?ÀÀAÓF€JØ�=‰=œŸ™Ó%Ð%r   c                   óf   a a€ ] tR t^<t oRtV3R lV 3R lltV3R lR ltV3R lR ltRtVt	V ;t
# )	ÚMKDGradientsa[  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

c                ó   <€ V ^8„  d   QhRR/# ©r   r   N© )r   Ú__classdict__s   "€r   r   ÚMKDGradients.__annotate__T   s   ø€ ÷ Lñ L˜$ñ Lr   c                óX   <€ \         SV `  4        R V n        \        R^RR7      V n        R# )ç:Œ0âŽyE>ÚdiffF)ÚmodeÚorderÚ
normalizedN)ÚsuperÚ__init__Úepsr   Úgrad)ÚselfÚ	__class__s   &€r   rM   ÚMKDGradients.__init__T   s%   ø€ Ü‰ÑÔØˆŒä#¨°qÀUÔKˆŽ	r   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# ©r   r$   r   ©r   r   )r   rD   s   "€r   r   rE   Z   s#   ø€ ÷ <ñ <™Ÿ™ð <©%¯,©,ñ <r   c                ót  € \        V\        P                  4      '       g   \        R\	        V4       24      h\        VP                  4      ^8X  g   \        RVP                   24      hV P                  V4      ) pVR,          pVR,          p\        P                  ! \        W4V P                  4      ^R7      # )aƒ  Compute gradient magnitude and orientation channels for grayscale patches.

Args:
    x: Patch tensor with shape ``(B, 1, H, W)``, where ``B`` is batch size,
        ``1`` is the grayscale channel, and ``H``/``W`` are patch height and width.

Returns:
    Tensor with shape ``(B, 2, H, W)``. Channel 0 stores gradient magnitude,
    and channel 1 stores gradient orientation in radians.
ú&Input type is not a torch.Tensor. Got ú-Invalid input shape, we expect Bx1xHxW. Got: r2   )r(   r(   r   r(   r(   )r(   r(   r)   r(   r(   )Ú
isinstancer   r   Ú	TypeErrorÚtypeÚlenÚshapeÚ
ValueErrorrO   Úcatr   rN   )rP   r$   Úgrads_xyÚgxÚgys   &&   r   ÚforwardÚMKDGradients.forwardZ   s’   € ô ˜!œUŸ\™\×*Ò*ÜÐDÄTÈ!ÃWÀIÐNÓOÐOÜ�1—7‘7‹|˜qÔ ÜÐLÈQÏWÉWÈIÐVÓWÐWà—I‘I˜a“L�=ˆØ�mÕ$ˆØ�mÕ$ˆÜ�yŠyœ "¨$¯(©(Ó3¸Ô;Ð;r   c                ó    <€ V ^8„  d   QhRS[ /# ©r   r   ©r   )r   rD   s   "€r   r   rE   o   s   ø€ ÷ 'ñ '™#ñ 'r   c                ó.   € V P                   P                  # )N)rQ   Ú__name__©rP   s   &r   Ú__repr__ÚMKDGradients.__repr__o   s   € Ø�~‰~×&Ñ&Ð&r   )rN   rO   ©ri   Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__rM   rc   rk   Ú__static_attributes__Ú__classdictcell__Ú__classcell__©rQ   rD   s   @@r   r@   r@   <   s/   ù‡ € ñ÷.Ló L÷<ð <÷*'÷ 'ð 'r   r@   c                   óf   a a€ ] tR t^st oRtV3R lV 3R lltV3R lR ltV3R lR ltRtVt	V ;t
# )	ÚVonMisesKernela“  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

c          	      ó�   <€ V ^8„  d   QhRS[ RS[S[S[S[S[ 3,          ,          S[S[S[S[ 3,          R3,          3,          RR/# )r   r   Úcoeffs.r   N)r   r   r   Úfloatr   )r   rD   s   "€r   r   ÚVonMisesKernel.__annotate__‹   sS   ø€ ÷ 1ñ 1¡3ð 1±±d¹5ÁÉÀÕ;LÕ6MÉuÑUZÑ[`ÑbeÐ[eÕUfÐhkÐUkÕOlÐ6lÕ0mð 1Ðrvñ 1r   c                óÔ  <€ \         SV `  4        Wn        \        P                  ! V4      pV P                  R V4       \        V4      ^,
          pW@n        ^V,          ^,           V n        \        P                  ! ^^W.4      p\        P                  ! V4      ^,           pVP                  R^^4      p\        P                  ! ^V,          ^,           .4      p\        P                  ! V4      VRV^,           % \        P                  ! VR,          4      Wt^,           R% VP                  R^^4      pV P                  RV4       V P                  RV4       V P                  RV4       R# )ry   Nºr)   NNÚemb0ÚfrangeÚweightsr4   )rL   rM   r   r   ÚtensorÚregister_bufferr\   ÚnÚdÚonesr6   r8   ÚzerosÚsqrt)	rP   r   ry   Úb_coeffsrƒ   r~   r   r€   rQ   s	   &&&     €r   rM   ÚVonMisesKernel.__init__‹   s  ø€ Ü‰ÑÔà$ŒÜ—<’< Ó'ˆØ×Ñ˜X xÔ0ô �‹K˜!�OˆØŒØ�Q•˜•ˆŒô �zŠz˜1˜a Ð8Ó9ˆÜ—’˜a“ 1Õ$ˆØ—‘  A qÓ)ˆÜ—+’+˜q 1�u q�y˜kÓ*ˆÜ Ÿ:š: hÓ/ˆ��!�a•%ÐÜ Ÿ:š: h¨r¥lÓ3ˆ�A•�ÐØ—/‘/ " a¨Ó+ˆØ×Ñ˜V TÔ*Ø×Ñ˜X vÔ.Ø×Ñ˜Y¨Ö0r   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# rT   rU   )r   rD   s   "€r   r   r{   £   s#   ø€ ÷ (ñ (™Ÿ™ð (©%¯,©,ñ (r   c                óô  € \        V\        P                  4      '       g   \        R\	        V4       24      h\        VP                  4      ^8X  d   VP                  ^,          ^8w  d   \        RVP                   24      h\        V P                  \        P                  4      '       g   \        R\	        V4       24      hV P                  P                  V4      P                  VP                  ^ 4      ^^^4      pV P                  P                  V4      V,          p\        P                  ! V4      p\        P                  ! V4      p\        P                  ! W$V.^R7      pV P                   V,          # )aE  Embed orientation values with the Von Mises kernel basis.

Args:
    x: Orientation tensor with shape ``(B, 1, H, W)``, where values are
        angular orientations in radians.

Returns:
    Kernel embedding with shape ``(B, D, H, W)``, where ``D`` is the
    number of channels produced by the configured coefficient list.
rW   rX   z%Emb0 type is not a torch.Tensor. Got r2   )rY   r   r   rZ   r[   r\   r]   r^   r~   r9   ÚrepeatÚsizer   ÚcosÚsinr_   r€   )rP   r$   r~   r   Úemb1Úemb2Ú	embeddings   &&     r   rc   ÚVonMisesKernel.forward£   s  € ô ˜!œUŸ\™\×*Ò*ÜÐDÄTÈ!ÃWÀIÐNÓOÐOä�1—7‘7‹|˜qÔ  A§G¡G¨A¥J°!¤OÜÐLÈQÏWÉWÈIÐVÓWÐWä˜$Ÿ)™)¤U§\¡\×2Ò2ÜÐCÄDÈÃGÀ9ÐMÓNÐNà�y‰y�|‰|˜A‹×%Ñ% a§f¡f¨Q£i°°A°qÓ9ˆØ—‘—‘ Ó" QÕ&ˆÜ�yŠy˜Ó ˆÜ�yŠy˜Ó ˆÜ—I’I˜t¨4Ð0°aÔ8ˆ	Ø�|‰|˜iÕ'Ð'r   c                ó    <€ V ^8„  d   QhRS[ /# rf   rg   )r   rD   s   "€r   r   r{   ¾   ó   ø€ ÷ xñ x™#ñ xr   c           
     óœ   € V P                   P                   R V P                   RV P                   RV P                   RV P
                   R2
# )ú(patch_size=z, n=z, d=z	, coeffs=Ú))rQ   ri   r   rƒ   r„   ry   rj   s   &r   rk   ÚVonMisesKernel.__repr__¾   sN   € Ø—.‘.×)Ñ)Ð*¨,°t·±Ð6GÀtÈDÏFÉFÈ8ÐSWÐX\×X^ÑX^ÐW_Ð_hÐim×itÑitÐhuÐuvÐwÐwr   )r„   rƒ   r   rm   ru   s   @@r   rw   rw   s   s0   ù‡ € ñ÷.1ó 1÷0(ð (÷6x÷ xð xr   rw   c                   ó|   a a€ ] tR t^Ât oRtRV3R lV 3R llltV3R lR ltV3R lR ltV3R lR	 ltR
t	Vt
V ;t# )ÚEmbedGradientsa  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

c                ó*   <€ V ^8„  d   QhRS[ RS[RR/# )r   r   Úrelativer   N)r   Úbool)r   rD   s   "€r   r   ÚEmbedGradients.__annotate__Ø   s"   ø€ ÷ )ñ )¡3ð )±tð )Èñ )r   c                óú   <€ \         SV `  4        Wn        W n        R V n        \        V\        R,          R7      V n        \        WRR7      p\        VR,          VR,          4      w  rEV P                  RV4       R# )	rG   r   ©r   ry   Tr    r'   N)r(   r(   r(   r   )r(   r(   r(   r)   )rL   rM   r   r�   rN   rw   ÚCOEFFSÚkernelr   r   r‚   )rP   r   r�   r*   Ú_r'   rQ   s   &&&   €r   rM   ÚEmbedGradients.__init__Ø   sj   ø€ Ü‰ÑÔØ$ŒØ ŒØˆŒô %°
Ä6È'Å?ÔSˆŒô   zÐ\`ÔaˆÜ˜% 
Õ+¨U°:Õ->Ó?‰ˆØ×Ñ˜U CÖ(r   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# )r   Úmagsr   rU   )r   rD   s   "€r   r   rŸ   æ   s#   ø€ ÷ +ñ +™UŸ\™\ð +©e¯l©lñ +r   c                óN   € \         P                  ! WP                  ,           4      # )z@Embed square roots of magnitudes with eps for numerical reasons.)r   r‡   rN   )rP   r§   s   &&r   Úemb_magsÚEmbedGradients.emb_magsæ   s   € ä�zŠz˜$§¡�/Ó*Ð*r   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# )r   Úgradsr   rU   )r   rD   s   "€r   r   rŸ   ê   s#   ø€ ÷ 7ñ 7™UŸ\™\ð 7©e¯l©lñ 7r   c                ó¬  € \        V\        P                  4      '       g   \        R\	        V4       24      h\        VP                  4      ^8X  g   \        RVP                   24      hVR,          pVR,          pV P                  '       d"   W0P                  P                  V4      ,
          pV P                  V4      V P                  V4      ,          # )ag  Embed gradient magnitude and orientation into kernel descriptor channels.

Args:
    grads: Gradient tensor with shape ``(B, 2, H, W)``. Channel 0 contains
        magnitudes, and channel 1 contains orientations.

Returns:
    Embedded gradient tensor with shape ``(B, D, H, W)``, where ``D`` is
    the number of channels produced by the orientation kernel.
rW   z-Invalid input shape, we expect Bx2xHxW. Got: )r(   :Nr)   Nr(   r(   )r(   r}   r(   r(   )rY   r   r   rZ   r[   r\   r]   r^   r�   r'   r9   r£   r©   )rP   r¬   r§   Úoriss   &&  r   rc   ÚEmbedGradients.forwardê   s£   € ô ˜%¤§¡×.Ò.ÜÐDÄTÈ%Ã[ÀMÐRÓSÐSÜ�5—;‘;Ó 1Ô$ÜÐLÈUÏ[É[ÈMÐZÓ[Ð[Ø�[Õ!ˆØ�[Õ!ˆØ�=�=ˆ=ØŸ(™(Ÿ+™+ dÓ+Õ+ˆDØ�{‰{˜4Ó  4§=¡=°Ó#6Õ6Ð6r   c                ó    <€ V ^8„  d   QhRS[ /# rf   rg   )r   rD   s   "€r   r   rŸ   ÿ   s   ø€ ÷ dñ d™#ñ dr   c                óh   € V P                   P                   R V P                   RV P                   R2# )r—   z, relative=r˜   )rQ   ri   r   r�   rj   s   &r   rk   ÚEmbedGradients.__repr__ÿ   s4   € Ø—.‘.×)Ñ)Ð*¨,°t·±Ð6GÀ{ÐSW×S`ÑS`ÐRaÐabÐcÐcr   )rN   r£   r   r�   )é    F)ri   rn   ro   rp   rq   rM   r©   rc   rk   rr   rs   rt   ru   s   @@r   r›   r›   Â   s:   ù‡ € ñ÷*)õ )÷+ð +÷7ð 7÷*d÷ dð dr   r›   c                ó†   € V ^8„  d   QhR\         R\        \         \        P                  3,          R\        P                  /# )r   Úkernel_typeÚgridsr   )r   r   r   r   )r   s   "r   r   r     s;   € ÷ ]ñ ]¬#ð ]´d¼3ÄÇÁÐ;LÕ6Mð ]ÔRW×R^ÑR^ñ ]r   c           	     óö  € RRR\         P                  \        ,          R\         P                  ^,          R\         P                  ^,          /pV R8X  d   RpRR.pMV R8X  d   R	pRR.p\        VP	                  4       4      pW^ ,          ,          P
                  R,          pVP                  4        UUu/ uF  w  rxWxW',          ,          bK  	  p	ppV	P                  4        UUu/ uF3  w  rxWxP                  ^ 4      P                  ^ 4      P                  4       bK5  	  p	pp\        V\        X,          R
7      p
\        V\        V,          R
7      pV
! V	X^ ,          ,          4      P                  4       pV! W”^,          ,          4      P                  4       p\        V
P                  VP                  4      pVP                  ^ VR,          4      VP                  ^ VR,          4      ,          # u uppi u uppi )z<Compute embeddings for cartesian and polar parametrizations.r'   ç      ð?r&   r$   r%   Úcartr   Úpolarr   r¡   r4   ©r(   r   ©r(   r)   )ÚmathÚpiÚsqrt2ÚlistÚkeysr]   ÚitemsÚ	unsqueezerz   rw   r¢   Úsqueezer>   r„   Úindex_select)rµ   r¶   ÚfactorsÚcoeffs_Úparams_rÁ   r   ÚkÚvÚgrids_normedÚvm_aÚvm_bÚemb_aÚemb_br=   s   &&             r   Úspatial_kernel_embeddingrÐ     s“  € à�c˜5¤$§'¡'¬E¥/°3¼¿¹À!½ÀSÌ$Ï'É'ÐTUÍ+ÐV€GØ�fÔØˆØ˜�*‰Ø	˜Ô	ØˆØ˜%�.ˆô �—
‘
“Ó€DØ˜A•w•×%Ñ% bÕ)€Jð 38·+±+´-Ô@±-©$¨!�A˜7�:•~Ò%±-€LÑ@ØGS×GYÑGYÔG[Ô\ÑG[¹t¸q�A—{‘{ 1“~×/Ñ/°Ó2×8Ñ8Ó:Ò:ÑG[€LÑ\ô  Z¼¸w½ÔH€DÜ Z¼¸w½ÔH€Dá�˜g a�jÕ)Ó*×2Ñ2Ó4€EÙ� a�jÕ)Ó*×2Ñ2Ó4€Eô   §¡¨¯©Ó/€JØ×Ñ˜a ¨DÕ!1Ó2°U×5GÑ5GÈÈ:ÐVZÕK[Ó5\Õ\Ð\ùó AùÛ\s   Â5G/Ã%9G5c                   óŽ   a a€ ] tR tRt oRtRV3R lV 3R llltV3R lR ltV3R lR ltV3R	 lR
 ltV3R lR lt	Rt
VtV ;t# )Ú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

c                ó<   <€ V ^8„  d   QhRS[ RS[RS[RS[RS[RR/# )r   rµ   Ú	fmap_sizeÚin_dimsÚdo_gmaskÚdo_l2r   N)r   r   rž   )r   rD   s   "€r   r   Ú$ExplicitSpacialEncoding.__annotate__=  sG   ø€ ÷ &+ñ &+áð&+ñ ð&+ñ ð	&+ñ
 ð&+ñ ð&+ð 
ñ&+r   c                ó²  <€ \         S	V `  4        VR9  d   \        V R24      hWn        W n        W0n        W@n        WPn        \        V4      V n	        RV n
        \        V P                  V P                  4      pV P                  '       d*   V P                  RR7      V n
        W`P                  ,          pV P                  RVP                  ^ 4      4       VP                  ^ ,          V n        V P
                  V P                   ,          V n        V P"                  V n        V P'                  4       w  rxV P                  RV4       V P                  RV4       R# )	rº   z" is not valid, use polar or cart).Nr¸   )ÚsigmaÚembr‘   Úidx1)rº   r¹   )rL   rM   ÚNotImplementedErrorrµ   rÔ   rÕ   rÖ   r×   r+   ÚgridÚgmaskrÐ   Ú	get_gmaskr‚   rÃ   r]   Úd_embÚout_dimsÚodimsÚ	init_kron)
rP   rµ   rÔ   rÕ   rÖ   r×   rÛ   r‘   rÜ   rQ   s
   &&&&&&   €r   rM   Ú ExplicitSpacialEncoding.__init__=  s  ø€ ô 	‰ÑÔàÐ/Ô/Ü%¨¨Ð5WÐ&XÓYÐYà&ÔØ"ŒØŒØ ŒØŒ
Ü! )Ó,ˆŒ	ØˆŒ
ô ' t×'7Ñ'7¸¿¹ÓCˆð �=�=ˆ=ØŸ™¨c˜Ó2ˆDŒJØŸ
™
Õ"ˆCð 	×Ñ˜U C§M¡M°!Ó$4Ô5ØŸ)™) A�,ˆŒ
Ø!Ÿ\™\¨D¯J©JÕ6ˆŒØŸ-™-ˆŒ
ð —^‘^Ó%‰
ˆØ×Ñ˜V TÔ*Ø×Ñ˜V TÖ*r   c                ó:   <€ V ^8„  d   QhRS[ RS[P                  /# )r   rÚ   r   )rz   r   r   )r   rD   s   "€r   r   rØ   e  s   ø€ ÷ 6ñ 6™uð 6©¯©ñ 6r   c                óØ   € V P                   R,          V P                   R,          P                  4       ,          p\        P                  ! RV^,          ,          V^,          ,          4      # )zCompute Gaussian mask.r&   r4   )rÞ   Úmaxr   Úexp)rP   rÚ   Únorm_rhos   && r   rà   Ú!ExplicitSpacialEncoding.get_gmaske  sH   € à—9‘9˜UÕ# d§i¡i°Õ&6×&:Ñ&:Ó&<Õ<ˆÜ�yŠy˜˜h¨�kÕ)¨E°1­HÕ4Ó5Ð5r   c                ó^   <€ V ^8„  d   QhRS[ S[P                  S[P                  3,          /# rf   )r   r   r   )r   rD   s   "€r   r   rØ   j  s&   ø€ ÷  ñ  ™5¡§¡©u¯|©|Ð!;Õ<ñ  r   c                ó  € \        V P                  V P                  4      p\        P                  P                  \        P                  V P                  4      p\        P                  ! V^VR,          4      pW1R,          3# )z3Initialize helper variables to calculate kronecker.r¼   r»   )	r>   rÕ   rá   r   ÚjitÚannotater   rÛ   rÅ   )rP   ÚkronÚ_embr‘   s   &   r   rä   Ú!ExplicitSpacialEncoding.init_kronj  sY   € ä˜dŸl™l¨D¯J©JÓ7ˆÜ�y‰y×!Ñ!¤%§,¡,°·±Ó9ˆÜ×!Ò! $¨¨4°­:Ó6ˆØ˜$•ZÐÐr   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# rT   rU   )r   rD   s   "€r   r   rØ   q  s#   ø€ ÷ ñ ™Ÿ™ð ©%¯,©,ñ r   c                ó"  € \        V\        P                  4      '       g   \        R\	        V4       24      h\        VP                  4      ^8X  d#   VP                  ^,          V P                  8X  g&   \        RV P                   RVP                   24      h\        P                  P                  \        P                  V P                  4      p\        P                  ! VP                  VP                  4      p\        P                  ! VP                  ^4      P!                  V4      VP                  ^4      P#                  ^^4      P!                  V4      4      pVP                  ^4      pV P$                  '       d   \'        V^R7      pV# )aX  Apply explicit spatial encoding to embedded patch features.

Args:
    x: Feature map with shape ``(B, C, H, W)``, where ``C`` must match
        ``in_dims`` and ``H``/``W`` are expected to match ``fmap_size``.

Returns:
    Encoded descriptor tensor with shape ``(B, D)``, where ``D`` is the
    flattened spatial-kernel descriptor dimension.
rW   z!Invalid input shape, we expect BxzxHxW. Got: r2   )rY   r   r   rZ   r[   r\   r]   rÕ   r^   rî   rï   rÛ   Úpromote_typesÚdtypeÚmatmulÚflattenr9   Ú	transposer×   r   )rP   r$   rÛ   rö   Úoutputs   &&   r   rc   ÚExplicitSpacialEncoding.forwardq  s  € ô ˜!œUŸ\™\×*Ò*ÜÐDÄTÈ!ÃWÀIÐNÓOÐOÜ�Q—W‘W“ Ô"¨¯©°­°t·|±|Ô)CÜÐ@ÀÇÁÀÈkÐZ[×ZaÑZaÐYbÐcÓdÐdô �i‰i× Ñ ¤§¡¨t¯x©xÓ8ˆÜ×#Ò# A§G¡G¨S¯Y©YÓ7ˆÜ—’˜aŸi™i¨›lŸo™o¨eÓ4°c·k±kÀ!³n×6NÑ6NÈqÐRSÓ6T×6WÑ6WÐX]Ó6^Ó_ˆØ—‘ Ó"ˆØ�:�:ˆ:Ü" 6¨qÔ1ˆFØˆr   c                ó    <€ V ^8„  d   QhRS[ /# rf   rg   )r   rD   s   "€r   r   rØ   �  s   ø€ ÷ 	
ñ 	
™#ñ 	
r   c                óÐ   € V P                   P                   R V P                   RV P                   RV P                   RV P
                   RV P                   RV P                   R2# )z(kernel_type=z, fmap_size=ú
, in_dims=z, out_dims=z, do_gmask=z, do_l2=r˜   )rQ   ri   rµ   rÔ   rÕ   râ   rÖ   r×   rj   s   &r   rk   Ú ExplicitSpacialEncoding.__repr__�  sv   € à�~‰~×&Ñ&Ð'ð (Ø×+Ñ+Ð,ð -ØŸ™Ð(ð )Ø—|‘|�nð %ØŸ™�ð 'ØŸ™�ð 'Ø—Z‘Z�L ð#ð	
r   )
rá   rÖ   r×   rÔ   rß   rÞ   rÕ   rµ   rã   râ   )rº   r³   é   TT)ri   rn   ro   rp   rq   rM   rà   rä   rc   rk   rr   rs   rt   ru   s   @@r   rÒ   rÒ   !  sB   ù‡ € ñ÷6&+õ &+÷P6ð 6÷
 ð  ÷ð ÷8	
÷ 	
ð 	
r   rÒ   c                   óÄ   a a€ ] tR tRt oRtRV3R lV 3R llltV3R lR ltV3R lR ltV3R	 lR
 ltV3R lR lt	V3R lR lt
V3R lR ltV3R lR ltRtVtV ;t# )Ú	Whiteningi™  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: ``'pcaws'`` replaces each kept eigenvalue ``lambda`` by ``(1 - alpha) * lambda +
        alpha``, a shrinkage towards 1 with weight ``alpha``, the eigenvalue at index ``keval`` (``0 <= keval <
        len(eigvals)``) of the whitening model's full spectrum, whatever ``output_dims`` is.
    t: Attenuation parameter.

Returns:
    l2-normalized, whitened descriptors.

Shape:
    - Input: ``(N, in_dims)``.
    - Output: ``(N, output_dims)``.

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)
    >>> whitening(descs).shape
    torch.Size([23, 128])

c                ó–   <€ V ^8„  d   QhRS[ RS[S[S[ S[S[ S[P                  3,          3,          R3,          RS[RS[RS[RS[RR/# )	r   ÚxformÚwhitening_modelNrÕ   Úoutput_dimsÚkevalÚtr   )r   r   r   r   r   r   rz   )r   rD   s   "€r   r   ÚWhitening.__annotate__À  ss   ø€ ÷ <ñ <áð<ñ ™t¡C©©c±5·<±<Ð.?Õ)@Ð$@ÕAÀ4ÐGÕHð<ñ ð	<ñ
 ð<ñ ð<ñ ð<ð 
ñ<r   c                óô  <€ \         SV `  4        Wn        W0n        WPn        W`n        R V n        \        WC4      pW@n        \        P                  ! \        P                  ! V4      RR7      V n        \        P                  ! \        P                  ! V4      RRV13,          RR7      V n        \        P                  ! \        P                   ! V4      RV RR7      V n        Ve   V P%                  V4       R# R# )r¸   T)Úrequires_gradr(   N)rL   rM   r  rÕ   r  r  ÚpvalÚminr  r   Ú	Parameterr   r†   ÚmeanÚeyeÚevecsr…   ÚevalsÚload_whitening_parameters)rP   r  r  rÕ   r  r  r  rQ   s   &&&&&&&€r   rM   ÚWhitening.__init__À  s¿   ø€ ô 	‰ÑÔàŒ
ØŒØŒ
ØŒØˆŒ	ô ˜+Ó/ˆØ&Ôô —L’L¤§¢¨WÓ!5ÀTÔJˆŒ	Ü—\’\¤%§)¢)¨GÓ"4°Q¸¸¸°_Õ"EÐUYÔZˆŒ
Ü—\’\¤%§*¢*¨WÓ"5°l°{Ð"CÐSWÔXˆŒ
àÒ&Ø×*Ñ*¨?Ö;ñ 'r   c                ód   <€ V ^8„  d   QhRS[ S[S[ S[S[P                  3,          3,          RR/# )r   r  r   N)r   r   r   r   )r   rD   s   "€r   r   r	  Ý  s4   ø€ ÷ $ñ $¹¹cÁ4ÉÉUÏ\É\ÐHYÕCZÐ>ZÕ9[ð $Ð`dñ $r   c                ó¢  a a€ S P                   R8X  d   RMRpW,          oSR,          S P                  n        SR,          RRS P                  13,          S P                  n        SR,          RS P                   S P
                  n        RS P                  RS P                  RV V3R	 lR
S P                  /pVS P                   ,          ! 4        R# )a.  Load and adapt whitening statistics for the selected transform.

Args:
    whitening_model: Dictionary containing whitening tensors. The expected
        entries are model variants such as ``"pca"`` or ``"lw"``, each holding
        ``mean``, ``eigvecs`` (eigenvectors), and ``eigvals`` (eigenvalues).
ÚlwÚpcar  Úeigvecsr(   NÚeigvalsÚpcawsc                  ó4   <€ S P                  SR ,          4      # )r  )Ú_modify_pcaws)rP   Úwh_models   €€r   Ú<lambda>Ú5Whitening.load_whitening_parameters.<locals>.<lambda>î  s   ø€ ˜T×/Ñ/°¸Õ0CÔDr   Úpcawt)	r  r  Údatar  r  r  Ú_modify_pcaÚ
_modify_lwÚ_modify_pcawt)rP   r  ÚalgoÚmodificationsr  s   f&  @r   r  Ú#Whitening.load_whitening_parametersÝ  s²   ù€ ð —z‘z TÔ)‰t¨uˆØ"Õ(ˆØ! &Õ)ˆ�	‰	ŒØ" 9Õ-¨aÐ1C°4×3CÑ3CÐ1CÐ.CÕDˆ�
‰
ŒØ" 9Õ-Ð.@°×0@Ñ0@ÐAˆ�
‰
Œð �4×#Ñ#Ø�$—/‘/ØÕDØ�T×'Ñ'ð	
ˆð 	�d—j‘jÖ!Ö#r   c                ó   <€ V ^8„  d   QhRR/# rB   rC   )r   rD   s   "€r   r   r	  õ  s   ø€ ÷ ñ ˜Tñ r   c                ó   € RV n         R# )zModify powerlaw parameter.g      à?N)r  rj   s   &r   r#  ÚWhitening._modify_pcaõ  s	   € àˆŽ	r   c                ó   <€ V ^8„  d   QhRR/# rB   rC   )r   rD   s   "€r   r   r	  ù  s   ø€ ÷ (ñ (˜Dñ (r   c                ó   € R# )zNo modification required.NrC   rj   s   &r   r$  ÚWhitening._modify_lwù  s   ‚ r   c                ó8   <€ V ^8„  d   QhRS[ P                  RR/# )r   r  r   NrU   )r   rD   s   "€r   r   r	  ü  s#   ø€ ÷ Jñ J¡U§\¡\ð J°dñ Jr   c           	     óœ  € VP                   ^ ,          p^ V P                  u;8:  d   V8  g"   M \        RV P                   RV RV R24      hWP                  ,          p^V,
          V P                  ,          V,           pV P                  \
        P                  ! \
        P                  ! VR4      4      ,          V P                  n        R# )aX  Shrink each kept eigenvalue towards 1: ``(1 - alpha) * lambda + alpha`` with ``alpha = eigvals[keval]``.

The shrinkage weight ``alpha`` is a property of the whitening model, not of how many components are kept, so it
is read from the full spectrum ``eigvals`` before truncation to ``output_dims``: keeping fewer components only
drops columns.
z*pcaws needs the eigenvalue at index keval=z. of the whitening model's spectrum, which has z eigenvalues (0 <= keval < z).Nç      à¿)	r]   r  r^   r  r  r   ÚdiagÚpowr"  )rP   r  rƒ   Úalphar  s   &&   r   r  ÚWhitening._modify_pcawsü  sž   € ð �M‰M˜!ÕˆØ�D—J‘JÖ" Ö"ÜØ<¸T¿Z¹Z¸LÐHvØ�#Ð0°°°2ð7óð ð Ÿ
™
Õ#ˆØ�e•)˜tŸz™zÕ)¨UÕ2ˆØŸ*™*¤u§z¢z´%·)²)¸EÀ4Ó2HÓ'IÕIˆ�
‰
Žr   c                ó   <€ V ^8„  d   QhRR/# rB   rC   )r   rD   s   "€r   r   r	    s   ø€ ÷ Lñ L˜tñ Lr   c                óÖ   € RV P                   ,          pV P                  \        P                  ! \        P                  ! V P
                  V4      4      ,          V P                  n        R# )zAttenuation for eigenvalues.Nr1  )r  r  r   r2  r3  r  r"  )rP   Úms   & r   r%  ÚWhitening._modify_pcawt  s;   € à�4—6‘6�MˆØŸ*™*¤u§z¢z´%·)²)¸D¿J¹JÈÓ2JÓ'KÕKˆ�
‰
Žr   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# rT   rU   )r   rD   s   "€r   r   r	    s#   ø€ ÷ 'ñ '™Ÿ™ð '©%¯,©,ñ 'r   c                óÖ  € \        V\        P                  4      '       g   \        R\	        V4       24      h\        VP                  4      ^8X  g   \        RVP                   24      hWP                  ,
          pWP                  ,          p\        P                  ! V4      \        P                  ! \        P                  ! V4      V P                  4      ,          p\        V^R7      # )a$  Whiten and L2-normalize local descriptors.

Args:
    x: Descriptor tensor with shape ``(N, D)``, where ``N`` is the number
        of descriptors and ``D`` is the input descriptor dimension.

Returns:
    Whitened descriptor tensor with shape ``(N, O)``, where ``O`` is
    ``output_dims``.
rW   z)Invalid input shape, we expect NxD. Got: r2   )rY   r   r   rZ   r[   r\   r]   r^   r  r  Úsignr3  Úabsr  r   ©rP   r$   s   &&r   rc   ÚWhitening.forward  sŸ   € ô ˜!œUŸ\™\×*Ò*ÜÐDÄTÈ!ÃWÀIÐNÓOÐOÜ�1—7‘7‹|˜qÔ ÜÐHÈÏÉÈ	ÐRÓSÐSØ—	‘	�MˆØ—
‘
�NˆÜ�JŠJ�q‹MœEŸIšI¤e§i¢i°£l°D·I±IÓ>Õ>ˆÜ˜Q AÔ&Ð&r   c                ó    <€ V ^8„  d   QhRS[ /# rf   rg   )r   rD   s   "€r   r   r	  &  r•   r   c                ó‚   € V P                   P                   R V P                   RV P                   RV P                   R2# )z(xform=rþ   ú, output_dims=r˜   )rQ   ri   r  rÕ   r  rj   s   &r   rk   ÚWhitening.__repr__&  s>   € Ø—.‘.×)Ñ)Ð*¨'°$·*±*°¸ZÈÏÉÀ~ÐUcÐdh×dtÑdtÐcuÐuvÐwÐwr   )	r  r  rÕ   r  r  r  r  r  r  )é€   é(   gffffffæ?)ri   rn   ro   rp   rq   rM   r  r#  r$  r  r%  rc   rk   rr   rs   rt   ru   s   @@r   r  r  ™  sg   ù‡ € ñ$÷L<õ <÷:$ð $÷0ð ÷(ð (÷Jð J÷"Lð L÷
'ð '÷(x÷ xð xr   r  c                   ó|   a a€ ] tR tRt oRtRV3R lV 3R llltV3R lR ltV3R lR ltV3R	 lR
 ltRt	Vt
V ;t# )ÚMKDDescriptori*  a²  Describe square grayscale patches with handcrafted Multiple Kernel Descriptors (MKD).

``mkd = MKDDescriptor()``, then ``descs = mkd(patches)`` takes grayscale patches
``(B, 1, patch_size, patch_size)``, 32 pixels square by default, and returns unit-norm descriptors ``(B, D)``,
``(B, 128)`` with the defaults: the gradient magnitudes and orientations of each patch embedded in polar and
Cartesian spatial kernels (``kernel_type="concat"``), then whitened by ``whitening="pcawt"`` and reduced to
``output_dims``. It has no CNN; only the whitening is learned, on ``training_set``, and the module is in eval mode
when built. To describe LAFs on an image, wrap it in :class:`LAFDescriptor` with the same ``patch_size``; for SIFT
histograms, use :class:`SIFTDescriptor`, and for a learned descriptor, :class:`HardNet`. This is based on the
paper "Understanding and Improving Kernel Local Descriptors". See :cite:`mukundan2019understanding` for more
details.

Convention:
    - Patches are ``(B, 1, patch_size, patch_size)``: ``patch_size`` must be the input's size, and another size
      raises ``ShapeError``. The kernels are centred on the patch centre :math:`(\text{patch\_size} - 1) / 2`.
    - The descriptor has unit L2 norm, and an intensity change :math:`a x + b` with :math:`a > 0` gives the same
      descriptor unless it leaves the patch nearly flat. The exception is a flat float16 patch with
      ``whitening=None``: the ``1e-8`` added to the gradient magnitudes underflows in float16, and the descriptor
      is all zero.
    - With whitening the descriptor is :math:`\min(\text{output\_dims}, E)` wide, where :math:`E` is the width of
      the kernel embedding: 238 for ``'concat'``, 175 for ``'polar'`` and 63 for ``'cart'``. With
      ``whitening=None`` it is that embedding, :math:`E` wide whatever ``output_dims`` says. Constructing a whitened
      descriptor loads its whitening model, and downloads it then if it is not cached yet; ``whitening=None``
      needs no download.

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: Width of the whitened descriptor, at most the embedding width; ignored with ``whitening=None``.

Returns:
    Descriptors of the patches, of unit norm except as stated in the Convention block.

Shape:
    - Input: ``(B, 1, patch_size, patch_size)``.
    - Output: ``(B, D)``, with :math:`D` as in the Convention block.

See Also:
    - :class:`SIFTDescriptor`: the handcrafted SIFT histograms of gradient orientation of a patch.
    - :class:`HardNet`: a learned descriptor of 32 x 32 patches.
    - :class:`LAFDescriptor`: runs this module on a patch per LAF of an image.

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

c                ó<   <€ V ^8„  d   QhRS[ RS[RS[RS[RS[ RR/# ©r   r   rµ   Ú	whiteningÚtraining_setr  r   N©r   r   )r   rD   s   "€r   r   ÚMKDDescriptor.__annotate__b  sG   ø€ ÷ 6ñ 6áð6ñ ð6ñ ð	6ñ
 ð6ñ ð6ð 
ñ6r   c                ó:  <€ \         SV `  4        Wn        W n        W0n        W@n        R V^@,          ,          V n        \        RV P                  V P                  3R4      V n        \        4       V n
        RpRpV P                  R8X  d   Wg.MV P                  .V n        ^ V n        VRVR/p\        P                  ! 4       V n        V P                   F}  p	\!        WV	,          R7      p
\#        W‘V
P$                  P&                  R7      p\        P(                  ! W«4      V P                  V	&   V ;P                  VP                  ,          un        K  	  \+        WPP                  4      V n        V P/                  V P0                  4       V P                  ew   \3        \4        V P                  ,          \6        P8                  ! R
4      R7      pWÄ,          p\;        W=V P                  V P,                  R7      V n        V P,                  V n        V P?                  4        R	# )çffffffö?Ú	replicaterº   r¹   ÚconcatTF©r   r�   ©rµ   rÔ   rÕ   NÚcpu©Úmap_location©rÕ   r  ©é   rY  ) rL   rM   r   rµ   rJ  rK  rÚ   r   Ú	smoothingr@   Ú	gradientsÚparametrizationsrã   r   Ú
ModuleDictÚfeatsr›   rÒ   r£   r„   Ú
Sequentialr  r  Ú"_register_load_state_dict_pre_hookÚ_fill_missing_stage_buffersr
   Úurlsr   Údevicer  Úwhitening_layerÚeval)rP   r   rµ   rJ  rK  r  Úpolar_sÚcart_sÚrelative_orientationsÚparametrizationÚgradient_embeddingÚspatial_encodingÚwhitening_modelsr  rQ   s   &&&&&&        €r   rM   ÚMKDDescriptor.__init__b  s¶  ø€ ô 	‰ÑÔà)ŒØ +ÔØ'ŒØ!-Ôà˜J¨�OÕ,ˆŒ
Ü'¨°·±¸T¿Z¹ZÐ0HÈ+ÓVˆŒÜ%›ˆŒàˆØˆØ59×5EÑ5EÈÔ5Q Ñ 1ÐX\×XhÑXhÐWiˆÔð ˆŒ
Ø!(¨$°¸Ð >Ðô —]’]“_ˆŒ
Ø#×4Ô4ˆOÜ!/¸:ÐfuÕPvÔ!wÐÜ6Ø+ÐK]×KdÑKd×KfÑKfô Ðô +-¯-ª-Ð8JÓ*]ˆD�J‰J�Ñ'Ø�JŠJÐ*×0Ñ0Õ0�Jñ  5ô !$ K·±Ó <ˆÔð 	×/Ñ/°×0PÑ0PÔQð �>‰>Ò%Ü7¼¸T×=MÑ=MÕ8NÔ]b×]iÒ]iÐjoÓ]pÔqÐØ.Õ<ˆOÜ#,Ø°D·J±JÈD×L\ÑL\ô$ˆDÔ ð ×)Ñ)ˆDŒJØ�	‰	Žr   c                óZ   <€ V ^8„  d   QhRS[ S[S[P                  3,          RS[RS[RR/# )r   Ú
state_dictÚprefixÚargsr   N)r   r   r   r   r   )r   rD   s   "€r   r   rM  š  s@   ø€ ÷ Añ A±d¹3ÁÇÁÐ;LÕ6Mð AÑWZð AÑcfð AÐkoñ Ar   c                ó@  a€ \         ;QJ d    V3R  lV 4       F  '       g   K   RM	  RM! V3R  lV 4       4      '       d   R# V P                  4        FF  w  rEVP                  R4      '       g   K  VP                  4       P	                  4       VSV,           &   KH  	  R# )c              3   óR   <"  € T F  qP                  SR ,           4      x € K  	  R# 5i)úfeats.N)Ú
startswith)Ú.0Úkeyrp  s   & €r   Ú	<genexpr>Ú<MKDDescriptor._fill_missing_stage_buffers.<locals>.<genexpr>›  s    øé € ÐG¹J°S�~‰~˜f xÕ/×0Ð0»Jùs   ƒ$'TFNrt  )ÚanyÚnamed_buffersru  ÚdetachÚclone)rP   ro  rp  rq  ÚnameÚbufs   &&f*  r   ra  Ú)MKDDescriptor._fill_missing_stage_buffersš  sh   ø€ ß‹3ÔG¹JÓG�3�3Š3ÔG¹JÓG×GÒGÙØ×+Ñ+Ö-‰IˆDØ�‰˜x×(Ô(Ø,/¯J©J«L×,>Ñ,>Ó,@�
˜6 D�=Ó)ó .r   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# )r   Úpatchesr   rU   )r   rD   s   "€r   r   rM  ¡  s#   ø€ ÷ #ñ #™uŸ|™|ð #±·±ñ #r   c           	     ó~  € \        V\        P                  4      '       g   \        R\	        V4       24      h\        VRR\        V P                  4      \        V P                  4      .4       V P                  V4      pV P                  V4      p. pV P                   FW  pV P                  V,          P                  VP                  4       VP                  V P                  V,          ! V4      4       KY  	  \        P                  ! V^R7      p\!        V^R7      pV P"                  e   V P%                  V4      pV# )aW  Compute Multiple Kernel Descriptor (MKD) vectors for image patches.

Args:
    patches: Grayscale patch tensor with shape ``(B, 1, patch_size, patch_size)``.

Returns:
    Descriptor tensor with shape ``(B, D)``, with ``D`` as in the class's Convention block.

Raises:
    ShapeError: if ``patches`` is not ``(B, 1, patch_size, patch_size)``.
rW   ÚBÚ1r2   )rY   r   r   rZ   r[   r	   r   r   rZ  r[  r\  r^  r9   rc  Úappendr_   r   rJ  rd  )rP   r‚  ÚgÚfeaturesri  r%   s   &&    r   rc   ÚMKDDescriptor.forward¡  sú   € ô ˜'¤5§<¡<×0Ò0ÜÐDÄTÈ'Ã]ÀOÐTÓUÐUÜ˜7 S¨#¬s°4·?±?Ó/CÄSÈÏÉÓEYÐ$ZÔ[à�N‰N˜7Ó#ˆØ�N‰N˜1Óˆð ˆØ#×4Ô4ˆOØ�J‰J�Õ'×*Ñ*¨1¯8©8Ô4Ø�O‰O˜DŸJ™J Ö7¸Ó:Ö;ñ  5ô
 �IŠI�h AÔ&ˆô ˜! Ô#ˆð �>‰>Ò%Ø×$Ñ$ QÓ'ˆAàˆr   c                ó    <€ V ^8„  d   QhRS[ /# rf   rg   )r   rD   s   "€r   r   rM  Æ  s   ø€ ÷ 
ñ 
™#ñ 
r   c                ó¶   € V P                   P                   R V P                   RV P                   RV P                   RV P
                   RV P                   R2# )r—   z, kernel_type=z, whitening=z, training_set=rB  r˜   )rQ   ri   r   rµ   rJ  rK  r  rj   s   &r   rk   ÚMKDDescriptor.__repr__Æ  so   € à�~‰~×&Ñ&Ð'ð (ØŸ/™/Ð*ð +Ø×+Ñ+Ð,ð -ØŸ™Ð(ð )Ø ×-Ñ-Ð.ð /Ø×+Ñ+Ð,¨Að/ð	
r   )r^  r[  rµ   rã   r  r\  r   rÚ   rZ  rK  rJ  rd  )r³   rQ  r!  ÚlibertyrD  )ri   rn   ro   rp   rq   rM   ra  rc   rk   rr   rs   rt   ru   s   @@r   rG  rG  *  s<   ù‡ € ñ5÷n6õ 6÷pAð A÷#ð #÷J
÷ 
ð 
r   rG  c                ó^   € V ^8„  d   QhR\         R\         R\        \         \        3,          /# )r   rµ   rK  r   )r   r   r   )r   s   "r   r   r   Ñ  s)   € ÷ *ñ *¤cð *¼ð *ÄÄcÌ3ÀhÅñ *r   c                ój   € \        \        V ,          \        P                  ! R4      R7      pW!,          # )zLoad whitening model.rT  rU  )r
   rb  r   rc  )rµ   rK  rl  s   && r   Úload_whitening_modelr�  Ñ  s*   € ä/´°[Õ0AÔPU×P\ÒP\Ð]bÓPcÔdÐØÕ)Ð)r   c                   óX   a a€ ] tR tRt oRtRV3R lV 3R llltV3R lR ltRtVtV ;t	# )	ÚSimpleKDi×  z+Example to write custom Kernel Descriptors.c                ó<   <€ V ^8„  d   QhRS[ RS[RS[RS[RS[ RR/# rI  rL  )r   rD   s   "€r   r   ÚSimpleKD.__annotate__Ú  sO   ø€ ÷ Jñ JáðJñ ðJñ ð	Jñ
 ðJñ ðJð 
ñJr   c                ób  <€ \         SV `  4        VR 8H  pRV^@,          ,          pWn        \        RWw3R4      p\	        4       p	\        WR7      p
\        W!V
P                  P                  R7      p\        V\        W$4      VP                  VR7      p\        P                  ! W‰W«V4      V n        R# )rº   rO  rP  rR  rS  rW  NrX  )rL   rM   r   r   r@   r›   rÒ   r£   r„   r  r�  rã   r   r_  rˆ  )rP   r   rµ   rJ  rK  r  r�   rÚ   rZ  r[  ÚoriÚeseÚwhrQ   s   &&&&&&       €r   rM   ÚSimpleKD.__init__Ú  sž   ø€ ô 	‰ÑÔà$¨Ñ/ˆØ˜j¨2�oÕ.ˆØ$Œä" 6¨E¨>¸;ÓGˆ	Ü “Nˆ	Ü¨
ÔFˆÜ%°+Ð]`×]gÑ]g×]iÑ]iÔjˆÜØÔ+¨KÓFÐPS×PYÑPYÐgrô
ˆô Ÿš i¸CÀbÓIˆŽr   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# rT   rU   )r   rD   s   "€r   r   r”  ò  s#   ø€ ÷ 
 ñ 
 ™Ÿ™ð 
 ©%¯,©,ñ 
 r   c                ó$   € V P                  V4      # )zßRun the example kernel-descriptor pipeline.

Args:
    x: Grayscale patch tensor with shape ``(B, 1, H, W)``.

Returns:
    Descriptor tensor produced by smoothing, gradient extraction, spatial
    encoding, and whitening.
)rˆ  r>  s   &&r   rc   ÚSimpleKD.forwardò  s   € ð �}‰}˜QÓÐr   )rˆ  r   )r³   rº   r!  r�  rD  )
ri   rn   ro   rp   rq   rM   rc   rr   rs   rt   ru   s   @@r   r’  r’  ×  s#   ù‡ € Ù5÷Jõ J÷0
 ÷ 
 ð 
 r   r’  c                ó¤  € V ^8„  d   Qh/ ^ \         9   d
   \        ;R&   ^\         9   d   \        \        ,          ;R&   ^\         9   d   \        \        ,          ;R&   ^\         9   d   \        \        ,          ;R&   ^\         9   d&   \        \        \        \        ,          3,          ;R&   ^\         9   d   \        \        \        3,          ;R&   # )r   r¿   ÚCOEFFS_N1_K1ÚCOEFFS_N2_K8ÚCOEFFS_N3_K8r¢   rb  )Ú__conditional_annotations__rz   r   r   r   )r   s   "r   r   r      sš   € ‡�÷ "Ò !„uÑ !ñ ÷ 5Ò 4Œd”5�kÑ 4ñ ÷  ?Ò >Œd”5�kÑ >ñ! ÷" KÒ JŒd”5�kÑ Jñ# ÷$ eÒ dŒŒS”$”u•+ÐÕÑ dñ% ÷(ò „dŒ3”ˆ8…nñ ò) r   )ç"¹g#ø[Â?ç–x@Ù”+Ñ?çKÈ'"Ì?)r¢  r£  r¤  gËˆfùFÄ?)r¹   rº   rQ  )r³   )*r¡  r½   Útypingr   r   r   r   r   r   r   Úkornia.core.checkr	   Úkornia.core.downloadr
   Úkornia.core.utilsr   Úkornia.filtersr   r   Úkornia.geometry.conversionsr   Úkornia.geometry.gridr   r¿   rž  rŸ  r   r¢   rb  r+   r>   ÚModuler@   rw   r›   rÐ   rÒ   r  rG  r�  r’  r   )rÉ   r¡  s   0@r   Ú<module>r­     s:  øð÷$ €ß 0Õ 0ã Ý å 0Ý 9Ý +ß :Ý 0Ý 0ð "€Ó !Ø'¨Ð4€Ó 4Ú>€Ó >ÚJ€Ó JØ"&¨°hÀÈgÐWcÐ!d€Ó dñ )óá(ˆð Ð	LÈQÈCÈwÐWÒWÙ(ñ€ó ÷4õ&ô4'�2—9‘9ô 4'ônLx�R—Y‘Yô Lxô^>d�R—Y‘Yô >dõB]ô<u
˜bŸi™iô u
ôpNx�—	‘	ô Nxôbd
�B—I‘Iô d
õN*ô% ˆr�y‰yö % ùòcs   Á7D=