Java Dip Tutorial PDF
Java Dip Tutorial PDF
Audience
This reference has been prepared for the beginners to help them understand and
implement the basic to advance algorithms of digital image processing in java.
Prerequisites
Before proceeding with this tutorial, you need to have a basic knowledge of digital
image processing and Java programming language.
Contents
About the Tutorial .................................................................................................................................... i
Audience .................................................................................................................................................. i
Prerequisites ............................................................................................................................................ i
Disclaimer & Copyright............................................................................................................................. i
Contents.................................................................................................................................................. ii
1.
2.
3.
4.
5.
GRAYSCALE CONVERSION.................................................................................................. 19
ii
6.
7.
8.
9.
iii
iv
vi
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.
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 isRasterPremultiplied, 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)
Methods
Sr. No.
Methods
copyData(WritableRaster outRaster)
It computes an arbitrary rectangular region of the BufferedImage and
copies it into a specified WritableRaster.
getColorModel()
It returns object of class ColorModel of an image.
getData()
It returns the image as one large tile.
getData(Rectangle rect)
It computes and returns an arbitrary region of the BufferedImage.
getGraphics()
This method returns a Graphics2D, retains backwards compatibility.
getHeight()
It returns the height of the BufferedImage.
getMinX()
It returns the minimum x coordinate of this BufferedImage.
getMinY()
It returns the minimum y coordinate of this BufferedImage.
getRGB(int x, int y)
It returns an integer pixel in the default
(TYPE_INT_ARGB) and default sRGB colorspace.
10
RGB
color
model
getType()
It returns the image type.
Example
The following example demonstrates the use of java BufferedImage class that draws
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;
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;
}
public 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:
3. 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:
Sr. No.
Methods
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;
outputStream.write(buffer, 0, length);
}
inputStream.close();
outputStream.close();
}catch(Exception e){
System.out.println("Exception: " + e.getMessage());
}
}
}
Output
When you execute the given code, the following output is seen:
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:
Sr. No.
Methods
This method resets the number of valid bytes of the byte array output
stream to zero, so that all the accumulated output in the stream is
discarded.
2
Example
The following example demonstrates ByteArrayOutputStream to upload an image to
the server:
Client Code
import javax.swing.*;
import java.net.*;
import java.awt.image.*;
import javax.imageio.*;
import java.io.*;
import java.awt.image.BufferedImage;
10
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
11
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 {
public static void main(String
ServerSocket server=null;
Socket socket;
server=new ServerSocket(4000);
System.out.println("Server Waiting for image");
socket=server.accept();
System.out.println("Client connected.");
InputStream in = socket.getInputStream();
DataInputStream dis = new DataInputStream(in);
12
Output
Client Side Output
When you execute the client code, the following output appears on client side:
After receiving the image, the server displays the image as shown below:
14
4. 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.
Methods
copyData(WritableRaster outRaster)
15
getColorModel()
It returns ColorModel of an image.
getData()
It returns the image as one large tile.
getData(Rectangle rect)
It computes and returns an arbitrary region of the BufferedImage.
getGraphics()
This method returns a Graphics2D, but is here for backwards compatibility.
getHeight()
It returns the height of the BufferedImage.
getMinX()
It returns the minimum x coordinate of this BufferedImage.
getMinY()
It returns the minimum y coordinate of this BufferedImage.
getRGB(int x, int y)
It returns an integer pixel in the default
(TYPE_INT_ARGB) and default sRGB colorspace.
10
RGB
color
model
getType()
It returns the image type.
Example
The following example demonstrates the use of java BufferedImage class that
displays pixels of an image of size (10 x 10):
import java.awt.*;
16
import java.awt.image.BufferedImage;
import java.io.*;
import javax.imageio.ImageIO;
import javax.swing.JFrame;
class Pixel {
BufferedImage
image;
int width;
int height;
public 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 public void main(String args[]) throws Exception
{
Pixel obj = new Pixel();
17
}
}
Output
When you execute the above example, it would print the pixels of the following
image:
Original Image
Pixels Output
18
5. 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:
Sr. No.
Method
brighter()
It creates a new Color that is a brighter version of this Color.
darker()
It creates a new Color that is a darker version of this Color.
getAlpha()
It returns the alpha component in the range 0-255.
19
toString()
It returns a string representation of this Color.
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;
public class GrayScale {
BufferedImage
image;
int width;
int height;
public 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++){
20
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.
21
Original Image
Grayscale Image
22
In this chapter we learn how to enhance the contrast of an image using histogram
equalization.
We use the OpenCV function equalizeHist() method. It can be found under Imgproc
package. Its syntax is given below:
Imgproc.equalizeHist(source, destination);
The parameters are described below:
Sr. No.
Parameters
Source
It is 8-bit single channel source image.
Destination
It is the destination image.
Apart from the equalizeHist() method, there are other methods provided by the
Imgproc class. They are described briefly:
Sr. No.
Method
filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double
delta)
It convolves an image with the kernel.
23
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;
}catch (Exception e) {
System.out.println("error: " + e.getMessage());
}
}
}
Output
When you execute the given code, the following output is seen:
Original Image
25
Parameters
destination
It is destination image.
rtype
It is desired output matrix type or rather the depth, since the number of
channels are the same as the input. If rtype is negative, the output matrix
has the same type as the input.
alpha
It is optional scale factor.
beta
It is optional delta added to the scaled values.
Apart from the convertTo() method, there are other methods provided by the Mat
class. They are described briefly:
Sr. No.
Methods
26
copyTo(Mat m)
It copies the matrix to another one.
diag()
It extracts a diagonal from a matrix, or creates a diagonal matrix.
dot(Mat m)
It computes a dot-product of two vectors.
reshape(int cn)
It changes the shape and/or the number of channels of a 2D matrix without
copying the data.
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;
27
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
28
29
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:
Sr. No.
Parameters
source
It is source image.
destination
It is destination image.
Size
It is Gaussian kernel size.
sigmaX
It is Gaussian kernel standard deviation in X direction.
Parameters
src1
It is first input array.
alpha
It is weight of the first array elements.
30
src2
It is second input array of the same size and channel number as src1.
Beta
It is weight of the second array elements.
gamma
It is scalar added to each sum.
Dst
It is output array that has the same size and number of channels as the
input arrays.
Apart from the GaussianBlur() method, there are other methods provided by the
Imgproc class. They are described briefly:
Sr. No.
Methods
filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double
delta)
It convolves an image with the kernel.
31
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;
32
Output
When you execute the given code, the following output is seen:
Original Image
Sharpened Image
33
9. IMAGE COMPRESSION
TECHNIQUES
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> list = ImageIO.getImageWritersByFormatName("jpg");
ImageWriteParam obj = writer_From_List.getDefaultWriteParam();
From this ImageWriteParam object, you can set the compression by calling these two
methods which are setCompressionMode() and setCompressionQuality(). Their
syntaxes are as given below:
obj.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
obj.setCompressionQuality(0.05f);
The setCompressionMode() method takes Mode_EXPLICIT as the parameter. Some
of the other MODES are described briefly:
Sr. No.
Modes
MODE_DEFAULT
It is a constant value that may be passed into methods to enable that
feature for future writes.
MODE_DISABLED
It is a constant value that may be passed into methods to disable that
feature for future writes.
MODE_EXPLICIT
It is a constant value that may be passed into methods to enable that
feature for future writes.
34
Methods
canOffsetTiles()
It returns true if the writer can perform tiling with non-zero grid offsets
while writing.
getBitRate(float quality)
It returns a float indicating an estimate of the number of bits of output
data for each bit of input image data at the given quality level.
getLocale()
It returns the currently set Locale, or null if only a default Locale is
supported.
isCompressionLossless()
It returns true if the current compression type provides lossless
compression.
unsetCompression()
It removes any previous compression type and quality settings.
unsetTiling()
It removes any previous tile grid parameters specified by calls to setTiling.
Example
The following example demonstrates the use of ImageWriteParam class to compress
an image:
import java.io.*;
import java.util.*;
import javax.imageio.*;
import java.awt.image.*;
import javax.imageio.stream.ImageOutputStream;
35
class Compresssion {
Iterator<ImageWriter>writers =
ImageIO.getImageWritersByFormatName("jpg");
ImageWriter writer = (ImageWriter) writers.next();
36
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
37
38
Parameters
source
It is source image.
destination
It is destination image.
top
It is the length in pixels of the border at the top of the image.
bottom
Length in pixels of the border at the bottom of the image.
left
It is the length in pixels of the border at the left of the image.
right
It is the length in pixels of the border at the right of the image.
borderType
It defines the type
BORDER_REPLICATE,
BORDER_CONSTANT etc.
of
39
Methods
filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double
delta)
It convolves an image with the kernel.
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;
40
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:
41
Original Image
43
Parameters
source
It is the source image.
destination
It is the destination image.
destinationSize
It is the size of the output image. By default, it is computed as
Size((src.cols*2), (src.rows*2)).
Apart from the pyrUp and pyrDown methods, there are other methods provided by
the Imgproc class. They are described briefly:
Sr. No.
Methods
44
filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double
delta)
It convolves an image with the kernel.
Example
The following example demonstrates the use of Imgproc class to perform up sampling
and down sampling 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;
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:
46
Original Image
On the original image, pyrUp (UP Sampling) and pyrDown (Down Sampling) are
performed. The output after sampling is as shown below:
47
PyrUP Image
pyrDown Image
48
Parameters
source
It is source image.
destination
It is destination image.
thresh
It is threshold value.
maxval
It is the maximum value to be used with the THRESH_BINARY and
THRESH_BINARY_INV threshold types.
type
The possible types are THRESH_BINARY,
THRESH_TRUNC, and THRESH_TOZERO.
THRESH_BINARY_INV,
49
Methods
filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double
delta)
It convolves an image with the kernel.
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;
50
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
51
Thresh Binary
52
Thresh Zero
53
The shape of the image can easily be changed by using OpenCV. Image can either
be flipped, 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.
Flipping an Image
OpenCV allows three types of flip codes which are described below:
Sr. No.
Flip Code
0
0 means, flipping around x axis.
1
1 means, flipping around y axis.
-1
-1 means, flipping around both axis.
We pass the appropriate flip code into method flip() in the Core class. Its syntax is
given below:
Core.flip(source mat, destination mat1, flip_code);
The method flip() takes three parameters: the source image matrix , the destination
image matrix, and the flip code.
Apart from the flip method, there are other methods provided by the Core class. They
are described briefly:
54
Sr. No.
Methods
sumElems(Mat src)
It blurs an image using a Gaussian filter.
Example
The following example demonstrates the use of Core class to flip 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;
55
56
}
}
Output
When you run the above example, it would flip an image name
digital_image_processing.jpg to its equivalent HSV color space image and write it on
hard disk with name flip.jpg.
Original Image
Flipped Image
57
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:
Sr. No.
Argument
source
It is source image.
destination
It is destination image.
Size
It is Gaussian kernel size.
SigmaX
It is Gaussian kernel standard deviation in X direction.
Apart from the GaussianBlur method, there are other methods provided by the
Imgproc class. They are described briefly:
Sr. No.
Methods
58
filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double
delta)
It convolves an image with the kernel.
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;
} 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:
60
61
We apply Box filter that blurs an image. A Box filter could be of dimensions 3x3, 5x5,
9x9 etc.
We use the OpenCV function filter2D() to apply Box filter to images. It can be found
under Imgproc package. Its syntax is given below:
filter2D(src, dst, ddepth, kernel, anchor, delta, BORDER_DEFAULT );
The function arguments are described below:
Sr. No.
Arguments
src
It is source image.
dst
It is destination image.
ddepth:
It is the depth of dst. A negative value (such as -1) indicates that the
depth is the same as the source.
kernel
It is the kernel to be scanned through the image.
anchor
It is the position of the anchor relative to its kernel. The location Point (1, -1) indicates the center by default.
Delta
It is a value to be added to each pixel during the convolution. By default
it is 0.
BORDER_DEFAULT
We let this value by default.
62
Methods
filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double
delta)
It convolves an image with the kernel.
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;
63
64
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:
1/25
1/25
1/25
1/25
1/25
1/25
1/25
1/25
1/25
1/25
1/25
1/25
1/25
1/25
1/25
1/25
1/25
1/25
1/25
1/25
1/25
1/25
1/25
1/25
65
66
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:
Sr. No.
Parameters
source
It is source image.
destination
It is destination image.
element
It is a structuring element used for erosion and dilation, if
element=Mat(), a 3 x 3 rectangular structuring element is used.
Apart from erode() and dilate() methods, there are other methods provided by the
Imgproc class. They are described briefly:
Sr. No.
Method
67
filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double
delta)
It convolves an image with the kernel.
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;
68
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:
69
Original Image
On the above original image, some erosion and dilation operations have been
performed which have been shown in the output below:
Erosion
70
Dilation
71
In this chapter we learn two ways of applying watermark on images. These ways are:
1. Applying Text Watermark
2. Applying Image watermark
Parameters
Source
It is source image.
Text
It is the string text that would appear on the image.
Point
It is the point where text should appear on image.
fontFace
It
is
font
type.
For
example:
FONT_HERSHEY_SIMPLEX,
FONT_HERSHEY_PLAIN, FONT_HERSHEY_COMPLEX etc.
fontScale
It is font scale factor that is multiplied by the font-specific base size.
color
It is text color.
72
Methods
normalize(Mat src, Mat dst, double alpha, double beta, int norm_type)
It normalizes the norm or value range of an array.
reduce(Mat src, Mat dst, int dim, int rtype, int dtype)
It reduces a matrix to a vector.
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;
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:
74
Original Image
75
Parameters
src1
It is first input array.
alpha
It is the weight of the first array elements.
src2
It is the second input array of the same size and channel number as
src1.
beta
It is the weight of the second array elements.
gamma
It is the scalar added to each sum.
dst
It is the output array that has the same size and number of channels
as the input arrays.
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;
76
Output
When you execute the given code, the following output is seen:
77
Original Image
78
Watermarked Image
79
18. UNDERSTANDING
CONVOLUTION
Performing Convolution
In order to perform convolution on an image, following steps are taken:
Repeat this procedure until all values of the image has been calculated.
We use the OpenCV function filter2D() to apply convolution to images. It can be found
under Imgproc package. Its syntax is given below:
filter2D(src, dst, ddepth , kernel, anchor, delta, BORDER_DEFAULT );
The function arguments are described below:
Sr. No.
Arguments
src
It is source image.
dst
It is destination image.
ddepth:
It is the depth of dst. A negative value (such as -1) indicates that the depth
is the same as the source.
kernel
It is the kernel to be scanned through the image.
anchor
80
It is the position of the anchor relative to its kernel. The location Point (-1,
-1) indicates the center by default.
6
delta
It is a value to be added to each pixel during the convolution. By default it
is 0.
BORDER_DEFAULT
We let this value by default.
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;
public class convolution {
public 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){
{
81
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:
0
82
Original Image
Convolved Image
83
Arguments
src
It is source image.
dst
It is destination image.
ddepth:
It is the depth of dst. A negative value (such as -1) indicates that the
depth is the same as the source.
kernel
It is the kernel to be scanned through the image.
anchor
It is the position of the anchor relative to its kernel. The location Point (1, -1) indicates the center by default.
delta
It is a value to be added to each pixel during the convolution. By default
it is 0.
BORDER_DEFAULT
We let this value by default.
84
Methods
filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double
delta)
It convolves an image with the kernel.
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;
85
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());
86
}
}
}
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
-1
-1
-1
87
This original image has also been convolved with the Prewitt operator of horizontal
edges, which is given below:
Horizontal Direction
-1
-1
-1
88
89
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 the OpenCV function filter2D() to apply Sobel operator to images.
It can be found under Imgproc package. Its syntax is given below:
filter2D(src, dst, ddepth, kernel, anchor, delta, BORDER_DEFAULT );
The function arguments are described below:
Sr. No.
Argument
src
It is source image.
dst
It is destination image.
ddepth:
It is the depth of dst. A negative value (such as -1) indicates that the depth
is the same as the source.
kernel
It is the kernel to be scanned through the image.
anchor
It is the position of the anchor relative to its kernel. The location Point (-1,
-1) indicates the center by default.
Delta
It is a value to be added to each pixel during the convolution. By default it
is 0.
BORDER_DEFAULT
We let this value by default.
90
Methods
filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double
delta)
It convolves an image with the kernel.
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;
91
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());
92
}
}
}
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
-1
-2
-1
93
This original image is convolved with the Sobel operator of horizontal edges, which
is given below:
Horizontal Direction
-1
-2
-1
94
95
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 the OpenCV function filter2D() to apply Kirsch operator to
images. It can be found under Imgproc package. Its syntax is given below:
filter2D(src, dst, ddepth , kernel, anchor, delta, BORDER_DEFAULT);
The function arguments are described below:
Sr. No.
Argument
src
It is source image.
dst
It is destination image.
ddepth:
It is the depth of dst. A negative value (such as -1) indicates that the
depth is the same as the source.
Kernel
It is the kernel to be scanned through the image.
Anchor
It is the position of the anchor relative to its kernel. The location Point (1, -1) indicates the center by default.
Delta
It is a value to be added to each pixel during the convolution. By default
it is 0.
BORDER_DEFAULT
96
Methods
filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double
delta)
It convolves an image with the kernel.
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;
97
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) {
98
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 as given
below:
Kirsch East
-3
-3
-3
-3
-3
99
This original image is convolved with the Kirsch operator of South West edges as
given below:
-3
-3
-3
-3
-3
100
101
Argument
src
It is source image.
dst
It is destination image.
ddepth:
It is the depth of dst. A negative value (such as -1) indicates that the depth
is the same as the source.
kernel
It is the kernel to be scanned through the image.
anchor
It is the position of the anchor relative to its kernel. The location Point (-1,
-1) indicates the center by default.
Delta
It is a value to be added to each pixel during the convolution. By default it
is 0.
BORDER_DEFAULT
102
Methods
filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double
delta)
It convolves an image with the kernel.
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;
103
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) {
104
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:
-2
-1
105
This original image has also been convolved with the Robinson operator of East edges
as given below:
-2
-1
106
107
Arguments
Src
It is source image.
Dst
It is destination image.
ddepth:
It is the depth of dst. A negative value (such as -1) indicates that the
depth is the same as the source.
kernel
It is the kernel to be scanned through the image.
anchor
It is the position of the anchor relative to its kernel. The location Point (1, -1) indicates the center by default.
delta
It is a value to be added to each pixel during the convolution. By default
it is 0.
BORDER_DEFAULT
108
Apart from the filter2D() method, there are other methods provided by the Imgproc
class. They are described briefly:
Sr. No.
Methods
filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double
delta)
It convolves an image with the kernel.
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;
109
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);
110
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
0
-1
-1
-1
-1
111
This original image is convolved with the Laplacian Positive operator as given below:
Laplacian Positive
0
-4
112
113
Arguments
src
It is source image.
dst
It is destination image.
ddepth:
It is the depth of dst. A negative value (such as -1) indicates that the depth
is the same as the source.
kernel
It is the kernel to be scanned through the image.
anchor
It is the position of the anchor relative to its kernel. The location Point (-1,
-1) indicates the center by default.
Delta
It is a value to be added to each pixel during the convolution. By default it
is 0.
114
BORDER_DEFAULT
We let this value by default.
Apart from the filter2D() method, there are other methods provide by the Imgproc
class. They are described briefly:
Sr. No.
Methods
filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double
delta)
It convolves an image with the kernel.
Example
The following example demonstrates the use of Imgproc class to apply weighted
average 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;
115
116
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:
10
117
Convolved Image
118
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:
Sr. No.
Interpolation methods
INTER_NEAREST
It is nearest-neighbor interpolation.
INTER_LINEAR
It is bilinear interpolation (used by default).
INTER_AREA
It is resampling using pixel area relation. It may be a preferred method for
image decimation, as it gives more-free results.
INTER_CUBIC
It is a bi-cubic interpolation over 4x4 pixel neighborhood.
INTER_LANCZOS4
It is a Lanczos interpolation over 8x8 pixel neighborhood.
119
Methods
filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double
delta)
It convolves an image with the kernel.
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;
120
{
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
121
122
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:
Sr. No.
Features
Runs Everywhere
ImageJ is written in Java, which allows it to run on Linux, Mac OS X and
Windows, in both 32-bit and 64-bit modes.
Open Source
ImageJ and its Java source code are freely available and in the public
domain.
Toolkit
Use ImageJ as an image processing toolkit (class library) to develop
applets, servlets, or applications.
Data Types
8-bit grayscale or indexed color, 16-bit unsigned integer, 32-bit floatingpoint, and RGB color.
123
File Formats
Open and save GIF, JPEG, BMP, PNG, PGM, FITS, and ASCII. Open DICOM.
Open TIFFs, GIFs, JPEGs, DICOMs, and raw data using a URL.
Selections
Create rectangular, elliptical, or irregular area selections. Create line and
point selections.
Image Enhancement
Supports smoothing, sharpening, edge detection, median filtering, and
thresholding on both 8-bit grayscale and RGB color images.
Color Processing
Split a 32-bit color image into RGB or HSV components. Merge 8-bit
components into a color image.
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:
Sr. No.
Features
Registering 3D images
This involves Elastic Alignment and Montage, Feature Extraction, Image
Stabilizer etc.
Segmenting images
It offers more than 35 types of segmentation.
Scripting
124
Developing Plug-ins
Use the Script Editor to start developing plug-ins and then run the plugins.
ImageJ Tricks
ImageJ is easy to use, but sometimes you wish for some function that is
actually implemented, yet you do not know how to trigger.
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 metadata.
Some of the basic features of ImageJ are described below:
Sr. No.
Features
Java
Apache Commons Imaging is written in 100% pure Java. It executes on
any JVM and any platform, without modification.
Image Formats
It reads and writes a wide variety of image formats, and supports some
variations and encodings missed by all or most other libraries.
Metadata support
It supports reading and writing a variety of meta data in a structured way,
including EXIF meta data.
Network Friendly
It is network-friendly. Commons Imaging only reads the data it needs, and
caches what is read so that it is not too heavy on the network.
Easy to use
125
Transparent
Commons Imaging aims to be transparent. There are no hidden buffers to
dispose, no native memory to free, no background threads.
Open Source
It is Free Software/Open Source. It is available under the Apache Software
License.
Color Conversions
The ColorConversions class offers methods to convert between the
following color spaces: CIE-L*CH, CIE-L*ab, CIE-L*uv, CMY, CMYK, HSL,
HSV, Hunter-Lab, RGB, XYZ, and YXY.
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:
Sr. No.
Features
Format conversion
It converts an image from one format to another (e.g. PNG to JPEG).
Transform
It can resize, rotate, crop, flip or trim an image.
Transparency
It renders portions of an image invisible.
Draw
It adds shapes or text to an image.
126
Decorate
It adds a border or frame to an image.
Special effects
It can Blur, sharpen, threshold, or tint an image.
Animation
It can create a GIF animation sequence from a group of images.
Composite
It can overlap one image over another.
Morphology of shapes
It extracts features, describe shapes and recognize patterns in images.
10
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:
Sr. No.
Features
View data
It views data, in 2D and 3D. Designed to handle complex 4D data schemes
and unlimited number of channels, where each channel can have its own
X, Y, and Z resolution.
127
Lazy Evaluation
It is designed from the ground to handle large image sets. Endrov uses
lazy evaluation, a concept mostly available in research programming
languages.
Scripting language
It supports graphical scripting language, as well as traditional scripting.
Java
Written in Java. Plug-in architecture allows easy extension with new Java
plug-ins. It can interact with Matlab.
Formats
It accesses almost all commercial and open file formats using Bio-formats.
Microscopic Processing
It can control all your microscopes with one program and do on-the-fly
image analysis.
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:
Sr. No.
Features
128
Geometric Transformation
These functions can be used to clean, align, correct images, or apply
artistic 3D effects.
Color Correction
These functions are used to correct images with swapped color channels,
balance color intensities or perform various image analysis tasks.
Image Enhancement
These functions are used to correct common errors in photography such
as red-eye and imbalanced colors as well as aid in diagnostic evaluation of
medical images.
Region of Interest
These functions are used to create and modify regions of interest in images
to perform image processing functions on specific portions of an image,
save time in bar-code, and OCR recognition or perform various image
analysis tasks.
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:
Sr. No.
Features
Smoothing Images
129
Morphology Transformations
OpenCV function morphologyEx to apply Morphological Transformation
such as opening, closing, TopHat, and BlackHat etc.
Image Pyramids
OpenCV functions pyrUp and pyrDown to down sample or up sample a
given image.
Remapping
In OpenCV, the
implementation.
function
remap
offers
simple
remapping
Histogram Calculation
For simple purposes, OpenCV implements the function calcHist, which
calculates the histogram of a set of arrays (usually images or image
planes). It can operate with up to 32 dimensions.
130
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 realtime 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:
Sr. No.
Features
Smoothing Images
This involves applying Blur, GaussianBlur, medianBlur, and bilateral Filter.
Morphology Transformations
OpenCV function morphologyEx to apply Morphological Transformation
such as opening, closing, TopHat, and BlackHat etc.
Image Pyramids
OpenCV functions pyrUp and pyrDown to down sample or up sample a
given image.
Remapping
In OpenCV, the function remap offers a simple remapping implementation.
131
Histogram Calculation
For simple purposes, OpenCV implements the function calcHist, which
calculates the histogram of a set of arrays (usually images or image
planes). It can operate with up to 32 dimensions.
Integrating OpenCV
The following steps explain how to integrate OpenCV into your applications.
Download OpenCV
You can download OpenCV from their official Website here.
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.
132
Select External Folder... and browse to select the folder C:\OpenCV2.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.
133
134
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 described briefly:
Sr. No.
Methods
filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double
delta)
It convolves an image with the kernel.
135
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);
136
mat.put(0, 0, data);
Output
When you execute the given example, it converts an image named
digital_image_processing.jpg to its equivalent Grayscale image and writes it on hard
disk with name grayscale.jpg.
137
Original Image
Grayscale Image
138
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:
Sr. No.
COLOR_RGB2BGR
COLOR_RGB2BGRA
COLOR_RGB2GRAY
COLOR_RGB2HLS
COLOR_RGB2HSV
COLOR_RGB2Luv
COLOR_RGB2YUV
COLOR_RGB2Lab
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:
139
Sr. No.
Methods
filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double
delta)
It convolves an image with the kernel.
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;
140
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.
142