The below example adds the channel data values of two images together. It divides the resulting value by 1.0, as decided by the value for argument scale. Lastly, it adds a value of 2, as decided by the vlaue of the offset argument.
```python
# Importing Image and ImageChops module from PIL package 
from PIL import Image, ImageChops
  
# creating a image1 object
im1 = Image.open(r"C:\Users\sadow984\Desktop\a2.PNG")
  
# creating a image2 object
im2 = Image.open(r"C:\Users\sadow984\Desktop\x5.PNG")
  
# applying add method
im3 = ImageChops.add(im1, im2, scale = 1.0, offset = 2)
  
im3.show()
```

ImageChops Example (Pillow)

The ImageChops class contains functions for channel operations, known as chops, for images. Chops involve arithmetical operations that involve the channels of an image and take one or two images as arguments. Most of these functions only support 8-bit image color modes.
ImageChops has functions that supports the following chops, those familiar with photo editing may recognize these terms:
- Add
- Blend
- Composite
- Constant
- Darker
- Difference
- Duplicate
- Invert
- Lighter
- Logical AND
- Logical OR
- Logical XOR
- Multiply
- Soft Light
- Hard Light
- Overlay
- Offset
- Screen
- Subtract

Saint Olaf College

Pillow is a fork of the discontinued Python Imaging Library (PIL) and is the most popular package for image processing. It allows for the creation, editing, and exporting of images, as well as including support for a large number of image file formats. Pillow is not included with a Python installation and must be installed with a package manager such as pip.

Image Processing with Pillow

https://pillow.readthedocs.io/en/stable/index.html

Pillow Documentation

The most important class in Pillow is the Image class. Instances of the Image class can be created by loading images from files, processing preexisting images, or by making images from scratch.
The most common approach is to load an image from a file using the open() function:
```python
Image.open(filepath)
```
The open() function will return an Image object if successful. Otherwise, an OSError exception is raised if the file can't be found.

Image Class (Pillow)

Color modes are strings that refer to the the type and depth of pixels in an image. They are a property of images and they are also used in function arguments. Color modes are measured in bits, referring to how much data can be stored in a pixel. Color modes that support a larger number of bits can store more data, and thus more color, in a pixel.
There are many color modes in Pillow, but the most common ones are the following:
- "1" - 1-bit pixels. Black-and-white only.
- "L" - 8-bit pixels. Grayscale.
- "RGB" - 3x8-bit pixels. Separates a pixel into primary colors. Full color.
- "RGBA" - 4x8-bit pixels. RGB with transparency support.
- "CMYK" - 4x8-bit pixels. Alternate way to separate a pixel into primary colors.

Color Modes

Images consist of one or more bands of data. Pillow lets an image contain multiple bands if said bands have the same resolution and bit depth. The types of bands seen in an image depend on the type of image. For example, a PNG image will have bands for red, blue, green, and alpha (transparency). A pixel in an image will have a value in each band assigned to it.

Bands (Pillow)

The ImageDraw class allows for generating simple 2D graphics. It can be used for creating new images, or annotating/retouching existing images.
The central function of an ImageDraw object is the ImageDraw.Draw() function. This creates an object that can be used for drawing inside an image given through an argument.
```python
d = ImageDraw.Draw(image)
```

ImageDraw Class (Pillow)

ImageChops Class (Pillow)

ImageOps contains a number of image processing operations. This is similar to ImageChops, but isn't necessarily limited to channel operations. Like ImageChops, most of these operations only work on images of 8-bit color modes.
These operations include:
- Auto Contrast
- Colorize
- Contain
- Pad
- Crop
- Scale
- Deform
- Equalize
- Expand
- Fit
- Flip
- Grayscale
- Invert
- Mirror
- Posterize
- Solarize

ImageOps Class (Pillow)

The ImageGrab class allows for copying the contents of the screen or the computer's clipboard, if an image is in the clipboard.
There are only two functions, ImageGrab.grab() and ImageGrab.grabcllipboard().
ImageGrab.grab() takes a snapshot of the screen when given the bounding box to snapshot, and returns and image object.
```python
image = ImageGrab.grab(region)
```
ImageGrab.grabclipboard() takes the image in the system's clipboard and returns an image object.
```python
image = ImageGrab.grabclipboard()
```

ImageGrab Class (Pillow)

The ImageMath Class provides an eval() function that can be used for davanced image processing. The eval() function takes an expression in regular Python syntax, and an environment, which is a dictionary mapping names to images.
```python
output = ImageMath.eval(expression, envionment)
```
The expression also supports a number of built-in functions specific to image processing:
- abs(image) - Absolute value of an image
- convert(image, mode) - Convert an image to a specified color mode
- float(image) - Convert an image to a float
- int(image) - Convert an image to a n int
- max(image1, image2) - Maximum value of an image
- min(image1, image2) - Minimum value of an image

ImageMath Class (Pillow)

The ImagePath class stores and manipulates 2-dimensional vectors that correspond to image coordinates. A path object can either be a sequence of 2-tuples or a sequence numeric values. Path objects can be passed to methods in the ImageDraw class.
The ImagePath class also contains a number of functions to modify the path itself, such as the comoact() function to remove points that are close together, or the tolist() function to convert the path to a python list.

ImagePath Class (Pillow)

The ImageShow class is used for displaying images to the system's screen. Images are displayed through objects called viewers. There are a number of default viewers in Pillow, so creating new viewers is not necessary for showing an image.
Showing an image requires the show() function.
```python
ImageShow.show(image)
```
show() returns true if a suitable viewer was found.

Learn Before

Related

Learn After