+
    õäûjõN  ã                  óÀ  € ^ RI Ht ^ RIHtHtHtHtHtHtH	t	H
t
 ^ RIt^ RIHtHtHt ^ RIHt ^ RIHtHtHt ^ RIHtHt ^ RIHt ^ R	IHtHtHtHt ^ R
IH t  ^ RI!H"t" ]	! R]R]PF                  3,          R7      t$R R lt% ! R R]4      t&]]
]PF                  ]&3,          ]]']PF                  3,          ]]']3,          3,          t( ! R R]4      t) ! R R])4      t*R# )é    )Úannotations)ÚAnyÚCallableÚDictÚ
NamedTupleÚOptionalÚTupleÚTypeVarÚUnionN)Úfloat16Úfloat32Úfloat64)Ú_AugmentationBase)Ú_transform_inputÚ_transform_input_by_shapeÚ_validate_input_dtype)Ú_IMAGE_SHAPESÚ_raise_input_rank_error©Úeye_like)Ú_to_device_nonblockingÚis_autocast_enabledÚis_compilingÚis_exporting)ÚBoxes)Ú	KeypointsÚ_F.)Úboundc               ó    € V ^8„  d   QhRRRR/# )é   Úmethodr   Úreturn© )Úformats   "ÚXC:\Ai_Coding\apps\studio\ComfyUI\.venv\Lib\site-packages\kornia\augmentation\_2d\base.pyÚ__annotate__r&   $   s   € ÷ ñ  ð ¨ñ ó    c                ó"   € W P                   R&   V # )a+  Mark an implementation that only reads the input's shape, dtype and device.

Store the function itself, not a boolean: an override (including a wrapper that
copies function attributes) must not inherit another implementation's promise.
Overridable callees in the matrix path are checked separately.
Ú_kornia_input_metadata_only)Ú__dict__)r!   s   &r%   Ú_input_metadata_onlyr+   $   s   € ð 6<‡O�OÐ1Ñ2Ø€Mr'   c                  óB   € ] tR t^/t$ R]R&   R]R&   R]R&   R R ltR	tR
# )Ú_InputMetadatazTuple[int, ...]Úshapeztorch.dtypeÚdtypeztorch.deviceÚdevicec               ó   € V ^8„  d   QhRR/# )r    r"   útorch.Tensorr#   )r$   s   "r%   r&   Ú_InputMetadata.__annotate__4   s   € ÷ Xñ X˜\ñ Xr'   c                	óŽ   € \         P                  ! RV P                  V P                  R 7      P	                  V P
                  4      # ))r/   r0   r#   )ÚtorchÚemptyr/   r0   Úexpandr.   )Úselfs   &r%   ÚmaterializeÚ_InputMetadata.materialize4   s.   € ô �{Š{˜2 T§Z¡Z¸¿¹ÔD×KÑKÈDÏJÉJÓWÐWr'   r#   N)Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__annotations__r9   Ú__static_attributes__r#   r'   r%   r-   r-   /   s    ‡ ØÓØÓØÓ÷Xñ Xr'   r-   c                  óH   € ] tR t^=tRtR R lt]RRRR/R R	 ll4       tR
tR# )ÚAugmentationBase2Da³  Build a custom 2D augmentation, applied per sample with probability ``p`` (default 0.5).

``output = MyAugmentation(...)(input)`` processes images of shape ``(B, C, H, W)`` once a subclass
implements ``apply_transform`` and supplies any parameter generation it needs. This generic base supports
custom operations, including matrix-free warps such as :class:`RandomElasticTransform` and
:class:`RandomThinPlateSpline`. Use :class:`IntensityAugmentationBase2D` for value-only operations or
:class:`GeometricAugmentationBase2D` for matrix-based coordinate transforms.

This class is the anchor for the contract the 2D augmentations of ``kornia.augmentation`` inherit.
Mix and 3D augmentations have their own bases and contracts.

Args:
    p: probability for applying an augmentation. This param controls the augmentation probabilities
      element-wise for a batch.
    p_batch: probability for applying an augmentation to a batch. This param controls the augmentation
      probabilities batch-wise.
    same_on_batch: apply the same transformation across the batch.
    keepdim: whether to keep the output shape the same as input ``True`` or broadcast it to the batch
      form ``False``.

Convention:
    - the working layout is ``(B, C, H, W)`` float. A ``(C, H, W)`` input is promoted to ``(1, C, H, W)``
      and an ``(H, W)`` input to ``(1, 1, H, W)``; ``keepdim=True`` restores the input rank on the way out
      and never drops a real batch dimension. The dtype guard accepts ``float16``, ``bfloat16``, ``float32``
      and ``float64`` and raises ``TypeError`` on an integer tensor. The output keeps the input's device.
    - a wrong input rank raises :class:`~kornia.core.exceptions.InputRankError` with the same message from
      every entry point, the class, ``validate_tensor()`` and the containers. It is a ``ValueError`` and also a
      ``RuntimeError`` and an ``AssertionError``, the types those entry points raised before
      (`#4424 <https://github.com/kornia/kornia/issues/4424>`_). ``validate_tensor()`` accepts the ranks
      ``forward`` accepts.
    - this base samples ``p`` per sample and uses ``p_batch`` as a call-wide gate. ``same_on_batch=True``
      shares applicable sampled values across the batch. Concrete constructors need not expose ``p_batch``;
      it can be set as an attribute on any augmentation. A sample the gate skips comes back
      with its input values, its values cannot make the call raise, and where they are finite its gradient
      is the identity; a class whose transform checks input values or has an unbounded derivative runs it
      on 0.5 for skipped samples. An augmentation that changes the sample shape still raises ``ValueError``
      when the gate mixes applied and skipped samples (`#4497 <https://github.com/kornia/kornia/issues/4497>`_).
    - parameter sampling normally uses CPU defaults independently of the image device. Moving RNG state or
      samplers is incomplete for some generators, and returned parameter placement is a separate concern;
      see `#4426 <https://github.com/kornia/kornia/issues/4426>`_.
    - reproducibility goes through torch's global generators; there is no per-instance generator.
      ``generator=`` raises at construction; in ``forward`` it emits ``FutureWarning`` and is ignored,
      like other unknown keyword overrides
      (`#4427 <https://github.com/kornia/kornia/issues/4427>`_). :doc:`/get-started/conventions` states the
      seeding, ``DataLoader``-worker, parameter-placement and serialization rules.
    - the last draw is kept in ``_params``; ``forward(x, params=...)`` replaces that dict wholesale, stores the
      caller's dict by reference and, if ``batch_prob`` is absent, inserts an all-true gate into it. Replaying
      parameters reproduces the output, except for :class:`RandomDissolving`, whose VAE latents are drawn
      during application and are not stored.
    - with static ``p=1.0, p_batch=1.0`` every sample is transformed: a ``batch_prob`` put into ``params`` is not
      consulted by the image, the transformation matrix, the labels or ``inverse``, in eager and compiled runs
      alike (`#5585 <https://github.com/kornia/kornia/issues/5585>`_). Pass ``p < 1`` to skip samples by hand,
      which every one of those paths honors.
    - a ``_param_generator.*`` range buffer in ``state_dict()`` updates the samplers when loading changes it, and
      a learnable range is read before each draw; see :doc:`/get-started/conventions` for the classes this leaves
      out (`#4428 <https://github.com/kornia/kornia/issues/4428>`_).
    - an empty batch gives an empty output, except on a minority of classes that raise on ``B = 0``
      (`#4429 <https://github.com/kornia/kornia/issues/4429>`_).
    - rotation-like parameters are in degrees, and a positive angle turns the image counter-clockwise as
      displayed (top-left origin, y pointing down), as :func:`~kornia.geometry.transform.rotate` documents;
      :class:`RandomAffine` turns clockwise (`#4408 <https://github.com/kornia/kornia/issues/4408>`_).
    - ``torch.jit.script`` is not supported; ``torch.compile(fullgraph=True)`` works for some augmentations
      and flags only.

See Also:
    - :class:`GeometricAugmentationBase2D`: adds coordinate-aware geometric transform hooks.

c               ó    € V ^8„  d   QhRRRR/# )r    Úinputr2   r"   ÚNoner#   )r$   s   "r%   r&   ÚAugmentationBase2D.__annotate__ƒ   s   € ÷ @ñ @ \ð @°dñ @r'   c                óÈ   € \        V\        P                  \        \        \
        .R7       \        VP                  4      R9  d   \        VP                  \        4       R# R# )z[Check that the input has a float dtype and one of the ranks ``forward`` accepts: 2, 3 or 4.©Úaccepted_dtypesN)r    é   é   )
r   r5   Úbfloat16r   r   r   Úlenr.   r   r   ©r8   rD   s   &&r%   Úvalidate_tensorÚ"AugmentationBase2D.validate_tensorƒ   s>   € ä˜e´e·n±nÄgÌwÔX_Ð5`ÕaÜˆu�{‰{Ó 9Ô,Ü# E§K¡K´Ö?ñ -r'   r.   NÚmatch_channelTc               ó(   € V ^8„  d   QhRRRRRRRR/# )r    rD   r2   r.   úOptional[torch.Tensor]rQ   Úboolr"   r#   )r$   s   "r%   r&   rF   Š   s2   € ÷ 	dñ 	dØ!ð	dØ-Cð	dØ[_ð	dà	ñ	dr'   c               ó�   € \        V\        P                  \        \        \
        .R7       Vf   \        V4      # \        WVR7      # )zJConvert any incoming (H, W), (C, H, W) and (B, C, H, W) into (B, C, H, W).rH   )Úreference_shaperQ   )r   r5   rL   r   r   r   r   r   )r8   rD   r.   rQ   s   &&$$r%   Útransform_tensorÚ#AugmentationBase2D.transform_tensor‰   s:   € ô
 	˜e´e·n±nÄgÌwÔX_Ð5`ÕaàŠ=Ü# EÓ*Ð*ä(¨ÐUbÔcÐcr'   r#   )	r;   r<   r=   r>   Ú__doc__rO   r+   rW   r@   r#   r'   r%   rB   rB   =   s7   † ñCõJ@ð ð	dØFJð	dØbfö	dó ô	dr'   rB   c                  ó>  € ] tR t^–t$ RtRtR]R&   RtR]R&   RtR]R	&   Rt	R
]R&   Rt
R]R&   ]R R l4       tR R ltR R lt]R R l4       t]R R l4       tR R lt]R R l4       tR)R R lltR)R R lltR)R  R! lltR)R" R# lltR)R$ R% lltR)R& R' lltR(tR# )*ÚRigidAffineAugmentationBase2Da†  Record a matrix for a custom 2D transform, applied per sample with probability ``p`` (default 0.5).

``output = MyAugmentation(...)(input)`` records a ``(B, 3, 3)`` matrix once a subclass implements
``compute_transformation`` and ``apply_transform``. This base manages matrix sampling and storage;
use :class:`GeometricAugmentationBase2D` for coordinate transforms or :class:`IntensityAugmentationBase2D`
for value-only operations.

See the Convention block on :class:`~kornia.augmentation.AugmentationBase2D`.

Args:
    p: probability for applying an augmentation. This param controls the augmentation probabilities
      element-wise for a batch.
    p_batch: probability for applying an augmentation to a batch. This param controls the augmentation
      probabilities batch-wise.
    same_on_batch: apply the same transformation across the batch.
    keepdim: whether to keep the output shape the same as input ``True`` or broadcast it to the batch
      form ``False``.

Convention:
    - a subclass implements :meth:`compute_transformation`, which returns the ``(B, 3, 3)`` matrix of the
      sampled transform, and ``apply_transform`` for images. Direct mask, box, and keypoint handlers are
      incomplete on this base; inherit the geometric base for its matrix-based handlers.
      :class:`~kornia.augmentation.container.AugmentationSequential` calls the subclass's mask, box and
      keypoint handlers with ``transform_matrix`` as ``transform``, as it does for a geometric child, and
      raises ``NotImplementedError`` for a registered data key whose handler is missing.
    - the matrix of the last call is readable as ``transform_matrix``. Subclasses opt into lazy construction
      with ``_compute_matrix_lazily``; a lazy matrix keeps only the input's shape, dtype and device, unless the
      subclass overrides ``transform_tensor``, ``generate_transformation_matrix``, ``compute_transformation``
      or ``identity_matrix``, in which case the input is kept until the matrix is read or replaced.
    - this base does not implement an inverse operation.

See Also:
    - :class:`GeometricAugmentationBase2D`: applies and records 2D geometric transformations.

NrS   Ú_transform_matrixFrT   Ú_compute_matrix_lazilyzOptional[_LazyMatrixArgs]Ú_lazy_matrix_argsúOptional[Dict[str, Any]]Ú_transform_matrix_paramsz*Optional[Tuple[Tuple[str, Any, int], ...]]Ú!_transform_matrix_params_snapshotc               ó    € V ^8„  d   QhRRRR/# )r    ÚparamsúDict[str, Any]r"   z Tuple[Tuple[str, Any, int], ...]r#   )r$   s   "r%   r&   Ú*RigidAffineAugmentationBase2D.__annotate__Å   s   € ÷ 

ñ 

 ð 

Ð4Tñ 

r'   c                ó’   € \         ;QJ d"    . R V P                  4        4       F  NK  	  5# ! R V P                  4        4       4      # )aU  Return each value of ``params`` with the version counter of each tensor value.

The values themselves are kept, not their ``id()``: a replaced tensor that is freed can hand its address to the
next tensor. An inference tensor has no version counter, so only its replacement is seen, not an in-place edit
made inside ``torch.inference_mode``.
c              3  ó²   "  € T FM  w  rY\        V\        P                  4      '       d#   VP                  4       '       g   VP                  MR3x € KO  	  R# 5i)é   Néÿÿÿÿ)Ú
isinstancer5   ÚTensorÚis_inferenceÚ_version)Ú.0ÚkeyÚvalues   &  r%   Ú	<genexpr>ÚARigidAffineAugmentationBase2D._params_snapshot.<locals>.<genexpr>Ì   sD   é € ð 
á,‘
�ð ¬:°e¼U¿\¹\×+JÒ+JÐSX×SeÑSe×SgÒSg˜ŸšÐmoÕpÛ,ùs   ‚=AÁ A)ÚtupleÚitems)rc   s   &r%   Ú_params_snapshotÚ.RigidAffineAugmentationBase2D._params_snapshotÄ   sB   € ÷ Œuñ 
à$Ÿl™lœnó
�uð 	
ˆuñ 
à$Ÿl™lœnó
ó 
ð 	
r'   c               ó    € V ^8„  d   QhRRRR/# )r    rc   rd   r"   rT   r#   )r$   s   "r%   r&   re   Ñ   s   € ÷ pñ p¨^ð pÀñ pr'   c                ó>  € V P                   VJd   R# V P                  pVf   \        4       # V P                  V4      p\	        V4      \	        V4      8w  d   R# \
        ;QJ d%    R \        W#4       4       F  '       d   K   R# 	  R# ! R \        W#4       4       4      # )zjWhether the recorded matrix was computed from ``params`` as they are now, not before a caller edited them.Fc              3  ój   "  € T F)  w  w  rpw  rEqaV8H  ;'       d    W%J ;'       d    W68H  x € K+  	  R # 5i©Nr#   )rn   Úk0Úv0Ún0Úk1Úv1Ún1s   &      r%   rq   ÚGRigidAffineAugmentationBase2D._matrix_matches_params.<locals>.<genexpr>Þ   s9   é € ÐoÑXnÑ:T¹,¸2À2ÉÈÐQS˜‘8×5Ð5  ×5Ð5¨R©XÔ5ÓXnùs   ‚#3¦3T)r`   ra   r   ru   rM   ÚallÚzip)r8   rc   ÚrecordedÚcurrents   &&  r%   Ú_matrix_matches_paramsÚ4RigidAffineAugmentationBase2D._matrix_matches_paramsÑ   sˆ   € à×(Ñ(°Ó6ÙØ×9Ñ9ˆØÒô  “>Ð!Ø×'Ñ'¨Ó/ˆÜˆx‹=œC ›LÔ(Ùß‹sÑoÔX[Ð\dÔXnÓo�sŒsÐoŠsÐoˆsÑoÔX[Ð\dÔXnÓoÓoÐor'   c               ó    € V ^8„  d   QhRRRR/# )r    rc   rd   r"   rE   r#   )r$   s   "r%   r&   re   à   s   € ÷ oñ o¨Nð o¸tñ or'   c                ó†   € \        4       '       g1   Wn        \        4       '       d   RMV P                  V4      V n        R# R# )zeRecord the params dict the image call was given, and its values, next to the matrix computed from it.N)r   r`   r   ru   ra   )r8   rc   s   &&r%   Ú_record_matrix_paramsÚ3RigidAffineAugmentationBase2D._record_matrix_paramsà   s1   € ä�~Š~Ø,2Ô)Ü=I¿^º^±TÐQU×QfÑQfÐgmÓQnˆDÖ2ñ r'   c               ó   € V ^8„  d   QhRR/# )r    r"   rS   r#   )r$   s   "r%   r&   re   ç   s   € ÷ &ñ &Ð"8ñ &r'   c                	óü   € V P                   fd   V P                  eV   V P                  w  rp\        V\        4      '       d   VP	                  4       MTpV P                  WBV4      V n         R V n        V P                   # rz   )r\   r^   rj   r-   r9   Úgenerate_transformation_matrix)r8   Úmatrix_inputrc   ÚflagsÚ	in_tensors   &    r%   Útransform_matrixÚ.RigidAffineAugmentationBase2D.transform_matrixæ   sp   € à×!Ñ!Ò)¨d×.DÑ.DÒ.PØ*.×*@Ñ*@Ñ'ˆL %Ü6@ÀÌ~×6^Ò6^˜×0Ñ0Ô2ÐdpˆIØ%)×%HÑ%HÈÐ\aÓ%bˆDÔ"Ø%)ˆDÔ"Ø×%Ñ%Ð%r'   c               ó    € V ^8„  d   QhRRRR/# )r    rD   r2   r"   r#   )r$   s   "r%   r&   re   ð   s   € ÷ "ñ " \ð "°lñ "r'   c                ó   € \        ^V4      # )zReturn 3x3 identity matrix.r   rN   s   &&r%   Úidentity_matrixÚ-RigidAffineAugmentationBase2D.identity_matrixï   s   € ô ˜˜5Ó!Ð!r'   c               ó(   € V ^8„  d   QhRRRRRRRR/# ©r    rD   r2   rc   úDict[str, torch.Tensor]r�   rd   r"   r#   )r$   s   "r%   r&   re   ô   s,   € ÷ "ñ "Ø!ð"Ø+Bð"ØKYð"à	ñ"r'   c                	ó   € \         hrz   ©ÚNotImplementedError)r8   rD   rc   r�   s   &&&&r%   Úcompute_transformationÚ4RigidAffineAugmentationBase2D.compute_transformationô   s
   € ô "Ð!r'   c               ó(   € V ^8„  d   QhRRRRRRRR/# r™   r#   )r$   s   "r%   r&   re   ú   s,   € ÷ %ñ %Ø!ð%Ø+Bð%ØKYð%à	ñ%r'   c                ón  € VR,          p\         P                  ! VR8„  4      pV P                  V4      pV P                  WbVR7      pV P                  R8X  dA   V P
                  R8X  d0   Tp\        4       '       d   VP                  VP                  4      pV# V P                  V4      p	\        4       '       d7   VP                  VP                  4      pV	P                  VP                  4      p	VP                  ^ ,          VP                  ^ ,          u;8X  d   V	P                  ^ ,          8X  db   M M^\        VP                  ! R.^.VP                  4       ^,
          ,          O5!  VP                  4      p
\         P                  ! W§V	4      pV# \!        VP#                  4       4      '       d   TMT	pV# )zIGenerate transformation matrices with the given input and param settings.Ú
batch_probg      à?)rc   r�   g      ð?ri   )r5   Ú
atleast_1drW   rž   ÚpÚp_batchr   Útyper/   r–   r.   r   ÚviewÚdimr0   ÚwhererT   Úany)r8   rD   rc   r�   r¢   Úto_applyr‘   Útrans_matrix_appliedÚtrans_matrixÚtrans_matrix_identityÚto_apply_expandeds   &&&&       r%   rŽ   Ú<RigidAffineAugmentationBase2D.generate_transformation_matrixù   sv  € ð
 ˜LÕ)ˆ
Ü×#Ò# J°Ñ$4Ó5ˆà×)Ñ)¨%Ó0ˆ	à#×:Ñ:¸9Ð[`Ð:ÓaÐà�6‰6�SŒ=˜TŸ\™\¨SÔ0ð
 0ˆLÜ"×$Ò$Ø+×0Ñ0°·±Ó=�ØÐà $× 4Ñ 4°YÓ ?Ðä× Ò Ø#7×#<Ñ#<¸U¿[¹[Ó#IÐ Ø$9×$>Ñ$>¸u¿{¹{Ó$KÐ!ð  ×%Ñ% aÕ(¨H¯N©N¸1Õ,=Ö_ÐAV×A\ÑA\Ð]^ÕA_×_Ü 6Ø—’˜bÐL Q CÐ+?×+CÑ+CÓ+EÈÕ+IÕ$JÓLÐNb×NiÑNió!Ðô !Ÿ;š;Ð'8ÐPeÓfˆLð Ðô 48¸¿¹»×3GÒ3GÑ/ÐMbˆLàÐr'   c          
     ó,   € V ^8„  d   QhRRRRRRRRR	R/# ©
r    rD   r2   rc   rš   r�   rd   Ú	transformrS   r"   r#   )r$   s   "r%   r&   re   !  ó<   € ÷ "ñ "àð"ð (ð"ð ð	"ð
 *ð"ð 
ñ"r'   c                	ó   € \         hrz   rœ   ©r8   rD   rc   r�   r³   s   &&&&&r%   Úinverse_inputsÚ,RigidAffineAugmentationBase2D.inverse_inputs!  ó
   € ô "Ð!r'   c          
     ó,   € V ^8„  d   QhRRRRRRRRR	R/# r²   r#   )r$   s   "r%   r&   re   *  r´   r'   c                	ó   € \         hrz   rœ   r¶   s   &&&&&r%   Úinverse_masksÚ+RigidAffineAugmentationBase2D.inverse_masks*  r¹   r'   c          
     ó,   € V ^8„  d   QhRRRRRRRRR	R/# )
r    rD   r   rc   rš   r�   rd   r³   rS   r"   r#   )r$   s   "r%   r&   re   3  s<   € ÷ "ñ "àð"ð (ð"ð ð	"ð
 *ð"ð 
ñ"r'   c                	ó   € \         hrz   rœ   r¶   s   &&&&&r%   Úinverse_boxesÚ+RigidAffineAugmentationBase2D.inverse_boxes3  r¹   r'   c          
     ó,   € V ^8„  d   QhRRRRRRRRR	R/# )
r    rD   r   rc   rš   r�   rd   r³   rS   r"   r#   )r$   s   "r%   r&   re   <  s<   € ÷ "ñ "àð"ð (ð"ð ð	"ð
 *ð"ð 
ñ"r'   c                	ó   € \         hrz   rœ   r¶   s   &&&&&r%   Úinverse_keypointsÚ/RigidAffineAugmentationBase2D.inverse_keypoints<  r¹   r'   c          
     ó,   € V ^8„  d   QhRRRRRRRRR	R/# r²   r#   )r$   s   "r%   r&   re   E  r´   r'   c                	ó   € \         hrz   rœ   r¶   s   &&&&&r%   Úinverse_classesÚ-RigidAffineAugmentationBase2D.inverse_classesE  r¹   r'   c               ó(   € V ^8„  d   QhRRRRRRRR/# )r    r‘   r2   rc   rš   r�   r_   r"   r#   )r$   s   "r%   r&   re   N  s,   € ÷ $ñ $Ø%ð$Ø/Fð$ØOgð$à	ñ$r'   c                	óö  € Vf   V P                   pV P                  pV P                  '       Ed   Tp\        ;QJ dH    R V P                  V P
                  V P                  V P                  3 4       F  '       d   K   RM=	  RM9! R V P                  V P
                  V P                  V P                  3 4       4      '       d5   \        \        VP                  4      VP                  VP                  4      pV P                  R WRV3R7       V P                  V4       V P                  WVR 4      # V P                  WV4      pV P                  WW64      pV P                  VR R7       V P                  V4       V# )Nc              3  óV   "  € T F  p\        VR R4      \        VRV4      J x € K!  	  R# 5i)r)   NÚ__func__)Úgetattr)rn   r!   s   & r%   rq   Ú;RigidAffineAugmentationBase2D.apply_func.<locals>.<genexpr>^  s6   é € ð ñ�Fô ˜Ð =¸tÓDÌÐPVÐXbÐdjÓHkÕkóùs   ‚')FT)r’   Úlazy_matrix_args)r�   Ú_paramsr]   r‚   rW   rŽ   rž   r–   r-   rs   r.   r/   r0   Ú_commit_staterŠ   Útransform_inputs)r8   r‘   rc   r�   Úmatrix_paramsr�   r­   Úoutputs   &&&&    r%   Ú
apply_funcÚ(RigidAffineAugmentationBase2D.apply_funcN  s]  € ð Š=Ø—J‘JˆEð Ÿ™ˆØ×&×&Ñ&ð AJˆL÷ ‹sñ ð ×)Ñ)Ø×7Ñ7Ø×/Ñ/Ø×(Ñ(ñ	ó�s�sŠsñ ð ×)Ñ)Ø×7Ñ7Ø×/Ñ/Ø×(Ñ(ñ	ó÷ ò ô  .¬e°I·O±OÓ.DÀiÇoÁoÐW`×WgÑWgÓh�Ø×Ñ°ÈÐ^cÐGdÐÔeØ×&Ñ& }Ô5Ø×(Ñ(¨¸EÀ4ÓHÐHà×:Ñ:¸9ÈeÓTˆØ×&Ñ& y¸%ÓNˆØ×Ñ¨LÈ4ÐÔPØ×"Ñ" =Ô1àˆr'   )r^   r\   r`   ra   rz   )r;   r<   r=   r>   rY   r\   r?   r]   r^   r`   ra   Ústaticmethodru   r†   rŠ   Úpropertyr’   r+   r–   rž   rŽ   r·   r¼   rÀ   rÄ   rÈ   rÖ   r@   r#   r'   r%   r[   r[   –   sÊ   ‡ ñ"ðH 15ÐÐ-Ó4ð $)Ð˜DÓ(Ø37ÐÐ0Ó7Ø9=ÐÐ6Ó=ØTXÐ%Ð'QÓXàô

ó ð

õpõoð ô&ó ð&ð ô"ó ð"õ"ð
 ô%ó ð%÷N"÷"÷"÷"÷"÷$ó $r'   r[   )+Ú
__future__r   Útypingr   r   r   r   r   r	   r
   r   r5   r   r   r   Úkornia.augmentation.baser   Úkornia.augmentation.utilsr   r   r   Ú!kornia.augmentation.utils.helpersr   r   Úkornia.core.opsr   Úkornia.core.utilsr   r   r   r   Úkornia.geometry.boxesr   Úkornia.geometry.keypointsr   rk   r   r+   r-   ÚstrÚ_LazyMatrixArgsrB   r[   r#   r'   r%   Ú<module>rå      sÁ   ðõ$ #ç S× SÓ Sã ß +Ñ +å 6ß hÑ hß TÝ $ß eÓ eÝ 'Ý /áˆT˜ # u§|¡|Ð"3Õ4Ô5€õôX�Zô Xð ˜˜eŸl™l¨NÐ:Õ;¸TÀ#ÀuÇ|Á|ÐBSÕ=TÐVZÐ[^Ð`cÐ[cÕVdÐdÕe€ôVdÐ*ô Vdôr\Ð$6ö \r'   