Java Image Processing Tutorial

Program to convert base64 to Image and vice versa

2019-07-26T04:45:00.004-07:00

Code snippet:
This method decodes the base64 string into the bytes and converts it into an image.
* Note: this method expects input to be an encoded Image in base64 format. It can't work with other other files encoded in base64 format

ByteArrayInputStream bis = new ByteArrayInputStream(Base64.getDecoder().decode(base64data));
BufferedImage img = ImageIO.read(bis);
bis.close();

This method encodes the PNG image to base64 format
ByteArrayOutputStream output = new ByteArrayOutputStream();
ImageIO.write(image, "PNG", output);
String encodedString = Base64.getEncoder().encodeToString(output.toByteArray());

output.close();

Program to convert image byte array to PDF

2019-07-22T02:53:00.000-07:00

Simple sample program to convert image byte array to PDF

//input path. path where byte array is saved
String pathOfByteArrayFile = "/home/inputByteArray.txt";

//output path. path where rendered you need to save . Output PDF should render properly
String outputPDFPath = "/home/output.pdf";
try
{
File file = new File(pathOfByteArrayFile);
FileOutputStream fout = new FileOutputStream(outputPDFPath);
byte[] bArray = Base64.decode(FileUtils.readFileToByteArray(file));
fout.write(bArray);
fout.close();
assertFalse(false);
}
catch (Exception e)
{
//your logic for failure
}

Image Management in Cloud

2017-04-06T01:49:00.001-07:00

Folks,

I came across a nice website where image management and manipulation is very easy. (http://cloudinary.com/)

Please take time to explore this with free account. You can resize image just by specifying the image URL with size.
Similarly many other features it support. Please explore this and let me know if any clarifications needed.
Meanwhile you can reply me through comments if you know better image management sites in cloud.

Thanks folks!!!

Vector Graphics - Part 3

2015-05-27T00:33:00.002-07:00

To recap, lets see the difference between vector graphics and Bitmaps.

As vectors are defined through mathematical equations, its graphical file too is constructed from mathematical equations. Greatest advantage of this is that they can be refined to any level without losing clarity.
Some of the Vector files prevalent in market : PDF,SVG, Adope Illustrator, PostScript etc.

Bitmap is something which is purely constructed from pixels. Advantage of this is since pixels are used here, we can use these files in photoshop and edit. But obviously loses clarity.
Some of the bitmap files prevalent in market : JPEG,PNG,GIF etc.

Vector Graphics - Part 2

2015-02-16T00:56:00.001-08:00

Vector graphics is normally used in context of 2D rather than 3D.
In this blog, we will see how vector graphics is used in devices such as printers to print an image or a PDF.

We will take the example of PS(Post Script) printer.
Right now in market there are many varieties of printers are available. Example: dot-matrix printers, laser printers.
In this case, we will take the example of post script PDF printers.

Firstly, what is a post script printer? It is a driver needs to be installed in the printer to recognize PDF.
Once the driver installed, the bit stream which application(Java here), will be rendered by printers using vector graphics and print the page.
PDF is an example of vector graphics.
You can scale it to whatever size and it will remain as it is.

In next blog, we will see what is difference between vectors and bitmaps and types of files printers render using these complex features.

Vector Graphics - Basic 1

2014-05-28T22:56:00.000-07:00

Use of geometrical primitives such as lines, curves, points, polygons etc. (which can be mathematically derived) to represent image constitute Vector graphics. As name suggests Vector Graphics constitute of Vectors(location points) and graphics(images).
Reader must know vectors before he understands this implementation. (Vector represented by V with an arrow mark at the top.).
Each of these vectors has a definite position on the multidimensional plane and determines the direction of the path. Also each path may be assigned a colour, texture, shape, contrast or thickness.

Right now, the standard followed is Scalable Vector Graphics (SVG), recommended by The World Wide Web Consortium (W3C).

Vectorization

2014-05-13T04:37:00.002-07:00

Conversion of raster graphics into vector graphics is known as Vectorization or Image tracing.
Classic example is when satellite captures images, they cectorize it to create maps.

There are many algorithms for Vectorization. There is no single defined clear cut algorithm for this.
Some of them are
1) Sobel
2) Canny Edge
3) Roberts Cross
4) Sparse Pixel
5) MaxDistanceVectorizer
6) LineVectorizer
7) DirectionBasedVectorizer

Image Scaling

2014-02-25T20:40:00.001-08:00

Image scaling is the process of resizing a image. When image scaling is done(sizing is increased), the pixel mark will be visible. When the image is resized , the resulting image is larger than the original, and preserves all the original detail, but has undesirable jaggedness

Some of the Interpolation Types are:
1)Nearest-neighbor interpolation
2)Bilinear interpolation
3)Bicubic interpolation
4)Lanczos resampling
5)hqx
6)Supersampling
7)Vectorization

Mini Project for Image Processing Beginners

2013-12-03T22:45:00.000-08:00

A short project for Engineering graduates.

Take an MRI Scanned image or a X-Ray image of healthy person as well as a patient and compare the pixel values, edges etc.
This will help you understand the general values of a healthy body.
Using that as mean or median, try to create an diagnoses software using these images as input.
I will add the sample code or algorithm for your reference.

So keep checking the blog for more.

Java Advanced Imaging

2012-01-17T01:48:00.000-08:00

It is basically a set of API's built in Java to provide rich library for image processing. It provides set of interfaces that support a simple, high-level programming model which allows developers to create their own image manipulation routines.

It is developed to help those who are in the field of Remote Sensing, medical Imaging etc.
Big features incorporated in JAI are :

Added great functionality for digital Imaging.
Supports wide range of data types
Support for legacy codes and java 2D classes
Almost pure Java code. Native code is almost eliminated which makes this much more efficient and faster
Control the amount of memory available to program

Box Blur

2011-12-14T04:17:00.000-08:00

As i promised in my earlier posts that we will return to Blurring Image concepts, we are back.
In this post, i will try to explain Box Blur.

Box Blur is basically an image filter which gets created by taking average values of its neighboring image. Since taking average value of pixels is simple, the algorithm can be implemented quite easily.

One of the major advantage of Box Blur is that if applied repeatedly it approximates to Gaussian Kernel.

Original

Box Blurred

Watershed Segmentation

2011-11-11T01:12:00.001-08:00

Watershed is a segmentation method where waters are flooded through the image , and make all the low lying areas of image submerge in water, so that remaining high lying areas(pixels) are edges. This way it provides clear boundary of image and this method is one of efficient method to identify the edges.

Different approaches may be employed to use the watershed principle for image segmentation :-

Local minima of the gradient of the image may be chosen as markers, in this case an over-segmentation is produced and a second step involves region merging.
Marker based watershed transformation make use of specific marker positions which have been either explicitly defined by the user or determined automatically with morphological operators or other ways.

How to obtain watershed lines :-

Remove minima which are not required(irrelevant)
merge the regions obtained(sub-regions

Combination of Edge Detection Methods : An Example

2011-10-25T00:38:00.000-07:00

In this post, i would like to post few examples of images treated under different combinations of Edge Detection methods like Sobel, Prewitt, Roberts, Frei-Chen etc

Normal Image

HORIZONTAL VERTICAL Image

None Sobel

None Roberts

None Prewitt

None Frei-Chen

Frei-Chen None

Frei-Chen Frei-Chen

Frei-Chen Prewitt

Frei-Chen Roberts

Frei-Chen Sobel

Prewitt Sobel

Prewitt Prewitt

Prewitt Roberts

Prewitt None

Prewitt Frei-Chen

Roberts Sobel

Roberts Roberts

Roberts Frei-Chen

Roberts None

Roberts Prewitt

Sobel Sobel

Sobel Prewitt

Sobel Roberts

Sobel None

Sobel Frei-Chen

Basic Method to Detect Edges of an Image

2011-10-24T05:20:00.000-07:00

As you may have studied in subjects like Operation Research or might have experienced, the changes occur only at edges. And hence to detect these edges we need to track the drastic change in pixel value. Boundary or an edge will have a sudden abrupt change in pixel value.

In the first stage of edge detection, the image is cleaned from noise by applying some filters. But also need to remember that not all edges will have a distinct change from its neighboring pixels. So there are problems with false edge detection, missing actual edges etc.

Two major methods widely employed in Edge Detection :-

Derivative Method :- In this method, we take the derivative w.r.t to time. We know that derivative yields maximum location which might correspond to an edge. If we take the same derivative one more time i.e twice on original, maximum turns to zeros. Hence one more approach it to take second derivative and look for maximum zeros. This is nothing but Laplacian Approach.
Gradient Method :- Here it looks at nearby pixels to find the changes in pixel value. If value corresponding to them are large, then it is a probable edge.

Introduction to Techniques of Edge Detection in Images

2011-10-20T22:12:00.000-07:00

Edge detection is a important weapon in Image Processing. As name suggests it detects the edges of an image. More importantly it is able to capture some important properties of an image.

Important properties of Edge Detection :-

1) As we know in an image, not all pixels are important for a particular application. Some lesser important pixels can be eliminated. Edge detection helps in re-structuring an image.

2) Eliminates the need to process and store redundant pixel information.

3) Makes analyzing and interpreting the pictures much easier.

4) Helps immensely in Pattern Recognition

Example of Edge Detection :-

Image (Before Edge Detection)

Image (After Edge Detection)

In next post i will explain few Techniques (Sobel, Prewitt, Roberts etc) of edge detection.

Segmentation

2011-10-19T03:58:00.000-07:00

Segmentation is nothing but segmenting the image into multiple pixel sets. It is meant to change the representation of an image. Segmentation makes analysis more simpler as it gives another simpler view of same image. It involves locating the edges of image, objects or any other contrasting things in an image. The output of segmentation is used immensely in lots of applications. For example in medical imaging, segmentation might give you the tumor cell edge as it has greater contrast compared to the rest of image.

Different types to achieve segmentation are :-

Thresholding

Clustering methods

Compression-based methods

Histogram-based methods

Edge detection

Region growing methods

Split-and-merge methods

Partial differential equation-based methods

Graph partitioning methods

Watershed transformation

Model based segmentation

Multi-scale segmentation

Semi-automatic segmentation

Neural networks segmentation

We will look into each of these methods in seperate posts.

Overlapping The Images

2011-07-21T21:56:00.000-07:00

This example will help you to understand the concept of Graphics2D better. Just go through the example provided next and see the result. I believe example itself is self-explanatory.

As usual if you have any doubts,clarifications etc you can ask me.

Program :-

package client;

import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;

public class OverlappingImage {
public static void main(String args[]) {

BufferedImage image1 = null;
BufferedImage image2 = null;
try {
image1 = ImageIO.read(new File("C:/temp/Winter.jpg"));
image2 = ImageIO.read(new File("C:/temp/Sunset.jpg"));
} catch (IOException e) {
e.printStackTrace();
}

Graphics2D g = image1.createGraphics();
g.drawImage(image1, 0, 0, null);
g.drawImage(image2, 100, 10, null);

File file = new File("C:/temp/overLayedImage.jpg");
try {
ImageIO.write(image1, "JPG", file);
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("Check the new overlapped image");
}
}

Screenshot of output is given below.

Screenshot of our program from our Program

2011-06-03T05:03:00.000-07:00

Lets try to take Screenshot of our program from our Program. It sound weired right. Thats what we will try to attempt in this post. Always operating system tries to take a screenshot when we press PrtScn in keyboard. This time lets make our Java program to take the screenshot.

As usual we will just brush up few library's and methods required to create this java program.

1) getScreenSize method in Java.awt.toolkit : Gets the size of the screen. On systems with multiple displays, the primary display is used. Multi-screen aware display dimensions are available from GraphicsConfiguration and GraphicsDevice.

2) java.awt.Robot :- This class is used to generate native system input events for the purposes of test automation, self-running demos, and other applications where control of the mouse and keyboard is needed. The primary purpose of Robot is to facilitate automated testing of Java platform implementations.

Using the class to generate input events differs from posting events to the AWT event queue or AWT components in that the events are generated in the platform's native input queue. For example, Robot.mouseMove will actually move the mouse cursor instead of just generating mouse move events.

Note that some platforms require special privileges or extensions to access low-level input control. If the current platform configuration does not allow input control, an AWTException will be thrown when trying to construct Robot objects. For example, X-Window systems will throw the exception if the XTEST 2.2 standard extension is not supported (or not enabled) by the X server.

Applications that use Robot for purposes other than self-testing should handle these error conditions gracefully.

3) java.awt.Rectange :- A Rectangle specifies an area in a coordinate space that is enclosed by the Rectangle object's upper-left point (x,y) in the coordinate space, its width, and its height.

A Rectangle object's width and height are public fields. The constructors that create a Rectangle, and the methods that can modify one, do not prevent setting a negative value for width or height.

A Rectangle whose width or height is exactly zero has location along those axes with zero dimension, but is otherwise considered empty. The isEmpty() method will return true for such a Rectangle. Methods which test if an empty Rectangle contains or intersects a point or rectangle will always return false if either dimension is zero. Methods which combine such a Rectangle with a point or rectangle will include the location of the Rectangle on that axis in the result as if the addPoint(method) method were being called.

A Rectangle whose width or height is negative has neither location nor dimension along those axes with negative dimensions. Such a Rectangle is treated as non-existant along those axes. Such a Rectangle is also empty with respect to containment calculations and methods which test if it contains or intersects a point or rectangle will always return false. Methods which combine such a Rectangle with a point or rectangle will ignore the Rectangle entirely in generating the result. If two Rectangle objects are combined and each has a negative dimension, the result will have at least one negative dimension.

Methods which affect only the location of a Rectangle will operate on its location regardless of whether or not it has a negative or zero dimension along either axis.

Note that a Rectangle constructed with the default no-argument constructor will have dimensions of 0x0 and therefore be empty. That Rectangle will still have a location of (0,0) and will contribute that location to the union and add operations. Code attempting to accumulate the bounds of a set of points should therefore initially construct the Rectangle with a specifically negative width and height or it should use the first point in the set to construct the Rectangle.

For example:

     Rectangle bounds = new Rectangle(0, 0, -1, -1);
     for (int i = 0; i < points.length; i++) {
         bounds.add(points[i]);
     }

or if we know that the points array contains at least one point:

     Rectangle bounds = new Rectangle(points[0]);
     for (int i = 1; i < points.length; i++) {
         bounds.add(points[i]);
     }

This class uses 32-bit integers to store its location and dimensions. Frequently operations may produce a result that exceeds the range of a 32-bit integer. The methods will calculate their results in a way that avoids any 32-bit overflow for intermediate results and then choose the best representation to store the final results back into the 32-bit fields which hold the location and dimensions. The location of the result will be stored into the x and y fields by clipping the true result to the nearest 32-bit value. The values stored into the width and height dimension fields will be chosen as the 32-bit values that encompass the largest part of the true result as possible. Generally this means that the dimension will be clipped independently to the range of 32-bit integers except that if the location had to be moved to store it into its pair of 32-bit fields then the dimensions will be adjusted relative to the "best representation" of the location. If the true result had a negative dimension and was therefore non-existant along one or both axes, the stored dimensions will be negative numbers in those axes. If the true result had a location that could be represented within the range of 32-bit integers, but zero dimension along one or both axes, then the stored dimensions will be zero in those axes.

4) delay method :- Sleeps for the specified time. If you want more time to capture image, ie to move the screen to specified page and then take image, just give more milliseconds.

5) createScreenCapture method :- Creates an image containing pixels read from the screen. This image does not include the mouse cursor.

6) createGraphics method :- Creates a Graphics2D, which can be used to draw into this BufferedImage

Now lets see the real program :-

package client;

import java.awt.AWTException;

import java.awt.Dimension;

import java.awt.Graphics;

import java.awt.Image;

import java.awt.Rectangle;

import java.awt.Robot;

import java.awt.Toolkit;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.IOException;

import java.util.Scanner;

import javax.imageio.ImageIO;

public class ScreenCapture {

public static void main(String args[]) {

System.out.println("Enter the name which you want to give it to your sceenshot");

Scanner kb=new Scanner(System.in);

String screenShotName=kb.next();

String output="C:\\"+screenShotName+".jpeg";

Robot robot = null;

try {

robot = new Robot();

robot.delay(1000);

} catch (AWTException e) {

e.printStackTrace();

}

Dimension d = new Dimension(Toolkit.getDefaultToolkit().getScreenSize());

int width = (int) d.getWidth();

int height = (int) d.getHeight();

BufferedImage bufferedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

Graphics g = bufferedImage.createGraphics();

Rectangle rectangle=new Rectangle(d);

Image image = robot.createScreenCapture(rectangle);

g.drawImage(image, 0, 0, width, height, null);

try {

ImageIO.write( bufferedImage, "jpeg",new File(output));

} catch (IOException e) {

e.printStackTrace();

}

System.out.println("You can find screenshot in c:\\"+screenShotName+".jpeg");

}

Let me show you the output :-

Raster Image

2011-03-28T04:03:00.000-07:00

A raster graphics image is a data structure epresenting a generally rectangular grid of pixels, or points of color, viewable via amonitor, paper, or other display medium. Raster images are stored in image files with varying formats. Or a raster image is a class representing a rectangular array of pixels. A Raster encapsulates a DataBuffer that stores the sample values and a SampleModel that describes how to locate a given sample value in a DataBuffer.

A Raster defines values for pixels occupying a particular rectangular area of the plane, not necessarily including (0, 0). The rectangle, known as the Raster's bounding rectangle and available by means of the getBounds method, is defined by minX, minY, width, and height values. The minX and minY values define the coordinate of the upper left corner of the Raster. References to pixels outside of the bounding rectangle may result in an exception being thrown, or may result in references to unintended elements of the Raster's associated DataBuffer. It is the user's responsibility to avoid accessing such pixels.

A SampleModel describes how samples of a Raster are stored in the primitive array elements of a DataBuffer. Samples may be stored one per data element, as in a PixelInterleavedSampleModel or BandedSampleModel, or packed several to an element, as in a SinglePixelPackedSampleModel or MultiPixelPackedSampleModel. The SampleModel is also controls whether samples are sign extended, allowing unsigned data to be stored in signed Java data types such as byte, short, and int.

Although a Raster may live anywhere in the plane, a SampleModel makes use of a simple coordinate system that starts at (0, 0). A Raster therefore contains a translation factor that allows pixel locations to be mapped between the Raster's coordinate system and that of the SampleModel. The translation from the SampleModel coordinate system to that of the Raster may be obtained by the getSampleModelTranslateX and getSampleModelTranslateY methods.

A Raster may share a DataBuffer with another Raster either by explicit construction or by the use of the createChild and createTranslatedChild methods. Rasters created by these methods can return a reference to the Raster they were created from by means of the getParent method. For a Raster that was not constructed by means of a call to createTranslatedChild or createChild, getParent will return null.

The createTranslatedChild method returns a new Raster that shares all of the data of the current Raster, but occupies a bounding rectangle of the same width and height but with a different starting point. For example, if the parent Raster occupied the region (10, 10) to (100, 100), and the translated Raster was defined to start at (50, 50), then pixel (20, 20) of the parent and pixel (60, 60) of the child occupy the same location in the DataBuffer shared by the two Rasters. In the first case, (-10, -10) should be added to a pixel coordinate to obtain the corresponding SampleModel coordinate, and in the second case (-50, -50) should be added.

The translation between a parent and child Raster may be determined by subtracting the child's sampleModelTranslateX and sampleModelTranslateY values from those of the parent.

The createChild method may be used to create a new Raster occupying only a subset of its parent's bounding rectangle (with the same or a translated coordinate system) or with a subset of the bands of its parent.

All constructors are protected. The correct way to create a Raster is to use one of the static create methods defined in this class. These methods create instances of Raster that use the standard Interleaved, Banded, and Packed SampleModels and that may be processed more efficiently than a Raster created by combining an externally generated SampleModel and DataBuffer.

You can see the below image to look at the pixels.

Image Processing Basics 3 - Image Buffering

2011-03-25T03:54:00.000-07:00

Buffered Image :- As the name suggests it is the buffering of image data.

java.awt.BufferedImage is responsible for Buffering of images in Java

Actually BuffreedImage is nothing but collection of image data,pixels,RGB Colors etc. BuffredImage basically contains two parst. Raster part and Color part. Color part is responsible for storing color of the image to be buffered. Raster part holds the raw image and their representation. Rater images are stored in image files in different formats.Some of the formats are :-

1) BitMap :- a bitmap or pixmap is a type of memory organization or image file format used to store digital images

2) OpenRaster :- Open Raster is a file format proposed for the common exchange of layered images between raster graphics editors. It is meant as a replacement for later versions of the Adobe PSD format. OpenRaster is still in development and so far is supported by a few programs.The default file extension for OpenRaster files is ".ora"

3) .ico :- This is a format for icons in Microsoft

4) . .ICO files contain one or more small images at multiple sizes and color depths

5) Cur :- The CUR file format is an almost identical image file format for non-animated cursors in Microsoft Windows

6) Gif

7) Jpeg etc

Vector File Formats-They normally deal with size and shapes

AI (Adobe Illustrator)
CDR (CorelDRAW)
EPS (Encapsulated PostScript)
WMF (Windows Metafile)
DXF (AutoCAD)
SVG (Scalable Vector Graphics)

Ok. Lets forget these bull shit theories which can be learned when need arises.( Google’s Help). Coming to the programming part i will demonstrate a simple example of Image buffering and displaying the buffered image.

Actual Program :-

import java.awt.Graphics;

import java.awt.Image;

import java.awt.image.BufferedImage;

import javax.swing.ImageIcon;

import javax.swing.JFrame;

import javax.swing.JLabel;

public class ImageBufferingExample {

Image image;

JFrame frame = new JFrame();

public ImageBufferingExample() {

image = loadImage();

BufferedImage bufferedImage = new BufferedImage(100, 100,BufferedImage.TYPE_INT_RGB);

JLabel label = new JLabel(new ImageIcon(bufferedImage));

Graphics g = bufferedImage.getGraphics();

g.drawImage(image, 0, 0, null);

frame.getContentPane().add(label);

frame.setVisible(true);

}

public static void main(String args[]) {

ImageBufferingExample imageBufferingExample = new ImageBufferingExample();

}

public Image loadImage() {

return new ImageIcon("c:\\Sunset.gif").getImage();

}

Some concepts to see before explaining program :-

JFrame :- The JFrame class is slightly incompatible with Frame. Like all other JFC/Swing top-level containers, a JFrame contains a JRootPane as its only child. The content panec provided by the root pane should, as a rule, contain all the non-menu components displayed by the JFrame. This is different from the AWT Frame case. As a conveniance add and its variants, remove and setLayout have been overridden to forward to the contentPane as necessary. This means you can write:

frame.add(child);

BufferedImage :- The BufferedImage subclass describes an Image with an accessible buffer of image data. A BufferedImage is comprised of a Color Model and a Raster of image data. The number and types of bands in the Sample Model of the Raster must match the number and types required by the ColorModel to represent its color and alpha components. All BufferedImage objects have an upper left corner coordinate of (0, 0). Any Raster used to construct a BufferedImage must therefore have minX=0 and minY=0.

This class relies on the data fetching and setting methods of Raster, and on the color characterization methods of ColorModel.

public BufferedImage(int width, int height, int imageType)

JLabel :- A JLabel object can display either text, an image, or both. You can specify where in the label's display area the label's contents are aligned by setting the vertical and horizontal alignment. By default, labels are vertically centered in their display area. Text-only labels are leading edge aligned, by default; image-only labels are horizontally centered, by default.

You can also specify the position of the text relative to the image. By default, text is on the trailing edge of the image, with the text and image vertically aligned.

A label's leading and trailing edge are determined from the value of its Component Orientation property. At present, the default Component Orientation setting maps the leading edge to left and the trailing edge to right.

Finally, you can use the setIconTextGap method to specify how many pixels should appear between the text and the image. The default is 4 pixels.

Java.awt.Graphics :- The Graphics class is the abstract base class for all graphics contexts that allow an application to draw onto components that are realized on various devices, as well as onto off-screen images.

A Graphics object encapsulates state information needed for the basic rendering operations that Java supports. This state information includes the following properties:

The Component object on which to draw.
A translation origin for rendering and clipping coordinates.
The current clip.
The current color.
The current font.
The current logical pixel operation function (XOR or Paint).
The current XOR alternation color

Now coming to the actual program, BufferedImage has three arguments which includes height and width of image. The third argument is image Type. I will explain each of them in detail at the end of this blog. Next create a JLabel which contains an BufferedImage. draw the image using graphics API and add them to content pane of JFrame. Make sure to Set Visibility to true to see the image on the screen. I believe the program is self explainatory.

Coming back to Image Types, They are :-

1) TYPE_3BYTE_BGR :- Represents an image with 8-bit RGB color components, corresponding to a Windows-style BGR color model) with the colors Blue, Green, and Red stored in 3 bytes. There is no alpha. The image has a ComponentColorModel. When data with non-opaque alpha is stored in an image of this type, the color data must be adjusted to a non-premultiplied form and the alpha discarded

2) TYPE_4BYTE_ABGR :- Represents an image with 8-bit RGBA color components with the colors Blue, Green, and Red stored in 3 bytes and 1 byte of alpha. The image has a ComponentColorModel with alpha. The color data in this image is considered not to be premultiplied with alpha. The byte data is interleaved in a single byte array in the order A, B, G, R from lower to higher byte addresses within each pixel.

3) TYPE_4BYTE_ABGR_PRE :- Represents an image with 8-bit RGBA color components with the colors Blue, Green, and Red stored in 3 bytes and 1 byte of alpha. The image has a ComponentColorModel with alpha. The color data in this image is considered to be premultiplied with alpha. The byte data is interleaved in a single byte array in the order A, B, G, R from lower to higher byte addresses within each pixel.

4) TYPE_BYTE_BINARY :- Represents an opaque byte-packed 1, 2, or 4 bit image. The image has an IndexColorModel without alpha. When this type is used as the imageType argument to the BufferedImage constructor that takes an imageType argument but no ColorModel argument, a 1-bit image is created with an IndexColorModel with two colors in the default sRGB ColorSpace: {0, 0, 0} and {255, 255, 255}.Images with 2 or 4 bits per pixel may be constructed via the BufferedImage constructor that takes a ColorModel argument by supplying a ColorModel with an appropriate map size.Images with 8 bits per pixel should use the image types TYPE_BYTE_INDEXED or TYPE_BYTE_GRAY depending on their ColorModel.When color data is stored in an image of this type, the closest color in the colormap is determined by the IndexColorModel and the resulting index is stored. Approximation and loss of alpha or color components can result, depending on the colors in the IndexColorModel colormap.

5) TYPE_BYTE_GRAY :- Represents a unsigned byte grayscale image, non-indexed. This image has a ComponentColorModel with a CS_GRAY colorspace. When data with non-opaque alpha is stored in an image of this type, the color data must be adjusted to a non-premultiplied form and the alpha discarded

6) TYPE_BYTE_INDEXED :- Represents an indexed byte image. When this type is used as the imageType argument to the BufferedImage constructor that takes an imageType argument but no ColorModel argument, an IndexColorModel is created with a 256-color 6/6/6 color cube palette with the rest of the colors from 216-255 populated by grayscale values in the default sRGB ColorSpace.When color data is stored in an image of this type, the closest color in the colormap is determined by the IndexColorModel and the resulting index is stored. Approximation and loss of alpha or color components can result, depending on the colors in the IndexColorModel colormap.

7) TYPE_CUSTOM :- Image type is not recognized so it must be a customized image. This type is only used as a return value for the getType() method.

8) TYPE_INT_ARGB :- Represents an image with 8-bit RGBA color components packed into integer pixels. The image has a DirectColorModel with alpha. The color data in this image is considered not to be premultiplied with alpha.

9) TYPE_INT_ARGB_PRE :-Represents an image with 8-bit RGBA color components packed into integer pixels. The image has a DirectColorModel with alpha. The color data in this image is considered to be premultiplied with alpha.

10) TYPE_INT_BGR :- Represents an image with 8-bit RGB color components, corresponding to a Windows- or Solaris- style BGR color model, with the colors Blue, Green, and Red packed into integer pixels. There is no alpha. The image has a DirectedColorModel. When data with non-opaque alpha is stored in an image of this type, the color data must be adjusted to a non-premultiplied form and the alpha discarded.

11) TYPE_INT_RGB :-Represents an image with 8-bit RGB color components packed into integer pixels. The image has a DirectedColorModel without alpha. When data with non-opaque alpha is stored in an image of this type, the color data must be adjusted to a non-premultiplied form and the alpha discarded.

12) TYPE_USHORT_555_RGB :- Represents an image with 5-5-5 RGB color components (5-bits red, 5-bits green, 5-bits blue) with no alpha. This image has a DirectColorModel. When data with non-opaque alpha is stored in an image of this type, the color data must be adjusted to a non-premultiplied form and the alpha discarded.

13)TYPE_USHORT_565_RGB :- Represents an image with 5-6-5 RGB color components (5-bits red, 6-bits green, 5-bits blue) with no alpha. This image has a DirectColorModel. When data with non-opaque alpha is stored in an image of this type, the color data must be adjusted to a non-premultiplied form and the alpha discarded.

14) TYPE_USHORT_GRAY :- Represents an unsigned short grayscale image, non-indexed). This image has a ComponentColorModel with a CS_GRAY ColorSpace. When data with non-opaque alpha is stored in an image of this type, the color data must be adjusted to a non-premultiplied form and the alpha discarded.

15) BITMASK :- Represents image data that is guaranteed to be either completely opaque, with an alpha value of 1.0, or completely transparent, with an alpha value of 0.0.

16) OPAQUE :- Represents image data that is guaranteed to be completely opaque, meaning that all pixels have an alpha value of 1.0.

17) SCALE_AREA_AVERAGING :- Use the Area Averaging image scaling algorithm. The image object is free to substitute a different filter that performs the same algorithm yet integrates more efficiently into the image infrastructure supplied by the toolkit.

18) SCALE_FAST :-Choose an image-scaling algorithm that gives higher priority to scaling speed than smoothness of the scaled image

19) SCALE_REPLICATE :- Use the image scaling algorithm embodied in the ReplicateScaleFilter class. The Image object is free to substitute a different filter that performs the same algorithm yet integrates more efficiently into the imaging infrastructure supplied by the toolkit.

20) SCALE_SMOOTH :-Choose an image-scaling algorithm that gives higher priority to image smoothness than scaling speed.

21) TRANSLUCENT :- Represents image data that contains or might contain arbitrary alpha values between and including 0.0 and 1.0.

22) TRANSLUCENT :- Represents image data that contains or might contain arbitrary alpha values between and including 0.0 and 1.0.

Output Image :-

Blurring The Image

2011-03-24T23:30:00.000-07:00

Guys let me ask you a question. What happens when your spectacles are lost and you are desperate to read something. You are witnessing a phenomenon known as Blurring. Well guys that brings us to a new topic called Image Blurring.

So guys you might have a question now why to blur the image? Because normally blurring created discomfort. Here is the truth. If you see any sensitive data in the website, normally its blurred. I think you might have got some idea about blurring now. But honestly i feel blurring the sensitive data to hide is a bad form. Because the image blurred can be reverted back.

There are many techniques for blurring the image. Most important ones are

1) Gaussian Blur

2) Convolve

3) Motion Blur

4) Faster Motion Blur etc

We will learn about all these topics in detail in following chapters. But an important pre-requisite I feel before starting the blurring chapters is that you must know Buffering the Image. If you know buffering the image you can skip the next session else Just glance through it to get some idea.

Just look at this figure for Gaussian Blur.

Image Processing Basics 2 - Image Scaling

2011-03-22T02:51:00.000-07:00

Scaling algorithms are used to scale the image i.e. to change the size of image as per our requirement. Since it involves re-sizing the image normally there is a loss of smoothness and sharpness.

Some of the Scaling Methods are :-

Nearest – Neighbour Interpolation :-

In this technique to enlarge the pixel, value of nearest pixel is copied i.e the color of pixel in new image is the color of the nearest pixel of the original image. If you enlarge the pixel by 400% then each pixel will be enlarged 4x4 therby forming 16 pixels with same color.

Advantage of this technique is that it will not introduce any bias in the image as the image itself is scaled without loss of data

Disadvantage is that it will introduce aliasing and jaggies.

Aliasing :- It refers to an effect which causes the pixel to be aliases i.e. it will be copy of the other. Problem arises because it introduces jaggies which means stairlike lines that appear where there should be smooth straight lines or curves. For example, when a nominally straight, un-aliased line steps across one pixel, a dogleg occurs halfway through the line, where it crosses the threshold from one pixel to the other.

Example Image : -

As you can see in above image , individual pixel is a square type and you can notice edges of squares or rectangles which should appear smooth .

Bilinear Interpolation :-

In Bilinear Interpolation, linear interpolation is used to estimate the color of the pixel. Linear interpolation deals with estimation of an arbitrary points with respect to two other points.

Example :- Consider two points P & Q.

Consider an arbitrary point S. Now how to determine the value of S if value of P is 255 and value of q is 0 given the length between P & Q is 100 and distance between S and P is 25.

S-P/d = Q-S/(D-d)

=> S-255/25=0-S/75

=> S-255=-(S/3)

=> 4S=255x3

=> S=191.25

Bicubic Interpolation :-

Images re-sampled with bicubic interpolation are smoother and have fewer interpolation artifacts. It is computational intensive and includes algorithms such as Lagrange Polynomials, cubic spines, cubic convolution algorithms etc.We will re-visit these complex topics after we finish basics.

Supersampling :-

Aliasing occurs because real-world objects have continuous, smooth curves and lines, whereas monitors can only display discrete points of light called pixels. Since pixels are uniformly colored and always of the same shape, lines become jagged.Supersampling is one of the ways of solving this problem. Samples are taken at several instances inside the pixel (not just at the center as default) and an average color value is calculated. This is achieved by rendering the image at a much higher resolution than the one being displayed, then downsampling it to the desired size, using the extra pixels for calculation. The result is smoother transitions from one line of pixels to another along the edges of objects.

Now coming to programming perspective, lets take a small example where i will demonstrate how to scale a image.

Only changes it involves compared to my previous programs is getScaledInstance.

getScaledInstance :- Creates a scaled version of this image. A new Image object is returned which will render the image at the specified width and height by default. The new Image object may be loaded asynchronously even if the original source image has already been loaded completely. If either width or height is a negative number then a value is substituted to maintain the aspect ratio of the original image dimensions. If both width and height are negative, then the original image dimensions are used.

public Image getScaledInstance(int width,int height,int hints)

Hints has several inbuilt values. You can each of them.

1) SCALE_AREA_AVERAGING :- Use the Area Averaging image scaling algorithm. The image object is free to substitute a different filter that performs the same algorithm yet integrates more efficiently into the image infrastructure supplied by the toolkit.

2) SCALE_DEFALUT :- Use the default image-scaling algorithm

3) SCALE_FAST :- Choose an image-scaling algorithm that gives higher priority to scaling speed than smoothness of the scaled image.

4) SCALE_REPLICATE :- Use the image scaling algorithm embodied in the ReplicateScaleFilter class. The Image object is free to substitute a different filter that performs the same algorithm yet integrates more efficiently into the imaging infrastructure supplied by the toolkit.

5) SCALE_SMOOTH :- Choose an image-scaling algorithm that gives higher priority to image smoothness than scaling speed.

Program :-

LoadImage Interface :-

     import java.awt.Toolkit;
   import java.awt.event.WindowAdapter;
   import java.awt.event.WindowEvent;
   public interface LoadImage {
      public void loadImage();
   }

   Actual Class :-

   import java.awt.*;

import java.awt.event.*;

class ImageProcessScale extends Frame implements LoadImage{

Image image;

public ImageProcessScale (){

loadImage();

}

public void paint(Graphics g){

g.translate( this.getInsets().left,this.getInsets().top);

MediaTracker tracker = new MediaTracker(this);

tracker.addImage(image, 1);

try{

tracker.waitForAll();

}catch(InterruptedException e)

{

System.out.println(e);

}

g.drawImage(image,10,150,this);

}

@Override
public void loadImage() {
image = Toolkit.getDefaultToolkit().getImage("c:\\Sunset.jpg");
   image=image.getScaledInstance(432, 432, Image.SCALE_AREA_AVERAGING);
   this.setVisible(true);

   this.addWindowListener(
   new WindowAdapter(){
   public void windowClosing(WindowEvent e){
   System.exit(0);
   }
   }
   );

}

public static void main(String[] args){

ImageProcessScale imageprocessscale = new ImageProcessScale();

}

}

Output Snapshot :-

Pixel Representation

2011-03-21T02:05:00.000-07:00

Let us study some basic terms before starting with programs.

1) Pixel :-

Its is a smallest unit of a picture that can be represented.The address of a pixel corresponds to its coordinates. Pixels are normally arranged in a two-dimensional grid, and are often represented using dots or squares.

In color image pixels are normally represented in RGB or CYMB. Major image file formats are JPEG, EXIF, TIFF, RAW, PNG, GIF, BMP etc. They can also be represented as vector formats like CGM, SVG etc. Pixel in a modern computer image is represented by four unsigned 8-bit bytes of data. Three of those four bytes represent the colors red, green, and blue. The fourth byte, often referred to as the alpha byte, represents transparency. In black and white image, black has the value 0 and white 255. If the value is 0, the pixel is completely transparent regardless of the values of the color bytes. If the value is 255, the pixel is completely opaque with the color of the pixel being determined exclusively by the values stored in the three color bytes

2) Pixel Representation :-

Alpha

Red

Green

Blue

MSB LSB

3) Pixel Density or Pixel Per Inch (PPI) :-

It is a measurement of the resolution of devices in various contexts like image scanners, digital cameras, monitors etc

Image Processing Basics 1

2011-03-18T01:52:00.000-07:00

Java Image processing basically involves Java awt packages i.e Abstract Window Toolkit. Hence make sure you have awt jar files before you begin this tutorial.

Firstly i will cover the basic example of how to render an image. I am going to use Eclipse IDE. You are free to use any IDE. Make sure Java path is set in environment variables.

We will brush up some important concepts before starting actual code. 10 important things to look up are listed below. Just go through once to get some idea. If you didn't understand completely don't worry as we will learn each of them separately in future examples.

1) java.awt.Frame :-

A Frame is a top-level window with a title and a border.The size of the frame includes any area designated for the border. The dimensions of the border area may be obtained using the getInsets method, however, since these dimensions are platform-dependent, a valid insets value cannot be obtained until the frame is made displayable by either calling pack or show. Since the border area is included in the overall size of the frame, the border effectively obscures a portion of the frame, constraining the area available for rendering and/or displaying subcomponents to the rectangle which has an upper-left corner location of (insets.left, insets.top), and has a size of width - (insets.left + insets.right) by height - (insets.top + insets.bottom).

Frames are capable of generating the following types of WindowEvents:

WINDOW_OPENED
WINDOW_CLOSING:
WINDOW_CLOSED
WINDOW_ICONIFIED
WINDOW_DEICONIFIED
WINDOW_ACTIVATED
WINDOW_DEACTIVATED
WINDOW_GAINED_FOCUS
WINDOW_LOST_FOCUS
WINDOW_STATE_CHANGED

2) java.awt.image :-

The abstract class Image is the superclass of all classes that represent graphical images. The image must be obtained in a platform-specific manner.

3) java.awt.toolkit :-

This class is the abstract superclass of all actual implementations of the Abstract Window Toolkit. Subclasses of Toolkit are used to bind the various components to particular native toolkit implementations.

Many GUI operations may be performed asynchronously. This means that if you set the state of a component, and then immediately query the state, the returned value may not yet reflect the requested change. This includes, but is not limited to:

Scrolling to a specified position.
Moving the focus from one component to another.
Making a top-level container visible.
Setting the size or location of a top-level container.

Most applications should not call any of the methods in this class directly. The methods defined by Toolkit are the "glue" that joins the platform-independent classes in the java.awt package with their counterparts in java.awt.peer. Some methods defined by Toolkit query the native operating system directly.

4) Java.awt.event.WindowEvent :-

A low-level event that indicates that a window has changed its status. This low-level event is generated by a Window object when it is opened, closed, activated, deactivated, iconified, or deiconified, or when focus is transfered into or out of the Window.

The event is passed to every WindowListener or WindowAdapter object which registered to receive such events using the window's addWindowListener method. Each such listener object gets this WindowEvent when the event occurs.

5) java.awt.Toolkit.getDefaultToolkit() :-

Gets the default toolkit.

If a system property named "java.awt.headless" is set to true then the headless implementation of Toolkit is used. If there is no "java.awt.headless" or it is set to false and there is a system property named "awt.toolkit", that property is treated as the name of a class that is a subclass of Toolkit; otherwise the default platform-specific implementation of Toolkit is used. Also loads additional classes into the VM, using the property 'assistive_technologies' specified in the Sun reference implementation by a line in the 'accessibility.properties' file. The form is "assistive_technologies=..." where the "..." is a comma-separated list of assistive technology classes to load. Each class is loaded in the order given and a single instance of each is created using Class.forName(class).newInstance(). This is done just after the AWT toolkit is created. All errors are handled via an AWTError exception.

6) getImage(String filename) :-

Returns an image which gets pixel data from the specified file, whose format can be either GIF, JPEG or PNG. The underlying toolkit attempts to resolve multiple requests with the same filename to the same returned Image. Since the mechanism required to facilitate this sharing of Image objects may continue to hold onto images that are no longer in use for an indefinite period of time, developers are encouraged to implement their own caching of images by using the createImage variant wherever available. If the image data contained in the specified file changes, the Image object returned from this method may still contain stale information which was loaded from the file after a prior call. Previously loaded image data can be manually discarded by calling the flush method on the returned image. This method first checks if there is a security manager installed. If so, the method calls the security manager's chekRead method with the file specified to ensure that the access to the image is allowed.

7) paint(Graphics g) :-

Paints the container. This forwards the paint to any lightweight components that are children of this container. If this method is reimplemented, super.paint(g) should be called so that lightweight components are properly rendered. If a child component is entirely clipped by the current clipping setting in g, paint() will not be forwarded to that child.

8) java.wat.Graphics :-

The Graphics class is the abstract base class for all graphics contexts that allow an application to draw onto components that are realized on various devices, as well as onto off-screen images.

A Graphics object encapsulates state information needed for the basic rendering operations that Java supports. This state information includes the following properties:

The Component object on which to draw.

A translation origin for rendering and clipping coordinates.

The current clip.

The current color.

The current font.

The current logical pixel operation function (XOR or Paint).

The current XOR alternation color

9) java.awt.MediaTracker :-

The MediaTracker class is a utility class to track the status of a number of media objects. Media objects could include audio clips as well as images, though currently only images are supported.

To use a media tracker, create an instance of MediaTracker and call its addImage method for each image to be tracked. In addition, each image can be assigned a unique identifier. This identifier controls the priority order in which the images are fetched. It can also be used to identify unique subsets of the images that can be waited on independently. Images with a lower ID are loaded in preference to those with a higher ID number.

Tracking an animated image might not always be useful due to the multi-part nature of animated image loading and painting, but it is supported. MediaTracker treats an animated image as completely loaded when the first frame is completely loaded. At that point, the MediaTracker signals any waiters that the image is completely loaded. If no ImageObservers are observing the image when the first frame has finished loading, the image might flush itself to conserve resources

10) drawImage() :-

Draws as much of the specified image as has already been scaled to fit inside the specified rectangle.The image is drawn inside the specified rectangle of this graphics context's coordinate space, and is scaled if necessary. Transparent pixels do not affect whatever pixels are already there.This method returns immediately in all cases, even if the entire image has not yet been scaled, dithered, and converted for the current output device. If the current output representation is not yet complete, then drawImage returns false. As more of the image becomes available, the process that loads the image notifies the image observer by calling its imageUpdate method.A scaled version of an image will not necessarily be available immediately just because an unscaled version of the image has been constructed for this output device. Each size of the image may be cached separately and generated from the original data in a separate image production sequence.

Now lets see one example where an image is rendered. It does nothing other than accepting an image input and displaying.

LoadImage Interface :-

import java.awt.Toolkit;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

public interface LoadImage {

public void loadImage();

}

Actual Class :-

import java.awt.*;

import java.awt.event.*;

class ImageProcess extends Frame implements LoadImage {

private static final long serialVersionUID = 1L;

Image image;

public static void main(String[] args) {

ImageProcess img = new ImageProcess();

img.loadImage();

}

public void loadImage() {

image = Toolkit.getDefaultToolkit().getImage("c:\\Sunset.jpg");

this.setVisible(true);

this.addWindowListener(new WindowAdapter() {

public void windowClosing(WindowEvent e) {

System.exit(0);

}

});

}

public void paint(Graphics g) {

System.out.println("Processing...");

g.translate(this.getInsets().left, this.getInsets().top);

MediaTracker tracker = new MediaTracker(this);

tracker.addImage(image, 1, 100, 100);

try {

tracker.waitForID(1, 1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

g.drawImage(image, 120, 30, image.getWidth(this), image.getHeight(this), this);

}

Now lets see some key aspects of this program.

1) Inside loadImeage() method setVisible is set to true because by default it is false and the image gets hidden. So make sure you set this as true otherwise you wont be able to see any image.

2) WindowListener Events are present because once the image is displayed, you need to close the window for exit. If this event listener is not present you wont be able to close the windoe. Actually you can experiment it.

3) Normally paint is the inbuilt method that is called innumerable times in the program. Whenever there is a small change ,the paint method is called. We don't need to call this method as this is done internally. Println will show you how many times it is called. Remember whenever there is a small change in dimension of image, paint is called. In fact paint is called to render the image first time also.

But here since MediaTracker is used paint() is called only once. MediaTracker internally implements threads which waits for other threads to finish job.

Now you might have a question of how it calls paint automatically? Answer is ImageObserver interface. I have explained that to you at the end of this post.

4) Use of translate method is to Translates the origin of the graphics context to the point (x, y) in the current coordinate system. Modifies this graphics context so that its new origin corresponds to the point (x, y) in this graphics context's original coordinate system. All coordinates used in subsequent rendering operations on this graphics context will be relative to this new origin.

public abstract void translate(int x, int y)

Parameters:

x - the x coordinate.

y - the y coordinate

5) public Insets getInsets() :-

Determines the insets of this container, which indicate the size of the container's border. A Frame object, for example, has a top inset that corresponds to the height of the frame's title bar.

g.translate(this.getInsets().left, this.getInsets().top);

6) addImage :-

Adds a scaled image to the list of images being tracked by this media tracker. The image will eventually be rendered at the indicated width and height.

public void addImage(Image image,
int id,
int w,
int h)

addImage parameter has one important thing i.e ID. This ID is associated with image. Whenever you will refer tracker and image use this ID. Following code will help you to understand better.

tracker.waitForID(1, 1000);

public boolean waitForID(int id,
long ms)

Starts loading all images tracked by this media tracker with the specified 
identifier. This method waits until all the images with the specified identifier 
have finished loading, or until the length of time specified in milliseconds by 
the ms argument has passed. If there is an error while loading or scaling an image, then that image is 
considered to have finished loading. Use the statusID, 
isErrorID, and isErrorAny methods to check for errors.

7) And lastly dont forget to draw the image

g.drawImage(image, 120, 30, image.getWidth(this), image.getHeight(this), this);

ImageObserver interface is the last argument in drawImage() method. When an object implements it, call to drawImage starts a new thread automatically which loads requested image. It looks after the process of image loading. This thread notifies ImageObserver whenever new data arrives or any modifications take place.When we are writing paint actually we are overriding some component class paint() method. Hence we can use this safely.

8) Compile and run the program. I have added how the output looks. Enjoy.

The real funny part is when you resize image you will understand how many times paint() method is being called.Resize it using mouse and observe the console where processing... is gets printed.

Any questions or clarifications or feedbacks are warmly welcomed.

Thank You

Output Screen :-