Image Filtering : Opencv Interface

In the previous post we have seen how to manually define custom filters.
We made use of filter2D function with Gaussian kernel and Blur operator to demonstrate working of this function.

Opencv provides predefined functions for most common operators like blur operator, Gaussian operator, in this post we are going to discuss how to make use of this interface.

1. Blur operator
   We have already discussed this filter in this post.
2. Gaussian Filter
   Gaussian filter is discussed here.
3. Median Filter
   As the name suggests median operator takes median of all the elements covered by mask, and replaces center pixel with this median.

Code:

Results:

Bash script: Volume and Brightness [Ubuntu 12.04]

1) Brightness.sh 

Allows you to set up brightness of your monitor using terminal.

Following command is used to set brightness level.

sudo sh -c 'echo <brightness> > /sys/class/backlight/<device>/brightness'

Here <brightness> is brightness level, and takes integer values starting from 0. Higher the value, higher the brightness.

2) Volume.sh 

Allows you to mute or unmute speakers.

Mute

pactl set-sink-mute 0 1

Enable speakers

pactl set-sink-mute 0 0

Here pactl stands for 'Pulse Audio Control'

3) Startup.sh

This script will run every bash script from given directory.

I use this script for switching profiles.

For example if I store brightness.sh and volume.sh in startup_scripts directory and run startup.sh then this startup.sh will run both brightness.sh and volume.sh for me.

Image Filtering : Gaussian Filter

First things first, what is Gaussian filter?

Gaussian filter is a kernel based on the values obtained by plotting Gaussian function.

In my previous post we have seen how to use filter2D function provided by opencv to perform correlation on the images with given kernel.

We also discussed an example of blur operator. This operator assigns equal weight to every element in the neighborhood. But it is quite natural to think that the pixels which are close to target pixel in image should have more weight assigned to them. This is exactly what we try to achieve using Gaussian filter.

Gaussian function is given by,

 The plot of this function looks like this,

Values of Gaussian function have been used to construct this kernel.
As you can see the center pixel has maximum weight of 0.159 and weight values decreases as the distance from center pixel increases. All the pixels which are at same distance from the center pixel have same weight value, are also known as contours.

Following image is formed using Gaussian kernel.

Lets compare results of blur operator in the previous post and

Original Image

Blur Operator

Gaussian Smoothing

As it is evident from the result that features of image are well preserved in case of Gaussian kernel than that of the blur operator.

Sample code for Gaussian Blurring:

Image Filtering Basics: Convolution and Correlation - II

As we discussed in the previous post opencv allows us to perform convolution and correlations easily.
Actually opencv lets you perform correlation only. There is difference in correlation and convolution,
for performing convolution we first rotate mask chosen by 180 degree and then apply the procedure discussed in the part I of this post.

More formally correlation is defined as

whereas convolution is defined as

As you can see negative arguments in case of mask F are have negative sign. This corresponds to reflection against x and y axis or in other words rotation by 180 degrees. 

In standard literature mask is also known as kernel, we will follow this convention throughout this blog here onward.

The filter2D is a function provided by opencv to perform correlation. 

Signature of filter2D.

filter2D(src, dst, ddepth, kernel, anchor, delta,Border_Type);    

Mat src : source image.

Mat dst : destination image.

ddepth : image depth of the destination.

kernel : Mask function.

Anchor : represents location of anchor/ origo w.r.t the kernel.

delta : a value to be added to each pixel during convolution.

Border_Type : Way to pad image.

Results:

Original Image

With blur operator of size 5x5

Image Filtering Basics: Convolution and Correlation.

Let's consider two images I and F. I is input image and F is mask.

Correlation

For convolution we keep center of mask matrix over every pixel of input image update that value with weighted sum of every other pixel covered by the mask.

As can be seen from the above image, in the 10 is the center of  area covered by mask in 'I'.

So in output image that value is updated by the the expression given in the image. This operation is repeated for every pixel of the input image and output image is constructed. 

As you might have guessed by now that given mask computes average values in the neighborhood and updates the center pixel with this new value. As a result we get a smoother image in output. Saying that output will be a smoother image is quite intuitive, clearly every pixel in the output image (o) will have a component from the neighboring pixels. This components decrease the difference in intensities values of neighboring pixels. Hence change in intensity while moving across new image is lesser or in other words smoother.   

If we change the mask we get different results. For example if change the value of the center pixel of the mask by 2. The the image obtained by taking convolution will have more weight to the current pixel being scanned. 

Lets see few example of this operation:

1) Here F has only center pixel as 1. Therefore contribution from neighbors is 0 and there is no change in image. 

2) Shift operator

 3) Blur operator which we discussed in the main part

In the next post we are going to discuss how to perform convolution with opencv.

Image Processing Basics : Intensity [Part II] _ Convert image into Binary Format

In this post we will study the effect of increasing number of bits used for storing each pixel.

[Basics of image representation are covered here]
[Github : Gist]

Result:

 Original Image

No intensity levels allowed = 2.

No of intensity levels = 4

No of intensity levels = 8

It is very clear from the results obtained that as no. of intensity levels or in other words bits associated with every pixel increases quality of image increases. 

Image Processing Basics: Intensity

A digital image is nothing but an array of numbers. Every number represents intensity of corresponding pixel. We usually use 8 bits for storing intensity of a pixel i.e. we can store 0 - 255 discrete intensity values.

As we increase number of bits associated with each pixel total number of intensity levels increases and hence quality of the image. So a gray image which has only one type of intensity and has dimension NxM, will have size of 8*NxM bits or NxM bytes. Similarly a color image with 8 bit representation would consume 3*NxM bytes of memory space.

Typical range of N and M is around 1000~2000. As you can see with increase in every bit of the image representation, size of image increases significantly.

In this post we are going to discuss how to access elements of image using iterators.

But before that let's discuss few terms.

1) Iterators : Iterators are nothing but a way to access data from containers. C++ provides us a way to access elements from structures provided by standard template library like stack, queue and map. We are going to use iterators to access individual pixel of image.

2) typeof : typeof is a special keyword provided by c++ which returns type of current object.

Let's start with code.

Function saturate takes image, increase and channel no as an input.
As an output it generates new image with increased intensity for given channel.
Github : Gist

Result:

First one is the original image and the second one is output image. The dark part in output is because of overflow.