Class SharpenFilterOptions

Class SharpenFilterOptions

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

The sharpen filter options.

public class SharpenFilterOptions : GaussianBlurFilterOptions

Inheritance

objectFilterOptionsBaseConvolutionFilterOptionsGaussianBlurFilterOptionsSharpenFilterOptions

Inherited Members

GaussianBlurFilterOptions.DefaultSize, GaussianBlurFilterOptions.DefaultSigma, GaussianBlurFilterOptions.Kernel, GaussianBlurFilterOptions.Size, GaussianBlurFilterOptions.Sigma, GaussianBlurFilterOptions.Radius, 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_SharpenFilterOptions__ctor_System_Int32_System_Double_"></a> SharpenFilterOptions\(int, double\)

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

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

Parameters

size int

The size of the kernel.

sigma double

The sigma.

SharpenFilterOptions()

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

public SharpenFilterOptions()

Properties

Kernel

Gets the kernel.

public override double[,] Kernel { get; }

Property Value

double[,]

Sigma

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

public override double Sigma { get; set; }

Property Value

double

Size

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

public override int Size { get; set; }

Property Value

int