[ Team LiB ] Previous Section Next Section

12.9 Combining Colors with AlphaComposite

As we've just seen, antialiasing works by drawing with translucent colors at the edges of a shape. But what exactly does it mean to draw with a translucent color? Take another look at Figure 12-9, or, better yet, run the example using the GraphicsExampleFrame program, so you can see the example in full color. When you draw with a translucent color, whatever color is below it "shows through." In Figure 12-9, the background gray colors show through the pure translucent red and blue colors, resulting in reddish and bluish grays. At the hardware level, of course, there is no such thing as a translucent color; drawing with a translucent color is simulated by combining the drawing color with the existing color beneath it.

Combining colors in this way is called compositing and is the job of the Composite interface. You can pass a Composite object to the setComposite( ) method of a Graphics2D object to tell it how to combine a drawing color (the source color) with the colors that are already on the drawing surface (the destination colors). Java 2D defines one implementation of the Composite interface, AlphaComposite, that combines colors based on their alpha transparency values.

The default AlphaComposite object used by Graphics2D is sufficient for most drawing, so you don't often need to create AlphaComposite objects. Still, there are interesting effects you can achieve with AlphaComposite. Example 12-12 demonstrates these effects (and an unrelated clipping effect), which are shown in Figure 12-10.

Figure 12-10. Effects created with AlphaComposite

The example does much of its drawing into an off-screen image, then copies the contents of that image onto the screen. This is because many compositing effects can only be achieved when working with a drawing surface (such as an off-screen image) that has an "alpha channel" and supports transparent colors. Be sure to check out how this off-screen BufferedImage is created.

Example 12-12 also illustrates the type of effects that are possible when you set a clipping region. Java 2D allows any Shape to be used as a clipping region; graphics are displayed only if they fall within this shape. The example uses the java.awt.geom.Area class to define a complex shape, combining two ellipses and a rectangle, and then uses this shape as a clipping region.

Example 12-12. CompositeEffects.java
package je3.graphics;
import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;

public class CompositeEffects implements GraphicsExample {
    Image cover;  // The image we'll be displaying, and its size
    static final int COVERWIDTH = 127, COVERHEIGHT = 190;

    /** This constructor loads the cover image */
    public CompositeEffects( ) {
        java.net.URL imageurl = this.getClass( ).getResource("cover.gif");
        cover = new javax.swing.ImageIcon(imageurl).getImage( );

    // These are basic GraphicsExample methods
    public String getName( ) {return "Composite Effects";} 
    public int getWidth( ) { return 6*COVERWIDTH + 70; } 
    public int getHeight( ) { return COVERHEIGHT + 35; }

    /** Draw the example */
    public void draw(Graphics2D g, Component c) {
        // fill the background 
        g.setPaint(new Color(175, 175, 175));
        g.fillRect(0, 0, getWidth( ), getHeight( ));

        // Set text attributes
        g.setFont(new Font("SansSerif", Font.BOLD, 12));

        // Draw the unmodified image
        g.translate(10, 10);
        g.drawImage(cover, 0, 0, c);
        g.drawString("SRC_OVER", 0, COVERHEIGHT+15);

        // Draw the cover again, using AlphaComposite to make the opaque
        // colors of the image 50% translucent
        g.translate(COVERWIDTH+10, 0);
        g.drawImage(cover, 0, 0, c);

        // Restore the pre-defined default Composite for the screen, so
        // opaque colors stay opaque.
        // Label the effect
        g.drawString("SRC_OVER, 50%", 0, COVERHEIGHT+15);

        // Now get an offscreen image to work with.  In order to achieve
        // certain compositing effects, the drawing surface must support
        // transparency. Onscreen drawing surfaces cannot, so we have to do the
        // compositing in an offscreen image that is specially created to have
        // an "alpha channel", then copy the final result to the screen.
        BufferedImage offscreen =
            new BufferedImage(COVERWIDTH, COVERHEIGHT,
        // First, fill the image with a color gradient background that varies
        // left-to-right from opaque to transparent yellow
        Graphics2D osg = offscreen.createGraphics( );
        osg.setPaint(new GradientPaint(0, 0, Color.yellow,
                                       COVERWIDTH, 0,
                                       new Color(255, 255, 0, 0))); 
        osg.fillRect(0,0, COVERWIDTH, COVERHEIGHT);

        // Now copy the cover image on top of this, but use the DstOver rule
        // which draws it "underneath" the existing pixels and allows the
        // image to show depending on the transparency of those pixels.
        osg.drawImage(cover, 0, 0, c);
        // And display this composited image on the screen.  Note that the
        // image is opaque and that none of the screen background shows through
        g.translate(COVERWIDTH+10, 0);
        g.drawImage(offscreen, 0, 0, c);
        g.drawString("DST_OVER", 0, COVERHEIGHT+15);

        // Now start over and do a new effect with the off-screen image.
        // First, fill the offscreen image with a new color gradient.  We
        // don't care about the colors themselves; we just want the
        // translucency of the background to vary.  We use opaque black to
        // transparent black. Note that since we've already used this offscreen
        // image, we set the composite to Src, so we can fill the image and
        // ignore anything that is already there.
        osg.setPaint(new GradientPaint(0, 0, Color.black,
                                       COVERWIDTH, COVERHEIGHT,
                                       new Color(0, 0, 0, 0))); 
        osg.fillRect(0,0, COVERWIDTH, COVERHEIGHT);
        // Now set the compositing type to SrcIn, so colors come from the 
        // source, but translucency comes from the destination
        // Draw our loaded image into the off-screen image, compositing it.
        osg.drawImage(cover, 0, 0, c);
        // And then copy our off-screen image to the screen.  Note that the
        // image is translucent and some of the background shows through.
        g.translate(COVERWIDTH+10, 0);
        g.drawImage(offscreen, 0, 0, c);
        g.drawString("SRC_IN", 0, COVERHEIGHT+15);
        // If we do the same thing but use SrcOut, then the resulting image 
        // will have the inverted translucency values of the destination
        osg.setPaint(new GradientPaint(0, 0, Color.black,
                                       COVERWIDTH, COVERHEIGHT,
                                       new Color(0, 0, 0, 0))); 
        osg.fillRect(0,0, COVERWIDTH, COVERHEIGHT);
        osg.drawImage(cover, 0, 0, c);
        g.translate(COVERWIDTH+10, 0);
        g.drawImage(offscreen, 0, 0, c);
        g.drawString("SRC_OUT", 0, COVERHEIGHT+15);

        // Here's a cool effect; it has nothing to do with compositing, but
        // uses an arbitrary shape to clip the image.  It uses Area to combine
        // shapes into more complicated ones.
        g.translate(COVERWIDTH+10, 0);
        Shape savedClip = g.getClip( );  // Save current clipping region
        // Create a shape to use as the new clipping region.  
        // Begin with an ellipse
        Area clip = new Area(new Ellipse2D.Float(0,0,COVERWIDTH,COVERHEIGHT));
        // Intersect with a rectangle, truncating the ellipse.
        clip.intersect(new Area(new Rectangle(5,5,
        // Then subtract an ellipse from the bottom of the truncated ellipse.
        clip.subtract(new Area(new Ellipse2D.Float(COVERWIDTH/2-40,
                                                   COVERHEIGHT-20, 80, 40)));
        // Use the resulting shape as the new clipping region
        // Then draw the image through this clipping region
        g.drawImage(cover, 0, 0, c);
        // Restore the old clipping region so we can label the effect
        g.drawString("Clipping", 0, COVERHEIGHT+15);
    [ Team LiB ] Previous Section Next Section