The Visioneers

Background Subtraction in C# Part 2

whaldsz — Wed, 25 Jan 2012 10:59:05 +0000

My old post has been receiving lots of hits requesting for the source code of the background subtraction in this post. The code below is an improved implementation, much faster and less code. Please note that this method is excellent for the type of images where foreground and background object is contrasting. Additional image post-processing may be needed to remove small blobs.


var image= new Image(filename);

// threshold values for each channel
var thresholds = new [] {new TRange(70,255), new TRange(0,255), new TRange(0,255)};

Image[] grays = image.Convert().Split();

// threshold each channel
for (int i = 0; i < 3; i++)

{
grays[i]._ThresholdToZero(new Gray(thresholds [i].LowerValue));
grays[i]._ThresholdToZeroInv(new Gray(thresholds [i].UpperValue));
grays[i]._ThresholdBinary(new Gray(1), new Gray(255));
}

// merge the thresholded array of binary images above
var  mask = grays[0].And(grays[1].And(grays[2]));

// result
var resultImage = image.Copy(mask);

Share now!

DB Creator in SQLITE and C#

whaldsz — Wed, 25 Jan 2012 09:53:54 +0000

In one of my projects, there is a need to implement a server-less SQL database. The result of my exploration led me to SQLITE. I’m lucky to have found a good wrapper since I’m using C#. All is well until the need to re-create the database arises. This is required when the application is being readied for deployment. In my application, one of the requirements was to be able to reset the database or re create the database inside the application.

To serve this purpose, I developed a small C#console application to create the database for me. The code is quiet simple , far from optimized and buggy but of course it is up to you to improve it.


public static class Util
 {
public static bool CreateDb(string db)
{
try
{
Console.WriteLine("Please wait creating database " + db);
SQLiteConnection.CreateFile(db);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return false;
}

return true;
}

public static bool ExecuteScript(string script, string connectionString)
{
try
{
if (!File.Exists(script)) throw new FileNotFoundException(script);

DbProviderFactory fact = DbProviderFactories.GetFactory("System.Data.SQLite");
using (DbConnection cnn = fact.CreateConnection())
{
cnn.ConnectionString = connectionString;

using (var cmd = cnn.CreateCommand())
{
var fileInfo = new FileInfo(script);
var sql = fileInfo.OpenText().ReadToEnd();

var tables = System.Text.RegularExpressions.Regex.Split(sql, "\r\n\r\n");

if (tables.Length > 0)
{
cnn.Open();

foreach (var table in tables)
{
Console.WriteLine("Writing TABLE: \n" + table);
cmd.CommandText = table;
cmd.CommandType = CommandType.Text;

cmd.ExecuteNonQuery();
}
}

cnn.Close();
return true;
}
}

}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return false;
}
}
}


In your app.config, you need the following entry:



  
    
  

  
    
      
      
    
  




Finally, add a reference to the first file, the second file below should be in the same location as the executable:

System.Data.SQLite.dll
System.Data.SQLite.lib

 Share now!

We got 2nd during the 32nd R&D Review

whaldsz — Fri, 01 Jul 2011 21:24:19 +0000

During the 32nd In-house Research and Development Review last May10-11, 2011 held at Munoz City, Philippines. Our on-going research on Milled Rice Computer Vision garnered an award.

For more information, follow this link - http://www.philmech.gov.ph/?page=news&action=details&code01=NP11050002

Share now!

AFMA Best R&D Paper for Technology/Information Generation

whaldsz — Thu, 29 Oct 2009 16:56:01 +0000

Our study, “Development of a Computer Vision System for Milled Rice Quality Analysis” won the AFMA Best R&D Paper for Technology/Information Generation – Agriculture category.

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!

Background Subtraction in C#

whaldsz — Fri, 14 Nov 2008 17:16:27 +0000

I have been trying to learn OpenCV for a while now and I came across Emgu.CV, a C# wrapper. Although the Emgu.CV is still under development, it has a many features that will make your work a lot easier if you’re doing a project in computer vision and image processing areas. Some of its capabilities enable you to develop web applications that can do processing of video and images via TCP/IP.

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.

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

Color filtering in Cielab color space
Image masking (as i call it)
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:

// background subtraction in cielab color space
private void CielabColorFilteringBGSubtraction(string filename, bool displayResult)
{
    // create new image from file
    Image rgbimage = new Imagebyte>(filename);

    // make a copy of the image in lab color space
    Image labimage = rgbimage.Convert();

    // get the width and size
    int width = labimage.Width;
    int height = labimage.Height;

    // get the filter range for each channel in lab color space
    IntRange l = new IntRange(Byte.Parse(min1TextBox.Text), Byte.Parse(max1TextBox.Text));
    IntRange a = new IntRange(Byte.Parse(min2TextBox.Text), Byte.Parse(max2TextBox.Text));
    IntRange b = new IntRange(Byte.Parse(min3TextBox.Text), Byte.Parse(max3TextBox.Text));

    // process each row in the image
    for (int i = 0; i < width; i++)
    {
        // process each pixel
        for (int j = 0; j < height; j++)
        {
            if (
                (labimage[j, i].X >=l.Max ) || (labimage[j, i].X <= l.Min) ||
                 (labimage[j, i].Y >= a.Max) || (labimage[j, i].Y <= a.Min) ||
                 (labimage[j, i].Z >= b.Max) || (labimage[j, i].Z <= b.Min)
                )
            {
                // if outside the filter range, set the pixel to black color
                rgbimage[j, i] = new Bgr(0, 0, 0);
            }
        }
    }

    // display
    if (displayResult) this.NewImage("Cielab-based background segmented image", rgbimage);
}

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:

// background subtraction by converting the RGB image to binary to create the mask
// then use this mask to copy foreground objects in the image
private void RGBImageMaskBGSubtraction(string filename, bool displayResult)
{
    // load the threshold value for grayscale image
    double threshold = double.Parse(max2TextBox.Text);

    // create new image
    Image img = new Imagebyte>(filename);

    //convert to grayscale
    Image gray = img.Convert();

    //convert to binary image using the threshold
    gray = gray.ThresholdBinary(new Gray(threshold), new Gray(255));

    // copy pixels from the original image where pixels in 
    // mask image is nonzero
    Image newimg = img.Copy(gray);

    // display result
    if (displayResult) this.NewImage("Background segmented", newimg);

}

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:

// background subtraction by extracting one channel in cielab image to 
 // create binary mask, and use this mask to copy foreground objects in 
 // the original image
 private void CielabChannelMaskBGSubtraction(string filename, bool displayResult)
 {
     double threshold = double.Parse(max2TextBox.Text);

     Imagebyte> rgb = new Imagebyte>(filename);
     Image img = rgb.Convert();

     //get the a* channel 
     Image gray = img[channel];

     //threshold and invert
     gray = gray.ThresholdBinary(new Gray(threshold), new Gray(255)).Not();

    // display the result
     if (displayResult) this.NewImage("Background segmented", image);
 }

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,

In Method 1, all three channels are used as filter ranges.
Method 2, uses channel 1(maximum) for grayscale threshold value
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.
I have included two images located in the source code folder for testing purposes.

Screenshot is given below:

[attachments force_saveas="0" logged_users="0"]

Share now!