Cara menggunakan python pillow detect color

The >>> cropped_img = img.crop((300, 150, 700, 1000)) >>> cropped_img.size (400, 850) >>> cropped_img.show() >>> low_res_img = cropped_img.resize( ... (cropped_img.width // 4, cropped_img.height // 4) ... ) >>> low_res_img.show() 5 Module and >>> cropped_img = img.crop((300, 150, 700, 1000)) >>> cropped_img.size (400, 850) >>> cropped_img.show() >>> low_res_img = cropped_img.resize( ... (cropped_img.width // 4, cropped_img.height // 4) ... ) >>> low_res_img.show() 5 Class in Pillow

The main class defined in Pillow is the

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

For the code in this section, you’ll need the image file named

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

Get Images: Click here to get access to the images that you’ll manipulate and process with Pillow.

You can place this image file in the project folder that you’re working in.

When exploring images with Pillow, it’s best to use an interactive REPL environment. You’ll start by opening the image that you just downloaded:

>>>

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

You might expect to import from Pillow instead of from PIL. You did install

>>> low_res_img = cropped_img.reduce(4)

>>> low_res_img = cropped_img.reduce(4)

>>> low_res_img = cropped_img.reduce(4)

You call the function to read the image from the file and to read the image into memory so that the file can now be closed. You use a

>>> low_res_img = cropped_img.reduce(4)

In this example, the object is a JPEG image-specific type that’s a subclass of the

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

>>> low_res_img = cropped_img.reduce(4)

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

>>>

>>> img.show()

The

>>> low_res_img = cropped_img.reduce(4)

On some systems, calling

>>> low_res_img = cropped_img.reduce(4)

You’ll need to be familiar with three key properties when dealing with images in the Python Pillow library. You can explore these using the

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

>>>

>>> img.format
'JPEG'

>>> img.size
(1920, 1273)

>>> img.mode
'RGB'

The format of an image shows what type of image you’re dealing with. In this case, the format of the image is

>>> cropped_img.save("cropped_image.jpg")
>>> low_res_img.save("low_resolution_cropped_image.png")

>>> cropped_img.save("cropped_image.jpg")
>>> low_res_img.save("low_resolution_cropped_image.png")

Often, you may need to crop and resize images. The

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

>>>

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

The argument to

>>> cropped_img.save("cropped_image.jpg")
>>> low_res_img.save("low_resolution_cropped_image.png")

The new image that

>>> cropped_img.save("cropped_image.jpg")
>>> low_res_img.save("low_resolution_cropped_image.png")

>>> converted_img = img.transpose(Image.FLIP_TOP_BOTTOM)
>>> converted_img.show()

In the code above, you also change the resolution of the cropped image using

>>> converted_img = img.transpose(Image.FLIP_TOP_BOTTOM)
>>> converted_img.show()

In the example above, you’re setting the new width and height to a quarter of their original values using the (

>>> converted_img = img.transpose(Image.FLIP_TOP_BOTTOM)
>>> converted_img.show()

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

>>> converted_img = img.transpose(Image.FLIP_TOP_BOTTOM)
>>> converted_img.show()

There are additional optional parameters that you can use with to control how the image is resampled. Alternatively, you can achieve similar scaling using :

>>>

>>> low_res_img = cropped_img.reduce(4)

The argument determines the factor by which you scale the image down. If you prefer to set a maximum size rather than a scaling factor, then you can use . The size of the thumbnail will be smaller than or equal to the size that you set.

Note: The

>>> rotated_img = img.rotate(45)
>>> rotated_img.show()

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

>>> cropped_img.save("cropped_image.jpg")
>>> low_res_img.save("low_resolution_cropped_image.png")

>>> converted_img = img.transpose(Image.FLIP_TOP_BOTTOM)
>>> converted_img.show()

>>> rotated_img = img.rotate(45)
>>> rotated_img.show()

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

Once you’re happy with your returned image, you can save any of the

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

>>>

>>> cropped_img.save("cropped_image.jpg")
>>> low_res_img.save("low_resolution_cropped_image.png")

Once you call the method, it creates the image files in your project folder. In this example, one of the images is a JPEG image and the other is a PNG image. The extension that you use as a filname automatically determines the file format, or you can specify the format as an additional optional argument.

Basic Image Manipulation

You can manipulate the image beyond cropping and resizing. Another common requirement is to rotate or flip the image. You can use the method for some transformations. Go ahead and carry on with the same REPL session that you started in the previous section:

>>>

>>> converted_img = img.transpose(Image.FLIP_TOP_BOTTOM)
>>> converted_img.show()

This code displays the following image:

There are seven options that you can pass as arguments to

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

1. $ python -m venv venv
   $ source venv/bin/activate
   (venv) $ python -m pip install Pillow
   

   03: Flips the image left to right, resulting in a mirror image

2. $ python -m venv venv
   $ source venv/bin/activate
   (venv) $ python -m pip install Pillow
   

   04: Flips the image top to bottom

3. $ python -m venv venv
   $ source venv/bin/activate
   (venv) $ python -m pip install Pillow
   

   05: Rotates the image by 90 degrees counterclockwise

4. $ python -m venv venv
   $ source venv/bin/activate
   (venv) $ python -m pip install Pillow
   

   06: Rotates the image by 180 degrees

5. $ python -m venv venv
   $ source venv/bin/activate
   (venv) $ python -m pip install Pillow
   

   07: Rotates the image by 270 degrees counterclockwise, which is the same as 90 degrees clockwise

6. $ python -m venv venv
   $ source venv/bin/activate
   (venv) $ python -m pip install Pillow
   

   08: Transposes the rows and columns using the top-left pixel as the origin, with the top-left pixel being the same in the transposed image as in the original image

7. $ python -m venv venv
   $ source venv/bin/activate
   (venv) $ python -m pip install Pillow
   

   09: Transposes the rows and columns using the bottom-left pixel as the origin, with the bottom-left pixel being the one that remains fixed between the original and modified versions

All the rotation options above define rotations in steps of 90 degrees. If you need to rotate an image by another angle, then you can use :

>>>

>>> rotated_img = img.rotate(45)
>>> rotated_img.show()

This method call rotates the image by 45 degrees counterclockwise, giving the following image:

The

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

>>>

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

This method returns a larger image that fully contains the rotated image:

You can customize the rotation further with . You can now change the size and orientation of an image. In the next section, you’ll learn about different types of images in the Python Pillow library.

Bands and Modes of an Image in the Python Pillow Library

An image is a two-dimensional array of pixels, where each pixel corresponds to a color. Each pixel can be represented by one or more values. For example, in an RGB image, each pixel is represented by three values corresponding to the red, green, and blue values for that pixel.

Therefore, the

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

RGBA images also include the alpha value, which contains information about the transparency for each pixel. An RGBA image has four bands, one for each of the colors and a fourth one containing the alpha values. Each band has the same dimensions as the image dimensions. Therefore, an RGBA image of size

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

The mode of an image describes what type of image you’re working with. Pillow supports most standard modes, including black-and-white (binary), grayscale, RGB, RGBA, and CMYK. You can see the full list of supported modes in the Pillow documentation on .

You can find out how many bands are in an

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

This image’s mode is also RGB. You can convert this image into other modes. This code uses the same REPL session that you started in the previous sections:

>>>

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

You call

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

The outputs from the calls to

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

You can separate an image into its bands using and combine separate bands back into an

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

>>>

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

The mode of the object that

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

Now, you can create three new RGB images showing the red, green, and blue channels separately using

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

>>>

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

The first argument in

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

The red band alone, stored in the variable

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

This method needs a function as an argument. The function that you use determines how each point transforms. In this case, you use a

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

When you merge the red band with green and blue bands containing zeros, you get an RGB image called

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

You also repeat a similar process to obtain

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

The red image contains a strong signal in the pixels that represent the strawberry, because these pixels are mostly red. The green and blue channels show these pixels as dark because they have small values. The exceptions are those pixels that represent the reflection of the light on the surface of the strawberry as these pixels are nearly white.

Creating the side-by-side displays shown in this tutorialShow/Hide

In this tutorial, when there are several images output in the code that need to be displayed next to one another to make comparisons easier, the images are displayed side by side rather than as separate images.

These side-by-side displays were created using Pillow itself. You can use the function

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

The first parameter in

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

The overall size of the display is calculated from the size of the images and the number of images used. You then create a new

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

The

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

The image in the main article showing the three color channels for the strawberry image was obtained by calling the

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

>>>

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

This function was used to generate all the displays that show more than one image in this tutorial.

Image Filters Using Convolution Kernels

One of the methods that’s used in image processing is image convolution using kernels. The aim of this tutorial is not to give a detailed explanation of image processing theory. If you’re interested in the science of image processing, one of the best resources that you can use is Digital Image Processing by Gonzalez and Woods.

In this section, you’ll learn the basics of how you can use convolution kernels to perform image processing. But what’s a convolution kernel? A kernel is a matrix:

You can consider a simple image to understand the process of convolution using kernels. The image has a size of

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

You can place the kernel anywhere on the image and use the location of the kernel’s central cell as a reference. The diagram below is a representation of the top-left portion of the image:

The elements in this diagram represent different aspects of the image and the kernel:

• The white squares represent pixels in the image that have a value of

  $ python -m venv venv
  $ source venv/bin/activate
  (venv) $ python -m pip install Pillow
  

  38.
• The red squares represent pixels in the image that have a value of

  $ python -m venv venv
  $ source venv/bin/activate
  (venv) $ python -m pip install Pillow
  

  56. These make up the dot in the image shown above.
• Each purple region represents the kernel. This kernel consists of a

  $ python -m venv venv
  $ source venv/bin/activate
  (venv) $ python -m pip install Pillow
  

  57 region, and each cell in the kernel has a value of

  $ python -m venv venv
  $ source venv/bin/activate
  (venv) $ python -m pip install Pillow
  

  58. The diagram shows the kernel in three different positions labeled 1, 2, and 3.

A new image can be created as a result of the convolution of the image with the kernel. You can understand the convolution process through the following steps:

1. Locate kernel: Consider one of the kernel locations and look at the image pixels covered by the kernel’s nine cells.
2. Multiply kernel and pixel values: Multiply the values in each of the kernel’s cells with the corresponding pixel values in the image. You’ll have nine values from the nine multiplications.
3. Sum results of multiplications: Add those nine values together. The result will be the value of the pixel in the new image that has the same coordinates as the kernel’s center pixel.
4. Repeat for all pixels: Repeat the process for every pixel in the image, moving the kernel each time so that the kernel’s central cell corresponds to a different image pixel each time.

You can see this process with the three kernel positions labeled 1, 2, and 3 in diagram above. Consider the kernel position labeled 1. The position of this kernel is

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

Therefore, all the multiplications from step 2 will be zero, and their addition will also be zero. The new image will have a value of zero at pixel

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

The scenario is different for the other kernel positions shown. Next, consider the kernel labeled 2, located at

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

The third kernel position illustrated above is at

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

The diagram and the discussion above only consider three kernel positions. The convolution process repeats this process for every possible kernel position in the image. This gives a value for each pixel position in the new image.

The result of the convolution is shown on the right in the following image, with the original image on the left:

The kernel that you used is a box blur kernel. The factor of

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

The Python Pillow library has several built-in kernels and functions that’ll perform the convolution described above. You don’t need to understand the math of filtering through convolution to use these filters, but it always helps to know what’s happening behind the scenes when using these tools.

The next sections will look at the kernels and image filtering capabilities available in the

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

Image Blurring, Sharpening, and Smoothing

You’ll return to using the image of the buildings that you used at the beginning of this tutorial. You can start a new REPL session for this section:

>>>

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

In addition to

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

You can blur the image using the predefined

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

>>>

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

The displayed image is a blurred version of the original one. You can zoom in to observe the difference in more detail using

>>> cropped_img.save("cropped_image.jpg")
>>> low_res_img.save("low_resolution_cropped_image.png")

>>> low_res_img = cropped_img.reduce(4)

>>>

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

The two cropped images show the difference between the two versions:

You can customize the type and amount of blurring that you need using or :

>>>

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

You can see the three blurred images below, shown in the same order as in the code above:

The

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

The blurred images show that the box blur filter with a radius of

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

You can also use the

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

What if you want to sharpen an image? In that case, you can use the

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

>>>

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

You’re comparing a cropped version of both images showing a small portion of the building. The sharpened image is on the right:

Perhaps instead of sharpening an image, you need to smooth it. You can achieve this by passing

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

>>>

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

Below, you can see the original image on the left and the smoothed image on the right:

You’ll see an application of the smooth filter in the next section, in which you’ll learn about more filters in the

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

Edge Detection, Edge Enhancement, and Embossing

When you look at an image, it’s relatively easy to determine the edges of objects within that image. It’s also possible for an algorithm to detect edges automatically using edge detection kernels.

The

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

>>>

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

The result is an image showing the edges from the original image:

This filter identifies the edges in the image. You can obtain a better outcome by applying the

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

>>>

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

You can see a comparison of the original grayscale image and the two edge detection results below. The version with smoothing before edge detection is shown at the bottom:

You can also enhance the edges of the original image with the

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

>>>

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

You used the smoothed version of the grayscale image to enhance the edges. A portion of the original grayscale image and the image with the edges enhanced are shown side by side below. The image with edge enhancement is on the right:

Another predefined filter in

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

>>>

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

You’re using the smoothed, grayscale version as a starting point for this filter. You can see the embossed image below, which shows a different effect using the edges in the image:

In this section, you’ve learned about several filters available in the

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

Image Thresholding

You’ll start by working on

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

First, you can crop the image to a smaller one to remove some of the background. You can start a new REPL session for this project:

>>>

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

The cropped image contains the cat and some of the background that’s too close to the cat for you to crop it:

Each pixel in a color image is represented digitally by three numbers corresponding to the red, green, and blue values of that pixel. Thresholding is the process of converting all the pixels to either the maximum or minimum value depending on whether they’re higher or lower than a certain number. It’s easier to do this on a grayscale image:

>>>

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

You achieve thresholding by calling

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

The figure below shows the grayscale image and the result from the thresholding process:

In this example, all the points in the grayscale image that had a pixel value greater than

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

Thresholding can be used to segment images when the object to segment is distinct from the background. You can achieve better results with versions of the original image that have higher contrast. In this example, you can achieve higher contrast by thresholding the blue channel of the original image rather than the grayscale image, because the dominant colors in the background are brown and green colors, which have a weak blue component.

You can extract the red, green, and blue channels from the color image as you did earlier:

>>>

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

The red, green, and blue channels are shown below, from left to right. All three are displayed as grayscale images:

The blue channel has a higher contrast between the pixels representing the cat and those representing the background. You can use the blue channel image to threshold:

>>>

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

You use a threshold value of

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

Note: When dealing with certain image formats, such as JPEG, that rely on lossy compression, the images may vary slightly depending on which JPEG decoders you’re using. Different operating systems often come with different default JPEG decoders. Therefore, the results that you get when processing images may vary depending on the operating system and JPEG decoder that you’re using.

You may need to slightly adjust the threshold value if your results do not match the ones shown in this tutorial.

The result of thresholding is the following:

You can identify the cat in this black-and-white image. However, you’d like to have an image in which all the pixels that correspond to the cat are white and all other pixels are black. In this image, you still have black regions in the area which corresponds to the cat, such as where the eyes, nose and mouth are, and you also still have white pixels elsewhere in the image.

You can use the image processing techniques called erosion and dilation to create a better mask that represents the cat. You’ll learn about these two techniques in the next section.

Erosion and Dilation

You can look at the image file called

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

The left-hand side of this binary image shows a white dot on a black background, while the right-hand side shows a black hole in a solid white section.

Erosion is the process of removing white pixels from the boundaries in an image. You can achieve this in a binary image by using

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

You can see the effect of erosion by applying

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>>

>>> img.show()

You’ve applied the filter three times using a

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

The dot has shrunk but the hole has grown as a result of erosion.

Dilation is the opposite process to erosion. White pixels are added to the boundaries in a binary image. You can achieve dilation by using

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

You can apply dilation to the same image containing a dot and a hole, which you can open and load again:

>>>

>>> img.show()

The dot has now grown bigger, and the hole has shrunk:

You can use erosion and dilation together to fill in holes and remove small objects from a binary image. Using the image with a dot and hole, you can perform ten erosion cycles to remove the dot, followed by ten dilation cycles to restore the hole to its original size:

>>>

>>> img.show()

You perform ten erosion cycles with the first

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

The dot has disappeared, and the hole is larger than it was in the original image. The second

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

However, the dot is no longer present in the image. The erosions and dilations have modified the image to keep the hole but remove the dot. The number of erosions and dilations needed depends on the image and what you want to achieve. Often, you’ll need to find the right combination through trial and error.

You can define functions to perform several cycles of erosion and dilation:

>>>

>>> img.show()

These functions make it easier to experiment with erosion and dilation for an image. You’ll use these functions in the next section as you continue working on placing the cat into the monastery.

Image Segmentation Using Thresholding

You can use a sequence of erosions and dilations on the threshold image that you obtained earlier to remove parts of the mask that don’t represent the cat and to fill in any gaps in the region containing the cat. Once you’ve experimented with erosion and dilation, you’ll be able to use educated guesses in a trial-and-error process to find the best combination of erosions and dilations to achieve the ideal mask.

Starting with the image

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>>

>>> img.show()

The eroded threshold image no longer contains white pixels representing the background of the image:

However, the remaining mask is smaller than the overall outline of the cat and has holes and gaps within it. You can perform dilations to fill the gaps:

>>>

>>> img.show()

The fifty-eight cycles of dilation filled all the holes in the mask to give the following image:

However, this mask is too big. You can therefore finish the process with a series of erosions:

>>>

>>> img.show()

The result is a mask that you can use to segment the image of the cat:

You can avoid the sharp edges of a binary mask by blurring this mask. You’ll have to convert it from a binary image into a grayscale image first:

>>>

>>> img.show()

The

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

The mask now looks like a cat! Now you’re ready to extract the image of the cat from its background:

>>>

>>> img.show()

First, you create a blank image with the same size as

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

You’ve segmented the image of the cat and extracted the cat from its background.

Superimposition of Images Using >>> from PIL import Image >>> filename = "buildings.jpg" >>> with Image.open(filename) as img: ... img.load() ... >>> type(img) <class 'PIL.JpegImagePlugin.JpegImageFile'> >>> isinstance(img, Image.Image) True 36

You can go a step further and paste the segmented image of the cat into the image of the monastery courtyard from the image repository for this tutorial:

>>>

>>> img.show()

You’ve used to paste an image onto another one. This method can be used with three arguments:

• The first argument is the image that you want to paste in. You’re resizing the image to one-fifth of its size using the integer division operator (

  >>> converted_img = img.transpose(Image.FLIP_TOP_BOTTOM)
  >>> converted_img.show()
  

  5).
• The second argument is the location in the main image where you want to paste the second picture. The tuple includes the coordinates within the main image where you want to place the top-left corner of the image that you’re pasting in.
• The third argument provides the mask that you wish to use if you don’t want to paste the entire image.

You’ve used the mask that you obtained from the process of thresholding, erosion, and dilation to paste the cat without its background. The output is the following image:

You’ve segmented the cat from one image and placed it into another image to show the cat sitting quietly in the monastery courtyard rather than in the field where it was sitting in the original image.

Creation of A Watermark

Your final task in this example is to add the Real Python logo as a watermark to the image. You can get the image file with the Real Python logo from the repository accompanying this tutorial:

Get Images: Click here to get access to the images that you’ll manipulate and process with Pillow.

You should continue working in the same REPL session:

>>>

>>> img.format
'JPEG'

>>> img.size
(1920, 1273)

>>> img.mode
'RGB'

This is the full-size logo in color:

You can change the image to grayscale and threshold it using

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

>>>

>>> img.format
'JPEG'

>>> img.size
(1920, 1273)

>>> img.mode
'RGB'

The output shows the contour from the Real Python logo. The contour is ideal for using as a watermark on your image:

To use this as a watermark, you’ll need to reverse the colors so that the background is black and only the outline that you want to keep is white. You can achieve this using

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

>>>

>>> img.format
'JPEG'

>>> img.size
(1920, 1273)

>>> img.mode
'RGB'

You’ve converted the pixels that had a value of

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

Your final step is to paste this outline onto the image of the cat sitting in the monastery courtyard. You can use

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>>

>>> img.format
'JPEG'

>>> img.size
(1920, 1273)

>>> img.mode
'RGB'

The first argument in

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

The image now includes a Real Python watermark:

The watermark has a rectangular outline, which is a result of the contour filter that you used earlier. If you prefer to remove this outline, you can crop the image using

>>> cropped_img.save("cropped_image.jpg")
>>> low_res_img.save("low_resolution_cropped_image.png")

Using NumPy to Subtract Images From Each Other

See if you can spot the differences between the following two images:

This isn’t a hard one! However, you decide to cheat and write a Python program to solve the puzzle for you. You can download the image files

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

Get Images: Click here to get access to the images that you’ll manipulate and process with Pillow.

Your first step is to read the images using Pillow and convert them to NumPy arrays:

>>>

>>> img.format
'JPEG'

>>> img.size
(1920, 1273)

>>> img.mode
'RGB'

Since

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>>

>>> img.format
'JPEG'

>>> img.size
(1920, 1273)

>>> img.mode
'RGB'

When you subtract an array from another one of the same size, the result is another array with the same shape as the original arrays. You can convert this array into an image using

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>>

>>> img.format
'JPEG'

>>> img.size
(1920, 1273)

>>> img.mode
'RGB'

The result of subtracting one NumPy array from another and converting into a Pillow

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

The difference image only shows three regions from the original image. These regions highlight the differences between the two images. You can also see some noise surrounding the cloud and the fence, which is due to small changes in the original JPEG compression in the region surrounding these items.

Using NumPy to Create Images

You can go further and create images from scratch using NumPy and Pillow. You can start by creating a grayscale image. In this example, you’ll create a simple image containing a square, but you can create more elaborate images in the same way:

>>>

>>> img.format
'JPEG'

>>> img.size
(1920, 1273)

>>> img.mode
'RGB'

You create an array of size

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

You can NumPy arrays using both rows and columns. In this example, the first slice,

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

You can use

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

You’ve created a grayscale image containing a square. The mode of the image is inferred automatically when you use

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>>

>>> img.format
'JPEG'

>>> img.size
(1920, 1273)

>>> img.mode
'RGB'

You can also go further and create a color image. You can repeat the process above to create three images, one corresponding to the red channel, another to the green, and a final one corresponding to the blue channel:

>>>

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

You create an

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>>

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

The first argument in

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

You’ve combined the separate bands into an RGB color image. In the next section, you’ll go a step further and create a GIF animation using NumPy and Pillow.

Creating Animations

In the previous section, you created a color image containing three overlapping squares of different colors. In this section, you’ll create an animation showing those three squares merging into a single white square. You’ll create several versions of the images containing three squares, and the location of the squares will vary slightly between successive images:

>>>

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

You create an empty list called

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

The red square starts in a position displaced to the top-left of the center. In each successive frame, the red square moves closer to the center until it reaches the center in the final iteration of the loop. The blue square is initially shifted toward the bottom-right then moves towards the center with each iteration.

Note that in this example, you’re iterating over

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

You learned earlier that you can save an

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>>

>>> cropped_img = img.crop((300, 150, 700, 1000))
>>> cropped_img.size
(400, 850)

>>> cropped_img.show()

>>> low_res_img = cropped_img.resize(
...     (cropped_img.width // 4, cropped_img.height // 4)
... )
>>> low_res_img.show()

The first argument in

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

• >>> from PIL import Image
  >>> filename = "buildings.jpg"
  >>> with Image.open(filename) as img:
  ...     img.load()
  ...
  
  >>> type(img)
  <class 'PIL.JpegImagePlugin.JpegImageFile'>
  
  >>> isinstance(img, Image.Image)
  True
  

  81 ensures that all the images in the sequence are saved, and not just the first one.

• >>> from PIL import Image
  >>> filename = "buildings.jpg"
  >>> with Image.open(filename) as img:
  ...     img.load()
  ...
  
  >>> type(img)
  <class 'PIL.JpegImagePlugin.JpegImageFile'>
  
  >>> isinstance(img, Image.Image)
  True
  

  82 allows you to append the remaining images in the sequence to the GIF file.

This code saves

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

>>> from PIL import Image
>>> filename = "buildings.jpg"
>>> with Image.open(filename) as img:
...     img.load()
...

>>> type(img)
<class 'PIL.JpegImagePlugin.JpegImageFile'>

>>> isinstance(img, Image.Image)
True

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install Pillow

The three squares with different colors merge into a single white square. Can you create your own animation using different shapes and different colors?