Pillow contains an ImageFilter module that contains pre-defined filters. The filter() method can be used to apply these filters onto an image instance.
```python
image.filter(filtertype)
```

Image Filters (Pillow)

The point() method in image instances can be used to transform each pixel through using a function that is applied to each pixel.
This generally follows the below syntax:
```python
output= image.point(lambda i: expression)
```

For example, the below will select all pixels and multiply them by 1.2:
```python
image.point(lambda i: i * 1.2)
```

The below will change the threshold of the image to a value of 120.
```python
threshold = 120  
image= image.point(lambda p: p > threshold and 255)
image.show()
```
Notice the "and 255" added to the expression used for the argument.. Python returns the last value examined and uses that for pixel manipulation. If p is less than the threshold value, it will not look at the "and 255" part of the expression and thus return 0. If p is greater than the threshold value, then it will look at the "and 255" portion and thus return 255.

Point Operations (Pillow)

Pillow contains the ImageEnhance module, which contains a number of classes that allow for image enhancing. In particular, these classes allow for changing the color balance, contrast, brightness, and sharpness of an image.
After creating an image enhancing object from an image, the enhance() function can be called on it with the enhancement factor as an argument. This will return the enhanced image. A factor of 1.0 returns the original image.
```python
image = enhanceobject.enhance(factor)
```

ImageEnhance (Pillow)

Pillow features multiple methods of adding effects or filters to images in order to modify them:
- Filters
- Point Operations
- Enhancement

Saint Olaf College

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)

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

Pillow Documentation

Similar to the open() function, Image objects have a save() function to write an image to disk.
```python
imageobject.save(filename, format)
```
This will write an image to disk of the specified name and format, The format argument allows for Pillow to save image to a specific format, but is not required. If no format argument is passed, the format of the image is automatically determined using the filename's extension.

Writing Images (Pillow)

Image objects have several properties to help identify them.
The format property identifies the source of an image, which can be none if the image didn't come from a file.
The size property is a tuple containing the width and height of the image in pixels.
The mode property identifies the type of color mode, such as RGB or CMYK.
```python
image.format
image.size
image.mode
```

Identifying Images (Pillow)

Cropping images requires a tuple containing the bounds of the pixels to crop. The tuple takes two sets of coordinates that define the boundaries.
```python
boundaries = (x1, y1, x2, y2)
region = image.crop(boundaries)
```

Cropping Images (Pillow)

Image objects have a transpose() function to flip or rotate an image.
```python
image.transpose(method)
```
The method parameter can be any of the following:
- PIL.Image.FLIP_LEFT_RIGHT
- PIL.Image.FLIP_TOP_BOTTOM
- PIL.Image.ROTATE_90
- PIL.Image.ROTATE_180
- PIL.Image.ROTATE_270

Transposing Images (Pillow)

Pillow supports multiple types of image transformations:
- Resize
- Rotate
- Color Transformation
- Advanced Transformations

Transforming Images (Pillow)

Pillow includes support for image sequences, otherwise known as animated formats, such as GIF. Animated formats can be opened using the usual open() function, which will automatically load the first frame of the animation.
The seek() function allows for loading the other frames of the animation. The argument of seek() is the number of frames to skip ahead.
```python
image = Image.open("animation.gif")
image.seek(frame)
```
The tell() function returns the current frame number.
```python
image = Image.open("animation.gif")
image.tell()
```

Image Sequences (Pillow)

Pillow contains a TarIO module that allows for reading an image contained in a tar archive. The TarIO() function takes a tar file path and the name of the desired image inside the tar as arguments. The returned object can then be passed into Pillow's open() function.
```python
fp = TarIO.TarIO(tarfile, file)
image = Image.open(fp)
```

Reading From a tar Archive (Pillow)

PIllow includes a draft() function for image objects that allows for custom image decoding for images that have been opened, but not yet loaded. The function takes two arguments, the desired color mode and image size, and will load the image to the specifications provided. This can speed up decoding if the arguments specify a simpler color mode or smaller image size.
```python
image = Image.open(filepath)
image.draft(mode, size)
```

Learn Before

Related

Learn After

Learn After

Related