Developing Imaging Applications Using the Java2D[tm], JAI and New ImageIO APIs

The Java 2D API provides enhanced two-dimensional graphics, text, and imaging capabilities for Java programs through extensions to the AWT.

We start by importing all the necessary packages.

import java.awt.*;
import java.awt.event.*;
import com.sun.image.codec.jpeg.*;
import java.awt.image.BufferedImage;
import java.awt.image.DataBuffer;
import java.awt.geom.GeneralPath;
import java.io.*;
import javax.swing.*;

Then we load our GIF or JPEG into an Image object using the Applet method getImage().

//read a jpeg image from an input file
 img = getToolkit().getImage(JPEGText.class.getResource("image.jpg"));
        try {
            MediaTracker tracker = new MediaTracker(this);
            tracker.addImage(img, 0);
            tracker.waitForID(0);
        } catch (Exception e) {}

When a component needs to be displayed, its paint() or update() method is automatically invoked with an appropriate Graphics context. You can use the Graphics2D rendering hints attribute to specify whether you want objects to be rendered as quickly as possible or whether you prefer that the rendering quality be as high as possible.

public void paint(Graphics g) {
        Graphics2D g2 = (Graphics2D) g;
        Dimension d = getSize();
        g2.setBackground(getBackground());
        g2.clearRect(0, 0, d.width, d.height);
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                            RenderingHints.VALUE_ANTIALIAS_ON);
        g2.setRenderingHint(RenderingHints.KEY_RENDERING,
                            RenderingHints.VALUE_RENDER_QUALITY);
        int w = d.width;
        int h = d.height;

        ....

BufferedImage can be used to hold and to manipulate image data retrieved from a file. To display the image, you need to set up the Graphics2D rendering context and then call one of the Graphics2D rendering methods. The graphic elements are rendered off-screen to the BufferedImage and are then copied to the screen through a call to Graphics2D drawImage().

BufferedImage bi = (BufferedImage) createImage(w, h);

You need to create a Graphics2D context for the BufferedImage by using the createGraphics() method.

Then you can use the drawImage() method from the Graphics2D class to draw the image into the buffered image.

     Graphics2D big = bi.createGraphics();
        big.drawImage(img, 0, 0, null); < p>You need to use the drawString() method in Graphics2D to add text to a graphic field at a certain location.

        //draw some strings with Font() on the BufferedImage
       big.setFont(new Font("Dialog", Font.PLAIN, 10));
   big.setColor(Color.black);
   big.drawString("BufferedImage", 4, 12);

        //display the BufferedImage on the screen
        g2.drawImage(bi, 0, 0, this);

Once the image is completely drawn, you can use the JPEGImageEncoder class of the non-standard com.sun.image.codec.jpeg package to encode the image. Or, if you use the Java[tm] 2 SDK, Standard Edition, v 1.4, you can use the standardImageIO class.

         //save the BufferedImage as a jpeg
        try {
             File file = new File("images", "test.jpg");
             FileOutputStream out = new FileOutputStream(file);
 

            JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
            JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam(bi);
            param.setQuality(1.0f, false);
            encoder.setJPEGEncodeParam(param);
            encoder.encode(bi);
            // or JDK 1.4
            // ImageIO.write(image, "JPEG", out);

        } catch (Exception ex) {
            g2.setColor(Color.red);
            g2.drawString("write permissions on images/test.jpg?", 5, h*2-5);
        }

Rotating Images
Finally, you can modify the transform attribute in the Graphics2D context to rotate graphics primitives when they are rendered. Graphics2D provides several methods for changing the transform attribute.

You can construct a new AffineTransform and change the Graphics2D transform attribute by calling transform.

We set the x, y coordinates of rotate() so that the image is rendered around an anchor point.

double x = 0.5*w;
        double y = 0.5*h;
        AffineTransform at = new AffineTransform();
        at.rotate(Math.toRadians(90),x,y);
        g2.transform(at);
        g2.drawImage(bi, 0, 0, null);

        where bi is BufferedImage

II) Using the Java Advanced Imaging API

Image acquisition and display are relatively easy in JAI. In this code example, we read a JPEG image, render into a BufferedImage and TIFF encode it.

JAI packages that needs to be imported are:

import javax.media.jai.*;
import com.sun.media.jai.codec.*;

The easiest way to load a local image file stored in JPEG or any other supported image file format is to use the "fileload" operation as follows:

private static RenderedImage img;

        // Read the image from the designated path.
        System.out.println("load image from '" + fileName+"'");
        img =  (RenderedImage)JAI.create("fileload", fileName);

Call RenderedImageAdapter to convert the image into PlanarImages.

The PlanarImage implements the java.awt.image.RenderedImage interface.

        RenderedImageAdapter ria = new RenderedImageAdapter(img);

        or we could simply call

        // PlanarImage image = JAI.create("fileload", fileName);

Use getAsBufferedImage on the PlanarImage to produce a BufferedImage.
Then use the drawImage() method from the Graphics2D class to draw the image into the buffered image.

        BufferedImage bi = ria.getAsBufferedImage();

Once we get the buffered image, the rest of the code is quite similar to the Java2D API discussed previously.

                  Graphics2D big = bi.createGraphics();

        big.setFont(new Font("Dialog", Font.PLAIN, 10));
        big.setColor(Color.black);
        big.drawString("BufferedImage", 4, 12);

        g2.drawImage(bi, 0, 0, this);

        //Define the destination file name

        File file = new File("images", "test.tiff");
        FileOutputStream out = new FileOutputStream(file);

Then we create the image encoder and encode the buffered image in TIFF.

        TIFFEncodeParam params = new TIFFEncodeParam();
        params.setCompression(TIFFEncodeParam.COMPRESSION_NONE);
        ImageEncoder encoder = ImageCodec.createImageEncoder("TIFF",out,params);
        if(encoder == null) {
                System.out.println("imageEncoder is null");
                System.exit(0);
        }
        encoder.encode(bi);

III) Using the New ImageIO API

The Java programming language Image I/O API provides a pluggable architecture for working with images stored in files and accessed across the network.

The javax.imageio.ImageIO class provides a set of static convenience methods that perform most simple Image I/O operations.

ImageIO packages that needs to be imported are:

import javax.imageio.*;

Reading a JPEG, GIF or PNG image is simple as shown below.

The format of the image will be auto-detected by the API based on the contents of the file.

            File f = new File("duke.jpg");
        BufferedImage bufi = ImageIO.read(f);

Writing an image in a supported format is equally simple:

            File file = new File("images", "test14.jpng");
        ImageIO.write(bufi, "png", file);
 

The list of supported formats may be obtained by calling ImageIO.getWriterFormatNames().

Summary

In this article we saw how to develop Java platform applications using the Java2D API, JAI and ImageIO Interfaces by covering the various APIs. We discussed each API, and learned about the Graphics context, BufferedImage operations, reading images, image encoding among various supported image formats, rotating images, displaying images on the screen and saving them to an image file in one of the supported formats.

Through the code samples contained here, we have seen some practical uses of the Imaging APIs, although we will not be using them to their full potential until they are used to perform sophisticated imaging operations.

For Further Information

        Java2D Tutorial
        JAI Programming Guide
        Java Image I/O API Guide
        All the above references are available from http://java.sun.com/.

Sources:
        Download JImage.jar  (press shift key and click) which contains the following files.

        JPEGJ2d.java
        JPEGJai.java
        JPEGImageIO.java
        duke.jpg

      Note: These samples have been modified from the tutorials above for illustration purpose.
 
  DOC ID #1280