Image filtering, also known as convolution, is a fundamental technique used to modify or enhance an image. It involves applying a mathematical operator, called a kernel or filter, to every pixel in the image. This process is essential for tasks like noise reduction, sharpening, and edge detection. This module will explore various low-pass filters available in OpenCV, which are primarily used for blurring and smoothing images.

5.1 Blurring for Noise Reduction

Blurring, or smoothing, is an operation that removes high-frequency content (like noise and fine edges) from an image. This is typically achieved by convolving the image with a low-pass filter kernel, where each pixel’s value is replaced by a function of the values of its neighbors.

Averaging Blur

This is the simplest form of blurring. It works by convolving the image with a normalized box filter. In this process, the value of the central pixel is replaced by the average of all pixel values in the kernel area. The OpenCV function for this is blur().

• Function: Imgproc.blur(src, dst, ksize)
• Key Parameter: ksize is a Size object (e.g., new Size(45, 45)) that defines the dimensions of the kernel. Larger kernels result in more pronounced blurring.

import org.opencv.core.Core;

import org.opencv.core.Mat;

import org.opencv.core.Size;

import org.opencv.imgcodecs.Imgcodecs;

import org.opencv.imgproc.Imgproc;

public class BlurTest {

public static void main(String args[]) {

System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

Mat src = Imgcodecs.imread(“path/to/your/image.jpg”);

Mat dst = new Mat();

Size ksize = new Size(45, 45);

Imgproc.blur(src, dst, ksize);

Imgcodecs.imwrite(“path/to/your/blurred_image.jpg”, dst);

System.out.println(“Image processed with Averaging Blur.”);

}

}

The resulting image will appear softer and less detailed than the original.

Gaussian Blur

Instead of a simple box filter where all neighboring pixels have equal weight, Gaussian blur uses a Gaussian filter. In this filter, pixels closer to the center of the kernel are given more weight in the averaging calculation. This results in a smoother, more natural-looking blur that is less prone to the blocky artifacts of a box filter.

• Function: Imgproc.GaussianBlur(src, dst, ksize, sigmaX)
• Key Parameters: ksize defines the kernel size, which must be odd. sigmaX is the Gaussian kernel standard deviation in the X direction. Increasing ksize or sigmaX will increase the amount of blur. If sigmaX is set to 0, it is calculated from the kernel size.

import org.opencv.core.Core;

import org.opencv.core.Mat;

import org.opencv.core.Size;

import org.opencv.imgcodecs.Imgcodecs;

import org.opencv.imgproc.Imgproc;

public class GaussianTest {

public static void main(String args[]) {

System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

Mat src = Imgcodecs.imread(“path/to/your/image.jpg”);

Mat dst = new Mat();

Imgproc.GaussianBlur(src, dst, new Size(45, 45), 0);

Imgcodecs.imwrite(“path/to/your/gaussian_blurred_image.jpg”, dst);

System.out.println(“Image processed with Gaussian Blur.”);

}

}

Median Blur

Median blur is a non-linear filtering technique. To perform this operation, we replace each pixel’s value with the median value of all the pixels in the kernel area. This method is particularly effective at removing “salt-and-pepper” noise while preserving edges better than linear filters like Gaussian blur.

• Function: Imgproc.medianBlur(src, dst, ksize)
• Key Parameter: ksize is a single integer representing the aperture linear size; it must be odd.

import org.opencv.core.Core;

import org.opencv.core.Mat;

import org.opencv.imgcodecs.Imgcodecs;

import org.opencv.imgproc.Imgproc;

public class MedianBlurTest {

public static void main(String args[]) {

System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

Mat src = Imgcodecs.imread(“path/to/your/image.jpg”);

Mat dst = new Mat();

Imgproc.medianBlur(src, dst, 15);

Imgcodecs.imwrite(“path/to/your/median_blurred_image.jpg”, dst);

System.out.println(“Image processed with Median Blur.”);

}

}

5.2 Advanced Filtering Techniques

Beyond the basic blurring methods, OpenCV provides more specialized filters for various image processing tasks.

Bilateral Filter

The bilateral filter is a powerful non-linear filter that can smooth an image while preserving sharp edges. It considers both the spatial distance (like Gaussian blur) and the intensity difference between pixels. This means it averages pixels that are not only close to each other but also similar in color, thus avoiding blurring across strong edges.

• Function: Imgproc.bilateralFilter(src, dst, d, sigmaColor, sigmaSpace)
• Key Parameters: d is the diameter of the pixel neighborhood; sigmaColor and sigmaSpace control the influence of color similarity and spatial distance.

import org.opencv.core.Core;

import org.opencv.core.Mat;

import org.opencv.imgcodecs.Imgcodecs;

import org.opencv.imgproc.Imgproc;

public class BilateralFilterTest {

public static void main(String args[]) {

System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

Mat src = Imgcodecs.imread(“path/to/your/image.jpg”);

Mat dst = new Mat();

Imgproc.bilateralFilter(src, dst, 15, 80, 80, Core.BORDER_DEFAULT);

Imgcodecs.imwrite(“path/to/your/bilateral_filtered_image.jpg”, dst);

System.out.println(“Image processed with Bilateral Filter.”);

}

}

Box Filter

The box filter is very similar to the averaging blur. It applies a box filter to an image, but it gives the user the option to specify whether the kernel should be normalized. If it is not normalized, it simply calculates the sum of the pixel values in the kernel area.

• Function: Imgproc.boxFilter(src, dst, ddepth, ksize, anchor, normalize)
• Key Parameter: normalize is a boolean that, if true, makes this filter identical to the blur() function.

import org.opencv.core.Core;

import org.opencv.core.Mat;

import org.opencv.core.Point;

import org.opencv.core.Size;

import org.opencv.imgcodecs.Imgcodecs;

import org.opencv.imgproc.Imgproc;

public class BoxFilterTest {

public static void main( String[] args ) {

System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

Mat src = Imgcodecs.imread(“path/to/your/image.jpg”);

Mat dst = new Mat();

Imgproc.boxFilter(src, dst, -1, new Size(45, 45), new Point(-1, -1), true);

Imgcodecs.imwrite(“path/to/your/box_filtered_image.jpg”, dst);

System.out.println(“Image processed with Box Filter.”);

}

}

Square Box Filter

The sqrBoxFilter() calculates the sum of squared values over a box-shaped neighborhood.

• Function: Imgproc.sqrBoxFilter(src, dst, ddepth, ksize)

import org.opencv.core.Core;

import org.opencv.core.Mat;

import org.opencv.core.Size;

import org.opencv.imgcodecs.Imgcodecs;

import org.opencv.imgproc.Imgproc;

public class SqrBoxFilterTest {

public static void main( String[] args ) {

System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

Mat src = Imgcodecs.imread(“path/to/your/image.jpg”);

Mat dst = new Mat();

Imgproc.sqrBoxFilter(src, dst, -1, new Size(1, 1));

Imgcodecs.imwrite(“path/to/your/sqrbox_filtered_image.jpg”, dst);

System.out.println(“Image processed with Square Box Filter.”);

}

}

2D Filter

The filter2D() function is a generic convolution tool that allows you to apply any custom, user-defined kernel to an image. This is useful for implementing custom filters for effects like sharpening, embossing, or specialized edge detection.

• Function: Imgproc.filter2D(src, dst, ddepth, kernel)
• Key Parameter: kernel is a Mat object that you define, representing the convolution kernel.

import org.opencv.core.Core;

import org.opencv.core.CvType;

import org.opencv.core.Mat;

import org.opencv.imgcodecs.Imgcodecs;

import org.opencv.imgproc.Imgproc;

public class Filter2DTest {

public static void main( String[] args ) {

System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

Mat src = Imgcodecs.imread(“path/to/your/image.jpg”);

Mat dst = new Mat();

// Creating a custom kernel matrix for sharpening

Mat kernel = new Mat(3, 3, CvType.CV_32F);

float[] kernelData = {

0, -1,  0,

-1,  5, -1,

0, -1,  0

};

kernel.put(0, 0, kernelData);

Imgproc.filter2D(src, dst, -1, kernel);

Imgcodecs.imwrite(“path/to/your/filter2d_image.jpg”, dst);

System.out.println(“Image processed with custom 2D Filter.”);

}

}

Now that we have covered filters that modify pixel intensity based on neighbors, we will transition to operations that modify the image structure based on shape, introducing morphological transformations.