Gaussian smoothing is probably the most used filter in computer vision because this filter optimally suppresses random noise in the image for the corresponding filter window size. Additionally, because smoothing gives a smoothed image, it is better suited for further processing such as binarization.

We will consider an example that demonstrates a smoothing effect using the Gaussian filter. You will see and compare the thresholded original image and the thresholded smoothed image.

Use the Project Generator wizard for creating an empty project with the linked ofxOpenCv addon (see the Using ofxOpenCv section). Then, copy the sunflower.png image into bin/data of the project.

In the testApp.h file, add a line that includes the addon's header just after the #include "ofMain.h" line:

#include "ofMain.h"
#include "ofxOpenCv.h"

Add the following members to the testApp class declaration:

ofxCvColorImage image;	            //Original image
ofxCvGrayscaleImage grayImage;     //Grayscaled original image
ofxCvGrayscaleImage filtered;      //Image used for filtering

In testApp.cpp, the setup() function loads an image from the file, copies it to the color image image, and creates its grayscaled copy grayImage. Note that for loading the image from the file, we use a temporary object imageOf as follows:

void testApp::setup(){
  ofImage imageOf;  //Temporary image for loading from the file
  imageOf.loadImage( "sunflower.png" );  //Load image from
                                         //the file

  //Set image pixels
  image.setFromPixels( imageOf.getPixelsRef() );

  //Convert to a grayscale image
  grayImage = image;
}

To obtain a shorter code, we perform the all image processing steps right in draw() and directly draw its results on the screen using just one filtered image. A more accurate approach is to declare a separate image for each image we want draw, and then process it once in update(). Also, in the example, the input image has not changed so we can do the processing right in setup(). So, the update() function is empty here, and the draw() function does all the image processing:

void testApp::draw(){
  ofBackground( 128, 128, 128 ); //Set the background color

  //Get image dimensions
  int w = image.width;
  int h = image.height;
  ofSetColor( 255, 255, 255 );  //Set a color for images drawing

  //Draw original image
  grayImage.draw( 0, 0, w, h );

  //Thresholding original image
  filtered = grayImage;         //Copy the image
  filtered.threshold( 128 );    //Thresholding original image
                                //using thresold 128
  filtered.draw( w+10, 0, w, h );  //Draw

  //Smoothing original image
  filtered = grayImage;            //Copy the image
  filtered.blurGaussian( 9 );      //Gaussian blurring
                                   //with window size 9x9
  filtered.draw( 0, h+10, w, h );  //Draw

  //Thresholding smoothed image
  filtered.threshold( 128 );     //Thresholding smoothed image
                                 //using thresold 128
  filtered.draw( w+10, h+10, w, h );  //Draw
}

Run the example and you will see four images:

Note that the Thresholded smoothed image has more smooth contours.

Here are two parameters of the algorithm:

Adjust these parameters and watch how the smoothness of the contours and the overall number of white pixels change. Now we will consider geometrical transformation of images.