Class GaussianBlurFilterOptions

Class GaussianBlurFilterOptions

Namespace: Aspose.Imaging.ImageFilters.FilterOptions
Assembly: Aspose.Imaging.dll (25.2.0)

The Gaussian blur filter options.

public class GaussianBlurFilterOptions : ConvolutionFilterOptions

Inheritance

objectFilterOptionsBaseConvolutionFilterOptionsGaussianBlurFilterOptions

Derived

SharpenFilterOptions

Inherited Members

ConvolutionFilterOptions.MinSize, ConvolutionFilterOptions.Kernel, ConvolutionFilterOptions.Factor, ConvolutionFilterOptions.Bias, object.GetType(), object.MemberwiseClone(), object.ToString(), object.Equals(object?), object.Equals(object?, object?), object.ReferenceEquals(object?, object?), object.GetHashCode()

Examples

The following example applies various types of filters to a raster image.```csharp [C#]

                                                                                string dir = "c:\\temp\\";

                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                {
                                                                                    Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;

                                                                                    // Apply a median filter with a rectangle size of 5 to the entire image.
                                                                                    rasterImage.Filter(rasterImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.MedianFilterOptions(5));
                                                                                    rasterImage.Save(dir + "sample.MedianFilter.png");
                                                                                }

                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                {
                                                                                    Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;

                                                                                    // Apply a bilateral smoothing filter with a kernel size of 5 to the entire image.
                                                                                    rasterImage.Filter(rasterImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.BilateralSmoothingFilterOptions(5));
                                                                                    rasterImage.Save(dir + "sample.BilateralSmoothingFilter.png");
                                                                                }

                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                {
                                                                                    Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;

                                                                                    // Apply a Gaussian blur filter with a radius of 5 and a sigma value of 4.0 to the entire image.
                                                                                    rasterImage.Filter(rasterImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.GaussianBlurFilterOptions(5, 4.0));
                                                                                    rasterImage.Save(dir + "sample.GaussianBlurFilter.png");
                                                                                }

                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                {
                                                                                    Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;

                                                                                    // Apply a Gauss-Wiener filter with a radius of 5 and a smooth value of 4.0 to the entire image.
                                                                                    rasterImage.Filter(rasterImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.GaussWienerFilterOptions(5, 4.0));
                                                                                    rasterImage.Save(dir + "sample.GaussWienerFilter.png");
                                                                                }

                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                {
                                                                                    Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;

                                                                                    // Apply a motion wiener filter with a length of 5, a smooth value of 4.0 and an angle of 90.0 degrees to the entire image.
                                                                                    rasterImage.Filter(rasterImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.MotionWienerFilterOptions(10, 1.0, 90.0));
                                                                                    rasterImage.Save(dir + "sample.MotionWienerFilter.png");
                                                                                }

                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                {
                                                                                    Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;

                                                                                    // Apply a sharpen filter with a kernel size of 5 and a sigma value of 4.0 to the entire image.
                                                                                    rasterImage.Filter(rasterImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.SharpenFilterOptions(5, 4.0));
                                                                                    rasterImage.Save(dir + "sample.SharpenFilter.png");
                                                                                }

## Constructors

### <a id="Aspose_Imaging_ImageFilters_FilterOptions_GaussianBlurFilterOptions__ctor_System_Int32_System_Double_"></a> GaussianBlurFilterOptions\(int, double\)

Initializes a new instance of the Aspose.Imaging.ImageFilters.FilterOptions.GaussianBlurFilterOptions class.

```csharp
public GaussianBlurFilterOptions(int size, double sigma)

Parameters

size int

The Gaussian kernel size..

sigma double

The Gaussian kernel sigma.

GaussianBlurFilterOptions()

Initializes a new instance of the Aspose.Imaging.ImageFilters.FilterOptions.GaussianBlurFilterOptions class.

public GaussianBlurFilterOptions()

Fields

DefaultSigma

The default Gaussian kernel sigma.

protected const double DefaultSigma = 1

Field Value

double

DefaultSize

The default Gaussian kernel size.

protected const byte DefaultSize = 5

Field Value

byte

Properties

Kernel

Gets the Gaussian kernel.

public override double[,] Kernel { get; }

Property Value

double[,]

Radius

Gets the radius of Gausseian Aspose.Imaging.ImageFilters.Convolution.ISquareConvolutionKernel.

public int Radius { get; set; }

Property Value

int

Sigma

Gets the Gaussian kernel sigma (smoothing). Must be a positive non-zero value.

public virtual double Sigma { get; set; }

Property Value

double

Size

Gets the Gaussian kernel size. Must be a positive non-zero odd value.

public virtual int Size { get; set; }

Property Value

int