403Webshell
Server IP : 146.190.157.162  /  Your IP : 216.73.216.186
Web Server : Apache
System : Linux ubuntu-s-2vcpu-4gb-amd-sfo3-01-KIT-DIGITAL 6.5.0-44-generic #44-Ubuntu SMP PREEMPT_DYNAMIC Fri Jun 7 15:10:09 UTC 2024 x86_64
User : businessweek ( 639)
PHP Version : 8.2.10-2ubuntu2.2
Disable Function : exec,passthru,shell_exec,system,proc_open,popen,pcntl_exec,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_signal,pcntl_signal_dispatch,pcntl_getpriority,pcntl_setpriority,dl,putenv,parse_ini_file,show_source
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : OFF
Directory :  /usr/lib/python3/dist-packages/PIL/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /usr/lib/python3/dist-packages/PIL/__pycache__/ImageChops.cpython-311.pyc
�

D#�d[���ddlmZd�Zd�Zd�Zd�Zd�Zd�Zd�Zd	�Z	d
�Z
d�Zd�Zdd�Z
dd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zdd�ZdS)�)�Imagec�8�tjd|j|��S)zVFill a channel with a given grey level.

    :rtype: :py:class:`~PIL.Image.Image`
    �L)r�new�size)�image�values  �0/usr/lib/python3/dist-packages/PIL/ImageChops.py�constantrs���9�S�%�*�e�,�,�,�c�*�|���S)ziCopy a channel. Alias for :py:meth:`PIL.Image.Image.copy`.

    :rtype: :py:class:`~PIL.Image.Image`
    )�copy�rs r
�	duplicaters���:�:�<�<�rc��|���|�|j�����S)zl
    Invert an image (channel). ::

        out = MAX - image

    :rtype: :py:class:`~PIL.Image.Image`
    )�load�_new�im�chop_invertrs r
�invertr's1��
�J�J�L�L�L��:�:�e�h�*�*�,�,�-�-�-rc��|���|���|�|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`
    )rrr�chop_lighter��image1�image2s  r
�lighterr4sB���K�K�M�M�M�
�K�K�M�M�M��;�;�v�y�-�-�f�i�8�8�9�9�9rc��|���|���|�|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`
    )rrr�chop_darkerrs  r
�darkerrCsB���K�K�M�M�M�
�K�K�M�M�M��;�;�v�y�,�,�V�Y�7�7�8�8�8rc��|���|���|�|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`
    )rrr�chop_differencers  r
�
differencer"RsB���K�K�M�M�M�
�K�K�M�M�M��;�;�v�y�0�0���;�;�<�<�<rc��|���|���|�|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`
    )rrr�
chop_multiplyrs  r
�multiplyr%asB���K�K�M�M�M�
�K�K�M�M�M��;�;�v�y�.�.�v�y�9�9�:�:�:rc��|���|���|�|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`
    )rrr�chop_screenrs  r
�screenr(rsB���K�K�M�M�M�
�K�K�M�M�M��;�;�v�y�,�,�V�Y�7�7�8�8�8rc��|���|���|�|j�|j����S)z
    Superimposes two images on top of each other using the Soft Light algorithm

    :rtype: :py:class:`~PIL.Image.Image`
    )rrr�chop_soft_lightrs  r
�
soft_lightr+��B���K�K�M�M�M�
�K�K�M�M�M��;�;�v�y�0�0���;�;�<�<�<rc��|���|���|�|j�|j����S)z
    Superimposes two images on top of each other using the Hard Light algorithm

    :rtype: :py:class:`~PIL.Image.Image`
    )rrr�chop_hard_lightrs  r
�
hard_lightr/�r,rc��|���|���|�|j�|j����S)z|
    Superimposes two images on top of each other using the Overlay algorithm

    :rtype: :py:class:`~PIL.Image.Image`
    )rrr�chop_overlayrs  r
�overlayr2�sB���K�K�M�M�M�
�K�K�M�M�M��;�;�v�y�-�-�f�i�8�8�9�9�9r��?�c��|���|���|�|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`
    )rrr�chop_add�rr�scale�offsets    r
�addr:�sF���K�K�M�M�M�
�K�K�M�M�M��;�;�v�y�)�)�&�)�U�F�C�C�D�D�Drc��|���|���|�|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`
    )rrr�
chop_subtractr7s    r
�subtractr=�sF���K�K�M�M�M�
�K�K�M�M�M��;�;�v�y�.�.�v�y�%��H�H�I�I�Irc��|���|���|�|j�|j����S)z�Add two images, without clipping the result. ::

        out = ((image1 + image2) % MAX)

    :rtype: :py:class:`~PIL.Image.Image`
    )rrr�chop_add_modulors  r
�
add_modulor@�sB���K�K�M�M�M�
�K�K�M�M�M��;�;�v�y�0�0���;�;�<�<�<rc��|���|���|�|j�|j����S)z�Subtract two images, without clipping the result. ::

        out = ((image1 - image2) % MAX)

    :rtype: :py:class:`~PIL.Image.Image`
    )rrr�chop_subtract_modulors  r
�subtract_modulorC�sB���K�K�M�M�M�
�K�K�M�M�M��;�;�v�y�5�5�f�i�@�@�A�A�Arc��|���|���|�|j�|j����S)ajLogical 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�chop_andrs  r
�logical_andrF�sB���K�K�M�M�M�
�K�K�M�M�M��;�;�v�y�)�)�&�)�4�4�5�5�5rc��|���|���|�|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`
    )rrr�chop_orrs  r
�
logical_orrI�sB���K�K�M�M�M�
�K�K�M�M�M��;�;�v�y�(�(���3�3�4�4�4rc��|���|���|�|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`
    )rrr�chop_xorrs  r
�logical_xorrL�sB���K�K�M�M�M�
�K�K�M�M�M��;�;�v�y�)�)�&�)�4�4�5�5�5rc�.�tj|||��S)z�Blend images using constant transparency weight. Alias for
    :py:func:`PIL.Image.blend`.

    :rtype: :py:class:`~PIL.Image.Image`
    )r�blend)rr�alphas   r
rNrNs���;�v�v�u�-�-�-rc�.�tj|||��S)z�Create composite using transparency mask. Alias for
    :py:func:`PIL.Image.composite`.

    :rtype: :py:class:`~PIL.Image.Image`
    )r�	composite)rr�masks   r
rQrQs���?�6�6�4�0�0�0rNc��|�|}|���|�|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`
    )rrrr9)r�xoffset�yoffsets   r
r9r9 s=������	�J�J�L�L�L��:�:�e�h�o�o�g�w�7�7�8�8�8r)r3r4)N)�rrrrrrr"r%r(r+r/r2r:r=r@rCrFrIrLrNrQr9�rr
�<module>rXsx��$������-�-�-����
.�
.�
.�:�:�:�9�9�9�=�=�=�;�;�;�"9�9�9�	=�	=�	=�	=�	=�	=�	:�	:�	:�E�E�E�E�J�J�J�J�
=�
=�
=�
B�
B�
B�6�6�6�$5�5�5�6�6�6�.�.�.�1�1�1�9�9�9�9�9�9r

Youez - 2016 - github.com/yon3zu
LinuXploit