Non-Photorealistic Rendering | Software by Default

Posts Tagged 'Non-Photorealistic Rendering'

C# How to: Image Distortion Blur

Article Purpose

This article explores the process of implementing an Image Distortion Blur filter. This image filter is classified as a non-photo realistic image filter, primarily implemented in rendering artistic effects.

Flower: Distortion Factor 15

Sample Source Code

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

Flower: Distortion Factor 10

Using the Sample Application

The sample source code that accompanies this article includes a Windows Forms based sample application. The concepts explored in this article have all been implemented as part of the sample application. From an end user perspective the following configurable options are available:

Load/Save Images – Clicking the Load Image button allows a user to specify a source/input image. If desired, output filtered images can be saved to the local file system by clicking the Save Image button.
Distortion Factor – The level or intensity of image distortion applied when implementing the filter can be specified when adjusting the Distortion Factor through the user interface. Lower factor values result in less distortion being evident in resulting images. Specifying higher factor values result in more intense image distortion being applied.

The following image is screenshot of the Image Distortion Blur sample application:

Flower: Distortion Factor 10

Flower: Distortion Factor 10

Image Distortion

In this article and the accompanying sample source code images are distorted through slightly adjusting each individual pixel’s coordinates. The direction and distance by which pixel coordinates are adjusted differ per pixel as a result of being randomly selected. The maximum distance offset applied depends on the user specified Distortion Factor. Once all pixel coordinates have been updated, implementing a Median Filter provides smoothing and an image blur effect.

Applying an Image Distortion Filter requires implementing the following steps:

Iterate Pixels – Each pixel forming part of the source/input image should be iterated.
Calculate new Coordinates – For every pixel being iterated generate two random values representing XY-coordinate offsets to be applied to a pixel’s current coordinates. Offset values can equate to less than zero in order to represent coordinates above or to the left of the current pixel.
Apply Median Filter – The newly offset pixels will appear somewhat speckled in the resulting image. Applying a Median Filter reduces the speckled appearance whilst retaining a distortion effect.

Flower: Distortion Factor 10

Median Filter

Applying a Median Filter is the final step required when implementing an Image Distortion Blur filter. Median Filters are often implemented in reducing image noise. The method of image distortion illustrated in this article express similarities when compared to image noise. In order to soften the appearance of image noise we implement a Median Filter.

A Median Filter can be applied through implementing the following steps:

Iterate Pixels – Each pixel forming part of the source/input image should be iterated.
Inspect Pixel Neighbourhood – Each neighbouring pixel in relation to the pixel currently being iterated should be added to a temporary collection.
Determine Neighbourhood Median – Once all neighbourhood pixels have been added to a temporary collection, sort the collection by value. The element value located at the middle of the collection represents the pixel neighbourhood’s Median value.

Flower: Distortion Factor 10

Flower: Distortion Factor 15

Implementing Image Distortion

The sample source code defines the DistortionBlurFilter method, an extension method targeting the Bitmap class. The following code snippet illustrates the implementation:

public static Bitmap DistortionBlurFilter( 
         this Bitmap sourceBitmap, int distortFactor) 
{
    byte[] pixelBuffer = sourceBitmap.GetByteArray(); 
    byte[] resultBuffer = sourceBitmap.GetByteArray(); 

 
    int imageStride = sourceBitmap.Width * 4; 
    int calcOffset = 0, filterY = 0, filterX = 0; 
    int factorMax = (distortFactor + 1) * 2; 
    Random rand = new Random(); 

 
    for (int k = 0; k + 4 < pixelBuffer.Length; k += 4) 
    {
        filterY = distortFactor - rand.Next(0, factorMax); 
        filterX = distortFactor - rand.Next(0, factorMax); 

 
        if (filterX * 4 + (k % imageStride) < imageStride  
                   && filterX * 4 + (k % imageStride) > 0) 
        { 
            calcOffset = k + filterY * imageStride +  
                         4 * filterX; 

 
            if (calcOffset >= 0 &&  
                calcOffset + 4 < resultBuffer.Length) 
            { 
                resultBuffer[calcOffset] = pixelBuffer[k]; 
                resultBuffer[calcOffset + 1] = pixelBuffer[k + 1]; 
                resultBuffer[calcOffset + 2] = pixelBuffer[k + 2]; 
            }
        }
    }

 
    return resultBuffer.GetImage(sourceBitmap.Width,  
                        sourceBitmap.Height).MedianFilter(3); 
}

Flower: Distortion Factor 15

Implementing a Median Filter

The MedianFilter extension method targets the Bitmap class. The implementation as follows:

public static Bitmap MedianFilter(this Bitmap sourceBitmap, 
                                  int matrixSize) 
{ 
    byte[] pixelBuffer = sourceBitmap.GetByteArray(); 
    byte[] resultBuffer = new byte[pixelBuffer.Length]; 
    byte[] middlePixel; 


    int imageStride = sourceBitmap.Width * 4; 
    int filterOffset = (matrixSize - 1) / 2; 
    int calcOffset = 0, filterY = 0, filterX = 0; 
    List<int> neighbourPixels = new List<int>(); 


    for (int k = 0; k + 4 < pixelBuffer.Length; k += 4) 
    { 
        filterY = -filterOffset; filterX = -filterOffset; 
        neighbourPixels.Clear(); 


        while (filterY <= filterOffset) 
        { 
            calcOffset = k + (filterX * 4) + 
            (filterY * imageStride); 


            if (calcOffset > 0 &&  
                calcOffset + 4 < pixelBuffer.Length) 
            { 
                neighbourPixels.Add(BitConverter.ToInt32( 
                                    pixelBuffer, calcOffset)); 
            } 


            filterX++; 


            if (filterX > filterOffset) 
             { filterX = -filterOffset; filterY++; }
        }


        neighbourPixels.Sort(); 
        middlePixel = BitConverter.GetBytes( 
                      neighbourPixels[filterOffset]); 


        resultBuffer[k] = middlePixel[0]; 
        resultBuffer[k + 1] = middlePixel[1]; 
        resultBuffer[k + 2] = middlePixel[2]; 
        resultBuffer[k + 3] = middlePixel[3]; 
    }


    return resultBuffer.GetImage(sourceBitmap.Width,  
                                 sourceBitmap.Height); 
}

Flower: Distortion Factor 25

Sample Images

This article features a number of sample images. All featured images have been licensed allowing for reproduction. The following images feature as sample images:

Lilium chalcedonicum in habitat at Hrisomiglia, Greece.
Attribution: Ernst Gügel. This file is licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license.
Download from Wikipedia

Lilium ponticum in habitat near Ikizdere, Turkey.
Attribution: Ernst Gügel. This file is licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license.
Download from Wikipedia

Lilium sargentiae flora.
Attribution: Denis Barthel. This file is licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license.
Download from Wikipedia

A lilium longiflorum, commonly known as an Easter Lily.
Attribution: Matt H. Wade. This file is licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license.
Download from Wikipedia

Flora Lilium bulbiferum ssp. croceum, ex coll. Monte Adone, Bologna, Italia.
Attribution: Denis Barthel. This file is licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license.
Download from Wikipedia

Turks Cap Lily the Great Smoky Mountains National Park in western North Carolina.
Attribution: Arx Fortis. This file is licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license.
Download from Wikipedia

Orange Lily in full bloom showing pollen covered stamens, Ontario, Canada. June 2002.
Attribution: Relic38. This file is licensed under the Creative Commons Attribution 3.0 Unported license.
Download from Wikipedia

Zantedeschia aethiopica (common names calla lily, arum lily).
Attribution: Two+two=4. This file has been released into the public domain. This applies worldwide.
Download from Wikipedia

C# How to: Fuzzy Blur Filter

Published August 9, 2013 Augmented Reality , C# , Code Samples , Edge Detection , Extension Methods , Graphic Filters , Graphics , How to , Image Convolution , Image Filters , Image Processing , Microsoft , Morphology Filters , New Version , Non-Photorealistic Rendering , Opensource , Tip , Update 3 Comments
Tags: Alpha Red Green Blue, Augmented Reality, Binary Image, Bitmap ARGB, Bitmap Filters, Bitmap.LockBits, BitmapData, Blur, Boolean Edge Detection, Box Blur, C#, Calculate Matrix, Calculating Kernels, Code Sample, Color Filters, Computer vision, Converting Images, Convolution filters, Convolution Kernel, Convolution matrix, Edge Detect, Edge Detection, Edge enhance, Edge Masks, Extension Methods, Feature extraction, Fuzzy Blur, Graphic Filters, How to, Image, Image Blur, Image Edge Detection, Image Intensity, Image Manipulation, Image processing, Image Transform, Machine vision, Morphologial Filters, Non-Photorealistic Rendering, Pixel Filters

Article Purpose

This article serves to illustrate the concepts involved in implementing a Fuzzy Blur Filter. This filter results in rendering non-photo realistic images which express a certain artistic effect.

Frog: Filter Size 19×19

Sample Source Code

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

Using the Sample Application

The sample source code accompanying this article includes a Windows Forms based test application. The concepts explored throughout this article can be replicated/tested using the sample application.

When executing the sample application the user interface exposes a number of configurable options:

Loading and Saving Images – Users are able to load source/input images from the local file system by clicking the Load Image button. Clicking the Save Image button allow users to save filter result images.
Filter Size – The specified filter size affects the filter intensity. Smaller filter sizes result in less blurry images being rendered, whereas larger filter sizes result in more blurry images being rendered.
Edge Factors – The contrast of fuzzy image noise expressed in resulting images depend on the specified edge factor values. Values less than one result in detected image edges being darkened and values greater than one result in detected image edges being lightened.

The following image is a screenshot of the Fuzzy Blur Filter sample application in action:

Frog: Filter Size 9×9

Fuzzy Blur Overview

The Fuzzy Blur Filter relies on the interference of image noise when performing edge detection in order to create a fuzzy effect. In addition image blurring results from performing a mean filter.

The steps involved in performing a Fuzzy Blur Filter can be described as follows:

Edge Detection and Enhancement – Using the first edge factor specified enhance image edges by performing Boolean Edge detection. Being sensitive to image noise, a fair amount of detected image edges will actually be image noise in addition to actual image edges.
Mean Filter Blur – Using the edge enhanced image created in the previous step perform a mean filter blur. The enhanced edges will be blurred since a Mean filter does not have edge preservation properties. The size of the Mean filter implemented depends on a user specified value.
Edge Detection and Enhancement – Using the Mean filter blurred image created in the previous step once again perform Boolean Edge detection, enhancing detected edges according to the second edge factor specified.

Frog: Filter Size 9×9

Mean Filter Blurring

A Mean Filter Blur, also known as a Box Blur, can be performed through image convolution. The size of the matrix/kernel implemented when preforming image convolution will be determined through user input.

Every matrix/kernel element should be set to one. The resulting value should be multiplied by a factor value equating to one divided by the matrix/kernel size. As an example, a matrix/kernel size of 3×3 can be expressed as follows:

An alternative expression can also be:

Frog: Filter Size 9×9

Boolean Edge Detection without a local threshold

When performing Boolean Edge Detection a local threshold should be implemented in order to exclude image noise. In this article we rely on the interference of image noise in order to render a fuzzy image effect. By not implementing a local threshold when performing Boolean Edge detection the sample source code ensures sufficient interference from image noise.

The steps involved in performing Boolean Edge Detection without a local threshold can be described as follows:

Calculate Neighbourhood Mean – Iterate each pixel forming part of the source/input image. Using a 3×3 matrix size calculate the mean value of the neighbourhood surrounding the pixel currently being iterated.
Create Mean comparison Matrix – Once again using a 3×3 matrix size compare each neighbourhood pixel to the newly calculated mean value. Create a temporary 3×3 size matrix, each matrix element’s value should be the result of mean comparison. Should the value expressed by a neighbourhood pixel exceed the mean value the corresponding temporary matrix element should be set to one. When the calculated mean value exceeds the value of a neighbourhood pixel the corresponding temporary matrix element should be set to zero.
Compare Edge Masks – Using sixteen predefined edge masks compare the temporary matrix created in the previous step to each edge mask. If the temporary matrix matches one of the predefined edge masks multiply the specified factor to the pixel currently being iterated.

Note: A detailed article on Boolean Edge detection implementing a local threshold can be found here: C# How to: Boolean Edge Detection

Frog: Filter Size 9×9

The sixteen predefined edge masks each represent an image edge in a different direction. The predefined edge masks can be expressed as:

Frog: Filter Size 13×13

Implementing a Mean Filter

The sample source code defines the MeanFilter method, an extension method targeting the Bitmap class. The definition listed as follows:

private static Bitmap MeanFilter(this Bitmap sourceBitmap, 
                                 int meanSize)
{
    byte[] pixelBuffer = sourceBitmap.GetByteArray(); 
    byte[] resultBuffer = new byte[pixelBuffer.Length];


    double blue = 0.0, green = 0.0, red = 0.0;
    double factor = 1.0 / (meanSize * meanSize);


    int imageStride = sourceBitmap.Width * 4;
    int filterOffset = meanSize / 2; 
    int calcOffset = 0, filterY = 0, filterX = 0; 


    for (int k = 0; k + 4 < pixelBuffer.Length; k += 4)
    {
        blue = 0; green = 0; red = 0;
        filterY = -filterOffset;
        filterX = -filterOffset;


        while (filterY <= filterOffset)
        {
            calcOffset = k + (filterX * 4) +
            (filterY * imageStride); 


            calcOffset = (calcOffset < 0 ? 0 :
            (calcOffset >= pixelBuffer.Length - 2 ?
            pixelBuffer.Length - 3 : calcOffset));


            blue += pixelBuffer[calcOffset];
            green += pixelBuffer[calcOffset + 1];
            red += pixelBuffer[calcOffset + 2];


            filterX++;


            if (filterX > filterOffset)
            {
                filterX = -filterOffset;
                filterY++;
            }
        }


        resultBuffer[k] = ClipByte(factor * blue);
        resultBuffer[k + 1] = ClipByte(factor * green);
        resultBuffer[k + 2] = ClipByte(factor * red);
        resultBuffer[k + 3] = 255;
    }


    return resultBuffer.GetImage(sourceBitmap.Width, sourceBitmap.Height);
}

Frog: Filter Size 19×19

Implementing Boolean Edge Detection

Boolean Edge detection is performed in the sample source code through the implementation of the BooleanEdgeDetectionFilter method. This method has been defined as an extension method targeting the Bitmap class.

The following code snippet provides the definition of the BooleanEdgeDetectionFilter extension method:

public static Bitmap BooleanEdgeDetectionFilter( 
       this Bitmap sourceBitmap, float edgeFactor) 
{
    byte[] pixelBuffer = sourceBitmap.GetByteArray(); 
    byte[] resultBuffer = new byte[pixelBuffer.Length]; 
    Buffer.BlockCopy(pixelBuffer, 0, resultBuffer, 
                     0, pixelBuffer.Length); 


    List<string> edgeMasks = GetBooleanEdgeMasks(); 
 
    int imageStride = sourceBitmap.Width * 4; 
    int matrixMean = 0, pixelTotal = 0; 
    int filterY = 0, filterX = 0, calcOffset = 0; 
    string matrixPatern = String.Empty; 


    for (int k = 0; k + 4 < pixelBuffer.Length; k += 4) 
    {
        matrixPatern = String.Empty; 
        matrixMean = 0; pixelTotal = 0; 
        filterY = -1; filterX = -1; 


        while (filterY < 2) 
        {
            calcOffset = k + (filterX * 4) + 
            (filterY * imageStride); 


            calcOffset = (calcOffset < 0 ? 0 : 
            (calcOffset >= pixelBuffer.Length - 2 ? 
            pixelBuffer.Length - 3 : calcOffset)); 
 
            matrixMean += pixelBuffer[calcOffset]; 
            matrixMean += pixelBuffer[calcOffset + 1]; 
            matrixMean += pixelBuffer[calcOffset + 2]; 


            filterX += 1; 


            if (filterX > 1) 
             { filterX = -1; filterY += 1; } 
        }


        matrixMean = matrixMean / 9; 
        filterY = -1; filterX = -1; 


        while (filterY < 2) 
        {
            calcOffset = k + (filterX * 4) + 
            (filterY * imageStride); 


            calcOffset = (calcOffset < 0 ? 0 : 
            (calcOffset >= pixelBuffer.Length - 2 ? 
            pixelBuffer.Length - 3 : calcOffset)); 


            pixelTotal = pixelBuffer[calcOffset]; 
            pixelTotal += pixelBuffer[calcOffset + 1]; 
            pixelTotal += pixelBuffer[calcOffset + 2]; 
 
            matrixPatern += (pixelTotal > matrixMean 
                                       ? "1" : "0"); 
            filterX += 1; 


            if (filterX > 1) 
            { filterX = -1; filterY += 1; } 
        } 


        if (edgeMasks.Contains(matrixPatern)) 
        {
            resultBuffer[k] = 
            ClipByte(resultBuffer[k] * edgeFactor); 


            resultBuffer[k + 1] = 
            ClipByte(resultBuffer[k + 1] * edgeFactor); 


            resultBuffer[k + 2] = 
            ClipByte(resultBuffer[k + 2] * edgeFactor); 
        }
    }


    return resultBuffer.GetImage(sourceBitmap.Width, sourceBitmap.Height); 
}

Frog: Filter Size 13×13

The predefined edge masks implemented in mean comparison have been wrapped by the GetBooleanEdgeMasks method. The definition as follows:

public static List<string> GetBooleanEdgeMasks() 
{
    List<string> edgeMasks = new List<string>(); 


    edgeMasks.Add("011011011"); 
    edgeMasks.Add("000111111"); 
    edgeMasks.Add("110110110"); 
    edgeMasks.Add("111111000"); 
    edgeMasks.Add("011011001"); 
    edgeMasks.Add("100110110"); 
    edgeMasks.Add("111011000"); 
    edgeMasks.Add("111110000"); 
    edgeMasks.Add("111011001"); 
    edgeMasks.Add("100110111"); 
    edgeMasks.Add("001011111"); 
    edgeMasks.Add("111110100"); 
    edgeMasks.Add("000011111"); 
    edgeMasks.Add("000110111"); 
    edgeMasks.Add("001011011"); 
    edgeMasks.Add("110110100"); 


    return edgeMasks; 
}

Frog: Filter Size 19×19

Implementing a Fuzzy Blur Filter

The FuzzyEdgeBlurFilter method serves as the implementation of a Fuzzy Blur Filter. As discussed earlier a Fuzzy Blur Filter involves enhancing image edges through Boolean Edge detection, performing a Mean Filter blur and then once again performing Boolean Edge detection. This method has been defined as an extension method targeting the Bitmap class.

The following code snippet provides the definition of the FuzzyEdgeBlurFilter method:

public static Bitmap FuzzyEdgeBlurFilter(this Bitmap sourceBitmap,  
                                         int filterSize,  
                                         float edgeFactor1,  
                                         float edgeFactor2) 
{
    return  
    sourceBitmap.BooleanEdgeDetectionFilter(edgeFactor1). 
    MeanFilter(filterSize).BooleanEdgeDetectionFilter(edgeFactor2); 
}

Frog: Filter Size 3×3

Sample Images

This article features a number of sample images. All featured images have been licensed allowing for reproduction. The following images feature as sample images:

Tyler’s Tree Frog
Attribution: LiquidGhoul. This file has been released into the public domain by its author, LiquidGhoul. This applies worldwide.
Download from Wikipedia.

Phyllobates Terribilis
Attribution: Wilfried Berns. This file is licensed under the Creative Commons Attribution-Share Alike 2.0 Germany license.
Download from Wikipedia.

Dendropsophus Microcephalus
Attribution: Brian Gratwicke. This file is licensed under the Creative Commons Attribution 2.0 Generic license.
Download from Wikipedia

Panamanian Golden Frog
Attribution: Brian Gratwicke. This file is licensed under the Creative Commons Attribution 2.0 Generic license.
Download from Wikipedia.

C# How to: Image Abstract Colours Filter

Published July 28, 2013 Augmented Reality , Blogging , C# , Code Samples , Edge Detection , Extension Methods , Graphic Filters , How to , Image Arithmetic , Image Filtering , Image Filters , Image Processing , Image Transform , Learn Everyday , Microsoft , New Version , Non-Photorealistic Rendering , Opensource , Tip , Update 4 Comments
Tags: Augmented Reality, Binary Image, Bitmap ARGB, Bitmap Filters, Bitmap.LockBits, BitmapData, C#, Code Sample, Color Averaging, Color Filters, Computer vision, Converting Images, Edge Detect, Edge Detection, Feature extraction, Graphic Filters, Image, Image Intensity, Image processing, Image Transform, Machine vision, Non-Photorealistic Rendering, Pixel Filters

Article Purpose

This article explores Abstract Colour Image filters as a process of Non-photo Realistic Image Rendering. The output images produced reflects a variety of artistic effects.

Colour Values	Red, Blue	Filter Size	9
Edge Tracing	Black	Edge Threshold	55

Sample Source Code

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

Colour Values	Blue	Filter Size	9
Edge Tracing	Double Intensity	Edge Threshold	60

Using the Sample Application

The sample source code that accompanies this article includes a Windows Forms based sample application. The concepts discussed in this article have been illustrated through the implementation of the sample application.

When executing the sample application, through the user interface several options are made available to the user, described as follows:

Load/Save Images – Source/input images may be loaded from the local file system through clicking the Load Image button. If desired by the user, resulting output images can be saved to the local file system through clicking the Save Image button.
Colour Channels – The colour values Red, Green and Blue can be updated or remain unchanged when applying a filter, indicated through the associated Checkboxes.
Filter Size – The level of filter intensity depends on the size of the filter. Larger filter sizes result in more intense filtering being applied. Smaller filter size result in less intense filtering being applied.
Colour Shift Type – Colour intensity values can be swapped around through selecting the Colour Shift type: Shift Left and Shift Right.
Edge Tracing Type – When applying a filter the edges forming part of the original source/input image will be expressed as part of the output image. The method in which image edges are indicated/highlighted will be determined through the type of Edge Tracing specified when applying the filter. Supported types of Edge Tracing include: Black, White, Half Intensity, Double Intensity and Inverted.
Edge Threshold – Edges forming part of the source/input image are determines through means of image edge detection implementing a threshold value. Lower threshold values result in more emphasized edges expressed within resulting images. Higher threshold values reduce edge emphasis in resulting images.

Colour Values	Green	Filter Size	9
Edge Tracing	Double Intensity	Edge Threshold	60

Colour Values	Red, Blue	Filter Size	9
Edge Tracing	Double Intensity	Edge Threshold	55

The following image is a screenshot of the Image Abstract Colour Filter sample application in action:

Abstracting Image Colours

The Abstract Colour Filter explored in this article can be considered a non-photo realistic filter. As the title implies, non-photo realistic filters transforms an input image, usually a photograph, producing a result image which visibly lacks the aspects of realism expressed in the input image. In most scenarios the objective of non-photo realistic filters can be described as using photographic images in rendering images having an animated appearance.

Colour Values	Blue	Filter Size	11
Edge Tracing	Double Intensity	Edge Threshold	60

Colour Values	Red	Filter Size	11
Edge Tracing	Double Intensity	Edge Threshold	60

The Abstract Colour Filter can be broken down into two main components: Colour Averaging and Image Edge detection. Through implementing a variety of colour averaging algorithms resulting images express abstract yet uniform colours. Abstract colours result in output images no longer appearing photo realistic, instead output images appear unconventionally augmented/artistic.

Output images express a lesser degree of image definition and detail, when compared to input images. In some scenarios output images might not be easily recognisable. In order to retain some image detail, edge/boundary detail detected from input images will be emphasised in result images.

Colour Values	Green	Filter Size	11
Edge Tracing	Double Intensity	Edge Threshold	60

Colour Values	Green, Blue	Filter Size	11
Edge Tracing	Double Intensity	Edge Threshold	75

The steps required when applying an Abstract Colour Filter can be described as follows:

Perform Edge Detection – Using the source/input image perform edge detection, producing a binary image expressing image edges in the foreground/as white.
Calculate Pixel Neighbourhood Colour Averages – Iterate each pixel forming part of the input image, inspecting the pixel’s neighbouring pixels. Calculate the sum total and average of each colour channel, Red, Green and Blue. The value of the pixel currently being iterated should be set depending to neighbourhood average.
Trace Edges within Colour Averages – Simultaneously iterate the colour average image and the edge detected image. If the pixel being iterated forms part of an edge, update the corresponding pixel in the average colour image, depending on the specified method of Edge Tracing.

Colour Values	Red, Green	Filter Size	11
Edge Tracing	Double Intensity	Edge Threshold	75

Colour Values	Red	Filter Size	11
Edge Tracing	Black	Edge Threshold	60

Implementing Pixel Neighbourhood Colour Averaging

In the sample source code neighbourhood colour averaging has been implemented through the definition of the AverageColoursFilter extension method. This method creates a new image using the source image as input. The following code snippet provides the definition:

public static Bitmap AverageColoursFilter(this Bitmap sourceBitmap,  
                                          int matrixSize,   
                                          bool applyBlue = true, 
                                          bool applyGreen = true, 
                                          bool applyRed = true, 
                                          ColorShiftType shiftType = 
                                          ColorShiftType.None)  
{
    byte[] pixelBuffer = sourceBitmap.GetByteArray(); 
    byte[] resultBuffer = new byte[pixelBuffer.Length]; 

 
    int calcOffset = 0; 
    int byteOffset = 0; 
    int blue = 0; int green = 0; int red = 0; 
    int filterOffset = (matrixSize - 1) / 2; 

 
    for (int offsetY = filterOffset; offsetY <  
        sourceBitmap.Height - filterOffset; offsetY++) 
    {
        for (int offsetX = filterOffset; offsetX <  
            sourceBitmap.Width - filterOffset; offsetX++) 
        { 
            byteOffset = offsetY * sourceBitmap.Width*4 +  
                         offsetX * 4; 

 
            blue = 0; green = 0; red = 0; 

 
            for (int filterY = -filterOffset;  
                filterY <= filterOffset; filterY++) 
            { 
                for (int filterX = -filterOffset; 
                    filterX <= filterOffset; filterX++) 
                { 
                    calcOffset = byteOffset +  
                    (filterX * 4) + 
                    (filterY * sourceBitmap.Width * 4); 

 
                    blue += pixelBuffer[calcOffset]; 
                    green += pixelBuffer[calcOffset + 1]; 
                    red += pixelBuffer[calcOffset + 2]; 
                }
            }

 
            blue = blue / matrixSize; 
            green = green / matrixSize; 
            red = red / matrixSize; 

 
            if (applyBlue == false ) 
            { blue = pixelBuffer[byteOffset]; } 

 
            if (applyGreen == false ) 
            { green = pixelBuffer[byteOffset + 1]; } 

 
            if (applyRed == false ) 
            { red = pixelBuffer[byteOffset + 2]; } 

 
            if (shiftType == ColorShiftType.None) 
            {
                resultBuffer[byteOffset] = (byte)blue; 
                resultBuffer[byteOffset + 1] = (byte)green; 
                resultBuffer[byteOffset + 2] = (byte)red; 
                resultBuffer[byteOffset + 3] = 255; 
            }
            else if (shiftType == ColorShiftType.ShiftLeft) 
            {
                resultBuffer[byteOffset] = (byte)green; 
                resultBuffer[byteOffset + 1] = (byte)red; 
                resultBuffer[byteOffset + 2] = (byte)blue; 
                resultBuffer[byteOffset + 3] = 255; 
            }
            else if (shiftType == ColorShiftType.ShiftRight) 
            { 
                resultBuffer[byteOffset] = (byte)red; 
                resultBuffer[byteOffset + 1] = (byte)blue; 
                resultBuffer[byteOffset + 2] = (byte)green; 
                resultBuffer[byteOffset + 3] = 255; 
            } 
        }
    } 

 
    Bitmap resultBitmap = new Bitmap(sourceBitmap.Width,  
                                     sourceBitmap.Height); 

 
    BitmapData resultData =  
               resultBitmap.LockBits(new Rectangle (0, 0, 
               resultBitmap.Width, resultBitmap.Height), 
               ImageLockMode.WriteOnly, 
               PixelFormat.Format32bppArgb); 

 
    Marshal.Copy(resultBuffer, 0, resultData.Scan0,  
                               resultBuffer.Length); 

 
    resultBitmap.UnlockBits(resultData); 

 
    return resultBitmap; 
}

Colour Values	Green, Blue	Filter Size	17
Edge Tracing	Black	Edge Threshold	85

Implementing Gradient Based Edge Detection

When applying an Abstract Colours Filter, one of the required steps involve image edge detection. The sample source code implements Gradient based edge detection through the definition of the GradientBasedEdgeDetectionFilter method. This method has been defined as an extension method targeting the bitmap class. The definition as follows:

public static Bitmap GradientBasedEdgeDetectionFilter( 
                        this Bitmap sourceBitmap, 
                        byte threshold = 0) 
{
    BitmapData sourceData = 
               sourceBitmap.LockBits(new Rectangle (0, 0, 
               sourceBitmap.Width, sourceBitmap.Height), 
               ImageLockMode.ReadOnly, 
               PixelFormat.Format32bppArgb); 

 
    byte[] pixelBuffer = new byte[sourceData.Stride * sourceData.Height]; 
    byte[] resultBuffer = new byte[sourceData.Stride * sourceData.Height]; 

 
    Marshal.Copy(sourceData.Scan0, pixelBuffer, 0, pixelBuffer.Length); 
    sourceBitmap.UnlockBits(sourceData); 

 
    int sourceOffset = 0, gradientValue = 0; 
    bool exceedsThreshold = false; 

 
    for (int offsetY = 1; offsetY <  
                          sourceBitmap.Height - 1; offsetY++) 
     {
        for (int offsetX = 1; offsetX <  
                              sourceBitmap.Width - 1; offsetX++) 
         { 
            sourceOffset = offsetY * sourceData.Stride + 
                           offsetX * 4; 
            gradientValue = 0; 
            exceedsThreshold = true; 

 
            // Horizontal Gradient 
            CheckThreshold(pixelBuffer, 
                           sourceOffset - 4, 
                           sourceOffset + 4, 
                           ref gradientValue, threshold, 2); 
            // Vertical Gradient 
            exceedsThreshold = 
            CheckThreshold(pixelBuffer, 
                           sourceOffset - sourceData.Stride, 
                           sourceOffset + sourceData.Stride, 
                           ref gradientValue, threshold, 2); 

 
            if (exceedsThreshold == false) 
             { 
                gradientValue = 0; 

 
                // Horizontal Gradient 
                exceedsThreshold = 
                CheckThreshold(pixelBuffer, 
                               sourceOffset - 4, 
                               sourceOffset + 4, 
                               ref gradientValue, threshold); 


                if (exceedsThreshold == false) 
                 { 
                    gradientValue = 0; 


                    // Vertical Gradient 
                    exceedsThreshold = 
                    CheckThreshold(pixelBuffer, 
                                   sourceOffset - sourceData.Stride, 
                                   sourceOffset + sourceData.Stride, 
                                   ref gradientValue, threshold); 


                    if (exceedsThreshold == false) 
                     {
                        gradientValue = 0; 


                        // Diagonal Gradient : NW-SE 
                        CheckThreshold(pixelBuffer, 
                                       sourceOffset - 4 - sourceData.Stride, 
                                       sourceOffset + 4 + sourceData.Stride, 
                                       ref gradientValue, threshold, 2); 
                        // Diagonal Gradient : NE-SW 
                        exceedsThreshold = 
                        CheckThreshold(pixelBuffer, 
                                       sourceOffset - sourceData.Stride + 4, 
                                       sourceOffset - 4 + sourceData.Stride, 
                                       ref gradientValue, threshold, 2); 


                        if (exceedsThreshold == false) 
                         {
                            gradientValue = 0; 


                            // Diagonal Gradient : NW-SE 
                            exceedsThreshold = 
                            CheckThreshold(pixelBuffer, 
                                           sourceOffset - 4 - sourceData.Stride, 
                                           sourceOffset + 4 + sourceData.Stride, 
                                           ref gradientValue, threshold); 


                            if (exceedsThreshold == false) 
                             {
                                gradientValue = 0; 


                                // Diagonal Gradient : NE-SW 
                                exceedsThreshold = 
                                CheckThreshold(pixelBuffer, 
                                               sourceOffset - sourceData.Stride + 4, 
                                               sourceOffset + sourceData.Stride - 4, 
                                               ref gradientValue, threshold); 
                             } 
                         }
                     }
                 } 
             }


            resultBuffer[sourceOffset] = (byte)(exceedsThreshold ? 255 : 0); 
            resultBuffer[sourceOffset + 1] = resultBuffer[sourceOffset]; 
            resultBuffer[sourceOffset + 2] = resultBuffer[sourceOffset]; 
            resultBuffer[sourceOffset + 3] = 255; 
         } 
     }


    Bitmap resultBitmap = new Bitmap(sourceBitmap.Width, sourceBitmap.Height); 


    BitmapData resultData = resultBitmap.LockBits(new Rectangle (0, 0, 
                            resultBitmap.Width, resultBitmap.Height), 
                            ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb); 


    Marshal.Copy(resultBuffer, 0, resultData.Scan0, resultBuffer.Length); 
    resultBitmap.UnlockBits(resultData); 


    return resultBitmap; 
}

Colour Values	Red, Green	Filter Size	5
Edge Tracing	Black	Edge Threshold	85

Implementing an Abstract Colour Filter

The AbstractColorsFilter method serves as means of combining an average colour image and an edge detected image. This extension method targets the Bitmap class. The following code snippet details the definition:

public static Bitmap AbstractColorsFilter(this Bitmap sourceBitmap, 
                                          int matrixSize, 
                                          byte edgeThreshold, 
                                          bool applyBlue = true, 
                                          bool applyGreen = true, 
                                          bool applyRed = true, 
                                          EdgeTracingType edgeType =  
                                          EdgeTracingType.Black, 
                                          ColorShiftType shiftType = 
                                          ColorShiftType.None) 
{ 
    Bitmap edgeBitmap =  
    sourceBitmap.GradientBasedEdgeDetectionFilter(edgeThreshold); 

  
    Bitmap colorBitmap =  
    sourceBitmap.AverageColoursFilter(matrixSize,  
                 applyBlue, applyGreen, applyRed, shiftType); 

  
    byte[] edgeBuffer = edgeBitmap.GetByteArray(); 
    byte[] colorBuffer = colorBitmap.GetByteArray(); 
    byte[] resultBuffer = colorBitmap.GetByteArray(); 

  
    for (int k = 0; k + 4 < edgeBuffer.Length; k += 4) 
    {
        if (edgeBuffer[k] == 255) 
        { 
            switch (edgeType) 
            {
                case EdgeTracingType.Black: 
                    resultBuffer[k] = 0; 
                    resultBuffer[k+1] = 0; 
                    resultBuffer[k+2] = 0; 
                    break; 
                case EdgeTracingType.White: 
                    resultBuffer[k] = 255; 
                    resultBuffer[k+1] = 255; 
                    resultBuffer[k+2] = 255; 
                    break; 
                case EdgeTracingType.HalfIntensity: 
                    resultBuffer[k] = ClipByte(resultBuffer[k] * 0.5); 
                    resultBuffer[k + 1] = ClipByte(resultBuffer[k + 1] * 0.5); 
                    resultBuffer[k + 2] = ClipByte(resultBuffer[k + 2] * 0.5); 
                    break; 
                case EdgeTracingType.DoubleIntensity: 
                    resultBuffer[k] = ClipByte(resultBuffer[k] * 2); 
                    resultBuffer[k + 1] = ClipByte(resultBuffer[k + 1] * 2); 
                    resultBuffer[k + 2] = ClipByte(resultBuffer[k + 2] * 2); 
                    break; 
                case EdgeTracingType.ColorInversion: 
                    resultBuffer[k] = ClipByte(255 - resultBuffer[k]); 
                    resultBuffer[k+1] = ClipByte(255 - resultBuffer[k+1]); 
                    resultBuffer[k+2] = ClipByte(255 - resultBuffer[k+2]); 
                    break; 
            }
        }
    }

  
    Bitmap resultBitmap = new Bitmap (sourceBitmap.Width, 
                                    sourceBitmap.Height); 

  
    BitmapData resultData = 
               resultBitmap.LockBits(new Rectangle (0, 0, 
               resultBitmap.Width, resultBitmap.Height), 
               ImageLockMode.WriteOnly, 
               PixelFormat.Format32bppArgb); 

  
    Marshal.Copy(resultBuffer, 0, resultData.Scan0, 
                               resultBuffer.Length); 

  
    resultBitmap.UnlockBits(resultData); 

  
    return resultBitmap; 
}

Colour Values	Red, Green	Filter Size	17
Edge Tracing	Double Intensity	Edge Threshold	85

Sample Images

This article features a number of sample images. All featured images have been licensed allowing for reproduction. The following images feature as sample images:

Fruit bodies of the agaric fungus Mycena atkinsoniana A.H. Sm. Specimens photographed in Strouds Run State Park, Athens, Ohio, USA
Attributed to: Dan Molter. This file is licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license.
Download from Wikipedia

The "indigo Lactarius", species Lactarius indigo (Schwein.) Fr. Specimen photographed in Strouds Run State Park, Athens, Ohio, USA.
Attributed to: Dan Molter. This file is licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license.
Download from Wikipedia