+
     i
  c                  s&   ^ 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               s$    V ^8  d   QhRRRRRR/# )   imageImage.Imagevalueintreturn Zformat   "5/usr/lib64/python3.14/site-packages/PIL/ImageChops.py__annotate__r      s!     - -K - - -    c                sF    \         P                  ! RV P                  V4      # )zNFill a channel with a given gray level.

:rtype: :py:class:`~PIL.Image.Image`
ZL)r   ZnewZsize)r   r      &&r   constantr      s     99S%**e,,r   c                    V ^8  d   QhRRRR/# r   r   r   r   r	   r
   r   r   r   r       s      [ [ r   c                s"    V P                  4       # )zaCopy a channel. Alias for :py:meth:`PIL.Image.Image.copy`.

:rtype: :py:class:`~PIL.Image.Image`
)Zcopyr      &r   	duplicater       s     ::<r   c               r   r   r	   r
   r   r   r   r   )   s     
. 
.+ 
.+ 
.r   c                st    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imZchop_invertr   r   r   invertr   )   s)     
JJL::ehh**,--r   c               $    V ^8  d   QhRRRRRR/# r   image1r   image2r   r	   r
   r   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   Zchop_lighterr   r   r   r   lighterr    6   s8     KKM
KKM;;vyy--fii899r   c               r   r   r	   r
   r   r   r   r   E   s!     9 9; 9 9 9r   c                r   )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   Zchop_darkerr   r   r   darkerr!   E   s8     KKM
KKM;;vyy,,VYY788r   c               r   r   r	   r
   r   r   r   r   T   s!     = ={ =K =K =r   c                r   )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   Zchop_differencer   r   r   
differencer"   T   s8     KKM
KKM;;vyy00;<<r   c               r   r   r	   r
   r   r   r   r   c   s!     ; ;[ ;+ ;+ ;r   c                r   )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   Zchop_multiplyr   r   r   multiplyr#   c   s8     KKM
KKM;;vyy..vyy9::r   c               r   r   r	   r
   r   r   r   r   t   s!     9 9; 9 9 9r   c                r   )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   Zchop_screenr   r   r   screenr$   t   s8     KKM
KKM;;vyy,,VYY788r   c               r   r   r	   r
   r   r   r   r      !     	= 	={ 	=K 	=K 	=r   c                r   )zs
Superimposes two images on top of each other using the Soft Light algorithm

:rtype: :py:class:`~PIL.Image.Image`
)r   r   r   Zchop_soft_lightr   r   r   
soft_lightr&      8     KKM
KKM;;vyy00;<<r   c               r   r   r	   r
   r   r   r   r      r%   r   c                r   )zs
Superimposes two images on top of each other using the Hard Light algorithm

:rtype: :py:class:`~PIL.Image.Image`
)r   r   r   Zchop_hard_lightr   r   r   
hard_lightr(      r'   r   c               r   r   r	   r
   r   r   r   r      s!     	: 	:K 	: 	: 	:r   c                r   )zp
Superimposes two images on top of each other using the Overlay algorithm

:rtype: :py:class:`~PIL.Image.Image`
)r   r   r   Zchop_overlayr   r   r   overlayr)      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
   r   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   Zchop_addr   r   r,   r.      &&&&r   addr2      s:     KKM
KKM;;vyy))&))UCDDr   c          
     r*   r+   r	   r
   r   r   r   r      s;     J JJ!,J5:JJOJJr   c                r/   )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   Zchop_subtractr0   r1   r   subtractr3      s:     KKM
KKM;;vyy..vyy%HIIr   c               r   r   r	   r
   r   r   r   r      s!     
= 
={ 
=K 
=K 
=r   c                r   )z{Add two images, without clipping the result. ::

    out = ((image1 + image2) % MAX)

:rtype: :py:class:`~PIL.Image.Image`
)r   r   r   Zchop_add_modulor   r   r   
add_modulor4      s8     KKM
KKM;;vyy00;<<r   c               r   r   r	   r
   r   r   r   r      s&     
B 
BK 
B 
B 
Br   c                r   )zSubtract two images, without clipping the result. ::

    out = ((image1 - image2) % MAX)

:rtype: :py:class:`~PIL.Image.Image`
)r   r   r   Zchop_subtract_modulor   r   r   subtract_modulor5      s8     KKM
KKM;;vyy55fii@AAr   c               r   r   r	   r
   r   r   r   r      s!     6 6 6[ 6[ 6r   c                r   )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   Zchop_andr   r   r   logical_andr6      s8     KKM
KKM;;vyy))&))455r   c               r   r   r	   r
   r   r   r   r      s!     5 5{ 5K 5K 5r   c                r   )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   Zchop_orr   r   r   
logical_orr7      s8     KKM
KKM;;vyy((344r   c               r   r   r	   r
   r   r   r   r     s!     6 6 6[ 6[ 6r   c                r   )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   Zchop_xorr   r   r   logical_xorr8     s8     KKM
KKM;;vyy))&))455r   c               s(    V ^8  d   QhRRRRRRRR/# )r   r   r   r   alphar-   r   r	   r
   r   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   r9      &&&r   r;   r;     s     ;;vu--r   c               s(    V ^8  d   QhRRRRRRRR/# )r   r   r   r   maskr   r	   r
   r   r   r   r     s,     	1 	1	1!,	14?	1	1r   c                r:   )zzCreate composite using transparency mask. Alias for
:py:func:`PIL.Image.composite`.

:rtype: :py:class:`~PIL.Image.Image`
)r   	composite)r   r   r=   r<   r   r>   r>     s     ??6400r   Nc               s(    V ^8  d   QhRRRRRRRR/# )r   r   r   xoffsetr   yoffsetz
int | Noner   r	   r
   r   r   r   r   (  s(     9 9+ 9 9j 9K 9r   c                s    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   r.   )r   r?   r@   r<   r   r.   r.   (  s3     	JJL::ehhoog788r   )g      ?r    )N)Z
__future__r   Z r   r   r   r   r    r!   r"   r#   r$   r&   r(   r)   r2   r3   r4   r5   r6   r7   r8   r;   r>   r.   r	   r   r   <module>rA      s~   $ # -
.:9=;"9	=	=	:E"J"
=
B6$56.	19 9r   