Image Processing in Python

Tanmoy Dasgupta

thetdg@live.com | Assistant Professor | Department of Electrical Engineering | Techno India University, Kolkata

I colud not get the sepll checekr wroikng. So this ntoebook mgiht cnotain erorrs / toyps.

This tutorial is supposed to be an introduction to the different scientific packages in python that can be utilized to perform different tasks related to image processing. I have inherently assumed that the reader already has good exposure on core Python and some exposure on Numpy, Scipy and Matplotlib. It is also assumed that the reader knows how to start IPython Notebooks.

This notebook contains materails that are useful and new. However, things that are useful are not new and the things that are new are not always useful. Feel free to improve it and send me suggestions.

Packages You Need

Python 2.7 or Python 3.4

Choose Python 2.7 is you want to settle with the past. Choose 3.4 if you want to go with the future.

NumPy

NumPy is the fundamental package for scientific computing with Python. It contains among other things:

1. a powerful N-dimensional array object
2. sophisticated (broadcasting) functions
3. tools for integrating C/C++ and Fortran code
4. useful linear algebra, Fourier transform, and random number capabilities

SciPy

The SciPy library is one of the core packages that make up the SciPy stack. It provides many user-friendly and efficient numerical routines such as routines for numerical integration and optimization.

Matplotlib

Matplotlib is a python 2D and 3D plotting library which produces publication quality figures in a variety of hardcopy formats and interactive environments across platforms. matplotlib can be used in python scripts, the python and ipython shell (ala MATLAB® or Mathematica®), web application servers, and different graphical user interface toolkits.

IPython

IPython provides a rich architecture for interactive computing with:

1. Powerful interactive shells (terminal and Qt-based).
2. A browser-based notebook with support for code, rich text, mathematical expressions, inline plots and other rich media.
3. Support for interactive data visualization and use of GUI toolkits.
4. Flexible, embeddable interpreters to load into your own projects.
5. Easy to use, high performance tools for parallel computing.

Python Imaging Library and Scikit-Image

These packages (among many others) have custom modules for image processing.

OpenCV

OpenCV (Open Source Computer Vision Library) is an open source computer vision and machine learning software library. OpenCV was built to provide a common infrastructure for computer vision applications and to accelerate the use of machine perception in the commercial products. The library has more than 2500 optimized algorithms, which includes a comprehensive set of both classic and state-of-the-art computer vision and machine learning algorithms. It has C++, C, Python, Java and MATLAB interfaces and supports Windows, Linux, Android and Mac OS.

Installing

Installing all these packages might seem a little too much! Don't worry. You can install all of the above (and many other packages) just by downloading and installing any of the following Python Distributions :

Continuum Anaconda Free (as in 'Freedom'). Both Python 2.7 and 3.4 are available. Availabe for Linux, Mac and Windows.

Enthought Canopy Free + Subscription based. Only Python 2.7. Availabe for Linux, Mac and Windows. Full featured product subscription is freely availabe for Academic use.

WinPython Portable. Free. Both Python 2.7 and 3.4 are available. Windows only.

Getting Started

Unlike almost all other IPython notebooks, I will NOT import Pylab Magic. But if you really want to, you can do it by uncommenting (removing the #) and running the following line.

In case you didn't have any error so far, you're good to go!

What is an image anyway?

Short answer It is just a 2 dimensional array (grayscale image) or a set of Three 2 dimensional arrays (colour image).

Long answer

Loading an Image as a Numpy array

Check the data type and the size of the array $A$

So, our image is a colour image and it has a resolution of $400 \times 267$. It is imported as an N-dimenstional array object available from numpy.

Now, let us segrigate the Red, Green and the Blue channels

Now that we know how to read and display an image. Let us do this:

See! A random image! Now let us create a random color image!

Image Enhancement Techniques

The principal objective of Image Enhancement is to process an image so that the result is more suitable than the original image for a particular application.

However, there are mainly TWO approaches towards image enhancement. A saptial domain approach and a frequency domain approach.

Spatial Domain Approach

It refers to the image plane itself and involves direct manipuation of the pixels of an image.

Frequency Domain Technique

Frequency domain processing techniques are based on modifying the Fourier Transform of an image.

Spatial Domain Approaches

Image processing functions in the spatial domain are often of the form $ g(x,y) = \mathcal{T}[f(x, y)]$, where, $f(x, y)$ is the input image and $g(x, y)$ is the processed output image. $\mathcal{T}$ is an operation on $f$ defined over some neighbourhood of the pixel at the location $(x, y)$. Usually a neighbourhood of $3\times 3$ (or sometimes $1\times 1$) is assumed about the pixel at $(x, y)$.

Spatial domain techniques include Pint processing, Image subtraction, Spatial filtering, Image averaging, etc.

Point processing include Contrast stretching, Gray-level slicing, Bit-plane slicing, Histogram processing, etc.

Spatial filtering includes Low pass filtering, Median filtering, High-pass filtering, etc.

Histogram and Contrast

The word histogram in the context of an image simply means a histogram plot of the pixel intensity vs number of pixels.

Now, let us go back to the original image of the Macaw. Let us plot the histogram of the pixel intensity. First convert the original image into a grayscale image. This RGB to grayscale conversion would use the formula (more on this formula later) $$X_{Gray} = [0.299\quad 0.587\quad 0.144] \cdot \left[\begin{array}{c} X_{R}\\ X_{G}\\ X_{B} \end{array}\right].$$

Let us now narrow the contrast the image

Contrast Stretching

The possible causes for low contrast images are

1. poor illumination
2. lack of dynamic range in imaging sensor
3. wrong setting of the lens aperture during image acquisition.

Contrast stretching attempts to increase the dynamic range of the gray levels of the image being processed. For a neighbourhood of size $1 \times 1$, contast stretching is usually done by a gray level transformation of the form $s = \mathcal{W}[r]$, where $r$ is the gray level of $f(x, y)$ at $(x, y)$, $s$ is the gray level of $g(x, y)$ at $(x, y)$ and $\mathcal{W}$ is a graylevel transformation function.

Now, let us load a low contrast image.

As we can see that the image has low contrast, we will use the following transformation function to stretch the contrast of the image. $$s=\mathcal{W}(r)=\begin{cases} 0, & r<103\\ \frac{255}{132}(r-103), & 103\le r\le235\\ 255, & r>235 \end{cases}$$

See that, now the pixel intensities are spread over wider range $[0, 255]$. This is known as linear contrast streatching.

Negative

If you subtract the pixel intensities of the original image from 255, what you get is essentially the negative of the image. $$ X_{neg} = \left[\begin{array}{ccc} 255 & \cdots & 255\\ \vdots & \ddots & \vdots\\ 255 & \cdots & 255 \end{array}\right] _{m\times n} - X_{m\times n}.$$

The transformation function in this case looks like this.

Compare the histogram of the negative with that of the original.

Dynamic Range Compression

to be done later

Power Law (Gamma) Transformations / Gamma Corrections

Gamma correction involves a nonlinear transformation of the form $s = \mathcal{W}[r] = 255\,c\,\left(\dfrac{r}{255}\right)^\gamma$, where, $c$ and $\gamma$ are positive constants. The following plot shows a $r$-vs-$s$ plot for different values of $\gamma$.

Gray-level Slicing

Sometimes we need to highlight a specific range of gray levels in a image. Possible application areas are finding masses of water in satellite imagery, enhancement of flaws in x-ray images, etc.

There are two basic approaches towards gray-level slicing.

1. Binary Thresholding : all gray levels in the range of interest are displayed using a high value and the rest using a low value.
2. Gradual Thresholding : desired range of gray levels are brightened but the background and the gray-level tonalities are preserved.

For exaple, let the range of interest be in $[120\,\, 180]$. Then the corresponding transformation functions would look like the following.

Now let us use these ideas in real life!

Load Scikit-image. It has built-in image data sets. More at http://scikit-image.org/docs/dev/api/skimage.data.html

By means of visual inspection we find that the texts in the scanned page has intensity values higher than $150$ and the background has intensity values lower than that.

(N.B. This is a very crude method! We will automate this later.)

So, we would consider a thresholding function that will search the image pixel by pixel. If the intensity of a pixel is greater than or equal to 150, it will be assigned a value of 255 and if its intensity falls below 150, a zero will be assigned in its place.

Change the value of the threshold in the above programme and see the changes!

Now consider gradual thresholding. We consider that the region of interest lies between intensity values of 100 and 170.

Bit Plane Slicing

1. Sometimes it is desirable to highlight the contribution made by specific bits to the total image appearance.
2. The image can be imagined to be composed of Eight 1-bit planes -- Plane 0 for the LSB plane and Plane 7 for the MSB.
3. The higher order bits contain visually significant data, the lower order plane contain more subtle details.

This can be acomplished by doing a Bitwise AND operation. For example, say the intensity of a pixel is 246 in decimal. In binary this would be $(1111\,0110)_2$. So in order to find the value of the 6th bit, one has to siimply do this $(1111\,0110)_2 \odot (0100\,0000)_2$. The result will simply produce the value of the 6th bit. In other words, $246 \odot 64$ will give you the value of the 6th bit.

Spatial Filtering

Low pass filters attenuate or eliminate high frequncy components in the Fourier domain. Low pass filtering gives rise to image blurring.

High pass filters attenuate or eliminate low frequncy components in the Fourier domain. High pass filtering gives rise to sharpening of edges and other sharp details.

How to implement?

Utilize suitable 2D masks of suitable size, e.g. $3 \times 3$, $5 \times 5$ or $7 \times 7$. In most of our use cases, we shall restrict ourselves to $3 \times 3$ masks. The mask is applied to certain pixels. Upon application, the mask calculates a wighted sum of the neighbourhood of the concerned pixel and the result substitutes the original pixel. Here is how it works.

Consider that there is a pixel of intensity $z_5$. The $3 \times 3$ neighbourhood of the pixel can be seen as $$\left[\begin{array}{ccc} z_{1} & z_{2} & z_{3}\\ z_{4} & z_{5} & z_{6}\\ z_{7} & z_{8} & z_{9} \end{array}\right].$$ Now consider that the mask that is applied on the pixel with intensity $z_5$ looks like $$\left[\begin{array}{ccc} w_{1} & w_{2} & w_{3}\\ w_{4} & w_{5} & w_{6}\\ w_{7} & w_{8} & w_{9} \end{array}\right].$$

Then, it will substitute $z_5$ by $w_1 z_1 + w_2 z_2 + \cdots + w_9 z_9$. Thus, $$z_{5\{new\}}=\sum_{i=1}^9 w_i z_i.$$

Thus, $$\left[\begin{array}{ccc} z_{1} & z_{2} & z_{3}\\ z_{4} & z_{5} & z_{6}\\ z_{7} & z_{8} & z_{9} \end{array}\right] \otimes \left[\begin{array}{ccc} w_{1} & w_{2} & w_{3}\\ w_{4} & w_{5} & w_{6}\\ w_{7} & w_{8} & w_{9} \end{array}\right] = \left[\begin{array}{ccc} z_{1} & z_{2} & z_{3}\\ z_{4} & \sum_{i=1}^9 w_i z_i & z_{6}\\ z_{7} & z_{8} & z_{9} \end{array}\right].$$

It does not do any changes to any other pixel anyway. The mask is centred on the image pixel whose new intensity value is tobe calculated. This calculation is performed for each pixel seperately by moving the mask to centre it on the pixel under consideration.

Smoothig spatial filters

Low pass spatial filtering

Examples of low pass spatial filter masks are

$$\mathcal{L}_1 = \dfrac{1}{9}\left[\begin{array}{ccc} 1 & 1 & 1\\ 1 & 1 & 1\\ 1 & 1 & 1 \end{array}\right]; \quad\quad \mathcal{L}_2 = \dfrac{1}{16}\left[\begin{array}{ccc} 1 & 2 & 1\\ 2 & 4 & 2\\ 1 & 2 & 1 \end{array}\right]$$

1. A low pass filter must have all positive coefficients.
2. For a low pass spatial filter mask shown as $\mathcal{L}_1$, the operation is also popularly termed as neighbourhood averaging. This averaging causes blurring and loss of sharpness.
3. For a filter mask shown in $\mathcal{L}_2$, it is called weighted averaging.

Median filtering

Median filters are nonlinear (why?) filters employed with an objective of noise reduction, withot bluring.

$$\underset{\textrm{image section under consideration}}{\underbrace{\left[\begin{array}{ccc} z_{1} & z_{2} & z_{3}\\ z_{4} & z_{5} & z_{6}\\ z_{7} & z_{8} & z_{9} \end{array}\right]}} \underset{\textrm{median filtering}}{\Rightarrow} \underset{\textrm{result of median filtering}}{\underbrace{\left[\begin{array}{ccc} z_{1} & z_{2} & z_{3}\\ z_{4} & \textrm{med}\{z_{5}\} & z_{6}\\ z_{7} & z_{8} & z_{9} \end{array}\right]}},$$

where $\textrm{med}\{z_{5}\}$ is the median of $z_1, z_2, \cdots, z_9$. Median value can be easily calculated by arranging $z_1, z_2, \cdots, z_9$ in ascending order of maginitude and then finding the value that is in the middle position.

This filter is most effective when the noise pattern consists of niose-like components and it is of utmost importance to preserve edge sharpness.

Now we shall use scikit-image. There are many built in filters. Check http://scikit-image.org/docs/stable/api/skimage.filters.html for more.

See that the low pass filter significantly reduces the noise level.

Now let us apply median filtering to the same image.

As one can easily see, an image corrupted with speckle noise can be better denoised with mean filtering. Now check an image with salt and pepper noise.

See the difference!

Sharpening spatial filters

Derivative filters

1. The differentiation operation is expected to sharpen an image.
2. One can use either first derivative or second derivative information.

Digital approximation of first derivative : $\dfrac{\partial f(x,y)}{\partial x} = f(x+1, y) - f(x, y), $ and $\dfrac{\partial f(x,y)}{\partial y} = f(x, y+1) - f(x, y).$

Constraints : The response of a first derivative filter must be

1. zero in areas of constant intensity,
2. must be non-zero at the onset of an intensity step or ramp,
3. nonzero along ramps.

Digital approximation of second derivative : $\dfrac{\partial ^2f(x,y)}{\partial x^2} = f(x+1, y) - 2 f(x, y) +f(x-1, y),$ and $\dfrac{\partial ^2f(x,y)}{\partial y^2} = f(x, y+1) - 2 f(x, y) +f(x, y-1).$

Constraints : The response of a second order derivative filter must be

1. zero in areas of constant intensity,
2. non-zero at the onset and the end of an intensity step or ramp,
3. zero along ramps of constant slope.

Implementing a first derivative filter for image sharpening

A first derivative image sharpening filter can be implemented by by applying the Gradient function. The gradient of a function $f(x, y)$ at coordinates $(x, y)$ is defined as the 2D column vector

$$\nabla f(x,y)\equiv\mathrm{grad}(f)\equiv \mathbf{g} \equiv \left[\begin{array}{c} g_{x}(x,y)\\ g_{y}(x,y) \end{array}\right]=\left[\begin{array}{c} \frac{\partial f(x,y)}{\partial x}\\ \frac{\partial f(x,y)}{\partial y} \end{array}\right].$$

The magnitude (length) of vector $\nabla f$ is given by $M(x, y) = ||\nabla f||= \sqrt{\mathbf{g}^T \mathbf{g}} = \sqrt{g_x^2 + g_y^2}$. In image processing, this last expression is often approximated as $|g_x| + |g_y|$.

$M(x, y)$ is an image of the same size of the original and called the gradient image. The computation of this gradient is the basis of various approaches to develop first derivative filter.

If $$\left[\begin{array}{ccc} z_{1} & z_{2} & z_{3}\\ z_{4} & z_{5} & z_{6}\\ z_{7} & z_{8} & z_{9} \end{array}\right]$$

is the image section under consideration, then, according to the above theory, after the application of first derivative filtering, the new value of $z_5$ will be $$M(x,y) = [(z_8 - z_5)^2 + (z_6 - z_5)^2]^{1/2} \approx |z_8 - z_5| + |z_6 - z_5|.$$ Another implementation involves cross-differences: $$M(x,y) = [(z_9 - z_5)^2 + (z_8 - z_6)^2]^{1/2} \approx |z_9 - z_5| + |z_8 - z_6|.$$ But there is one problem : masks of even size are awkward to implement (why?). Hence an approximation with $3 \times 3$ neighbourhood is preferred. The mostly used first order derivative masks are Sobel masks and Prewitt masks. They are like follows :

$$\mathcal{S}_{y}=\underset{\textrm{Sobel horizontal derivative}}{\underbrace{\left[\begin{array}{ccc} -1 & -2 & -1\\ 0 & 0 & 0\\ 1 & 2 & 1 \end{array}\right]}}; \quad \mathcal{S}_{x}=\underset{\textrm{Sobel vertical derivative}}{\underbrace{\left[\begin{array}{ccc} -1 & 0 & 1\\ -2 & 0 & 2\\ -1 & 0 & 1 \end{array}\right]}}; \quad \mathcal{P}_{y}=\underset{\textrm{Prewitt horizontal derivative}}{\underbrace{\left[\begin{array}{ccc} -1 & -1 & -1\\ 0 & 0 & 0\\ 1 & 1 & 1 \end{array}\right]}}; \quad \mathcal{P}_{x}=\underset{\textrm{Prewitt vertical derivative}}{\underbrace{\left[\begin{array}{ccc} -1 & 0 & 1\\ -1 & 0 & 1\\ -1 & 0 & 1 \end{array}\right]}} .$$

Now, lets get to work!

Another Example

Laplacian filter

A second order derivative filter can be implemented by employing a Laplacian mask. The Laplacian of an image function $f(x, y)$ of two variables is defined as $\nabla ^2 f(x, y) = \dfrac{\partial ^2f(x,y)}{\partial x^2} + \dfrac{\partial ^2f(x,y)}{\partial y^2}.$

Thus, $\nabla ^2 f(x, y) = f(x+1, y) + f(x-1, y) + f(x, y+1) + f(x, y-1) - 4f(x,y)$. So, a Laplacian mask would look like

$$\nabla^2_\perp=\underset{\textrm{Laplacian mask}}{\underbrace{\left[\begin{array}{rrr} 0 & 1 & 0\\ 1 & -4 & 1\\ 0 & 1 & 0 \end{array}\right]}}; \quad \nabla^2_\odot=\underset{\textrm{Omnidirectional Laplacian mask}}{\underbrace{\left[\begin{array}{rrr} 1 & 1 & 1\\ 1 & -8 & 1\\ 1 & 1 & 1 \end{array}\right]}}.$$

The second one, here, considers four directions 1. horizontal, 2. vertical, 3. +45$^\circ$ and 4. -45$^\circ$, whereas, the first one only considers the horizontal and vertical directions.

However, there is a problem regarding the direct implementation of a Laplacian mask. Being a second derivative operation, it highlights intensity discontinuities in an image, and in the process de-emphasizes image regions having slow variations in intensity profile. SO, in order to preserve the original background features and yet perform sharpening operation, the Laplacian operator is utilized in the following manner: $$g(x,y) = f(x, y) + c\left[\nabla^2 f(x, y)\right],$$ where, $c=-1$ for the operators we considered.

Here is a comparison of Laplacian filter with Sobel filters. For the first time, we are going to use OpenCV.

You can also use Scikit-image to achieve the same goals.

Now, check out Python Imaging Library (fork: pillow). It contains many built in spatial filter modules.

An important point to note : For a high pass spatial filter mask , whether utilizing first derivative or second derivative, the sum of the mask coefficients is always zero.

Unsharp masking and high boost filtering

This approach sharpens an image using kind of a 'back-calculation' method! Let the original image function be $f(x, y)$. First, a blurred version of the image is created. Let this version be $\bar{f}(x,y)$. Then this blurred version is subtracted from the original image. This creates a mask like $g_{mask}(x,y) = f(x, y) - \bar{f}(x,y)$. Then this mask is added to the original image resulting $g(x,y) = f(x,y) + k\,g_{mask}(x,y)$, where, $k$ is a constant.

If $k=1$, this process is called unsharp masking. When $k>1$, it is called high boost filtering.

Frequency Domain Approaches

Once we are comfortable with the spatial domain image enhancement techniques described above, we are ready to jump into a completely different approach towards image processing. Instead of directly manipulating the pixels in an image, we will now manipulate the Fourier Transform of the image. We would utilize the concept of 2D Discrete Fourier Transform (DFT), Fast Fourier Transform (FFT) and the Convolution theorem in 2 dimensions.

The 2D DFT pair for an image function $f(x,y)$ can be expressed as $$F(u, v) = \frac{1}{MN} \sum _{x=0}^{M-1} \sum _{y=0}^{N-1} f(x,y) \exp\left[-j2\pi\left(\frac{ux}{M}+\frac{vy}{N}\right)\right],$$ for $x=0,1,\cdots,M-1$ and $y=0,1,\cdots,N-1$, and $$f(x,y) =\sum _{u=0}^{M-1} \sum _{v=0}^{N-1} f(x,y) \exp\left[j2\pi\left(\frac{ux}{M}+\frac{vy}{N}\right)\right],$$ for $u=0,1,\cdots,M-1$ and $v=0,1,\cdots,N-1$.

The convolution theorem in 2D states that, $$h(x,y)* f(x,y) \rightleftharpoons H(u,v)F(u,v),$$ and $$ H(u,v)*F(u,v) \rightleftharpoons h(x,y)f(x,y).$$

In image enhancement problems, $f(x,y)$ is the input image, $g(x,y)$ is the output image and it is obtained by the application of a linear position invariant operator $h(x,y)$ on $f(x,y)$. Thus, $g(x,y)=h(x,y)* f(x,y),$ and $G(u,v)=H(u,v)* F(u,v)$. Here, $G(u,v)$, $H(u,v)$, and $F(u,v)$ are the DFTs of $g(x,y)$, $h(x,y)$ and $f(x,y)$ respectively. $H(u,v)$ is often called the process transfer function.

The main goal in frequency domain approach in image enhancement is to select a suitable $H(u,v)$ such that $g(x,y)$ exhibit some highlighted feature of $f(x,y)$.

Image processing in frequency domain usually involves the following steps:

INPUT : $f(x,y)$

1. Preprocess the input image $f(x,y)$
2. Take its DFT or FFT
3. Multiply the result with a suitable process transfer function $H$
4. Take the IDFT or IFFT of the result
5. Do some post-processing

OUTPUT : Enhanced image $g(x,y)$.

As an example, for Low Pass filtering one can using the Gaussian LPF TRansfer Function $$H_{GLPF}(u,v)=\exp\left[-\frac{D(u,v)}{2\sigma^2}\right],$$ and for High Pass filtering, one can use this: $$H_{GHPF}(u,v)=1-\exp\left[-\frac{D(u,v)}{2\sigma^2}\right].$$ Here, $D(u,v)$ is the distance of the point $(u,v)$ from the origin of the frequency plane, and $\sigma$ (std. deviation) is a measure of the spread of the Gaussian curve.

One can apply this to an image simply by using a built-in module in skimage.

Now we will see how to find Fourier Transform using Numpy. Numpy has an FFT package to do this. np.fft.fft2() provides us the frequency transform which will be a complex array. Its first argument is the input image, which is grayscale. Second argument is optional which decides the size of output array. If it is greater than size of input image, input image is padded with zeros before calculation of FFT. If it is less than input image, input image will be cropped. If no arguments passed, Output array size will be same as input.

Now once you got the result, zero frequency component (DC component) will be at top left corner. If you want to bring it to center, you need to shift the result by $\frac{N}{2}$ in both the directions. This is simply done by the function, np.fft.fftshift(). (It is more easier to analyze). Once you found the frequency transform, you can find the magnitude spectrum.

See, You can see more whiter region at the center showing low frequency content is more.

So you found the frequency transform Now you can do some operations in frequency domain, like high pass filtering and reconstruct the image, ie find inverse DFT. For that you simply remove the low frequencies by masking with a rectangular window of size $60\times 60$. Then apply the inverse shift using np.fft.ifftshift() so that DC component again come at the top-left corner. Then find inverse FFT using np.ifft2() function. The result, again, will be a complex number. You can take its absolute value.

The result shows High Pass Filtering is an edge detection operation. This also shows that most of the image data is present in the Low frequency region of the spectrum. Anyway we have seen how to find DFT, IDFT etc in Numpy. Now let’s see how to do it in OpenCV.

If you closely watch the result, especially the last image in JET color, you can see some artifacts. It shows some ripple like structures there, and it is called ringing effects. It is caused by the rectangular window we used for masking. This mask is converted to sinc shape which causes this problem. So rectangular windows is not used for filtering. Better option is Gaussian Windows.

Fourier Transform in OpenCV

OpenCV provides the functions cv2.dft() and cv2.idft() for this. It returns the same result as previous, but with two channels. First channel will have the real part of the result and second channel will have the imaginary part of the result. The input image should be converted to np.float32 first. We will see how to do it.

So, now we have to do inverse DFT. In previous session, we created a HPF, this time we will see how to remove high frequency contents in the image, ie we apply LPF to image. It actually blurs the image. For this, we create a mask first with high value (1) at low frequencies, ie we pass the LF content, and 0 at HF region.

Note : As usual, OpenCV functions cv2.dft() and cv2.idft() are faster than Numpy counterparts. But Numpy functions are more user-friendly.

Why Laplacian is a High Pass Filter?

The question is, why Laplacian is a high pass filter? Why Sobel is a HPF? etc. And the simplest answer that can be given to it is in terms of Fourier Transform. Just take the fourier transform of Laplacian for some higher size of FFT. Analyze it:

From image, you can see what frequency region each kernel blocks, and what region it passes. From that information, we can say why each kernel is a HPF or a LPF.