+
    UBi
                    &   ^ RI Ht ^RIHt R R ltR R ltR R ltR	 R
 ltR R ltR R lt	R R lt
R R ltR R ltR R ltR R ltR.R R lltR.R R lltR R ltR R  ltR! R" ltR# R$ ltR% R& ltR' R( ltR) R* ltR/R, R- lltR+# )0    )annotations)Imagec               $    V ^8  d   QhRRRRRR/# )   imageImage.Imagevalueintreturn )formats   "3/usr/lib/python3.14/site-packages/PIL/ImageChops.py__annotate__r      s!     - -K - - -    c                F    \         P                  ! RV P                  V4      # )zNFill a channel with a given gray level.

:rtype: :py:class:`~PIL.Image.Image`
L)r   newsize)r   r	   s   &&r   constantr      s     99S%**e,,r   c                    V ^8  d   QhRRRR/# r   r   r   r   r   )r   s   "r   r   r       s      [ [ r   c                "    V P                  4       # )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                    V ^8  d   QhRRRR/# r   r   )r   s   "r   r   r   )   s     
. 
.+ 
.+ 
.r   c                t    V P                  4        V P                  V P                  P                  4       4      # )z\
Invert an image (channel). ::

    out = MAX - image

:rtype: :py:class:`~PIL.Image.Image`
)load_newimchop_invertr   s   &r   invertr"   )   s)     
JJL::ehh**,--r   c               $    V ^8  d   QhRRRRRR/# r   image1r   image2r   r   )r   s   "r   r   r   6   s!     : :K : : :r   c                    V P                  4        VP                  4        V P                  V P                  P                  VP                  4      4      # )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   s8     KKM
KKM;;vyy--fii899r   c               $    V ^8  d   QhRRRRRR/# r$   r   )r   s   "r   r   r   E   s!     9 9; 9 9 9r   c                    V P                  4        VP                  4        V P                  V P                  P                  VP                  4      4      # )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     KKM
KKM;;vyy,,VYY788r   c               $    V ^8  d   QhRRRRRR/# r$   r   )r   s   "r   r   r   T   s!     = ={ =K =K =r   c                    V P                  4        VP                  4        V P                  V P                  P                  VP                  4      4      # )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   
differencer2   T   s8     KKM
KKM;;vyy00;<<r   c               $    V ^8  d   QhRRRRRR/# r$   r   )r   s   "r   r   r   c   s!     ; ;[ ;+ ;+ ;r   c                    V P                  4        VP                  4        V P                  V P                  P                  VP                  4      4      # )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   multiplyr6   c   s8     KKM
KKM;;vyy..vyy9::r   c               $    V ^8  d   QhRRRRRR/# r$   r   )r   s   "r   r   r   t   s!     9 9; 9 9 9r   c                    V P                  4        VP                  4        V P                  V P                  P                  VP                  4      4      # )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     KKM
KKM;;vyy,,VYY788r   c               $    V ^8  d   QhRRRRRR/# r$   r   )r   s   "r   r   r      !     	= 	={ 	=K 	=K 	=r   c                    V P                  4        VP                  4        V P                  V P                  P                  VP                  4      4      # )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     KKM
KKM;;vyy00;<<r   c               $    V ^8  d   QhRRRRRR/# r$   r   )r   s   "r   r   r      r<   r   c                    V P                  4        VP                  4        V P                  V P                  P                  VP                  4      4      # )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_lightrD      r@   r   c               $    V ^8  d   QhRRRRRR/# r$   r   )r   s   "r   r   r      s!     	: 	:K 	: 	: 	:r   c                    V P                  4        VP                  4        V P                  V P                  P                  VP                  4      4      # )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   overlayrH      s8     KKM
KKM;;vyy--fii899r   c          
     ,    V ^8  d   QhRRRRRRRRRR/# r   r%   r   r&   scalefloatoffsetr   r   )r   s   "r   r   r      s;     E EE!,E5:EJOEEr   c                    V P                  4        VP                  4        V P                  V P                  P                  VP                  W#4      4      # )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&   rK   rM   s   &&&&r   addrQ      s:     KKM
KKM;;vyy))&))UCDDr   c          
     ,    V ^8  d   QhRRRRRRRRRR/# rJ   r   )r   s   "r   r   r      s;     J JJ!,J5:JJOJJr   c                    V P                  4        VP                  4        V P                  V P                  P                  VP                  W#4      4      # )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_subtractrP   s   &&&&r   subtractrU      s:     KKM
KKM;;vyy..vyy%HIIr   c               $    V ^8  d   QhRRRRRR/# r$   r   )r   s   "r   r   r      s!     
= 
={ 
=K 
=K 
=r   c                    V P                  4        VP                  4        V P                  V P                  P                  VP                  4      4      # )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_modulorY      s8     KKM
KKM;;vyy00;<<r   c               $    V ^8  d   QhRRRRRR/# r$   r   )r   s   "r   r   r      s&     
B 
BK 
B 
B 
Br   c                    V P                  4        VP                  4        V P                  V P                  P                  VP                  4      4      # )zSubtract 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_modulor]      s8     KKM
KKM;;vyy55fii@AAr   c               $    V ^8  d   QhRRRRRR/# r$   r   )r   s   "r   r   r      s!     6 6 6[ 6[ 6r   c                    V P                  4        VP                  4        V P                  V P                  P                  VP                  4      4      # )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_andra      s8     KKM
KKM;;vyy))&))455r   c               $    V ^8  d   QhRRRRRR/# r$   r   )r   s   "r   r   r      s!     5 5{ 5K 5K 5r   c                    V P                  4        VP                  4        V P                  V P                  P                  VP                  4      4      # )zLogical 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_orre      s8     KKM
KKM;;vyy((344r   c               $    V ^8  d   QhRRRRRR/# r$   r   )r   s   "r   r   r     s!     6 6 6[ 6[ 6r   c                    V P                  4        VP                  4        V P                  V P                  P                  VP                  4      4      # )zLogical 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_xorri     s8     KKM
KKM;;vyy))&))455r   c               (    V ^8  d   QhRRRRRRRR/# )r   r%   r   r&   alpharL   r   r   )r   s   "r   r   r     s(     . .+ .{ .5 .[ .r   c                0    \         P                  ! WV4      # )z}Blend images using constant transparency weight. Alias for
:py:func:`PIL.Image.blend`.

:rtype: :py:class:`~PIL.Image.Image`
)r   blend)r%   r&   rk   s   &&&r   rm   rm     s     ;;vu--r   c               (    V ^8  d   QhRRRRRRRR/# )r   r%   r   r&   maskr   r   )r   s   "r   r   r     s,     	1 	1	1!,	14?	1	1r   c                0    \         P                  ! WV4      # )zzCreate composite using transparency mask. Alias for
:py:func:`PIL.Image.composite`.

:rtype: :py:class:`~PIL.Image.Image`
)r   	composite)r%   r&   ro   s   &&&r   rq   rq     s     ??6400r   Nc               (    V ^8  d   QhRRRRRRRR/# )r   r   r   xoffsetr
   yoffsetz
int | Noner   r   )r   s   "r   r   r   (  s(     9 9+ 9 9j 9K 9r   c                    Vf   TpV P                  4        V P                  V P                  P                  W4      4      # )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    rM   )r   rs   rt   s   &&&r   rM   rM   (  s3     	JJL::ehhoog788r   )g      ?r   )N)
__future__r    r   r   r   r"   r*   r.   r2   r6   r:   r?   rD   rH   rQ   rU   rY   r]   ra   re   ri   rm   rq   rM   r   r   r   <module>rx      s~   $ # -
.:9=;"9	=	=	:E"J"
=
B6$56.	19 9r   