计算机图形学基础：Java、OpenGL与JOGL

需积分: 10 194 浏览量更新于2024-07-17 收藏 1.41MB PDF 举报

《计算机图形学基础》是一本由David J. Eck撰写并以Java、OpenGL和JOGL为主要技术框架的教材。这本书于2010年5月发布了一个初步的、部分版本，旨在为学习者提供一个深入理解计算机图形学的基础。该书的原始电子版可在线获取，网址为<http://math.hws.edu/graphicsnotes/>。PDF版本不包含源代码文件，但提供了外部链接到这些文件，这些链接在阅读时以蓝色字体显示。此外，每个章节还附有指向在线版本的链接，方便读者查阅最新更新。 PDF版还包括内部链接，用红色标识，这些链接可以在Adobe Acrobat Reader等支持的PDF阅读器中直接点击导航。作者David J. Eck是霍巴特与威廉史密斯学院的数学与计算机科学系教授，他保留了作品的版权，并允许对其进行非商业性修改和分享，只要这些修改后的版本同样遵循Creative Commons Attribution-ShareAlike 3.0许可证。该许可协议允许用户自由复制、分发和修改作品，但要求所有衍生作品也需以同样的授权方式发布，以便知识共享。通过这本教材，读者可以系统地学习计算机图形学的基本概念，包括但不限于图像处理、几何变换、色彩理论、渲染技术、图形硬件接口以及使用Java和相关库（如OpenGL和JOGL）进行图形编程的方法。书中详尽阐述了如何构建可视化效果，以及如何利用这些技术来创建交互式图形应用程序。无论是对图形学入门者还是进阶研究者，这本书都是一个宝贵的资源，提供了实践与理论相结合的学习体验。

CHAPTER 1. JAVA GRAPHICS IN 2D 10

The source code ﬁles QuadraticBezierEdit.java and CubicBezierEdit.java deﬁne applications

that let you edit the curves shown in this image by dragging the control points and endpoints

of the curve. You can also ﬁnd applet versions of these applications in the web-site version of

these notes.

∗ ∗ ∗

Once you have a Path2D or a Line2D, or ind eed any object of type Shape, you can use it

with a Graphics2D. The Graphics2D class deﬁnes the methods

public void draw(Shape s)

public void fill(Shape s)

for drawing and ﬁlling S hapes. A Graphics2D has an instance variable of type Paint that tells

how shapes are to be ﬁlled. Paint is ju st an interface, but there are several standard classes

that implement that interface. One example is class Color. If the current paint in a Graphics2D

g2 is a Color, then calling g2.ﬁll(s) will ﬁll the Shape s with solid color. However, there are

other types of Paint, such as GradientPaint and TexturePaint, that represent other typ es of ﬁll.

You can set the Paint in a Graphics2D g2 by calling g2.setPaint(p). For a Color c, calling

g2.setColor(c) also sets the paint.

Calling g2.draw(s) will “stroke” the shape by moving an imaginary pen along the lines or

curves that make up the shape. You can use this m ethod, for example, to draw a line or the

boundary of a rectangle. By default, the shape will be stroked using a pen that is one unit

wide. In the usual pixel coord inates, this means one pixel wide, but in a non-standard coordinate

system, the pen will be one unit wide and one unit high, according the units of that coord inate

system. The pen is actually deﬁned by an object of type Stroke, which is another interface. To

set the stroke property of a Graphics2D g2, you can use the method g2.setStroke(stroke). The

stroke will almost certainly be of type B asicStroke, a class that implements the Stroke interface.

For example to draw lines with g2 that are 2.5 times as wide as usual, you would say

g2.setStroke( new BasicStroke(2.5F) );

Note that the parameter in the constructor is of type ﬂoat. BasicStroke has several alternative

constructors that can be used to specify various characteristics of the pen, such as how an

endpoint should be drawn and how one piece of a curve should be joined to the next. Most

interesting, perhaps, is the ability to draw dotted and dashed lines. Unfortunately, the details

CHAPTER 1. JAVA GRAPHICS IN 2D 11

are somewhat complicated, but as an example, here is how you can create a pen that draws a

pattern of dots and dashes:

float[] pattern = new float[] { 1, 3, 5, 3 }; // pattern of lines and spaces

BasicStroke pen = new BasicStroke( 1, BasicStroke.CAP

BUTT,

BasicStroke.JOIN

ROUND, 0, pattern, 0 );

This pen would draw a one-unit-long dot, followed by a 3-unit-wide space, followed by a 5-

unit-long dash, followed by a 3-unit-wide space, with the pattern repeating after that. You can

adjust the pattern to get diﬀerent types of dotted and dashed lines.

Note that in addition to the current Stroke, the eﬀect of g2.draw(s) also depends on the

current Paint in g2. The area covered by the pen is ﬁlled with the curr ent paint.

∗ ∗ ∗

Before leaving the topic of drawing with Graphi cs2D, I sh ould mention antialiasing. Aliasing

is a problem for raster-type graphics in general, caused by the fact that raster images are made

up of small, solid-colored pixels. It is not possible to draw geometrically perfect pictures by

coloring pixels. A diagonal geometric line, for example, will cover some pixels only partially,

and it is not possible to make a pixel half black and half white. When you try to draw a

line with black and w hite pixels only, the r esult is a jagged staircase eﬀect. This eﬀect is an

example of aliasing. Aliasing can also be s een in the outlines of characters drawn on the screen

and in diagonal or cur ved boun daries between any two regions of diﬀerent color. (The term

aliasing likely comes f rom the fact that most pictures are n aturally described in real-number

co ordinates. When you try to represent the image using pixels, many real-number co ordinates

will map to the same integer pixel coordinates; they can all be considered as diﬀerent names or

“aliases” for th e same pixel.)

Antialiasing is a term for techniques that are designed to mitigate the eﬀects of aliasing.

The idea is that when a pixel is only partially covered by a shape, the color of the pixel should

be a mixture of the color of the shape and the color of the background. When drawing a

black line on a w hite background, the color of a partially covered pixel would be gray, with the

shade of gray depending on the fraction of the pixel that is covered by the line. (In practice,

calculating this area exactly for each pixel would be too diﬃcult, so some approximate method

is used.) Here, for example, are two lines, greatly magniﬁed so that you can see the individual

pixels. The one on the right is drawn using antialiasing, while the one on the left is n ot:

CHAPTER 1. JAVA GRAPHICS IN 2D 12

Note that antialiasing does not give a perf ect image, but it can reduce the “jaggies” that are

caused by aliasing.

You can turn on antialiasing in a Graphics2D, and d oing so is generally a good idea. To do

so, simply call

g2.setRenderingHint(RenderingHints.KEY ANTIALIASING, RenderingHints.VALUE ANTIALIAS ON);

before using the Graphics2D g2 for drawing. Antialiasing can be applied to lines, to text, and

to the curved shapes such as ellipses. Note that turning on antialiasing is considered to be a

“hint,” which means that its exact eﬀect is not guaranteed, and it might even have no eﬀect

at all. In general, though, it does give an imp roved image. Turning antialiasing on does slow

down the drawing process, and the slow-down might be noticeable when drawing a very complex

image.

1.3 Transformations and Modeling

We now turn to another aspect of two-dimensional graphics in Java: geometric trans- (online)

formations. The material in this section will carry over nicely to three dimensions an d OpenGL.

It is an important foundation for th e rest of the course.

1.3.1 Geometric Transforms

Being able to draw geometric shapes is important, b ut it is only part of the story. Just as

important are geometric transforms that allow you to modify the shapes that you draw,

such as by moving them, changing their size, or rotating them. Some of this, you can do by

hand, by doing your own calculations. For example, if you want to move a shape three units to

the right, you can simply add 3 to each of th e horizontal coordinates that are used to draw the

shape. This would quickly become tedious, however, so its nice that we can get th e computer

to do it for us simply by specifying an appropriate geometric trans form. Fur th ermore, there

are things that you simply can’t do in Java without transforms. For example, when you draw

a string of text without a transform, th e baseline of the text can only be horizontal. There is

no way to draw the string tilted to a 30-degree angle. Similarly, the only way to draw a tilted

image is by applying a transform. Here is an example of a string and an image drawn by Java

in their normal orientation and w ith a counterclockwise 30-degree rotation:

CHAPTER 1. JAVA GRAPHICS IN 2D 13

Every Graphics2D graphics context has a current transform that is applied to all drawing

that is done in that context. You can change the transform, and the new value will apply to

all subsequent drawing operations; it will not aﬀect things that have already been drawn in

the graphics context. Generally, in a newly created Graphics2D, the current transform is the

identity transform, which has no eﬀect at all on drawing. (There are some exceptions to

this. For example, when drawing to a printer, the pixels are very small. If the same coordinates

are used when drawing to the pr inter as are us ed on the screen, the resulting picture would

be tiny. So, when drawing to a printer, Java provides a default transform that magniﬁes the

picture to make it look about the same size as it does on the screen.)

The transform in a Graphics2D can be any aﬃne transform. An aﬃne transform has the

property that when it is applied to any s et of parallel lines, the result is also a set of parallel

lines (or, possibly, a single line or even a single point). An aﬃne transform in two dimensions

can be speciﬁed by six numbers a, b, c, d, e, and f, which have the property that when the

transform is applied to a point (x,y), the resulting point (x1,y1) is given by th e formulas:

x1 = a*x + b*y + e

y1 = c*x + d*y + f

Aﬃne transform s have th e important property that if you apply one aﬃne transform and then

follow it with a second aﬃne transform, the result is another aﬃne transform. For example,

moving each point three u nits to the right is an aﬃne transform, and so is rotating each point by

30 degrees about the origin (0,0). Therefore the combined transform that ﬁrst moves a point to

the right and then r otates it is also an aﬃne transform. Combining two aﬃne transformations

in this way is called multiplying them (although it is not multiplication in the usual s en s e).

Mathematicians often use the term composing rather than multiplying.

It’s possible to build up any two-dimensional aﬃne transformation from a few basic kinds

of simple transforms: translation, rotation, and scaling . I t’s good to have an intuitive

understanding of these basic transforms and how they can be used, so we will go through them

in some detail. The eﬀect of a transform depends on what coordinate system you are using for

drawing. For this discussion, we assume that the origin, (0,0), is at the center of the picture,

with the positive direction of the x-axis pointing to the right and the positive direction of the y-

axis pointing up. Note that this orientation for the y-axis is the opposite of the usual orientation

CHAPTER 1. JAVA GRAPHICS IN 2D 14

in Java; it is, however, the more common orientation in mathematics and in OpenGL.

∗ ∗ ∗

A translation simply moves each point by a certain amount horizontally and a certain

amount vertically. The formula for a translation is

x1 = x + e

y1 = y + f

where the point (x,y) is moved e units horizontally and f units vertically. (Thus for a translation,

a = d = 1, and b = c = 0.) I f you wanted to apply this translation to a Graphics2D g, you

could simply say g.translate(e,f ). This would mean that for all subsequent d rawing operations,

e would be added to the x-coordinate and f would be added to the y-coordinate. Let’s look

at an example. Suppose that you are going to draw an “F” centered at (0,0). If you say

g.translate(4,2) before drawing the “F”, then every point of the “F” will be moved over 4

units and up 2 un its, and the “F” that appears on the screen will actually be centered at (4,2).

Here is a picture:

The light gray “F” in this picture shows what would be drawn without the translation; the

dark red “F” sh ows the same “F” drawn after applying a translation by (4,2). The arrow shows

that the upper left corner of the “F” has been moved over 4 units and up 2 units. Every point

in the “F” is subjected to the same displacement.

Remember that when you say g.translate(e,f ), the tr anslation applies to all the drawing that

you do after that, not just to the next shape that you draw. If you apply another transformation

to the same g, the second transform will not replace the translation. It will be multiplied by

the translation, so th at subsequent drawing will be aﬀected by the combined transformation.

This is an important point, and there w ill be a lot more to say about it later.

∗ ∗ ∗

A rotation rotates each point about the origin, (0,0). Every p oint is rotated through the

same angle, called the angle of rotation. For this pur pose, angles in Java are measured in

radians, not degrees. For example, the measure of a right angle is π/2, not 90. Positive angles

move the positive x-axis in the direction of the positive y-axis. (This is counterclockwise in the

co ordinate system that we are using here, but it is clockwise in the usual pixel coordinates,

where the y -axis points down rather than u p.) Although it is not obvious, when rotation

through an angle of r radians about the origin is applied to the point (x,y), then the resulting

point (x1,y1) is given by

x1 = cos(r) * x - sin(r) * y

y1 = sin(r) * x + cos(r) * y

剩余136页未读，继续阅读

汪江汇

粉丝: 0
资源: 1

计算机图形学基础：Java、OpenGL与JOGL

Foundations Of 3D Computer Graphics (高清PDF扫描版)

Computer_Graphics_with_OpenGL_4th_ed.pdf

computer graphics

foundation of computer science solution manual

geometry computation foundation of design 下载

foundation of machine learning

foundation of data science中文版

xmlgraphics

explain software architecture of android

mfc 调用media foundation

最新资源