+
    öäûj L  ã                   ó�   € ^ RI 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 ^ RIHt ^ R	IHt  ! R
 R]4      tR# )é    )ÚAnyÚDictÚOptionalÚTupleN)ÚRigidAffineAugmentationBase2D)Ú_mixed_gate_shape_error)Ú_transform_output_shape)ÚResample©Ú_torch_inverse_cast)ÚBoxes)Ú	Keypointsc                   óv  a a€ ] tR t^t oRtR!V3R lR lltV3R lR ltR!V3R lR lltR"V3R lR	 lltR"V3R
 lV 3R lllt	R"V3R lR llt
R"V3R lR lltR"V3R lR lltR"V3R lR lltR"V3R lR lltR"V3R lR lltR"V3R lR lltR"V3R lR lltR"V3R lR lltR"V3R lR lltR tVtV ;t# )#ÚGeometricAugmentationBase2DuÆ  Build a 2D coordinate transform, applied per sample with probability ``p`` (default 0.5).

``output = MyAugmentation(...)(input)`` warps images of shape ``(B, C, H, W)`` once a subclass implements
``compute_transformation`` and ``apply_transform``. Implement ``inverse_transform`` to support image inversion.
Use :class:`IntensityAugmentationBase2D` for an augmentation that changes values without moving coordinates.

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:
    - pixel coordinates are ``(x, y)`` at integer pixel centers, with corners ``(0, 0)`` and
      ``(W - 1, H - 1)`` (see :doc:`/get-started/conventions`); rotations, shears and affine maps are centered
      at ``((W - 1) / 2, (H - 1) / 2)``, and ``transform_matrix`` maps input pixel coordinates to output pixel
      coordinates.
    - the resampling classes, including the non-rigid :class:`RandomElasticTransform` and
      :class:`RandomThinPlateSpline`, default to bilinear interpolation with zero sampler padding. The
      ``align_corners`` default is ``True`` for :class:`RandomRotation`, :class:`RandomRotation90` and the crop
      and resize classes, and ``False`` for :class:`RandomAffine`, :class:`RandomShear`,
      :class:`RandomTranslate`, :class:`RandomPerspective`, :class:`RandomElasticTransform` and
      :class:`RandomThinPlateSpline` (`#4412 <https://github.com/kornia/kornia/issues/4412>`_).
    - this base provides a matrix-based ``inverse`` interface. Whether a concrete augmentation can invert a
      call depends on its implementation: a subclass without ``inverse_transform`` raises ``NotImplementedError``.
      Inverse resampling cannot recover image or mask information lost through cropping, padding, or
      interpolation. Tensor-form boxes may lose rotated corners through axis-aligned enclosure.
      For an empty batch, image and mask inverse restore the spatial dimensions recorded in the parameters.
    - containers process integer masks in at least float32 and reject labels that cannot be represented
      exactly in the working dtype. Direct ``transform_masks`` calls use the image dtype guard and therefore
      reject ``bool`` masks.
    - a subclass supplies its own :meth:`inverse_transform` -- the base raises ``NotImplementedError`` --
      while :meth:`compute_inverse_transformation` defaults to inverting the sampled matrix.
    - a scalar magnitude ``x`` means ``center Â± x``, as it does for the intensity classes: its lower end
      is floored at the parameter's lower bound, and an upper end past the upper bound raises the same
      error the explicit range does. The bounds are ``(-360, 360)`` for :class:`RandomRotation`'s and
      :class:`RandomAffine`'s ``degrees`` and for :class:`RandomShear`'s and :class:`RandomAffine`'s
      ``shear``, ``(-1, 1)`` for :class:`RandomTranslate`'s ``translate_x`` and ``translate_y``,
      ``(0, 1)`` for :class:`RandomAffine`'s ``translate``, and ``(-3, 3)`` for
      :class:`RandomRotation90`'s ``times``. The 3D angle ranges -- :class:`RandomRotation3D`'s and
      :class:`RandomAffine3D`'s ``degrees``, :class:`RandomAffine3D`'s ``shears`` and
      :class:`RandomMotionBlur3D`'s ``angle`` -- raise ``ValueError`` past ``(-360, 360)``, in scalar and
      explicit form.

Note:
    Masks are resampled with nearest neighbour whatever ``resample`` the augmentation uses for images,
    unless ``resample`` is passed explicitly to ``transform_masks()`` or ``inverse_masks()`` --
    which is what ``extra_args[DataKey.MASK]`` does in a container. An explicit value is honoured in
    both directions. Antialiasing is disabled for masks by default, even when it is enabled for images.
    Only :class:`Resize` and its subclasses, :class:`LongestMaxSize` and :class:`SmallestMaxSize`, read the
    flag: pass ``antialias=True`` explicitly to ``transform_masks()`` or through ``extra_args[DataKey.MASK]`` to
    filter soft masks. Other geometric augmentations ignore it.

See Also:
    - :class:`AugmentationBase2D`: base class for general 2D augmentations.

c                óÀ   <€ V ^8„  d   QhRS[ P                  RS[S[S[3,          RS[S[ P                  ,          RS[S[S[S[3,          ,          RS[ P                  /# )é   ÚinputÚflagsÚ	transformÚsizeÚreturn)ÚtorchÚTensorr   Ústrr   r   r   Úint)ÚformatÚ__classdict__s   "€ÚbC:\Ai_Coding\apps\studio\ComfyUI\.venv\Lib\site-packages\kornia\augmentation\_2d\geometric\base.pyÚ__annotate__Ú(GeometricAugmentationBase2D.__annotate___   sc   ø€ ÷ "ñ "á�|‰|ð"ñ ‘C™�H�~ð"ñ ™EŸL™LÕ)ð	"ñ
 ‘u™S¡#˜X•Õ'ð"ñ 
�‰ñ"ó    c                ó   € \         h)zIBy default, the exact transformation as ``apply_transform`` will be used.)ÚNotImplementedError)Úselfr   r   r   r   s   &&&&&r   Úinverse_transformÚ-GeometricAugmentationBase2D.inverse_transform_   s
   € ô "Ð!r!   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# )r   r   r   )r   r   )r   r   s   "€r   r   r    i   s#   ø€ ÷ .ñ .¹¿¹ð .ÉÏÉñ .r!   c                ó   € \        V4      # )z?Compute the inverse transform of given transformation matrices.r   )r$   r   s   &&r   Úcompute_inverse_transformationÚ:GeometricAugmentationBase2D.compute_inverse_transformationi   s   € ä" 9Ó-Ð-r!   c          	      óº   <€ V ^8„  d   QhRS[ P                  RS[S[S[S[ P                  3,          ,          RS[S[S[S[3,          ,          RS[ P                  /# )r   r   Úparamsr   r   ©r   r   r   r   r   r   )r   r   s   "€r   r   r    m   sa   ø€ ÷ Rñ Rá�|‰|ðRñ ™™c¡5§<¡<Ð/Õ0Õ1ðRñ ™™S¡#˜X�Õ'ð	Rñ
 
�‰ñRr!   c                ó<  € Vf   V P                   MTpVe   V P                  WV4      pMHV P                  f/   V P                  VP                  4      pV P                  WV4      pMV P                  p\
        P                  ! WAP                  VP                  R7      # )zuObtain transformation matrices.

Return the current transformation matrix if existed. Generate a new one, otherwise.
)ÚdeviceÚdtype)	r   Úgenerate_transformation_matrixÚtransform_matrixÚforward_parametersÚshaper   Ú	as_tensorr/   r0   ©r$   r   r,   r   r   s   &&&& r   Úget_transformation_matrixÚ5GeometricAugmentationBase2D.get_transformation_matrixm   s�   € ð $šm�—
’
°ˆØÒØ×;Ñ;¸EÈ5ÓQ‰IØ×"Ñ"Ò*Ø×,Ñ,¨U¯[©[Ó9ˆFØ×;Ñ;¸EÈ5ÓQ‰Ià×-Ñ-ˆIÜ�Š˜y·±ÀUÇ[Á[ÔQÐQr!   c          
      óÄ   <€ V ^8„  d   QhRS[ P                  RS[S[S[ P                  3,          RS[S[S[3,          RS[S[ P                  ,          RS[ P                  /# ©r   r   r,   r   r   r   ©r   r   r   r   r   r   )r   r   s   "€r   r   r    �   ód   ø€ ÷ ñ á�|‰|ðñ ‘S™%Ÿ,™,Ð&Õ'ðñ ‘C™�H�~ð	ñ
 ™EŸL™LÕ)ðñ 
�‰ñr!   c                ó   € V# )zMProcess masks corresponding to the inputs that are no transformation applied.© r6   s   &&&&&r   Úapply_non_transform_maskÚ4GeometricAugmentationBase2D.apply_non_transform_mask�   ó	   € ð ˆr!   c                óÊ   <€ V ^8„  d   QhRS[ P                  RS[S[S[ P                  3,          RS[S[S[3,          RS[S[ P                  ,          RS[RS[ P                  /# ©r   r   r,   r   r   Úkwargsr   r;   )r   r   s   "€r   r   r    ‹   sv   ø€ ÷ \ñ \á�|‰|ð\ñ ‘S™%Ÿ,™,Ð&Õ'ð\ñ ‘C™�H�~ð	\ñ
 ™EŸL™LÕ)ð\ñ ð\ñ 
�‰ñ\r!   c                óà   <€ R V9  d1   R Vf   V P                   MT9   d   \        P                  ! R4      VR &   RV9  d   RVf   V P                   MT9   d   RVR&   \        SV `  ! WV3RV/VB # )ÚresampleÚnearestÚ	antialiasFr   )r   r
   ÚgetÚsuperÚtransform_masks)r$   r   r,   r   r   rD   Ú	__class__s   &&&&&,€r   rK   Ú+GeometricAugmentationBase2D.transform_masks‹   su   ø€ ð ˜VÔ#¨
ÀUÂ]°t·z²zÐX]Ô(^Ü!)§¢¨iÓ!8ˆF�:Ñð ˜fÔ$¨ÀuÂ}¸¿ºÐZ_Ô)`Ø"'ˆF�;Ñä‰wÒ& u°eÑ[ÀyÐ[ÐTZÑ[Ð[r!   c          
      óÄ   <€ V ^8„  d   QhRS[ P                  RS[S[S[ P                  3,          RS[S[S[3,          RS[S[ P                  ,          RS[ P                  /# r:   r;   )r   r   s   "€r   r   r    ž   sd   ø€ ÷ !ñ !á�|‰|ð!ñ ‘S™%Ÿ,™,Ð&Õ'ð!ñ ‘C™�H�~ð	!ñ
 ™EŸL™LÕ)ð!ñ 
�‰ñ!r!   c                ó´   € RpRpRV9   d/   VR,          f$   RpRpV P                   P                  RR4      VR&   V P                  WW44      pV'       d   WcR&   V# )aE  Process masks corresponding to the inputs that are transformed.

Note:
    Uses ``flags["resample"]`` as given; ``transform_masks()`` supplies "nearest" when the caller
    did not choose one.
    Treats ``align_corners=None`` as the module's own ``align_corners``, so a mask is resampled on the
    same grid as its input.

FNÚalign_cornersT)r   rI   Úapply_transform)r$   r   r,   r   r   Úalign_corners_was_noneÚoriginal_align_cornersÚoutputs   &&&&&   r   Úapply_transform_maskÚ0GeometricAugmentationBase2D.apply_transform_maskž   sm   € ð  (-ÐØ15Ðð
 ˜eÔ#¨¨oÕ(>Ò(FØ%)Ð"Ø%)Ð"Ø%)§Z¡Z§^¡^°OÀUÓ%KˆE�/Ñ"à×%Ñ% e°UÓFˆ÷ "Ø%;�/Ñ"àˆr!   c          
      óœ   <€ V ^8„  d   QhRS[ RS[S[S[P                  3,          RS[S[S[3,          RS[S[P                  ,          RS[ /# r:   ©r   r   r   r   r   r   r   )r   r   s   "€r   r   r    Á   s\   ø€ ÷ 1ñ 1áð1ñ ‘S™%Ÿ,™,Ð&Õ'ð1ñ ‘C™�H�~ð	1ñ
 ™EŸL™LÕ)ð1ñ 
ñ1r!   c                óš   € Vf&   V P                   f   \        R4      hV P                   pV P                  WW44      pVP                  V4      # )z?Process boxes corresponding to the inputs that are transformed.úRNo valid transformation matrix found. Please either pass one or forward one first.)r2   ÚRuntimeErrorÚapply_non_transform_boxÚtransform_boxes_r6   s   &&&&&r   Úapply_transform_boxÚ/GeometricAugmentationBase2D.apply_transform_boxÁ   sP   € ð ÒØ×$Ñ$Ò,Ü"Ð#wÓxÐxØ×-Ñ-ˆIØ×,Ñ,¨U¸EÓMˆØ×%Ñ% iÓ0Ð0r!   c          
      óœ   <€ V ^8„  d   QhRS[ RS[S[S[P                  3,          RS[S[S[3,          RS[S[P                  ,          RS[ /# r:   ©r   r   r   r   r   r   r   )r   r   s   "€r   r   r    Ð   s\   ø€ ÷ 5ñ 5áð5ñ ‘S™%Ÿ,™,Ð&Õ'ð5ñ ‘C™�H�~ð	5ñ
 ™EŸL™LÕ)ð5ñ 
ñ5r!   c                óš   € Vf&   V P                   f   \        R4      hV P                   pV P                  WW44      pVP                  V4      # )zCProcess keypoints corresponding to the inputs that are transformed.rZ   )r2   r[   Úapply_non_transform_keypointÚtransform_keypoints_r6   s   &&&&&r   Úapply_transform_keypointÚ4GeometricAugmentationBase2D.apply_transform_keypointÐ   sP   € ð ÒØ×$Ñ$Ò,Ü"Ð#wÓxÐxØ×-Ñ-ˆIØ×1Ñ1°%ÀÓRˆØ×)Ñ)¨)Ó4Ð4r!   c          
      óÄ   <€ V ^8„  d   QhRS[ P                  RS[S[S[ P                  3,          RS[S[S[3,          RS[S[ P                  ,          RS[ P                  /# r:   r;   )r   r   s   "€r   r   r    ß   r<   r!   c                ó   € V# )zDProcess class tags corresponding to the inputs that are transformed.r>   r6   s   &&&&&r   Úapply_transform_classÚ1GeometricAugmentationBase2D.apply_transform_classß   rA   r!   c                óÊ   <€ V ^8„  d   QhRS[ P                  RS[S[S[ P                  3,          RS[S[S[3,          RS[S[ P                  ,          RS[RS[ P                  /# rC   r;   )r   r   s   "€r   r   r    é   sn   ø€ ÷ -ñ -á�|‰|ð-ñ ‘S™%Ÿ,™,Ð&Õ'ð-ñ ‘C™�H�~ð	-ñ
 ™EŸL™LÕ)ð-ñ ð-ñ 
�‰ñ-r!   c                ó  € V P                  V4      pVP                  4       pV P                  V4      pV P                  ! Vf   V P                  MTV3/ VB w  r#Rp	RV9   d*   VR,          P                  4       p
V
R,          V
R	,          3p	VP                  ^ ,          ^ 8X  d)   V	e%   VP                  ! . VP                  RR OV	O5!  pV# VP                  4       '       g   TpV# VP                  4       '       d   V P                  WcWIR7      pV# V	eO   \        VP                  RR 4      V	8w  d2   \        VP                  R,          . VP                  ^R OV	O5RR7      hT P                  Wh,          Ve	   WH,          MTV	VR7      Wx&   V# )
z¼Inverse image inputs.

For an empty batch with recorded input-shape metadata, image and mask inverses
restore the recorded spatial size while preserving the inverse input's channel count.
NÚforward_input_shape)r   r   r   :é   NNT)Úinverse)r   r   r   éþÿÿÿéÿÿÿÿ)Útransform_tensorÚcloneÚ_gateÚ#_process_kwargs_to_params_and_flagsÚ_paramsÚtolistr4   ÚreshapeÚanyÚallr%   Útupler   )r$   r   r,   r   r   rD   Ú	in_tensorrT   Úto_applyr   Ú_sizes   &&&&&,     r   Úinverse_inputsÚ*GeometricAugmentationBase2D.inverse_inputsé   s™  € ð ×)Ñ)¨%Ó0ˆ	Ø—‘Ó"ˆØ—:‘:˜fÓ%ˆà×@Ò@Ø"šNˆD�LŠL°¸ñ
ØAGñ
‰ˆð +/ˆØ  FÔ*àÐ0Õ1×8Ñ8Ó:ˆEØ˜"•I˜u R�yÐ)ˆDð �?‰?˜1Õ Ô" tÒ'7Ø×&Ò&ÐD¨	¯©¸¸Ð(<ÐD¸tÓDˆFð  ˆð —‘—’ØˆFð ˆð �\‰\�^Š^Ø×+Ñ+¨IÈiÐ+ÓcˆFð ˆð Ò¤E¨)¯/©/¸"¸#Ð*>Ó$?À4Ô$GÜ-¨i¯o©o¸bÕ.AÐCbÀYÇ_Á_ÐUVÐWYÐEZÐCbÐ]aÑCbÐlpÔqÐqØ#×5Ñ5ØÕ#Ø1:Ò1F˜)Ö-ÈIØØð	  6ó  ˆFÑð ˆr!   c                óÊ   <€ V ^8„  d   QhRS[ P                  RS[S[S[ P                  3,          RS[S[S[3,          RS[S[ P                  ,          RS[RS[ P                  /# rC   r;   )r   r   s   "€r   r   r      sv   ø€ ÷ oñ oá�|‰|ðoñ ‘S™%Ÿ,™,Ð&Õ'ðoñ ‘C™�H�~ð	oñ
 ™EŸL™LÕ)ðoñ ðoñ 
�‰ñor!   c                ó¤  € \        V4      pR V9   d   \        P                  ! R4      VR &   RV9   d=   VR,          f&   V P                  P                  RR4      pWcR&   WeR&   MVR,          VR&   VP                  R4      pV P	                  WRR7      pV P
                  ! W‚W43/ VB p	V P                  '       d   \        W‘P                  VR7      # T	# )rF   rG   rP   Frm   )r4   Úmatch_channel)Úreference_shape)	Údictr
   rI   r   rr   r   Úkeepdimr	   r4   )
r$   r   r,   r   r   rD   Únormalized_align_cornersr4   r|   rT   s
   &&&&&,    r   Úinverse_masksÚ)GeometricAugmentationBase2D.inverse_masks  sÑ   € ô �U“ˆØ˜ÔÜ (§¢¨YÓ 7ˆE�*Ñð ˜fÔ$ð �oÕ&Ò.Ø+/¯:©:¯>©>¸/È5Ó+QÐ(Ø)A�oÑ&à*B�Ò'à)/°Õ)@��oÑ&à—
‘
Ð0Ó1ˆØ×)Ñ)¨%ÈEÐ)ÓRˆ	Ø×$Ò$ Y¸ÑSÈFÑSˆØVZ×Vb×VbÐVbÔ& v¯{©{ÈEÔRÐnÐhnÐnr!   c                ó¢   <€ V ^8„  d   QhRS[ RS[S[S[P                  3,          RS[S[S[3,          RS[S[P                  ,          RS[RS[ /# rC   rX   )r   r   s   "€r   r   r    7  sf   ø€ ÷ "ñ "áð"ñ ‘S™%Ÿ,™,Ð&Õ'ð"ñ ‘C™�H�~ð	"ñ
 ™EŸL™LÕ)ð"ñ ð"ñ 
ñ"r!   c                óF  € VP                  4       pV P                  V4      pVf   \        R4      hV P                  ! Vf   V P                  MTV3/ VB w  r#VP                  4       '       g   TpV# VP                  4       '       d   VP                  V4      pV# VP                  4       P                  V4      pVP                  4       pV P                  VP                  VP                  V4      Vn
        V P                  VP                  VP                  V4      Vn        V# )Nú/`transform` has to be a torch.Tensor. Got None.)rs   rt   r[   ru   rv   ry   rz   r]   Ú_blend_by_probÚdataÚ_dataÚ_valid)	r$   r   r,   r   r   rD   rT   r}   Úapplieds	   &&&&&,   r   Úinverse_boxesÚ)GeometricAugmentationBase2D.inverse_boxes7  sù   € ð —‘“ˆØ—:‘:˜fÓ%ˆàÒÜÐPÓQÐQà×@Ò@Ø"šNˆD�LŠL°¸ñ
ØAGñ
‰ˆð
 �|‰|�~Š~ØˆFð ˆð �\‰\�^Š^Ø×+Ñ+¨IÓ6ˆFð ˆð —k‘k“m×4Ñ4°YÓ?ˆGØ—[‘[“]ˆFØ×.Ñ.¨w¯|©|¸U¿Z¹ZÈÓRˆFŒLØ ×/Ñ/°·±ÀÇÁÈhÓWˆFŒMàˆr!   c                ó¢   <€ V ^8„  d   QhRS[ RS[S[S[P                  3,          RS[S[S[3,          RS[S[P                  ,          RS[RS[ /# rC   ra   )r   r   s   "€r   r   r    [  sf   ø€ ÷ %ñ %áð%ñ ‘S™%Ÿ,™,Ð&Õ'ð%ñ ‘C™�H�~ð	%ñ
 ™EŸL™LÕ)ð%ñ ð%ñ 
ñ%r!   c                óv  € VP                  4       pV P                  V4      pVf   \        R4      hV P                  ! Vf   V P                  MTV3/ VB w  r#VP                  4       '       g   TpV# VP                  4       '       d   VP                  V4      pV# W,          P                  WG,          4      Wg&   V# )a  Inverse the transformation on keypoints.

Args:
    input: input keypoints torch.Tensor or object.
    params: the corresponding parameters for an operation.
    flags: static parameters.
    transform: the inverse transformation matrix
    kwargs: additional arguments

rŒ   )rs   rt   r[   ru   rv   ry   rz   rd   )r$   r   r,   r   r   rD   rT   r}   s   &&&&&,  r   Úinverse_keypointsÚ-GeometricAugmentationBase2D.inverse_keypoints[  s´   € ð$ —‘“ˆØ—:‘:˜fÓ%ˆàÒÜÐPÓQÐQà×@Ò@Ø"šNˆD�LŠL°¸ñ
ØAGñ
‰ˆð
 �|‰|�~Š~ØˆFð ˆð �\‰\�^Š^Ø×/Ñ/°	Ó:ˆFð ˆð  %�×CÑCÀIÕDWÓXˆFÑàˆr!   c                óÊ   <€ V ^8„  d   QhRS[ P                  RS[S[S[ P                  3,          RS[S[S[3,          RS[S[ P                  ,          RS[RS[ P                  /# rC   r;   )r   r   s   "€r   r   r    ‚  sn   ø€ ÷ ñ á�|‰|ðñ ‘S™%Ÿ,™,Ð&Õ'ðñ ‘C™�H�~ð	ñ
 ™EŸL™LÕ)ðñ ðñ 
�‰ñr!   c                ó   € V# ©Nr>   )r$   r   r,   r   r   rD   s   &&&&&,r   Úinverse_classesÚ+GeometricAugmentationBase2D.inverse_classes‚  rA   r!   c                ó”   <€ V ^8„  d   QhRS[ P                  RS[S[S[S[ P                  3,          ,          RS[RS[ P                  /# )r   r   r,   rD   r   r-   )r   r   s   "€r   r   r    Œ  sH   ø€ ÷ ñ Ù—\‘\ðÙ+3±D¹¹e¿l¹lÐ9JÕ4KÕ+LðÙ_bðá	�‰ñr!   c                ór  € VP                   pV P                  V4      pV P                  ! Vf   V P                  MTV P                  3/ VB w  r&Vf   V P                  pV P                  WRVR7      pV P                  V4      pV P                  WRWg4      pV P                  '       d   V P                  W„4      # V# )a   Perform inverse operations.

Args:
    input: the input torch.Tensor.
    params: the corresponding parameters for an operation.
        If None, a new parameter suite will be generated.
    **kwargs: key-value pairs to override the parameters and flags.

)r,   r   )
r4   rr   ru   rv   r   r7   r)   r   r†   Útransform_output_tensor)	r$   r   r,   rD   Úinput_shaper|   r   r   rT   s	   &&&,     r   ro   Ú#GeometricAugmentationBase2D.inverseŒ  s±   € ð —k‘kˆØ×)Ñ)¨%Ó0ˆ	à×@Ò@Ø"šNˆD�LŠL°¸¿
¹
ñ
ØFLñ
‰ˆð Š>Ø—\‘\ˆFØ×2Ñ2°9ÐSXÐ2ÓYˆ	à×7Ñ7¸	ÓBˆ	Ø×$Ñ$ Y¸ÓIˆà�<�<ˆ<Ø×/Ñ/°ÓDÐDàˆr!   r>   )NNrš   )Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__r%   r)   r7   r?   rK   rU   r^   re   ri   r   rˆ   r’   r–   r›   ro   Ú__static_attributes__Ú__classdictcell__Ú__classcell__)rL   r   s   @@r   r   r      s°   ù‡ € ñ=÷~"ò "÷.ð .÷Rò R÷(ò ÷\õ \÷&!ò !÷F1ò 1÷5ò 5÷ò ÷-ò -÷^oò o÷>"ò "÷H%ò %÷Nò ÷÷ ò r!   r   )Útypingr   r   r   r   r   Úkornia.augmentation._2d.baser   Úkornia.augmentation.baser   Úkornia.augmentation.utilsr	   Úkornia.constantsr
   Úkornia.core.utilsr   Úkornia.geometry.boxesr   Úkornia.geometry.keypointsr   r   r>   r!   r   Ú<module>r²      s4   ð÷$ .Ó -ã å FÝ <Ý =Ý %Ý 1Ý 'Ý /ôJÐ"?ö Jr!   