Ë
    ™2Úi[  ã                   ó”   — d dl mZ d„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd	„ Z	d
„ Z
d„ Zd„ Zdd„Zdd„Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zdd„Zy)é   )ÚImagec                 óD   — t        j                  d| j                  |«      S )zVFill a channel with a given grey level.

    :rtype: :py:class:`~PIL.Image.Image`
    ÚL)r   ÚnewÚsize)ÚimageÚvalues     úE/var/www/html/acx/venv/lib/python3.12/site-packages/PIL/ImageChops.pyÚconstantr      s   € ô �9‰9�S˜%Ÿ*™* eÓ,Ð,ó    c                 ó"   — | j                  «       S )ziCopy a channel. Alias for :py:meth:`PIL.Image.Image.copy`.

    :rtype: :py:class:`~PIL.Image.Image`
    )Úcopy©r   s    r
   Ú	duplicater      s   € ð �:‰:‹<Ðr   c                 ót   — | j                  «        | j                  | j                  j                  «       «      S )zl
    Invert an image (channel). ::

        out = MAX - image

    :rtype: :py:class:`~PIL.Image.Image`
    )ÚloadÚ_newÚimÚchop_invertr   s    r
   Úinvertr   '   s)   € ð 
‡J�J„LØ�:‰:�e—h‘h×*Ñ*Ó,Ó-Ð-r   c                 óª   — | j                  «        |j                  «        | j                  | j                  j                  |j                  «      «      S )z½
    Compares the two images, pixel by pixel, and returns a new image containing
    the lighter values. ::

        out = max(image1, image2)

    :rtype: :py:class:`~PIL.Image.Image`
    )r   r   r   Úchop_lighter©Úimage1Úimage2s     r
   Úlighterr   4   s8   € ð ‡K�K„MØ
‡K�K„MØ�;‰;�v—y‘y×-Ñ-¨f¯i©iÓ8Ó9Ð9r   c                 óª   — | j                  «        |j                  «        | j                  | j                  j                  |j                  «      «      S )z¼
    Compares the two images, pixel by pixel, and returns a new image containing
    the darker values. ::

        out = min(image1, image2)

    :rtype: :py:class:`~PIL.Image.Image`
    )r   r   r   Úchop_darkerr   s     r
   Údarkerr   C   s8   € ð ‡K�K„MØ
‡K�K„MØ�;‰;�v—y‘y×,Ñ,¨V¯Y©YÓ7Ó8Ð8r   c                 óª   — | j                  «        |j                  «        | j                  | j                  j                  |j                  «      «      S )z²
    Returns the absolute value of the pixel-by-pixel difference between the two
    images. ::

        out = abs(image1 - image2)

    :rtype: :py:class:`~PIL.Image.Image`
    )r   r   r   Úchop_differencer   s     r
   Ú
differencer"   R   s8   € ð ‡K�K„MØ
‡K�K„MØ�;‰;�v—y‘y×0Ñ0°·±Ó;Ó<Ð<r   c                 óª   — | j                  «        |j                  «        | j                  | j                  j                  |j                  «      «      S )a  
    Superimposes two images on top of each other.

    If you multiply an image with a solid black image, the result is black. If
    you multiply with a solid white image, the image is unaffected. ::

        out = image1 * image2 / MAX

    :rtype: :py:class:`~PIL.Image.Image`
    )r   r   r   Úchop_multiplyr   s     r
   Úmultiplyr%   a   s8   € ð ‡K�K„MØ
‡K�K„MØ�;‰;�v—y‘y×.Ñ.¨v¯y©yÓ9Ó:Ð:r   c                 óª   — | j                  «        |j                  «        | j                  | j                  j                  |j                  «      «      S )zª
    Superimposes two inverted images on top of each other. ::

        out = MAX - ((MAX - image1) * (MAX - image2) / MAX)

    :rtype: :py:class:`~PIL.Image.Image`
    )r   r   r   Úchop_screenr   s     r
   Úscreenr(   r   s8   € ð ‡K�K„MØ
‡K�K„MØ�;‰;�v—y‘y×,Ñ,¨V¯Y©YÓ7Ó8Ð8r   c                 óª   — | j                  «        |j                  «        | j                  | j                  j                  |j                  «      «      S )z
    Superimposes two images on top of each other using the Soft Light algorithm

    :rtype: :py:class:`~PIL.Image.Image`
    )r   r   r   Úchop_soft_lightr   s     r
   Ú
soft_lightr+   €   ó8   € ð ‡K�K„MØ
‡K�K„MØ�;‰;�v—y‘y×0Ñ0°·±Ó;Ó<Ð<r   c                 óª   — | j                  «        |j                  «        | j                  | j                  j                  |j                  «      «      S )z
    Superimposes two images on top of each other using the Hard Light algorithm

    :rtype: :py:class:`~PIL.Image.Image`
    )r   r   r   Úchop_hard_lightr   s     r
   Ú
hard_lightr/   Œ   r,   r   c                 óª   — | j                  «        |j                  «        | j                  | j                  j                  |j                  «      «      S )z|
    Superimposes two images on top of each other using the Overlay algorithm

    :rtype: :py:class:`~PIL.Image.Image`
    )r   r   r   Úchop_overlayr   s     r
   Úoverlayr2   ˜   s8   € ð ‡K�K„MØ
‡K�K„MØ�;‰;�v—y‘y×-Ñ-¨f¯i©iÓ8Ó9Ð9r   c                 ó®   — | j                  «        |j                  «        | j                  | j                  j                  |j                  ||«      «      S )zé
    Adds two images, dividing the result by scale and adding the
    offset. If omitted, scale defaults to 1.0, and offset to 0.0. ::

        out = ((image1 + image2) / scale + offset)

    :rtype: :py:class:`~PIL.Image.Image`
    )r   r   r   Úchop_add©r   r   ÚscaleÚoffsets       r
   Úaddr8   ¤   s<   € ð ‡K�K„MØ
‡K�K„MØ�;‰;�v—y‘y×)Ñ)¨&¯)©)°U¸FÓCÓDÐDr   c                 ó®   — | j                  «        |j                  «        | j                  | j                  j                  |j                  ||«      «      S )zî
    Subtracts two images, dividing the result by scale and adding the offset.
    If omitted, scale defaults to 1.0, and offset to 0.0. ::

        out = ((image1 - image2) / scale + offset)

    :rtype: :py:class:`~PIL.Image.Image`
    )r   r   r   Úchop_subtractr5   s       r
   Úsubtractr;   ³   s<   € ð ‡K�K„MØ
‡K�K„MØ�;‰;�v—y‘y×.Ñ.¨v¯y©y¸%ÀÓHÓIÐIr   c                 óª   — | j                  «        |j                  «        | j                  | j                  j                  |j                  «      «      S )z‡Add two images, without clipping the result. ::

        out = ((image1 + image2) % MAX)

    :rtype: :py:class:`~PIL.Image.Image`
    )r   r   r   Úchop_add_modulor   s     r
   Ú
add_modulor>   Â   s8   € ð ‡K�K„MØ
‡K�K„MØ�;‰;�v—y‘y×0Ñ0°·±Ó;Ó<Ð<r   c                 óª   — | j                  «        |j                  «        | j                  | j                  j                  |j                  «      «      S )zŒSubtract two images, without clipping the result. ::

        out = ((image1 - image2) % MAX)

    :rtype: :py:class:`~PIL.Image.Image`
    )r   r   r   Úchop_subtract_modulor   s     r
   Úsubtract_modulorA   Ï   s8   € ð ‡K�K„MØ
‡K�K„MØ�;‰;�v—y‘y×5Ñ5°f·i±iÓ@ÓAÐAr   c                 óª   — | j                  «        |j                  «        | j                  | j                  j                  |j                  «      «      S )aj  Logical AND between two images.

    Both of the images must have mode "1". If you would like to perform a
    logical AND on an image with a mode other than "1", try
    :py:meth:`~PIL.ImageChops.multiply` instead, using a black-and-white mask
    as the second image. ::

        out = ((image1 and image2) % MAX)

    :rtype: :py:class:`~PIL.Image.Image`
    )r   r   r   Úchop_andr   s     r
   Úlogical_andrD   Ü   s8   € ð ‡K�K„MØ
‡K�K„MØ�;‰;�v—y‘y×)Ñ)¨&¯)©)Ó4Ó5Ð5r   c                 óª   — | j                  «        |j                  «        | j                  | j                  j                  |j                  «      «      S )z¦Logical OR between two images.

    Both of the images must have mode "1". ::

        out = ((image1 or image2) % MAX)

    :rtype: :py:class:`~PIL.Image.Image`
    )r   r   r   Úchop_orr   s     r
   Ú
logical_orrG   î   s8   € ð ‡K�K„MØ
‡K�K„MØ�;‰;�v—y‘y×(Ñ(¨¯©Ó3Ó4Ð4r   c                 óª   — | j                  «        |j                  «        | j                  | j                  j                  |j                  «      «      S )z³Logical XOR between two images.

    Both of the images must have mode "1". ::

        out = ((bool(image1) != bool(image2)) % MAX)

    :rtype: :py:class:`~PIL.Image.Image`
    )r   r   r   Úchop_xorr   s     r
   Úlogical_xorrJ   ý   s8   € ð ‡K�K„MØ
‡K�K„MØ�;‰;�v—y‘y×)Ñ)¨&¯)©)Ó4Ó5Ð5r   c                 ó0   — t        j                  | ||«      S )z‰Blend images using constant transparency weight. Alias for
    :py:func:`PIL.Image.blend`.

    :rtype: :py:class:`~PIL.Image.Image`
    )r   Úblend)r   r   Úalphas      r
   rL   rL     s   € ô �;‰;�v˜v uÓ-Ð-r   c                 ó0   — t        j                  | ||«      S )z†Create composite using transparency mask. Alias for
    :py:func:`PIL.Image.composite`.

    :rtype: :py:class:`~PIL.Image.Image`
    )r   Ú	composite)r   r   Úmasks      r
   rO   rO     s   € ô �?‰?˜6 6¨4Ó0Ð0r   Nc                 ó€   — |€|}| j                  «        | j                  | j                  j                  ||«      «      S )a�  Returns a copy of the image where data has been offset by the given
    distances. Data wraps around the edges. If ``yoffset`` is omitted, it
    is assumed to be equal to ``xoffset``.

    :param image: Input image.
    :param xoffset: The horizontal distance.
    :param yoffset: The vertical distance.  If omitted, both
        distances are set to the same value.
    :rtype: :py:class:`~PIL.Image.Image`
    )r   r   r   r7   )r   ÚxoffsetÚyoffsets      r
   r7   r7      s5   € ð €ØˆØ	‡J�J„LØ�:‰:�e—h‘h—o‘o g¨wÓ7Ó8Ð8r   )g      ð?é    )N)Ú r   r   r   r   r   r   r"   r%   r(   r+   r/   r2   r8   r;   r>   rA   rD   rG   rJ   rL   rO   r7   © r   r
   ú<module>rW      sv   ðõ$ ò-òò
.ò:ò9ò=ò;ò"9ò	=ò	=ò	:óEóJò
=ò
Bò6ò$5ò6ò.ò1ô9r   