Java DIP - Introduction

Digital Image Processing (DIP) deals with manipulation of digital images using a digital computer. It is a sub field of signals and systems but focuses particularly on images. DIP focuses on developing a computer system that is able to perform processing on an image. The input of such system is a digital image. The system processes the image using efficient algorithms, and gives an image as an output.

Java is a high level programming language that is widely used in the modern world. It can support and handle digital image processing efficiently using various functions.

Java BufferedImage Class

Java BufferedImage class is a subclass of Image class. It is used to handle and manipulate the image data. A BufferedImage is made of ColorModel of image data. All BufferedImage objects have an upper left corner coordinate of (0, 0).

Constructors

This class supports three types of constructors.

The first constructor constructs a new BufferedImage with a specified ColorModel and Raster.

BufferedImage(ColorModel cm, WritableRaster raster, 
boolean isRasterPremultipped, Hashtable<?,?> properties)

The second constructor constructs a BufferedImage of one of the predefined image types.

BufferedImage(int width, int height, int imageType)

The third constructor constructs a BufferedImage of one of the predefined image types: TYPE_BYTE_BINARY or TYPE_BYTE_INDEXED.

BufferedImage(int width, int height, int imageType, IndexColorModel cm)

Example

The following example demonstrates the use of java BufferedImage class that draw some text on the screen using Graphics Object −

import java.awt.Graphics;
import java.awt.Image;
import java.awt.image.BufferedImage;

import javax.swing.JFrame;
import javax.swing.JPanel;

pubpc class Test extends JPanel {

   pubpc void paint(Graphics g) {
      Image img = createImageWithText();
      g.drawImage(img, 20,20,this);
   }

   private Image createImageWithText() {
      BufferedImage bufferedImage = new BufferedImage(200,200,BufferedImage.TYPE_INT_RGB);
      Graphics g = bufferedImage.getGraphics();

      g.drawString("www.tutorialspoint.com", 20,20);
      g.drawString("www.tutorialspoint.com", 20,40);
      g.drawString("www.tutorialspoint.com", 20,60);
      g.drawString("www.tutorialspoint.com", 20,80);
      g.drawString("www.tutorialspoint.com", 20,100);
      
      return bufferedImage;
   }
   
   pubpc static void main(String[] args) {
      JFrame frame = new JFrame();
      frame.getContentPane().add(new Test());

      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.setSize(200, 200);
      frame.setVisible(true);
   }
}

Output

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

Downloading & Uploading Images

In this chapter we are going to see how you can download an image from internet, perform some image processing techniques on the image, and then again upload the processed image to a server.

Downloading an Image

In order to download an image from a website, we use java class named URL, which can be found under java.net package. Its syntax is given below −

String website = "http://tutorialspoint.com";
URL url = new URL(website);				

Apart from the above method, there are other methods available in class URL as described briefly −

Example

The following example demonstrates the use of java URL class to download an image from the internet −

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import java.net.URL;

pubpc class Download {

   pubpc static void main(String[] args) throws Exception {
   
      try{
         String fileName = "digital_image_processing.jpg";
         String website = "http://tutorialspoint.com/java_dip/images/"+fileName;
         
         System.out.println("Downloading File From: " + website);
         
         URL url = new URL(website);
         InputStream inputStream = url.openStream();
         OutputStream outputStream = new FileOutputStream(fileName);
         byte[] buffer = new byte[2048];
         
         int length = 0;
         
         while ((length = inputStream.read(buffer)) != -1) {
            System.out.println("Buffer Read of length: " + length);
            outputStream.write(buffer, 0, length);
         }
         
         inputStream.close();
         outputStream.close();
         
      } catch(Exception e) {
         System.out.println("Exception: " + e.getMessage());
      }
   }
}

Output

When you execute the given above, the following output is seen.

It would download the following image from the server.

Uploading an Image

Let us see how to upload an image to a webserver. We convert a BufferedImage to byte array in order to send it to server.

We use Java class ByteArrayOutputStream, which can be found under java.io package. Its syntax is given below −

ByteArrayOutputStream baos = new ByteArrayOutputStream();
ImageIO.write(image, "jpg", baos);

In order to convert the image to byte array, we use toByteArray() method of ByteArrayOutputStream class. Its syntax is given below −

byte[] bytes = baos.toByteArray();

Apart from the above method, there are other methods available in the ByteArrayOutputStream class as described briefly −

Example

The following example demonstrates ByteArrayOutputStream to upload an image to the server −

Cpent Code

import javax.swing.*;  
import java.net.*; 
import java.awt.image.*;
import javax.imageio.*;
import java.io.*;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;

pubpc class Cpent{
   pubpc static void main(String args[]) throws Exception{
   
      Socket soc;
      BufferedImage img = null;
      soc=new Socket("localhost",4000);
      System.out.println("Cpent is running. ");
      
      try {
         System.out.println("Reading image from disk. ");
         img = ImageIO.read(new File("digital_image_processing.jpg"));
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         
         ImageIO.write(img, "jpg", baos);
         baos.flush();
         
         byte[] bytes = baos.toByteArray();
         baos.close();
         
         System.out.println("Sending image to server. ");
         
         OutputStream out = soc.getOutputStream(); 
         DataOutputStream dos = new DataOutputStream(out);
         
         dos.writeInt(bytes.length);
         dos.write(bytes, 0, bytes.length);
         
         System.out.println("Image sent to server. ");

         dos.close();
         out.close();
         
      } catch (Exception e) {
         System.out.println("Exception: " + e.getMessage());
         soc.close();
      }
      soc.close();
   }
}

Server Code

import java.net.*;
import java.io.*;
import java.awt.image.*;

import javax.imageio.*; 
import javax.swing.*; 

class Server {
   pubpc static void main(String  args[]) throws Exception{
      ServerSocket server=null;
      Socket socket;
      server = new ServerSocket(4000);
      System.out.println("Server Waiting for image");

      socket = server.accept();
      System.out.println("Cpent connected.");
      
      InputStream in = socket.getInputStream();
      DataInputStream dis = new DataInputStream(in);

      int len = dis.readInt();
      System.out.println("Image Size: " + len/1024 + "KB");
      
      byte[] data = new byte[len];
      dis.readFully(data);
      dis.close();
      in.close();

      InputStream ian = new ByteArrayInputStream(data);
      BufferedImage bImage = ImageIO.read(ian);
 
      JFrame f = new JFrame("Server");
      ImageIcon icon = new ImageIcon(bImage);
      JLabel l = new JLabel();
      
      l.setIcon(icon);
      f.add(l);
      f.pack();
      f.setVisible(true);
   }
}

Output

Cpent Side Output

When you execute the cpent code, the following output appears on cpent side −

Server Side Output

When you execute the server code, the following ouptut appears on server side −

After receiving the image, the server displays the image as shown below −

Java DIP - Image Pixels

An image contains a two dimensional array of pixels. It is actually the value of those pixels that make up an image. Usually an image could be color or grayscale.

In Java, the BufferedImage class is used to handle images. You need to call getRGB() method of the BufferedImage class to get the value of the pixel.

Getting Pixel Value

The pixel value can be received using the following syntax−

Color c = new Color(image.getRGB(j, i));

Getting RGB Values

The method getRGB() takes the row and column index as a parameter and returns the appropriate pixel. In case of color image, it returns three values which are (Red, Green, Blue). They can be get as follows−

c.getRed();
c.getGreen();
c.getBlue();

Getting Width and Height of Image

The height and width of the image can be get by calpng the getWidth() and getHeight() methods of the BufferedImage class. Its syntax is given below−

int width = image.getWidth();
int height = image.getHeight();

Apart from these methods, there are other methods supported in the BufferedImage class. They are described briefly−

Example

The following example demonstrates the use of java BufferedImage class that displays pixels of an image of size (100 x 100)−

import java.awt.*;
import java.awt.image.BufferedImage;

import java.io.*;

import javax.imageio.ImageIO;
import javax.swing.JFrame;

class Pixel {
   BufferedImage image;
   int width;
   int height;
   
   pubpc Pixel() {
      try {
         File input = new File("blackandwhite.jpg");
         image = ImageIO.read(input);
         width = image.getWidth();
         height = image.getHeight();
         
         int count = 0;
         
         for(int i=0; i<height; i++) {
         
            for(int j=0; j<width; j++) {
            
               count++;
               Color c = new Color(image.getRGB(j, i));
               System.out.println("S.No: " + count + " Red: " + c.getRed() +"  Green: " + c.getGreen() + " Blue: " + c.getBlue());
            }
         }

      } catch (Exception e) {}
   }
   
   static pubpc void main(String args[]) throws Exception {
      Pixel obj = new Pixel();
   }
}

Output

When you execute the above example, it would print the pixels of the following image −

Original Image

Pixels Output

If you scroll down the ouput, the following pattern is seen−

Java DIP - GrayScale Conversion

In order to convert a color image to Grayscale image, you need to read pixels or data of the image using File and ImageIO objects, and store the image in BufferedImage object. Its syntax is given below −

File input = new File("digital_image_processing.jpg");
BufferedImage image = ImageIO.read(input);	

Further, get the pixel value using method getRGB() and perform GrayScale() method on it. The method getRGB() takes row and column index as parameter.

Color c = new Color(image.getRGB(j, i));
int red = (c.getRed() * 0.299);
int green =(c.getGreen() * 0.587);
int blue = (c.getBlue() *0.114);

Apart from these three methods, there are other methods available in the Color class as described briefly −

The last step is to add all these three values and set it again to the corresponding pixel value. Its syntax is given below −

int sum = red+green+blue;
Color newColor = new Color(sum,sum,sum);
image.setRGB(j,i,newColor.getRGB());

Example

The following example demonstrates the use of Java BufferedImage class that converts an image to Grayscale −

import java.awt.*;
import java.awt.image.BufferedImage;

import java.io.*;

import javax.imageio.ImageIO;
import javax.swing.JFrame;

pubpc class GrayScale {

   BufferedImage  image;
   int width;
   int height;
   
   pubpc GrayScale() {
   
      try {
         File input = new File("digital_image_processing.jpg");
         image = ImageIO.read(input);
         width = image.getWidth();
         height = image.getHeight();
         
         for(int i=0; i<height; i++) {
         
            for(int j=0; j<width; j++) {
            
               Color c = new Color(image.getRGB(j, i));
               int red = (int)(c.getRed() * 0.299);
               int green = (int)(c.getGreen() * 0.587);
               int blue = (int)(c.getBlue() *0.114);
               Color newColor = new Color(red+green+blue,
               
               red+green+blue,red+green+blue);
               
               image.setRGB(j,i,newColor.getRGB());
            }
         }
         
         File ouptut = new File("grayscale.jpg");
         ImageIO.write(image, "jpg", ouptut);
         
      } catch (Exception e) {}
   }
   
   static pubpc void main(String args[]) throws Exception {
      GrayScale obj = new GrayScale();
   }
}

Output

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

Original Image

Grayscale Image

Java DIP - Enhancing Image Contrast

In this chapter learn how to enhance the contrast of an image using histogram equapzation.

We use the OpenCV function equapzeHist() method. It can be found under Imgproc package. Its syntax is given below −

Imgproc.equapzeHist(source, destination);

The parameters are described below −

Apart from the equapzeHist() 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 enhance contrast of an image −

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.highgui.Highgui;
import org.opencv.imgproc.Imgproc;

pubpc class Main {

   static int width;
   static int height;
   static double alpha = 2;
   static double beta = 50;
   
   pubpc static void main( String[] args ) {
   
      try {
         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());
         
         Imgproc.equapzeHist(source, destination);
         Highgui.imwrite("contrast.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

Enhanced Contrast Image

Java DIP - Enhancing Image Brightness

In this chapter we enhance the brightness of an image by multiplying each pixel of the image with an alpha value and adding another beta value to it.

We OpenCV function convertTo that does the above operation automatically. It can be found under Mat package. Its syntax is given below −

int alpha = 2;
int beta = 50;
sourceImage.convertTo(destination, rtype , alpha, beta);		 

The parameters are described below −

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

Example

The following example demonstrates the use of Mat class to enhance brightness of an image −

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

pubpc class Main {
   static int width;
   static int height;
   static double alpha = 2;
   static double beta = 50;
   
   pubpc static void main( String[] args ) {
   
      try{
         System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
         Mat source =  Highgui.imread("digital_image_processing.jpg",Highgui.CV_LOAD_IMAGE_COLOR);
         Mat destination = new Mat(source.rows(),source.cols(),
         
         source.type());
         source.convertTo(destination, -1, alpha, beta);
         Highgui.imwrite("brightWithAlpha2Beta50.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

Enhanced Bright Image (Alpha=1 & Beta=50)

Enhanced Bright Image (Alpha=2 & Beta=50)

Java DIP - Enhancing Image Sharpness

In this chapter we learn to increase the sharpness of an image using Gaussian filter.

First we use OpenCV function GaussianBlur. It can be found under Imgproc package. Its syntax is given below −

Imgproc.GaussianBlur(source, destination, new Size(0,0), sigmaX);

The parameters are described briefly −

Further, we use OpenCV function addWeighted to apply image watermark to image. It can be found under Core package. Its syntax is given below −

Core.addWeighted(InputArray src1, alpha, src2, beta, gamma, OutputArray dst);

The parameters of this function are described below −

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

Example

The following example demonstrates the use of Imgproc and Core class to apply sharpening to an image −

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Size;
import org.opencv.highgui.Highgui;
import org.opencv.imgproc.Imgproc;

pubpc class Main {
   pubpc static void main( String[] args ) {
      try{
         System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
         Mat source = Highgui.imread("digital_image_processing.jpg",
         Highgui.CV_LOAD_IMAGE_COLOR);
         Mat destination = new Mat(source.rows(),source.cols(),source.type());
         Imgproc.GaussianBlur(source, destination, new Size(0,0), 10);
         Core.addWeighted(source, 1.5, destination, -0.5, 0, destination);
         Highgui.imwrite("sharp.jpg", destination);
      } catch (Exception e) {
      }
   }
}

Output

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

Original Image

Sharped Image

Java DIP - Image Compression Technique

An image can easily be compressed and stored through Java. Compression of image involves converting an image into jpg and storing it.

In order to compress an image, we read the image and convert into BufferedImage object.

Further, we get an ImageWriter from getImageWritersByFormatName() method found in the ImageIO class. From this ImageWriter, create an ImageWriteParam object. Its syntax is given below −

Iterator<ImageWriter> pst = ImageIO.getImageWritersByFormatName("jpg");
ImageWriteParam obj = writer_From_List.getDefaultWriteParam();

From this ImageWriteParam object, you can set the compression by calpng these two methods which are setCompressionMode() and setCompressionQuapty(). Their syntaxes are as given below −

obj.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
obj.setCompressionQuapty(0.05f);

The setCompressionMode() method takes Mode_EXPLICIT as the parameter. Some of the other MODES are described briefly −

Apart from the compressions methods, there are other methods provided by the ImageWriteParam class. They are described briefly −

Example

The following example demonstrates the use of ImageWriteParam class to compress an image −

import java.io.*;
import java.util.*;
import java.awt.image.*;

import javax.imageio.*;
import javax.imageio.stream.ImageOutputStream;

class Compression {

   pubpc static void main(String[] args) throws IOException {
   
      File input = new File("digital_image_processing.jpg");
      BufferedImage image = ImageIO.read(input);

      File compressedImageFile = new File("compress.jpg");
      OutputStream os =new FileOutputStream(compressedImageFile);

      Iterator<ImageWriter>writers =  ImageIO.getImageWritersByFormatName("jpg");
      ImageWriter writer = (ImageWriter) writers.next();

      ImageOutputStream ios = ImageIO.createImageOutputStream(os);
      writer.setOutput(ios);

      ImageWriteParam param = writer.getDefaultWriteParam();
      
      param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
      param.setCompressionQuapty(0.05f);
      writer.write(null, new IIOImage(image, null, null), param);
      
      os.close();
      ios.close();
      writer.dispose();
   }
}

Output

When you execute the given code, it compresses the image digital_image_processing.jpg to its equivalent compressed image and writes it on the hard disk with the name compress.jpg.

Original Image

Compressed Image - Quapty Factor − 0.05

Compressed Image - Quapty Factor − 0.5

Java DIP - Adding Border

In this chapter we learn to add different types of borders to an image.

We use OpenCV function copyMakeBorder. It can be found under Imgproc package. Its syntax is given below −

Imgproc.copyMakeBorder(source,destination,top,bottom,left,right,borderType);

The parameters are described below −

Apart from the copyMakeBorder() 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 add border to an image −

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;

pubpc class main {
   pubpc static void main( String[] args ) {
   
      try {
         System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
         Mat source = Highgui.imread("digital_image_processing.jpg",
         
         Highgui.CV_LOAD_IMAGE_COLOR);
         Mat destination = new Mat(source.rows(),source.cols(),source.type());
         
         int top, bottom, left, right;
         int borderType;

         /// Initiapze arguments for the filter
         top = (int) (0.05*source.rows()); 
         bottom = (int) (0.05*source.rows());
         left = (int) (0.05*source.cols()); 
         right = (int) (0.05*source.cols());

         destination = source;
         Imgproc.copyMakeBorder(source, destination, top, bottom, left, right, Imgproc.BORDER_WRAP);
         Highgui.imwrite("borderWrap.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

Isolated Border Image

Wrapped Border Image

Reflect Border Image

Java DIP - Image Pyramids

Image pyramid is nothing but a method to display a multi-resolution image. The lowermost layer is a highest-resolution version of image and the topmost layer is a lowest-resolution version of the image. Image pyramids are used to handle image at different scales.

In this chapter we perform some down samppng and up samppng on images.

We use OpenCV functions pyrUp and pyrDown. They can be found under Imgproc package. Its syntax is given below −

Imgproc.pyrUp(source, destination, destinationSize);
Imgproc.pyrDown(source, destination,destinationSize);

The parameters are described below −

Apart from the pyrUp and pyrDown methods, there are other methods provided by the Imgproc class. They are described briefly −

Example

The following example demonstrates the use of Imgproc class to perform up samppng and down samppng on an image.

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

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

pubpc class main {
   pubpc static void main( String[] args ) {
   
      try{
      
         System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
         Mat source = Highgui.imread("digital_image_processing.jpg",
         Highgui.CV_LOAD_IMAGE_COLOR);
         
         Mat destination1 = new Mat(source.rows()*2, source.cols()*2,source.type());
         destination1 = source;
         
         Imgproc.pyrUp(source, destination1, new  Size(source.cols()*2   source.rows()*2));
         Highgui.imwrite("pyrUp.jpg", destination1);
         
         source = Highgui.imread("digital_image_processing.jpg", 
         Highgui.CV_LOAD_IMAGE_COLOR);
         
         Mat destination = new Mat(source.rows()/2,source.cols()/2, source.type());
         destination = source;
         Imgproc.pyrDown(source, destination, new Size(source.cols()/2,  source.rows()/2));
         Highgui.imwrite("pyrDown.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

On the original image, pyrUp(UP Samppng) and pyrDown(Down Samppng) are performed. The output after samppng is as shown below −

PyrUP Image

pyrDown Image

Java DIP - Basic Thresholding

Thresholding enables to achieve image segmentation in the easiest way. Image segmentation means spaniding the complete image into a set of pixels in such a way that the pixels in each set have some common characteristics. Image segmentation is highly useful in defining objects and their boundaries.

In this chapter we perform some basic thresholding operations on images.

We use OpenCV function threshold. It can be found under Imgproc package. Its syntax is given below −

Imgproc.threshold(source, destination, thresh , maxval , type);

The parameters are described below −

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

Example

The following example demonstrates the use of Imgproc class to perform thresholding operations to an image −

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;

pubpc class main {
   pubpc static void main( String[] args ) {
   
      try{

         System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
         Mat source = Highgui.imread("digital_image_processing.jpg",  Highgui.CV_LOAD_IMAGE_COLOR);
         Mat destination = new Mat(source.rows(),source.cols(),source.type());

         destination = source;
         Imgproc.threshold(source,destination,127,255,Imgproc.THRESH_TOZERO);
         Highgui.imwrite("ThreshZero.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

On the above original image, some thresholding operations is performed which is shown in the output below −

Thresh Binary

Thresh Binary Invert

Thresh Zero

Java DIP - Image Shape Conversion

The shape of the image can easily be changed by using OpenCV. Image can either be fppped, scaled, or rotated in any of the four directions.

In order to change the shape of the image, we read the image and convert 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.

Fppping an Image

OpenCV allows three types of fpp codes which are described below −

We pass the appropriate fpp code into method fpp() in the Core class. Its syntax is given below −

Core.fpp(source mat, destination mat1, fpp_code);

The method fpp() takes three parameters − the source image matrix, the destination image matrix, and the fpp code.

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

Example

The following example demonstrates the use of Core class to fpp an image −

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;

pubpc class Main {
   pubpc 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);
         Core.fpp(mat, mat1, -1);

         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 run the above example, it would fpp an image name digital_image_processing.jpg to its equivalent HSV color space image and write it on hard disk with name fpp.jpg.

Original Image

Fppped Image

Java DIP - Applying Gaussian Filter

In this chapter, we apply Gaussian filter to an image that blurs an image. We are going to use OpenCV function GaussianBlur to apply Gaussian filter to images. It can be found under Imgproc package. Its syntax is given below −

Imgproc.GaussianBlur(source, destination,Size,SigmaX);

The function arguments are described below −

Apart from the GaussianBlur 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 Gaussian filter to an image.

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

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


pubpc class Main {
   pubpc static void main( String[] args ) {
   
      try {
         System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
         
         Mat source = Highgui.imread("digital_image_processing.jpg",
         Highgui.CV_LOAD_IMAGE_COLOR);
         
         Mat destination = new Mat(source.rows(),source.cols(),source.type());
         Imgproc.GaussianBlur(source, destination,new Size(45,45), 0);
         Highgui.imwrite("Gaussian45.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

When this original image is convolved with the Gaussian filter of size 11 and 45, the following output is seen.

Gaussian filter of size 11

Gaussian filter of size 45

Java DIP - Applying Box Filter

We apply Box filter that blurs an image. A Box filter could be of dimensions 3x3, 5x5, 9x9 etc.

We use OpenCV function filter2D to apply Box 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 provided by the Imgproc class. They are described briefly −

Example

The following example demonstrates the use of Imgproc class to apply Box filter 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;

pubpc class convolution {
   pubpc 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++) {
                  m[k] = m[k]/(kernelSize * kernelSize);
               }
               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

In this example we convolve our image with the following filter (kernel). This filter results in blurring an image as its size increases.

This original image has been convolved with the box filter of size 5, which is given below −

Box filter of size 5

Convolved Image (with Box Filter of Size 5)

Convolved Image (with Box Filter of Size 9)

Java DIP - Eroding and Dilating

In this chapter we learn apply two very common morphology operators:Dilation and Erosion.

We use OpenCV function erode and dilate. They can be found under Imgproc package. Its syntax is given below −

Imgproc.erode(source, destination, element);
Imgproc.dilate(source, destination, element);				

The parameters are described below −

Apart from erode() and dilate() methods, there are other methods provided by the Imgproc class. They are described briefly −

Example

The following example demonstrates the use of Imgproc class to perform erosion and dilation on an image −

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;

pubpc class main {
   pubpc static void main( String[] args ) {
   
      try{	
         System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
         Mat source = Highgui.imread("digital_image_processing.jpg",  Highgui.CV_LOAD_IMAGE_COLOR);
         Mat destination = new Mat(source.rows(),source.cols(),source.type());
         
         destination = source;

         int erosion_size = 5;
         int dilation_size = 5;
         
         Mat element = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new  Size(2*erosion_size + 1, 2*erosion_size+1));
         Imgproc.erode(source, destination, element);
         Highgui.imwrite("erosion.jpg", destination);

         source = Highgui.imread("digital_image_processing.jpg",  Highgui.CV_LOAD_IMAGE_COLOR);
         
         destination = source;
         
         Mat element1 = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new  Size(2*dilation_size + 1, 2*dilation_size+1));
         Imgproc.dilate(source, destination, element1);
         Highgui.imwrite("dilation.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

On the above original image, some erosion and dilation operations have been performed which have been shown in the output below −

Erosion

Dilation

Java DIP - Applying Watermark

In this chapter we learn two ways of applying watermark on images. These ways are −

Applying Text Watermark

Applying Image watermark

Applying Text Watermark

We use OpenCV function putText to apply text watermark to image. It can be found under Core package. Its syntax is given below −

Core.putText(source, Text, Point, fontFace ,fontScale , color);

The parameters of this function are described below −

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

Example

The following example demonstrates the use of Core class to apply text watermark to an image −

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

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

pubpc class Main {
   pubpc static void main( String[] args ) {
   
      try{
         System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
         Mat source = Highgui.imread("digital_image_processing.jpg",  Highgui.CV_LOAD_IMAGE_COLOR);
         Mat destination = new Mat(source.rows(),source.cols(), source.type());  
         
         Core.putText(source, "Tutorialspoint.com", new Point  (source.rows()/2,source.cols()/2), Core.FONT_ITALIC,new Double(1),new  Scalar(255));

         Highgui.imwrite("watermarked.jpg", source);
         
      } catch (Exception e) {
         System.out.println("Error: "+e.getMessage());
      }
   }
}

Output

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

Original Image

Text Watermarked Image

Applying Image Watermark on Image

We are going to use OpenCV function addWeighted to apply image watermark to image. It can be found under Core package. Its syntax is given below −

Core.addWeighted(InputArray src1, alpha, src2 (Watermark image), beta, gamma, OutputArray dst);

The parameters of this function are described below −

Example

The following example demonstrates the use of Core class to apply image watermark to an image −

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

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

pubpc class Main {
   pubpc static void main( String[] args ) {
   
      try{
         System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
         
         Mat source = Highgui.imread("digital_image_processing.jpg",  Highgui.CV_LOAD_IMAGE_COLOR);
         Mat waterMark = Highgui.imread("watermark.png",  Highgui.CV_LOAD_IMAGE_COLOR);
         Rect ROI = new Rect(waterMark.rows() * 4,waterMark.cols(),  waterMark.cols(),waterMark.rows());
         
         Core.addWeighted(source.submat(ROI), 0.8, waterMark, 0.2, 1,  source.submat(ROI));
         Highgui.imwrite("watermarkedImage.jpg", source);
         
      } catch (Exception e) {
         System.out.println("Error: " + e.getMessage());
      }
   }
}

Output

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

Original Image

The Watermark Image

Watermarked Image

Java DIP - Understand Convolution

Convolution is a mathematical operation on two functions f and g. The function f and g in this case are images, since an image is also a two dimensional function.

Performing Convolution

In order to perform convolution on an image, following steps are taken −

Fpp the mask (horizontally and vertically) only once.

Spde the mask onto the image.

Multiply the corresponding elements and then add them.

Repeat this procedure until all values of the image has been calculated.

We use OpenCV function filter2D to apply convolution 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 −

Example

The following example demonstrates the use of Imgproc class to perform convolution on 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;

pubpc class convolution {
   pubpc static void main( String[] args ) {
   
      try {
         int kernelSize = 3;
         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,0);
               put(0,2,0);

               put(1,0,0);
               put(1,1,1);
               put(1,2,0);

               put(2,0,0);
               put(2,1,0);
               put(2,2,0);
            }
         };
         
         Imgproc.filter2D(source, destination, -1, kernel);
         Highgui.imwrite("original.jpg", destination);
         
      } catch (Exception e) {
          System.out.println("Error:" + e.getMessage());
      }
   }
}

Output

In this example we convolve our image with the following filter(kernel). This filter results in producing original image as it is −

Original Image

Convolved Image

Java DIP - Prewitt Operator

Prewitt operator is used for edge detection in an image. It detects two types of edges: vertical edges and horizontal edges.

We use OpenCV function filter2D to apply Prewitt 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 Prewitt 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;

pubpc class convolution {
   pubpc 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-1);
               put(1,1,0);
               put(1,2,1);

               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 Prewitt operator of vertical edges as given below −

Vertical direction

Convolved Image(Vertical Direction)

This original image has also been convolved with the Prewitt operator of horizontal edges, which is given below −

Horizontal Direction

Convolved Image(Horizontal Direction)

Java DIP - Sobel Operator

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;

pubpc class convolution {
   pubpc 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)

Java DIP - Kirsch Operator

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;

pubpc class convolution {
   pubpc 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)

Java DIP - Robinson Operator

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;

pubpc class convolution {
   pubpc 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)

Java DIP - Laplacian Operator

Laplacian Operator is also a derivative operator which is used to find edges in an image. The major difference between Laplacian and other operators pke 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;

pubpc class convolution {
   pubpc 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)

Java DIP - Weighted Average Filter

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;

pubpc class convolution {
   pubpc 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

Java DIP - Create Zooming Effect

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;

pubpc class Main {
   pubpc 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)

Java DIP - Open Source Libraries

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

ImageJ

Fiji

Commons Imaging

ImageMagick

Endrov

LeadTools

OpenCv

ImageJ

ImageJ is a pubpc 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 −

Commons Imaging

Apache Commons Imaging, previously known as Apache Commons Sanselan, is a pbrary 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, fpp, mirror, rotate, distort, shear, and transform images, adjust image colors, apply various special effects, or draw text, pnes, polygons, elppses, 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 pcense 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 apppcations. Written in optimized C/C++, the pbrary can take advantage of multi-core processing.

Some basic features of OpenCV are described briefly −

Java DIP - Introduction to OpenCV

OpenCV is released under a BSD pcense 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 apppcations. Written in optimized C/C++, the pbrary 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 apppcations.

Download OpenCV

You can download OpenCV from their official Website here.

Create User Library

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

Launch Ecppse

Select Window -> Preferences from the menu.

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

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

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

Browse through C:OpenCV-2.4.6uildjava and select opencv-246.jar. After adding the jar, extend the opencv-246.jar and select Native pbrary location and press Edit.

Select External Folder... and browse to select the folder C:OpenCV-2.4.6uildjavax64. 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 pbrary is created. Now you can reuse this configuration in any of the project.

Create OpenCV Project

Create a new java project in ecppse.

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

Cpck finish and you are done.

Java DIP - OpenCV GrayScale Conversion

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 psted 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;

pubpc class Main {
   pubpc 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

Java DIP - OpenCV Color Space Conversion

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;

pubpc class Main {
   pubpc 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)