Pixelating a Square Image to 256 Big Pixels Using Python’s Matplotlib

by

💡 Problem Formulation: In digital image processing, pixelation is a visual effect where an image is blurred by reducing its resolution. This article addresses how to pixelate a square image to create an abstract version consisting of 256 (16×16) larger pixels using Python’s Matplotlib library. If you start with a high-resolution photo, the desired output is a retro-style, 16×16 grid representation of the original image.

Method 1: Using Matplotlib’s Imshow with Resizing

An effective approach to pixelate an image involves resizing the original image to the desired number of big pixels (16×16) and then enlarging it back to its original size. We utilize Matplotlib’s imshow function to display the image, combined with a resizing process using the Scikit-image library.

Here’s an example:

import matplotlib.pyplot as plt
from skimage import data, transform

# Loading an example image from scikit-image
image = data.astronaut()
# Resizing to 16x16 pixels
image_resized = transform.resize(image, (16, 16), anti_aliasing=True)
# Displaying it back at a larger size
plt.imshow(image_resized, interpolation='nearest')
plt.show()

The output of this code is a pixelated version of the astronaut image with each pixel enlarged to fill the original image dimensions.

This snippet first loads a sample image, then utilizes the transform.resize method from Scikit-image to resize the image to the desired 16×16 resolution, and finally uses Matplotlib’s imshow() function with interpolation='nearest' to enlarge and display the pixelated image.

Method 2: Directly Manipulating Pixel Data with Numpy

You can also directly manipulate the pixel data using Numpy by applying a block average to the image. This method involves dividing the image into 256 blocks and calculating the average color of the pixels in each block.

Here’s an example:

import matplotlib.pyplot as plt
import numpy as np
from PIL import Image

# Open an image file
image = Image.open('example.jpg').convert('RGB')
image_array = np.array(image)

# Pixelate by averaging blocks of pixels
block_size = 16
(h, w) = image_array.shape[:2]
image_array = image_array[:h // block_size * block_size, :w // block_size * block_size]
image_pixelated = image_array.reshape(h // block_size, block_size, w // block_size, block_size, 3).mean(axis=(1, 3))

# Show the pixelated image
plt.imshow(image_pixelated.astype('uint8'), interpolation='nearest')
plt.axis('off')  # Turn off the axis
plt.show()

The output is a 16×16 grid that represents the pixelated version of the input image.

This code converts an image into a Numpy array, segments it into non-overlapping 16×16 blocks, calculates the mean color value for each block, and then creates a new image with these mean color values, effectively pixelating the image.

Method 3: Adaptive Image Rescaling with OpenCV

With the OpenCV library, which is optimized for image processing, you can efficiently resize images using different scaling algorithms to achieve pixelation.

Here’s an example:

import cv2
import matplotlib.pyplot as plt

# Load the image in color
image = cv2.imread('example.jpg')
# Resize down to 16x16
smaller_image = cv2.resize(image, (16, 16), interpolation=cv2.INTER_AREA)
# Scale back up to original size
pixelated_image = cv2.resize(smaller_image, image.shape[:2][::-1], interpolation=cv2.INTER_NEAREST)

# Display the resized image
plt.imshow(cv2.cvtColor(pixelated_image, cv2.COLOR_BGR2RGB))
plt.show()

The output is a pixelated image with large, visible blocks, each corresponding to the averaged color of the original pixels.

This code uses OpenCV to reduce the image’s resolution down to 16×16 and then enlarges it, preserving the large blocky pixels. The INTER_AREA interpolation method scales down the image by computing pixel area relation, while INTER_NEAREST is used to avoid introducing new colors when scaling the pixelated image back up.

Method 4: Custom Pixelate Function with Python

You can build your own pixelate function in Python by iterating over each block of pixels, averaging out the colors, and reconstructing the pixelated image manually without relying on specific image processing libraries.

Here’s an example:

from PIL import Image
import matplotlib.pyplot as plt
import numpy as np

def pixelate(input_image, pixel_size):
    image = Image.open(input_image)
    image = image.resize(
        (image.size[0] // pixel_size, image.size[1] // pixel_size),
        Image.NEAREST
    )
    image = image.resize(
        (image.size[0] * pixel_size, image.size[1] * pixel_size),
        Image.NEAREST
    )
    return image

pixelated_image = pixelate('example.jpg', 32)
plt.imshow(np.array(pixelated_image))
plt.axis('off')
plt.show()

The output is a pixelated version of the original image with distinct 32×32 block size pixels.

This code defines a custom function pixelate which takes an image path and a pixel size as input. The image is first downsized to the resolution given by the pixel size and then upsized back to its original dimensions, using the nearest neighbor interpolation for both operations to maintain the pixelated effect.

Bonus One-Liner Method 5: Simplified Pixelation with PIL

The Python Imaging Library (PIL) can also be used for quick image transformations. It offers a simple one-liner for resizing an image twice to pixelate it.

Here’s an example:

from PIL import Image
import matplotlib.pyplot as plt

pixelated_image = Image.open('example.jpg').resize((16, 16), Image.NEAREST).resize((256, 256), Image.NEAREST)
plt.imshow(pixelated_image)
plt.axis('off')
plt.show()

The output is the pixelated image that has been resized down and then back up, applying the nearest neighbor interpolation.

This concise method takes advantage of the Image.resize method from PIL to shrink and then expand the image, using the NEAREST filter to keep the pixelation effect.

Summary/Discussion

  • Method 1: Resizing with Scikit-image and Matplotlib. Strengths: Uses well-established scientific libraries. Weaknesses: Requires installing scikit-image.
  • Method 2: Numpy Block Averaging. Strengths: Offers a low-level, numpy-based approach. Weaknesses: A bit more complex with manual numpy manipulations.
  • Method 3: Rescaling with OpenCV. Strengths: Fast and efficient, suited for larger images. Weaknesses: OpenCV installation may be overkill if only pixelation is needed.
  • Method 4: Custom Python Function Using PIL. Strengths: Flexibility in resizing methods and pixel sizes. Weaknesses: Less performance-optimized for large images.
  • Bonus Method 5: PIL One-Liner. Strengths: Extremely simple and straightforward. Weaknesses: Limited resizing options and less control.