Emboss Filters

Emboss Kernel Filter

         In this example, we manipulate pixel values based on their surrounding counterparts. The resulting pixel values are proportionally diminished relative to the values of the top-left surrounding pixels and increased in correspondence to the bottom-right corner surroundings. Essentially, brighter top-left pixels lead to a greater decrease in value, while a brighter bottom-right pixel results in an increase in value. The maximum value of 255 represents white, and 0 corresponds to black color. If the result exceeds 255, it is capped at 255, and values below 0 are adjusted to 0. The sum of all matrix coefficients remains equal to 1, ensuring that the overall brightness of the image stays constant.

// emboss3x3 kernel
double[,] customKernel = new double[,]
{
    { -2, -1,  0, },
    { -1,  1,  1, },
    {  0,  1,  2, },
};

         Hence, the image edges and contours are visually enhanced, acquiring more shadow from the top-left side and increased light from the bottom-right side. This image effect, known as the "Emboss" filter, relates the appearance of the image being embossed or elevated from the background. The result is a visual illusion of depth and texture.

Original image

Emboss filter

Emboss 3x3 kernel filter

C# code example

         The following C# code example demonstrates the usage of the Aspose.Imaging .NET API. You can employ the `ConvolutionFilter` class, which offers predefined kernel filters "Emboss3x3" and "Emboss5x5" with different kernel matrix sizes. Additionally, you have the flexibility to create your custom kernel matrix. In this code example, image templates in PNG and SVG formats are loaded from the "templates" folder, and filters are applied from a predefined list.

using System;
using System.Collections.Generic;
using System.IO;

using Aspose.Imaging.ImageFilters.ComplexUtils;
using Aspose.Imaging.ImageFilters.Convolution;
using Aspose.Imaging.ImageFilters.FilterOptions;

const int Size = 5;
const double Sigma = 1.5, Angle = 45;

double[,] customKernel = GetRandomKernel(Size, 7, new Random());
Complex[,] customComplex = ConvolutionFilter.ToComplex(customKernel);
var kernelFilters = new FilterOptionsBase[]
{
    // convolution filters
    new ConvolutionFilterOptions(ConvolutionFilter.Emboss3x3),
    new ConvolutionFilterOptions(ConvolutionFilter.Emboss5x5),
    new ConvolutionFilterOptions(ConvolutionFilter.Sharpen3x3),
    new ConvolutionFilterOptions(ConvolutionFilter.Sharpen5x5),
    new ConvolutionFilterOptions(ConvolutionFilter.GetBlurBox(Size)),
    new ConvolutionFilterOptions(ConvolutionFilter.GetBlurMotion(Size, Angle)),
    new ConvolutionFilterOptions(ConvolutionFilter.GetGaussian(Size, Sigma)),
    new ConvolutionFilterOptions(customKernel),
    new GaussianBlurFilterOptions(Size, Sigma),
    new SharpenFilterOptions(Size, Sigma),
    new MedianFilterOptions(Size),
    // deconvolution filters
    new DeconvolutionFilterOptions(ConvolutionFilter.GetGaussian(Size, Sigma)),
    new DeconvolutionFilterOptions(customKernel),
    new DeconvolutionFilterOptions(customComplex),
    new GaussWienerFilterOptions(Size, Sigma),
    new MotionWienerFilterOptions(Size, Sigma, Angle),
};

var templatesFolder = @"c:\Users\USER\Downloads\templates\";
var dataDir = templatesFolder; 
var inputPaths = new[]
{
    Path.Combine(dataDir, "template.png"),
    Path.Combine(dataDir, "template.svg"),
};

var outputs = new List<string>();
foreach (var inputPath in inputPaths)
{
    for (int i = 0; i < kernelFilters.Length; i++)
    {
        var options = kernelFilters[i];
        using (var image = Image.Load(inputPath))
        {
            var outputPath = $"{inputPath}-{i}.png";

            if (image is RasterImage raster)
            {
                Filter(raster, options, outputPath);
            }
            else if (image is VectorImage vector)
            {
                var vectorAsPng = inputPath + ".png";
                if (!File.Exists(vectorAsPng))
                {
                    vector.Save(vectorAsPng);
                    outputs.Add(vectorAsPng);
                }

                using (var png = Image.Load(vectorAsPng))
                {
                    Filter(png as RasterImage, options, outputPath);
                }
            }
        }
    }
}

outputs.ForEach(p => File.Delete(p));

static void Filter(RasterImage raster, FilterOptionsBase options, string outputPath)
{
    raster.Filter(raster.Bounds, options);
    raster.Save(outputPath);
}

static double[,] GetRandomKernel(int cols, int rows, Random random)
{
    double[,] customKernel = new double[cols, rows];
    for (int y = 0; y < customKernel.GetLength(0); y++)
    {
        for (int x = 0; x < customKernel.GetLength(1); x++)
        {
            customKernel[y, x] = random.NextDouble();
        }
    }
    return customKernel;
}