+
    åûjØ&  ã                   óÈ   € R t ^ RIt^ RIHt . ROt ! R R]P                  4      t ! R R]P                  4      t ! R R]P                  4      tR	 R
 ltR R lt	R R lt
R# )aH  Mirror images left to right or top to bottom, or turn them by 180 degrees, by reversing tensor axes.

The flips reverse the last axes of a tensor of any batch shape: :func:`hflip` the last one (the width ``W``),
:func:`vflip` the second to last (the height ``H``) and :func:`rot180` both. They copy elements without interpolation,
so they are exact for every dtype and differentiable, and their module forms take no arguments.

Which function to use:

- Mirror left to right: :func:`hflip` or :class:`Hflip`; top to bottom: :func:`vflip` or :class:`Vflip`.
- Turn by a half turn: :func:`rot180` or :class:`Rot180`.
- To rotate by any angle, use :func:`~kornia.geometry.transform.rotate`; for random flips in an augmentation
  pipeline, :class:`~kornia.augmentation.RandomHorizontalFlip` or :class:`~kornia.augmentation.RandomVerticalFlip`.
N)ÚnnÚHflipÚRot180ÚVflipc                   óH   a € ] tR t^&t o RtV 3R lR ltV 3R lR ltRtV tR# )r   a»  Flip images top to bottom by reversing the height axis (module form).

Build ``flipper = Vflip()``, which takes no arguments, then ``out = flipper(input)`` reverses the rows of
``(*, H, W)`` tensors as :func:`vflip` does. To mirror left to right, use :class:`Hflip`; for a half turn,
:class:`Rot180`.

Convention:
    - See the convention block of :func:`~kornia.geometry.transform.vflip`.

Returns:
    The vertically flipped image torch.Tensor, with the shape of the input.

See Also:
    - :func:`vflip`: the one-call form.
    - :class:`Hflip`: mirrors left to right instead.
    - :class:`~kornia.augmentation.RandomVerticalFlip`: flips with a probability, in an augmentation pipeline.

Examples:
    >>> vflip = Vflip()
    >>> input = torch.tensor([[[
    ...    [0., 0., 0.],
    ...    [0., 0., 0.],
    ...    [0., 1., 1.]
    ... ]]])
    >>> vflip(input)
    tensor([[[[0., 1., 1.],
              [0., 0., 0.],
              [0., 0., 0.]]]])

c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# ©é   ÚinputÚreturn©ÚtorchÚTensor)ÚformatÚ__classdict__s   "€Ú[C:\Ai_Coding\apps\studio\ComfyUI\.venv\Lib\site-packages\kornia\geometry\transform\flips.pyÚ__annotate__ÚVflip.__annotate__F   ó#   ø€ ÷ ñ ™UŸ\™\ð ©e¯l©lñ ó    c                ó   € \        V4      # )aE  Flip the image content along the vertical image axis.

Args:
    input: Tensor containing one image or a batch of images, typically
        shaped ``(*, C, H, W)``, where :math:`H` is height and
        :math:`W` is width.

Returns:
    Tensor with the same shape as ``input`` whose rows are reversed
    from top to bottom.
)Úvflip©Úselfr
   s   &&r   ÚforwardÚVflip.forwardF   ó   € ô �U‹|Ðr   c                ó    <€ V ^8„  d   QhRS[ /# ©r	   r   ©Ústr)r   r   s   "€r   r   r   T   ó   ø€ ÷ 'ñ '™#ñ 'r   c                ó.   € V P                   P                  # ©N©Ú	__class__Ú__name__©r   s   &r   Ú__repr__ÚVflip.__repr__T   ó   € Ø�~‰~×&Ñ&Ð&r   © N©	r&   Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__r   r(   Ú__static_attributes__Ú__classdictcell__©r   s   @r   r   r   &   ó   ø‡ € ñ÷>ð ÷'ö 'r   c                   óH   a € ] tR t^Xt o RtV 3R lR ltV 3R lR ltRtV tR# )r   a¼  Mirror images left to right by reversing the width axis (module form).

Build ``flipper = Hflip()``, which takes no arguments, then ``out = flipper(input)`` reverses the columns of
``(*, W)`` tensors as :func:`hflip` does. To flip top to bottom, use :class:`Vflip`; for a half turn,
:class:`Rot180`.

Convention:
    - See the convention block of :func:`~kornia.geometry.transform.hflip`.

Returns:
    The horizontally flipped image torch.Tensor, with the shape of the input.

See Also:
    - :func:`hflip`: the one-call form.
    - :class:`Vflip`: flips top to bottom instead.
    - :class:`~kornia.augmentation.RandomHorizontalFlip`: flips with a probability, in an augmentation pipeline.

Examples:
    >>> hflip = Hflip()
    >>> input = torch.tensor([[[
    ...    [0., 0., 0.],
    ...    [0., 0., 0.],
    ...    [0., 1., 1.]
    ... ]]])
    >>> hflip(input)
    tensor([[[[0., 0., 0.],
              [0., 0., 0.],
              [1., 1., 0.]]]])

c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# r   r   )r   r   s   "€r   r   ÚHflip.__annotate__x   r   r   c                ó   € \        V4      # )aJ  Flip the image content along the horizontal image axis.

Args:
    input: Tensor containing one image or a batch of images, typically
        shaped ``(*, C, H, W)``, where :math:`H` is height and
        :math:`W` is width.

Returns:
    Tensor with the same shape as ``input`` whose columns are reversed
    from left to right.
)Úhflipr   s   &&r   r   ÚHflip.forwardx   r   r   c                ó    <€ V ^8„  d   QhRS[ /# r   r   )r   r   s   "€r   r   r7   †   r!   r   c                ó.   € V P                   P                  # r#   r$   r'   s   &r   r(   ÚHflip.__repr__†   r*   r   r+   Nr,   r3   s   @r   r   r   X   r4   r   c                   óH   a € ] tR t^Št o RtV 3R lR ltV 3R lR ltRtV tR# )r   au  Turn images by 180 degrees by reversing the height and width axes (module form).

Build ``rotator = Rot180()``, which takes no arguments, then ``out = rotator(input)`` reverses both the rows and the
columns of ``(*, H, W)`` tensors as :func:`rot180` does, without interpolation. To rotate by a stored angle, use
:class:`Rotate`.

Convention:
    - See the convention block of :func:`~kornia.geometry.transform.rot180`.

Returns:
    The rotated image torch.Tensor, with the shape of the input.

See Also:
    - :func:`rot180`: the one-call form.
    - :class:`Rotate`: rotates by any stored angle, with interpolation.

Examples:
    >>> rot180 = Rot180()
    >>> input = torch.tensor([[[
    ...    [0., 0., 0.],
    ...    [0., 0., 0.],
    ...    [0., 1., 1.]
    ... ]]])
    >>> rot180(input)
    tensor([[[[1., 1., 0.],
              [0., 0., 0.],
              [0., 0., 0.]]]])

c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# r   r   )r   r   s   "€r   r   ÚRot180.__annotate__©   s#   ø€ ÷ ñ ™UŸ\™\ð ©e¯l©lñ r   c                ó   € \        V4      # )aF  Rotate image content by 180 degrees without changing tensor shape.

Args:
    input: Tensor containing one image or a batch of images, typically
        shaped ``(*, C, H, W)``, where :math:`H` is height and
        :math:`W` is width.

Returns:
    Tensor with the same shape as ``input`` and both spatial axes
    reversed.
)Úrot180r   s   &&r   r   ÚRot180.forward©   s   € ô �e‹}Ðr   c                ó    <€ V ^8„  d   QhRS[ /# r   r   )r   r   s   "€r   r   r@   ·   r!   r   c                ó.   € V P                   P                  # r#   r$   r'   s   &r   r(   ÚRot180.__repr__·   r*   r   r+   Nr,   r3   s   @r   r   r   Š   s   ø‡ € ñ÷<ð ÷'ö 'r   c                óX   € V ^8„  d   QhR\         P                  R\         P                  /# r   r   )r   s   "r   r   r   »   s"   € ÷ 'ñ '”%—,‘,ð '¤5§<¡<ñ 'r   c                ó4   € \         P                  ! V RR.4      # )u<  Turn images by 180 degrees by reversing the height and width axes.

``out = rot180(input)`` reverses the last two axes of ``(*, H, W)`` tensors and returns the same shape: the image
turned by a half turn, exactly, without the interpolation of :func:`rotate`. For any other angle, or a turn about
another centre, use :func:`rotate`; for the module form, :class:`Rot180`.

.. image:: _static/img/rot180.png

Convention:
    - flips both the height and width axes (equivalent to :func:`vflip` followed by
      :func:`hflip`)
    - requires rank â‰¥ 2: unbatched ``(H, W)``/``(C, H, W)`` or batched
      ``(*, C, H, W)`` all work

Args:
    input: input torch.Tensor.

Returns:
    The rotated image torch.Tensor, with the shape of the input.

See Also:
    - :class:`Rot180`: the module form.
    - :func:`rotate`: rotates by any angle about the centre or a given point, with interpolation; at 180 degrees
      about the default centre it matches ``rot180`` up to float rounding.
    - :func:`hflip`: reverses the width axis only.
    - :func:`vflip`: reverses the height axis only.

éþÿÿÿéÿÿÿÿ)r   Úflip©r
   s   &r   rB   rB   »   s   € ô: �:Š:�e˜b "˜XÓ&Ð&r   c                óX   € V ^8„  d   QhR\         P                  R\         P                  /# r   r   )r   s   "r   r   r   Û   s"   € ÷ 'ñ '”—‘ð '¤%§,¡,ñ 'r   c                ó@   € V P                  R4      P                  4       # )a‘  Mirror images left to right by reversing the width axis.

``out = hflip(input)`` reverses the last axis of ``(*, W)`` tensors, the width of ``(*, H, W)`` images, and returns
the same shape. To flip top to bottom, use :func:`vflip`; for a half turn, :func:`rot180`; for random flips in an
augmentation pipeline, :class:`~kornia.augmentation.RandomHorizontalFlip`.

.. image:: _static/img/hflip.png

Convention:
    - flips the last dimension (dim ``-1``); accepts any rank :math:`\geq 1`
      (rank 0 is outside the contract)

Args:
    input: input torch.Tensor.

Returns:
    The horizontally flipped image torch.Tensor, with the shape of the input.

See Also:
    - :class:`Hflip`: the module form.
    - :func:`vflip`: reverses the height axis instead.
    - :func:`rot180`: reverses both axes.
    - :class:`~kornia.augmentation.RandomHorizontalFlip`: flips with a probability, in an augmentation pipeline.

rJ   ©rK   Ú
contiguousrL   s   &r   r9   r9   Û   s   € ð4 �:‰:�b‹>×$Ñ$Ó&Ð&r   c                óX   € V ^8„  d   QhR\         P                  R\         P                  /# r   r   )r   s   "r   r   r   ø   s"   € ÷ 'ñ '”—‘ð '¤%§,¡,ñ 'r   c                ó@   € V P                  R4      P                  4       # )uÄ  Flip images top to bottom by reversing the height axis.

``out = vflip(input)`` reverses the second-to-last axis of ``(*, H, W)`` tensors and returns the same shape. To
mirror left to right, use :func:`hflip`; for a half turn, :func:`rot180`; for random flips in an augmentation
pipeline, :class:`~kornia.augmentation.RandomVerticalFlip`.

.. image:: _static/img/vflip.png

Convention:
    - flips along the height axis (the second-to-last dimension)
    - requires rank â‰¥ 2 (operates on dim ``-2``): unbatched ``(H, W)``/
      ``(C, H, W)`` or batched ``(*, C, H, W)`` all work

Args:
    input: input torch.Tensor.

Returns:
    The vertically flipped image torch.Tensor, with the shape of the input.

See Also:
    - :class:`Vflip`: the module form.
    - :func:`hflip`: reverses the width axis instead.
    - :func:`rot180`: reverses both axes.
    - :class:`~kornia.augmentation.RandomVerticalFlip`: flips with a probability, in an augmentation pipeline.

rI   rO   rL   s   &r   r   r   ø   s   € ð6 �:‰:�b‹>×$Ñ$Ó&Ð&r   )r   r   r   r9   rB   r   )r0   r   r   Ú__all__ÚModuler   r   r   rB   r9   r   r+   r   r   Ú<module>rU      sZ   ðñ$ó Ý â
B€ô/'ˆB�I‰Iô /'ôd/'ˆB�I‰Iô /'ôd.'ˆR�Y‰Yô .'õb'õ@'÷:'r   