Java2D入门与图形处理详解

需积分: 9 134 浏览量更新于2024-07-25 收藏 2.56MB PDF 举报

Java2D开发是基于Java平台的2D图形处理技术，它提供了一套强大的工具和接口，使得开发者能够创建各种复杂且交互式的图形应用程序。本文档旨在为Java程序员介绍Java2D的基本概念、功能和用法。首先，"WhoAreYou?" 和 "AboutThisBook" 部分可能会涉及作者或编者的介绍，以及书籍的目标读者和主要内容概览。这部分可能强调了Java2D作为Java SE的一部分，其在图形用户界面（GUI）设计、游戏开发、数据可视化等领域的应用价值。 "AbouttheExamples" 可能讨论了书中提供的示例代码的作用，这些例子通常用来帮助读者理解和实践Java2D的各种功能。字体约定部分("FontConventions")则可能介绍在文档中的文本格式和符号规范，以便读者更好地理解文档内容。 "RequestforComments" 和 "Acknowledgments" 部分可能包含反馈邀请和对合作者或支持者的感谢。 "Chapter1.Introduction" 是整个文档的入门部分，"WhatIsJava2D?" 会解释Java2D的定义和核心特性，包括它是如何在Java环境中处理2D图形的。随后的章节会探讨Java2D所能实现的功能，如渲染管道、透明度处理、图层混合和坐标空间管理。 "Chapter2.TheBigPicture" 强调Java2D的整体框架，包括Graphics2D类和渲染过程。"AllAboutAlpha" 部分深入讨论了透明度的概念，而"Compositing" 则讲解图层混合技术。 "Chapter3.Geometry" 讲解图形的基础元素，如点、形状、路径，以及针对高级用户的定制几何操作。"LinesandCurves" 包括直线和曲线的绘制，"Rectangles" 和 "EllipsesandArcs" 则介绍基本的几何形状。 "Chapter4.PaintingandStroking" 是关于绘画和描边操作的章节，讲解如何使用颜色、渐变和纹理进行绘图，以及如何控制线条的宽度和样式。 "Chapter5.Rendering" 转移到更高级的渲染技术，如变换、角度单位、图层混合、裁剪和渲染提示，这些都是确保图形效果精确和高效的关键因素。 "Chapter6.Text" 提供了文本绘制的概述，包括文本渲染、迭代器的使用等，这对于实现复杂的文字排版和布局至关重要。通过阅读这些章节，Java2D开发者可以系统地学习并掌握如何利用Java平台进行高质量的2D图形开发，无论是简单的图形界面还是复杂的图形算法实现。

Java 2D Graphics

age 12

It works exactly the same way in Java 2, except that it's a Graphics2D that is passed to paint(). To

take advantage of all the spiffy 2D features, you'll have to perform a cast in your paint() method,

like this:

public void paint(Graphics g) {

Graphics2D g2 = (Graphics2D)g;

// Now we can do cool 2D stuff.

}

Note that your component may not necessarily be drawn on the screen. The Graphics2D that gets

passed to paint() might actually represent a printer or any other output device.

Swing components work almost the same way. Strictly speaking, however, you should implement

the paintComponent() method instead of paint(). Swing uses the paint() method to draw child

components. Swing's implementation of paint() calls paintComponent() to draw the component

itself. You may be able to get away with implementing

paint() instead of paintComponent(), but

then don't be surprised if the component is not drawn correctly.

1.5.2 Drawing on Images

You can use a Graphics or Graphics2D to draw on images, as well. If you have an Image that you

have created yourself, you can get a corresponding Graphics2D by calling createGraphics(), as

follows:

public void drawOnImage(Image i) {

Graphics g = i.getGraphics();

// Now draw on the image using g.

}

This works only for any Image you've created yourself, not for an Image loaded from a file.

If you have a BufferedImage (Java 2D's new image class), you can obtain a Graphics2D as

follows:

public void drawOnBufferedImage(BufferedImage bi) {

Graphics2D g2 = bi.createGraphics();

// Now draw on the image using g2.

}

I'll talk more about these techniques in Chapter 9.

1.5.3 ApplicationFrame

Many of the examples in this book assume that you have a Graphics2D object to work with. This

section contains a simple test window that makes it easy to use a Graphics2D. The window,

ApplicationFrame, appears centered on your screen and goes away when you close it. You can

test

Graphics2D features easily by subclassing ApplicationFrame and overriding the paint()

method.

import java.awt.*;

import java.awt.event.*;

public class ApplicationFrame

extends Frame {

public ApplicationFrame() { this("ApplicationFrame v1.0"); }

Java 2D Graphics

age 13

public ApplicationFrame(String title) {

super(title);

createUI();

}

protected void createUI() {

setSize(500, 400);

center();

addWindowListener(new WindowAdapter() {

public void windowClosing(WindowEvent e) {

dispose();

System.exit(0);

}

});

}

public void center() {

Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();

Dimension frameSize = getSize();

int x = (screenSize.width - frameSize.width) / 2;

int y = (screenSize.height - frameSize.height) / 2;

setLocation(x, y);

}

Remember that the programming examples in this book are available online. See the Preface for

details.

1.6 File Formats

There are many, many ways to store graphics information in a file. In this section I'll briefly

describe two formats, GIF and JPEG. These formats are common currencies of the Internet—any

web browser that shows images knows how to show GIF and JPEG images. Similarly, the JDK can

load and display GIF or JPEG images.

For more detailed information on these formats, or on other popular graphics file formats, see the

Encyclopedia of Graphics File Formats , by James D. Murray and William vanRyper (O'Reilly).

1.6.1 GIF

GIF stands for Graphics Interchange Format. GIF images can have 2 to 256 colors and are

compressed before being stored. The compression algorithm is lossless, which means that the

original picture will be restored verbatim when the image is decompressed and displayed.

There are actually two common flavors of this format, GIF87a and GIF89a. GIF89a offers the

option of designating one of the image colors as transparent. Applications that know how to show

GIF89a images correctly will allow the background to show through the transparent areas of the

image. You've probably seen these "transparent GIFs" in web pages.

GIF89a also supports simple animations, which you've probably seen in web pages. These are

called animated GIFs ; they've been supported in Java since JDK 1.1. For more information on

animated GIFs, see GIF Animation Studio by Richard Koman (published by Songline Studios,

Inc.).

Java 2D Graphics

age 14

1.6.2 JPEG

JPEG stands for Joint Photographic Experts Group. Unlike some other file formats, it was designed

specifically for photographic images. JPEG images support more colors than GIF images, up to 24

bits per pixel. JPEG images are compressed before being stored using a lossy compression

algorithm. This means that when the image is loaded and displayed, it will not be exactly the same

as the original image. The 2D API includes support for reading and writing JPEG files in the

com.sun.image.codec.jpeg package, which is covered in Chapter 9.

1.6.3 Utilities

There are many utilities that convert images between different file formats. Here are five freeware

or shareware solutions:

GNU Image Manipulation Program (GIMP) (Unix, freeware)

Much of the functionality of Adobe Photoshop is included in this freeware application. See

http://www.gimp.org/.

ImageMagick (Unix, freeware)

This free application lets you convert from one file format to another, change the size of an

image, and perform other basic manipulations. See http://www.imagemagick.com.

xv (Unix, shareware)

This shareware application performs a variety of image manipulation functions. The full

source code is available. See http://www.trilon.com/xv/xv.html.

GraphicConverter (MacOS, shareware)

This versatile tool handles most common graphics file formats with a clean interface and

lots of useful features. See http://www.lemkesoft.de/us_index.html.

LView Pro (Windows, shareware)

This is a Windows program, similar to GraphicConverter for the Mac. It handles a variety of

file formats and offers some editing features. See http://www.lview.com/.

If you're more serious about images and image processing, you should get a real tool like Adobe's

Photoshop (http://www.adobe.com/) or Live Picture from the company of the same name

(http://www.mgisoft.com/index_flash.asp).

1.7 Hello, 2D!

This chapter ends with a bang—an example that demonstrates the power of the 2D API. You

probably won't understand much of the code at this point, but rest assured that it all will become

clear as you work through the rest of the book.

In general terms, this is what the example does:

• The example draws a background of colored circles.

Java 2D Graphics

age 15

• Then the example draws an image. The image is broken into small pieces, and each piece is

drawn partially transparent, allowing the circles to show through. The image is Raphael's

self-portrait, taken from the Virtual Uffizi at http://www.arca.net/uffizi/.

• Finally, the example draws some text on a color-gradient-filled background. Then the text is

drawn a second time, rotated 90°.

The results are shown in Figure 15.1. This is a less than 200 lines of code (with lots of comments).

It's a small subset of what can be accomplished with the 2D API.

Note that this example depends on the ApplicationFrame class presented earlier in this chapter. If

you haven't entered and compiled ApplicationFrame, do it now.

[3]

Like all the other examples in this book, ShowOff is available online. See the Preface for details.

import java.awt.*;

import java.awt.event.*;

import java.awt.font.*;

import java.awt.geom.*;

import java.awt.image.BufferedImage;

import java.io.*;

import java.util.Random;

import com.sun.image.codec.jpeg.*;

public class ShowOff

extends Component {

public static void main(String[] args) {

try {

// The image is loaded either from this

// default filename or the first command-

// line argument.

// The second command-line argument specifies

// what string will be displayed. The third

// specifies at what point in the string the

// background color will change.

String filename = "Raphael.jpg";

String message = "Java2D";

int split = 4;

if (args.length > 0) filename = args[0];

if (args.length > 1) message = args[1];

if (args.length > 2) split = Integer.parseInt(args[2]);

ApplicationFrame f = new ApplicationFrame("ShowOff v1.0");

f.setLayout(new BorderLayout());

ShowOff showOff = new ShowOff(filename, message, split);

f.add(showOff, BorderLayout.CENTER);

f.setSize(f.getPreferredSize());

f.center();

f.setResizable(false);

f.setVisible(true);

}

catch (Exception e) {

System.out.println(e);

System.exit(0);

}

private BufferedImage mImage;

private Font mFont;

private String mMessage;

private int mSplit;

private TextLayout mLayout;

Java 2D Graphics

age 16

public ShowOff(String filename, String message, int split)

throws IOException, ImageFormatException {

// Get the specified image.

InputStream in = getClass().getResourceAsStream(filename);

JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(in);

mImage = decoder.decodeAsBufferedImage();

in.close();

// Create a font.

mFont = new Font("Serif", Font.PLAIN, 116);

// Save the message and split.

mMessage = message;

mSplit = split;

// Set our size to match the image's size.

setSize((int)mImage.getWidth(), (int)mImage.getHeight());

}

public void paint(Graphics g) {

Graphics2D g2 = (Graphics2D)g;

// Turn on antialiasing.

g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,

RenderingHints.VALUE_ANTIALIAS_ON);

drawBackground(g2);

drawImageMosaic(g2);

drawText(g2);

}

protected void drawBackground(Graphics2D g2) {

// Draw circles of different colors.

int side = 45;

int width = getSize().width;

int height = getSize().height;

Color[] colors = { Color.yellow, Color.cyan, Color.orange,

Color.pink, Color.magenta, Color.lightGray };

for (int y = 0; y < height; y += side) {

for (int x = 0; x < width; x += side) {

Ellipse2D ellipse = new Ellipse2D.Float(x, y, side, side);

int index = (x + y) / side % colors.length;

g2.setPaint(colors[index]);

g2.fill(ellipse);

}

protected void drawImageMosaic(Graphics2D g2) {

// Break the image up into tiles. Draw each

// tile with its own transparency, allowing

// the background to show through to varying

// degrees.

int side = 36;

int width = mImage.getWidth();

int height = mImage.getHeight();

for (int y = 0; y < height; y += side) {

for (int x = 0; x < width; x += side) {

// Calculate an appropriate transparency value.

float xBias = (float)x / (float)width;

float yBias = (float)y / (float)height;

float alpha = 1.0f - Math.abs(xBias - yBias);

g2.setComposite(AlphaComposite.getInstance(

AlphaComposite.SRC_OVER, alpha));

// Draw the subimage.

int w = Math.min(side, width - x);

剩余290页未读，继续阅读

EamonAnt

粉丝: 0
资源: 8

Java2D入门与图形处理详解

Java游戏编程入门

教你实现自己的Java 2D游戏引擎

Java 2D开发技巧之“灯光与阴影”

JAVA2D开发实例

java2D Java Java Java

GameDevSetup:为 Java 2D 游戏开发设置库和工作环境

java 2D api

java 2d game

java2d 文档

java 2D Graphics

最新资源