Image instances have a resize() function which accepts a tuple that contains the desired width and height. Optionally, a resample filter to be applied to the image and a 4-tuple bounding box that provides a specific region of the image to scale can be passed as arguments.
```python
size = (newwidth, newheight)
image.resize(size, resample=None, box=None)
```

Resizing Images (Pillow)

Image instances have a rotate() function that allows for rotation. The argument of the function is the amount of degrees to rotate the image counter-clockwise.
```python
image.rotate(angle)
```

Rotating Images (Pillow)

Pillow allows for converting images to different color modes.
```
image.convert(mode=None, matrix=None, dither=None, palette=0, colors=256)
```
mode - The desired color mode
matrix - Optional conversion matrix
dither - Optional dithering method. Can be either NONE or FLOYDSTEINBERG
palette - Palette to use. Can be either WEB or ADAPTIVE. WEB involves a set number of colors while ADAPTIVE uses the number of colors set by the colors argument
colors - Number of colors to use if palette is ADAPTIVE


Color Transformations (Pillow)

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

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)

Transforming Images (Pillow)

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

Image Effects (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