To read an image from a jpg or a png file saved on your computer, Pillow's image module provides a read() function (Image.open). This function returns an image object, which contains information such as pixel type, image size, and image format. The following is an example of how to read an image. Note that the import statement is only run once at the beginning of the program:

>>> from PIL import Image
>>> img = Image.open("image.png")

To display the image on your screen, use the show() function as follows:

>>> img.show()

To write or save an image to a file on your computer, use the save() function associated to the image object. It takes in the absolute or relative file path to where you want to store the image:

>>> img.save("temp.png") # Example showing relative path
>>> img.save("/tmp/temp.png") # Example showing absolute path

Cropping an image means to extract a particular region of the image, which is smaller than the original image. This region in some books/references in called the Region of Interest (ROI). The concept of ROI is sometimes useful when you want to run your algorithm only on a particular part of the image and not the entire image. The image object has a crop() function that takes two coordinates--the upper-left corner and the bottom-right corner of the rectangle that you are interested in--and returns the cropped image:

>>> from PIL import Image
>>> dim = (100,100,400,400) #Dimensions of the ROI
>>> crop_img = img.crop(dim)
>>> crop_img.show()

The following images shows the crop function as used in the preceding code:

Figure 3: (Left) Original image and (right) a cropped region of the original image

Color spaces and channelsLike in the world of mathematics, we have different coordinate system: for example, a 2-D cartesian plane and 2-D polar coordinates. A point could be stored as (x, y) or (r, theta). Each coordinate system has a specific use case, which makes calculations easier. Similarly, in the world of image processing, we have different color spaces. An image can store its color values in the form of Red, Blue, Green (RGB) or it could as Cyan, Magenta, Yellow, Key(black) (CMYK). Some examples of other color spaces are HSV, HSL, CMY, and it goes on. Each value in the color space is called a color channel. For example, in the RGB color space we say that Red, Blue, and Green each are channels of the image. An image can be represented in many different modes (color spaces) such as RGB, CMYK, Grayscale, and YUV. The colors in the image that we see are derived by the mixture of the colors in each color channel of the color space. Let's look at some of the common color spaces in detail:

Figure 4 Example of a grayscale image

Figure 5: Illustration of HSV color space

Image source: By HSV_color_solid_cylinder.png: SharkDderivative work: SharkD Talk - HSV_color_solid_cylinder.png, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=9801673

At the beginning of the chapter, we said that an image is stored in the form of a 2D matrix. So how do we accommodate for the multiple channels in the image? Simple, we have multiple 2D matrices for each channel. A little exercise--how many matrices will a grayscale image have?

If you try to print the pixel value of a grayscale image, you will only get one value, but if you try to print the pixel value of an RGB image, then you will get three values; this shows that RGB has three channels, red, green, and blue and grayscale images have only one value.

In the following code snippet, we print the pixel values of an RGB image and a grayscale image:

>>> from PIL import Image
>>> img = Image.open("image.png")
>>> img.getpixel((100,100))
output
(150, 188, 233, 255)
>>> img.convert("L").getpixel((100,100))

This is the following output:

181

The following image shows the different color channels in an RGB image:

Figure 6: Red, green, and blue respectively

Image depth

Image depth or the color depth is the number of bits used to represent a color of a pixel. The image depth determines the range of colors an image can have. For example, if we have an image with a depth of 4 bits, then the pixel value will range from 0 to 15 (which is the biggest number we can store using 4 bits - 2^4 -1 = 15 ). Whereas if we use 8 bits, then the value will range from 0 to 255, providing a finer color spectrum. Another way of thinking about image depth is that the number of bits also determines the number of colors, which can be used in an image. For example, 1 bit implies two colors, 2 bits - four colors, and 8 bits - 256 colors.

Images can be converted from one color space to another using the convert function of the image module. To convert an image from RGB color space to grayscale color space, use the L mode. There are various other modes available such as 1 which is 1-bit pixel mode, P-8 bit pixel mode, RGB-3X8 bit pixel, and RGBA-4X8 bit pixel.

The following code snippet shows how to convert a color image to grayscale:

>>> from PIL import Image
>>> grayscale = img.convert("L")
>>> grayscale.show()

The following image shows the result of the preceding code (converting an image from RGB mode to grayscale mode):

Figure 7: Output after converting from RGB mode to grayscale

There are times when you need to perform different types of transformations to images such as resize, rotate, and flip. Pillow provides direct functions to perform these transformations, saving you from having to write the code from scratch:

        >>> from PIL import Image
        >>> resize_img = img.resize((200,200))
        >>> resize_img.show()

        >>> from PIL import Image
        >>> rotate_img = img.rotate(90)
        >>> rotate_img.show()

The result of the preceding code is shown in the following image:

Figure 8: Output after rotating the image by 90 degrees

Image enhancement involves operations such as changing the contrast, brightness, color balance, or sharpness of an image. Pillow provides an ImageEnhance module, which has functions that can help you perform the earlier mentioned operations.

We will begin with importing the ImageEnhance module using the following code:

>>> from PIL import ImageEnhance

After importing the library, let us see how to use the functions available in the library. First we will see how to change the brightness of an image:

        >>> enhancer = ImageEnhance.Brightness(img)
        >>> enhancer.enhance(2).show()

The enhance() function takes a float as an argument, which describes the factor which we want to change the brightness of the image. A factor value less than 1 will decrease the brightness and a factor value greater than 1 will increase the brightness of the image. A factor value equal to 1 will give the original image as output. The output of the enhance() function is an image with the changed brightness:

Figure 9: This image shows the increase in the brightness of the image - the image to the left is the original picture and the image to the right is the enhanced one

Next we will see how to change the contrast of an image.

        >>> enhancer = ImageEnhance.Contrast(img)
        >>> enhancer.enhance(2).show()

Again the enhance() function takes a float argument. A factor equal to 1 will give you the original image, while a factor value less than 1 will decrease the contrast and greater than 1 will increase the contrast:

Figure 10: This figure shows the change in the contrast of the image - the image to the left is the original picture and the image to the right is the enhanced image

Accessing pixels of an imageSometimes for performing tasks such as thresholding (which will be covered later in the book), we have to access the individual pixels in an image. Pillow provides a PixelAccess class with functions to manipulate image pixel values. getpixel() and putpixel() are some of the functions in the PixelAccess class:

        >>> img.getpixel((100,100))        

This is the following output:

        (150, 188, 233, 255)

        >>> img.putpixel((100,100),(20,230,145))
        >>> img.getpixel((100,100))

This is the following output:

        (20, 230, 145,255)