The event was held during the 21st National Research Symposium last October 9, 2009 at the Fernando Lopez Hall of the Bureau of Soils and Water Management (BSWM) Bldg., Visayas Avenue, Diliman, Quezon City.

Check the full article @ http://www.bar.gov.ph/news/21stnrswinners.asp

 Share now!

My goal in this article is to demonstrate simple background segmentation techniques using Emgu.CV.  Background segmentation is important if you are trying to extract features from an image and you want to remove or filter out unwanted objects.  You may also find this technique important when the recovery of color information from foreground objects is important.

Our objective is to remove the background from the rice image below. We want to get the color information from the rice kernels and be able to extract features for for each kernel, maybe for shape analysis or classification purposes.

Source code is available at the Visioneer Forum site.

I am sure there are other ways to perform background subtraction but this article will cover three methods that .

1. Color filtering in Cielab color space
2. Image masking (as i call it)
3. Cielab + image masking

The three methods will be explained shortly and the link to the source code is available at the visioneer forum.

Color Filtering in Cielab Color Space

In this method, a copy of RGB image in Cielab space is obtained, and then process this image (in Cielab space) pixel by pixel.  Each pixel is checked if its color value is within specified range, otherwise, the pixel in the corresponding RGB image is set to black color.  An implementation is visible below:

   1: // background subtraction in cielab color space

   2: private void CielabColorFilteringBGSubtraction(string filename, bool displayResult)

   3: {

   4:     // create new image from file

   5:     Image<Bgr, Byte> rgbimage = new Image<Bgr, byte>(filename);

   6: 

   7:     // make a copy of the image in lab color space

   8:     Image<Lab, Byte> labimage = rgbimage.Convert<Lab, Byte>();

   9: 

  10:     // get the width and size

  11:     int width = labimage.Width;

  12:     int height = labimage.Height;

  13: 

  14:     // get the filter range for each channel in lab color space

  15:     IntRange l = new IntRange(Byte.Parse(min1TextBox.Text), Byte.Parse(max1TextBox.Text));

  16:     IntRange a = new IntRange(Byte.Parse(min2TextBox.Text), Byte.Parse(max2TextBox.Text));

  17:     IntRange b = new IntRange(Byte.Parse(min3TextBox.Text), Byte.Parse(max3TextBox.Text));

  18: 

  19:     // process each row in the image

  20:     for (int i = 0; i < width; i++)

  21:     {

  22:         // process each pixel

  23:         for (int j = 0; j < height; j++)

  24:         {

  25:             if (

  26:                 (labimage[j, i].X >=l.Max ) || (labimage[j, i].X <= l.Min) ||

  27:                  (labimage[j, i].Y >= a.Max) || (labimage[j, i].Y <= a.Min) ||

  28:                  (labimage[j, i].Z >= b.Max) || (labimage[j, i].Z <= b.Min)

  29:                 )

  30:             {

  31:                 // if outside the filter range, set the pixel to black color

  32:                 rgbimage[j, i] = new Bgr(0, 0, 0);

  33:             }

  34:         }

  35:     }

  36: 

  37:     // display

  38:     if (displayResult) this.NewImage("Cielab-based background segmented image", rgbimage);

  39: }

The resulting image looks like this.  In my PC, it took about 3.20 sec to perform background segmentation.

Image Masking

In this method, what we do is convert an RGB image into binary via binary thresholding.  (The choice of threshold value depends on the image, so you have to experiment on this.)  This binary image will serve as the mask image to copy pixels from the original image to the destination image, if the corresponding pixel in the mask image is nonzero. This is given by the following representation:

DestinatioImage(x,y) = SourceImage(x,y) if MaskImage(x,y) <> 0

where x and y is the pixel coordinates of the image. Source, destination and mask image have the same size.

Code implementation is as follows:

   1: // background subtraction by converting the RGB image to binary to create the mask

   2: // then use this mask to copy foreground objects in the image

   3: private void RGBImageMaskBGSubtraction(string filename, bool displayResult)

   4: {

   5:     // load the threshold value for grayscale image

   6:     double threshold = double.Parse(max2TextBox.Text);

   7: 

   8:     // create new image

   9:     Image<Bgr, Byte> img = new Image<Bgr, byte>(filename);

  10: 

  11:     //convert to grayscale

  12:     Image<Gray, Byte> gray = img.Convert<Gray, Byte>();

  13: 

  14:     //convert to binary image using the threshold

  15:     gray = gray.ThresholdBinary(new Gray(threshold), new Gray(255));

  16:

  17:     // copy pixels from the original image where pixels in 

  18:     // mask image is nonzero

  19:     Image<Bgr, Byte> newimg = img.Copy(gray);

  20: 

  21:     // display result

  22:     if (displayResult) this.NewImage("Background segmented", newimg);

  23: 

  24: }

One thing we should be aware of is that, all channels in RGB image is used to convert the image in grayscale image, then eventually binary image.  The output image is shown below:

Obviously, this is far worst then the first method.  But the advantage of segmentation using this technique is the speed.  The image was segmented for only 0.25 sec with more than 12X improvement, but we have to live with the quality. According to my tests, the performance improvement increases as the image size increased.  If we are very much concerned with the pixels in foreground objects, then the Image Masking method will not satisfy our requirements. 

However, there is another method to achieve the segmentation quality of cielab color filtering method, and the speed of the image masking method. 

Cielab + Image masking

In this method, we combine the first two techniques to get the cream of both ice creams.   What we do is to perform the processing as in image masking method, but instead of using 3 channels (in RGB format) to convert the image to grayscale, we convert the image into Cielab space, select the a*-channel of the image, and use this channel to derive the mask image.

Code implementation here:

   1: // background subtraction by extracting one channel in cielab image to 

   2:  // create binary mask, and use this mask to copy foreground objects in 

   3:  // the original image

   4:  private void CielabChannelMaskBGSubtraction(string filename, bool displayResult)

   5:  {

   6:      double threshold = double.Parse(max2TextBox.Text);

   7: 

   8:      Image<Bgr, byte> rgb = new Image<Bgr, byte>(filename);

   9:      Image<Lab, Byte> img = rgb.Convert<Lab, Byte>();

  10: 

  11:      //get the a* channel 

  12:      Image<Gray, Byte> gray = img[channel];

  13: 

  14:      //threshold and invert

  15:      gray = gray.ThresholdBinary(new Gray(threshold), new Gray(255)).Not();

  16: 

  17:     // display the result

  18:      if (displayResult) this.NewImage("Background segmented", image);

  19:  }

Resulting output image here, note that it has almost the same quality as in the first method but with little performance penalty (processing takes around 0.03 sec longer than the second method).

Please note that you need to tweak the filter range(threshold value) for this to work in your problem area. Also,

1. In Method 1, all three channels are used as filter ranges.
2. Method 2, uses channel 1(maximum) for grayscale threshold value
3. In method 3, you can select among the radio buttons (on the right) which channels to choose as the source for the mask image.  Then modify the filter range for that selected channel mask. You can also modify the source code to select one or more channels if it gives better performance.
4. I have included two images located in the source code folder for testing purposes.

Screenshot is given below:

 Share now!

I did this software for Bureau of Post-harvest Research Extension (BPRE) and indirectly, to National Food Authority (NFA) for the purpose of quickly determining the grain size of milled rice.

The demo and initial version of the caliper software is available for download here:

• caliper software. 

To use the software, simply install the application, then open the sample image included in the installation (“bigas.bmp”), then that’s it!  You can try it for other similar problems, like corn, barley, etc.  Please give me feedback if problems arises.  For any questions, you may email me at {vlad_crasher at yahoo point com}.

UPDATE: Yesterday (September 15, 2008), they told me that the test was successful!  The classification result did matched with the manual methods performed by human inspector.

 Share now!

• Chalky
• Sound/Good
• Damaged
• Red
• Paddy
• Discolored

My goal is to share how to build a model, apply this classifier to your test data to determine its accuracy, and finally, implement the model as an application.  The library called LibSVM has made my work a lot simpler.  Why reinvent the wheel?  Here’s how you do it:

1. Acquire the image.  This could be accomplished by various methods.  You can use scanner, digital camera, or video camera.
2. Pre-process the captured image.  The goal is to ensure that unimportant objects are discarded, and enhance your region of interests to prevent lost of features.
3. Extract features (Morphological & Color), one set for training and another set for testing.
4. You may need to scale your data, especially if the value of some features are a lot  larger than the other.
5. Train and build the SVM model.  You may need to find the optimal parameters (the penalty, C and kernel parameter, gamma).  This may take a while depending on the type of SVM and kernel you choose.
6. If you are satisfied with the prediction accuracy of your model, then apply it to your test data, or real data.
7. Build your application.

Simple, eh?

 Share now!

The software is used for determining the grain size of a given milled rice sample.  Additional information about other milled rice grade factors are also provided as follows:

1. Total number of kernels and weight of the milled rice sample
2. Number of headrice and weight
3. Number of broken kernels including its total weight
4. Brewers

I will provide more information soon.  Keep posted!  And hey… feel free to comment.  Tell me what you think!

 Share now!