+
    ýäûjE ã                   óü  € ^ RI t ^ RIt^ RIHtHtHtHtHt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 ^ RIHtHt ^ R	IHt ^ R
IHtHt ^ RIH t 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/H0t0H1t1 ^ RI2H3t3H4t4 ^ RI5H6t6H7t7 ^ RI8H9t9 ^RI:H;t; ^RI<H=t= ^RI>H?t?H@t@HAtAHBtBHCtC ^RIDHEtE ^RIFHGtG ^RIHHItI R.tJ] P–                  ] P˜                  ] Pš                  3tN] Pž                  3tP] P¢                  ] P¤                  3tS] P¨                  3tU] P¬                  ] P®                  3tX]]]3tY]]P´                  ]]P´                  ,          3,          t[R R lt\Rt] ! R R];]=4      t^R# ) é    N)
ÚAnyÚDictÚIteratorÚListÚLiteralÚOptionalÚSequenceÚTupleÚUnionÚcast)Únn)ÚRigidAffineAugmentationBase2D)ÚRandomElasticTransform)ÚRandomFisheye)ÚRandomThinPlateSpline)ÚAugmentationBase3DÚRigidAffineAugmentationBase3D)Ú_AugmentationBase)Ú_boxes_to_padded_tensorÚ_raise_input_rank_error)ÚDataKeyÚResample)Ú_check_async)ÚPILImage)Únumpy)Ú_is_pil_imageÚ_rebuild_container)Úeye_like)Ú _normalize_to_float32_or_float64Úis_autocast_enabledÚis_exporting)ÚBoxesÚ
VideoBoxes)Ú	KeypointsÚVideoKeypoints)Úimage_to_tensor)ÚTransformMatrixMinIn)ÚImageSequential)ÚAugmentationSequentialOpsÚDataTypeÚInputSequentialOpsÚ_filter_child_optionsÚ_validate_extra_args)Ú	ParamItem)ÚPatchSequential)ÚVideoSequentialÚAugmentationSequentialc                ó0   € V ^8„  d   QhR\         R\        /# )é   ÚargÚreturn)r   Úbool)Úformats   "ÚaC:\Ai_Coding\apps\studio\ComfyUI\.venv\Lib\site-packages\kornia\augmentation\container\augment.pyÚ__annotate__r9   A   s   € ÷ Nñ Nœð N¤ñ Nó    c                 ó‚   € \         P                  P                  R 4      pVRJ;'       d    \        WP                  4      # )r   N)ÚsysÚmodulesÚgetÚ
isinstanceÚndarray)r4   Únumpy_modules   & r8   Ú_is_numpy_arrayrB   A   s4   € ô —;‘;—?‘? 7Ó+€LØ˜tÐ#×MÐM¬
°3×8LÑ8LÓ(MÐMr:   z#either (D, H, W) or (B, C, D, H, W)c                   ó0  a a€ ] tR t^Lt oRtRtRtR]P                  3RRRRRRRRR	R
RR/V3R lV 3R lllt	V3R lV 3R llt
V3R lR lt]RQV3R lR ll4       tRRV3R lR lltRSV3R lR lltV3R lR ltRRRR/V3R lR llt]V3R lR l4       tV3R lR  ltRR/V3R! lR" lltRR/V3R# lR$ lltV3R% lR& ltV3R' lR( ltRRRR/V3R) lR* lltR+RR,R-/V3R. lV 3R/ llltV3R0 lR1 ltV3R2 lR3 ltV3R4 lR5 ltV3R6 lR7 ltV3R8 lR9 ltV3R: lR; ltV3R< lR= lt RSV3R> lR? llt!]V3R@ lRA l4       t"]V3RB lRC l4       t#]V3RD lRE l4       t$V3RF lRG lt%V3RH lRI lt&V3RJ lRK lt'V3RL lRM lt(V3RN lRO lt)RPt*Vt+V ;t,# )Tr1   aH  Augment aligned images, masks, boxes, keypoints and labels with one parameter draw.

``augmented = AugmentationSequential(*transforms, data_keys=keys)(*inputs)`` applies each selected child to the
aligned positional inputs and returns them in the same order. ``data_keys`` supports images, masks, boxes,
keypoints and class labels; inversion only reverses supported geometric children, so it is not generally a lossless
round trip. It records the selected children and their sampled parameters in ``_params`` for replay; use
:class:`~kornia.augmentation.container.ImageSequential` for an image tensor alone, or
:class:`~kornia.augmentation.container.VideoSequential` for a video tensor alone.

.. image:: _static/img/AugmentationSequential.png

Args:
    *args: a list of kornia augmentation modules.

    data_keys: the input type sequential for applying augmentations. Accepts "input", "image", "mask",
               "bbox", "bbox_xyxy", "bbox_xywh", "keypoints", "class", "label".

    same_on_batch: apply the same transformation across the batch. If None, it will not overwrite the function-wise
                   settings.

    keepdim: whether to keep the output shape the same as input (True) or broadcast it to the batch form (False).
             If None, it will not overwrite the function-wise settings.

    random_apply: randomly select children to apply. The selected children run in random order and repeat when the
                  requested count exceeds the number of children that can be drawn: the children with a nonzero
                  selection weight, mix augmentations not counted, plus one place when the count and the mix
                  augmentations together reach the number of children, since a mix augmentation is then certain to
                  take a place. With only mix children one of them is drawn, and with all weights 0 and no mix child
                  nothing is.
                  An int or a range that is not fixed to the number of children also repeats when the drawn count
                  exceeds the sum of the weights. That rule is deprecated since kornia 0.9.1, with a
                  ``FutureWarning`` on the calls whose draw it changes, as in
                  :class:`~kornia.augmentation.container.ImageSequential`.
                  If int, a fixed number of transformations will be selected.
                  If (a,), x number of transformations (a <= x <= len(args)) will be selected.
                  If (a, b), x number of transformations (a <= x <= b) will be selected.
                  If True, the whole list of args will be processed as a sequence in a random order, whatever the
                  scale of the weights, and so will a count fixed to the number of children. With a non-mix child of
                  weight 0 or more than one mix augmentation, that count cannot be filled: children repeat and some
                  may be left out.
                  If False, the whole list of args will be processed as a sequence in original order.
    random_apply_weights: selection weights for each child, as in
                          :class:`~kornia.augmentation.container.ImageSequential`.

    transformation_matrix_mode: computation mode for the chained transformation matrix, via `.transform_matrix`
                                attribute.
                                If `silent`, the default, the transformation matrix is computed silently and a
                                direct non-rigid module is skipped rather than treated as an identity. Nested
                                containers are not handled consistently; see the Convention note below.
                                If `rigid`, transformation matrix will be computed silently and the non-rigid
                                modules will trigger errors.
                                If `skip`, transformation matrix will be totally ignored.
                                In a caller's autocast region `.transform_matrix` keeps the input's dtype, and
                                float32 input is computed in float32.
                                The validator also accepts `silence`, an alias that behaves
                                like `silent`; any other value raises ``ValueError``.

    extra_args: a dict keyed by ``kornia.constants.DataKey`` that **replaces** the default
                ``{DataKey.MASK: {'resample': Resample.NEAREST, 'align_corners': None}}`` rather than
                merging into it, so an override that omits a key drops that key's default. An empty dict
                is falsy and restores the default. ``DataKey.IMAGE`` honours both entries and
                ``DataKey.KEYPOINTS`` honours neither. For ``DataKey.MASK`` on a 2D geometric augmentation
                that uses the base mask path the ``resample`` entry is honoured in both directions, and a
                dict without one resamples masks with nearest neighbour. ``align_corners`` is
                handler-dependent: some warps honor it, but resize mask paths replace it.
                :class:`~kornia.augmentation.RandomResizedCrop` in the default ``cropping_mode='slice'``
                ignores it for nearest resampling.
                :class:`~kornia.augmentation.RandomElasticTransform` has its own mask path and honours
                both entries. As in the constructors, ``resample`` may be a string, an int or a
                ``kornia.constants.Resample`` member.

Convention:
    - each child keeps the contract of its own base and class; mix and 3D children do not inherit every
      :class:`~kornia.augmentation.AugmentationBase2D` convention.
    - ``data_keys`` names one entry per positional argument, case-insensitively: ``input`` (alias
      ``image``), ``mask``, ``bbox``, ``bbox_xyxy``, ``bbox_xywh``, ``keypoints`` and ``label`` (alias
      ``class``); any other name raises a ``ValueError`` that is also a ``KeyError``. With ``data_keys=None``
      the call takes a dict whose keys are these names, optionally followed by a ``_`` or ``-`` suffix
      (``mask_2``, ``class_id``). The longest matching name wins and a suffix needs its separator:
      ``bbox_xyxy2`` is a ``bbox`` key and must hold vertices. Unrecognized keys (``images``, ``masks``,
      ``labels``) are returned unchanged, without a warning. The input dict is not modified.
    - the layouts are ``(B, C, H, W)`` for images and masks, ``(B, N, 4, 2)`` vertices for ``bbox``,
      ``(B, N, 4)`` for ``bbox_xyxy`` and ``bbox_xywh``, and ``(B, N, 2)`` in ``(x, y)`` for ``keypoints``;
      ``N = 0`` is accepted. 3D inputs are ``(D, H, W)`` or ``(B, C, D, H, W)``; rank 4 is rejected as
      ambiguous. A ``(B, H, W)`` mask is returned as ``(B, 1, H, W)``, or as ``(B, H, W)`` under
      ``keepdim=True``. A single tensor mask, ``(H, W)``, ``(1, H, W)``, ``(1, C, H, W)`` or one ``(C, H, W)``,
      next to a ``(B, C, H, W)`` image is repeated to batch ``B`` before the first child, so each sample's own
      parameters apply to its copy; a 3D mask whose leading size is ``B`` is read as ``(B, H, W)``. A list of
      masks is not repeated. A single ``(1, T, C, H, W)`` mask is repeated the same way next to a
      ``(B, T, C, H, W)`` video. Next to a BTCHW video a ``(B, T, H, W)`` mask is read with one channel and
      returned as ``(B, T, 1, H, W)``, and a single ``(1, T, H, W)`` mask is repeated too. Any other mask rank
      next to a video, or a 5D mask next to a non-video image, raises ``ValueError`` instead of guessing. A
      replay with no image (``params=`` given, no ``INPUT`` key) reads the batch to repeat to from the recorded
      params instead. A wrong input rank raises :class:`~kornia.core.exceptions.InputRankError` with the message
      a bare augmentation gives; next to a video or 3D child it lists the shapes the container runs, the
      video's 5D layout or ``(D, H, W)`` and ``(B, C, D, H, W)``
      (`#4424 <https://github.com/kornia/kornia/issues/4424>`_).
    - boxes use the inclusive ``xyxy_plus`` convention of :class:`~kornia.geometry.boxes.Boxes`. Flips map
      ``x' = W - 1 - x`` and ``y' = H - 1 - y`` for every key, as :func:`~kornia.geometry.transform.hflip`
      does. Labels pass through geometric steps untouched.
    - masks are resampled with nearest interpolation by default (see ``extra_args``; padding can still add the
      fill value) and come back in their own dtype. Floating masks use the image's working dtype; integer
      masks use at least float32 (float64 with a float64 image). Integer labels not exactly representable
      in that working dtype raise ``RuntimeError`` instead of being rounded, unless checks are disabled
      (``kornia.core.check.disable_checks``, ``python -O`` or ``KORNIA_CHECKS=0``). On accelerators an
      asynchronous assertion may report by the next synchronization; MPS before torch 2.13 checks on the host.
    - a ``mask`` list contains one tensor per image sample, in sample order. Each entry is
      ``(H, W)``, ``(C, H, W)`` or ``(1, C, H, W)``, with matching spatial dimensions; channel counts
      may differ. Each entry uses its sample's gate, transform parameters and matrix, including in
      nested sequences, auto-augment policies, replay and inverse. Full-batch mask tensors must use
      separate ``mask`` data keys; a list with incompatible length or entry shape raises ``ValueError``,
      also in an inverse without an image. Video, mix and 3D children, and a geometric
      :class:`~kornia.augmentation.container.PatchSequential`, do not support mask lists and raise
      ``NotImplementedError``. Inverse warps can only approximately restore resampled pixels and
      cannot recover pixels moved out of the frame.
    - the ``mask``, box and ``keypoints`` handlers of a geometric child, or of a custom
      :class:`~kornia.augmentation.RigidAffineAugmentationBase2D` subclass, receive the transform of the
      call's ``params``: the one the child recorded when it last transformed an image with those params, while no
      value in them has been replaced or edited in place, or else one recomputed from them, so a replay without
      the image, after a newer draw or after an edit follows ``params``. Inference tensors have no version
      counter, so an in-place edit made inside ``torch.inference_mode`` is not seen; replace the value instead.
      The mask limitations above apply; a handler the subclass does not implement raises
      ``NotImplementedError``. A non-rigid warp child has no matrix, so the coordinate keys are refused; see
      the note below.
    - ``.inverse()`` undoes the 2D geometric steps and leaves intensity, custom rigid and non-rigid steps
      applied. 3D geometric children raise ``NotImplementedError``, mix children ``RuntimeError``. Tensor
      boxes come back as axis-aligned enclosures; pass :class:`~kornia.geometry.boxes.Boxes` to keep rotated
      corners. Content lost to cropping, padding or interpolation is not recovered.
    - ``same_on_batch`` and ``keepdim`` default to ``None``, which keeps each child's own setting;
      ``True`` or ``False`` overrides it.
    - Nested :class:`AugmentationSequential` children contribute the matrix they record for the current call
      under their own ``transformation_matrix_mode``; one whose children are all non-rigid records none and is
      skipped. In ``silent`` mode, plain :class:`ImageSequential` children contribute their geometric operations,
      using each operation's recorded parameters even when the sampled sequence repeats a member. The ``rigid``
      mode still rejects a plain image sequence, and ``skip`` records no matrix.

.. note::
    :class:`~kornia.augmentation.RandomElasticTransform`, :class:`~kornia.augmentation.RandomThinPlateSpline`
    and :class:`~kornia.augmentation.RandomFisheye` warp the image without a transformation matrix, so a
    keypoint or box data key raises ``NotImplementedError`` when any of them is in the pipeline, nested
    containers included. The check reads the pipeline, not the sampled gates: it raises at ``p=0`` and when
    ``random_apply`` does not draw the warp. A ``mask`` key follows the image through
    :class:`~kornia.augmentation.RandomElasticTransform` and raises on the other two
    (`#4420 <https://github.com/kornia/kornia/issues/4420>`_).

.. note::
    A mix child (e.g. RandomMixUpV2, RandomCutMixV2, RandomMosaic) receives ``mask``, box and ``keypoints``
    keys with the image's parameters; keys it does not implement raise ``NotImplementedError``, as in a
    direct call. A ``class``/``label`` key raises ``NotImplementedError`` from the container.

.. note::
    See a working example `here <https://www.kornia.org/tutorials/nbs/data_augmentation_sequential.html>`__.

See Also:
    - :class:`~kornia.augmentation.container.ImageSequential`: chains transforms for an image tensor only.
    - :class:`~kornia.augmentation.container.VideoSequential`: chains transforms for a video tensor only.

Examples:
    >>> import kornia
    >>> input = torch.randn(2, 3, 5, 6)
    >>> mask = torch.ones(2, 3, 5, 6)
    >>> bbox = torch.tensor([[
    ...     [1., 1.],
    ...     [2., 1.],
    ...     [2., 2.],
    ...     [1., 2.],
    ... ]]).expand(2, 1, -1, -1)
    >>> points = torch.tensor([[[1., 1.]]]).expand(2, -1, -1)
    >>> aug_list = AugmentationSequential(
    ...     kornia.augmentation.ColorJiggle(0.1, 0.1, 0.1, 0.1, p=1.0),
    ...     kornia.augmentation.RandomAffine(360, p=1.0),
    ...     data_keys=["input", "mask", "bbox", "keypoints"],
    ...     same_on_batch=False,
    ...     random_apply=10,
    ... )
    >>> out = aug_list(input, mask, bbox, points)
    >>> [o.shape for o in out]
    [torch.Size([2, 3, 5, 6]), torch.Size([2, 3, 5, 6]), torch.Size([2, 1, 4, 2]), torch.Size([2, 1, 2])]
    >>> # apply the exact augmentation again.
    >>> out_rep = aug_list(input, mask, bbox, points, params=aug_list._params)
    >>> [(o == o_rep).all() for o, o_rep in zip(out, out_rep)]
    [tensor(True), tensor(True), tensor(True), tensor(True)]
    >>> # inverse the augmentations
    >>> out_inv = aug_list.inverse(*out)
    >>> [o.shape for o in out_inv]
    [torch.Size([2, 3, 5, 6]), torch.Size([2, 3, 5, 6]), torch.Size([2, 1, 4, 2]), torch.Size([2, 1, 2])]

This example demonstrates the integration of VideoSequential and AugmentationSequential.

    >>> import kornia
    >>> input = torch.randn(2, 3, 5, 6)[None]
    >>> mask = torch.ones(2, 3, 5, 6)[None]
    >>> bbox = torch.tensor([[
    ...     [1., 1.],
    ...     [2., 1.],
    ...     [2., 2.],
    ...     [1., 2.],
    ... ]]).expand(2, 1, -1, -1)[None]
    >>> points = torch.tensor([[[1., 1.]]]).expand(2, -1, -1)[None]
    >>> aug_list = AugmentationSequential(
    ...     VideoSequential(
    ...         kornia.augmentation.ColorJiggle(0.1, 0.1, 0.1, 0.1, p=1.0),
    ...         kornia.augmentation.RandomAffine(360, p=1.0),
    ...     ),
    ...     data_keys=["input", "mask", "bbox", "keypoints"]
    ... )
    >>> out = aug_list(input, mask, bbox, points)
    >>> [o.shape for o in out]  # doctest: +ELLIPSIS
    [torch.Size([1, 2, 3, 5, 6]), torch.Size([1, 2, 3, 5, 6]), ...([1, 2, 1, 4, 2]), torch.Size([1, 2, 1, 2])]

Perform ``OneOf`` transformation with ``random_apply=1`` and ``random_apply_weights``
in ``AugmentationSequential``.

    >>> import kornia
    >>> input = torch.randn(2, 3, 5, 6)[None]
    >>> mask = torch.ones(2, 3, 5, 6)[None]
    >>> bbox = torch.tensor([[
    ...     [1., 1.],
    ...     [2., 1.],
    ...     [2., 2.],
    ...     [1., 2.],
    ... ]]).expand(2, 1, -1, -1)[None]
    >>> points = torch.tensor([[[1., 1.]]]).expand(2, -1, -1)[None]
    >>> aug_list = AugmentationSequential(
    ...     VideoSequential(
    ...         kornia.augmentation.RandomAffine(360, p=1.0),
    ...     ),
    ...     VideoSequential(
    ...         kornia.augmentation.ColorJiggle(0.1, 0.1, 0.1, 0.1, p=1.0),
    ...     ),
    ...     data_keys=["input", "mask", "bbox", "keypoints"],
    ...     random_apply=1,
    ...     random_apply_weights=[0.5, 0.3]
    ... )
    >>> out = aug_list(input, mask, bbox, points)
    >>> [o.shape for o in out]  # doctest: +ELLIPSIS
    [torch.Size([1, 2, 3, 5, 6]), torch.Size([1, 2, 3, 5, 6]), ...([1, 2, 1, 4, 2]), torch.Size([1, 2, 1, 2])]

Use separate full-batch mask arguments when their channel counts differ:

    >>> import kornia.augmentation as K
    >>> input = torch.randn(2, 3, 32, 32)
    >>> mask_a = torch.ones(2, 3, 32, 32)
    >>> mask_b = torch.ones(2, 2, 32, 32)
    >>> aug_list = K.AugmentationSequential(
    ...     K.RandomHorizontalFlip(p=1.0),
    ...     data_keys=["input", "mask", "mask"],
    ... )
    >>> out = aug_list(input, mask_a, mask_b)
    >>> [value.shape for value in out]
    [torch.Size([2, 3, 32, 32]), torch.Size([2, 3, 32, 32]), torch.Size([2, 2, 32, 32])]

With ``data_keys=None``, dictionary keys match data-key names case-insensitively, optionally followed
by an underscore or hyphen suffix (for example, ``image_2`` or ``bbox_xyxy-left``). The longest matching
name wins, so coordinate boxes with an underscore/hyphen suffix retain their coordinate format.
Without that separator, ``bbox_xyxy2`` matches ``bbox`` and requires vertex boxes. ``input`` and ``class`` are
aliases of ``image`` and ``label``. Unrecognized items are returned without augmentation, and the
caller's dictionary is left intact.

    >>> import kornia.augmentation as K
    >>> img = torch.randn(1, 3, 256, 256)
    >>> mask = [torch.ones(1, 3, 256, 256), torch.ones(1, 2, 256, 256)]
    >>> bbox = [
    ...    torch.tensor([[28.0, 53.0, 143.0, 164.0], [254.0, 158.0, 364.0, 290.0], [307.0, 204.0, 413.0, 350.0]]),
    ...    torch.tensor([[254.0, 158.0, 364.0, 290.0], [307.0, 204.0, 413.0, 350.0]])
    ... ]
    >>> bbox = [Boxes.from_tensor(i).data for i in bbox]
    >>> aug_dict = K.AugmentationSequential(
    ...    K.ColorJiggle(0.1, 0.1, 0.1, 0.1, p=1.0),
    ...    K.RandomHorizontalFlip(p=1.0),
    ...    K.ImageSequential(K.RandomHorizontalFlip(p=1.0)),
    ...    K.ImageSequential(K.ColorJiggle(0.1, 0.1, 0.1, 0.1, p=1.0)),
    ...    data_keys=None,
    ...    same_on_batch=False,
    ...    random_apply=10,
    ... )
    >>> data = {'image': img, 'mask': mask[0], 'mask-b': mask[1], 'bbox': bbox[0], 'bbox-other':bbox[1]}
    >>> out = aug_dict(data)
    >>> out.keys()
    dict_keys(['image', 'mask', 'mask-b', 'bbox', 'bbox-other'])

NÚ	data_keysÚsame_on_batchÚkeepdimÚrandom_applyFÚrandom_apply_weightsÚtransformation_matrix_modeÚsilentÚ
extra_argsc                ó”  <€ V ^8„  d   QhRS[ S[S[3,          RS[S[ S[S[,          S[S[,          S[S[,          3,          ,          RS[S[,          RS[S[,          RS[ S[S[S[	S[S[3,          3,          RS[S[ S[S[
,          S[P                  3,          ,          RS[RS[S[S[S[S[S[3,          3,          ,          R	R
/	# )r3   ÚargsrD   rE   rF   rG   rH   rI   rK   r5   N)r   r   r(   r   r	   ÚstrÚintr   r6   r
   ÚfloatÚtorchÚTensorr   r   )r7   Ú__classdict__s   "€r8   r9   Ú#AugmentationSequential.__annotate__k  sã   ø€ ÷ A
ñ A
áÑ&©Ð7Õ8ðA
ñ ™E¡(©3¥-±¹#µÁÉÕ@QÐ"QÕRÕSðA
ñ  ¡•~ð	A
ñ
 ™$•ðA
ñ ™C¡¡u©S±#¨X¥Ð6Õ7ðA
ñ '¡u©X±e­_¹e¿l¹lÐ-JÕ'KÕLðA
ñ %(ðA
ñ ™T¡'©4±±S°­>Ð"9Õ:Õ;ðA
ð 
ñA
r:   c               ó  <€ V  . V n         \        SV `  ! VR VRVRVRVRR/  V P                  V4       \        \
        \        3V n        V  Ve-   V U	u. uF  p	\        P                  ! V	4      NK  	  up	V n
        MWn
        V P                  '       d²   \        ;QJ d&    R V P                   4       F  '       g   K   RM	  R	M! R V P                   4       4      '       d!   \        R
\         RV P                   R24      hV P                  ^ ,          \        P                  8w  d   \        R\        P                   R24      h\        V P                  4      V n        R	V n        R	V n        V Fƒ  p
\'        V
\(        4      '       d/   V
P+                  4       '       g   \,        P.                  ! R^R7       \'        V
\0        4      '       d   RV n        \'        V
\2        4      '       g   K|  RV n        K…  	  RV n        T;'       g%    \        P6                  R\8        P:                  RR//pVP=                  4        UUu/ uF2  w  r¼TRV9   d$   / VCR\8        P                  ! VR,          4      /CMTbK4  	  uppV n        R# u up	i u uppi )rE   rF   rG   rH   Úif_unsupported_opsÚskipNc              3   ó2   "  € T F  q\         9  x € K  	  R # 5i©N)r   )Ú.0Úin_types   & r8   Ú	<genexpr>Ú2AugmentationSequential.__init__.<locals>.<genexpr>’  s   é € ÐH¹¨g¤'Ö)»ùs   ‚TFz`data_keys` must be in z. Got Ú.zThe first input must be zSGeometric transformation detected in PatchSeqeuntial, which would break bbox, mask.)Ú
stacklevelÚresampleÚalign_corners) Ú_transform_matricesÚsuperÚ__init__Ú!_parse_transformation_matrix_moder   r   r1   Ú$_valid_ops_for_transform_computationr   r>   rD   ÚanyÚAssertionErrorÚINPUTÚNotImplementedErrorr)   Útransform_opÚcontains_video_sequentialÚcontains_3d_augmentationr?   r/   Úis_intensity_onlyÚwarningsÚwarnr0   r   Ú_transform_matrixÚMASKr   ÚNEARESTÚitemsrK   )ÚselfrD   rE   rF   rG   rH   rI   rK   rM   Úinpr4   ÚkeyÚvalueÚ	__class__s   &$$$$$$$*    €r8   rd   ÚAugmentationSequential.__init__k  s@  ø€ ñ 	ØACˆÔ ä‰ÒØð	
à'ð	
ð ð	
ð &ð		
ð
 "6ð	
ð  &ò	
ð 	×.Ñ.Ð/IÔJô *Ü)Ü"ðF
ˆÔ1ñ 	ØÒ Ù:CÓD¹)°3œgŸkšk¨#Ö.¹)ÑDˆD�Nà&ŒNà�>�>ˆ>ß‹sÑH¸¿ºÓH�s�sŠsÑH¸¿ºÓH×HÒHÜ$Ð'>¼w¸iÀvÈdÏnÉnÐM]Ð]^Ð%_Ó`Ð`à�~‰~˜aÕ ¤G§M¡MÔ1Ü)Ð,DÄWÇ]Á]ÀOÐSTÐ*UÓVÐVä5°d·n±nÓEˆÔà/4ˆÔ&Ø.3ˆÔ%ÛˆCÜ˜#œ×/Ò/¸×8MÑ8M×8OÒ8OÜ—’ØiÐvwõô ˜#œ×/Ò/Ø15�Ô.ä˜#Ô1×2Ô2Ø04�Ö-ñ ð "&ˆÔØ×hÐh¤G§L¡L°:¼x×?OÑ?OÐQ`ÐbfÐ2gÐ#hˆ
ð )×.Ñ.Ô0ô
á0‘
�ð È:ÐY^ÔK^ÐG�EÐG˜:¤x§|¢|°E¸*Õ4EÓ'FÒGÐdiÒiÙ0ò
ˆŽùò9 Eùó8
s   ÁJÈ>8Jc                ó   <€ V ^8„  d   QhRR/# )r3   r5   N© )r7   rS   s   "€r8   r9   rT   ®  s   ø€ ÷ %ñ %˜Tñ %r:   c                ó@   <€ V P                  4        \        SV `	  4       # )z4Reset cached params and transformation-matrix state.)Ú_reset_transform_matrix_staterc   Úclear_state)ru   ry   s   &€r8   r   Ú"AugmentationSequential.clear_state®  s   ø€ à×*Ñ*Ô,Ü‰wÑ"Ó$Ð$r:   c                ó8   <€ V ^8„  d   QhRS[ P                  RR/# )r3   Úmoduler5   N)r   ÚModule)r7   rS   s   "€r8   r9   rT   ³  s   ø€ ÷ 4ñ 4¹B¿I¹Ið 4È$ñ 4r:   c                ó„   € \        4       '       d   R # VP                  pVe   V P                  P                  V4       R # R # rY   )r!   Útransform_matrixrb   Úappend)ru   r‚   Úmatrixs   && r8   Ú%_update_transform_matrix_for_valid_opÚ<AugmentationSequential._update_transform_matrix_for_valid_op³  s8   € Ü�>Š>ÙØ×(Ñ(ˆð ÒØ×$Ñ$×+Ñ+¨FÖ3ñ r:   c                óÜ   <€ V ^8„  d   QhRS[ RS[S[,          RS[RS[S[S[S[3,          ,          RS[S[S[S[	P                  ,          ,          ,          RS[S[	P                  ,          /# )r3   Ú	containerÚparamsÚinputrK   Úsequence_matricesr5   )r(   r   r.   r*   r   r   rN   r   r   rQ   rR   )r7   rS   s   "€r8   r9   rT   ½  sz   ø€ ÷ kñ kÙ"ðká‘Y•ðkñ ðkñ ™T¡#¡s (�^Õ,ð	kñ
 $¡H©X±e·l±lÕ-CÕ$DÕEðkñ 
‘%—,‘,Õ	ñkr:   c              #  óº  "  € V EFK  pV P                  VP                  4      p\        WcV4      p\        V4      \        J d7   \
        P                  V\        P                  ! V4      W'V4       Rj  x€L
  Kt  \        V\
        4      '       d‰   Vf\   \        V4      \
        J dI   VP                  R8w  d6   \
        P                  V\        P                  ! V4      W'4       Rj  x€L
  Kç  Ké  Vf   VP                  M
\        V4      pVe   Vx € EK  EK  \        V\        \        34      '       g   EK1  \        P                  ! WeW'R7      x € EKN  	  R#  Lä Ls5i)z]Read invocation snapshots and parameter-aware geometric matrices from a plain image sequence.NrW   ©rK   )Úget_submoduleÚnamer,   Útyper(   r1   Ú_image_sequence_matricesr+   Úget_sequential_module_paramr?   Ú_transformation_matrix_argr…   Únextr   r   Úget_transform_matrix)	r‹   rŒ   r�   rK   rŽ   Úparamr‚   Ú
child_argsr‡   s	   &&&&&    r8   r”   Ú/AugmentationSequential._image_sequence_matrices¼  s,  é € ô ˆEØ×,Ñ,¨U¯Z©ZÓ8ˆFÜ.¨vÀ5ÓIˆJÜ�F‹|œÓ.Ü1×JÑJØÔ.×JÒJÈ5ÓQÐSXÐfwó÷ ò ô ˜FÔ$:×;Ò;Ø$Ò,´°f³ÔAWÓ1WØ×8Ñ8¸FÔBÜ#9×#RÑ#RØ"Ô$6×$RÒ$RÐSXÓ$YÐ[`ó$÷ ò ñ Cð
 9JÒ8Q˜V×4Ò4ÔW[Ð\mÓWn�FØÒ)Ø$�ò *ä˜FÔ%BÔDaÐ$b×cÕcÜ(×=Ò=¸fÈUÔjÕjó% ññùs,   ‚A0EÁ2EÁ3A2EÃ%EÃ&A
EÄ6"EÅEc                óv   <€ V ^8„  d   QhRS[ P                  RS[RS[RS[S[S[S[3,          ,          RS[RR/# )r3   r‚   r™   r�   rK   Úimage_transformedr5   N)	r   rƒ   r.   r*   r   r   rN   r   r6   )r7   rS   s   "€r8   r9   rT   Ù  sX   ø€ ÷ <ñ <á—	‘	ð<ñ ð<ñ ð	<ñ
 ™T¡#¡s (�^Õ,ð<ñ  ð<ð 
ñ<r:   c                ój  € \        WV4      p\        V4      \        J dƒ   V P                  R9   dr   \	        4       '       gb   V P
                  P                  T P                  T\        P                  ! V4      TTV'       d   \        VP                  4      MR4      4       R# V P                  V4       R# )zMCollect nested matrices, using invocation snapshots only after an image call.N)rJ   Úsilence)r,   r“   r(   r–   r!   rb   Úextendr”   r+   r•   ÚiterÚ_sequence_matricesÚ"_update_transform_matrix_by_module)ru   r‚   r™   r�   rK   r�   s   &&&&&&r8   Ú_update_image_sequence_matrixÚ4AugmentationSequential._update_image_sequence_matrixÙ  s�   € ô +¨6¸uÓEˆ
ä�‹LœOÓ+Ø×/Ñ/Ð3HÔHÜ —N’Nà×$Ñ$×+Ñ+Ø×-Ñ-ØÜ&×BÒBÀ5ÓIØØß7H”D˜×2Ñ2Ô3Èdóöð ×3Ñ3°FÖ;r:   c          	      ó�   <€ V ^8„  d   QhRS[ P                  RS[S[,          RS[S[S[S[3,          ,          RS[ P                  /# )r3   r�   rŒ   rK   r5   )rQ   rR   r   r.   r   r   rN   r   )r7   rS   s   "€r8   r9   rT   ô  sK   ø€ ÷ ñ Ù—\‘\ðÙ+/±	­?ðÙHPÑQUÑVYÑ[^ÐV^ÕQ_ÕH`ðá	�‰ñr:   c                ó  € \        WV4      pV P                  4        V FI  pV P                  VP                  4      p\        P
                  ! WWCR7      pV P                  WTWR7       KK  	  \        4       '       g   W n        V# )aG  Apply prepared parameters and record the current transformation matrix.

Nested containers use this entry point instead of :meth:`forward`.

Args:
    input: Input tensor.
    params: Parameters for each child in execution order.
    extra_args: Optional overrides forwarded to child modules.

Returns:
    Transformed tensor.
)r‚   r™   rK   r�   )	r-   r   r‘   r’   r+   Ú	transformr¤   r!   Ú_params)ru   r�   rŒ   rK   r™   r‚   s   &&&&  r8   Útransform_inputsÚ'AugmentationSequential.transform_inputsô  sr   € ô *¨$¸FÓCˆ
Ø×ÑÔÛˆEØ×'Ñ'¨¯
©
Ó3ˆFÜ&×0Ò0°ÈUÔjˆEØ×.Ñ.¨v¸eÐ.Ö[ñ ô �~Š~Ø!ŒLØˆr:   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# )r3   r�   r5   )rQ   rR   )r7   rS   s   "€r8   r9   rT     s#   ø€ ÷ "ñ "¡U§\¡\ð "±e·l±lñ "r:   c                óV   € V P                   '       d   \        ^V4      # \        ^V4      # )zReturn identity matrix.)rm   r   )ru   r�   s   &&r8   Úidentity_matrixÚ&AugmentationSequential.identity_matrix  s(   € à×(×(Ð(Ü˜A˜uÓ%Ð%ä˜˜5Ó!Ð!r:   rŒ   c                ó  <€ V ^8„  d   QhRS[ S[S[S[S[3,          3,          RS[S[S[,          ,          RS[S[ S[S[,          S[S[,          S[S[,          3,          ,          RS[ S[S[S[,          S[S[S[3,          3,          /# ©r3   rM   rŒ   rD   r5   ©	r   r*   r   rN   r   r   r.   rO   r   )r7   rS   s   "€r8   r9   rT     s‹   ø€ ÷ @ñ @á‘X™t¡C© MÕ2Ð2Õ3ð@ñ ™™i�Õ)ð@ñ ™E¡$¡s¥)©T±#­Y¹¹W½Ð"EÕFÕGð	@ñ
 
‰x™™h�©©c±8¨mÕ)<Ð<Õ	=ñ@r:   c          
     óÌ  € Rp\        V4      ^8X  dX   \        V^ ,          \        4      '       d;   V P                  \	        \
        \        \        3,          V^ ,          4      4      w  rBr5V P                  P                  pV P                  P                  V4      V P                  n	         Vf   V P                  pV P                  ! VRV P                  P                  RV/  V P                  ! VRV P                  P                  / pVf   \        R4      h\        V P                  P                  4      pV P                   P#                  4        U	U
u/ uF  w  ršW˜9   g   K  V	\%        W
V4      bK  	  pp	p
TpVRRR	1,           Fƒ  pV P'                  VP(                  4      pV P                  P*                  ! VRVRVRV/ p\        V P                  P                  4      ^8X  g   \        V\,        \.        34      '       d   K€  V.pK…  	  V P1                  W<V P                  P                  R7      pW`P                  n	        \        V\.        4      '       d<   \3        WÄ4       UUu/ uF	  w  ppVVbK  	  pppX'       d   VP5                  V4       V# \        V4      ^8X  d    \        V\,        4      '       d
   V^ ,          # V# u up
p	i   Y`P                  n	        i ; iu uppi )
a  Reverse the transformation applied.

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

Number of input tensors must align with the number of``data_keys``. If ``data_keys`` is not set, use
``self.data_keys`` by default.
NrD   rŒ   zrNo parameters available for inversing, please run a forward pass first or passing valid params into this function.r‚   r™   rK   ©rD   éÿÿÿÿ)Úlenr?   ÚdictÚ_preproc_dict_datar   r   rN   r*   rk   rD   Úpreproc_datakeysr©   Ú_validate_args_datakeysÚ_arguments_preprocÚ
ValueErrorÚsetrK   rt   r-   r‘   r’   ÚinverseÚlistÚtupleÚ_arguments_postprocÚzipÚupdate)ru   rŒ   rD   rM   Úoriginal_keysÚinvalid_dataÚoriginal_data_keysÚin_argsÚpresentrw   rx   rK   Úoutputsr™   r‚   ÚvÚkÚresults   &$$*              r8   r¾   ÚAugmentationSequential.inverse  s’  € ð ˆÜˆt‹9˜Œ>œj¨¨a­´$×7Ò7Ø;?×;RÑ;RÔSWÔX\Ô]`ÔbjÐ]jÕXkÐmqÐrsÕmtÓSuÓ;vÑ8ˆM dð "×.Ñ.×8Ñ8ÐØ&*×&7Ñ&7×&HÑ&HÈÓ&Sˆ×ÑÔ#ð	=ØŠ~ØŸ™�Ø×(Ò(¨$Ðe¸$×:KÑ:K×:UÑ:UÐeÐ^dÒeà×-Ò-¨tÐ[¸t×?PÑ?P×?ZÑ?ZÑ[ˆGàŠ~Ü ðBóð ô
 ˜$×+Ñ+×5Ñ5Ó6ˆGð #'§/¡/×"7Ñ"7Ô"9ôá"9‘J�CØ‘>ô ?�Ô)¨$°vÓ>Ò>Ù"9ð ñ ð
 '.ˆGØ¡ " Ÿ˜�Ø×+Ñ+¨E¯J©JÓ7�Ø×+Ñ+×3Ò3°WÐpÀVÐpÐSXÐpÐeoÑp�Ü�t×(Ñ(×2Ñ2Ó3°qÔ8Ä
È7ÔUYÔ[`ÐTa×@bÔ@bà&˜i’Gñ &ð ×.Ñ.¨tÈ×HYÑHY×HcÑHcÐ.ÓdˆGð +=×ÑÔ'Ü�m¤U×+Ò+Ü'*¨7Ô'BÔCÑ'B™t˜q !�a˜’dÑ'BˆFÑCßØ—‘˜lÔ+ØˆMäˆw‹<˜1Ô¤¨G´T×!:Ò!:Ø˜1•:Ðàˆùó5øð  +=×ÑÕ'üãCs2   Â+B)K Å
KÅ#KÅ4BK È.K É'K ËK ËKc                óx   <€ V ^8„  d   QhRS[ S[P                  ,          RS[RS[S[P
                  ,          RR/# )r3   ÚmaskÚbatchÚsizer5   N)r   rQ   rR   rO   r   ÚSize)r7   rS   s   "€r8   r9   rT   W  sE   ø€ ÷ yñ y¡$¡u§|¡|Õ"4ð y¹Sð yÉÑQV×Q[ÑQ[ÕH\ð yÐaeñ yr:   c                ób  € \        V 4      V8w  d   \        RV R\        V 4       R24      h\        V 4       Fô  w  r4\        V\        P
                  4      '       g&   \        RV R\        V4      P                   R24      hVP                  R9  g*   VP                  ^8X  d>   VP                  ^ ,          ^8w  d&   \        RV R\        VP                  4       R24      hVf   K¯  VP                  RR V8w  g   KÅ  \        RV R	\        V4       R
\        VP                  4       R24      h	  R# )z?Validate the per-sample mask-list layout before any child runs.z-Mask list must contain one entry per sample (z); got r^   zMask list entry z must be a torch.Tensor; got z0 must be (H, W), (C, H, W) or (1, C, H, W); got z5. Use separate mask data keys for full-batch tensors.Nz must have spatial size z; got ©r3   é   é   éþÿÿÿ)r¶   r¼   Ú	enumerater?   rQ   rR   r“   Ú__name__ÚndimÚshaperÀ   )rÏ   rÐ   rÑ   ÚiÚentrys   &&&  r8   Ú_validate_mask_listÚ*AugmentationSequential._validate_mask_listV  s)  € ô ˆt‹9˜ÔÜÐLÈUÈGÐSZÔ[^Ð_cÓ[dÐZeÐefÐgÓhÐhÜ! $ž‰HˆAÜ˜e¤U§\¡\×2Ò2Ü Ð#3°A°3Ð6SÔTXÐY^ÓT_×ThÑThÐSiÐijÐ!kÓlÐlØ�z‰z Ô*¨u¯z©z¸Q¬À5Ç;Á;ÈqÅ>ÐUVÔCVÜ Ø& q cð *Ü  §¡Ó-Ð.Ð.cðeóð ð Ô E§K¡K°°Ð$4¸Ö$<Ü Ð#3°A°3Ð6NÌuÐUYË{ÈmÐ[aÔbgÐhm×hsÑhsÓbtÐauÐuvÐ!wÓxÐxó (r:   c                ó4   <€ V ^8„  d   QhRS[ S[,          RR/# )r3   rD   r5   N)r   r   )r7   rS   s   "€r8   r9   rT   f  s    ø€ ÷ ñ ÁTÉ'Å]ð ÐW[ñ r:   c                ó  € V F„  pV\         9  d   V\        9  d   K  V P                  4        FU  p\        V\        4      '       g   K  \        \        V4      P                   R VP                  P                  4        R24      h	  K†  	  R# )z does not support z: inputs. See https://github.com/kornia/kornia/issues/4420.N)
Ú_KEYPOINTS_OPTIONSÚ_BOXES_OPTIONSr=   r?   Ú_NON_RIGID_WARPSrj   r“   rÙ   r’   Úlower)ru   rD   rw   r‚   s   &&  r8   Ú+_reject_coordinates_through_non_rigid_warpsÚBAugmentationSequential._reject_coordinates_through_non_rigid_warpsf  s|   € ó ˆCØÔ,Ô,°¼NÔ1JÙØŸ,™,ž.�Ü˜fÔ&6×7Ô7Ü-Ü ›<×0Ñ0Ð1Ð1CÀCÇHÁHÇNÁNÓDTÐCUð VLð Lóð ó )ó r:   c                ó`   <€ V ^8„  d   QhRS[ RS[S[,          RS[S[S[,          ,          RR/# )r3   rM   rD   rŒ   r5   N©r*   r   r   r   r.   )r7   rS   s   "€r8   r9   rT   s  s@   ø€ ÷ Dñ DÙðDÙ*.©w­-ðDÙAIÉ$ÉyÍ/ÕAZðDà	ñDr:   c               óª  € \        V4      \        V4      8w  d%   \        R \        V4       R\        V4       R24      hRp\        W14       F  w  rVV\        9   g   K  Tp M	  RpV P                  p\        V\        P                  4      '       da   VP                  R9   g   VP                  ^8X  d?   V'       d7   VP                  R9   d   VP                  ^ ,          M^p	VP                  RR pM.Vf)   Ve%   V P                  '       g   V P                  V4      p	MR# V	f   R# V'       d9   V P                  4        U
u. uF  p
\        V
\        4      '       g   K  V
NK  	  up
M. pV'       d   V^ ,          P                  M^p\        W14       EF:  w  rÖV\        9  d   K  \        V\         4      '       d   V P#                  WÙV4       K=  \        V\        P                  4      '       g   K_  VP                  ^8X  d+   V'       g#   \%        R\'        VP                  4       R24      hV'       dL   VP                  ^8X  g;   VP                  ^8X  d   V^8X  g#   \%        R\'        VP                  4       R24      hV'       d“   \        V\        P                  4      '       ds   VP                  ^8X  db   VP                  V,          VP                  V,          8w  d9   \%        R\'        VP                  4       R\'        VP                  4       R24      hVP                  R9   d   VP                  ^ ,          M^pVf2   V^V	39  d&   \%        RV	 R	\'        VP                  4       R24      hEKâ  V^V	39  g   VP                  RR V8w  g   EK  \%        R
V	 R\'        VP                  4       R\'        VP                  4       R24      h	  R# u up
i )zBThe number of inputs must align with the number of data_keys. Got z and r^   Nz2A 5D mask is only valid next to a video; got mask z‡A mask next to a video must be 5D, (1, T, C, H, W) or (B, T, C, H, W), or (1, T, H, W) or (B, T, H, W) next to a BTCHW video; got mask z>Video and mask must have the same number of frames; got video z
 and mask zMask batch size must be 1 or z; got mask zVImage and mask must have matching spatial dimensions and compatible batch sizes (1 or z); got image rÔ   )rÖ   é   r×   )r¶   rh   rÂ   Ú_IMG_OPTIONSrl   r?   rQ   rR   rÚ   rÛ   rm   Ú_batch_size_from_paramsÚchildrenr0   Ú_temporal_channelÚ_MSK_OPTIONSr¿   rÞ   r¼   rÀ   )ru   rD   rŒ   rM   Úimager4   rw   Ú
image_sizeÚis_videoÚimage_batchÚcÚvideosÚtemporal_dimrÏ   Ú
mask_batchs   &$$*           r8   rº   Ú.AugmentationSequential._validate_args_datakeyss  sP  € ô ˆt‹9œ˜I›Ô&Ü ØTÔUXÐY]ÓU^ÐT_Ð_dÔehÐirÓesÐdtÐtuÐvóð ð ˆÜ˜DÖ,‰HˆCØ”lÖ"Ø�Ùñ -ð ,0ˆ
ð ×1Ñ1ˆÜ�eœUŸ\™\×*Ò*°·
±
¸iÔ0GÈEÏJÉJÐZ[ÌO×`hØ;@¿:¹:ÈÔ;O¨¯©°Q®ÐUVˆKØŸ™ R SÐ)‰JØŠ]˜vÒ1¸$×:W×:WÐ:Wà×6Ñ6°vÓ>‰KáØÒÙ÷ T\˜TŸ]™]œ_ÓO™_˜´
¸1¼o×0N—!�!™_ÒOÐacˆß6<�v˜a•y×2Ò2À!ˆÜ˜T×-‰IˆDØœ,Ô&ÙÜ˜$¤×%Ò%Ø×(Ñ(¨¸JÔGÙÜ˜d¤E§L¡L×1Ò1Ùð �y‰y˜AŒ~§hÜ Ð#UÔV[Ð\`×\fÑ\fÓVgÐUhÐhiÐ!jÓkÐkß §¡¨a¤°D·I±IÀ´NÀ|ÐWXÔGXÜ ðDÜDIÈ$Ï*É*ÓDUÐCVÐVWðYóð ÷
 Ü˜u¤e§l¡l×3Ò3Ø—J‘J !”OØ—J‘J˜|Õ,°·±¸LÕ0IÔIä ð!Ü!& u§{¡{Ó!3Ð 4°J¼uÀTÇZÁZÓ?PÐ>QÐQRðTóð ð +/¯)©)°vÔ*=˜Ÿ™ AžÀ1ˆJØÒ!Ø a¨Ð%5Ô5Ü$Ð'DÀ[ÀMÐQ\Ô]bÐcg×cmÑcmÓ]nÐ\oÐopÐ%qÓrÐrÚØ ! [Ð!1Ô1°T·Z±ZÀÀ°_È
×5RÜ ðØ(˜M¨´u¸U¿[¹[Ó7IÐ6JÈ*ÔUZÐ[_×[eÑ[eÓUfÐTgÐghðjóð óE .ùò Ps   Ä?OÅOc          	      ór   <€ V ^8„  d   QhRS[ RS[S[,          RS[S[S[,          ,          RS[S[ ,          /# )r3   rM   rD   rŒ   r5   ré   )r7   rS   s   "€r8   r9   rT   ¹  s>   ø€ ÷ 6ñ 6Ùð6Ù*.©w­-ð6ÙAIÉ$ÉyÍ/ÕAZð6á	‰h�ñ6r:   c               ó  € V P                   pR pRp\        W14       F³  w  rx\        P                  ! V4      \        9   g   K&  Rp\        \        P                  V4      P                  p\        V\        P                  4      '       dH   VP                  ^8X  g$   VP                  ^8X  d&   V P                  '       d   VP                  ^ ,          p M	  V'       g   Ve   V P                  V4      p. p	\        W14       EFý  w  rx\        P                  ! V4      \        9   d[   \        \        P                  V4      pVP                  p\        4       '       g   VP                  V n         V	P                  V4       K  \        P                  ! V4      \         9   d�   \        4       '       gi   \        V\"        4      '       d*   \%        V4      ^ 8”  d   V^ ,          P                  V n        M)\        \        P                  V4      P                  V n        V	P                  V P)                  WtV4      4       EK:  \        P                  ! V4      \*        9   d$   V	P                  V P-                  Wx4      4       EK|  \        P                  ! V4      \.        9   d$   V	P                  V P1                  Wx4      4       EK¾  \        P                  ! V4      \2        9   d   V	P                  V4       EKñ  \5        RV R24      h	  V	# )NFTúinput type of ú is not implemented.)Úinput_dtyperÂ   r   r>   rì   r   rQ   rR   Údtyper?   rÚ   rl   rÛ   rí   r!   r†   rð   r¿   r¶   Ú
mask_dtypeÚ_preproc_maskrâ   Ú_preproc_keypointsrã   Ú_preproc_boxesÚ_CLS_OPTIONSrj   )
ru   rD   rŒ   rM   Úworking_dtyperô   Ú	has_imager4   Údcaterv   s
   &$$*      r8   r»   Ú)AugmentationSequential._arguments_preproc¹  s  € ð ×(Ñ(ˆØ%)ˆØˆ	Ü˜dÖ.‰JˆCÜ�{Š{˜5Ó!¤\Ö1Ø �	Ü $¤U§\¡\°3Ó 7× =Ñ =�ô ˜c¤5§<¡<×0Ò0Ø—H‘H ”M c§h¡h°!¤m¸×8V×8VÐ8Và"%§)¡)¨A¥,�KÙñ /÷ ˜VÒ/à×6Ñ6°vÓ>ˆKØ ˆÜ˜d×.‰JˆCÜ�{Š{˜5Ó!¤\Ô1Üœ5Ÿ<™<¨Ó-�Ø #§	¡	�Ü#—~’~Ø'*§y¡y�DÔ$Ø—
‘
˜3–Ü—’˜UÓ#¤|Ô3ô $—~’~Ü! #¤t×,Ò,Ü˜s›8 aœ<Ø.1°!­f¯l©l˜DœOøä*.¬u¯|©|¸SÓ*A×*GÑ*G˜œØ—
‘
˜4×-Ñ-¨cÀ+ÓN×OÜ—’˜UÓ#Ô'9Ô9Ø—
‘
˜4×2Ñ2°3Ó>×?Ü—’˜UÓ#¤~Ô5Ø—
‘
˜4×.Ñ.¨sÓ:×;Ü—’˜UÓ#¤|Ô3Ø—
‘
˜3—ä)¨N¸5¸'ÐAUÐ*VÓWÐWñ7 /ð8 ˆ
r:   c          	      ór   <€ V ^8„  d   QhRS[ S[,          RS[ S[,          RS[ S[,          RS[ S[,          /# )r3   rÇ   Úout_argsrD   r5   )r   r*   r   )r7   rS   s   "€r8   r9   rT   ñ  s>   ø€ ÷ %ñ %Ù™H•~ð%Ù15±hµð%ÙLPÑQXÍMð%á	‰h�ñ%r:   c                ó„  € . p\        WV4       EF¢  w  rVp\        P                  ! V4      \        9   d   VP	                  V4       K9  \        P                  ! V4      \
        9   dB   V P                  \        \        V4      \        \        V4      4      pVP	                  V4       K™  \        P                  ! V4      \        9   dÇ   V P                  V\        \        V4      V4      p	\        4       '       d‚   \        V\        P                  \        34      '       d\   \        V	\         4      '       d+   V	 U
u. uF  qªP#                  VP$                  4      NK  	  p	p
MV	P#                  VP$                  4      p	VP	                  V	4       EK~  \        P                  ! V4      \&        9   dÇ   V P)                  V\        \*        V4      V4      p\        4       '       d‚   \        V\        P                  \*        34      '       d\   \        V\         4      '       d+   V U
u. uF  qªP#                  VP$                  4      NK  	  pp
MVP#                  VP$                  4      pVP	                  V4       EKc  \        P                  ! V4      \,        9   d   VP	                  V4       EK–  \/        R V R24      h	  V# u up
i u up
i )rü   rý   )rÂ   r   r>   rì   r†   rð   Ú_postproc_maskr   ÚMaskDataTyperâ   Ú_postproc_keypointr$   r    r?   rQ   rR   r¿   r“   rÿ   rã   Ú_postproc_boxesr"   r  rj   )ru   rÇ   r
  rD   ÚoutÚin_argÚout_argr  Ú_out_mÚ_out_krÜ   Ú_out_bs   &&&&        r8   rÁ   Ú*AugmentationSequential._arguments_postprocñ  sñ  € ð !ˆÜ&)¨'¸Y×&GÑ"ˆF˜UÜ�{Š{˜5Ó!¤\Ô1à—
‘
˜7Ö#ä—’˜UÓ#¤|Ô3Ø×,Ñ,¬T´,ÀÓ-HÌ$Ì|Ð]cÓJdÓe�Ø—
‘
˜6Ö"ä—’˜UÓ#Ô'9Ô9Ø×0Ñ0°¼¼iÈÓ9QÐSXÓY�Ü&×(Ò(¬Z¸ÄÇÁÌyÐ@Y×-ZÒ-ZÜ! &¬$×/Ò/Ù@FÓ!GÁ¸1§&¡&¨¯©Ö"6Á˜Ð!G˜à!'§¡¨V¯\©\Ó!:˜Ø—
‘
˜6×"ä—’˜UÓ#¤~Ô5Ø×-Ñ-¨f´d¼5À'Ó6JÈEÓR�Ü&×(Ò(¬Z¸ÄÇÁÌuÐ@U×-VÒ-VÜ! &¬$×/Ò/Ù@FÓ!GÁ¸1§&¡&¨¯©Ö"6Á˜Ð!G˜à!'§¡¨V¯\©\Ó!:˜Ø—
‘
˜6×"ä—’˜UÓ#¤|Ô3Ø—
‘
˜7×#ô *¨N¸5¸'ÐAUÐ*VÓWÐWñ? 'HðB ˆ
ùò) "Hùò "Hs   Ä8#J8È#J=c                ó    <€ V ^8„  d   QhRS[ /# )r3   r5   )rN   )r7   rS   s   "€r8   r9   rT     s   ø€ ÷ $ñ $©ñ $r:   c                óö   € V P                  4        Uu. uF  p\        V\        4      '       g   K  VNK  	  ppV'       d1   RRP                  V^ ,          P                  4      ,           R,           # \
        # u upi )zbDescribe the input shapes this container accepts next to a video or 3D child, for a rejected rank.Ú(z, Ú))rî   r?   r0   ÚjoinÚdata_formatÚ_VOLUME_BATCH_SHAPES)ru   rõ   rö   s   &  r8   Ú_video_or_volume_shapesÚ.AugmentationSequential._video_or_volume_shapes  s[   € ð "Ÿ]™]œ_ÓO™_˜´
¸1¼o×0N—!�!™_ˆÐOßØ˜Ÿ™ 6¨!¥9×#8Ñ#8Ó9Õ9¸CÕ?Ð?Ü#Ð#ùò Ps
   “A6°A6c                ó  <€ V ^8„  d   QhRS[ S[S[S[S[3,          3,          RS[S[S[,          ,          RS[S[ S[S[,          S[S[,          S[S[,          3,          ,          RS[ S[S[S[,          S[S[S[3,          3,          /# r±   r²   )r7   rS   s   "€r8   r9   rT   !  s‹   ø€ ÷ kñ ká‘X™t¡C© MÕ2Ð2Õ3ðkñ ™™i�Õ)ðkñ ™E¡$¡s¥)©T±#­Y¹¹W½Ð"EÕFÕGð	kñ
 
‰x™™h�©©c±8¨mÕ)<Ð<Õ	=ñkr:   c          
     ó|  € V P                  4        V'       d   VR,          f   VRR pK  Rp\        V4      ^8X  dX   \        V^ ,          \        4      '       d;   V P	                  \        \        \        \        3,          V^ ,          4      4      w  rBr5V P                  P                  V4      pW`P                  n         V P                  ! VRVRV/  V P                  V4       V P                  ! VRVRV/ p\        \!        \        V4      4      4      p\"        P$                  V9   d   VP'                  \"        P$                  4      p	VP)                  ^ VP+                  V	4      4       V U
u. uF  q§V
,          NK  	  pp
V U
u. uF  q¦V
,          NK  	  up
V P                  n        \"        P$                  V9   dˆ   V^ ,          p\        V\,        P.                  4      '       g   \1        R\3        V4       R24      hV P4                  '       d5   \        VP6                  4      ^8X  d   \9        VP6                  \:        4       VfÉ   \"        P$                  V9   d©   V^ ,          pV P<                  '       g   V P4                  '       dU   \        VP6                  4      R9  d%   \9        VP6                  V P?                  4       4       V PA                  VRR7      w  rÍMV PA                  VRR7      w  rÍV PC                  V4      pM\1        R4      h0 Vm\"        P$                  kpV PD                  PG                  4        UUu/ uF  w  ppWþ9   g   K  V\I        V VV4      bK  	  pppTpV FÌ  pV PK                  VPL                  4      pV P                  PN                  ! VRVR	VR
V/ p\        V P                  P                  4      ^8X  g   \        V\        \P        34      '       g   V.pV PS                  VVV^ ,          VPU                  \"        P$                  4      \"        P$                  V9   R7       KÎ  	  V\        \!        \        V4      4      4      8w  dZ   \!        \        V4      4       U
u. uF  q¨P'                  V
4      NK  	  pp
V U
u. uF  p
VV
,          NK  	  pp
W`P                  n        V PW                  VVVR7      pV P                  V P                  n        \Y        4       '       g   Wn-        \        V\P        4      '       d=   \]        VV4       UUu/ uF	  w  ppVVbK  	  pppX'       d   VP_                  V4       V# \        V4      ^8X  d    \        V\        4      '       d
   V^ ,          # V# u up
i u up
i u uppi u up
i u up
i   T P                  T P                  n        i ; iu uppi )z¦Compute multiple tensors simultaneously according to ``self.data_keys``.

See the Convention block on :class:`~kornia.augmentation.container.AugmentationSequential`.
NrD   rŒ   z&`INPUT` should be a torch.Tensor but `z` received.)Ú	dim_rangez;`params` must be provided whilst INPUT is not in data_keys.r‚   r™   rK   )rK   r�   r´   rµ   )rÕ   rÖ   rë   )rÕ   rë   )r3   rÖ   )0r   r¶   r?   r·   r¸   r   r   rN   r*   rk   r¹   rD   rº   ræ   r»   r¿   Úranger   ri   ÚindexÚinsertÚpoprQ   rR   r¼   r“   rm   rÛ   r   r  rl   r  Úautofill_dimÚforward_parametersrK   rt   r-   r‘   r’   r¨   rÀ   r¤   r>   rÁ   r!   r©   rÂ   rÃ   )ru   rŒ   rD   rM   rÄ   rÅ   rÆ   rÇ   Úinput_first_orderÚimage_indexrÜ   rv   Ú_Ú	out_shaperÈ   rw   rx   rK   rÉ   r™   r‚   Úrestore_orderrÊ   rË   rÌ   s   &$$*                     r8   ÚforwardÚAugmentationSequential.forward!  së  € ð 	×ÑÔ÷ �t˜B•xÒ'Ø˜˜�9ŠDð ˆÜˆt‹9˜Œ>œj¨¨a­´$×7Ò7Ø;?×;RÑ;RÔSWÔX\Ô]`ÔbjÐ]jÕXkÐmqÐrsÕmtÓSuÓ;vÑ8ˆM dà!×.Ñ.×?Ñ?À	ÓJÐØ&8×ÑÔ#ðC	9Ø×(Ò(¨$Ð\Ð:LÐ\ÐU[Ò\Ø×<Ñ<Ð=OÔPà×-Ò-¨tÐaÐ?QÐaÐZ`ÑaˆGô !%¤U¬3Ð/AÓ+BÓ%CÓ DÐÜ�}‰}Ð 2Ô2Ø0×6Ñ6´w·}±}ÓE�Ø!×(Ñ(¨Ð,=×,AÑ,AÀ+Ó,NÔOÙ/@ÓAÑ/@¨! 1Ÿ:˜:Ñ/@�ÐAÙN_Ó.`ÑN_ÈÀ!×/DÐ/DÑN_Ñ.`�×!Ñ!Ô+ä�}‰}Ð 2Ô2Ø˜a•j�Ü! #¤u§|¡|×4Ò4Ü$Ð'MÌdÐSVËiÈ[ÐXcÐ%dÓeÐeØ×0×0Ð0´S¸¿¹³^ÀqÔ5Hä+¨C¯I©IÔ7KÔLàŠ~ä—=‘=Ð$6Ô6Ø! !�*�Cà×5×5Ð5¸×9V×9VÐ9VÜ˜sŸy™y›>°Ô:Ü3°C·I±I¸t×?[Ñ?[Ó?]Ô^Ø'+×'8Ñ'8¸ÈÐ'8Ó'O™˜˜9à'+×'8Ñ'8¸ÈÐ'8Ó'O™˜Ø!×4Ñ4°YÓ?‘Fä$Ð%bÓcÐcð ;Ð*Ð:¬G¯M©MÐ:ˆGð #'§/¡/×"7Ñ"7Ô"9ôá"9‘J�C˜Ø‘>ô ?�Ô)¨$°°vÓ>Ò>Ù"9ð ñ ð
 <CˆGÛ�Ø×+Ñ+¨E¯J©JÓ7�Ø×+Ñ+×5Ò5°wÐrÀvÐrÐUZÐrÐgqÑr�Ü�t×(Ñ(×2Ñ2Ó3°qÔ8Ä
È7ÔUYÔ[`ÐTa×@bÒ@bà&˜i�GØ×2Ñ2ØØØ˜A•JØ)Ÿ~™~¬g¯m©mÓ<Ü&-§m¡mÐ7IÑ&Ið 3ö ñ  ð !¤D¬¬sÐ3DÓ/EÓ)FÓ$GÔGÜEJÌ3ÐO`ÓKaÔEbÓ cÑEbÀ×!8Ñ!8¸Ö!;ÑEb�Ð cÙ/<Ó=©}¨!˜7 1Ÿ:˜:©}�Ð=Ø.@×!Ñ!Ô+à×.Ñ.¨t°WÐHZÐ.Ó[ˆGà*.¯.©.ˆD×ÑÔ'Ü�~Š~Ø!ŒLä�m¤U×+Ò+Ü'*¨7°MÔ'BÔCÑ'B™t˜q !�a˜’dÑ'BˆFÑCßØ—‘˜lÔ+ØˆMäˆw‹<˜1Ô¤¨G´T×!:Ò!:Ø˜1•:ÐàˆùòI BùÚ.`ùó6ùò* !dùÚ=øð
 +/¯.©.ˆD×ÑÕ'üó
 Dsq   Ã B/V Å/U>Æ V ÆVÆA9V ÈA'V É9V ÊB7V ÍVÍVÍ$DV Ñ3VÒV ÒVÒ$&V Ô V8Õ>V ÖV5Úinput_names_to_handleÚoutput_typeÚptc          
      óf   <€ V ^8„  d   QhRS[ RS[S[S[ ,          ,          RS[R,          RS[ RS[ /# )r3   Úinputsr0  r1  Úkwargsr5   )r2  r   Úpil)r   r   r   r   )r7   rS   s   "€r8   r9   rT   Ž  sS   ø€ ÷ [ñ [áð[ñ  (©©S­	Õ2ð[ñ Ð1Õ2ð	[ñ
 ð[ñ 
ñ[r:   c          	     ó˜  <a € S P                   '       Eg   Tp\        V4      ^8X  dÅ   \        V^ ,          \        4      '       d¨   S P	                  V^ ,          4      w  rgr‰\        V^ ,          4      p
\        WhV4       Ff  w  r¼pV\        9   dC   \        V\        4      '       g   S P                  V4      '       d   S P                  V4      W«&   KS  S P                  WÍ4      W«&   Kh  	  V
3pM•S P                  P                  VP                  RS P                  4      4      p\        ;QJ d     . V 3R l\        W74       4       F  NK  	  5M! V 3R l\        W74       4       4      \        V\        V4      R 4      ,           pS P!                  V4       V Uu. uF(  q»\        9  g   K  V\"        9  g   K  VP$                  NK*  	  ppVR8w  d   V'       d   \'        RV: RV R24      hS P)                  \*        \,        S `^  VVVRS P0                  R7      pRp\        V4      ^8X  d<   \        V^ ,          \        4      '       d   S P	                  V^ ,          4      w  ppppMVP                  RS P                  4      pS P                  P                  V4      pS P3                  W÷V4      p\5        4       '       g8   \        V\6        P8                  4      '       d   VP;                  4       MTS n        \        V\        4      '       d   S P?                  WòV4      pV# S PA                  WòVV4      pV# \*        \,        S `^  ! V/ VB pV# u upi )	a  Overwrite the __call__ function to handle various inputs.

Arguments convert by data key, and only an image takes the image conversion. A mask given as a NumPy array,
a PIL image or an image file path keeps its dtype and label values, palette indices included. Every mask
must match the image's height and width, with a batch size of 1 or the image's. A single tensor mask
(``(H, W)``, batch 1, or one ``(C, H, W)`` mask) is repeated to the image's batch, so every sample's own
parameters apply to its copy and the output mask has the image's batch size; a 3D mask whose leading size
equals the image batch is read as ``(B, H, W)``. Arguments converted from NumPy go to the container's device
when it has parameters or buffers, as the image does.

Args:
    inputs: Inputs to operate on.
    input_names_to_handle: List of input names to convert.
        If None, convert every tensor, NumPy array and PIL image argument, and load a string as an image
        path only if it is the first positional argument, or the value of an ``input`` or ``image`` key
        (``image_0`` too) in a dictionary input.
    output_type: Desired output type ('pt', 'numpy', or 'pil').
    kwargs: Additional arguments.

Returns:
    Callable: Decorated function with converted input and output types.

rD   c              3   óJ   <"  € T F  w  rSP                  W4      x € K  	  R # 5irY   )Ú_convert_non_image)rZ   r4   Údata_keyru   s   &  €r8   r\   Ú2AugmentationSequential.__call__.<locals>.<genexpr>¼  s%   øé € ð )ÙPf¹}¸s�D×+Ñ+¨C×:Ð:ÓPfùs   ƒ #Nr2  zoutput_type=z9 converts images and masks only, and data_keys also hold z. Call with output_type='pt'.)Úsignature_source)!Ú_disable_featuresr¶   r?   r·   r¸   rÂ   rì   rN   Ú_is_valid_argÚ	to_tensorr9  rk   r¹   r>   rD   rÀ   Ú_check_output_typerð   r’   r¼   Ú_call_convertedrc   r(   Ú__call__r.  Ú_select_output_imager!   rQ   rR   ÚdetachÚ_output_imageÚ_convert_dict_outputÚ_convert_positional_output)ru   r0  r1  r4  r5  Úconverted_inputsÚkeysrD   rM   r+  Úconverted_dictrw   r4   r:  Ú
non_imagesÚtensor_outputrÄ   Úin_data_keysÚ_invalid_datarñ   rE  ry   s   f$$*,                €r8   rB  ÚAugmentationSequential.__call__Ž  sú  ù€ ð> ×%×%Ñ%Ø%ÐÜ�6‹{˜aÔ¤J¨v°a­y¼$×$?Ò$?Ø+/×+BÑ+BÀ6È!Å9Ó+MÑ(� Ü!% f¨Q¥i£�Ü*-¨d¸)Ö*DÑ&�C˜hà¤<Ô/´ZÀÄS×5IÒ5IÈT×M_ÑM_Ð`c×MdÒMdØ.2¯n©n¸SÓ.A˜Ó+à.2×.EÑ.EÀcÓ.T˜Ó+ñ +Eð %3Ð#4Ñ à ×-Ñ-×>Ñ>¸v¿z¹zÈ+ÐW[×WeÑWeÓ?fÓg�	ç#(¤5ô )ÜPSÐTZÔPfó)§5¡5ô )ÜPSÐTZÔPfó)ó $ä˜&¤ Y£Ð!1Ð2Ó3õ$4Ð ð
 ×#Ñ# KÔ0Ù.7Óo©i sÄlÑ;Rœ(ÐWZÔbnÑWnœ(˜#Ÿ(œ(©iˆJÐoØ˜dÔ"§zô !Ø" ;¡/Ð1jØ!�lÐ"?ðAóð ð !×0Ñ0Ü”o tÑ5Ø ØØ%ØØ!%§¡ð 1ó ˆMð 8<ˆMÜ�6‹{˜aÔ¤J¨v°a­y¼$×$?Ò$?ØEI×E\ÑE\Ð]cÐdeÕ]fÓEgÑB�˜|¨V±]à%Ÿz™z¨+°t·~±~ÓF�Ø×)Ñ)×:Ñ:¸<ÓHˆIð ×-Ñ-¨mÈÓVˆEÜ—>’>Ü7AÀ%ÌÏÉ×7VÒ7V U§\¡\¤^Ð\a�Ô"ô ˜m¬T×2Ò2ð ×)Ñ)¨-ÀeÓLð ð Ðð	 ×4Ñ4°]ÐQZÐ\aÓbð ð Ðô "¤/°4ÒAÀ6ÐTÈVÑTˆMØÐùòO ps   ÆMÆ'MÆ4Mc          
      óH   <€ V ^8„  d   QhRS[ RS[RS[S[,          RS[ RS[ /# )r3   rL  r1  rD   rñ   r5   )r   rN   r   r   )r7   rS   s   "€r8   r9   rT   ë  s@   ø€ ÷ @ñ @Ù ð@Ù/2ð@Ù?CÁG½}ð@ÙUXð@á	ñ@r:   c           
     ó  € \        V\        \        34      '       dS   \        V4      \        V4      8X  d:   \	        W4       UUu. uF  w  rVV P                  WRWd4      NK  	  ppp\        W4      # V P                  W4      # u uppi )z¯Convert a positional forward output for ``output_type``, one value per data key.

The outputs align with ``data_keys`` positionally; see :meth:`_convert_output_for_data_key`.
)r?   r¿   rÀ   r¶   rÂ   Ú_convert_output_for_data_keyr   Ú_convert_output)ru   rL  r1  rD   rñ   Úoutputr:  Ú	converteds   &&&&&   r8   rG  Ú1AugmentationSequential._convert_positional_outputë  s€   € ô �m¤d¬E ]×3Ò3¼¸MÓ8JÌcÐR[ËnÔ8\ô ),¨MÔ(Eôá(EÑ$�Fð ×1Ñ1°&ÀxÖWÙ(Eð ñ ô & mÓ?Ð?Ø×#Ñ# MÓ?Ð?ùós   ÁB c          
      ó^   <€ V ^8„  d   QhRS[ S[S[3,          RS[RS[RS[ S[S[3,          /# )r3   rL  r1  rñ   r5   )r   rN   r   )r7   rS   s   "€r8   r9   rT   ú  s?   ø€ ÷ 
ñ 
±$±s¹C°xµ.ð 
Ésð 
Ñ[^ð 
ÑcgÑhkÑmpÐhpÕcqñ 
r:   c                ób  € V P                  \        VP                  4       4      4      w  rE\        \	        V Uu. uF  qfT;'       g    . 9  g   K  VNK  	  upV4      4      pVP                  4        UU	u/ uF'  w  r‰W€P                  W’VP                  V4      V4      bK)  	  up	p# u upi u up	pi )aY  Convert a dict forward output for ``output_type``, keyed by its data keys.

Only the values under recognized image or mask keys take the conversion: an unrecognized key holds a
pass-through value the caller supplied, and moving it to channels-last (or making it a PIL image) is
not what they passed in. See :meth:`_convert_output_for_data_key`.
)Ú_read_datakeys_from_dictrÀ   rI  r·   rÂ   rt   rR  r>   )
ru   rL  r1  rñ   Úvalid_data_keysÚinvalid_keysrË   Úkey_data_keysrw   rx   s
   &&&&      r8   rF  Ú+AugmentationSequential._convert_dict_outputú  s­   € ð )-×(EÑ(EÄeÈM×L^ÑL^ÓL`ÓFaÓ(bÑ%ˆÜœS©]Ó!\©]¨È×HZÐHZÐXZÑ>[§! !©]Ñ!\Ð^mÓnÓoˆð ,×1Ñ1Ô3ô
á3‘
�ð ×2Ñ2°5À}×GXÑGXÐY\ÓG]Ð_dÓeÒeÙ3ò
ð 	
ùò "]ùó
s   ¹B&ÁB&ÁB&Á5-B+c          
      óH   <€ V ^8„  d   QhRS[ RS[RS[S[,          RS[ RS[ /# )r3   rx   r1  r:  rñ   r5   )r   rN   r   r   )r7   rS   s   "€r8   r9   rT     s:   ø€ ÷ 8ñ 8Ùð8Ù'*ð8Ù6>¹wÕ6Gð8ÙPSð8á	ñ8r:   c                óœ  € Vf   V# V\         9   d¬   VR8w  d¥   \        V\        P                  4      '       d…   VP	                  4       ^8X  dp   \        V\        P                  4      '       dP   VP	                  4       ^8X  d;   VP
                  ^ ,          VP
                  ^ ,          8X  d   VP                  ^4      pV P                  W4      # )aÀ  Convert one output value for ``output_type``.

A mask converts like the image, to the NumPy layout the mask input reads back (:meth:`to_numpy`), or to
one PIL image per sample. A 3D mask next to a batched image is read the way the input reads it: as
``(B, H, W)`` when its leading size is the image batch (a mask returned under ``keepdim=True``), so it gets
its channel axis back and stays batch-first; any other 3D mask is one ``(C, H, W)`` mask.
r2  )rð   r?   rQ   rR   ÚdimrÛ   Ú	unsqueezerS  )ru   rx   r1  r:  rñ   s   &&&&&r8   rR  Ú3AugmentationSequential._convert_output_for_data_key  s”   € ð ÒàˆLàœÔ$Ø˜tÔ#Ü˜5¤%§,¡,×/Ò/Ø—	‘	“˜qÔ Ü˜5¤%§,¡,×/Ò/Ø—	‘	“˜qÔ Ø—‘˜A• %§+¡+¨a¥.Ô0à—O‘O AÓ&ˆEØ×#Ñ# EÓ7Ð7r:   c                ó,   <€ V ^8„  d   QhRS[ RS[RS[ /# )r3   r4   r:  r5   )r   r   )r7   rS   s   "€r8   r9   rT   !  s"   ø€ ÷ ñ ¡cð ±Wð Áñ r:   c                óÔ  € V\         9   d   V# V\        9   Ed   \        V\        4      '       dV   V P	                  V4      '       d?   \
        P                  ! V4      ;_uu_ 4       p\        P                  ! V4      pR R R 4       M'\        V4      '       d   \        P                  ! V4      p\        V4      '       da   VP                  P                  '       g+   VP                  VP                  P                  R4      4      pV P                  \!        V4      4      # V# \        V4      '       d&   V P                  \"        P$                  ! V4      4      # V#   + '       g   i     L»; i)NÚ=)rì   rð   r?   rN   r>  ÚImageÚopenÚnpÚarrayr   rB   rÿ   ÚisnativeÚastypeÚnewbyteorderÚ_to_module_devicer&   rQ   Ú	as_tensor)ru   r4   r:  rÏ   s   &&& r8   r9  Ú)AugmentationSequential._convert_non_image!  sô   € Ø”|Ô#ØˆJØ”|Õ#ä˜#œs×#Ò#¨×(:Ñ(:¸3×(?Ò(?Ü—Z’Z —_”_¨ÜŸ(š( 4›.�C÷ %�_ä˜s×#Ò#Ü—h’h˜s“m�Ü˜s×#Ò#Ø—y‘y×)×)Ð)ØŸ*™* S§Y¡Y×%;Ñ%;¸CÓ%@ÓA�CØ×-Ñ-¬o¸cÓ.BÓCÐCØˆJÜ˜3×ÒØ×)Ñ)¬%¯/ª/¸#Ó*>Ó?Ð?Øˆ
÷ %—_ús   Á%EÅE'	c          	      óf   <€ V ^8„  d   QhRS[ RS[S[,          RS[S[S[R3,          ,          RS[ /# )r3   rT  rD   rÄ   .r5   )r   r   r   r   r
   rN   )r7   rS   s   "€r8   r9   rT   4  sA   ø€ ÷ ñ ÙðÙ&*©7¥mðÙDLÉUÑSVÐX[ÐS[Í_ÕD]ðá	ñr:   c                ó$  € \         P                  V9  d   R # VP                  \         P                  4      p\        V\        4      '       d   WV,          ,          # \        V4      ^8”  d%   \        V\        \        34      '       d	   W,          # V# rY   )r   ri   r$  r?   r·   r¶   r¿   rÀ   )ru   rT  rD   rÄ   Úidxs   &&&& r8   rC  Ú+AugmentationSequential._select_output_image4  si   € ô �=‰= 	Ô)ÙØ�o‰oœgŸm™mÓ,ˆÜ�fœd×#Ò#Ø¨Õ,Õ-Ð-Üˆy‹>˜AÔ¤*¨V´d¼E°]×"CÒ"CØ•;ÐØˆr:   c                ó¸   <€ V ^8„  d   QhRS[ S[S[3,          RS[S[S[R3,          S[S[,          S[S[R3,          S[S[ S[S[3,          ,          3,          /# )r3   Údatar5   .)r   rN   r*   r
   r   r   r   r   )r7   rS   s   "€r8   r9   rT   A  sY   ø€ ÷ <ñ <Ù™™h˜Õ'ð<á	‰u‘S˜#�X�¡¡W¥©u±X¸s°]Õ/CÁXÉdÑSVÑX[ÐS[ÍnÕE]Ð]Õ	^ñ<r:   c                óÆ  aa€ V P                   e   \        R4      h\        SP                  4       4      pV P	                  V4      w  poS'       d   S Uu/ uF  qDSV,          bK  	  upMR pS'       d3   \        ;QJ d    . V3R lV 4       F  NK  	  5M! V3R lV 4       4      MTp\        ;QJ d    . V3R lV 4       F  NK  	  5M! V3R lV 4       4      pW#We3# u upi )NzEIf you are using a dictionary as input, the data_keys should be None.c              3   ó8   <"  € T F  qS9  g   K  Vx € K  	  R # 5irY   r|   )rZ   rË   r[  s   & €r8   r\   Ú<AugmentationSequential._preproc_dict_data.<locals>.<genexpr>J  s   øé € Ð>¡˜1°Ñ(=—Q’Q£ùs   ƒ�
c              3   ó6   <"  € T F  pSV,          x € K  	  R # 5irY   r|   )rZ   rË   ru  s   & €r8   r\   rx  K  s   øé € Ð4©t¨!˜d 1Ÿgšg«tùs   ƒ)rD   r¼   rÀ   rI  rY  )ru   ru  rI  rD   rÜ   rÅ   Údata_unpackedr[  s   &f     @r8   r¸   Ú)AugmentationSequential._preproc_dict_dataA  s¯   ù€ ð �>‰>Ò%ÜÐdÓeÐeä�T—Y‘Y“[Ó!ˆØ"&×"?Ñ"?ÀÓ"EÑˆ	�<ß=I©LÓ9©L q˜4 �7š
©LÒ9ÈtˆßBN�uŒuÔ>¡Ó>�u‰uÔ>¡Ó>Ô>ÐTXˆßœÔ4©tÓ4Ÿ™Ô4©tÓ4Ó4ˆà Ð;Ð;ùò	 :s   ÁCc                ó|   <€ V ^8„  d   QhRS[ S[,          RS[S[S[,          S[S[S[,          ,          3,          /# )r3   rI  r5   )r	   rN   r
   r   r   r   )r7   rS   s   "€r8   r9   rT   O  s:   ø€ ÷ -ñ -©X±c­]ð -¹uÁTÉ'Å]ÑT\Ñ]aÑbeÕ]fÕTgÐEgÕ?hñ -r:   c                ó  a€ \        \        P                  \        R R7      oR V3R llp. p. pV F/  p VP	                  \        P
                  ! V! V4      4      4       K1  	  W43#   \         d    TP	                  T4        KU  i ; i)T)rw   Úreversec                ó0   € V ^8„  d   QhR\         R\        /# )r3   rw   r5   )rN   r   )r7   s   "r8   r9   ÚEAugmentationSequential._read_datakeys_from_dict.<locals>.__annotate__S  s   € ÷ 	Iñ 	Iœcð 	I¤gñ 	Ir:   c                óÜ   <€ V P                  4       pS FH  pW8X  g*   VP                  VR,           VR,           34      '       g   K2  \        P                  ! V4      u # 	  \	        RV  24      h)zDMatch a data-key name exactly or before an underscore/hyphen suffix.r+  Ú-z"Unrecognized data dictionary key: )ÚupperÚ
startswithr   r>   r¼   )rw   Ú	upper_keyr’   Únamess   &  €r8   Úretrieve_keyÚEAugmentationSequential._read_datakeys_from_dict.<locals>.retrieve_keyS  s`   ø€ àŸ	™	›ˆIÛ�ØÔ$¨	×(<Ñ(<¸dÀS½jÈ$ÐQTÍ*Ð=U×(VÔ(VÜ"Ÿ;š; tÓ,Ò,ñ ô ÐAÀ#ÀÐGÓHÐHr:   )Úsortedr   Ú__members__r¶   r†   r>   r¼   )ru   rI  r‡  rZ  r[  rË   r†  s   &&    @r8   rY  Ú/AugmentationSequential._read_datakeys_from_dictO  sƒ   ø€ ä”w×*Ñ*´¸TÔBˆ÷	Ið 	Ið ˆØˆÛˆAð'Ø×&Ñ&¤w§{¢{±<À³?Ó'CÖDñ ð Ð,Ð,øô ô 'Ø×#Ñ# A×&ð'ús   µ+A'Á'BÂBc                óf   <€ V ^8„  d   QhRS[ RS[S[P                  ,          RS[S[,          RS[ /# )r3   r4   rÿ   rô   r5   )r  r   rQ   rÿ   rO   )r7   rS   s   "€r8   r9   rT   e  sA   ø€ ÷ 
Wñ 
WÙð
WÙ(0±·±Õ(=ð
WÙLTÑUXÍMð
Wá	ñ
Wr:   c                óæ   € Ve   TM\         P                  p\        V\        4      '       d!   V Uu. uF  qPP	                  WT4      NK  	  up# V P                  V P	                  W4      V4      # u upi rY   )rQ   rP   r?   r¿   Ú
_cast_maskÚ_broadcast_single_mask)ru   r4   rÿ   rô   ÚworkingÚas   &&&&  r8   r  Ú$AugmentationSequential._preproc_maske  s^   € ð !Ò,‘%´%·+±+ˆÜ�cœ4× Ò á9<Ó=¹°A—O‘O AÖ/¹Ñ=Ð=Ø×*Ñ*¨4¯?©?¸3Ó+HÈ+ÓVÐVùò >s   ±A.c                óh   <€ V ^8„  d   QhRS[ P                  RS[ P                  RS[ P                  /# )r3   rÏ   rÿ   r5   )rQ   rR   rÿ   )r7   rS   s   "€r8   r9   rT   r  s.   ø€ ÷ ñ ™Ÿ™ð ©e¯k©kð ¹e¿l¹lñ r:   c                ó(  € V P                  4       '       g   \        V4      pV P                  V4      pV P                  \        P
                  \        P                  \        P                  \        P                  39   d“   \        P                  ! V P                  4      p\        P                  ! V\        VP                  ^,           4      8  VR4      pVP                  V P                  4      V 8H  P                  4       pRV R2p\        WV4       V# )z=Convert masks without silently rounding integer class labels.g        z5Integer mask labels must be exactly representable in zJ. Use a float64 image where supported or remap labels to smaller integers.)Úis_floating_pointr   Útorÿ   rQ   Úint32Úint64Úuint32Úuint64ÚiinfoÚwhererP   ÚmaxÚallr   )rÏ   rÿ   rU  ÚlimitsÚsafeÚexactÚmessages   &&     r8   rŽ  Ú!AugmentationSequential._cast_maskq  sÒ   € ð ×%Ñ%×'Ò'Ü4°UÓ;ˆEØ—G‘G˜E“Nˆ	ð �:‰:œ%Ÿ+™+¤u§{¡{´E·L±LÄ%Ç,Á,ÐOÔOÜ—[’[ §¡Ó,ˆFô
 —;’;˜y¬5°·±¸aµÓ+@Ñ@À)ÈSÓQˆDØ—W‘W˜TŸZ™ZÓ(¨DÑ0×5Ñ5Ó7ˆEàGÈÀwð O[ð [ð ô ˜Ô(ØÐr:   c                ód   <€ V ^8„  d   QhRS[ P                  RS[S[,          RS[ P                  /# )r3   rÏ   rô   r5   )rQ   rR   r   rO   )r7   rS   s   "€r8   r9   rT   ‰  s6   ø€ ÷ Fñ F¡U§\¡\ð FÁÉÅð FÑRW×R^ÑR^ñ Fr:   c                óv  € Ve   V^8X  g   V P                   R9  d   V # V P                   ^8X  d
   V R,          p V P                   ^8X  d%   V P                  ^ ,          ^V39  d   V R,          p MV P                  ^ ,          ^8w  d   V # V P                  ! V.V P                  R,          O5!  P                  4       # )am  Repeat a single mask along the batch so that each image sample transforms its own copy.

A mask that stands for "this mask for every image" is accepted by ``_validate_args_datakeys`` next to an
image of batch ``B > 1``. Unrepeated, a child would transform it with the parameters of sample 0 only
(flip, crop) or fail inside a per-sample warp (affine, perspective, ...), so it would not line up with
images ``1..B-1``.

The single-mask layouts are ``(H, W)``, ``(1, C, H, W)``, ``(1, H, W)`` and ``(C, H, W)``; an ``(H, W)``
mask is read as ``(1, H, W)``, as a NumPy ``(H, W)`` mask is. A 3D mask is read like ``transform_tensor``
reads it: as ``(B, H, W)`` when its leading size is the image batch (so it is left alone), otherwise as
one ``(C, H, W)`` mask. A 5D ``(1, T, C, H, W)`` mask, or a 4D ``(1, T, H, W)`` one, next to a video, only
expands dim 0; ``T`` is left alone.
N:é   NN)r3   rÕ   rÖ   rë   )rÚ   rÛ   ÚexpandÚ
contiguous)rÏ   rô   s   &&r8   r�  Ú-AugmentationSequential._broadcast_single_maskˆ  s—   € ð Ò +°Ô"2°d·i±iÀ|Ô6SØˆKØ�9‰9˜Œ>Ø˜•:ˆDØ�9‰9˜Œ>˜dŸj™j¨�m°A°{Ð3CÔCØ˜•:‰DØ�Z‰Z˜�]˜aÔØˆKà�{Š{˜;Ð8¨¯©°B­Ó8×CÑCÓEÐEr:   c                óF   <€ V ^8„  d   QhRS[ S[,          RS[S[,          /# )r3   rŒ   r5   )r   r.   r   rO   )r7   rS   s   "€r8   r9   rT   £  s#   ø€ ÷ (ñ (©©Y­ð (¹HÁS½Mñ (r:   c                óL   a€ R V3R lloV  F  pS! V4      pVf   K  Vu # 	  R# )zÝExtract the replay batch size when no image is available.

Args:
    params: Recorded parameter tree for the replayed augmentation call.

Returns:
    The original batch size, or None if no batch size could be recovered.
c                óF   € V ^8„  d   QhR\         R\        \        ,          /# )r3   rx   r5   )r   r   rO   )r7   s   "r8   r9   ÚDAugmentationSequential._batch_size_from_params.<locals>.__annotate__­  s   € ÷ 	ñ 	¤Cð 	¬H´S­Mñ 	r:   c                óF  <€ \        V \        4      '       d   S! V P                  4      # \        V \        4      '       d   V  F  pS! V4      pVf   K  Vu # 	  R# \        V \        4      '       d±   V P                  R4      pVeD   \        \        P                  ! V4      P                  R4      ^ ,          P                  4       4      # V P                  R4      pVeD   \        \        P                  ! V4      P                  R4      ^ ,          P                  4       4      # R# )zúRecursively read the original batch size stored in nested parameter metadata.

Args:
    value: A nested replay parameter value produced by a sequential augmentation.

Returns:
    The recovered batch size, or None when no batch metadata is present.
NÚvideo_batch_sizeÚforward_input_shaperµ   )r?   r.   ru  r¿   r·   r>   rO   rQ   rn  ÚreshapeÚitem)rx   r²  rÐ   Úvideo_batchr°  Ú_read_batch_sizes   &    €r8   r´  ÚHAugmentationSequential._batch_size_from_params.<locals>._read_batch_size­  sé   ø€ ô ˜%¤×+Ò+Ù'¨¯
©
Ó3Ð3Ü˜%¤×&Ò&Û!�DÙ,¨TÓ2�EØÔ(Ø$šñ "ñ Ü˜%¤×&Ò&Ø#Ÿi™iÐ(:Ó;�ØÒ*ÜœuŸš¨{Ó;×CÑCÀBÓGÈÕJ×OÑOÓQÓRÐRØ&+§i¡iÐ0EÓ&FÐ#Ø&Ò2ÜœuŸšÐ/BÓC×KÑKÈBÓOÐPQÕR×WÑWÓYÓZÐZÙr:   Nr|   )rŒ   r²  rÐ   r´  s   &  @r8   rí   Ú.AugmentationSequential._batch_size_from_params¢  s3   ø€ ÷	ð 	ó4 ˆDÙ$ TÓ*ˆEØÔ Ø’ñ ñ r:   c                ó,   <€ V ^8„  d   QhRS[ RS[ RS[ /# )r3   r4   Úliker5   )r  )r7   rS   s   "€r8   r9   rT   Í  s"   ø€ ÷ !ñ !¡,ð !±lð !Á|ñ !r:   c                óx  € \        V\        4      '       dd   \        V\        4      '       d   TMV.\        V4      ,          p\        W4       UUu. uF   w  rEVP	                  VP
                  4      NK"  	  upp# \        V\        4      '       d
   V^ ,          MTpVP	                  VP
                  4      # u uppi )r   )r?   r¿   r¶   rÂ   r–  rÿ   )ru   r4   r¸  Úlikesr‘  Úrefs   &&&   r8   r  Ú%AugmentationSequential._postproc_maskÍ  s†   € ô �cœ4× Ò Ü& t¬T×2Ò2‘D¸¸ÄÀSÃÕ8IˆEÜ25°c´/ÔB±/©¨�A—D‘D˜Ÿ™–O±/ÒBÐBÜ# D¬$×/Ò/ˆd�1Žg°TˆØ�v‰v�c—i‘iÓ Ð ùó Cs   Á&B6c                ó,   <€ V ^8„  d   QhRS[ RS[RS[/# ©r3   r4   r  r5   )r*   r   r"   )r7   rS   s   "€r8   r9   rT   ×  s"   ø€ ÷ 1ñ 1¡(ð 1±7ð 1¹uñ 1r:   c                óº  € \         P                  ! V4      \         P                  39   d   R pM‡\         P                  ! V4      \         P                  39   d   RpMZ\         P                  ! V4      \         P                  39   d   RpM-\        R\         P                  ! V4      P                   R24      h\        V\        4      '       d   V# V P                  '       d1   \        \        P                  V4      p\        P                  ! V4      # V P                  '       d   \!        R4      h\        \        P                  V4      p\        P                  ! WR7      # )Úvertices_plusÚ	xyxy_plusÚxywhúUnsupported mode `ú`.z&3D box handlers are not yet supported.©Úmode)r   r>   ÚBBOXÚ	BBOX_XYXYÚ	BBOX_XYWHr¼   r’   r?   r"   rl   r   rQ   rR   r#   Úfrom_tensorrm   rj   )ru   r4   r  rÆ  s   &&& r8   r  Ú%AugmentationSequential._preproc_boxes×  sù   € Ü�;Š;�uÓ¤'§,¡, Ô/Ø"‰DÜ�[Š[˜Ó¤G×$5Ñ$5Ð#6Ô6Ø‰DÜ�[Š[˜Ó¤G×$5Ñ$5Ð#6Ô6Ø‰DäÐ1´'·+²+¸eÓ2D×2IÑ2IÐ1JÈ"ÐMÓNÐNÜ�cœ5×!Ò!ØˆJØ×)×)Ð)Ü”u—|‘| SÓ)ˆCÜ×)Ò)¨#Ó.Ð.Ø×(×(Ð(Ü%Ð&NÓOÐOÜ”5—<‘< Ó%ˆÜ× Ò  Ô0Ð0r:   c                ó„   <€ V ^8„  d   QhRS[ RS[RS[RS[S[P
                  S[S[P
                  ,          S[3,          /# ©r3   r  r  r  r5   )r*   r"   r   r   rQ   rR   r   )r7   rS   s   "€r8   r9   rT   ê  sF   ø€ ÷ ,ñ ,Ùð,Ù).ð,Ù7>ð,á	‰u�|‰|™T¡%§,¡,Õ/±Ð6Õ	7ñ,r:   c                ó@  € \         P                  ! V4      \         P                  39   d   R pM‡\         P                  ! V4      \         P                  39   d   RpMZ\         P                  ! V4      \         P                  39   d   RpM-\        R\         P                  ! V4      P                   R24      h\        V\        4      '       d   V# \        V\        P                  4      '       d"   \        V\        4      '       g   \        W$4      # VP                  VR7      # )rÀ  rÁ  rÂ  rÃ  rÄ  rÅ  )r   r>   rÇ  rÈ  rÉ  r¼   r’   r?   r"   rQ   rR   r#   r   r?  )ru   r  r  r  rÆ  s   &&&& r8   r  Ú&AugmentationSequential._postproc_boxesê  sÓ   € ô �;Š;�uÓ¤'§,¡, Ô/Ø"‰DÜ�[Š[˜Ó¤G×$5Ñ$5Ð#6Ô6Ø‰DÜ�[Š[˜Ó¤G×$5Ñ$5Ð#6Ô6Ø‰DäÐ1´'·+²+¸eÓ2D×2IÑ2IÐ1JÈ"ÐMÓNÐNô �fœe×$Ò$ØˆNÜ�fœeŸl™l×+Ò+´J¸wÌ
×4SÒ4Sä*¨7Ó9Ð9à× Ñ  dÐ Ó+Ð+r:   c                ó,   <€ V ^8„  d   QhRS[ RS[RS[/# r¾  )r*   r   r$   )r7   rS   s   "€r8   r9   rT   ÿ  s"   ø€ ÷ 7ñ 7¡hð 7±wð 7Á9ñ 7r:   c                ó@  € R pV P                   '       EdN   \        V\        4      '       d   V# \        V\        4      '       d   \	        R4      h\        \        \        P                  \        \        P                  ,          3,          V4      p\        V\        4      '       dV   \        P                  ! V^ ,          4      '       g2   V^ ,          P                  pV Uu. uF  qDP                  4       NK  	  ppM8\        P                  ! V4      '       g   VP                  pVP                  4       p\        P                  ! V4      pV'       d   VP                  V4      # T# V P                   '       d   \#        R4      h\        V\        4      '       d   V# \        \        P                  V4      p\        P                  ! V4      '       g   VP                  pVP                  4       p\        P                  ! V4      pV'       d   VP                  V4      # T# u upi )Nz–A VideoSequential pipeline needs VideoKeypoints or a (B, T, N, 2) tensor for its keypoints, which carry the number of frames per video. Got Keypoints.z+3D keypoint handlers are not yet supported.)rl   r?   r%   r$   Ú	TypeErrorr   r   rQ   rR   r   r¿   r•  rÿ   rP   rÊ  r“   rm   rj   )ru   r4   r  rÿ   r‘  Úvideo_resultrÌ   s   &&&    r8   r  Ú)AugmentationSequential._preproc_keypointsÿ  s‰  € Øˆà×)×)Ñ)Ü˜#œ~×.Ò.Ø�
Ü˜#œy×)Ò)ÜðLóð ô ”uœUŸ\™\¬4´·±Õ+=Ð=Õ>ÀÓDˆCÜ˜#œt×$Ò$Ü×.Ò.¨s°1­v×6Ò6Ø �FŸL™L�EÙ.1Ó2©c¨Ÿ7™7ž9©c�CÐ2øÜ×,Ò,¨S×1Ò1ØŸ	™	�Ø—i‘i“k�Ü)×5Ò5°cÓ:ˆLß/4�<×$Ñ$ UÓ+ÐF¸,ÐFØ×(×(Ð(Ü%Ð&SÓTÐTÜ�cœ9×%Ò%ØˆJÜ”5—<‘< Ó%ˆÜ×&Ò& s×+Ò+Ø—I‘IˆEØ—)‘)“+ˆCä×&Ò& sÓ+ˆß%*ˆv�{‰{˜5Ó!Ð6°Ð6ùò! 3s   ÃHc                ó„   <€ V ^8„  d   QhRS[ RS[RS[RS[S[P
                  S[S[P
                  ,          S[3,          /# rÍ  )r*   r$   r   r   rQ   rR   r   )r7   rS   s   "€r8   r9   rT      sF   ø€ ÷ #ñ #Ùð#Ù)2ð#Ù;Bð#á	‰u�|‰|™T¡%§,¡,Õ/±Ð:Õ	;ñ#r:   c                óR   € \        V\        4      '       d   V# VP                  4       # rY   )r?   r$   r?  )ru   r  r  r  s   &&&&r8   r  Ú)AugmentationSequential._postproc_keypoint   s%   € ô �fœi×(Ò(ØˆNà× Ñ Ó"Ð"r:   )rE  r©   rb   rq   rf   rm   rl   rD   rK   rþ   r   rk   )NN)NTrY   )-rÙ   Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__rþ   r   r   ri   rd   r   rˆ   Ústaticmethodr”   r¤   rª   r®   r¾   rÞ   ræ   rº   r»   rÁ   r  r.  rB  rG  rF  rR  r9  rC  r¸   rY  r  rŽ  r�  rí   r  r  r  r  r  Ú__static_attributes__Ú__classdictcell__Ú__classcell__)ry   rS   s   @@r8   r1   r1   L   se  ù‡ € ñYðv €KØ€JðA
ð X_×WdÑWdÐVfðA
ð )-ð	A
ð
 #'ðA
ð ;@ðA
ð PTðA
ð +3ðA
ð ?C÷A
õ A
÷F%ó %÷
4ð 4ð ÷kñ kó ðk÷8<ò <÷6ò ÷2"ð "ð@ð -1ð@ð KO÷	@ò @ðD ÷yó ðy÷ð ðDØ]a÷Dò DðL6Ø]a÷6ò 6÷p%ð %÷N$ð $ðkð -1ðkð KO÷	kò kðZ[ð 6:ð[ð 6:÷	[õ [÷z@ð @÷
ð 
÷8ð 8÷2ð ÷&ð ÷<ð <÷-ð -÷,
Wò 
Wð ÷ó ðð, ÷Fó ðFð2 ÷(ó ð(÷T!ð !÷1ð 1÷&,ð ,÷*7ð 7÷B#÷ #ð #r:   )_r<   ro   Útypingr   r   r   r   r   r   r	   r
   r   r   rQ   r   Úkornia.augmentation._2d.baser   Ú3kornia.augmentation._2d.geometric.elastic_transformr   Ú)kornia.augmentation._2d.geometric.fisheyer   Ú3kornia.augmentation._2d.geometric.thin_plate_spliner   Úkornia.augmentation._3d.baser   r   Úkornia.augmentation.baser   Ú!kornia.augmentation.utils.helpersr   r   Úkornia.constantsr   r   Úkornia.core.checkr   Úkornia.core.externalr   rf  r   rh  Úkornia.core.mixin.image_moduler   r   Úkornia.core.opsr   Úkornia.core.utilsr   r    r!   Úkornia.geometry.boxesr"   r#   Úkornia.geometry.keypointsr$   r%   Úkornia.image.utilsr&   Úbaser'   rñ   r(   Úopsr)   r*   r+   r,   r-   rŒ   r.   Úpatchr/   Úvideor0   Ú__all__rÇ  rÈ  rÉ  rã   Ú	KEYPOINTSrâ   ri   ÚIMAGErì   rr   rð   ÚCLASSÚLABELr  rä   rR   r  rB   r  r1   r|   r:   r8   Ú<module>rú     s  ðó$ Û ß ]× ]× ]ã Ý å FÝ VÝ CÝ Uß ZÝ 6ß ^ß .Ý *Ý 2Ý ,ß LÝ $ß aÑ aß 3ß ?Ý .å &Ý "ß uÕ uÝ Ý "Ý "à#Ð
$€ð —,‘, × 1Ñ 1°7×3DÑ3DÐE€Ø×'Ñ'Ð)Ð Ø—‘˜wŸ}™}Ð-€Ø—‘ˆ€Ø—‘˜wŸ}™}Ð-€à*¨MÐ;PÐQÐ à�U—\‘\ 4¨¯©Õ#5Ð5Õ6€õNð =Ð ôZ#Ð1°?ö Z#r:   