§
    aÒ³g
  ã                  óÐ   — d dl mZ ddlmZ d*d	„Zd+d
„Zd+d„Zd,d„Zd,d„Zd,d„Z	d,d„Z
d,d„Zd,d„Zd,d„Zd,d„Z	 d-d.d„Z	 d-d.d„Zd,d„Zd,d„Zd,d„Zd,d„Zd,d „Zd/d"„Zd0d$„Zd1d2d)„Zd%S )3é    )Úannotationsé   )ÚImageÚimageúImage.ImageÚvalueÚintÚreturnc                ó8   — t          j        d| j        |¦  «        S )zVFill a channel with a given gray level.

    :rtype: :py:class:`~PIL.Image.Image`
    ÚL)r   ÚnewÚsize)r   r   s     úL/var/www/html/mpstechhub/venv/lib/python3.11/site-packages/PIL/ImageChops.pyÚconstantr      s   € õ Œ9�S˜%œ* eÑ,Ô,Ð,ó    c                ó*   — |                       ¦   «         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                ó‚   — |                       ¦   «          |                      | j                             ¦   «         ¦  «        S )zl
    Invert an image (channel). ::

        out = MAX - image

    :rtype: :py:class:`~PIL.Image.Image`
    )ÚloadÚ_newÚimÚchop_invertr   s    r   Úinvertr   )   s1   € ð 
‡J‚J�L„L€LØ�:Š:�e”h×*Ò*Ñ,Ô,Ñ-Ô-Ð-r   Úimage1Úimage2c                ó¶   — |                       ¦   «          |                      ¦   «          |                      | 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©r   r   s     r   Úlighterr!   6   sB   € ð ‡K‚K�M„M€MØ
‡K‚K�M„M€MØ�;Š;�v”y×-Ò-¨f¬iÑ8Ô8Ñ9Ô9Ð9r   c                ó¶   — |                       ¦   «          |                      ¦   «          |                      | 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$   E   sB   € ð ‡K‚K�M„M€MØ
‡K‚K�M„M€MØ�;Š;�v”y×,Ò,¨V¬YÑ7Ô7Ñ8Ô8Ð8r   c                ó¶   — |                       ¦   «          |                      ¦   «          |                      | 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'   T   sB   € ð ‡K‚K�M„M€MØ
‡K‚K�M„M€MØ�;Š;�v”y×0Ò0°´Ñ;Ô;Ñ<Ô<Ð<r   c                ó¶   — |                       ¦   «          |                      ¦   «          |                      | 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*   c   sB   € ð ‡K‚K�M„M€MØ
‡K‚K�M„M€MØ�;Š;�v”y×.Ò.¨v¬yÑ9Ô9Ñ:Ô:Ð:r   c                ó¶   — |                       ¦   «          |                      ¦   «          |                      | 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-   t   sB   € ð ‡K‚K�M„M€MØ
‡K‚K�M„M€MØ�;Š;�v”y×,Ò,¨V¬YÑ7Ô7Ñ8Ô8Ð8r   c                ó¶   — |                       ¦   «          |                      ¦   «          |                      | 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_lightr0   ‚   óB   € ð ‡K‚K�M„M€MØ
‡K‚K�M„M€MØ�;Š;�v”y×0Ò0°´Ñ;Ô;Ñ<Ô<Ð<r   c                ó¶   — |                       ¦   «          |                      ¦   «          |                      | 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_lightr4   Ž   r1   r   c                ó¶   — |                       ¦   «          |                      ¦   «          |                      | 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   Úoverlayr7   š   sB   € ð ‡K‚K�M„M€MØ
‡K‚K�M„M€MØ�;Š;�v”y×-Ò-¨f¬iÑ8Ô8Ñ9Ô9Ð9r   ç      ð?ÚscaleÚfloatÚoffsetc                óº   — |                       ¦   «          |                      ¦   «          |                      | 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   r9   r;   s       r   Úaddr?   ¦   sF   € ð ‡K‚K�M„M€MØ
‡K‚K�M„M€MØ�;Š;�v”y×)Ò)¨&¬)°U¸FÑCÔCÑDÔDÐDr   c                óº   — |                       ¦   «          |                      ¦   «          |                      | 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_subtractr>   s       r   ÚsubtractrB   ·   sF   € ð ‡K‚K�M„M€MØ
‡K‚K�M„M€MØ�;Š;�v”y×.Ò.¨v¬y¸%ÀÑHÔHÑIÔIÐIr   c                ó¶   — |                       ¦   «          |                      ¦   «          |                      | 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_modulorE   È   sB   € ð ‡K‚K�M„M€MØ
‡K‚K�M„M€MØ�;Š;�v”y×0Ò0°´Ñ;Ô;Ñ<Ô<Ð<r   c                ó¶   — |                       ¦   «          |                      ¦   «          |                      | 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_modulorH   Õ   sB   € ð ‡K‚K�M„M€MØ
‡K‚K�M„M€MØ�;Š;�v”y×5Ò5°f´iÑ@Ô@ÑAÔAÐAr   c                ó¶   — |                       ¦   «          |                      ¦   «          |                      | 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_andrK   â   sB   € ð ‡K‚K�M„M€MØ
‡K‚K�M„M€MØ�;Š;�v”y×)Ò)¨&¬)Ñ4Ô4Ñ5Ô5Ð5r   c                ó¶   — |                       ¦   «          |                      ¦   «          |                      | 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_orrN   ô   sB   € ð ‡K‚K�M„M€MØ
‡K‚K�M„M€MØ�;Š;�v”y×(Ò(¨¬Ñ3Ô3Ñ4Ô4Ð4r   c                ó¶   — |                       ¦   «          |                      ¦   «          |                      | 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_xorrQ     sB   € ð ‡K‚K�M„M€MØ
‡K‚K�M„M€MØ�;Š;�v”y×)Ò)¨&¬)Ñ4Ô4Ñ5Ô5Ð5r   Úalphac                ó.   — 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   rR   s      r   rT   rT     s   € õ Œ;�v˜v uÑ-Ô-Ð-r   Úmaskc                ó.   — 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   rU   s      r   rW   rW     s   € õ Œ?˜6 6¨4Ñ0Ô0Ð0r   NÚxoffsetÚyoffsetú
int | Nonec                óŽ   — |€|}|                       ¦   «          |                      | 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   r;   )r   rX   rY   s      r   r;   r;   (  s=   € ð €ØˆØ	‡J‚J�L„L€LØ�:Š:�e”h—o’o g¨wÑ7Ô7Ñ8Ô8Ð8r   )r   r   r   r	   r
   r   )r   r   r
   r   )r   r   r   r   r
   r   )r8   r   )
r   r   r   r   r9   r:   r;   r:   r
   r   )r   r   r   r   rR   r:   r
   r   )r   r   r   r   rU   r   r
   r   )N)r   r   rX   r	   rY   rZ   r
   r   )Ú
__future__r   Ú r   r   r   r   r!   r$   r'   r*   r-   r0   r4   r7   r?   rB   rE   rH   rK   rN   rQ   rT   rW   r;   © r   r   ú<module>r_      s  ðð$ #Ð "Ð "Ð "Ð "Ð "à Ð Ð Ð Ð Ð ð-ð -ð -ð -ðð ð ð ð
.ð 
.ð 
.ð 
.ð:ð :ð :ð :ð9ð 9ð 9ð 9ð=ð =ð =ð =ð;ð ;ð ;ð ;ð"9ð 9ð 9ð 9ð	=ð 	=ð 	=ð 	=ð	=ð 	=ð 	=ð 	=ð	:ð 	:ð 	:ð 	:ð STðEð Eð Eð Eð Eð$ STðJð Jð Jð Jð Jð"
=ð 
=ð 
=ð 
=ð
Bð 
Bð 
Bð 
Bð6ð 6ð 6ð 6ð$5ð 5ð 5ð 5ð6ð 6ð 6ð 6ð.ð .ð .ð .ð	1ð 	1ð 	1ð 	1ð9ð 9ð 9ð 9ð 9ð 9ð 9r   