ó
    tvi
  ã                  ó2  • S SK Jr  SSKJr  SS jrSS jrSS jrSS jrSS jrSS	 jr	SS
 jr
SS jrSS jrSS jrSS jr S         SS jjr S         SS jjrSS jrSS jrSS jrSS jrSS jrSS jr        S S jrS!S"S jjrg)#é    )Úannotationsé   )ÚImagec                óF   • [         R                  " SU R                  U5      $ )zNFill a channel with a given gray level.

:rtype: :py:class:`~PIL.Image.Image`
ÚL)r   ÚnewÚsize)ÚimageÚvalues     Ú</root/pdf_env/lib/python3.13/site-packages/PIL/ImageChops.pyÚconstantr      s   € ô 9Š9S˜%Ÿ*™* eÓ,Ð,ó    c                ó"   • U R                  5       $ )zaCopy 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   • U R                  5         U R                  U R                  R                  5       5      $ )z\
Invert an image (channel). ::

    out = MAX - image

:rtype: :py:class:`~PIL.Image.Image`
)ÚloadÚ_newÚimÚchop_invertr   s    r   Úinvertr   )   s)   € ð 
‡JJ„LØ:‰:e—h‘h×*Ñ*Ó,Ó-Ð-r   c                óª   • U R                  5         UR                  5         U R                  U R                  R                  UR                  5      5      $ )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   6   s8   € ð ‡KK„MØ
‡KK„MØ;‰;v—y‘y×-Ñ-¨f¯i©iÓ8Ó9Ð9r   c                óª   • U R                  5         UR                  5         U R                  U R                  R                  UR                  5      5      $ )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   s8   € ð ‡KK„MØ
‡KK„MØ;‰;v—y‘y×,Ñ,¨V¯Y©YÓ7Ó8Ð8r   c                óª   • U R                  5         UR                  5         U R                  U R                  R                  UR                  5      5      $ )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   s8   € ð ‡KK„MØ
‡KK„MØ;‰;v—y‘y×0Ñ0°·±Ó;Ó<Ð<r   c                óª   • U R                  5         UR                  5         U R                  U R                  R                  UR                  5      5      $ )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   s8   € ð ‡KK„MØ
‡KK„MØ;‰;v—y‘y×.Ñ.¨v¯y©yÓ9Ó:Ð:r   c                óª   • U R                  5         UR                  5         U R                  U R                  R                  UR                  5      5      $ )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   s8   € ð ‡KK„MØ
‡KK„MØ;‰;v—y‘y×,Ñ,¨V¯Y©YÓ7Ó8Ð8r   c                óª   • U R                  5         UR                  5         U R                  U R                  R                  UR                  5      5      $ )zs
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   € ð ‡KK„MØ
‡KK„MØ;‰;v—y‘y×0Ñ0°·±Ó;Ó<Ð<r   c                óª   • U R                  5         UR                  5         U R                  U R                  R                  UR                  5      5      $ )zs
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_lightr1   Ž   r.   r   c                óª   • U R                  5         UR                  5         U R                  U R                  R                  UR                  5      5      $ )zp
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   Úoverlayr4   š   s8   € ð ‡KK„MØ
‡KK„MØ;‰;v—y‘y×-Ñ-¨f¯i©iÓ8Ó9Ð9r   c                ó¬   • U R                  5         UR                  5         U R                  U R                  R                  UR                  X#5      5      $ )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   Úaddr:   ¦   s:   € ð ‡KK„MØ
‡KK„MØ;‰;v—y‘y×)Ñ)¨&¯)©)°UÓCÓDÐDr   c                ó¬   • U R                  5         UR                  5         U R                  U R                  R                  UR                  X#5      5      $ )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_subtractr7   s       r   Úsubtractr=   ·   s:   € ð ‡KK„MØ
‡KK„MØ;‰;v—y‘y×.Ñ.¨v¯y©y¸%ÓHÓIÐIr   c                óª   • U R                  5         UR                  5         U R                  U R                  R                  UR                  5      5      $ )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   € ð ‡KK„MØ
‡KK„MØ;‰;v—y‘y×0Ñ0°·±Ó;Ó<Ð<r   c                óª   • U R                  5         UR                  5         U R                  U R                  R                  UR                  5      5      $ )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_modulorC   Õ   s8   € ð ‡KK„MØ
‡KK„MØ;‰;v—y‘y×5Ñ5°f·i±iÓ@ÓAÐAr   c                óª   • U R                  5         UR                  5         U R                  U R                  R                  UR                  5      5      $ )aN  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_andrF   â   s8   € ð ‡KK„MØ
‡KK„MØ;‰;v—y‘y×)Ñ)¨&¯)©)Ó4Ó5Ð5r   c                óª   • U R                  5         UR                  5         U R                  U R                  R                  UR                  5      5      $ )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_orrI   ô   s8   € ð ‡KK„MØ
‡KK„MØ;‰;v—y‘y×(Ñ(¨¯©Ó3Ó4Ð4r   c                óª   • U R                  5         UR                  5         U R                  U R                  R                  UR                  5      5      $ )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_xorrL     s8   € ð ‡KK„MØ
‡KK„MØ;‰;v—y‘y×)Ñ)¨&¯)©)Ó4Ó5Ð5r   c                ó0   • [         R                  " XU5      $ )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   rN   rN     s   € ô ;Š;v uÓ-Ð-r   c                ó0   • [         R                  " XU5      $ )zzCreate composite using transparency mask. Alias for
:py:func:`PIL.Image.composite`.

:rtype: :py:class:`~PIL.Image.Image`
)r   Ú	composite)r   r   Úmasks      r   rQ   rQ     s   € ô ?Š?˜6¨4Ó0Ð0r   Nc                ó€   • Uc  UnU R                  5         U R                  U R                  R                  X5      5      $ )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   r9   )r
   ÚxoffsetÚyoffsets      r   r9   r9   (  s3   € ð ØˆØ	‡JJ„LØ:‰:e—h‘h—o‘o gÓ7Ó8Ð8r   )r
   úImage.Imager   ÚintÚreturnrV   )r
   rV   rX   rV   )r   rV   r   rV   rX   rV   )g      ð?r   )
r   rV   r   rV   r8   Úfloatr9   rY   rX   rV   )r   rV   r   rV   rO   rY   rX   rV   )r   rV   r   rV   rR   rV   rX   rV   )N)r
   rV   rT   rW   rU   z
int | NonerX   rV   )Ú
__future__r   Ú r   r   r   r   r   r!   r$   r'   r*   r-   r1   r4   r:   r=   r@   rC   rF   rI   rL   rN   rQ   r9   © r   r   Ú<module>r]      s  ðõ$ #å ô-ôô
.ô:ô9ô=ô;ô"9ô	=ô	=ô	:ð STðEØðEØ!,ðEØ5:ðEØJOðEàõEð$ STðJØðJØ!,ðJØ5:ðJØJOðJàõJô"
=ô
Bô6ô$5ô6ô.ð	1Øð	1Ø!,ð	1Ø4?ð	1àô	1÷9r   