
    &Th[                         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     V/home/stella.sw7ft.com/public_html/venv/lib/python3.12/site-packages/PIL/ImageChops.pyconstantr      s     99S%**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)     
JJL::ehh**,--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     KKM
KKM;;vyy--fii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     KKM
KKM;;vyy,,VYY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     KKM
KKM;;vyy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     KKM
KKM;;vyy..vyy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     KKM
KKM;;vyy,,VYY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     KKM
KKM;;vyy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     KKM
KKM;;vyy--fii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<     KKM
KKM;;vyy))&))UF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<     KKM
KKM;;vyy..vyy%HIIr   c                     | j                          |j                          | j                  | j                  j                  |j                              S )zAdd 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     KKM
KKM;;vyy00;<<r   c                     | j                          |j                          | j                  | j                  j                  |j                              S )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_modulorA      s8     KKM
KKM;;vyy55fii@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     KKM
KKM;;vyy))&))455r   c                     | j                          |j                          | j                  | j                  j                  |j                              S )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_orrG      s8     KKM
KKM;;vyy((344r   c                     | j                          |j                          | j                  | j                  j                  |j                              S )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_xorrJ      s8     KKM
KKM;;vyy))&))455r   c                 0    t        j                  | ||      S )zBlend 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     ;;vvu--r   c                 0    t        j                  | ||      S )zCreate 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     ??664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     	JJL::ehhoogw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   