The ImageSequence.Iterator() function takes an image sequence as an argument and returns an iterator object that can be used to loop over all frames in the image sequence. The [] operator can also be used to access a specific frame number.
```python
iterator = ImageSequence.Iterator(image)
frame = iterator[index]
```

Image Sequence Iteration (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()
```

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 features multiple methods of adding effects or filters to images in order to modify them:
- Filters
- Point Operations
- Enhancement

Image Effects (Pillow)

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