From 591d9b8a7c6d4bc45b1176f1b998ab0143521040 Mon Sep 17 00:00:00 2001
From: James South <james_south@hotmail.com>
Date: Tue, 31 Dec 2013 14:44:27 +0000
Subject: [PATCH] Adding blur and sharpen

Former-commit-id: 3e988b0d327e4572f9ef3979cdfce5251ade3bd1
---
 src/ImageProcessor/ImageFactory.cs            |  28 +
 src/ImageProcessor/ImageProcessor.csproj      |  10 +-
 src/ImageProcessor/Imaging/Convolution.cs     | 499 ++++++++++++++++++
 .../Imaging/Filters/ComicMatrixFilter.cs      |  13 +-
 src/ImageProcessor/Imaging/GaussianLayer.cs   | 179 +++++++
 src/ImageProcessor/Imaging/Pixel.cs           |  38 ++
 src/ImageProcessor/Processors/Crop.cs         |   1 +
 src/ImageProcessor/Processors/GaussianBlur.cs | 267 ++++------
 .../Processors/GaussianSharpen.cs             | 227 ++++++++
 .../Images/Thumbs.db.REMOVED.git-id           |   1 -
 .../Test_Website_NET45/Images/sample1.jpg     | Bin 0 -> 33850 bytes
 .../NET45/Test_Website_NET45/Images/text.png  | Bin 0 -> 7317 bytes
 .../Views/Home/Index.cshtml                   |   4 +-
 .../config/imageprocessor/processing.config   |  14 +
 14 files changed, 1108 insertions(+), 173 deletions(-)
 create mode 100644 src/ImageProcessor/Imaging/Convolution.cs
 create mode 100644 src/ImageProcessor/Imaging/GaussianLayer.cs
 create mode 100644 src/ImageProcessor/Imaging/Pixel.cs
 create mode 100644 src/ImageProcessor/Processors/GaussianSharpen.cs
 delete mode 100644 src/TestWebsites/NET45/Test_Website_NET45/Images/Thumbs.db.REMOVED.git-id
 create mode 100644 src/TestWebsites/NET45/Test_Website_NET45/Images/sample1.jpg
 create mode 100644 src/TestWebsites/NET45/Test_Website_NET45/Images/text.png

diff --git a/src/ImageProcessor/ImageFactory.cs b/src/ImageProcessor/ImageFactory.cs
index e6bf4609f..adcfb9178 100644
--- a/src/ImageProcessor/ImageFactory.cs
+++ b/src/ImageProcessor/ImageFactory.cs
@@ -323,6 +323,34 @@ namespace ImageProcessor
             return this;
         }
 
+        /// <summary>
+        /// Applies a Gaussian blur to the current image.
+        /// </summary>
+        /// <param name="radius">
+        /// The radius by which to blur the images pixels.
+        /// Any integer between 0 and 100.
+        /// </param>
+        /// <returns>
+        /// The current instance of the <see cref="T:ImageProcessor.ImageFactory"/> class.
+        /// </returns>
+        public ImageFactory Blur(int radius)
+        {
+            if (this.ShouldProcess)
+            {
+                // Sanitize the input.
+                if (radius > 100)
+                {
+                    radius = 0;
+                }
+
+                GaussianBlur blur = new GaussianBlur { DynamicParameter = radius };
+
+                this.Image = blur.ProcessImage(this);
+            }
+
+            return this;
+        }
+
         /// <summary>
         /// Constrains the current image, resizing it to fit within the given dimensions whilst keeping its aspect ratio.
         /// </summary>
diff --git a/src/ImageProcessor/ImageProcessor.csproj b/src/ImageProcessor/ImageProcessor.csproj
index 1d62f5252..236724acd 100644
--- a/src/ImageProcessor/ImageProcessor.csproj
+++ b/src/ImageProcessor/ImageProcessor.csproj
@@ -12,6 +12,8 @@
     <AssemblyName>ImageProcessor</AssemblyName>
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
+    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
+    <RestorePackages>true</RestorePackages>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -57,11 +59,15 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="ExtBitmap.cs" />
     <Compile Include="Helpers\Extensions\ImageExtensions.cs" />
     <Compile Include="Helpers\Extensions\EnumExtensions.cs" />
     <Compile Include="Helpers\Extensions\StringExtensions.cs" />
     <Compile Include="ImageFactory.cs" />
     <Compile Include="Imaging\AnchorPosition.cs" />
+    <Compile Include="Imaging\Convolution.cs" />
+    <Compile Include="Imaging\GaussianLayer.cs" />
+    <Compile Include="Imaging\Pixel.cs" />
     <Compile Include="Imaging\ColorQuantizer.cs" />
     <Compile Include="Imaging\ResizeLayer.cs" />
     <Compile Include="Imaging\Filters\BlackWhiteMatrixFilter.cs" />
@@ -83,8 +89,10 @@
     <Compile Include="Imaging\RoundedCornerLayer.cs" />
     <Compile Include="Imaging\TextLayer.cs" />
     <Compile Include="Processors\Alpha.cs" />
+    <Compile Include="Processors\GaussianBlur.cs" />
     <Compile Include="Processors\Brightness.cs" />
     <Compile Include="Processors\Contrast.cs" />
+    <Compile Include="Processors\GaussianSharpen.cs" />
     <Compile Include="Processors\RoundedCorners.cs" />
     <Compile Include="Processors\Saturation.cs" />
     <Compile Include="Processors\Flip.cs" />
@@ -99,8 +107,8 @@
     <Compile Include="Processors\Watermark.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
-  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <Import Project="$(SolutionDir)\.nuget\NuGet.targets" Condition="Exists('$(SolutionDir)\.nuget\NuGet.targets')" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/src/ImageProcessor/Imaging/Convolution.cs b/src/ImageProcessor/Imaging/Convolution.cs
new file mode 100644
index 000000000..61187eb4f
--- /dev/null
+++ b/src/ImageProcessor/Imaging/Convolution.cs
@@ -0,0 +1,499 @@
+// --------------------------------------------------------------------------------------------------------------------
+// <copyright file="Convolution.cs" company="James South">
+//   Copyright (c) James South.
+//   Licensed under the Apache License, Version 2.0.
+// </copyright>
+// <summary>
+//   Provides methods for applying blurring and sharpening effects to an image..
+// </summary>
+// --------------------------------------------------------------------------------------------------------------------
+
+namespace ImageProcessor.Imaging
+{
+    using System;
+    using System.Drawing;
+    using System.Drawing.Imaging;
+    using System.Runtime.InteropServices;
+
+    /// <summary>
+    /// Provides methods for applying blurring and sharpening effects to an image..
+    /// </summary>
+    public class Convolution
+    {
+        /// <summary>
+        /// The standard deviation 'sigma' value for calculating Gaussian curves.
+        /// </summary>
+        private readonly double standardDeviation = 1.4;
+
+        /// <summary>
+        /// Whether to use use dynamic divider for edges.
+        /// </summary>
+        private bool useDynamicDividerForEdges = true;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Convolution"/> class.
+        /// </summary>
+        public Convolution()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Convolution"/> class.
+        /// </summary>
+        /// <param name="standardDeviation">
+        /// The standard deviation.
+        /// </param>
+        public Convolution(double standardDeviation)
+        {
+            this.standardDeviation = standardDeviation;
+        }
+
+        /// <summary>
+        /// Gets or sets the threshold to add to the weighted sum.
+        /// <remarks>
+        /// <para>
+        /// Specifies the threshold value, which is added to each weighted
+        /// sum of pixels.
+        /// </para>
+        /// </remarks>
+        /// </summary>
+        public int Threshold { get; set; }
+
+        /// <summary>
+        /// Gets or sets the value used to divide convolution; the weighted sum
+        /// of pixels is divided by this value.
+        /// <remarks>
+        /// <para>If not set this value will be automatically calculated.</para>
+        /// </remarks>
+        /// </summary>
+        public double Divider { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether to use the dynamic divider for edges.
+        /// <remarks>
+        /// <para>
+        /// If it is set to <see langword="false" />, then the same divider, specified by <see cref="Divider" />
+        /// property or calculated automatically, will be applied both for non-edge regions
+        /// and for edge regions. If the value is set to <see langword="true" />, then the dynamically
+        /// calculated divider will be used for edge regions. This is calculated from the sum of the kernel
+        /// elements used at that region, which are taken into account for particular processed pixel
+        /// (elements, which are not outside image).
+        /// </para>
+        /// <para>Default value is set to <see langword="true" />.</para>
+        /// </remarks>
+        /// </summary>
+        public bool UseDynamicDividerForEdges
+        {
+            get
+            {
+                return this.useDynamicDividerForEdges;
+            }
+
+            set
+            {
+                this.useDynamicDividerForEdges = value;
+            }
+        }
+
+        /// <summary>
+        /// Create a 1 dimensional Gaussian kernel using the Gaussian G(x) function
+        /// </summary>
+        /// <param name="kernelSize">Kernel Size</param>
+        /// <returns>A Gaussian Kernel with the given size and deviation.</returns>
+        public double[,] CreateGaussianKernel(int kernelSize)
+        {
+            double[,] kernel = new double[kernelSize, 1];
+            double sum = 0.0d;
+
+            int midpoint = kernelSize / 2;
+            for (int i = 0; i < kernelSize; i++)
+            {
+                int x = i - midpoint;
+                double gx = this.Gaussian(x);
+                sum += gx;
+                kernel[i, 0] = gx;
+            }
+
+            // Normalise kernel so that the sum of all weights equals 1
+            for (int i = 0; i < kernelSize; i++)
+            {
+                kernel[i, 0] = kernel[i, 0] / sum;
+            }
+
+            return kernel;
+        }
+
+        /// <summary>
+        /// Create a 2 dimensional Gaussian kernel using the Gaussian G(x y) function
+        /// </summary>
+        /// <param name="kernelSize">Kernel Size</param>
+        /// <returns>A Gaussian Kernel with the given size and deviation.</returns>
+        public double[,] CreateGaussianKernel2D(int kernelSize)
+        {
+            double[,] kernel = new double[kernelSize, kernelSize];
+
+            int midpoint = kernelSize / 2;
+
+            for (int i = 0; i < kernelSize; i++)
+            {
+                int x = i - midpoint;
+
+                for (int j = 0; j < kernelSize; j++)
+                {
+                    int y = j - midpoint;
+                    double gxy = this.Gaussian2D(x, y);
+                    kernel[i, j] = gxy;
+                }
+            }
+
+            return kernel;
+        }
+
+        /// <summary>
+        /// Create a 2 dimensional Gaussian kernel using the Gaussian G(x y) function for 
+        /// blurring images.
+        /// </summary>
+        /// <param name="kernelSize">Kernel Size</param>
+        /// <returns>A Gaussian Kernel with the given size.</returns>
+        public double[,] CreateGuassianBlurFilter(int kernelSize)
+        {
+            // Create kernel
+            double[,] kernel = this.CreateGaussianKernel2D(kernelSize);
+            double min = kernel[0, 0];
+
+            // Convert to integer blurring kernel. First of all the integer kernel is calculated from Kernel2D
+            // by dividing all elements by the element with the smallest value.
+            double[,] intKernel = new double[kernelSize, kernelSize];
+            int divider = 0;
+
+            for (int i = 0; i < kernelSize; i++)
+            {
+                for (int j = 0; j < kernelSize; j++)
+                {
+                    double v = kernel[i, j] / min;
+
+                    if (v > ushort.MaxValue)
+                    {
+                        v = ushort.MaxValue;
+                    }
+
+                    intKernel[i, j] = (int)v;
+
+                    // Collect the divider
+                    divider += (int)intKernel[i, j];
+                }
+            }
+
+            // Update filter
+            this.Divider = divider;
+            return intKernel;
+        }
+
+        /// <summary>
+        /// Create a 2 dimensional Gaussian kernel using the Gaussian G(x y) function for 
+        /// sharpening images.
+        /// </summary>
+        /// <param name="kernelSize">Kernel Size</param>
+        /// <returns>A Gaussian Kernel with the given size.</returns>
+        public double[,] CreateGuassianSharpenFilter(int kernelSize)
+        {
+            // Create kernel
+            double[,] kernel = this.CreateGaussianKernel2D(kernelSize);
+            double min = kernel[0, 0];
+
+            // integer kernel
+            double[,] intKernel = new double[kernelSize, kernelSize];
+            int sum = 0;
+            int divider = 0;
+
+            for (int i = 0; i < kernelSize; i++)
+            {
+                for (int j = 0; j < kernelSize; j++)
+                {
+                    double v = kernel[i, j] / min;
+
+                    if (v > ushort.MaxValue)
+                    {
+                        v = ushort.MaxValue;
+                    }
+
+                    intKernel[i, j] = (int)v;
+
+                    // Collect the sum.
+                    sum += (int)intKernel[i, j];
+                }
+            }
+
+            // Recalculate the kernel.
+            int center = kernelSize >> 1;
+
+            for (int i = 0; i < kernelSize; i++)
+            {
+                for (int j = 0; j < kernelSize; j++)
+                {
+                    if ((i == center) && (j == center))
+                    {
+                        // Calculate central value
+                        intKernel[i, j] = (2 * sum) - intKernel[i, j];
+                    }
+                    else
+                    {
+                        // invert value
+                        intKernel[i, j] = -intKernel[i, j];
+                    }
+
+                    // Collect the divider
+                    divider += (int)intKernel[i, j];
+                }
+            }
+
+            // Update filter
+            this.Divider = divider;
+            return intKernel;
+        }
+
+        /// <summary>
+        /// Convert a Bitmap to an a multidimensional array of raw pixel values
+        /// </summary>
+        /// <param name="image">The image to convert</param>
+        /// <returns>a multidimensional array of raw pixel values</returns>
+        public Pixel[,] BitmapToPixels(Bitmap image)
+        {
+            Pixel[,] pixels = new Pixel[image.Width, image.Height];
+
+            BitmapData sourceData = image.LockBits(
+                new Rectangle(0, 0, image.Width, image.Height),
+                ImageLockMode.ReadOnly,
+                image.PixelFormat);
+
+            byte[] pixelBuffer = new byte[sourceData.Stride * sourceData.Height];
+
+            Marshal.Copy(sourceData.Scan0, pixelBuffer, 0, pixelBuffer.Length);
+            image.UnlockBits(sourceData);
+
+            int pixelSize = Image.GetPixelFormatSize(image.PixelFormat) / 8;
+            int stride = sourceData.Stride;
+
+            for (int x = 0; x < image.Width; x++)
+            {
+                for (int y = 0; y < image.Height; y++)
+                {
+                    int byteOffset = (y * stride) + (x * pixelSize);
+
+                    pixels[x, y] = new Pixel
+                    {
+                        A = pixelBuffer[byteOffset + 3],
+                        R = pixelBuffer[byteOffset + 2],
+                        G = pixelBuffer[byteOffset + 1],
+                        B = pixelBuffer[byteOffset]
+                    };
+                }
+            }
+
+            return pixels;
+        }
+
+        /// <summary>
+        /// Convert a multidimensional array of raw pixel values to a bitmap
+        /// </summary>
+        /// <param name="pixels">The pixels to convert</param>
+        /// <returns>a bitmap</returns>
+        public Bitmap PixelsToBitmap(Pixel[,] pixels)
+        {
+            int width = pixels.GetLength(0);
+            int height = pixels.GetLength(1);
+            Bitmap resultBitmap = new Bitmap(width, height);
+            BitmapData resultData = resultBitmap.LockBits(
+                new Rectangle(0, 0, resultBitmap.Width, resultBitmap.Height),
+                ImageLockMode.WriteOnly,
+                PixelFormat.Format32bppArgb);
+
+            byte[] pixelBuffer = new byte[resultData.Stride * resultData.Height];
+            int stride = resultData.Stride;
+            int pixelSize = Image.GetPixelFormatSize(resultBitmap.PixelFormat) / 8;
+
+            for (int x = 0; x < width; x++)
+            {
+                for (int y = 0; y < height; y++)
+                {
+                    int byteOffset = (y * stride) + (x * pixelSize);
+
+                    double pixelRed = pixels[x, y].R;
+                    double pixelGreen = pixels[x, y].G;
+                    double pixelBlue = pixels[x, y].B;
+                    double pixelAlpha = pixels[x, y].A;
+
+                    pixelBuffer[byteOffset] = (byte)pixelBlue;
+                    pixelBuffer[byteOffset + 1] = (byte)pixelGreen;
+                    pixelBuffer[byteOffset + 2] = (byte)pixelRed;
+                    pixelBuffer[byteOffset + 3] = (byte)pixelAlpha;
+                }
+            }
+
+            Marshal.Copy(pixelBuffer, 0, resultData.Scan0, pixelBuffer.Length);
+            resultBitmap.UnlockBits(resultData);
+
+            return resultBitmap;
+        }
+
+        /// <summary>
+        /// Processes the given kernel to produce an array of pixels representing a bitmap.
+        /// </summary>
+        /// <param name="pixels">The raw pixels of the image to blur</param>
+        /// <param name="kernel">The Gaussian kernel to use when performing the method</param>
+        /// <returns>An array of pixels representing the bitmap.</returns>
+        public Pixel[,] ProcessKernel(Pixel[,] pixels, double[,] kernel)
+        {
+            int width = pixels.GetLength(0);
+            int height = pixels.GetLength(1);
+            int kernelLength = kernel.GetLength(0);
+            int radius = kernelLength >> 1;
+            int kernelSize = kernelLength * kernelLength;
+            Pixel[,] result = new Pixel[width, height];
+
+            // For each line
+            for (int y = 0; y < height; y++)
+            {
+                // For each pixel
+                for (int x = 0; x < width; x++)
+                {
+                    // The number of kernel elements taken into account
+                    int processedKernelSize;
+
+                    // Colour sums
+                    double blue;
+                    double alpha;
+                    double divider;
+                    double green;
+                    double red = green = blue = alpha = divider = processedKernelSize = 0;
+
+                    // For each kernel row
+                    for (int i = 0; i < kernelLength; i++)
+                    {
+                        int ir = i - radius;
+                        int offsetY = y + ir;
+
+                        // Skip the current row
+                        if (offsetY < 0)
+                        {
+                            continue;
+                        }
+
+                        // Outwith the current bounds so break.
+                        if (offsetY >= height)
+                        {
+                            break;
+                        }
+
+                        // For each kernel column
+                        for (int j = 0; j < kernelLength; j++)
+                        {
+                            int jr = j - radius;
+                            int offsetX = x + jr;
+
+                            // Skip the column
+                            if (offsetX < 0)
+                            {
+                                continue;
+                            }
+
+                            if (offsetX < width)
+                            {
+                                double k = kernel[i, j];
+                                Pixel pixel = pixels[offsetX, offsetY];
+
+                                divider += k;
+
+                                red += k * pixel.R;
+                                green += k * pixel.G;
+                                blue += k * pixel.B;
+                                alpha += k * pixel.A;
+
+                                processedKernelSize++;
+                            }
+                        }
+                    }
+
+                    // Check to see if all kernel elements were processed
+                    if (processedKernelSize == kernelSize)
+                    {
+                        // All kernel elements are processed; we are not on the edge.
+                        divider = this.Divider;
+                    }
+                    else
+                    {
+                        // We are on an edge; do we need to use dynamic divider or not?
+                        if (!this.UseDynamicDividerForEdges)
+                        {
+                            // Apply the set divider.
+                            divider = this.Divider;
+                        }
+                    }
+
+                    // Check and apply the divider
+                    if ((long)divider != 0)
+                    {
+                        red /= divider;
+                        green /= divider;
+                        blue /= divider;
+                        alpha /= divider;
+                    }
+
+                    // Add any applicable threshold.
+                    red += this.Threshold;
+                    green += this.Threshold;
+                    blue += this.Threshold;
+                    alpha += this.Threshold;
+
+                    result[x, y].R = (byte)((red > 255) ? 255 : ((red < 0) ? 0 : red));
+                    result[x, y].G = (byte)((green > 255) ? 255 : ((green < 0) ? 0 : green));
+                    result[x, y].B = (byte)((blue > 255) ? 255 : ((blue < 0) ? 0 : blue));
+                    result[x, y].A = (byte)((alpha > 255) ? 255 : ((alpha < 0) ? 0 : alpha));
+                }
+            }
+
+            return result;
+        }
+
+        #region Private
+        /// <summary>
+        /// Implementation of 1D Gaussian G(x) function
+        /// </summary>
+        /// <param name="x">The x provided to G(x)</param>
+        /// <returns>The Gaussian G(x)</returns>
+        private double Gaussian(double x)
+        {
+            const double Numerator = 1.0;
+            double denominator = Math.Sqrt(2 * Math.PI) * this.standardDeviation;
+
+            double exponentNumerator = -x * x;
+            double exponentDenominator = 2 * Math.Pow(this.standardDeviation, 2);
+
+            double left = Numerator / denominator;
+            double right = Math.Exp(exponentNumerator / exponentDenominator);
+
+            return left * right;
+        }
+
+        /// <summary>
+        /// Implementation of 2D Gaussian G(x) function
+        /// </summary>
+        /// <param name="x">The x provided to G(x y)</param>
+        /// <param name="y">The y provided to G(x y)</param>
+        /// <returns>The Gaussian G(x y)</returns>
+        private double Gaussian2D(double x, double y)
+        {
+            const double Numerator = 1.0;
+            double denominator = (2 * Math.PI) * Math.Pow(this.standardDeviation, 2);
+
+            double exponentNumerator = (-x * x) + (-y * y);
+            double exponentDenominator = 2 * Math.Pow(this.standardDeviation, 2);
+
+            double left = Numerator / denominator;
+            double right = Math.Exp(exponentNumerator / exponentDenominator);
+
+            return left * right;
+        }
+        #endregion
+    }
+}
diff --git a/src/ImageProcessor/Imaging/Filters/ComicMatrixFilter.cs b/src/ImageProcessor/Imaging/Filters/ComicMatrixFilter.cs
index 9864016ec..5cdf12076 100644
--- a/src/ImageProcessor/Imaging/Filters/ComicMatrixFilter.cs
+++ b/src/ImageProcessor/Imaging/Filters/ComicMatrixFilter.cs
@@ -1,9 +1,12 @@
-// -----------------------------------------------------------------------
+// --------------------------------------------------------------------------------------------------------------------
 // <copyright file="ComicMatrixFilter.cs" company="James South">
-//     Copyright (c) James South.
-//     Licensed under the Apache License, Version 2.0.
+//   Copyright (c) James South.
+//   Licensed under the Apache License, Version 2.0.
 // </copyright>
-// -----------------------------------------------------------------------
+// <summary>
+//   Encapsulates methods with which to add a comic filter to an image.
+// </summary>
+// --------------------------------------------------------------------------------------------------------------------
 
 namespace ImageProcessor.Imaging.Filters
 {
@@ -118,7 +121,7 @@ namespace ImageProcessor.Imaging.Filters
                             }
                         }
 
-                        // Transfer the alpha channel from the mask to the hi sturation image.
+                        // Transfer the alpha channel from the mask to the high saturation image.
                         TransferOneArgbChannelFromOneBitmapToAnother(patternBitmap, hisatchBitmap, ChannelArgb.Blue, ChannelArgb.Alpha);
 
                         // Overlay the image.
diff --git a/src/ImageProcessor/Imaging/GaussianLayer.cs b/src/ImageProcessor/Imaging/GaussianLayer.cs
new file mode 100644
index 000000000..6daf65a1a
--- /dev/null
+++ b/src/ImageProcessor/Imaging/GaussianLayer.cs
@@ -0,0 +1,179 @@
+// --------------------------------------------------------------------------------------------------------------------
+// <copyright file="GaussianLayer.cs" company="James South">
+//   Copyright (c) James South.
+//   Licensed under the Apache License, Version 2.0.
+// </copyright>
+// <summary>
+//   A Gaussian layer for applying sharpening and blurring methods to an image.
+// </summary>
+// --------------------------------------------------------------------------------------------------------------------
+
+namespace ImageProcessor.Imaging
+{
+    using System;
+
+    /// <summary>
+    /// A Gaussian layer for applying sharpening and blurring methods to an image.
+    /// </summary>
+    public class GaussianLayer
+    {
+        /// <summary>
+        /// The size.
+        /// </summary>
+        private int size;
+
+        /// <summary>
+        /// The sigma.
+        /// </summary>
+        private double sigma;
+
+        /// <summary>
+        /// The threshold.
+        /// </summary>
+        private int threshold;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GaussianLayer"/> class.
+        /// </summary>
+        public GaussianLayer()
+        {
+            this.Size = 3;
+            this.Sigma = 1.4;
+            this.Threshold = 0;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GaussianLayer"/> class.
+        /// </summary>
+        /// <param name="size">
+        /// The size to set the Gaussian kernel to.
+        /// </param>
+        /// <param name="sigma">
+        /// The Sigma value (standard deviation) for Gaussian function used to calculate the kernel.
+        /// </param>
+        /// <param name="threshold">
+        /// The threshold value, which is added to each weighted sum of pixels.
+        /// </param>
+        public GaussianLayer(int size, double sigma = 1.4, int threshold = 0)
+        {
+            this.Size = size;
+            this.Sigma = sigma;
+            this.Threshold = threshold;
+        }
+
+        /// <summary>
+        /// Gets or sets the size of the Gaussian kernel.
+        /// <remarks>
+        /// <para>
+        /// If set to a value below 0, the property will be set to 0.
+        /// </para>
+        /// </remarks>
+        /// </summary>
+        public int Size
+        {
+            get
+            {
+                return this.size;
+            }
+
+            set
+            {
+                if (value < 0)
+                {
+                    value = 0;
+                }
+
+                this.size = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the sigma value (standard deviation) for Gaussian function used to calculate the kernel.
+        /// <remarks>
+        /// <para>
+        /// If set to a value below 0, the property will be set to 0.
+        /// </para>
+        /// </remarks>
+        /// </summary>
+        public double Sigma
+        {
+            get
+            {
+                return this.sigma;
+            }
+
+            set
+            {
+                if (value < 0)
+                {
+                    value = 0;
+                }
+
+                this.sigma = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the threshold value, which is added to each weighted sum of pixels.
+        /// <remarks>
+        /// <para>
+        /// If set to a value below 0, the property will be set to 0.
+        /// </para>
+        /// </remarks>
+        /// </summary>
+        public int Threshold
+        {
+            get
+            {
+                return this.threshold;
+            }
+
+            set
+            {
+                if (value < 0)
+                {
+                    value = 0;
+                }
+
+                this.threshold = value;
+            }
+        }
+
+        /// <summary>
+        /// Returns a value that indicates whether the specified object is an 
+        /// <see cref="GaussianLayer"/> object that is equivalent to 
+        /// this <see cref="GaussianLayer"/> object.
+        /// </summary>
+        /// <param name="obj">
+        /// The object to test.
+        /// </param>
+        /// <returns>
+        /// True if the given object  is an <see cref="GaussianLayer"/> object that is equivalent to 
+        /// this <see cref="GaussianLayer"/> object; otherwise, false.
+        /// </returns>
+        public override bool Equals(object obj)
+        {
+            GaussianLayer gaussianLayer = obj as GaussianLayer;
+
+            if (gaussianLayer == null)
+            {
+                return false;
+            }
+
+            return this.Size == gaussianLayer.Size
+                && Math.Abs(this.Sigma - gaussianLayer.Sigma) < 0.0001
+                && this.Threshold == gaussianLayer.Threshold;
+        }
+
+        /// <summary>
+        /// Returns a hash code value that represents this object.
+        /// </summary>
+        /// <returns>
+        /// A hash code that represents this object.
+        /// </returns>
+        public override int GetHashCode()
+        {
+            return this.Size.GetHashCode() + this.Sigma.GetHashCode() + this.Threshold.GetHashCode();
+        }
+    }
+}
diff --git a/src/ImageProcessor/Imaging/Pixel.cs b/src/ImageProcessor/Imaging/Pixel.cs
new file mode 100644
index 000000000..b214c3c9b
--- /dev/null
+++ b/src/ImageProcessor/Imaging/Pixel.cs
@@ -0,0 +1,38 @@
+// --------------------------------------------------------------------------------------------------------------------
+// <copyright file="Pixel.cs" company="James South">
+//   Copyright (c) James South.
+//   Licensed under the Apache License, Version 2.0.
+// </copyright>
+// <summary>
+//   Represents a single pixel.
+// </summary>
+// --------------------------------------------------------------------------------------------------------------------
+
+namespace ImageProcessor.Imaging
+{
+    /// <summary>
+    /// Represents a single pixel.
+    /// </summary>
+    public struct Pixel
+    {
+        /// <summary>
+        /// The red component of the pixel.
+        /// </summary>
+        public double R;
+
+        /// <summary>
+        /// The green component of the pixel.
+        /// </summary>
+        public double G;
+
+        /// <summary>
+        /// The blue component of the pixel.
+        /// </summary>
+        public double B;
+
+        /// <summary>
+        /// The alpha component of the pixel.
+        /// </summary>
+        public double A;
+    }
+}
diff --git a/src/ImageProcessor/Processors/Crop.cs b/src/ImageProcessor/Processors/Crop.cs
index 24267b09e..56a6b176d 100644
--- a/src/ImageProcessor/Processors/Crop.cs
+++ b/src/ImageProcessor/Processors/Crop.cs
@@ -145,6 +145,7 @@ namespace ImageProcessor.Processors
                     }
 
                     // Don't use an object initializer here.
+                    // ReSharper disable once UseObjectOrCollectionInitializer
                     newImage = new Bitmap(rectangle.Width, rectangle.Height, PixelFormat.Format32bppPArgb);
                     newImage.Tag = image.Tag;
 
diff --git a/src/ImageProcessor/Processors/GaussianBlur.cs b/src/ImageProcessor/Processors/GaussianBlur.cs
index 88fd5ce98..7da860121 100644
--- a/src/ImageProcessor/Processors/GaussianBlur.cs
+++ b/src/ImageProcessor/Processors/GaussianBlur.cs
@@ -1,32 +1,47 @@
-// -----------------------------------------------------------------------
+// --------------------------------------------------------------------------------------------------------------------
 // <copyright file="GaussianBlur.cs" company="James South">
-//     Copyright (c) James South.
-//     Licensed under the Apache License, Version 2.0.
+//   Copyright (c) James South.
+//   Licensed under the Apache License, Version 2.0.
 // </copyright>
-// -----------------------------------------------------------------------
+// <summary>
+//   Applies a Gaussian blur to the image.
+// </summary>
+// --------------------------------------------------------------------------------------------------------------------
 
 namespace ImageProcessor.Processors
 {
-    #region Using
     using System;
     using System.Collections.Generic;
     using System.Drawing;
-    using System.Drawing.Imaging;
-    using System.IO;
     using System.Text.RegularExpressions;
-    using ImageProcessor.Helpers.Extensions;
-    #endregion
+    using ImageProcessor.Imaging;
 
     /// <summary>
     /// Applies a Gaussian blur to the image.
-    /// Adapted from <see cref="http://code.google.com/p/imagelibrary/source/browse/trunk/Filters/GaussianBlurFilter.cs"/>
     /// </summary>
     public class GaussianBlur : IGraphicsProcessor
     {
+        #region Fields
         /// <summary>
         /// The regular expression to search strings for.
         /// </summary>
-        private static readonly Regex QueryRegex = new Regex(@"blur=(\d+(.\d+)?)", RegexOptions.Compiled);
+        private static readonly Regex QueryRegex = new Regex(@"blur=[^&]*", RegexOptions.Compiled);
+
+        /// <summary>
+        /// The blur regex.
+        /// </summary>
+        private static readonly Regex BlurRegex = new Regex(@"blur=\d+", RegexOptions.Compiled);
+
+        /// <summary>
+        /// The sigma regex.
+        /// </summary>
+        private static readonly Regex SigmaRegex = new Regex(@"sigma-\d+(.+\d+)?", RegexOptions.Compiled);
+
+        /// <summary>
+        /// The threshold regex.
+        /// </summary>
+        private static readonly Regex ThresholdRegex = new Regex(@"threshold-\d+", RegexOptions.Compiled);
+        #endregion
 
         #region IGraphicsProcessor Members
         /// <summary>
@@ -41,38 +56,24 @@ namespace ImageProcessor.Processors
         }
 
         /// <summary>
-        /// Gets or sets DynamicParameter.
+        /// Gets or sets the DynamicParameter.
         /// </summary>
-        public dynamic DynamicParameter
-        {
-            get;
-            set;
-        }
+        public dynamic DynamicParameter { get; set; }
 
         /// <summary>
         /// Gets the order in which this processor is to be used in a chain.
         /// </summary>
-        public int SortOrder
-        {
-            get;
-            private set;
-        }
+        public int SortOrder { get; private set; }
 
         /// <summary>
         /// Gets or sets any additional settings required by the processor.
         /// </summary>
-        public Dictionary<string, string> Settings
-        {
-            get;
-            set;
-        }
+        public Dictionary<string, string> Settings { get; set; }
 
         /// <summary>
         /// The position in the original string where the first character of the captured substring was found.
         /// </summary>
-        /// <param name="queryString">
-        /// The query string to search.
-        /// </param>
+        /// <param name="queryString">The query string to search.</param>
         /// <returns>
         /// The zero-based starting position in the original string where the captured substring was found.
         /// </returns>
@@ -91,7 +92,25 @@ namespace ImageProcessor.Processors
                     {
                         // Set the index on the first instance only.
                         this.SortOrder = match.Index;
-                        this.DynamicParameter = match.Value.Split('=')[1];
+
+                        // Normalise and set the variables.
+                        int maxSize;
+                        double maxSigma;
+                        int maxThreshold;
+
+                        int.TryParse(this.Settings["MaxSize"], out maxSize);
+                        double.TryParse(this.Settings["MaxSigma"], out maxSigma);
+                        int.TryParse(this.Settings["MaxThreshold"], out maxThreshold);
+
+                        int size = this.ParseBlur(match.Value);
+                        double sigma = this.ParseSigma(match.Value);
+                        int threshold = this.ParseThreshold(match.Value);
+
+                        size = maxSize < size ? maxSize : size;
+                        sigma = maxSigma < sigma ? maxSigma : sigma;
+                        threshold = maxThreshold < threshold ? maxThreshold : threshold;
+
+                        this.DynamicParameter = new GaussianLayer(size, sigma, threshold);
                     }
 
                     index += 1;
@@ -104,39 +123,33 @@ namespace ImageProcessor.Processors
         /// <summary>
         /// Processes the image.
         /// </summary>
-        /// <param name="factory">
-        /// The the current instance of the <see cref="T:ImageProcessor.ImageFactory"/> class containing
-        /// the image to process.
-        /// </param>
+        /// <param name="factory">The the current instance of the <see cref="T:ImageProcessor.ImageFactory" /> class containing
+        /// the image to process.</param>
         /// <returns>
-        /// The processed image from the current instance of the <see cref="T:ImageProcessor.ImageFactory"/> class.
+        /// The processed image from the current instance of the <see cref="T:ImageProcessor.ImageFactory" /> class.
         /// </returns>
         public Image ProcessImage(ImageFactory factory)
         {
             Bitmap newImage = null;
-            Image image = factory.Image;
+            Bitmap image = (Bitmap)factory.Image;
 
             try
             {
-                double radius = double.Parse(this.DynamicParameter);
-                byte[] sourceBytes = image.ToBytes(factory.ImageFormat);
-                byte[] destinationBytes = new byte[sourceBytes.Length];
-
-                this.ApplyGaussianBlur(image.Width, image.Height, radius, 1, ref sourceBytes, ref destinationBytes);
-
-
-                // Don't use an object initializer here.
-                newImage = new Bitmap(image.Width, image.Height, PixelFormat.Format32bppPArgb);
-                newImage = (Bitmap)newImage.FromBytes(destinationBytes);
+                newImage = new Bitmap(image);
+                GaussianLayer gaussianLayer = (GaussianLayer)this.DynamicParameter;
+
+                Convolution convolution = new Convolution(gaussianLayer.Sigma) { Threshold = gaussianLayer.Threshold };
+                Pixel[,] pixels = convolution.BitmapToPixels(newImage);
+                double[,] kernel = convolution.CreateGuassianBlurFilter(gaussianLayer.Size);
+                pixels = convolution.ProcessKernel(pixels, kernel);
+                newImage = convolution.PixelsToBitmap(pixels);
                 newImage.Tag = image.Tag;
 
-
                 image.Dispose();
                 image = newImage;
             }
-            catch (Exception ex)
+            catch
             {
-                var x = ex;
                 if (newImage != null)
                 {
                     newImage.Dispose();
@@ -149,142 +162,66 @@ namespace ImageProcessor.Processors
 
         #region Private
         /// <summary>
-        /// The apply gaussian blur.
+        /// Returns the correct <see cref="T:System.Double"/> containing the sigma value
+        /// for the given string.
         /// </summary>
-        /// <param name="width">
-        /// The width.
+        /// <param name="input">
+        /// The input string containing the value to parse.
         /// </param>
-        /// <param name="height">
-        /// The height.
-        /// </param>
-        /// <param name="radius">
-        /// The radius.
-        /// </param>
-        /// <param name="sourceBytes">
-        /// The source bytes array.
-        /// </param>
-        /// <param name="destinationBytes">
-        /// The destination byte array.
-        /// </param>
-        private void ApplyGaussianBlur(int width, int height, double radius, double amount, ref byte[] src, ref byte[] dst)
+        /// <returns>
+        /// The correct <see cref="T:System.Double"/> for the given string.
+        /// </returns>
+        private double ParseSigma(string input)
         {
-
-            int shift, dest, source;
-            int blurDiam = (int)Math.Pow(radius, 2);
-            int gaussWidth = (blurDiam * 2) + 1;
-
-            double[] kernel = CreateKernel(gaussWidth, blurDiam);
-
-            // Calculate the sum of the Gaussian kernel      
-            double gaussSum = 0;
-            for (int n = 0; n < gaussWidth; n++)
+            foreach (Match match in SigmaRegex.Matches(input))
             {
-                gaussSum += kernel[n];
+                // split on text-
+                return Convert.ToDouble(match.Value.Split('-')[1]);
             }
 
-            // Scale the Gaussian kernel
-            for (int n = 0; n < gaussWidth; n++)
-            {
-                kernel[n] = kernel[n] / gaussSum;
-            }
-            //premul = kernel[k] / gaussSum;
-
-
-            // Create an X & Y pass buffer  
-            byte[] gaussPassX = new byte[src.Length];
+            return 1.4d;
+        }
 
-            // Do Horizontal Pass  
-            for (int y = 0; y < height; y++)
+        /// <summary>
+        /// Returns the correct <see cref="T:System.Int32"/> containing the threshold value
+        /// for the given string.
+        /// </summary>
+        /// <param name="input">
+        /// The input string containing the value to parse.
+        /// </param>
+        /// <returns>
+        /// The correct <see cref="T:System.Int32"/> for the given string.
+        /// </returns>
+        private int ParseThreshold(string input)
+        {
+            foreach (Match match in ThresholdRegex.Matches(input))
             {
-                for (int x = 0; x < width; x++)
-                {
-                    dest = y * width + x;
-
-                    // Iterate through kernel  
-                    for (int k = 0; k < gaussWidth; k++)
-                    {
-
-                        // Get pixel-shift (pixel dist between dest and source)  
-                        shift = k - blurDiam;
-
-                        // Basic edge clamp  
-                        source = dest + shift;
-                        if (x + shift <= 0 || x + shift >= width)
-                        {
-                            source = dest;
-                        }
-
-                        // Combine source and destination pixels with Gaussian Weight  
-                        gaussPassX[(dest << 2) + 2] = (byte)(gaussPassX[(dest << 2) + 2] + (src[(source << 2) + 2]) * kernel[k]);
-                        gaussPassX[(dest << 2) + 1] = (byte)(gaussPassX[(dest << 2) + 1] + (src[(source << 2) + 1]) * kernel[k]);
-                        gaussPassX[(dest << 2)] = (byte)(gaussPassX[(dest << 2)] + (src[(source << 2)]) * kernel[k]);
-                    }
-                }
+                // split on text-
+                return Convert.ToInt32(match.Value.Split('-')[1]);
             }
 
-            // Do Vertical Pass  
-            for (int x = 0; x < width; x++)
-            {
-                for (int y = 0; y < height; y++)
-                {
-                    dest = y * width + x;
-
-                    // Iterate through kernel  
-                    for (int k = 0; k < gaussWidth; k++)
-                    {
-                        // Get pixel-shift (pixel dist between dest and source)   
-                        shift = k - blurDiam;
-
-                        // Basic edge clamp  
-                        source = dest + (shift * width);
-                        if (y + shift <= 0 || y + shift >= height)
-                        {
-                            source = dest;
-                        }
-
-                        // Combine source and destination pixels with Gaussian Weight  
-                        dst[(dest << 2) + 2] = (byte)(dst[(dest << 2) + 2] + (gaussPassX[(source << 2) + 2]) * kernel[k]);
-                        dst[(dest << 2) + 1] = (byte)(dst[(dest << 2) + 1] + (gaussPassX[(source << 2) + 1]) * kernel[k]);
-                        dst[(dest << 2)] = (byte)(dst[(dest << 2)] + (gaussPassX[(source << 2)]) * kernel[k]);
-                    }
-                }
-            }
+            return 0;
         }
 
         /// <summary>
-        /// Creates the Gaussian kernel.
+        /// Returns the correct <see cref="T:System.Int32"/> containing the blur value
+        /// for the given string.
         /// </summary>
-        /// <param name="gaussianWidth">
-        /// The gaussian width.
-        /// </param>
-        /// <param name="blurDiameter">
-        /// The blur diameter.
+        /// <param name="input">
+        /// The input string containing the value to parse.
         /// </param>
         /// <returns>
-        /// The <see cref="double"/>.
+        /// The correct <see cref="T:System.Int32"/> for the given string.
         /// </returns>
-        private double[] CreateKernel(int gaussianWidth, int blurDiam)
+        private int ParseBlur(string input)
         {
-
-            double[] kernel = new double[gaussianWidth];
-
-            // Set the maximum value of the Gaussian curve  
-            const double sd = 255;
-
-            // Set the width of the Gaussian curve  
-            double range = gaussianWidth;
-
-            // Set the average value of the Gaussian curve   
-            double mean = (range / sd);
-
-            // Set first half of Gaussian curve in kernel  
-            for (int pos = 0, len = blurDiam + 1; pos < len; pos++)
+            foreach (Match match in BlurRegex.Matches(input))
             {
-                // Distribute Gaussian curve across kernel[array]   
-                kernel[gaussianWidth - 1 - pos] = kernel[pos] = Math.Sqrt(Math.Sin((((pos + 1) * (Math.PI / 2)) - mean) / range)) * sd;
+                // split on text-
+                return Convert.ToInt32(match.Value.Split('=')[1]);
             }
 
-            return kernel;
+            return 0;
         }
         #endregion
     }
diff --git a/src/ImageProcessor/Processors/GaussianSharpen.cs b/src/ImageProcessor/Processors/GaussianSharpen.cs
new file mode 100644
index 000000000..eab7460a1
--- /dev/null
+++ b/src/ImageProcessor/Processors/GaussianSharpen.cs
@@ -0,0 +1,227 @@
+// --------------------------------------------------------------------------------------------------------------------
+// <copyright file="GaussianSharpen.cs" company="James South">
+//   Copyright (c) James South.
+//   Licensed under the Apache License, Version 2.0.
+// </copyright>
+// <summary>
+//   Applies a Gaussian sharpen to the image.
+// </summary>
+// --------------------------------------------------------------------------------------------------------------------
+
+namespace ImageProcessor.Processors
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Drawing;
+    using System.Text.RegularExpressions;
+    using ImageProcessor.Imaging;
+
+    /// <summary>
+    /// Applies a Gaussian sharpen to the image.
+    /// </summary>
+    public class GaussianSharpen : IGraphicsProcessor
+    {
+        #region Fields
+        /// <summary>
+        /// The regular expression to search strings for.
+        /// </summary>
+        private static readonly Regex QueryRegex = new Regex(@"sharpen=[^&]*", RegexOptions.Compiled);
+
+        /// <summary>
+        /// The sharpen regex.
+        /// </summary>
+        private static readonly Regex SharpenRegex = new Regex(@"sharpen=\d+", RegexOptions.Compiled);
+
+        /// <summary>
+        /// The sigma regex.
+        /// </summary>
+        private static readonly Regex SigmaRegex = new Regex(@"sigma-\d+(.+\d+)?", RegexOptions.Compiled);
+
+        /// <summary>
+        /// The threshold regex.
+        /// </summary>
+        private static readonly Regex ThresholdRegex = new Regex(@"threshold-\d+", RegexOptions.Compiled);
+        #endregion
+        #region IGraphicsProcessor Members
+        /// <summary>
+        /// Gets the regular expression to search strings for.
+        /// </summary>
+        public Regex RegexPattern
+        {
+            get
+            {
+                return QueryRegex;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the DynamicParameter.
+        /// </summary>
+        public dynamic DynamicParameter { get; set; }
+
+        /// <summary>
+        /// Gets the order in which this processor is to be used in a chain.
+        /// </summary>
+        public int SortOrder { get; private set; }
+
+        /// <summary>
+        /// Gets or sets any additional settings required by the processor.
+        /// </summary>
+        public Dictionary<string, string> Settings { get; set; }
+
+        /// <summary>
+        /// The position in the original string where the first character of the captured substring was found.
+        /// </summary>
+        /// <param name="queryString">The query string to search.</param>
+        /// <returns>
+        /// The zero-based starting position in the original string where the captured substring was found.
+        /// </returns>
+        public int MatchRegexIndex(string queryString)
+        {
+            int index = 0;
+
+            // Set the sort order to max to allow filtering.
+            this.SortOrder = int.MaxValue;
+
+            foreach (Match match in this.RegexPattern.Matches(queryString))
+            {
+                if (match.Success)
+                {
+                    if (index == 0)
+                    {
+                        // Set the index on the first instance only.
+                        this.SortOrder = match.Index;
+
+                        // Normalise and set the variables.
+                        int maxSize;
+                        double maxSigma;
+                        int maxThreshold;
+
+                        int.TryParse(this.Settings["MaxSize"], out maxSize);
+                        double.TryParse(this.Settings["MaxSigma"], out maxSigma);
+                        int.TryParse(this.Settings["MaxThreshold"], out maxThreshold);
+
+                        int size = this.ParseSharpen(match.Value);
+                        double sigma = this.ParseSigma(match.Value);
+                        int threshold = this.ParseThreshold(match.Value);
+
+                        size = maxSize < size ? maxSize : size;
+                        sigma = maxSigma < sigma ? maxSigma : sigma;
+                        threshold = maxThreshold < threshold ? maxThreshold : threshold;
+
+                        this.DynamicParameter = new GaussianLayer(size, sigma, threshold);
+                    }
+
+                    index += 1;
+                }
+            }
+
+            return this.SortOrder;
+        }
+
+        /// <summary>
+        /// Processes the image.
+        /// </summary>
+        /// <param name="factory">The the current instance of the <see cref="T:ImageProcessor.ImageFactory" /> class containing
+        /// the image to process.</param>
+        /// <returns>
+        /// The processed image from the current instance of the <see cref="T:ImageProcessor.ImageFactory" /> class.
+        /// </returns>
+        public Image ProcessImage(ImageFactory factory)
+        {
+            Bitmap newImage = null;
+            Bitmap image = (Bitmap)factory.Image;
+
+            try
+            {
+                newImage = new Bitmap(image);
+                GaussianLayer gaussianLayer = (GaussianLayer)this.DynamicParameter;
+
+                Convolution convolution = new Convolution(gaussianLayer.Sigma) { Threshold = gaussianLayer.Threshold };
+                Pixel[,] pixels = convolution.BitmapToPixels(newImage);
+                double[,] kernel = convolution.CreateGuassianSharpenFilter(gaussianLayer.Size);
+                pixels = convolution.ProcessKernel(pixels, kernel);
+                newImage = convolution.PixelsToBitmap(pixels);
+                newImage.Tag = image.Tag;
+
+                image.Dispose();
+                image = newImage;
+            }
+            catch
+            {
+                if (newImage != null)
+                {
+                    newImage.Dispose();
+                }
+            }
+
+            return image;
+        }
+        #endregion
+
+        #region Private
+        /// <summary>
+        /// Returns the correct <see cref="T:System.Double"/> containing the sigma value
+        /// for the given string.
+        /// </summary>
+        /// <param name="input">
+        /// The input string containing the value to parse.
+        /// </param>
+        /// <returns>
+        /// The correct <see cref="T:System.Double"/> for the given string.
+        /// </returns>
+        private double ParseSigma(string input)
+        {
+            foreach (Match match in SigmaRegex.Matches(input))
+            {
+                // split on text-
+                return Convert.ToDouble(match.Value.Split('-')[1]);
+            }
+
+            return 1.4d;
+        }
+
+        /// <summary>
+        /// Returns the correct <see cref="T:System.Int32"/> containing the threshold value
+        /// for the given string.
+        /// </summary>
+        /// <param name="input">
+        /// The input string containing the value to parse.
+        /// </param>
+        /// <returns>
+        /// The correct <see cref="T:System.Int32"/> for the given string.
+        /// </returns>
+        private int ParseThreshold(string input)
+        {
+            foreach (Match match in ThresholdRegex.Matches(input))
+            {
+                // split on text-
+                return Convert.ToInt32(match.Value.Split('-')[1]);
+            }
+
+            return 0;
+        }
+
+        /// <summary>
+        /// Returns the correct <see cref="T:System.Int32"/> containing the sharpen value
+        /// for the given string.
+        /// </summary>
+        /// <param name="input">
+        /// The input string containing the value to parse.
+        /// </param>
+        /// <returns>
+        /// The correct <see cref="T:System.Int32"/> for the given string.
+        /// </returns>
+        private int ParseSharpen(string input)
+        {
+            foreach (Match match in SharpenRegex.Matches(input))
+            {
+                // split on text-
+                return Convert.ToInt32(match.Value.Split('=')[1]);
+            }
+
+            return 0;
+        }
+        #endregion
+    }
+}
diff --git a/src/TestWebsites/NET45/Test_Website_NET45/Images/Thumbs.db.REMOVED.git-id b/src/TestWebsites/NET45/Test_Website_NET45/Images/Thumbs.db.REMOVED.git-id
deleted file mode 100644
index e4e463e56..000000000
--- a/src/TestWebsites/NET45/Test_Website_NET45/Images/Thumbs.db.REMOVED.git-id
+++ /dev/null
@@ -1 +0,0 @@
-90ba9cd46c99300489b004f2b4df360b84e4444d
\ No newline at end of file
diff --git a/src/TestWebsites/NET45/Test_Website_NET45/Images/sample1.jpg b/src/TestWebsites/NET45/Test_Website_NET45/Images/sample1.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..909fa4fc55d43e54c2e4ef54021b1fb7275676a0
GIT binary patch
literal 33850
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

literal 0
HcmV?d00001

diff --git a/src/TestWebsites/NET45/Test_Website_NET45/Images/text.png b/src/TestWebsites/NET45/Test_Website_NET45/Images/text.png
new file mode 100644
index 0000000000000000000000000000000000000000..21ebe3883c94844039cc07ad91487339b3ed1f34
GIT binary patch
literal 7317
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
P0Kj7nJ@snU7ZLvfNs}N=

literal 0
HcmV?d00001

diff --git a/src/TestWebsites/NET45/Test_Website_NET45/Views/Home/Index.cshtml b/src/TestWebsites/NET45/Test_Website_NET45/Views/Home/Index.cshtml
index 25593e8ff..7bc0464b9 100644
--- a/src/TestWebsites/NET45/Test_Website_NET45/Views/Home/Index.cshtml
+++ b/src/TestWebsites/NET45/Test_Website_NET45/Views/Home/Index.cshtml
@@ -8,6 +8,8 @@
             <div class="col-s-6">
                 <h2>Resized</h2>
                 <img src="/images/Penguins.jpg?width=300" />
+                <img src="/images/Penguins.jpg?width=300&blur=7" />
+                <img src="/images/Penguins.jpg?width=300&sharpen=7" />
                 <h3>Foreign language test.</h3>
                 <img src="/images/udendørs.jpg?width=300" />
                 <img src="/images/udendørs.jpg?preset=demo&filter=comic" />
@@ -51,7 +53,7 @@
             </div>
         </div>
     </section>
-        <section>
+    <section>
         <div class="row">
             <h2>Resize Stretch</h2>
             <div class="col-s-4">
diff --git a/src/TestWebsites/NET45/Test_Website_NET45/config/imageprocessor/processing.config b/src/TestWebsites/NET45/Test_Website_NET45/config/imageprocessor/processing.config
index 844c56d40..fc33547f6 100644
--- a/src/TestWebsites/NET45/Test_Website_NET45/config/imageprocessor/processing.config
+++ b/src/TestWebsites/NET45/Test_Website_NET45/config/imageprocessor/processing.config
@@ -7,6 +7,20 @@
         <setting key="MaxHeight" value="3000"/>
       </settings>
     </plugin>
+    <plugin name="GaussianBlur">
+      <settings>
+        <setting key="MaxSize" value="22"/>
+        <setting key="MaxSigma" value="5.1"/>
+        <setting key="MaxThreshold" value="100"/>
+      </settings>
+    </plugin>
+    <plugin name="GaussianSharpen">
+      <settings>
+        <setting key="MaxSize" value="22"/>
+        <setting key="MaxSigma" value="5.1"/>
+        <setting key="MaxThreshold" value="100"/>
+      </settings>
+    </plugin>
     <plugin name="Preset">
       <settings>
         <setting key="demo" value="width=300&#038;height=150"/>