Scikit Image − Image Filters

In the context of image processing, Image filters are techniques or mathematical operations applied to an image to modify, enhance, or extract specific information from it. Filters play a crucial role in manipulating and improving the visual characteristics of images. 

Image filters are operate on a pixel-by-pixel basis, applying mathematical operations to pixels within a defined neighborhood. This neighborhood is often determined by structuring elements or footprints. These filters are used for a wide range of tasks, including smoothing, sharpening, and enhancing specific image features, and they can be implemented through techniques like convolution and frequency domain manipulation.

The Scikit Image library provides mainly two modules to work with image filters, including filters module and filters.rank module. 

Basic filters in Scikit Image

Within Scikit Image, the "filters" submodule offers a variety of functions for applying filters to images. Specifically, the basic filters such as Minimum, Maximum, Median, and others are available within the filters.rank submodule. 

• Minimum Filter: Applied using skimage.filters.rank.minimum() function, this filter returns the local minimum of an image.
• Maximu Filter: This filter can be applied using the skimage.filters.rank.maximum() function, and it returns the local maximum of the input image.
• Median Filter: It can be employed via skimage.filters.rank.median() function, this filter calculates the local median of an image.
• Mean Filter: The skimage.filters.rank.mean() function can be used to calculate the local mean filter of an image.

Example

Here is an example demonstrating how to apply basic filters such as "minimum", "maximum", "median", and "mean" filters to an input image −

import numpy as np 
import matplotlib.pyplot as plt 
from skimage.filters.rank import minimum, maximum, mean, median 
from skimage import io 
 
# Load the input image 
input_image = io.imread('Images/Blue.jpg', as_gray=True)
 
# Define the structuring element (kernel)
footprint = np.ones((5, 5))
 
# Apply minimum filter 
output_min = minimum(input_image, footprint=footprint)
 
# Apply maximum filter 
output_max = maximum(input_image, footprint=footprint)
 
# Apply median filter 
output_med = median(input_image, footprint=footprint)
 
# Apply mean filter 
output_mean = mean(input_image, footprint=footprint)
 
# Visualize the input and filtered images 
fig, axes = plt.subplots(1, 5, figsize=(10, 5))
 
axes[0].imshow(input_image, cmap='gray')
axes[0].set_title("Input Image")
axes[0].axis('off')
 
axes[1].set_title("Minimum Filter")
axes[1].imshow(output_min, cmap='gray')
axes[1].axis('off')
 
axes[2].imshow(output_max, cmap='gray')
axes[2].set_title("Maximum Filter")
axes[2].axis('off')
 
axes[3].imshow(output_med, cmap='gray')
axes[3].set_title("Median Filter")
axes[3].axis('off')
 
axes[4].imshow(output_mean, cmap='gray')
axes[4].set_title("Mean Filter")
axes[4].axis('off')
 
plt.tight_layout()
plt.show()

Output

Convolutional filters

In image filtering convolution is a neighborhood operation, where each output pixel is a weighted sum of neighboring input pixels using a convolution kernel. A very commonly used convolutional filter is the Gaussian filter.

Gaussian filter

The Gaussian filter is a classic image filter that is similar to the mean filter but assigns varying weights to neighborhood values. Pixels closer to the center are weighted more heavily than those farther away. The Gaussian filter's standard deviation, denoted as sigma, determines the size of the neighborhood.

This filter is generally used for blurring images while preserving their essential features. To apply the Gaussian filter, skimage.filters.gaussian() is used.

Example

Here's a simple example of how to apply a Gaussian filter using the filters.gaussian() function −

import numpy as np 
import matplotlib.pyplot as plt 
from skimage import io, filters 
 
# Load the input image 
image = io.imread('Images/Blue.jpg', as_gray=True)
 
# Apply the Gaussian filter with a specified sigma 
sigma = 2 
image_gaussian = filters.gaussian(image, sigma)
 
# Display the original and filtered images 
fig, axes = plt.subplots(1, 2, figsize=(10, 10))
ax1, ax2 = axes.ravel()
 
ax1.imshow(image, cmap='gray')
ax1.set_title('Original Image')
ax1.axis('off')
 
ax2.imshow(image_gaussian, cmap='gray')
ax2.set_title('Gaussian Filtered Image (sigma={})'.format(sigma))
ax2.axis('off')
plt.tight_layout()
plt.show()

Output