+
    ýäûjáo  ã                   óÚ   € ^ RI HtHtHtHtHtHtHtHt ^ RI	t	^ RI	H
t
 ^ RIHt ^ RIHt ^ RIHt ^ RIHtHt ^ RIHtHtHtHtHt ^ RIHtHt ^ R	IHtH t  ^R
I!H"t" R.t# ! R R]4      t$R# )é    )ÚAnyÚDictÚListÚOptionalÚSequenceÚTupleÚUnionÚcastN)Únn)Ú_AugmentationBase)ÚSequentialBase)ÚImageSequentialÚ_get_new_batch_shape)Ú_frame_boxesÚ_frame_keypointsÚ_raise_input_rank_errorÚ_video_boxesÚ_video_keypoints)ÚBoxesÚ
VideoBoxes)Ú	KeypointsÚVideoKeypoints)Ú	ParamItemÚVideoSequentialc            
       ó8  a a€ ] tR t^*t oRt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R ltV3R lR ltV3R lR ltV3R lR lt	]
V3R lR l4       t]
V3R lR l4       t]
V3R lR l4       tV3R lR ltV3R lR ltV3R  lR! ltR7V3R" lV 3R# llltR7V3R$ lV 3R% llltR7V3R& lV 3R' llltR7V3R( lV 3R) llltR7V3R* lV 3R+ llltR7V3R, lV 3R- llltR7V3R. lV 3R/ llltR7V3R0 lV 3R1 llltR8V3R2 lR3 lltR8V3R4 lR5 lltR6tVtV ;t# )9r   aQ  Apply an image augmentation sequence to a video while optionally sharing draws across frames.

``output = VideoSequential(*modules, data_format=...)(video)`` accepts ``(B, T, C, H, W)`` by default or
``(B, C, T, H, W)`` with ``data_format="BCTHW"``, flattens it for the child modules, then restores that layout.
``same_on_frame=True`` shares supported augmentation draws across each clip's frames; use
:class:`~kornia.augmentation.container.AugmentationSequential` to transform a video with aligned annotations.

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

Args:
    *args: a list of augmentation module.
    data_format: only BCTHW and BTCHW are supported.
    same_on_frame: share each clip's sampled transform parameters across its temporal frames.
    random_apply: randomly select a sublist (order agnostic) of args to
        apply transformation. Selections repeat when the requested count is larger than the number of children
        that can be drawn, or, for an int or a range that is not fixed to the number of children, than the sum of
        the weights. That second rule is deprecated since kornia 0.9.1, with a ``FutureWarning`` on the calls whose
        draw it changes. See :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`.
    if_unsupported_ops: what ``inverse`` does on reaching a plain ``nn.Module``, as in
        :class:`~kornia.augmentation.container.ImageSequential`: ``'raise'`` or ``'skip'``.

Convention:
    - the input is 5-dimensional and the layout is named by ``data_format``, which accepts ``"BTCHW"``
      (the default) and ``"BCTHW"``, case-insensitively; any other spelling raises ``AssertionError``.
      The output keeps the input layout.
    - ``same_on_frame`` is ``True`` by default, so supported Kornia augmentation parameters are shared by every
      frame of a clip. With ``same_on_frame=False`` each frame draws parameters independently. It does not
      synchronize randomness inside ordinary ``nn.Module`` children such as ``Dropout``. Nested
      :class:`ImageSequential` and other ``SequentialBase`` children require ``same_on_frame=False``.
    - like :class:`~kornia.augmentation.container.ImageSequential`, this container takes image tensors only: it has
      no ``data_keys`` and no ``.transform_matrix`` attribute. Register a ``VideoSequential`` as a child of
      :class:`~kornia.augmentation.container.AugmentationSequential` to augment video masks, boxes and keypoints
      alongside the clip. For video boxes, use ``bbox`` vertices with shape ``(B, T, N, 4, 2)``;
      coordinate keys ``bbox_xyxy`` and ``bbox_xywh`` do not accept ``(B, T, N, 4)`` tensors.

See Also:
    - :class:`~kornia.augmentation.container.ImageSequential`: applies the same kind of sequence to images.
    - :class:`~kornia.augmentation.container.AugmentationSequential`: transforms a video with aligned annotations.

Example:
    If set `same_on_frame` to True, we would expect the same augmentation has been applied to each
    timeframe.

    >>> import kornia
    >>> input = torch.randn(2, 3, 1, 5, 6).repeat(1, 1, 4, 1, 1)
    >>> aug_list = VideoSequential(
    ...     kornia.augmentation.ColorJiggle(0.1, 0.1, 0.1, 0.1, p=1.0),
    ...     kornia.color.BgrToRgb(),
    ...     kornia.augmentation.RandomAffine(360, p=1.0),
    ...     random_apply=10,
    ...     data_format="BCTHW",
    ...     same_on_frame=True)
    >>> output = aug_list(input)
    >>> (output[0, :, 0] == output[0, :, 1]).all()
    tensor(True)
    >>> (output[0, :, 1] == output[0, :, 2]).all()
    tensor(True)
    >>> (output[0, :, 2] == output[0, :, 3]).all()
    tensor(True)

    If set `same_on_frame` to False:

    >>> aug_list = VideoSequential(
    ...     kornia.augmentation.ColorJiggle(0.1, 0.1, 0.1, 0.1, p=1.0),
    ...     kornia.augmentation.RandomAffine(360, p=1.0),
    ...     kornia.augmentation.RandomMixUpV2(p=1.0),
    ... data_format="BCTHW",
    ... same_on_frame=False)
    >>> output = aug_list(input)
    >>> output.shape
    torch.Size([2, 3, 4, 5, 6])
    >>> (output[0, :, 0] == output[0, :, 1]).all()
    tensor(False)

    Reproduce with provided params.
    >>> out2 = aug_list(input, params=aug_list._params)
    >>> torch.equal(output, out2)
    True

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

    >>> import kornia
    >>> input, label = torch.randn(2, 3, 1, 5, 6).repeat(1, 1, 4, 1, 1), torch.tensor([0, 1])
    >>> aug_list = VideoSequential(
    ...     kornia.augmentation.ColorJiggle(0.1, 0.1, 0.1, 0.1, p=1.0),
    ...     kornia.augmentation.RandomAffine(360, p=1.0),
    ...     kornia.augmentation.RandomMixUpV2(p=1.0),
    ... data_format="BCTHW",
    ... same_on_frame=False,
    ... random_apply=1,
    ... random_apply_weights=[0.5, 0.3, 0.8]
    ... )
    >>> out = aug_list(input)
    >>> out.shape
    torch.Size([2, 3, 4, 5, 6])

Údata_formatÚBTCHWÚsame_on_frameTÚrandom_applyFÚrandom_apply_weightsNÚif_unsupported_opsÚraisec                óÐ   <€ V ^8„  d   QhRS[ P                  RS[RS[RS[S[S[S[S[S[3,          3,          RS[S[S[S[	,          S[
P                  3,          ,          RS[RR/# )	é   Úargsr   r   r   r    r!   ÚreturnN)r   ÚModuleÚstrÚboolr	   Úintr   r   r   ÚfloatÚtorchÚTensor)ÚformatÚ__classdict__s   "€Ú_C:\Ai_Coding\apps\studio\ComfyUI\.venv\Lib\site-packages\kornia\augmentation\container\video.pyÚ__annotate__ÚVideoSequential.__annotate__˜   s€   ø€ ÷ 'ñ 'á�y‰yð'ñ ð'ñ ð	'ñ
 ™C¡¡u©S±#¨X¥Ð6Õ7ð'ñ '¡u©X±e­_¹e¿l¹lÐ-JÕ'KÕLð'ñ  ð'ð 
ñ'ó    c               ó  <€ \         SV `  ! VR RRRRVRVRV/  W n        VP                  4       V n        V P                  R
9  d   \        RV R	24      hV  V P                  R8X  d
   ^V n        R# V P                  R8X  d
   ^V n        R# R# )Úsame_on_batchNÚkeepdimr   r    r!   ÚBCTHWr   z-Only `BCTHW` and `BTCHW` are supported. Got `z`.)r7   r   )ÚsuperÚ__init__r   Úupperr   ÚAssertionErrorÚ_temporal_channel)Úselfr   r   r   r    r!   r%   Ú	__class__s   &$$$$$*€r0   r9   ÚVideoSequential.__init__˜   s¹   ø€ ô 	‰ÒØð	
àð	
ð ð	
ð &ð		
ð
 "6ð	
ð  2ò	
ð +ÔØ&×,Ñ,Ó.ˆÔØ×ÑÐ#5Ô5Ü Ð#PÐQ\ÐP]Ð]_Ð!`ÓaÐaÙØ×Ñ˜wÔ&Ø%&ˆDÖ"Ø×Ñ Ô(Ø%&ˆDÖ"ñ )r3   c                óT   <€ V ^8„  d   QhRS[ P                  RS[RS[ P                  /# )r$   Úbatch_shapeÚchennel_indexr&   )r,   ÚSizer*   )r.   r/   s   "€r0   r1   r2   ³   s3   ø€ ÷ `ñ `Á5Ç:Á:ð `Ñ^að `Ñfk×fpÑfpñ `r3   c                ó\   € \        \        P                  VR V W^,           R  ,           4      # ©N)r
   r,   rC   )r=   rA   rB   s   &&&r0   Ú'__infer_channel_exclusive_batch_shape__Ú7VideoSequential.__infer_channel_exclusive_batch_shape__³   s+   € ä”E—J‘J ¨N¨]Ð ;¸kÐZ[ÕJ[ÐJ]Ð>^Õ ^Ó_Ð_r3   c                óT   <€ V ^8„  d   QhRS[ P                  RS[RS[ P                  /# )r$   ÚparamÚ	frame_numr&   ©r,   r-   r*   )r.   r/   s   "€r0   r1   r2   ·   s-   ø€ ÷ 
<ñ 
<±e·l±lð 
<Ésð 
<ÑW\×WcÑWcñ 
<r3   c                óÚ   € VR,          P                   ! ^V.^.\        VP                  R,          4      ,          O5!  pVP                  ! R.\	        VP                  R,          4      O5!  # )a>  Repeat parameters across channels.

The input is shaped as (B, ...), while to output (B * same_on_frame, ...), which
to guarantee that the same transformation would happen for each frame.

(B1, B2, ..., Bn) => (B1, ... B1, B2, ..., B2, ..., Bn, ..., Bn)
                      | ch_size | | ch_size |  ..., | ch_size |
ºé   NN):NNNN.éÿÿÿÿ)ÚrepeatÚlenÚshapeÚreshapeÚlist)r=   rI   rJ   Úrepeateds   &&& r0   Ú __repeat_param_across_channels__Ú0VideoSequential.__repeat_param_across_channels__·   sX   € ð ˜Õ&×-Ò-¨a°ÐZ¸q¸cÄCÈÏÉÐTVÍÓDXÕ>XÓZˆØ×Ò Ð;¤T¨%¯+©+°b­/Ó%:Ó;Ð;r3   c                óz   <€ V ^8„  d   QhRS[ P                  RS[ P                  RS[RS[RS[RS[ P                  /# )r$   ÚvrA   rJ   r   r5   r&   )r,   r-   rC   r*   r)   )r.   r/   s   "€r0   r1   r2   Ã   sI   ø€ ÷ ñ Ù—‘ðÙ,1¯J©JðÙCFðÙW[ðÙlpðá	�‰ñr3   c                óÜ  € VP                  4       '       g   V# V'       dD   V'       d<   VP                  ! V^ ,          V,          .^.VP                  ^,
          ,          O5!  # V'       d   V P                  W4      # V'       dh   VP	                  ^4      P                  ! ^V^ ,          .^.VP                  ^,
          ,          O5!  P
                  ! R.VP                  R,          O5!  # V# )r   rM   rO   )ÚnumelrP   ÚndimrV   Ú	unsqueezerS   rR   )r=   rY   rA   rJ   r   r5   s   &&&&&&r0   Ú__broadcast_param__Ú#VideoSequential.__broadcast_param__Ã   s²   € ð �w‰w�yŠyØˆHçŸ]Ø—8’8˜K¨�N¨YÕ6ÐN¸1¸#ÀÇÁÈ!ÅÕ:LÓNÐNßØ×8Ñ8¸ÓFÐFßØ—;‘;˜q“>×(Ò(¨¨K¸­NÐR¸q¸cÀQÇVÁVÈaÅZÕ>PÓR×ZÒZÐ[]ÐlÐ`a×`gÑ`gÐhjÕ`kÓlÐlØˆr3   c                óT   <€ V ^8„  d   QhRS[ S[S[P                  3,          RS[RR/# )r$   ÚparamsrJ   r&   N)r   r(   r,   r-   r*   )r.   r/   s   "€r0   r1   r2   Ñ   s7   ø€ ÷ Vñ V©t±C¹¿¹Ð4EÕ/Fð VÑSVð VÐ[_ñ Vr3   c                óÌ  € \        VP                  4       4       FÆ  w  r4VP                  4       '       g   K  VR8X  di   \        P                  ! W$P
                  VP                  R7      pVR,          V,          V,           P                  VP                  ^ ,          R4      W&   KŒ  VR8X  d   VP                  V^R7      W&   Kª  VR8X  g   K³  V P                  WB4      W&   KÈ  	  R# )	a°  Repeat the parameters of :class:`~kornia.augmentation.RandomCutMixV2` over the frames of each video.

The generator lays its parameters out as ``(num_mix, B, ...)``: the video is axis 1, so the repeat of
:meth:`__broadcast_param__` over axis 0 would repeat the mixes instead of the frames. ``mix_pairs`` also
holds video indices, which must become indices into the ``B * T`` flattened frames. Frame ``t`` of a video
is mixed with frame ``t`` of its partner video, so all frames of a video cut the same box from the same
partner.

Args:
    params: Parameters drawn for the ``B`` videos; updated in place to cover the ``B * T`` frames.
    frame_num: Number of frames ``T`` in each video.
Ú	mix_pairs©ÚdeviceÚdtypeNÚcrop_src)ÚdimÚ
batch_prob).NrO   )rT   Úitemsr[   r,   Úarangere   rf   rS   rR   Úrepeat_interleaverV   )r=   ra   rJ   ÚkeyÚvalueÚframess   &&&   r0   Ú_broadcast_cutmix_paramsÚ(VideoSequential._broadcast_cutmix_paramsÑ   s¯   € ô ˜vŸ|™|›~Ö.‰JˆCØ—;‘;—=’=ÙØ�kÔ!äŸš i¿¹ÈEÏKÉKÔX�Ø$ YÕ/°)Õ;¸fÕD×MÑMÈeÏkÉkÐZ[ÍnÐ^`Óa�“Ø˜
Ô"à#×5Ñ5°iÀQÐ5ÓG�“Ø˜Ö$à"×CÑCÀEÓU�“ó /r3   c                óJ   <€ V ^8„  d   QhRS[ P                  RS[S[,          /# )r$   Úmoduler&   )r   r'   r   r(   )r.   r/   s   "€r0   r1   r2   ï   s#   ø€ ÷ ñ ¡2§9¡9ð ±¹#µñ r3   c                óÒ   € \        V \        P                  4      '       d   R# \        V \        P                  4      '       d   R# \        V \        P                  4      '       d   R# R# )a%  Name the parameter of a mix augmentation that holds indices into the image batch.

Along its first axis the parameter has one row per image, and its values index the batch as well. Drawn per
video, those values are video indices, which must become indices into the ``B * T`` flattened frames.
Úmixup_pairsrc   ÚpermutationN)Ú
isinstanceÚKÚRandomMixUpV2ÚPatchMixÚRandomMosaic)rs   s   &r0   Ú_batch_index_paramÚ"VideoSequential._batch_index_paramî   sC   € ô �fœaŸo™o×.Ò.Ù Ü�fœaŸj™j×)Ò)ÙÜ�fœaŸn™n×-Ò-Ù Ùr3   c                óT   <€ V ^8„  d   QhRS[ P                  RS[RS[ P                  /# )r$   rY   rJ   r&   rK   )r.   r/   s   "€r0   r1   r2   þ   s/   ø€ ÷ Fñ F¡5§<¡<ð F¹Cð FÁEÇLÁLñ Fr3   c                ó   € \         P                  ! V P                  ^ ,          V P                  V P                  R7      V,          pW,          VP
                  ! R.^.V P                  ^,
          ,          O5!  ,           # )zZMap video indices, already repeated over the frames, to frame ``t`` of each indexed video.rd   rO   )r,   rk   rR   re   rf   Úviewr\   )rY   rJ   ro   s   && r0   Ú_video_to_frame_indicesÚ'VideoSequential._video_to_frame_indicesý   sU   € ô —’˜aŸg™g a�j°·±ÀÇÁÔIÈIÕUˆØ�}˜vŸ{š{¨2ÐE°!°¸¿¹À½
Õ1CÓEÕEÐEr3   c                óz   <€ V ^8„  d   QhRS[ S[S[S[P                  3,          S[S[,          3,          RS[RR/# )r$   rI   Úoriginal_batch_sizer&   N)r	   r   r(   r,   r-   r   r   r*   )r.   r/   s   "€r0   r1   r2     sF   ø€ ÷ ]ñ ]Ù‘T™#™uŸ|™|Ð+Õ,©d±9­oÐ=Õ>ð]ÙUXð]à	ñ]r3   c                ó¼  € \        V \        4      '       dE   RV 9   d<   \        P                  ! RWR,          P                  \        P
                  R7      V R&   R# \        V \        4      '       dl   V  Fc  p\        V\        4      '       g   K  \        VP                  \        \        34      '       g   KC  \        P                  VP                  V4       Ke  	  R# R# )zÝAttach the original video batch size to nested replay metadata.

Args:
    param: Parameter tree returned by a nested sequential container.
    original_batch_size: Batch size of the public video before frame flattening.
Úforward_input_shaperd   Úvideo_batch_sizeN© )rw   Údictr,   Úfullre   ÚlongrT   r   Údatar   Ú_record_video_batch_size)rI   r„   Úitems   && r0   r�   Ú(VideoSequential._record_video_batch_size  s    € ô �eœT×"Ò"Ø$¨Ô-Ü,1¯JªJØÐ+Ð:OÕ4P×4WÑ4WÔ_d×_iÑ_iô-�Ð(Ñ)ñ Ü�eœT×"Ò"Û�Ü˜d¤I×.Ô.´:¸d¿i¹iÌ$ÔPTÈ×3VÔ3VÜ#×<Ñ<¸T¿Y¹YÐH[Ö\ó ñ #r3   c                óT   <€ V ^8„  d   QhRS[ P                  RS[RS[ P                  /# ©r$   ÚinputrJ   r&   rK   )r.   r/   s   "€r0   r1   r2     s*   ø€ ÷ 3ñ 3©U¯\©\ð 3Ácð 3ÉeÏlÉlñ 3r3   c                ó¶   € V P                   R 8X  d   VP                  ^^4      pV P                   R8X  d    VP                  ! R.VP                  R,          O5!  # )r7   r   :r$   NNrO   )r   Ú	transposerS   rR   ©r=   r’   rJ   s   &&&r0   Ú_input_shape_convert_inÚ'VideoSequential._input_shape_convert_in  sM   € à×Ñ˜wÔ&à—O‘O A qÓ)ˆEØ×Ñ˜wÔ&Øà�}Š}˜RÐ2 %§+¡+¨b¥/Ó2Ð2r3   c                óT   <€ V ^8„  d   QhRS[ P                  RS[RS[ P                  /# r‘   rK   )r.   r/   s   "€r0   r1   r2   "  s-   ø€ ÷ ñ ©u¯|©|ð Éð ÑPU×P\ÑP\ñ r3   c                ó¼   € VP                   ! RV.VP                  R,          O5!  pV P                  R8X  d   VP                  ^^4      pV P                  R8X  d    V# )a  Reshape a flattened video tensor back to its original layout.

Args:
    input: Flattened tensor with the frame dimension merged into the batch axis.
    frame_num: Number of frames in each video clip.

Returns:
    The tensor reshaped back to the original video layout.
rM   r7   r   rO   )r€   rR   r   r”   r•   s   &&&r0   Ú_input_shape_convert_backÚ)VideoSequential._input_shape_convert_back"  sU   € ð —
’
˜2˜yÐ;¨5¯;©;°r­?Ó;ˆØ×Ñ˜wÔ&Ø—O‘O A qÓ)ˆEØ×Ñ˜wÔ&Øàˆr3   c                óJ   <€ V ^8„  d   QhRS[ P                  RS[S[,          /# )r$   rA   r&   )r,   rC   r   r   )r.   r/   s   "€r0   r1   r2   4  s'   ø€ ÷ Mñ M©e¯j©jð M¹TÁ)½_ñ Mr3   c           	     óª  € WP                   ,          pV^ ,          pV P                  4       pV P                  WP                   4      p. pV EFƒ  w  rg\        V\        P
                  \        \        P                  34      '       Ed�   V P                  V4      p\        V\        P                  4      p	\        VRR4      ;'       d    VRJ ;'       d    V	'       * p
V P                  '       d*   V
'       d"   \        P                  ! ^.VR,          O4      pMlV P                  '       d   TpMWV
'       d"   \        P                  ! V.VR,          O4      pM.\        P                  ! V^ ,          V,          .VR,          O4      pVP                  V4      p\        V\        4      '       d?   V P                  '       d-   V	'       d%   V P!                  WÃ4       V P#                  WÂ4       EM#\        V\        4      '       dç   V P!                  WÃ4       \%        VP'                  4       4       F·  w  rÞVR8X  d3   \        V\        P(                  \        P*                  34      '       d   K>  VR8X  d   KG  VR8X  d   VP-                  WÞ/4       Kb  V P/                  WáW P                  V
4      WÍ&   V P                  '       g   K•  WØ8X  g   K�  V P1                  WÍ,          V4      WÍ&   K¹  	  M'\        V\$        4      '       d   V P!                  WÃ4       \3        Wl4      pMœ\        V\4        34      '       dz   VP                  \        P                  ! V^ ,          V,          .VR,          O4      4      pV P!                  VV4       V P                  '       d   \7        R4      h\3        VV4      pM\3        VR4      p\9        WñV4      pVP;                  V4       EK†  	  V# )	a  Generate per-module parameters for video inputs.

Args:
    batch_shape: Video batch shape, typically 5D.

Returns:
    Parameter list aligned with execution order, with values broadcast
    across frames depending on ``same_on_frame`` and module settings.
r5   FNrM   Úorderr‡   r†   z=nn.Sequential is currently unsupported for ``same_on_frame``.)r<   Úget_forward_sequencerF   rw   rx   Ú
RandomCropr   ÚMixAugmentationBaseV2r|   ÚRandomCutMixV2Úgetattrr   r,   rC   Úforward_parametersr‰   r�   rp   rT   rj   ÚColorJiggleÚColorJitterÚupdater^   r�   r   r   Ú
ValueErrorr   Úappend)r=   rA   rJ   r„   Únamed_modulesra   Únamers   Úbatch_index_paramÚ	is_cutmixÚis_same_on_batchÚ	mod_shapeÚ	mod_paramÚkrY   rI   Ú	seq_params   &&               r0   r¤   Ú"VideoSequential.forward_parameters4  s  € ð  × 6Ñ 6Õ7ˆ	Ø)¨!�nÐØ×1Ñ1Ó3ˆà×BÑBÀ;×PfÑPfÓgˆàˆÜ)‰LˆDÜ˜&¤1§<¡<Ô1BÄA×D[ÑD[Ð"\×]Ó]Ø$(×$;Ñ$;¸FÓ$CÐ!Ü& v¬q×/?Ñ/?Ó@�	ô ˜F O°UÓ;×kÐkÐ@QÐUYÐ@Y×kÐkÐbkÔ^kð !ð ×%×%Ð%×*:Ü %§
¢
¨AÐ+@°¸BµÐ+@Ó A‘IØ×'×'Ð'Ø +‘Iß%Ü %§
¢
¨IÐ+H¸ÀB½Ð+HÓ I‘Iä %§
¢
¨K¸­N¸YÕ,FÐ+YÈÐUWÍÐ+YÓ Z�Ià"×5Ñ5°iÓ@�	ä˜i¬×.Ò.°4×3E×3EÐ3EÏ)Ø×1Ñ1°)ÔQØ×1Ñ1°)ÖGÜ 	¬4×0Ò0Ø×1Ñ1°)ÔQÜ $ Y§_¡_Ó%6Ö 7™˜à œ<¬J°vÄÇÁÌqÏ}É}Ð?]×,^Ò,^Ù$ØÐ 2Ô2Ù$ØÐ 5Ô5Ø%×,Ñ,¨a¨VÔ4Ù$Ø'+×'?Ñ'?Ø¨I×7IÑ7IÐK[ó(˜	™ð  ×-×-Ò-°!Ö2HØ+/×+GÑ+GÈ	ÍÐV_Ó+`˜I›Lò !8ô   	¬4×0Ò0Ø×1Ñ1°)ÔQä! $Ó2‘ä˜F¤^Ð$5×6Ò6ð #×5Ñ5´e·j²jÀ+ÈaÅ.ÐS\ÕB\ÐAoÐ_jÐkmÕ_nÐAoÓ6pÓq�	Ø×-Ñ-¨iÐ9LÔMØ×%×%Ð%Ü$Ð%dÓeÐeÜ! $¨	Ó2‘ô " $¨Ó-�ä.¨uÀ6ÓJˆKØ�M‰M˜%× ñu *ðx ˆr3   c          	      ó�   <€ V ^8„  d   QhRS[ P                  RS[S[,          RS[S[S[S[3,          ,          RS[ P                  /# ©r$   r’   ra   Ú
extra_argsr&   ©r,   r-   r   r   r   r   r(   r   )r.   r/   s   "€r0   r1   r2   ƒ  óQ   ø€ ÷ @ñ @Ù—\‘\ð@Ù+/±	­?ð@ÙHPÑQUÑVYÑ[^ÐV^ÕQ_ÕH`ð@á	�‰ñ@r3   c                ó    <€ VP                  V P                  4      pV P                  W4      p\        SV `  WVR7      pV P                  W4      # )a  Apply sequence transforms to video tensors.

Args:
    input: Input video tensor.
    params: Parameters aligned with the execution sequence.
    extra_args: Optional per-input-type overrides.

Returns:
    Transformed video tensor in the original video layout.
©r¶   )Úsizer<   r–   r8   Útransform_inputsrš   ©r=   r’   ra   r¶   rJ   r>   s   &&&& €r0   r¼   Ú VideoSequential.transform_inputsƒ  sN   ø€ ð Ÿ™ D×$:Ñ$:Ó;ˆ	Ø×,Ñ,¨UÓ>ˆä‘Ñ(¨À:Ð(ÓNˆà×-Ñ-¨eÓ?Ð?r3   c          	      ó�   <€ V ^8„  d   QhRS[ P                  RS[S[,          RS[S[S[S[3,          ,          RS[ P                  /# rµ   r·   )r.   r/   s   "€r0   r1   r2   —  r¸   r3   c                ó    <€ VP                  V P                  4      pV P                  W4      p\        SV `  WVR7      pV P                  W4      # )a  Apply inverse sequence transforms to video tensors.

Args:
    input: Augmented video tensor.
    params: Parameters used during forward execution.
    extra_args: Optional per-input-type overrides.

Returns:
    Inverse-transformed video tensor in the original layout.
rº   )r»   r<   r–   r8   Úinverse_inputsrš   r½   s   &&&& €r0   rÁ   ÚVideoSequential.inverse_inputs—  sN   ø€ ð Ÿ™ D×$:Ñ$:Ó;ˆ	Ø×,Ñ,¨UÓ>ˆä‘Ñ& uÀÐ&ÓLˆà×-Ñ-¨eÓ?Ð?r3   c          	      ó�   <€ V ^8„  d   QhRS[ P                  RS[S[,          RS[S[S[S[3,          ,          RS[ P                  /# rµ   r·   )r.   r/   s   "€r0   r1   r2   «  r¸   r3   c                ó    <€ VP                  V P                  4      pV P                  W4      p\        SV `  WVR7      pV P                  W4      # )a  Apply sequence transforms to video mask tensors.

Args:
    input: Input video mask tensor.
    params: Parameters aligned with the execution sequence.
    extra_args: Optional per-input-type overrides.

Returns:
    Transformed mask tensor in the original video layout.
rº   )r»   r<   r–   r8   Útransform_masksrš   r½   s   &&&& €r0   rÅ   ÚVideoSequential.transform_masks«  sN   ø€ ð Ÿ™ D×$:Ñ$:Ó;ˆ	Ø×,Ñ,¨UÓ>ˆä‘Ñ'¨À*Ð'ÓMˆà×-Ñ-¨eÓ?Ð?r3   c          	      ó�   <€ V ^8„  d   QhRS[ P                  RS[S[,          RS[S[S[S[3,          ,          RS[ P                  /# rµ   r·   )r.   r/   s   "€r0   r1   r2   ¿  r¸   r3   c                ó    <€ VP                  V P                  4      pV P                  W4      p\        SV `  WVR7      pV P                  W4      # )a  Apply inverse sequence transforms to video masks.

Args:
    input: Augmented video mask tensor.
    params: Parameters used during forward execution.
    extra_args: Optional per-input-type overrides.

Returns:
    Inverse-transformed mask tensor in the original layout.
rº   )r»   r<   r–   r8   Úinverse_masksrš   r½   s   &&&& €r0   rÉ   ÚVideoSequential.inverse_masks¿  sN   ø€ ð Ÿ™ D×$:Ñ$:Ó;ˆ	Ø×,Ñ,¨UÓ>ˆä‘Ñ% eÀ
Ð%ÓKˆà×-Ñ-¨eÓ?Ð?r3   c          
      ó¼   <€ V ^8„  d   QhRS[ S[P                  S[3,          RS[S[,          RS[S[S[S[	3,          ,          RS[ S[P                  S[3,          /# rµ   ©
r	   r,   r-   r   r   r   r   r   r(   r   )r.   r/   s   "€r0   r1   r2   Ó  ó_   ø€ ÷ ñ Ù™5Ÿ<™<©Ð.Õ/ðÙ9=¹i½ðÙV^Ñ_cÑdgÑilÐdlÕ_mÕVnðá	‰u�|‰|™UÐ"Õ	#ñr3   c           
     óˆ  <€ \        V\        P                  4      '       dÉ   VP                  ^ 4      VP                  ^4      rT\        P
                  ! VP                  WE,          VP                  ^4      VP                  ^4      VP                  ^4      4      RR7      p\        SV `!  WVR7      pVP                  P                  WEVP                  P                  ^4      ^^4      pV# \        V\        4      '       d2   \        SV `!  \        V4      W#R7      p\        WaP                  4      pV# \        SV `!  WVR7      pV# ©a:  Transform bounding boxes.

Args:
    input: torch.Tensor with shape ``(B, T, N, 4, 2)``.
        If input is a `Keypoints` type, the internal shape is ``(B * T, N, 4, 2)``.
    params: params for the sequence.
    extra_args: Optional dictionary of extra arguments with specific options for different input types.
Úvertices_plus)Úmoderº   )rw   r,   r-   r»   r   Úfrom_tensorrS   r8   Útransform_boxesrŒ   r   r   r   Útemporal_channel_size©r=   r’   ra   r¶   Ú	batchsizerJ   ro   r>   s   &&&&   €r0   rÓ   ÚVideoSequential.transform_boxesÓ  s  ø€ ô �eœUŸ\™\×*Ò*Ø#(§:¡:¨a£=°%·*±*¸Q³-�yÜ×%Ò%Ø—‘˜iÕ3°U·Z±ZÀ³]ÀEÇJÁJÈqÃMÐSX×S]ÑS]Ð^_ÓS`ÓaÐhwôˆEô ‘GÑ+¨EÀjÐ+ÓQˆEØ—J‘J×&Ñ& y¸U¿Z¹Z¿_¹_ÈQÓ=OÐQRÐTUÓVˆEð ˆô ˜œz×*Ò*Ü‘WÑ,¬\¸%Ó-@À&Ð,Ó`ˆFÜ  ×)DÑ)DÓEˆEð ˆô ‘GÑ+¨EÀjÐ+ÓQˆEØˆr3   c          
      ó¼   <€ V ^8„  d   QhRS[ S[P                  S[3,          RS[S[,          RS[S[S[S[	3,          ,          RS[ S[P                  S[3,          /# rµ   rÌ   )r.   r/   s   "€r0   r1   r2   ì  rÍ   r3   c           
     óˆ  <€ \        V\        P                  4      '       dÉ   VP                  ^ 4      VP                  ^4      rT\        P
                  ! VP                  WE,          VP                  ^4      VP                  ^4      VP                  ^4      4      RR7      p\        SV `!  WVR7      pVP                  P                  WEVP                  P                  ^4      ^^4      pV# \        V\        4      '       d2   \        SV `!  \        V4      W#R7      p\        WaP                  4      pV# \        SV `!  WVR7      pV# rÏ   )rw   r,   r-   r»   r   rÒ   rS   r8   Úinverse_boxesrŒ   r   r   r   rÔ   rÕ   s   &&&&   €r0   rÚ   ÚVideoSequential.inverse_boxesì  s  ø€ ô �eœUŸ\™\×*Ò*Ø#(§:¡:¨a£=°%·*±*¸Q³-�yÜ×%Ò%Ø—‘˜iÕ3°U·Z±ZÀ³]ÀEÇJÁJÈqÃMÐSX×S]ÑS]Ð^_ÓS`ÓaÐhwôˆEô ‘GÑ)¨%ÀJÐ)ÓOˆEØ—J‘J×&Ñ& y¸U¿Z¹Z¿_¹_ÈQÓ=OÐQRÐTUÓVˆEð ˆô ˜œz×*Ò*Ü‘WÑ*¬<¸Ó+>ÀÐ*Ó^ˆFÜ  ×)DÑ)DÓEˆEð ˆô ‘GÑ)¨%ÀJÐ)ÓOˆEØˆr3   c          
      ó¼   <€ V ^8„  d   QhRS[ S[P                  S[3,          RS[S[,          RS[S[S[S[	3,          ,          RS[ S[P                  S[3,          /# rµ   ©
r	   r,   r-   r   r   r   r   r   r(   r   )r.   r/   s   "€r0   r1   r2     s`   ø€ ÷ ñ á‘U—\‘\¡9Ð,Õ-ðñ ‘Y•ðñ ™T¡#¡s (�^Õ,ð	ñ
 
‰u�|‰|™YÐ&Õ	'ñr3   c           	     óL  <€ \        V\        P                  4      '       d«   VP                  ^ 4      VP                  ^4      rT\	        VP                  WE,          VP                  ^4      VP                  ^4      4      4      p\        SV `  WVR7      pVP                  P                  WEVP                  P                  ^4      ^4      pV# \        V\        4      '       d2   \        SV `  \        V4      W#R7      p\        WaP                  4      pV# \        SV `  WVR7      pV# ©a4  Transform bounding boxes.

Args:
    input: torch.Tensor with shape ``(B, T, N, 2)``.
        If input is a `Keypoints` type, the internal shape is ``(B * T, N, 2)``.
    params: params for the sequence.
    extra_args: Optional dictionary of extra arguments with specific options for different input types.
rº   )rw   r,   r-   r»   r   rS   r8   Útransform_keypointsrŒ   r   r   r   rÔ   rÕ   s   &&&&   €r0   rà   Ú#VideoSequential.transform_keypoints  sø   ø€ ô �eœUŸ\™\×*Ò*Ø#(§:¡:¨a£=°%·*±*¸Q³-�yÜ˜eŸm™m¨IÕ,AÀ5Ç:Á:ÈaÃ=ÐRW×R\ÑR\Ð]^ÓR_Ó`ÓaˆEÜ‘GÑ/°È*Ð/ÓUˆEØ—J‘J×&Ñ& y¸U¿Z¹Z¿_¹_ÈQÓ=OÐQRÓSˆEð ˆô ˜œ~×.Ò.ä‘WÑ0Ô1AÀ%Ó1HÈ&Ð0ÓhˆFÜ$ V×-HÑ-HÓIˆEð ˆô ‘GÑ/°È*Ð/ÓUˆEØˆr3   c          
      ó¼   <€ V ^8„  d   QhRS[ S[P                  S[3,          RS[S[,          RS[S[S[S[	3,          ,          RS[ S[P                  S[3,          /# rµ   rÝ   )r.   r/   s   "€r0   r1   r2      s`   ø€ ÷ ñ á‘U—\‘\¡9Ð,Õ-ðñ ‘Y•ðñ ™T¡#¡s (�^Õ,ð	ñ
 
‰u�|‰|™YÐ&Õ	'ñr3   c           	     óL  <€ \        V\        P                  4      '       d«   VP                  ^ 4      VP                  ^4      rT\	        VP                  WE,          VP                  ^4      VP                  ^4      4      4      p\        SV `  WVR7      pVP                  P                  WEVP                  P                  ^4      ^4      pV# \        V\        4      '       d2   \        SV `  \        V4      W#R7      p\        WaP                  4      pV# \        SV `  WVR7      pV# rß   )rw   r,   r-   r»   r   rS   r8   Úinverse_keypointsrŒ   r   r   r   rÔ   rÕ   s   &&&&   €r0   rä   Ú!VideoSequential.inverse_keypoints   sø   ø€ ô �eœUŸ\™\×*Ò*Ø#(§:¡:¨a£=°%·*±*¸Q³-�yÜ˜eŸm™m¨IÕ,AÀ5Ç:Á:ÈaÃ=ÐRW×R\ÑR\Ð]^ÓR_Ó`ÓaˆEÜ‘GÑ-¨eÈ
Ð-ÓSˆEØ—J‘J×&Ñ& y¸U¿Z¹Z¿_¹_ÈQÓ=OÐQRÓSˆEð ˆô ˜œ~×.Ò.Ü‘WÑ.Ô/?ÀÓ/FÈÐ.ÓfˆFÜ$ V×-HÑ-HÓIˆEð ˆô ‘GÑ-¨eÈ
Ð-ÓSˆEØˆr3   c          	      ó    <€ V ^8„  d   QhRS[ P                  RS[S[S[,          ,          RS[S[S[S[3,          ,          RS[ P                  /# rµ   ©r,   r-   r   r   r   r   r(   r   )r.   r/   s   "€r0   r1   r2   :  sV   ø€ ÷ Iñ IÙ—\‘\ðIÙ+3±D¹µOÕ+DðIÙYaÑbfÑgjÑloÐgoÕbpÕYqðIá	�‰ñIr3   c                ó|   € Vf'   V P                   e   V P                   pM\        R4      hV P                  WVR7      # )z�Inverse transformation.

Used to inverse a torch.Tensor according to the performed transformation by a forward pass, or with respect to
provided parameters.
z.No valid params to inverse the transformation.rº   )Ú_paramsÚRuntimeErrorrÁ   ©r=   r’   ra   r¶   s   &&&&r0   ÚinverseÚVideoSequential.inverse:  s>   € ð Š>Ø�|‰|Ò'ØŸ™‘ä"Ð#SÓTÐTà×"Ñ" 5¸ZÐ"ÓHÐHr3   c          	      ó    <€ V ^8„  d   QhRS[ P                  RS[S[S[,          ,          RS[S[S[S[3,          ,          RS[ P                  /# rµ   rç   )r.   r/   s   "€r0   r1   r2   J  sV   ø€ ÷ Kñ KÙ—\‘\ðKÙ+3±D¹µOÕ+DðKÙYaÑbfÑgjÑloÐgoÕbpÕYqðKá	�‰ñKr3   c                ó6  € \        VP                  4      ^8w  d>   \        VP                  RRP                  V P                  4      ,           R,           4       Vf-   V P                  VP                  4      V n        V P                  pV P                  WVR7      # )z'Define the video computation performed.Ú(z, Ú)rº   )rQ   rR   r   Újoinr   r¤   ré   r¼   rë   s   &&&&r0   ÚforwardÚVideoSequential.forwardJ  sw   € ô ˆu�{‰{Ó˜qÔ Ü# E§K¡K°°t·y±yÀ×AQÑAQÓ7RÕ1RÐUXÕ1XÔYàŠ>Ø×2Ñ2°5·;±;Ó?ˆDŒLØ—\‘\ˆFà×$Ñ$ U¸zÐ$ÓJÐJr3   )ré   r<   r   r   rE   )NN)Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__r9   rF   rV   r^   rp   Ústaticmethodr|   r�   r�   r–   rš   r¤   r¼   rÁ   rÅ   rÉ   rÓ   rÚ   rà   rä   rì   ró   Ú__static_attributes__Ú__classdictcell__Ú__classcell__)r>   r/   s   @@r0   r   r   *   sN  ù‡ € ñiðZ'ð #ð'ð #ð	'ð
 ;@ð'ð PTð'ð #*÷'õ '÷6`ð `÷
<ð 
<÷ð ÷Vð Vð: ÷ó ðð ÷Fó ðFð
 ÷]ó ð]÷(3ð 3÷ð ÷$Mð M÷^@õ @÷(@õ @÷(@õ @÷(@õ @÷(õ ÷2õ ÷2õ ÷6õ ÷4Iò I÷ K÷ Kò Kr3   )%Útypingr   r   r   r   r   r   r	   r
   r,   r   Úkornia.augmentationÚaugmentationrx   Úkornia.augmentation.baser   Ú"kornia.augmentation.container.baser   Ú#kornia.augmentation.container.imager   r   Ú!kornia.augmentation.utils.helpersr   r   r   r   r   Úkornia.geometry.boxesr   r   Úkornia.geometry.keypointsr   r   ra   r   Ú__all__r   rˆ   r3   r0   Ú<module>r     sP   ð÷$ K× JÓ Jã Ý å Ý 6Ý =ß U÷õ ÷ 4ß ?å àÐ
€ôkK�oö kKr3   