mirror of
https://github.com/python-pillow/Pillow.git
synced 2025-10-31 07:57:27 +03:00
164 lines
4.5 KiB
ReStructuredText
164 lines
4.5 KiB
ReStructuredText
=========================
|
|
The PIL.ImageChops Module
|
|
=========================
|
|
|
|
The PIL.ImageChops Module
|
|
=========================
|
|
|
|
The **ImageChops** module contains a number of arithmetical image
|
|
operations, called *channel operations* ("chops"). These can be used for
|
|
various purposes, including special effects, image compositions,
|
|
algorithmic painting, and more.
|
|
|
|
At this time, channel operations are only implemented for 8-bit images
|
|
(e.g. "L" and "RGB").
|
|
|
|
Most channel operations take one or two image arguments and returns a
|
|
new image. Unless otherwise noted, the result of a channel operation is
|
|
always clipped to the range 0 to MAX (which is 255 for all modes
|
|
supported by the operations in this module).
|
|
|
|
Module Contents
|
|
---------------
|
|
|
|
**add(image1, image2, scale=1.0, offset=0)**
|
|
[`# <#PIL.ImageChops.add-function>`_]
|
|
Add images ((image1 + image2) / scale + offset).
|
|
|
|
Adds two images, dividing the result by scale and adding the offset.
|
|
If omitted, scale defaults to 1.0, and offset to 0.0.
|
|
|
|
*image1*
|
|
*image1*
|
|
Returns:
|
|
|
|
**add\_modulo(image1, image2)**
|
|
[`# <#PIL.ImageChops.add_modulo-function>`_]
|
|
Add images without clipping ((image1 + image2) % MAX).
|
|
|
|
Adds two images, without clipping the result.
|
|
|
|
*image1*
|
|
*image1*
|
|
Returns:
|
|
|
|
**blend(image1, image2, alpha)** [`# <#PIL.ImageChops.blend-function>`_]
|
|
Blend images using constant transparency weight.
|
|
|
|
Same as the **blend** function in the **Image** module.
|
|
|
|
**composite(image1, image2, mask)**
|
|
[`# <#PIL.ImageChops.composite-function>`_]
|
|
Create composite using transparency mask.
|
|
|
|
Same as the **composite** function in the **Image** module.
|
|
|
|
**constant(image, value)** [`# <#PIL.ImageChops.constant-function>`_]
|
|
|
|
*image*
|
|
*value*
|
|
Returns:
|
|
|
|
**darker(image1, image2)** [`# <#PIL.ImageChops.darker-function>`_]
|
|
Compare images, and return darker pixel value (min(image1, image2)).
|
|
|
|
Compares the two images, pixel by pixel, and returns a new image
|
|
containing the darker values.
|
|
|
|
*image1*
|
|
*image1*
|
|
Returns:
|
|
|
|
**difference(image1, image2)**
|
|
[`# <#PIL.ImageChops.difference-function>`_]
|
|
Calculate absolute difference (abs(image1 - image2)).
|
|
|
|
Returns the absolute value of the difference between the two images.
|
|
|
|
*image1*
|
|
*image1*
|
|
Returns:
|
|
|
|
**duplicate(image)** [`# <#PIL.ImageChops.duplicate-function>`_]
|
|
|
|
*image*
|
|
Returns:
|
|
|
|
**invert(image)** [`# <#PIL.ImageChops.invert-function>`_]
|
|
|
|
*image*
|
|
Returns:
|
|
|
|
**lighter(image1, image2)** [`# <#PIL.ImageChops.lighter-function>`_]
|
|
Compare images, and return lighter pixel value (max(image1,
|
|
image2)).
|
|
|
|
Compares the two images, pixel by pixel, and returns a new image
|
|
containing the lighter values.
|
|
|
|
*image1*
|
|
*image1*
|
|
Returns:
|
|
|
|
**logical\_and(image1, image2)**
|
|
[`# <#PIL.ImageChops.logical_and-function>`_]
|
|
**logical\_or(image1, image2)**
|
|
[`# <#PIL.ImageChops.logical_or-function>`_]
|
|
**logical\_xor(image1, image2)**
|
|
[`# <#PIL.ImageChops.logical_xor-function>`_]
|
|
**multiply(image1, image2)** [`# <#PIL.ImageChops.multiply-function>`_]
|
|
Superimpose positive images (image1 \* image2 / MAX).
|
|
|
|
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.
|
|
|
|
*image1*
|
|
*image1*
|
|
Returns:
|
|
|
|
**offset(image, xoffset, yoffset=None)**
|
|
[`# <#PIL.ImageChops.offset-function>`_]
|
|
Offset image data.
|
|
|
|
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.
|
|
|
|
*image*
|
|
*xoffset*
|
|
*yoffset*
|
|
Returns:
|
|
|
|
**screen(image1, image2)** [`# <#PIL.ImageChops.screen-function>`_]
|
|
Superimpose negative images (MAX - ((MAX - image1) \* (MAX - image2)
|
|
/ MAX)).
|
|
|
|
Superimposes two inverted images on top of each other.
|
|
|
|
*image1*
|
|
*image1*
|
|
Returns:
|
|
|
|
**subtract(image1, image2, scale=1.0, offset=0)**
|
|
[`# <#PIL.ImageChops.subtract-function>`_]
|
|
Subtract images ((image1 - image2) / scale + offset).
|
|
|
|
Subtracts two images, dividing the result by scale and adding the
|
|
offset. If omitted, scale defaults to 1.0, and offset to 0.0.
|
|
|
|
*image1*
|
|
*image1*
|
|
Returns:
|
|
|
|
**subtract\_modulo(image1, image2)**
|
|
[`# <#PIL.ImageChops.subtract_modulo-function>`_]
|
|
Subtract images without clipping ((image1 - image2) % MAX).
|
|
|
|
Subtracts two images, without clipping the result.
|
|
|
|
*image1*
|
|
*image1*
|
|
Returns:
|
|
|