A simple blurring filter.

In addition to OpenCV, we need numpy for arrays and the signal processing library from SciPy.

import cv2 as cv
import numpy as np
import scipy.signal as sig

We need a test image which we convert to greyscale. Here we use lenna.ppm, which you have to download and place in your working directory.

frame =cv.imread( "lenna.ppm" )
grey = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)

Other test images can be found at the same source.

We display the image to check that everything works:

cv.imshow("img",grey)
cv.waitKey(0)

Averaging pixels

1. Consider the following python code. What does it do?

(n,m) = grey.shape
new = np.zeros((n-6,m-6),dtype=np.uint8)

for i in range(n-6):
   for j in range(m-6):
      orig = grey[i:i+7,j:j+7]
      new[i,j] = round(sum(orig.flatten())/49)

2. Run the python code. What does the matrix new look like?
3. Display new as an image and compare it to the original grey. What is the visual effect?

What you should observe is a blurring effect.
Contours are smoothened by averaging a neighbourhood.

Using a signal processing library

What we did above is such a standard operation that we have an API therefore. We can define a \(7\times7\) averaging filter like this.

f7 = np.ones((7,7)) /  49

• What does this look like as a matrix?

To apply the filter to the image, we can use the standard convolution operator as follows:

g7 = sig.convolve2d(grey,f7).astype(np.uint8)

Note that we have to convert the result to integers explicitly, lest OpenCV will not interpret it as an image. The result can be displayed as

cv.imshow("filtered",g7)
cv.waitKey(0)

• Compare the two images. What does the filter do?
• Compare the filtered image to the image new from your manual averaging. Do they look different in any way?

The API has different methods to handle the boundaries.
We simply cropped a few pixel around the border, and thus new may be smaller than images filtered with the API.

We can do the same thing using the OpenCV library, like this.

c7 = cv.filter2D(grey,-1,f7)

The second argument (-1) specifies the colour depth of the output which should be the same as for the input.

f3 = np.ones((3,3)) /  9
f5 = np.ones((5,5)) /  25