Category: 01. Java Digital Image Processing

In order to change color space of one image to another using OpenCV, we read image into BufferedImage and convert it into Mat Object. Its syntax is given below −

File input = new File("digital_image_processing.jpg");
BufferedImage image = ImageIO.read(input);
//convert Buffered Image to Mat.

OpenCv allows many color conversion types, all of which can be found in the Imgproc class. Some of the types are described briefly −

From any of the color conversion type, just pass the appropriate one into method cvtColor() in the Imgproc class. Its syntax is given below −

Imgproc.cvtColor(source mat, destination mat1, Color_Conversion_Code);

The method cvtColor() takes three parameters which are the source image matrix, the destination image matrix and the color conversion type.

Apart from the cvtColor() method, there are other methods provide by the Imgproc class. They are described briefly −

Example

The following example demonstrates the use of Imgproc class to convert an image from one color space to another.

import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;

import java.io.File;
import javax.imageio.ImageIO;

import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.imgproc.Imgproc;

public class Main {
   public static void main( String[] args ) {
   
  try {
     System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
     File input = new File("digital_image_processing.jpg");
     BufferedImage image = ImageIO.read(input);	
     byte[] data = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
     Mat mat = new Mat(image.getHeight(),image.getWidth(), CvType.CV_8UC3);
     mat.put(0, 0, data);
     Mat mat1 = new Mat(image.getHeight(), image.getWidth(), CvType.CV_8UC3);
     Imgproc.cvtColor(mat, mat1, Imgproc.COLOR_RGB2HSV);
     byte[] data1 = new byte[mat1.rows()*mat1.cols()*(int)(mat1.elemSize())];
     mat1.get(0, 0, data1);
     BufferedImage image1 = new BufferedImage(mat1.cols(), mat1.rows(), 5);
     image1.getRaster().setDataElements(0, 0, mat1.cols(), mat1.rows(), data1);
     File ouptut = new File("hsv.jpg");
     ImageIO.write(image1, "jpg", ouptut);
     
  } catch (Exception e) {
     System.out.println("Error: " + e.getMessage());
  }
   }
}

Output

When you execute the given example, it converts an image name digital_image_processing.jpg to its equivalent HSV color space image and writes it on hard disk with name hsv.jpg.

Original Image (RGB)

Converted Image (HSV)

In order to convert a color image to Grayscale image using OpenCV, we read the image into BufferedImage and convert it into Mat Object. Its syntax is given below −

File input = new File("digital_image_processing.jpg");
BufferedImage image = ImageIO.read(input);
//convert Buffered Image to Mat.

Then you can transform the image from RGB to Grayscale format by using method cvtColor() in the Imgproc class. Its syntax is given below −

Imgproc.cvtColor(source mat, destination mat1, Imgproc.COLOR_RGB2GRAY);

The method cvtColor() takes three parameters which are the source image matrix, the destination image matrix, and the color conversion type.

Apart from the cvtColor method, there are other methods provided by the Imgproc class. They are listed below −

Example

The following example demonstrates the use of Imgproc class to convert an image to Grayscale −

import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;

import java.io.File;
import javax.imageio.ImageIO;

import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.imgproc.Imgproc;

public class Main {
   public static void main( String[] args ) { 
   
  try {
     System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
     File input = new File("digital_image_processing.jpg");
     BufferedImage image = ImageIO.read(input);	
     byte[] data = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
     Mat mat = new Mat(image.getHeight(), image.getWidth(), CvType.CV_8UC3);
     mat.put(0, 0, data);
     Mat mat1 = new Mat(image.getHeight(),image.getWidth(),CvType.CV_8UC1);
     Imgproc.cvtColor(mat, mat1, Imgproc.COLOR_RGB2GRAY);
     byte[] data1 = new byte[mat1.rows() * mat1.cols() * (int)(mat1.elemSize())];
     mat1.get(0, 0, data1);
     BufferedImage image1 = new BufferedImage(mat1.cols(),mat1.rows(), BufferedImage.TYPE_BYTE_GRAY);
     image1.getRaster().setDataElements(0, 0, mat1.cols(), mat1.rows(), data1);
     File ouptut = new File("grayscale.jpg");
     ImageIO.write(image1, "jpg", ouptut);
     
  } catch (Exception e) {
     System.out.println("Error: " + e.getMessage());
  }
   }
}

Output

When you execute the given example, it converts an image name digital_image_processing.jpg to its equivalent Grayscale image and writes it on hard disk with name grayscale.jpg.

Original Image

Grayscale Image

OpenCV is released under a BSD license and hence it is free for both academic and commercial use. It has C++, C, Python, and Java interfaces, and it supports Windows, Linux, Mac OS, iOS, and Android.

OpenCV was designed for computational efficiency and with a strong focus on real-time applications. Written in optimized C/C++, the library can take advantage of multi-core processing.

Some of the basic features of OpenCV are described below −

Integrating OpenCV

These following steps explain how to integrate OpenCV into your applications.

Download OpenCV

You can download OpenCV from their official Website here.

Create User Library

Further, we create a user library of OpenCV, so that we can use it as a future project.

Launch Eclipse

Select Window -> Preferences from the menu.

Navigate under Java -> Build Path -> User Libraries and click New.

Now enter the name for your library. For example, OpenCV-2.4.6.

After that, select your new user library(i.e. OpenCV-2.4.6) and click on Add External JARs.

Browse through C:\OpenCV-2.4.6\build\java\ and select opencv-246.jar. After adding the jar, extend the opencv-246.jar and select Native library location and press Edit.

Select External Folder… and browse to select the folder C:\OpenCV-2.4.6\build\java\x64. If you have a 32-bit system, you need to select the x86 folder instead of x64.

Press Ok and you are done.

Now your user library is created. Now you can reuse this configuration in any of the project.

Create OpenCV Project

Create a new java project in eclipse.

On the Java Settings step, under Libraries tab, select Add Library… and select OpenCV-2.4.6, then click Finish.

Click finish and you are done.

In this chapter, we explore some of the free image processing libraries that are widely used and can be easily integrated in the project. These libraries include −

• ImageJ
• Fiji
• Commons Imaging
• ImageMagick
• Endrov
• LeadTools
• OpenCv

ImageJ

ImageJ is a public domain Java image processing program inspired by NIH Image for the Macintosh. It can display, edit, analyze, process, save, and print 8-bit, 16-bit, and 32-bit images.

Some of the basic features of ImageJ are described below −

Fiji

Fiji is an image processing package. It can be described as a distribution of ImageJ (and ImageJ2) together with Java, Java3D, and a lot of plug-ins organized into a coherent menu structure. Fiji compares to ImageJ as Ubuntu compares to Linux.

Apart from the ImageJ basic features, some of the advanced features of Fiji are described below −

Learn Java in-depth with real-world projects through our Java certification course. Enroll and become a certified expert to boost your career.

Commons Imaging

Apache Commons Imaging, previously known as Apache Commons Sanselan, is a library that reads and writes a variety of image formats, including fast parsing of image information such as(size, color, space, ICC profile, etc.) and the meta data.

Some of the basic features of ImageJ are described below −

ImageMagick

ImageMagick is a software suite to create, edit, compose, or convert bitmap images. It can read and write images in more than 100 formats including DPX, EXR, GIF, JPEG, JPEG-2000, PDF, PNG, Postscript, SVG, and TIFF. Use ImageMagick to resize, flip, mirror, rotate, distort, shear, and transform images, adjust image colors, apply various special effects, or draw text, lines, polygons, ellipses, and Bezier curve.

Some of the basic features of ImageMagick are described below −

Endrov

Endrov is a multi-purpose image analysis program. It is written independently and designed to address many of the shortcomings of other free software and many commercial packages.

Some of the basic features of Endrov are described below −

LEADTOOLS

LEADTOOLS provides over 200 image processing functions in several categories including document cleanup, medical image enhancement, color conversion and correction, noise reduction, edge detection, and more.

Some of the basic features of LEADTOOLS are described below −

OpenCV

OpenCV is released under a BSD license and hence it is free for both academic and commercial use. It has C++, C, Python, and Java interfaces and it supports Windows, Linux, Mac OS, iOS, and Android. OpenCV was designed for computational efficiency and with a strong focus on real-time applications. Written in optimized C/C++, the library can take advantage of multi-core processing.

Some basic features of OpenCV are described briefly −

Zooming is the process of enlarging an image so that the details in the image become more visible and prominent.

We use OpenCV function resize to apply zooming to images. It can be found under Imgproc package. Its syntax is given below −

Imgproc.resize(source,destination, destination.size(),zoomFactor,zoomFactor,Interpolation);

In the resize function, we pass source image, destination image and its size, zooming factor, and the interpolation method to use.

The interpolation methods available are described below −

Apart from the resize method, there are other methods provided by the Imgproc class. They are described briefly −

Example

The following example demonstrates the use of Imgproc class to apply zooming to an image.

import org.opencv.core.Core;
import org.opencv.core.Mat;

import org.opencv.highgui.Highgui;
import org.opencv.imgproc.Imgproc;

public class Main {
   public static void main( String[] args ) {
   
  try {
     int zoomingFactor = 2;
     System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
     
     Mat source = Highgui.imread("image.jpg", Highgui.CV_LOAD_IMAGE_GRAYSCALE);
     Mat destination = new Mat(source.rows() * zoomingFactor, source.cols()*  zoomingFactor,source.type());  
     
     Imgproc.resize(source, destination, destination.size(),  zoomingFactor,zoomingFactor,Imgproc.INTER_NEAREST);
     Highgui.imwrite("zoomed.jpg", destination);
     
  } catch (Exception e) {
     System.out.println("Error: "+e.getMessage());
  }
   }
}

Output

When you execute the given code, the following output is seen −

Original Image

Zoomed Image(Zooming factor − 2)

In weighted average filter, we gave more weight to the center value, due to which the contribution of center becomes more than the rest of the values. Due to weighted average filtering, we can control the blurring of image.

We use OpenCV function filter2D to apply weighted average filter to images. It can be found under Imgproc package. Its syntax is given below −

filter2D(src, dst, depth , kernel, anchor, delta, BORDER_DEFAULT );

The function arguments are described below −

Apart from the filter2D() method, there are other methods provide by the Imgproc class. They are described briefly −

Example

The following example demonstrates the use of Imgproc class to apply weighted average filter to an image of Graycale.

import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;

import org.opencv.highgui.Highgui;
import org.opencv.imgproc.Imgproc;

public class convolution {
   public static void main( String[] args ) {
   
  try {
     int kernelSize = 9;
     System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
     
     Mat source = Highgui.imread("grayscale.jpg",  Highgui.CV_LOAD_IMAGE_GRAYSCALE);
     Mat destination = new Mat(source.rows(),source.cols(),source.type());
     
     Mat kernel = Mat.ones(kernelSize,kernelSize, CvType.CV_32F) {	      
     
     for(int i=0; i<kernel.rows(); i++) {
        for(int j=0; j<kernel.cols(); j++) {
           double[] m = kernel.get(i, j);
           for(int k =0; k<m.length; k++) {
              if(i==1 && j==1) {
                 m[k] = 10/18;
              }
              else{
                 m[k] = m[k]/(18);
              }
           }
           kernel.put(i,j, m);
           }
        }	
     };	      
     
     Imgproc.filter2D(source, destination, -1, kernel);
     Highgui.imwrite("output.jpg", destination);
     
  } catch (Exception e) {
     System.out.println("Error: " + e.getMessage());
  }
   }
}

Output

When you execute the given code, the following output is seen −

Original Image

This original image is convolved with the weighted average filter as given below −

Weighted Average Filter

Convolved Image

Laplacian Operator is also a derivative operator which is used to find edges in an image. The major difference between Laplacian and other operators like Prewitt, Sobel, Robinson, and Kirsch is that these all are first order derivative masks but Laplacian is a second order derivative mask.

We use OpenCV function filter2D to apply Laplacian operator to images. It can be found under Imgproc package. Its syntax is given below −

filter2D(src, dst, depth , kernel, anchor, delta, BORDER_DEFAULT );

The function arguments are described below −

Apart from the filter2D() method, there are other methods provided by the Imgproc class. They are described briefly −

Example

The following example demonstrates the use of Imgproc class to apply Laplacian operator to an image of Grayscale.

import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;

import org.opencv.highgui.Highgui;
import org.opencv.imgproc.Imgproc;

public class convolution {
   public static void main( String[] args ) {
   
  try {
     int kernelSize = 9;
     System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
     
     Mat source = Highgui.imread("grayscale.jpg",  Highgui.CV_LOAD_IMAGE_GRAYSCALE);
     Mat destination = new Mat(source.rows(),source.cols(),source.type());
     Mat kernel = new Mat(kernelSize,kernelSize, CvType.CV_32F) {
        {
           put(0,0,0);
           put(0,1,-1)
           put(0,2,0);
           put(1,0-1);
           put(1,1,4);
           put(1,2,-1);
           put(2,0,0);
           put(2,1,-1);
           put(2,2,0);
        }
     };	      
     
     Imgproc.filter2D(source, destination, -1, kernel);
     Highgui.imwrite("output.jpg", destination);
     
  } catch (Exception e) {
     System.out.println("Error: " + e.getMessage());
  }
   }
}

Output

When you execute the given code, the following output is seen −

Original Image

This original image is convolved with the Laplacian Negative operator as given below −

Laplacian Negative

Convolved Image(Laplacian Negative)

This original image is convolved with the Laplacian Positive operator as given below −

Laplacian Positive

Convolved Image (Laplacian Positive)

Robinson compass masks are yet another type of derivative masks which are used for edge detection. This operator is also known as direction mask. In this operator we take one mask and rotate it in all the eight major directions to get edges of the eight directions.

We are going to use OpenCV function filter2D to apply Robinson operator to images. It can be found under Imgproc package. Its syntax is given below −

filter2D(src, dst, depth , kernel, anchor, delta, BORDER_DEFAULT );

The function arguments are described below −

Apart from the filter2D method, there are other methods provided by the Imgproc class. They are described briefly −

Example

The following example demonstrates the use of Imgproc class to apply Robinson operator to an image of Grayscale.

import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;

import org.opencv.highgui.Highgui;
import org.opencv.imgproc.Imgproc;

public class convolution {
   public static void main( String[] args ) {
   
  try {
     int kernelSize = 9;
     System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
     
     Mat source = Highgui.imread("grayscale.jpg",  Highgui.CV_LOAD_IMAGE_GRAYSCALE);
     Mat destination = new Mat(source.rows(),source.cols(),source.type());
     
     Mat kernel = new Mat(kernelSize,kernelSize, CvType.CV_32F) {
        {
           put(0,0,-1);
           put(0,1,0);
           put(0,2,1);
           put(1,0-2);
           put(1,1,0);
           put(1,2,2);
           put(2,0,-1);
           put(2,1,0);
           put(2,2,1);
        }
     };	      
     
     Imgproc.filter2D(source, destination, -1, kernel);
     Highgui.imwrite("output.jpg", destination);
     
  } catch (Exception e) {
     System.out.println("Error: " + e.getMessage());
  }
   }
}

Output

When you execute the given code, the following output is seen −

Original Image

This original image is convolved with the Robinson operator of North edges as given below −

North Direction Mask

Convolved Image(Robinson North)

This original image has also been convolved with the Robinson operator of East edges as given below −

East Direction Mask

Convolved Image(Robinson East)

Kirsch compass masks are yet another type of derivative mask which are used for edge detection. This operator is also known as direction mask. In this operator we take one mask and rotate it in all the eight compass directions to get edges of the eight directions.

We are going to use OpenCV function filter2D to apply Kirsch operator to images. It can be found under Imgproc package. Its syntax is given below −

filter2D(src, dst, depth , kernel, anchor, delta, BORDER_DEFAULT );

The function arguments are described below −

Apart from the filter2D() method, there are other methods provided by the Imgproc class. They are described briefly −

Example

The following example demonstrates the use of Imgproc class to apply Kirsch operator to an image of Grayscale.

import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;

import org.opencv.highgui.Highgui;
import org.opencv.imgproc.Imgproc;

public class convolution {
   public static void main( String[] args ) {
   
  try {
     int kernelSize = 9;
     System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
     
     Mat source = Highgui.imread("grayscale.jpg",  Highgui.CV_LOAD_IMAGE_GRAYSCALE);
     Mat destination = new Mat(source.rows(),source.cols(),source.type());
     
     Mat kernel = new Mat(kernelSize,kernelSize, CvType.CV_32F) {
        {
           put(0,0,-3);
           put(0,1,-3);
           put(0,2,-3);
  
           put(1,0-3);
           put(1,1,0);
           put(1,2,-3);
           put(2,0,5);
           put(2,1,5);
           put(2,2,5);
        }
     };	      
     
     Imgproc.filter2D(source, destination, -1, kernel);
     Highgui.imwrite("output.jpg", destination);
     
  } catch (Exception e) {
     System.out.println("Error: " + e.getMessage());
  }
   }
}

Output

When you execute the given code, the following output is seen −

Original Image

This original image is convolved with the Kirsch operator of East edges, which as given below −

Kirsch East

Convolved Image(Kirsch East)

This original image is convolved with the Kirsch operator of South West edges, which as given below −

Kirsch South West

Convolved Image (Kirsch South West)

Sobel operator is very similar to Prewitt operator. It is also a derivative mask and is used for edge detection. Sobel operator is used to detect two kinds of edges in an image: Vertical direction edges and Horizontal direction edges.

We are going to use OpenCV function filter2D to apply Sobel operator to images. It can be found under Imgproc package. Its syntax is given below −

filter2D(src, dst, depth , kernel, anchor, delta, BORDER_DEFAULT );

The function arguments are described below −

Apart from the filter2D method, there are other methods provide by the Imgproc class. They are described briefly −

Example

The following example demonstrates the use of Imgproc class to apply Sobel operator to an image of Grayscale.

import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;

import org.opencv.highgui.Highgui;
import org.opencv.imgproc.Imgproc;

public class convolution {
   public static void main( String[] args ) {
   
  try {
     int kernelSize = 9;
     System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
     
     Mat source = Highgui.imread("grayscale.jpg",  Highgui.CV_LOAD_IMAGE_GRAYSCALE);
     Mat destination = new Mat(source.rows(),source.cols(),source.type());
     
     Mat kernel = new Mat(kernelSize,kernelSize, CvType.CV_32F) {
        {
           put(0,0,-1);
           put(0,1,0);
           put(0,2,1);
           put(1,0-2);
           put(1,1,0);
           put(1,2,2);
           put(2,0,-1);
           put(2,1,0);
           put(2,2,1);
        }
     };	      
     
     Imgproc.filter2D(source, destination, -1, kernel);
     Highgui.imwrite("output.jpg", destination);
     
  } catch (Exception e) {
     System.out.println("Error: " + e.getMessage());
  }
   }
}

Output

When you execute the given code, the following output is seen −

Original Image

This original image is convolved with the Sobel operator of vertical edges, which is given below −

Vertical Direction

Convolved Image(Vertical Direction)

This original is convolved with the Sobel operator of horizontal edges, which is given below −

Horizontal Direction

Convolved Image(Horizontal Direction)