Window Filters

Box filter is the simplest low-pass operator to smooth the input image. It is useful to remove high-frequency noise. It simply adds all pixels with the same weight and find the average value. As a result, the output image is getting blurry.

Gaussian filter uses the standard normal distribution function to reduce high-frequency noise. It applys a higher weight at the center pixel and lesser weights while it is farther away. So, it produces more natural blur image than the box filter.

Here is a C++ code snippet to generate a 1D Gaussian kernel. The standard deviation, σ determines how the function is dispersed.

// make 1D gaussian kernel using normal distribution function
// do only half(positive area) and mirror to negative side
// because Gaussian is even function, symmetric to Y-axis
void generateGaussianKernel(float sigma, float *kernel, int kernelSize)
{
    float sum = 0;                 // used for normalization
    double result = 0;             // result of gaussian func

    int center = kernelSize / 2;   // center value of n-array(0 ~ n-1)

    if(sigma == 0)
    {
        for(int i = 0; i <= center; ++i)
            kernel[center+i] = kernel[center-i] = 0;

        kernel[center] = 1.0;
    }
    else
    {
        for(int i = 0; i <= center; ++i)
        {
            // dividing (sqrt(2*PI)*sigma) is not needed because normalizing result later
            result = exp(-(i*i)/(double)(2*sigma*sigma));
            kernel[center+i] = kernel[center-i] = (float)result;
            sum += (float)result;
            if(i != 0) sum += (float)result;
        }

        // normalize kernel
        // make sum of all elements in kernel to 1
        for(int i = 0; i <= center; ++i)
            kernel[center+i] = kernel[center-i] /= sum;
    }
}

Or, the gaussian filter can be also approximated with Pascal's triangle. The following is a 3x3, 5x5 and 7x7 Gaussian kernels using Pascal's triangle. Note that the gaussian kernel is seperable, so it can be performed 1D convolution twice; vertical and horizontal to reduce the mathematical computation. A 2D convolution with a 3x3 kernel requires 9 multiplications, however, a seperable convolution requires only 6 multiplications.

Please check WebGL version of Gaussian Blur implementation for more performance optimization using GLSL shaders.

Prewitt edge detection operator uses equal weights in the gradient function.

Therefore, the 3x3 Prewitt gradient kernels G_x and G_y are;

Sobel edge detection operator uses a higher weight for the center pixel in the gradient functions. The 3x3 G_x and G_y of Sobel gradient kernels are;

Roberts gradient function uses diagonal neighbour pixels to calculate the difference. And, the gradient kernels are 2x2 matrix.

If you subtract the smoothed image from the original image, you can get the details only which are the edges of the image. It is called unsharp mask.
Unsharp Mask = Original Image - Burred Image

By combining the original image and unsharp mask together, the resulting image produces clearer and enhances the edges and details in the original image. The following intensity profile diagrams show the steps of sharpening process using the unsharp mask.

Please see the sharpening example with a typical image.

The unsharp mask is similar to the result of applying the laplacian filter to the input image. The difference is the peaks of the intensity changes are inverted. Therefore, we can construct the sharpening kernel by subtracting the laplacian output from the input image.