In the previous blog, we briefly introduced Low Pass filters. In this blog, let’s discuss them in detail. Low Pass filters (also known as Smoothing or averaging filter) are mainly used for blurring and noise reduction. Both of these can serve as a useful pre-processing step in many applications.
In general, the Low Pass filters block high-frequency parts of an image. Because noise typically consists of sharp transitions in intensity values, this results in noise reduction. But one downside is that edges are also blurred (Later we will see the blurring techniques which don’t blur the edges).
Now, let’s discuss some of the most commonly used blurring techniques
1. Averaging
In this, each pixel value in an image is replaced by the weighted average of the neighborhood (defined by the filter mask) intensity values. The most commonly used filter is the Box filter which has equal weights. A 3×3 normalized box filter is shown below
It’s a good practice to normalize the filter. This is to make sure that the image doesn’t get brighter or darker. You can also use an unnormalized box filter.
OpenCV provides two inbuilt functions for averaging namely:
- cv2.blur() that blurs an image using only the normalized box filter and
- cv2.boxFilter() which is more general, having the option of using either normalized or unnormalized box filter. Just pass an argument normalize=False to the function
The basic syntax of both the functions are shown below
|
1 2 3 4 5 |
cv2.blur(src, ksize [, anchor[, borderType]]]) cv2.boxFilter(src, ddepth, ksize[, anchor[, normalize[, borderType]]]]) # src - input image # ksize - Kernel size # ddepth - the output image depth (Pass -1 to use that of input) |
Let’s take an example
|
1 2 3 4 5 6 7 |
import cv2 import numpy as np img = cv2.imread('D:/downloads/opencv.png') blur = cv2.boxFilter(img,-1,(5,5), normalize = True) # or use cv2.blur() as shown below # blur = cv2.blur(img,(5,5)) |
The output looks like this
2. Median Blurring
This is a non-linear filtering technique. As clear from the name, this takes a median of all the pixels under the kernel area and replaces the central element with this median value. This is quite effective in reducing a certain type of noise (like salt-and-pepper noise) with considerably less edge blurring as compared to other linear filters of the same size.
Because we are taking a median, the output image will have no new pixel values other than that in the input image.
Note: For an even number of entries, there is more than one possible median, thus kernel size must be odd and greater than 1 for simplicity.
OpenCV provides an inbuilt function for this
|
1 |
cv2.medianBlur(input_image, kernel_size) |
Let’s take an example
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
import cv2 import numpy as np from skimage.util import random_noise # Load an image im_arr = cv2.imread("D:/downloads/opencv_logo.PNG") # Add salt and pepper noise to the image noise_img = random_noise(im_arr, mode="s&p",amount=0.3) noise_img = np.array(255*noise_img, dtype = 'uint8') # Apply median filter median = cv2.medianBlur(noise_img,5) # Display the image cv2.imshow('blur',noise_img) cv2.imshow('blur1',median) cv2.waitKey(0) cv2.destroyAllWindows() |
The output looks like this
See how effectively median blurring is able to remove salt and pepper noise and still able to preserve the edges.
In the next blog, we will discuss Gaussian Blurring, another blurring technique which is widely used in computer graphics and is computationally very efficient. Hope you enjoy reading.
If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.