C# How to: Standard Deviation Edge Detection

Article Purpose

This article explores detection implemented through computing neighbourhood on RGB  . The main sections of this article consists of a detailed explanation of the concepts related to the standard deviation edge detection algorithm and an in-depth discussion and a practical implementation through source code.

Butterfly Filter 3×3 Factor 5.0

Butterfly Filter 3x3 Factor 5.0

Sample Source Code

This article is accompanied by a sample source code Visual Studio project which is available for download .

Using the Sample Application

This article’s accompanying sample source code includes a based sample application. The sample application provides an implementation of the concepts explored by this article. Concepts discussed can be easily replicated and tested by using the sample application.

Source/input files can be specified from the local system when clicking the Load Image button. Additionally users also have the option to save resulting filtered by clicking the Save Image button.

The sample application user interface exposes three filter configuration values to the end user in the form of predefined filter size values, a output flag and a factor. End users can configure whether filtered result images should express using source colour values or in . The filter size value specified by the user determines the number of included when calculating values.

Filter size has a direct correlation to the extend at which gradient edges will be represented in resulting images. Faint edge values require larger filter size values in order to be expressed in a resulting output image. Larger filter size values require additional computation and would thus have a longer completion time when compared to smaller filter size values.

The following screenshot captures the Standard Deviation Edge Detection sample application in action.

Standard Deviation Edge Detection Screenshot

Standard Deviation

can be achieved through a variety of methods, each associated with particular benefits and trade offs. This article is focussed on through implementing calculations on a neighbourhood.

Pixel Neighbourhood

A pixel neighbourhood refers to a set of pixels, all of which are related through location coordinates. The width and height of a pixel neighbourhood must be equal, in other words, a pixel neighbourhood can only be square. Additionally, the width/height of a pixel neighbourhood must be an uneven value. When inspecting a pixel’s neighbouring pixels, the pixel being inspected will always be located at the exact center of the pixel neighbourhood. Only when a pixel neighbourhood’s width/height are an uneven value can such a pixel neighbourhood have an exact center pixel. Each pixel represented in an has a different set of neighbours, some neighbours overlap, but no two pixels have the exact same neighbours. A pixel’s neighbouring pixels can be determined when considering the pixel to be at the center of a block of pixels, extending half the neighbourhood size less one in horizontal, vertical and diagonal directions.

Butterfly Filter 3×3 Factor 5

Butterfly Filter 3x3 Factor 5

Pixel Neighbourhood Mean value

value calculation forms a core part in calculating . The mean value from a set of values could be considered equivalent to the value set’s average value. The average of a set of  values can be calculated as the sum total of all the values in a set, divided by the number of values in the set.

Standard Deviation

From the page we gain the following quote:

In statistics, the standard deviation (SD, also represented by the Greek letter sigma, σ for the population standard deviation or s for the sample standard deviation) is a measure that is used to quantify the amount of variation or dispersion of a set of data values. A standard deviation close to 0 indicates that the data points tend to be very close to the (also called the expected value) of the set, while a high standard deviation indicates that the data points are spread out over a wider range of values

A pixel neighbourhood’s can indicate whether a significant change in image gradient is present in a neighbourhood. A large value is an indication that the neighbourhood’s pixel values could be spread far from the calculated . Inversely, a small will indicate that the neighbourhood’s pixel values are closer to the calculated . A sudden change in image gradient will equate to a large standard deviation.

Steps required in calculating can be described as follows:

  1. Calculate the Mean value. Calculate the sum of all pixels in a pixel neighbourhood then divide the sum total using the number of pixels contained in a neighbourhood. In essence calculating the mean value should be seen as calculating the average of all the pixels in a neighbourhood.
  2. Calculate combined Variance using value. Subtract the mean value from each pixel in the neighbourhood, the result should be squared and added to a sum total. should then be calculated as the calculated mean subtracted squared pixel value divided using the number of pixels in a neighbourhood.
  3. Calculate as the Variance square root.

Butterfly Filter 3×3 Factor 5

Butterfly Filter 3x3 Factor 5

Standard Deviation Edge Detection Algorithm

The standard deviation edge detection algorithm is based in the concept of , providing additional capabilities. The algorithm allows for a more prominent expression of through means of a  variance factor. Calculated values can be increased or decreased when implementing a variance factor. When variances are less significant, resulting images will express gradient edges at faint/low intensity levels. Providing a factor will result in output images expressing gradient edges at a higher intensity.

factor and filter size should not be confused. When source gradient edges are expressed at low intensities, higher filter sizes would result in those low intensity source edges to be expressed in resulting images. In a scenario where high intensity gradient edges from a source are expressed in resulting images at low intensities, a higher factor would increase resulting edge intensity.

The following list provides a summary of the steps required  to implement the algorithm:

  1. Iterate through all of the pixels contained within an .
  2. For each pixel being iterated, determine the neighbouring pixels. The pixel neighbourhood size will be determined by the specified filter size.
  3. Calculate the Mean value of the current pixel neighbourhood.
  4. Calculate the Variance. Subtract the value from each neighbourhood pixel, the result should be squared and summed to a total value. Finally, the variance total value should be divided by the number of pixels that make up the pixel  neighbourhood. If a variance factor had been specified, the calculated variance value should be multiplied against it and the result assigned as the new calculated value.
  5. Calculate the Standard Deviation. Once the has been calculated the can be expressed as the square root of the calculated value. The value should be assigned to the result buffer pixel relating to the source buffer pixel currently being iterated.

It is important to note that the steps as described above should be applied per individual colour channel, Red, Green and Blue.

Butterfly Filter 3×3 Factor 4.5

Butterfly Filter 3x3 Factor 4.5

Implementing a Standard Deviation Edge Detection filter

The sample source code that accompanies this article provides a public targeting the class. A private overloaded implementation of the StandardDeviationEdgeDetection method performs the bulk of the required functionality. The following code snippet illustrates the public overloaded version of the StandardDeviationEdgeDetection method:

public static Bitmap StandardDeviationEdgeDetection(this Bitmap sourceBuffer, 
                                                    int filterSize, 
                                                    float varianceFactor = 1.0f, 
                                                    bool grayscaleOutput = true)
{
     return sourceBuffer.ToPixelBuffer()
                        .StandardDeviationEdgeDetection(sourceBuffer.Width, 
                                                        sourceBuffer.Height,
                                                        filterSize,
                                                        varianceFactor,
                                                        grayscaleOutput)
                         .ToBitmap(sourceBuffer.Width, sourceBuffer.Height);
}

The StandardDeviationEdgeDetection method accepts 3 parameters, the first parameter serves to signal that the method is an targeting the class. A brief description of the other parameters as follows:

  • filterSize determines the pixel neighbourhood size. Note that the parameter is expected to reflect the pixel neighbourhood width/height. As an example, a filterSize  parameter value provided as 3 would equate to a pixel neighbourhood consisting of 9 pixels, as would a filterSize of 5 indicate a neighbourhood of 25 pixels.
  • varianceFactor signifies the factor value applied to a calculated variance.
  • grayscale being a boolean value indicates whether the resulting should be represented in , or in the original colour values from the source .

Butterfly Filter 3×3 Factor 4 

Butterfly Filter 3x3 Factor 4

The following code snippet relates the private implementation of the StandardDeviationEdgeDetection method, which performs all of the tasks required to implement the standard deviation edge detection algorithm.

private static byte[] StandardDeviationEdgeDetection(this byte[] pixelBuffer, 
                                                     int imageWidth, 
                                                     int imageHeight,
                                                     int filterSize,
                                                     float varianceFactor = 1.0f,
                                                     bool grayscaleOutput = true)
{
    byte[] resultBuffer = new byte[pixelBuffer.Length];

    int filterOffset = (filterSize - 1) / 2;
    int calcOffset = 0;
    int stride = imageWidth * pixelByteCount;
            
    int byteOffset = 0;
    var neighbourCount = filterSize * filterSize;
            
    var blueNeighbours = new int[neighbourCount];
    var greenNeighbours = new int[neighbourCount];
    var redNeighbours = new int[neighbourCount];

    double resetValue = 0;
    double meanBlue = 0, meanGreen = 0, meanRed = 0;
    double varianceBlue = 0, varianceGreen = 0, varianceRed = 0;

    varianceFactor = varianceFactor * varianceFactor;

    for (int offsetY = filterOffset; offsetY <
        imageHeight - filterOffset; offsetY++)
    {
        for (int offsetX = filterOffset; offsetX <
            imageWidth - filterOffset; offsetX++)
        {
            byteOffset = offsetY *
                            stride +
                            offsetX * pixelByteCount;

            meanBlue = resetValue;
            meanGreen = resetValue;
            meanRed = resetValue;

            varianceBlue = resetValue;
            varianceGreen = resetValue;
            varianceRed = resetValue;

            for (int filterY = -filterOffset, neighbour = 0;
                filterY <= filterOffset; filterY++)
            {
                for (int filterX = -filterOffset;
                    filterX <= filterOffset; filterX++, neighbour++)
                {
                    calcOffset = byteOffset +
                                    (filterX * pixelByteCount) +
                                    (filterY * stride);

                    blueNeighbours[neighbour] = pixelBuffer[calcOffset];
                    greenNeighbours[neighbour] = pixelBuffer[calcOffset + 1];
                    redNeighbours[neighbour] = pixelBuffer[calcOffset + 2];
                }
            }

            meanBlue = blueNeighbours.Average();
            meanGreen = greenNeighbours.Average();
            meanRed = redNeighbours.Average();

            for (int n = 0; n < neighbourCount; n++)
            {
                varianceBlue = varianceBlue + 
                                SquareNumber(blueNeighbours[n] - meanBlue);
                varianceGreen = varianceGreen + 
                                SquareNumber(greenNeighbours[n] - meanGreen);
                varianceRed = varianceRed + 
                                SquareNumber(redNeighbours[n] - meanRed);
            }

            varianceBlue = varianceBlue / 
                            neighbourCount * 
                            varianceFactor;

            varianceGreen = varianceGreen /
                            neighbourCount * 
                            varianceFactor;

            varianceRed = varianceRed / 
                            neighbourCount * 
                            varianceFactor;

            if (grayscaleOutput)
            {
                var pixelValue = ByteVal(ByteVal(Math.Sqrt(varianceBlue)) |
                                         ByteVal(Math.Sqrt(varianceGreen)) | 
                                         ByteVal(Math.Sqrt(varianceRed)));

                resultBuffer[byteOffset] = pixelValue;
                resultBuffer[byteOffset + 1] = pixelValue;
                resultBuffer[byteOffset + 2] = pixelValue;
                resultBuffer[byteOffset + 3] = Byte.MaxValue;
            }
            else
            {
                resultBuffer[byteOffset] = ByteVal(Math.Sqrt(varianceBlue));
                resultBuffer[byteOffset + 1] = ByteVal(Math.Sqrt(varianceGreen));
                resultBuffer[byteOffset + 2] = ByteVal(Math.Sqrt(varianceRed));
                resultBuffer[byteOffset + 3] = Byte.MaxValue;
            }
        }
    }

    return resultBuffer;
}

This method features several for loops, resulting in each pixel being iterated. Notice how the two inner most loops declare negative initializer values. In order to determine a pixel’s neighbourhood, the pixel should be considered as being located at the exact center of the neighbourhood. Negative initializer values enable the code to determine neighbouring pixels located to the left and above of the pixel being iterated.

A pixel neighbourhood needs to be determined in terms of each colour channel, Red, Green and Blue. The pixel neighbourhood of each colour channel must be averaged individually.  Logically it follows that pixel neighbourhood should also be calculated per colour channel.

The method signature indicates the varianceFactor parameter should be optional and assigned a default value of 1.0. Should a variance factor not be required, implementing a default factor value of 1.0 will not result in any change to the calculated value.

Butterfly Filter 3x3 Factor 4

When output has been configured the resulting output pixel will express the same value on all three colour channels. The value will be calculated through the application of a bitwise OR operation, applied to the of each colour channel. The square root of a pixel neighbourhood’s provides the value for that pixel neighbourhood.

If output had not been configured the resulting pixel colour channels will be assigned the of the related colour channel on the source pixel.

private const byte maxByteValue = Byte.MaxValue;
private const byte minByteValue = Byte.MinValue;

public static byte ByteVal(int val)
{
    if (val < minByteValue) { return  minByteValue; }
    else if (val > maxByteValue) { return  maxByteValue; }
    else { return (byte)val; }
}

The StandardDeviationEdgeDetection method reflects several references to the ByteVal method, as illustrated in the code snippet above. Casting double and int values to values could result in values exceeding the upper and lower bounds allowed by the type. The ByteVal method tests whether a value would exceed upper and lower bounds, when determined to do so the resulting value is assigned either the upper inclusive bound or lower inclusive bound value, depending on the bound being exceeded.

Bee Filter 3×3 Factor 5

Bee Filter 3x3 Factor 5

Sample Images

This article features several sample images provided as examples. All sample images were created using the sample application. All of the original source images used in generating sample images have been licensed by their respective authors to allow for reproduction here. The following section lists each original source image and related license and copyright details.

Viceroy (Limenitis archippus), Mer Bleue Conservation Area, Ottawa, Ontario © 2008 D. Gordon E. Robertson is used here under a Creative Commons Attribution-Share Alike 3.0 Unported license.

Viceroy (Limenitis archippus), Mer Bleue Conservation Area, Ottawa, Ontario


Old World Swallowtail on Buddleja davidii © 2008 Thomas Bresson is used here under a Creative Commons Attribution 2.0 Generic license.Old World Swallowtail on Buddleja davidii


Cethosia cyane butterfly © 2006 Airbete is used here under a Creative Commons Attribution-Share Alike 3.0 Unported license.

Cethosia_cyane


“Weiße Baumnymphe (Idea leuconoe) fotografiert im Schmetterlingshaus des Maximilianpark Hamm”  © 2009 Steffen Flor is used here under a  Creative Commons Attribution-Share Alike 3.0 Unported license.

Weiße Baumnymphe (Idea leuconoe) fotografiert im Schmetterlingshaus des Maximilianpark Hamm


"Dark Blue Tiger tirumala septentrionis by kadavoor" © 2010 Jeevan Jose, Kerala, India is used here under a Creative Commons Attribution-ShareAlike 4.0 International License

Dark Blue Tiger tirumala septentrionis by kadavoor


"Common Lime Butterfly Papilio demoleus by Kadavoor" © 2010 Jeevan Jose, Kerala, India is used here under a Creative Commons Attribution-ShareAlike 4.0 International License

Common Lime Butterfly Papilio demoleus by Kadavoor


Syrphidae, Knüllwald, Hessen, Deutschland © 2007 Fritz Geller-Grimm is used here under a Creative Commons Attribution-Share Alike 3.0 Unported license

Syrphidae, Knüllwald, Hessen, Deutschland


Related Articles and Feedback

Feedback and questions are always encouraged. If you know of an alternative implementation or have ideas on a more efficient implementation please share in the comments section.

I’ve published a number of articles related to imaging and images of which you can find URL links here:

Advertisements

0 Responses to “C# How to: Standard Deviation Edge Detection”



  1. Leave a Comment

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s




Dewald Esterhuizen

Blog Stats

  • 464,106 hits

Enter your email address to follow and receive notifications of new posts by email.

Join 210 other followers

Archives

Twitter feed


%d bloggers like this: