B
    eAd[  ã               @   s¾   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d0dd„Zdd„ Zd d!„ Zd"d#„ Zd$d%„ Zd&d'„ Zd(d)„ Zd*d+„ Zd1d-d.„Zd,S )2é   )ÚImagec             C   s   t  d| j|¡S )zVFill a channel with a given grey level.

    :rtype: :py:class:`~PIL.Image.Image`
    ÚL)r   ÚnewÚsize)ÚimageÚvalue© r   ú@/var/www/html/venv/lib/python3.7/site-packages/PIL/ImageChops.pyÚconstant   s    r
   c             C   s   |   ¡ S )ziCopy a channel. Alias for :py:meth:`PIL.Image.Image.copy`.

    :rtype: :py:class:`~PIL.Image.Image`
    )Úcopy)r   r   r   r	   Ú	duplicate   s    r   c             C   s   |   ¡  |  | j ¡ ¡S )zl
    Invert an image (channel). ::

        out = MAX - image

    :rtype: :py:class:`~PIL.Image.Image`
    )ÚloadÚ_newÚimZchop_invert)r   r   r   r	   Úinvert'   s    	r   c             C   s$   |   ¡  |  ¡  |  | 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   Zchop_lighter)Úimage1Úimage2r   r   r	   Úlighter4   s    
r   c             C   s$   |   ¡  |  ¡  |  | 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   Zchop_darker)r   r   r   r   r	   ÚdarkerC   s    
r   c             C   s$   |   ¡  |  ¡  |  | 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   Zchop_difference)r   r   r   r   r	   Ú
differenceR   s    
r   c             C   s$   |   ¡  |  ¡  |  | 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   Zchop_multiply)r   r   r   r   r	   Úmultiplya   s    r   c             C   s$   |   ¡  |  ¡  |  | 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   Zchop_screen)r   r   r   r   r	   Úscreenr   s    	r   c             C   s$   |   ¡  |  ¡  |  | 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   Zchop_soft_light)r   r   r   r   r	   Ú
soft_light€   s    r   c             C   s$   |   ¡  |  ¡  |  | 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   Zchop_hard_light)r   r   r   r   r	   Ú
hard_lightŒ   s    r   c             C   s$   |   ¡  |  ¡  |  | 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   Zchop_overlay)r   r   r   r   r	   Úoverlay˜   s    r   ç      ð?é    c             C   s(   |   ¡  |  ¡  |  | 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   Zchop_add)r   r   ÚscaleÚoffsetr   r   r	   Úadd¤   s    
r   c             C   s(   |   ¡  |  ¡  |  | 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   Zchop_subtract)r   r   r   r   r   r   r	   Úsubtract³   s    
r    c             C   s$   |   ¡  |  ¡  |  | j |j¡¡S )z‡Add two images, without clipping the result. ::

        out = ((image1 + image2) % MAX)

    :rtype: :py:class:`~PIL.Image.Image`
    )r   r   r   Zchop_add_modulo)r   r   r   r   r	   Ú
add_moduloÂ   s    r!   c             C   s$   |   ¡  |  ¡  |  | j |j¡¡S )zŒSubtract two images, without clipping the result. ::

        out = ((image1 - image2) % MAX)

    :rtype: :py:class:`~PIL.Image.Image`
    )r   r   r   Zchop_subtract_modulo)r   r   r   r   r	   Úsubtract_moduloÏ   s    r"   c             C   s$   |   ¡  |  ¡  |  | 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   Zchop_and)r   r   r   r   r	   Úlogical_andÜ   s    r#   c             C   s$   |   ¡  |  ¡  |  | 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   Zchop_or)r   r   r   r   r	   Ú
logical_orî   s    
r$   c             C   s$   |   ¡  |  ¡  |  | 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   Zchop_xor)r   r   r   r   r	   Úlogical_xorý   s    
r%   c             C   s   t  | ||¡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   Úalphar   r   r	   r&     s    r&   c             C   s   t  | ||¡S )z†Create composite using transparency mask. Alias for
    :py:func:`PIL.Image.composite`.

    :rtype: :py:class:`~PIL.Image.Image`
    )r   Ú	composite)r   r   Úmaskr   r   r	   r(     s    r(   Nc             C   s(   |dkr|}|   ¡  |  | 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`
    N)r   r   r   r   )r   ZxoffsetZyoffsetr   r   r	   r      s    r   )r   r   )r   r   )N)Ú r   r
   r   r   r   r   r   r   r   r   r   r   r   r    r!   r"   r#   r$   r%   r&   r(   r   r   r   r   r	   Ú<module>   s*   		



