Gaussian blur filter.
The filter performs
Using Sigma property it is possible to configure
For the list of supported pixel formats, see the documentation to Convolution filter.
Sample usage:
// create filter with kernel size equal to 11 // and Gaussia sigma value equal to 4.0 GaussianBlur filter = new GaussianBlur( 4, 11 ); // apply the filter filter.ApplyInPlace( image ); Initial image:
Result image:
public void FindPeaksTest()
{
Bitmap hand = Properties.Resources.rhand;
GaussianBlur median = new GaussianBlur(1.1);
median.ApplyInPlace(hand);
// Extract contour
BorderFollowing bf = new BorderFollowing(1);
List<IntPoint> contour = bf.FindContour(hand);
hand = hand.Clone(new Rectangle(0, 0, hand.Width, hand.Height), PixelFormat.Format24bppRgb);
// Find peaks
KCurvature kcurv = new KCurvature(30, new DoubleRange(0, 45));
// kcurv.Suppression = 30;
var peaks = kcurv.FindPeaks(contour);
List<IntPoint> supports = new List<IntPoint>();
for (int i = 0; i < peaks.Count; i++)
{
int j = contour.IndexOf(peaks[i]);
supports.Add(contour[(j + kcurv.K) % contour.Count]);
supports.Add(contour[Accord.Math.Tools.Mod(j - kcurv.K, contour.Count)]);
}
// show(hand, contour, peaks, supports);
Assert.AreEqual(2, peaks.Count);
Assert.AreEqual(46, peaks[0].X);
Assert.AreEqual(0, peaks[0].Y);
Assert.AreEqual(2, peaks[1].X);
Assert.AreEqual(11, peaks[1].Y);
}
private void SetFilter()
{
ImageType = ImageTypes.Rgb32bpp;
Af.GaussianBlur newFilter = new Af.GaussianBlur();
newFilter.Sigma = Remap(sigma, 0.5, 5.0);
newFilter.Size = (int)Remap(size, 3, 21);
imageFilter = newFilter;
}
/// <summary>
/// Initializes a new instance of the <see cref="DifferenceOfGaussians"/> class.
/// </summary>
///
public DifferenceOfGaussians()
{
formatTranslations = new Dictionary<PixelFormat, PixelFormat>();
formatTranslations[PixelFormat.Format8bppIndexed] = PixelFormat.Format8bppIndexed;
formatTranslations[PixelFormat.Format16bppGrayScale] = PixelFormat.Format16bppGrayScale;
formatTranslations[PixelFormat.Format24bppRgb] = PixelFormat.Format24bppRgb;
formatTranslations[PixelFormat.Format32bppRgb] = PixelFormat.Format32bppRgb;
formatTranslations[PixelFormat.Format32bppArgb] = PixelFormat.Format32bppArgb;
formatTranslations[PixelFormat.Format48bppRgb] = PixelFormat.Format48bppRgb;
formatTranslations[PixelFormat.Format64bppArgb] = PixelFormat.Format64bppArgb;
this.first = new GaussianBlur()
{
Size = 3,
Sigma = 0.4
};
this.second = new GaussianBlur()
{
Size = 5,
Sigma = 0.4
};
this.subtract = new Subtract();
}
/// <summary>
/// Process the filter on the specified image.
/// </summary>
///
/// <param name="image">Source image data.</param>
///
protected override unsafe void ProcessFilter( UnmanagedImage image )
{
UnmanagedImage bgImage = null;
BitmapData bgLockedData = null;
// get image size
int width = image.Width;
int height = image.Height;
int offset = image.Stride - ( ( image.PixelFormat == PixelFormat.Format8bppIndexed ) ? width : width * 3 );
// check if we have provided background
if ( ( backgroundImage == null ) && ( unmanagedBackgroundImage == null ) )
{
// resize image to 1/3 of its original size to make bluring faster
ResizeBicubic resizeFilter = new ResizeBicubic( (int) width / 3, (int) height / 3 );
UnmanagedImage tempImage = resizeFilter.Apply( image );
// create background image from the input image blurring it with Gaussian 5 times
GaussianBlur blur = new GaussianBlur( 5, 21 );
blur.ApplyInPlace( tempImage );
blur.ApplyInPlace( tempImage );
blur.ApplyInPlace( tempImage );
blur.ApplyInPlace( tempImage );
blur.ApplyInPlace( tempImage );
// resize the blurred image back to original size
resizeFilter.NewWidth = width;
resizeFilter.NewHeight = height;
bgImage = resizeFilter.Apply( tempImage );
tempImage.Dispose( );
}
else
{
if ( backgroundImage != null )
{
// check background image
if ( ( width != backgroundImage.Width ) || ( height != backgroundImage.Height ) || ( image.PixelFormat != backgroundImage.PixelFormat ) )
{
throw new InvalidImagePropertiesException( "Source image and background images must have the same size and pixel format" );
}
// lock background image
bgLockedData = backgroundImage.LockBits(
new Rectangle( 0, 0, width, height ),
ImageLockMode.ReadOnly, backgroundImage.PixelFormat );
bgImage = new UnmanagedImage( bgLockedData );
}
else
{
bgImage = unmanagedBackgroundImage;
}
}
// get background image's statistics (mean value is used as correction factor)
ImageStatistics bgStatistics = new ImageStatistics( bgImage );
byte* src = (byte*) image.ImageData.ToPointer( );
byte* bg = (byte*) bgImage.ImageData.ToPointer( );
// do the job
if ( image.PixelFormat == PixelFormat.Format8bppIndexed )
{
// grayscale image
double mean = bgStatistics.Gray.Mean;
for ( int y = 0; y < height; y++ )
{
for ( int x = 0; x < width; x++, src++, bg++ )
{
if ( *bg != 0 )
{
*src = (byte) Math.Min( mean * *src / *bg, 255 );
}
}
src += offset;
bg += offset;
}
}
else
{
// color image
double meanR = bgStatistics.Red.Mean;
double meanG = bgStatistics.Green.Mean;
double meanB = bgStatistics.Blue.Mean;
for ( int y = 0; y < height; y++ )
{
for ( int x = 0; x < width; x++, src += 3, bg += 3 )
{
// red
if ( bg[RGB.R] != 0 )
{
src[RGB.R] = (byte) Math.Min( meanR * src[RGB.R] / bg[RGB.R], 255 );
}
// green
if ( bg[RGB.G] != 0 )
{
src[RGB.G] = (byte) Math.Min( meanG * src[RGB.G] / bg[RGB.G], 255 );
}
// blue
if ( bg[RGB.B] != 0 )
{
src[RGB.B] = (byte) Math.Min( meanB * src[RGB.B] / bg[RGB.B], 255 );
}
}
src += offset;
bg += offset;
}
}
if ( backgroundImage != null )
{
backgroundImage.UnlockBits( bgLockedData );
}
// dispose background image if it was not set manually
if ( ( backgroundImage == null ) && ( unmanagedBackgroundImage == null ) )
{
bgImage.Dispose( );
}
}
