old-saburly-wagtail-web/env/lib/python3.10/site-packages/PIL/__pycache__/ImageChops.cpython-310.pyc

o
<00><><EFBFBD>f
<00>@
s<>dd
lm
Z

ddlmZ
d>d	d
<EFBFBD>Zd?dd<0C>Zd?d
d<0E>Zd@dd<12>Zd@dd<14>Zd@dd<16>Z	d@dd<18>Z
d@dd<1A>Zd@dd<1C>Zd@dd<1E>Z
d@dd <20>Z	dAdBd%d&<26>Z	dAdBd'd(<28>Zd@d)d*<2A>Zd@d+d,<2C>Zd@d-d.<2E>Zd@d/d0<64>Zd@d1d2<64>ZdCd4d5<64>ZdDd7d8<64>ZdEdFd=d$<24>Zd9S)G<>)
<01>annotations<6E>
)
<01>Image<67>image<67>Image.Image<67>value<75>int<6E>returncC
st<00>
d
|j|
<01>S)zVFill a channel with a given gray level.

    :rtype: :py:class:`~PIL.Image.Image`
    <20>
L)r<00>new<65>size)rr<00>r
<00>P/home/amir/Desktop/saburlyweb/env/lib/python3.10/site-packages/PIL/ImageChops.py<70>constantsrc

C
s|<00><00>S)
ziCopy a channel. Alias for :py:meth:`PIL.Image.Image.copy`.

    :rtype: :py:class:`~PIL.Image.Image`
    )
<01>copy<70>
rr
r
r<00>	duplicate src

C
s|<00><00>
|<00>
|j<02><03><00>
S)
zl
    Invert an image (channel). ::

        out = MAX - image

    :rtype: :py:class:`~PIL.Image.Image`
    )<04>load<61>_new<65>im<69>chop_invertrr
r
r<00>invert)s	
r<00>image1<65>image2cC
<01>$|<00><00>
|
<01><00>
|<00>
|j<02>|
j<02>
<01>
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`
    )rrr<00>chop_lighter<65>rrr
r
r<00>lighter6<00>


rcC
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`
    )rrr<00>chop_darkerrr
r
r<00>darkerErr cC
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`
    )rrr<00>chop_differencerr
r
r<00>
differenceTrr"cC
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`
    )rrr<00>
chop_multiplyrr
r
r<00>multiplycs

r$cC
r)
z<>
    Superimposes two inverted images on top of each other. ::

        out = MAX - ((MAX - image1) * (MAX - image2) / MAX)

    :rtype: :py:class:`~PIL.Image.Image`
    )rrr<00>chop_screenrr
r
r<00>screents	

r&cC
r)
z
    Superimposes two images on top of each other using the Soft Light algorithm

    :rtype: :py:class:`~PIL.Image.Image`
    )rrr<00>chop_soft_lightrr
r
r<00>
soft_light<EFBFBD><00>

r(cC
r)
z
    Superimposes two images on top of each other using the Hard Light algorithm

    :rtype: :py:class:`~PIL.Image.Image`
    )rrr<00>chop_hard_lightrr
r
r<00>
hard_light<EFBFBD>r)r+cC
r)
z|
    Superimposes two images on top of each other using the Overlay algorithm

    :rtype: :py:class:`~PIL.Image.Image`
    )rrr<00>chop_overlayrr
r
r<00>overlay<61>r)r-<00><00>?<3F>scale<6C>float<61>offsetcC
<01>(|<00><00>
|
<01><00>
|<00>
|j<02>|
j||<03><03>
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`
    )rrr<00>chop_add<64>rrr/r1r
r
r<00>add<64><00>

r5cC
r2)
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`
    )rrr<00>
chop_subtractr4r
r
r<00>subtract<63>r6r8cC
r)
z<>Add two images, without clipping the result. ::

        out = ((image1 + image2) % MAX)

    :rtype: :py:class:`~PIL.Image.Image`
    )rrr<00>chop_add_modulorr
r
r<00>
add_modulo<EFBFBD><00>

r:cC
r)
z<>Subtract two images, without clipping the result. ::

        out = ((image1 - image2) % MAX)

    :rtype: :py:class:`~PIL.Image.Image`
    )rrr<00>chop_subtract_modulorr
r
r<00>subtract_modulo<6C>r;r=cC
r)
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`
    )rrr<00>chop_andrr
r
r<00>logical_and<6E>s


r?cC
r)
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`
    )rrr<00>chop_orrr
r
r<00>
logical_or<EFBFBD>rrAcC
r)
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`
    )rrr<00>chop_xorrr
r
r<00>logical_xor
rrC<00>alphacC
<01>t<00>
||
|<02>S)
z<>Blend images using constant transparency weight. Alias for
    :py:func:`PIL.Image.blend`.

    :rtype: :py:class:`~PIL.Image.Image`
    )r<00>blend)rrrDr
r
rrF
srF<00>maskcC
rE)
z<>Create composite using transparency mask. Alias for
    :py:func:`PIL.Image.composite`.

    :rtype: :py:class:`~PIL.Image.Image`
    )r<00>	composite)rrrGr
r
rrH
s	rHN<>xoffset<65>yoffset<65>
int | NonecC
s(|d
ur|
}|<00><00>
|<00>
|j<02>|
|<02><02>
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)rrrr1)rrIrJr
r
rr1(
s


)rrrrr	r)rrr	r)rrrrr	r)r.r
)
rrrrr/r0r1r0r	r)rrrrrDr0r	r)rrrrrGrr	r)
N)rrrIrrJrKr	r)<19>
__future__r<00>rrrrrr r"r$r&r(r+r-r5r8r:r=r?rArCrFrHr1r
r
r
r<00><module>
s2

	
	








<0C><0C>