Komputer Grafik

Reading list

• Introduction to Computer Graphics– Foley, Van Dam and Feiner, Hughes, Phillips– Addison-Wesley

• Computer Graphics, Principles and Practice– Foley, Van Dam,Feiner, Hughes– Addison Wesley.

• Old Leaving Cert maths books !?!

What is computer graphics?

PicturesVideo Image processing / analysisGUIs3D ModellingVirtual Reality

Pictures

• Varoius formats: BMP, GIF, JPEG…

• .mov, .avi, .wmv, DivX, Quicktime…

Image processing / analysis

• Filters, image enhancement, medical imaging, astronomy…

• Edge detection, face recognition…

Graphical User Interface (GUI)

• W.I.M.P - Windows, icons,menu, pointers

3D Modelling

• Cartesian Coordinate System• Transformations • Clipping• Hidden line removal• Lighting

3D Modelling

• Fully immersive, interactive 3D displays

Course content

• The emphasis of the course is on the algorithms and techniques used to develop realistic views of three dimensional objects modelled in the computer.

• Developing views will involve problems of scaling, rotation, translation, curves, and hidden surface removal.

• Aim to put the theory to practice through the use of the graphics language ‘processing’

Course content

What will be covered:• Raster displays • Cartesian Coordinate System• Introduction to ‘Processing’

language• 2D Transformation, Scaling &

Rotation• 2D Transformation using

matrices• 3D Transformation, Scaling &

Rotation using martices• Simple animation/interaction• Surface Modelling• Hidden-Surface Problem.

What will NOT be covered:1. Paint and Imaging packages

(Adobe Photoshop) 2. CAD packages (AutoCAD) 3. Rendering packages (Lightscape) 4. Modelling packages (3D Studio

MAX, Blender) 5. Animation packages (Digimation)

Computer graphics = Maths

• Can’t stress this enough!

• Primarily… matrices, trigonometry and calculus.

1000cos*sin*0sin*cos*

1000cossin0sincos

1000000

)(),(1

θθθθ

1000000

1000cossin0sincos

),()(2

θθθθ

Practical work

http://www.processing.org/

“ Processing is an open source programming language and environment for people who want to program images, animation, and sound. It is used by students, artists, designers, architects, researchers, and hobbyists for learning, prototyping, and production. It is created to teach fundamentals of computer programming within a visual context and to serve as a software sketchbook and professional production tool. ”

2D Transformations with Matrices

Matrices

3,32,31,3

3,22,21,2

3,12,11,1

aaaaaaaaa

• A matrix is a rectangular array of numbers.

• A general matrix will be represented by an upper-case italicised letter.

• The element on the ith row and jth column is denoted by ai,j. Note that we start indexing at 1, whereas C indexes arrays from 0.

• Given two matrices A and B if we want to add B to A(that is form A+B) then if A is (n×m), B must be (n×m), Otherwise, A+B is not defined.

• The addition produces a result, C = A+B, with elements:

Matrices – Addition

jijiji BAC ,,, +=

121086

84736251

• Given two matrices A and B if we want to multiply B by A(that is form AB) then if A is (n×m), B must be (m×p), i.e., the number of columns in A must be equal to the number of rows in B. Otherwise, AB is not defined.

• The multiplication produces a result, C = AB, with elements:

(Basically we multiply the first row of A with the first column of B and put this in the c1,1 element of C. And so on…).

Matrices – Multiplication

kkjikji baC

966695557644

623386

329854762

Matrices – Multiplication (Examples)

2×6+ 6×3+ 7×2=44

623386

Undefined!2x2 x 3x2 2!=3

2x2 x 2x4 x 4x4 is allowed. Result is 2x4 matrix

• Unlike scalar multiplication, AB ≠ BA

• Matrix multiplication distributes over addition:A(B+C) = AB + AC

• Identity matrix for multiplication is defined as I.

• The transpose of a matrix, A, is either denoted AT or A’ is obtained by swapping the rows and columns of A:

Matrices -- Basics

3,23,1

2,22,1

1,21,1

3,22,21,2

3,12,11,1 'aaaaaa

Aaaaaaa

2D Geometrical Transformations

Translate

Rotate Scale

Translate Points

Recall.. We can translate points in the (x, y) plane to new positions by adding translation amounts to the coordinates of the points. For each point P(x, y) to be moved by dx units parallel to the x axis and by dyunits parallel to the y axis, to the new point P’(x’, y’ ). The translation has the following form:

dyydxx

P(x,y)

P’(x’,y’)

In matrix format:

If we define the translation matrix , then we have P’ =P + T.

Scale Points

Points can be scaled (stretched) by sx along the x axis and by syalong the y axis into the new points by the multiplications:

We can specify how much bigger or smaller by means of a “scale factor”

To double the size of an object we use a scale factor of 2, to half the size of an obejct we use a scale factor of 0.5

ysyxsx

P(x,y)

P’(x’,y’)

xsx• x

sy• y

If we define , then we have P’ =SP

Rotate Points (cont.)

Points can be rotated through an angle θ about the origin:

θθθαθα

θαθα

θθθαθα

θαθα

cossincossinsincos

)sin()sin(|'|'

sincossinsincoscos

)cos()cos(|'|'

−=−=

P(x,y)

P’(x’,y’)

θθθθ

cossinsincos

P’ =RP

Review…

• Translate: P’ = P+T• Scale: P’ = SP• Rotate: P’ = RP

• Spot the odd one out…– Multiplying versus adding matrix…– Ideally, all transformations would be the same..

• easier to code

• Solution: Homogeneous Coordinates

Homogeneous Coordinates

For a given 2D coordinates (x, y), we introduce a third dimension:

[x, y, 1]

In general, a homogeneous coordinates for a 2D point has the form:

[x, y, W]

Two homogeneous coordinates [x, y, W] and [x’, y’, W’] are said to be of the same (or equivalent) if

x = kx’ eg: [2, 3, 6] = [4, 6, 12]y = ky’ for some k ≠ 0 where k=2W = kW’

Therefore any [x, y, W] can be normalised by dividing each element by W:[x/W, y/W, 1]

Homogeneous Transformations

Now, redefine the translation by using homogeneous coordinates:

Similarly, we have:

11001001

PTP ×='

11000000

11000cossin0sincos

θθθθ

Scaling Rotation

P’ = S × P P’ = R × P

Composition of 2D Transformations

1. Additivity of successive translations

We want to translate a point P to P’ by T(dx1, dy1) and then to P’’ by another T(dx2, dy2)

On the other hand, we can define T21= T(dx1, dy1) T(dx2, dy2) first, then apply T21 to P:

]),()[,('),('' 112222 PddTddTPddTP yxyxyx ==

PTP 21'' =

1001001

),(),(

112221

ddTddTT

T(-1,2) T(1,-1)

(1,3)(2,2)

100110001

100210101

100110

Examples of Composite 2D Transformations

Composition of 2D Transformations (cont.)

2. Multiplicativity of successive scalings

PSPssSssS

PssSssSP

)],(),([

]),()[,(''

1000*000*

1000000

),(),(

112221

ssSssSS

3. Additivity of successive rotations

)]()([])()[(''

θθθθ

+++−+

1000)cos()sin(0)sin()cos(

1000cossin0sincos

θθθθθθθθ

θθθθ

θθ RRR

4. Different types of elementary transformations discussed above can be concatenated as well.

MPPddTR

PddTRP

)],()([

]),()[('

),()( yx ddTRM θ=

Consider the following two questions:

1) translate a line segment P1 P2, say, by -1 units in the x direction and -2 units in the y direction.

2). Rotate a line segment P1 P2, say by θ degrees counter clockwise, about P1.

P1(1,2)

P2(3,3)

P1(1,2)

P2(3,3)P’2

Other Than Point Transformations…

Translate Lines: translate both endpoints, then join them.

Scale or Rotate Lines: More complex. For example, consider to rotate an arbitrary line about a point P1, three steps are needed:1). Translate such that P1 is at the origin;2). Rotate;3). Translate such that the point at the origin

returns to P1.

T(-1,-2) R(θ)

P1(1,2)

P2(3,3)

P2(2,1)T(1,2)P2

Another Example.

Translate

Rotate

Translate

Order Matters!

As we said, the order for composition of 2D geometrical transformations matters, because, in general, matrix multiplication is not commutative. However, it is easy to show that, in the following four cases, commutativity holds:

1). Translation + Translation2). Scaling + Scaling3). Rotation + Rotation4). Scaling (with sx = sy) + Rotation

just to verify case 4:

if sx = sy, M1 = M2.

1000cossin0sincos

1000000

)(),(1

θθθθ

1000000

1000cossin0sincos

),()(2

θθθθ

Rigid-Body vs. Affine Transformations

A transformation matrix of the form

where the upper 2×2 sub-matrix is orthogonal, preserves angles and lengths. Such transforms are called rigid-body transformations, because the body or object being transformed is not distorted in any way. An arbitrary sequence of rotation and translation matrices creates a matrix of this form.

The product of an arbitrary sequence of rotation, translations, and scale matrices will cause an affine transformation, which have the property of preserving parallelism of lines, but not of lengths and angles.

1002221

trrtrr

Rigid-Body vs. Affine Transformations (cont.)

Shear transformation is also affine.

Unit cube 45º Scale in x, not in y

Rigid- bodyTransformation

AffineTransformation

Shear in the x direction Shear in the y direction

10001001 a

10001001

3D Transformations

• 2D coordinates • 3D coordinates

Right-handed coordinate system:

3D Transformations (cont.)

1. Translation in 3D is a simple extension from that in 2D:

2. Scaling is similarly extended:

1000100010001

zyx ddd

1000000000000

zyx ss

3D Transformations (cont.)

3. The 2D rotation introduced previously is just a 3D rotation about

the z axis.

similarly we have: X

1000010000cossin00sincos

)(θθθθ

10000cossin00sincos00001

)(θθθθ

10000cos0sin00100sin0cos

)(θθ

Composition of 3D Rotations

In 3D transformations, the order of a sequence of rotations matters!

10000cos0sin0sinsincoscossin0sincossincoscos

)()(βββααβαβααβα

ββαααα

βα yz RR

10000cossinsincossin00cossin0sincossincoscos

)()(βαβαβ

ααββαβα

αααα

αβ zy RR

)()()()( βααβ yzzy RRRR ≠

More Rotations

We have shown how to rotate about one of the principle axes, i.e. the

axes constituting the coordinate system. There are more we can do,

for example, to perform a rotation about an arbitrary axis:

P2(x2, y2 , z2)

P1(x1, y1 , z1)

We want to rotate an object about an

axis in space passing through (x1, y1, z1)

and (x2, y2, z2).

Rotating About An Arbitrary AxisY

1). Translate the object by (-x1, -

y1, -z1): T(-x1, -y1, -z1)

2). Rotate the axis about x so

that it lies on the xz plane: Rx(α)

3). Rotate the axis about y so

that it lies on z: Ry (β)

4). Rotate object about z by θ: Rz(θ)

Rotating About An Arbitrary Axis (cont.)

After all the efforts, don’t forget to undo the rotations and the translation!

Therefore, the mixed matrix that will perform the required task of rotating an

object about an arbitrary axis is given by:

M = T(x1,y1,z1) Rx(-α)Ry(-β) Rz(θ) Ry(β) Rx(α)T(-x1,-y1,-z1)

Finding β is trivial, but what about α?

The angle between the z axis and the

projection of P1 P2 on yz plane is α.

2D Transformations

What is a transformation?

• A transformation is an operation that transforms or changes a shape (line, drawing etc.)

• There are several basic ways you can change a shape: – translation (moving it)

– rotation (turning it round)

– scaling (making it bigger or smaller).

• There are others, but we’ll worry about them later.

2D Geometrical Transformations

Translate

Rotate Scale

Translation

• Consider the arrow below. We may want tomove it from position A to position B.

Translate Points

We can translate points in the (x, y) plane to new positions by adding translation amounts to the coordinates of the points. For each point P(x, y) to be moved by dx units parallel to the x axis and by dyunits parallel to the y axis, to the new point P’(x’, y’ ). The translation has the following form:

dyydxx

P(x,y)

P’(x’,y’)

Translating a line or shape

• To translate a line, simply translate both of its end points.

• Translating a shape therefore, simply translate all of thepoints.

• The same applies for all transformations.

Scale Points

Points can be scaled (stretched) by sx along the x axis and by syalong the y axis into the new points by the multiplications:

We can specify how much bigger or smaller by means of a “scale factor”

To double the size of an object we use a scale factor of 2, to half the size of an obejct we use a scale factor of 0.5

ysyxsx

==''P(x,y)

P’(x’,y’)

xsx• x

sy• y

We first review the idea of sin and cos for a given angle θ :

Useful formulas:

Rotate Points

sincos

/sin/cos

θθθθθαθαθαθαθαθα

sin)sin(cos)cos(sinsincoscos)cos(sincoscossin)sin(

−=−=−−=++=+

Rotate Points (cont.)

Points can be rotated through an angle θ about the origin:

θθθαθα

θαθα

θθθαθα

θαθα

cossincossinsincos

)sin()sin(|'|'

sincossinsincoscos

)cos()cos(|'|'

−=−=

P(x,y)

P’(x’,y’)

Identity transformations

• Some transformations lead to no change in the shape/drawing

• Translate(0,0)• Rotate(0)• Scale(1,1)

Order of transformations

• The order in which transformations are applied to ashape is important.

• Performing a translation followed by a rotation, will givean entirely different drawing to a performing the rotationfollowed by the same translation.

rotation by 45° followed by translation (100,0)

translation (100,0) followed by rotation by 45°

Rotation around local origin

• At the moment, our rotation is centred around theorigin. What is often required is to spin the shape inits original location (in-situ)

local origin

Rotation around local origin

• This can be achieved by combining two of our existingtransformations: Translate the shape to the origin, rotateit the required amount about the origin and translate itback to where it was.

Local rotation

Summary

• So we have looked at simple transformation ofpoints/lines etc.

• Next we will look at transformations using matrices.

Composite 3D Transformations

Example of Composite 3D Transformations

Try to transform the line segments P1P2 and P1P3 from their start position in (a) to their ending position in (b).

The first solution is to compose the primitive transformations T, Rx, Ry, and Rz. This approach is easier to illustrate and does offer help on building an understanding. The 2nd, more abstract approach is to use the properties of special orthogonal matrices.

(a) (b)

Breaking a difficult problem into simpler sub-problems:1.Translate P1 to the origin.2. Rotate about the y axis such that P1P2 lies in the (y, z) plane.3. Rotate about the x axis such that P1P2 lies on the z axis.4. Rotate about the z axis such that P1P3 lies in the (y, z) plane.

−−−

1000100010001

−−

10000sin0cos00100cos0sin

))90((

zzyyxxPzyxTPzzyyxxPzyxTP

PzyxTP

]1[),,(

]1000[),,(

1313133111'

1212122111'

−−−=•−−−=

=•−−−=

P′1 P′2

10000cossin00sincos00001

φφφφ

P′′1P′′2 φD2

P′′′1

P′′′2

P′′′3

)(αzR

TRzyxTRRR yxz ⋅=−−−⋅−⋅⋅ ),,()90()()( 111θφα

Finally, we have the composite matrix:

Vector Rotation

Rotate the vector

θθθθ

sincos

cossinsincos

The unit vector along the x axis is [1, 0]T. After rotating about the origin by θ, the resulting vector is

Vector Rotation (cont.)

Rotate the vector

θθθθ

cossin

cossinsincos

The above results states that if we try to rotate a vector, originally pointing the direction of the x (or y) axis, toward a new direction, u (or v), the rotation matrix, R, could be simply written as [u | v] without the need of any explicit knowledge of θ, the actual rotation angle.

Similarly, the unit vector along the y axis is [0, 1]T. After rotating about the origin by θ, the resulting vector is

Vector Rotation (cont.)

The reversed operation of the above rotation is to rotate a vector that is not originally pointing the x (or y) direction into the direction of the positive x or y axis. The rotation matrix in this case is R(-θ ), expressed by R-1(θ )

where T denotes the transpose.

)(cossinsincos

)cos()sin()sin()cos(

)(1 θθθθθ

θθθθ

−−−−−

Rotate the vectoruu

Example

what is the rotation matrix if one wants the vector T in the left figure to be rotated to the direction of u.

(2, 3)

[ ] TT

If, on the other hand, one wants the vector u to be rotated to the direction of the positive x axis, the rotation matrix should be

Rotation Matrices

Rotation matrix is orthonormal:• Each row is a unit vector

• Each row is perpendicular to the other, i.e. their dot product is zero.

• Each vector will be rotated by R(θ) to lie on the positive x and y axes, respectively. The two column vectors are those into which vectors along the positive x and y axes are rotated.

• For orthonormal matrices, we have

1sincos1)sin(cos

cossinsincos

=+=−+

θθθθ

0)sin(cossincos =−×+× θθθθ

)()(1 θθ TRR =−

Cross Product

• The cross product or vector product of two vectors, v1 and v2, is another vector:

• The cross product of two vectors is orthogonal to both• Right-hand rule dictates direction of cross product.

−−−−

21 )(y x y xz x z x

z y z yvv

v2v1× v2

Extension to 3D Cases

The above examples can be extended to 3D cases….

In 2D, we need to know u, which will be

rotated to the direction of the positive x axis.uv

v=u1×u2

In 3D, however, we need to know more than

one vector. See in the left figure, for example,

two vectors, u1 and u2 are given. If after

rotation, u1 is aligned to the positive z axis, this

will only give us the third column in the rotation

matrix. What about the other two columns?

3D Rotation

In many cases in 3D, only one vector will be aligned to one of the coordinate axes, and the others are often not explicitly given. Let’s see the example:

Note, in this example, vector P1P2 will be

rotated to the positive z direction. Hence the

fist column vector in the rotation matrix is the

normalised P1P2. But what about the other

two columns? After all, P1P3 is not perpendi-

cular to P1P2. Well, we can find it by taking

the cross product of P1P2 and P1P3. Since

P1P2 × P1P3 is perpendicular to both P1P2

and P1P3, it will be aligned into the direction

of the positive x axis.

And the third direction is decide by the cross

product of the other two directions, which is

P1P2 ×(P1P2 ×P1P2 ).

Therefore, the rotation matrix should be

3D Rotation (cont.)

××××

312121

PPPPPPPPPPPP

PPPPPPPP

Yaw, Pitch, and Roll

Imagine three lines running through an airplane and intersecting at right angles at the airplane’s centre of gravity.

Roll: rotation around the

front-to-back axis.

side-to-side axis.

vertical axis.

An Example of the Airplane

Consider the following example. An airplane is oriented such that its nose is pointing in the positive z direction, its right wing is pointing in the positive xdirection, its cockpit is pointing in the positive y direction. We want to transform the airplane so that it heads in the direction given by the vector DOF (direction of flight), is centre at P, and is not banked.

Solution to the Airplane Example

First we are to rotate the positive zp direction into the direction of DOF, which gives us the third column of the rotation matrix: DOF / |DOF|. The xpaxis must be transformed into a horizontal vector perpendicular to DOF –that is in the direction of y×DOF. The yp direction is then given by xp × zp = DOF ×(y × DOF).

××××

=DOFDOF

DOFyDOFDOFyDOF

DOFyDOFyR

Inverses of (2D and) 3D Transformations

1. Translation:

2. Scaling:

3. Rotation:

4. Shear:

),,(),,(1zyxzyx dddTdddT −−−=−

)1,1,1(),,(1

zyxzyx sss

SsssS =−

)()()(1 θθθ TRRR =−=−

),(),(1yxyx shshSHshshSH −−=−

Transformation as a change in coordinate system

Local versus world coordinate system

• Until now, we have defined all points, lines, etc, within the world coordinate system.

• Not ideal to have every object defined inside the world-coordinate system.

• Better (read easier, more re-usable) to have ‘objects’, each with their own ‘local’ coordinate system… which can then be placed into the world coordinate system.

• The idea is analogous to having several pieces of paper…– Each page with an object on it which is being

translated, scaled, rotated.. Before being placed on the world coordinate system

• This requires a change in mentality when drawing our objects.

• Before, we drew an object in the world-coordinate system, scaled it, rotated it, and then transformed it to the required location.

• With a ‘local’ coordinate system, the reverse is the case… • We translate our local coordinate system, then rotate,

then scale, and finally draw our object…• The advantage of this, is that each object (or page) can

in turn be made of several simliar ‘local’ coordinate systems, which can be draw with out regard to the ‘world’ coordinate system…

• Let define the representation of a point in the coordinate system i, and define the representation of a point in the coordinate system j.

• Then let define the transformation the converts the representation of a point in the coordinate system j into its representation in the coordinate system i, such that:

)()( jji

i PMP •= ←

jiM ←

• If for coordinate system k,then:

• so

)()( kkj

j PMP •= ←

)()()()( kki

i PMPMMPMP •=••=•= ←←←←

kjjiki MMM ←←← •=

)2,4(21 TM =← )5.0,5.0()3,2(32 STM •=←

)5.0,5.0()3,2()2,4(31 STTM ••=←

)6,6()2,0()5.0,5.0()3,2()2,4(3311 =•••=•= ← STTPMP

)6,6(1 =P

)2,0(3 =P

• Computer graphics languages / APIs typically use this concept of local coordinate systems…

• Cue processing example…

Viewing in 3D

Projections

• Display device (a screen) is 2D…– How do we map 3D objects to 2D space?

• 2D to 2D is straight forward…– 2D window to world.. and a viewport on the 2D

surface.– Clip what won't be shown in the 2D window, and map

the remainder to the viewport.

• 3D to 2D is more complicated…– Solution : Transform 3D objects on to a 2D plane

using projections

Projections

• In 3D…– View volume in the world– Projection onto the 2D projection plane– A viewport to the view surface

• Process…– 1… clip against the view volume, – 2… project to 2D plane, or window,– 3… map to viewport.

Projections

• Conceptual Model of the 3D viewing process

Projections

• Projections: key terms…– Projection from 3D to 2D is defined by straight projection

rays (projectors) emanating from the 'center of projection', passing through each point of the object, and intersecting the 'projection plane' to form a projection.

Types of projections

• 2 types of projections – perspective and parallel.

• Key factor is the center of projection. – if distance to center of projection is finite : perspective– if infinite : parallel

Perspective v Parallel

• Perspective: – visual effect is similar to human visual system... – has 'perspective foreshortening'

• size of object varies inversely with distance from the center of projection.

– angles only remain intact for faces parallel to projection plane.

• Parallel:– less realistic view because of no foreshortening– however, parallel lines remain parallel. – angles only remain intact for faces parallel to

projection plane.

Perspective Projections

• Any parallel lines not parallel to the projection plane, converge at a vanishing point. – There are an infinite number of these, 1 for each of

the infinite amount of directions line can be oriented.

• If a set of lines are parallel to one of the three principle axes, the vanishing point is called an axis vanishing point. – There are at most 3 such points, corresponding to the

number of axes cut by the projection plane.

• Example: – if z projection plane cuts the z axis: normal to it, so

only z has a principle vanishing point, as x and y are parallel and have none.

• Can categorise perspective projections by the number of principle vanishing points, and the number of axes the projection plane cuts.

• 2 different examples of a one-point perspective projection of a cube.(note: x and y parallel lines do not converge)

• Two-point perspective projection:– This is often used in architectural, engineering

and industrial design drawings. – Three-point is used less frequently as it adds

little extra realism to that offered by two-point perspective projection.

• Two-point perspective projection:

p (x,y,z)

Projection plane

ps(xs,ys)C

By similar triangles:

p(x,y,z)

Projection plane

ps(xs,ys)C

dzx s=+

1/100000000100001

Parallel Projections

• 2 principle types: – orthographic and oblique.

• Orthographic : – direction of projection = normal to the projection

plane.

• Oblique : – direction of projection != normal to the projection

plane.

• Orthographic (or orthogonal) projections: – front elevation, top-elevation and side-elevation. – all have projection plane perpendicular to a principle axes.

• Useful because angle and distance measurements can be made...

• However, As only one face of an object is shown, it can be hard to create a mental image of the object, even when several view are available.

• Orthogonal projections:

• Oblique parallel projections– Objects can be visualised better then with

orthographic projections– Can measure distances, but not angles*

* Can only measure angles for faces of objects parallel to the plane

• 2 common oblique parallel projections: – Cavalier and Cabinet

• Cavalier:– The direction of the projection makes a 45 degree angle

with the projection plane. – Because there is no foreshortening, this causes an

exaggeration of the z axes.

• Cabinet:– The direction of the projection makes a 63.4 degree angle with

the projection plane. This results in foreshortening of the z axis, and provides a more “realistic” view.

Oblique Parallel Projections

• Cavalier, cabinet and orthogonal projections can all be specified in terms of (α, β) or (α, λ) since – tan(β) = 1/λ

P=(0, 0, 1)

λ cos(α)

λ sin(α)

λ=1 β = 45 Cavalier projection α = 0 - 360

λ=0.5 β = 63.4 Cabinet projection α = 0 – 360

λ=0 β = 90 Orthogonal projection α = 0 – 360

(xs,ys)

(0,0,1)P

Consider the point P:

P can be represented in 3D space - (0,0,1)

P can be represented in 2D (screen coords) - (xs,ys)

• At (0,0,1)xs = λ cos αys = λ sin α

• Generally – multiply by z and allow for (non-zero) x and y

xs= x + z.λ.cos αys = y + z.λ.sin α

100000000sin100cos01

αλαλ

Basic Raster Graphics Algorithms for 2D Drawing

• Raster Display:Primitive element: pixel Raster: A rectangular array of points or dotsPixel: One dot or picture element of the rasterScan line: A row of pixels

Great asset: total control of the image Biggest problems: you work at a particular RESOLUTION

Plotting pixels

• In it’s most basic form, each pixel can be set to black or white (i.e. turned on or off), allowing patterns of dots to be created on the screen.

• Classic problem… “staircasing”.

Memory Mapping• Drawing on the computer screen is achieved by

setting the right pixels either on or off. Each pixel on the screen corresponds to an address in the computers memory - this is known as memory mapping and the display is said to be a “memory mapped display.”

Memory Mapping

Cartesian Coordinate System

• In practice, the Cartesian coordinate system is used to define the location of pixels, leaving the computer to convert the coordinates to specific memory locations.

• The modern Cartesian coordinate system in two dimensions (also called a rectangular coordinate system) is defined by two axes, at right angles to each other, forming a plane (an xy-plane). The horizontal axis is labeled x, and the vertical axis is labeled y.

• The coordinates in a three dimensional system are of the form (x,y,z).

Cartesian Coordinate System

p(x, y)

Line Drawing

• A (straight) line can be mathematically defined by its end points. Todescribe a line we need simply to state the coordinates of the two ends.

e.g. - (3, 8),(12, 20)

p(12, 20)

p(3, 8)

Line Drawing

Drawing lines on a raster grid implicitly involves approximation. The general process is called rasterization or scan-conversion.

Optimal Line Drawing

– straight – pass through endpoints – smooth – independent of endpoint

order – uniform brightness – brightness independent of

slope – efficient

What is the best way to draw a line from the pixel (x1,y1) to (x2,y2)? Such a line should ideally have the following properties:

y Line Characterisations

Explicit: y = mx + B Implicit: F(x,y) = ax + by + c = 0

Constant slope:

(xi , yi)

∆∆

(xi , yi)

The simplest strategy is:1) Compute m;2) Increment x by 1 starting

with the leftmost point;3) Calculate yi = mxi + B;4) Intensify the pixel at (xi ,

Round(yi)), where Round(yi) = Floor(0.5+yi)

(xi , Round(yi))

The above brute-force strategy is inefficient, however, becauseeach iteration requires a floating-point (or binary fraction) multiply,Addition, and invocation of Floor. We can eliminate the multiplicationby noting that:

And if ∆x =1, then yi+1 = yi + m. Thus, a unit of change in x changesy by m, which is the slope of the line.

xmyBxxmBmxy iiii ∆+=+∆+=+= ++ )(11

(xi , yi)

(xi , Round(yi))(xi+1 , yi+1)

(xi +1, yi + m)

Simple Incremental Algorithm

An incremental algorithm can be defined: At each step, we make incremental calculations based on the preceding step, starting from one of the endpoints.

Slope Problem

• Note that in order to implement the above algorithm, the slope mhas to be between 0 and 1; then we are able to step along x axis; otherwise, we must reverse the roles of x and y and assigning a unit step to y and incrementing x by ∆x = ∆y/m = 1/m.

m >1, cannot step along x. To handle this, swap x and y.

m <1, can step along x.

Midpoint Line (Bresenham) Algorithm

• What is wrong with the incremental algorithm?– It requires floating-point operations (Round)– The time-consuming floating-point operations are

unnecessary because both endpoints are integers.– Therefore, instead of incrementing y and then rounding it at each

step, we just go to the right, or to the right and up using only integer quantities.

Increment Decision

The problem becomes to decide on which side of the line the midpoint lies?

P = (xp , yp)

Assume the slope of the line, m, is between 0 and 1.Consider the line in the right figure, where the previously selected pixel is P (xp , yp). Now, we must choose between the pixel one increment to the right (called the east pixel, E) or the pixel one increment to the right and one increment up (called the northeast pixel, NE). Let Qbe the intersection point of the line being scan-converted with the grid line x = xp+1. Let M be the midpoint between E and NE. It is easy to see that , if M lies above the line, pixel Eis closer to the line; if M is below the line, pixel NE is closer to the line.

Solution

Let’s consider the explicit form of the line: y = mx + B.We have

F(x,y) = dy• x - dx• y + B• dx = 0.Compare with the implicit form

F(x,y) = ax + by + c = 0We have a=dy, b = -dx, and c =B• dx.

P (x0,y0)

P (x1,y1)

dx=x1 – x0

dy=y1 -y

−−

Given a point (x , y), investigate the sign of F:

+= 0),( yxF

Point below the line

Point on the line

Point above the line

Decision Variable d

Since we’re trying to decide the relationship between M and the line, we need only to compute

and to test its sign.

Define a decision variable d:

)21,1()( ++= pp yxFMF

++++=++=

)21()1()

21,1( cybxayxFd pppp

Choose pixel NEChoose pixel E

Choose pixel E

(xp , yp)

(xp +1, yp)

)21,1( ++ pp yx

(xp+1, yp+1)

How will d be used?

Assume E is chosen, M is incremented by one step in the x direction. Then

ayxFcybaxa

cybxayxFd

oldold

ppppnew

+++=+++++=

++++=++=

)21,1()

21()1(

)21()2()

(xp , yp)M

(xp +1, yp) (xp +2, yp)

)21,2( ++= ppnew yxFd

(xp+1, yp+1)(xp+2, yp+1)

)21,1( ++= ppold yxFd

Incremental updateWe call the increment to add after E is chosen ∆E : ∆E = a = dy. In other words, we can derive the value of the decision variable at the next step incrementally from the value at the current step without having to computing F(M) directly, by merely adding ∆E .On the other hand, if NE is chosen:

Therefore, ∆NE = a + b= dy – dx.Now the initial condition:

Hence, dstart = a +b/2 = dy – dx/2.

dxdydbad

bayxFcbybaxa

cybxayxFd

oldold

ppppnew

−+=++=

++++=++++++=

++++=++=

)21,1()

21()1(

)23()2()

)21()1()

cybxayxF

++++=++

Summary to the midpoint technique

Let’s summarise the incremental midpoint algorithm. At each step, the algorithm chooses between two pixels based on the sign of the decision variable calculated in the previous iteration; then it updates the decision variable by adding either ∆E or ∆NE to the old value, depending on the choice of the pixel. The algorithm starts from the first endpoint, and the first decision variable is given by a+b/2. Using dstart, we choose the second pixel, and so on.

To eliminate the fraction in dstart, we redefine our original F by multiplying it by 2; F(x,y) = 2(ax+by+c). This multiplies each constant the decision variable (and the increments ∆E and ∆NE) by 2 but does not affect the sign of the decision variable, which is all that matters for the midpoint test.

Summary to the midpoint technique (cont.)

Initialisation: dstart = 2 × a +b = 2×dy – dx where dy = y1 – y0 and dx = x1 – x0 .

Incremental update: 1) if E was chosen, ∆E = 2× dy dnew = dold + ∆E

2) if NE was chosen, ∆NE = 2× (dy – dx)dnew = dold + ∆NE

Advantage: The arithmetic needed to evaluate dnew for any step is a simple integer addition. No time-consuming multiplication is involved. Further, the incremental update is quite simple, therefore, it is an efficient algorithm. Note: the given algorithm only works for those line with slope (0, 1).

Lines: Arbitrary Directions

Step through x, increment y

Step through x, decrement y

Step through y, decrement x

Step through y, increment x

Example• Line end points:

(x0 , y0) = (5, 8) (x1 , y1) = (9, 11)

Solution:dx = 4dy = 3dstart=2*dy-dx=2 > 0NE is chosen∆NE = 2*(dy-dx) = -2 <0d = d + ∆NE = 0E is chosen

…4 5 6 7 8 9 10 116

Lines: Some Remarks• Weaker Intensity of Diagonal Lines.

Consider the two scan-converted lines in the left figure. The diagonal line, B, has a slope of 1 and hence is times as long as A, the horizontal line. Yet the same number of pixels (9) is drawn to represent each line. If the intensity of each pixel is I, then the intensity per unit length of line A is I, whereas for line B it is only I/ .

Filling Polygons• Three types of polygons

1. Simple convex 2. simple concave 3. non-simple(self-intersection)

Convex polygons have the property that intersecting lines crossing it either one (crossing a corner), two (crossing an edge, going through the polygon and going out the other edge), or an infinite number of times (if the intersecting line lies on an edge).

Some Problems

1. Which pixels should be filled in? 2. Which happened to the top pixels? To the rightmost pixels?

Some Remarks to the 2nd problem

Why is the 2nd problem such a big deal? What would happen if we fill the top and right most pixels? Because this will cause “double-fill” when two rectangles are adjacent. “Double-filling” brings the following two disadvantages:

1). Inefficient2). If polygons have different colour, then final

colour depends on the order in which the polygons are drawn, and may lead to “flicker”.

General Ideas about Polygon Filling

• Rules for shared edges:– A shared vertical edge belongs to the rightmost of the two

sharing shapes. (Therefore, the right edge of rectangles will not be filled).

– A shared non-vertical edge belongs to the upper shape. (Therefore, the top edge of rectangles will not be filled).

• Fill in polygons by computing intersections of boundaries with scan lines, and filling between pairs of intersections– This is the actual algorithm!

A span is the collection of adjacent pixels on a single scan line which lie inside the primitive.

Coherence literally means to be logically consistent or connected. Spatial coherencemeans that primitives don't change an awful lot if at all from pixel to pixel within a scan line or from scan line to scan line. This allows us to optimise our algorithms.

Edge coherence means that most of the edges that intersect scan line i also intersect scan line i+1.

Illustration of the Ideas

scan lines

spanspan

Filling the Spans

Span-filling is an important step in the whole polygon-filling algorithm, and i is implemented by a three-step process:

1. Find the intersections of the scan line with all edges of the polygon.

2. Sort the intersections by increasing x coordinates.3. Fill in all pixels between pairs of intersections that lie interior to

the polygon.

Now more questions arise:– How do we find and sort the intersections efficiently?– How do we judge whether a pixel lying inside or outside the

polygon?

Parity (Odd-Even) Rule

Begin from a point outside the polygon, increasing the x value, counting the number of edges crossed so far, a pixel is inside the polygon if the number of edges crossed so far (parity) is odd, and outside if the number of edges crossed so far (parity) is even. This is known as the parity, or the odd-even, rule. It works for any kind of polygons.

Parity starting from even

oddodd

Implementation of the Ideas

: intersection points between scan lines and edges (span extrema).

: interior pixels

Implementation of the Ideas (cont.)

Filled pixels using the strictly inside principle.

Q1: Given an intersection with an arbitrary, fractional xvalue, how do we determine which pixel on either side of that intersection is interior?

Four Elaborations to the 2nd Question

A: The strictly

inside rule:

Q2: How do we deal with the special case of intersections at integer pixel coordinates?

A: Use the criterion we used for avoid conflicting between shared edges: if the leftmost pixel in a span has integer x coordinate, we define it to be interior; if the rightmost pixel has integer x coordinate, we define it to be exterior.

Four Elaborations (cont.)

Q3: How do we deal with the special case for shared vertices?

A: We count the ymin vertex of an edge in the parity calculation but not the ymax vertex.

ymin ymin

Q4: How do we deal with the special case in which the vertices define a horizontal edge?

A: Bottom edges are drawn but top edges are not.

Bottom edges are drawn Top edges are not

Example

Let’s apply the rules to scan line 8 below. We fill in the pixels from point a, pixel (2, 8), to the first pixel to the left of point b, pixel (4, 8), and from the first pixel to the right of point c, pixel (9, 8), to one pixel to the left of point d, pixel (12, 8). For scan line 3, vertex A counts once because it is the ymin vertex of edge FA, but the ymax vertex of edge AB; this causes odd parity, so we draw the span from there to one pixel to the left of the intersection with edge CB.

oddoddeven evena b c d

We deal properly with the horizontal edges by not counting their vertices. For the figure in the last slide, consider bottom edge AB. Vertex A is a yminvertex for edge JA, and AB does not contribute. Therefore, the parity is odd and the span AB is drawn. Vertical edge BC has its ymin at B, but again ABdoes not contribute. The parity becomes even, and the span is terminated. At vertex J, edge IJ has a ymin vertex but edge JA does not, so the parity becomes odd and the span is drawn to edge BC. The span that starts at edge IJ and hits C sees no change at C because C is a ymax vertex for BC, so the span continues along bottom edge CD; at D, however, edge DE has a ymin vertex, so the parity is reset to even and the span ends. At I, edge IJhas its ymax vertex and edge HI also does not contribute, so parity stays even and the top edge IH is not drawn. At H, however, edge GH has a yminvertex, the parity becomes odd, and the span is drawn from H to the pixel to the left of the intersection with edge EF. Finally, there is no ymin vertex at G, nor is there one at F, so top edge FG is not drawn.

In order to calculate intersections between scan lines and edges, we must avoid the brute-force technique of testing each polygon edge for intersection with each new scan line – it is inefficient and slow.

Clever Solution: if an edge intersects with a scan line, and the slope of the edge is m, then successive scan line intersections can be found from:

xi+1 = xi + 1/m

where i is the scan line count.

Given that 1/m = (x1 – x0)/(y1 – y0)

the floating-point arithmetic can be avoided by storing the numerator, comparing to the denominator, and incrementing x when it overflows.

Edge Coherence

1/m = 2/5

xmin = 3,

the sequence is:

numerator:

denominator:

Edge Coherence (cont.)

−−

,...514

• Two sub-problems for polygon filling

• Find and sort intersections

• Fill the spans.

AET = active-edge table

store all edges intersected by a scan-line y sorted by xintersection. Each entry in AET contains the ymax coordinate of the edge, the x coordinate of the intersection point, and 1/m.

ET = Global Edge Table

Scan-Line Algorithm

• Catch the intersection information in a table

Edge Table (ET) with all edges sorted by ymin

Active Edge Table (AET) containing

The edges that intersect the current scan line

Their points of intersection

Sorted by x-coordinate, left to right

Catching Edge/Scan line intersections

An Example of the Active Edge Table

11 13 0

AET pointer

CDAs each new scan-line y+1 is encounter, update AET:1). Remove edges not intersected by y+1 (ymax=y)2). Add edges intersected by y+1 (ymin=y+1)3). Calculate new x intersections.Ymax x m

Global edge table (ET): make the addition of edges to the AET efficient. It contains all edges sorted by their smaller y coordinate. The ET is typically built by using a bucket sort with as many buckets as there are scan-lines. Within each bucket, edges are kept in order of increasing x coordinate of the lower endpoint. Each entry in the ET contains the ymaxcoordinate of the edge, the x coordinate of the bottom endpoint (xmin), and 1/m.

An Example for the Global Edge Table

11 13 0 λ CD

9 2 0 λ FA

3 2 -5/2 AB

5 7 6/4 λ BC

9 2 -5/2 EF

11 7 6/4 λ DE

1. Set y to the smallest y coordinate that has an entry in the ET, that is, y for the first nonempty bucket.

2. Initialise the AET to be empty.

3. Repeat until the AET and ET are empty.

3.1 Move from ET bucket y to the AET those edges whose ymin= y (entering edges).

3.2 Remove from the AET those entries for which y=ymax (edges not involved in the next scan line), then sort the AET on x (made easier because ET is pre-sorted).

3.3 Fill in desired pixel values on scan line y by using pairs of x coordinates from the AET.

3.4 Increment y by 1 (to the coordinate of the next scan line).

3.5 For each non-vertical edge remaining in the AET, update x for the new y.

Scan-Line Algorithm (cont.)

Examples:

Solutions:

Line Clipping

• Line clipping against rectangles

The problem: Given a set of 2D lines or polygons and a window, clip the lines or polygons to their regions that are inside the window.

(x1, y1)

xmin xmax

(x0, y0)

Motivations

• Efficiency

• Display in portion of a screen

• Occlusions

Clip rectangle

In: 3 verticesOut: 6 verticesClip

Clip In: 1 polygonOut: 2 polygons

Clipping is tricky!

1. If x0 < xmin and x1 < xmin

or x0 > xmax and x1 > xmax

or y0 < ymin and y1 < ymin

or y0 > ymax and y1 > ymax

trivial rejection.

2. If xmin ≤ x ≤ xmax

and ymin ≤ y ≤ ymax

trivially accepted.

Simple Cases

xmin xmax

• Region and outcodes

The Cohen-Sutherland Line-Clipping Algorithm

First bit: above top edge y > ymaxSecond bit: below bottom edge y < yminThird bit: to right of right edge x > xmaxFourth bit: to left of left edge x < xmin

• Checking for trivial acceptance or rejection using outcodes1). Each endpoint of a line segment is assigned an outcode;

2). If both 4-bit codes are zero, the line can be trivially accepted;

3). A logical and is performed on both outcodes;

4). If the result is nonzero, the line can be trivially rejected.

The C-S Line-Clipping Algorithm (cont.)

Steps for Cohen-Sutherland Algorithm

1. End-points pairs are checked for trivial acceptance or rejection using outcode;

2. If not trivially accepted or rejected, divide the line segment into two at a clip edge;

3. Iteratively clipped by test trivial-acceptance or trivial-rejection, and divided into two segments until completely inside or trivial-rejection.

0101 0100

1000 1010

Polygon Clipping

• Sutherland-Hodgeman algorithm (A divide-and-conquer strategy)

• Polygons can be clipped against each edge of the window one at a time. Edge intersections, if any, are easy to find since the X or Y coordinates are already known.

• Vertices which are kept after clipping against one window edge are saved for clipping against the remaining edges.

• Note that the number of vertices usually changes and will often increases.

Top Clip Boundary

Clipping A Polygon Step by Step

Right Clip Boundary

Bottom Clip Boundary

Left Clip Boundary

Sutherland-Hodgeman Algorithm

Note the difference between this strategy and the Cohen-Sutherland algorithm for clipping a line: the polygon clipper clips against each window edge in succession, whereas the line clipper is a recursive algorithm.

Given a polygon with n vertices, v1, v2,…, vn, the algorithm clips the polygon against a single, infinite clip edge and outputs another series of vertices defining the clipped polygon. In the next pass, the partially clipped polygon is then clipped against the second clip edge, and so on. Let’s considering the polygon edge from vertex vi to vertex vi+1.Assume that start point vi has been dealt with in the previous iteration, four cases will appear.

Sutherland-Hodgeman Algorithm(cont.)

Inside Outside

Clip Boundary

Polygon been clipped

vi+1: output

Case 1

Inside Outside

Polygon been clipped vi

Case 2

i: output

Inside Outside

Polygon been clipped

Case 3

(no output)

Inside Outside

Case 4

vi+1: second output

i: first output

An Example for the Polygon Clipping

Solution:

As we said, the Sutherland-Hodgeman algorithm clip the polygon against one at a time. We start with the right edge of the clip rectangle. In order to clip the polygon against the line, each edge of the polygon have to be considered. Starting with the edge, represented by a pair of vertices, v5v1:

Clipping edge Clipping edge Clipping edge

Solution (cont.):

Now v1v2:

Solution (cont.):

Now v2v3:

v2v2 v3v2 v3

Solution (cont.):

Now v3v4:

v2v2 v3v3

Solution (cont.):

Now v4v5:

v2v2 v3

After these, we have to clip the polygon against the other three edges of the window in a similar way.

Visible surface determination

Problem outline

• Given a set of 3D objects and a viewing specification, we wish to determine which lines or surfaces are visible, so that we do not needlessly calculate and draw surfces, which will not ultimately be seen by the viewer, or which might confuse the viewer.

Simple example…

With all lines drawn, it is not easy to determine the front and back of the box.

Is this the front face of the cube or the rear?

Simple example…

Approaches

• There are 2 fundamental approaches to the problem.

– Object space – Image space

Object space

• Object space algorithms do their work on the objects themselves before they are converted to pixels in the frame buffer. The resolution of the display device is irrelevant here as this calculation is done at the mathematical level of the objects

• Pseudo code…– for each object a in the scene

• determine which parts of object a are visible• draw these parts in the appropriate colour

• Involves comparing the polygons in object a to other polygons in a and to polygons in every other object in the scene.

Image space

• Image space algorithms do their work as the objects are being converted to pixels in the frame buffer. The resolution of the display device is important here as this is done on a pixel by pixel basis.

• Pseudo code…– for each pixel in the frame buffer

• determine which polygon is closest to the viewer at that pixel location

• colour the pixel with the colour of that polygon at that location

Algorithms

• Object space – Back-face culling

• Image space– z-buffer algorithm

• Hybrid– Depth-sort

Back-face culling

• Back-face culling (an object space algorithm) works on 'solid' objects which you are looking at from the outside. That is, the polygons of the surface of the object completely enclose the object.

Back-face culling

• Which way does a surface point?

• Vector mathematics defines the concept of a surface’s normal vector.

• A surface’s normal vector is simply an arrow that is perpendicular tothat surface.

• Every planar polygon has a surface normal, that is, a vector that is normal to the surface of the polygon.

– Actually every planar polygon has two normals.

• Given that this polygon is part of a 'solid' object we are interested in the normal that points OUT, rather than the normal that points in.

Back-face culling

• Consider the 2 faces of a cube and their normal vectors.

• Vectors N1 and N2 are the normals to surfaces 1 and 2 respectively.

• Vector L points from surface 1 to the viewpoint.

• Depending on the angle between L, and N1 & N2, they may or may not be visible to the viewer.

surface1surface2

Back-face culling

• If we define θ to be the angle between L and N.

• Then a surface is visible from the position given by Lif:

• Can calculate Cos θ using the formula:

°≤≤ 900 θ 1cos0 ≤≤ θor

θcos... NLNL =

Back-face culling

• Determining N:• Can use cross product to calculate N

• N = A × B– NB. Vertices are given a counterclockwise order when

looking at visible side.

Back-face culling

• Limitations:– It can only be used on solid

objects…• Remove the top or front face of the

cube, and suddenly we can see inside, and our algorithm falls over.

– It works fine for convex polyhedra but not necessarily for concave polyhedra.

• example of a partially hidden face, that will not be eliminated by Back-face removal.

Z-buffer algorithm

• The z-buffer or depth-buffer is one of the simplest visible-surface algorithms.

• Z-buffering is an image-space algorithm, an involves the use of a (surprisingly) z-buffer, to store the depth, or z-value of each pixel.

• All of the elements of the z-buffer are initially set to be 'very far away.' Whenever a pixel colour is to be changed the depth of this new colour is compared to the current depth in the z-buffer. If this colour is 'closer' than the previous colour the pixel is given the new colour, and the z-buffer entry for that pixel is updated as well. Otherwise the pixel retains the old colour, and the z-buffer retains its old value.

Z-buffer algorithm

• Pseudo code…for each polygon for each pixel p in the polygon's projection

pz = polygon's normalized z-value at (x, y);

//z ranges from -1 to 0

if (pz > zBuffer[x, y]) // closer to the camera { zBuffer[x, y] = pz;

framebuffer[x, y] = colour of pixel p;

Depth-sort algorithm

• a.k.a. The Painter's Algorithm• The idea here is to go back to front drawing all the

objects into the frame buffer with nearer objects being drawn over top of objects that are further away.

• Simple algorithm:– Sort all polygons based on their farthest z coordinate – Resolve ambiguities – draw the polygons in order from back to front

• This algorithm would be very simple if the z coordinates of the polygons were guaranteed never to overlap. Unfortunately that is usually not the case, which means that step 2 can be somewhat complex.

• First must determine z-extent for each polygon

z-extent

• Ambiguities arise when the z-extents of twosurfaces overlap.

surface 1

surface 2

• Any polygons whose z extents overlap must be tested against each other.

• We start with the furthest polygon and call it P. Polygon P must be compared with every polygon Q whose z extent overlaps P's z extent. 5 comparisons are made. If any comparison is true then P can be written before Q. If at least one comparison is true for each of the Qs then P is drawn and the next polygon from the back is chosen as the new P.

1. do P and Q's x-extents not overlap. 2. do P and Q's y-extents not overlap. 3. is P entirely on the opposite side of Q's plane from the viewport. 4. is Q entirely on the same side of P's plane as the viewport. 5. do the projections of P and Q onto the (x,y) plane not overlap.

• If all 5 tests fail we quickly check to see if switching P and Q will work. Tests 1, 2, and 5 do not differentiate between P and Q but 3 and 4 do. So we rewrite 3 and 4

3’. is Q entirely on the opposite side of P's plane from the viewport.4’. is P entirely on the same side of Q's plane as the viewport.

Qif they do, test fails

x - extents not overlap?

Qif they do, test fails

y - extents not overlap?

is P entirely on the opposite side of Q's plane from the viewport.

Test is true…

is Q entirely on the same side of P's plane asthe viewport.

QTest is true…

do the projections of P and Q onto the (x,y) plane not overlap.

hole in P

Test is true…

• If all tests fail…

– … then reverse P and Q in the list of surfacessorted by Zmax

– set a flag to say that the test has beenperformed once.

– If the tests fail a second time, then it isnecessary to split the surfaces and repeat thealgorithm on the 4 surfaces

• End up drawing Q2,P1,P2,Q1

Surface Modelling

Many real-world objects are inherently smooth, therefore need infinitely many points to model it. This is not feasible for a computer with finite storage. More often we merely approximate the object with pieces of planes, spheres, or other shapes that are easy to describe mathematically. We will introduce two most common representations for 3D surfaces: polygon mesh surfaces and parametric surfaces. We will also discuss parametric curves since parametric surfaces are a generalisation of the curves.

Modelling the Elegant Teapot

Polygon Meshes

VERTEX TABLEV1: x1, y1, z1

V2: x2, y2, z2

V3: x3, y3, z3

V4: x4, y4, z4

V5: x5, y5, z5

EDGE TABLEE1: V1, V2

E2: V2, V3

E3: V3, V1

E4: V3, V4

E5: V4, V5

E6: V5, V1

POLYGON TABLEP1: V1, V2 , V3

P2: V1 , V3 , V4 , V5

POLYGON TABLEP1: E1, E2 , E3

P2: E3 , E4 , E5 , E6

• The geometry can be stored as three tables: a vertex table, an edge table, and a polygon table. Each entry in the vertex table is a list of coordinates defining that point. Each entry in the edge table consists of a pointer to each endpoint of that edge. And the entries in the polygon table define a polygon by providing pointers to the edges that make up the polygon.

• We can eliminate the edge table by letting the polygon table reference the vertices directly, but we can run into problems, such as drawing some edges twice, because we don't realise that we have visited the same set of points before, in a different polygon. We could go even further and eliminate the vertex table by listing all the coordinates explicitly in the polygon table, but this wastes space because the same points appear in the polygon table several times.

Polygon Meshes

Representing Polygon Meshes

1). The explicit way: just list 3D vertices of each polygon in a certain order. The problems are, firstly it represents same vertex many times and secondly, no explicit representation of shared edges and vertices

2). Pointer to a vertex list: store all vertices once into a numbered list, and represent each polygon by its vertices. It saves space (vertex only listed once) but still has no explicit representation of shared edges and vertices

3). Explicit edges: list all edges that belong to a polygon, and for each edge list the vertices that define it along with the polygons of which it is a member.

)),,(),...,,,(),,,(( 222111 nnn zyxzyxzyxP =

)5,4,3,1(=P

),,( 121 PVVE =

Types of Curves

1). Explicit: In the Cartesian plane, an explicit equation of a planar curve is given by y = f(x). The difficulties with this approach are that (1) it is impossible to get multiple values of y for a single x, so curves such as circles and ellipses must be represented by multiple curve segments; and (2) describing curves with vertical tangents is difficult and numerically unstable.

2). Implicit:f(x, y) = 0 Ax+By+C =0This method has difficulties on determining tangent continuity of two given curves which is crucial in many applications.(Circle can be defined as: x2+y2=1, but what about a half circle?)

Types of Curves

3). Parametric Curves:The cubic polynomials that defines a curve segment Q(t)= [x(t) y(t)]T are of the form

Written in matrix form, it becomes

Q(t)= [x(t) y(t)] = T⋅ C

dtctbtatydtctbtatx

+++=23

C [ ]123 tttT =

Parametric Curves

The equations that describe a parametric curve depend on a variable t that is not explicitly part of the geometry.

By sweeping through t, in our case 0 ≤ t ≤ 1, it is possible to evaluate the equations and determine the x and y values for points on the curve.

t = 0.0

t = 1.0

Parameter space Object space

Continuity

The derivative of Q(t) is the parametric tangent vector of the curve. Applying the definition to the curve’s equation, we have

Often we will want to represent a curve as a series of curves pieced together. But if we will want these curves to fit together reasonably ...continuity!

[ ]yyyxxx ctbtactbta

CttCTdtd

dtdxtQtQ

⋅=⋅=

]0123[

Continuity

Two curve segments join together: G0

geometric continuity.

The directions of the tangent vectors (not necessarily the magnitudes) are equal: G1

geometric continuity.

Both the directions and magnitudes are equal: C1

parametric continuity.

Second-order parametric continuity: C2 parametric continuity.

Note: For two curves to join smoothly, we require only that their tangent-vector directions match; we do not require that their magnitudes match.

Parametric Cubic Curves

To join multiple curves into one curve smoothly, we need to specify the positions and their tangent-vectors of both ends, i.e. the continuity requirements. This gives us four constraints, and so the four knowns can be used to solve the four unknowns, i.e. coefficients, in a cubic polynomial.

p2∇p1

Specifying Curves

• Interpolating splinecurve passes through the control points knots (Cardinal spline, Catmull-Rom spline)

• Control Pointscontrol points that lie on the curve

• Knotsa set of points that influence the curve's shape

• Approximating splinecontrol points merely influence shape (Hermite Curves, B-spline)

Examples of Cubic Curves

• Hermite• Defined by two end points + two endpoint tangent vectors.

• Bézier• Defined by two endpoints + two other points that control the

endpoints tangent vectors.

Hermite Curves

Depending on which four knowns we have, parametric curves can be divided into different groups. The simplest of the cubic curves, the Hermite form, is defined by two endpoints and the tangent vectors at these endpoints.

Hermite Curves

(x1,y1)

(x2,y2)∇p1

∇p2t=1

Hermite Curves (cont.)

(x1,y1)

(x2,y2)∇p1

∇p2t=1

ytyyyyt

xtxxxxt

ddtctbtatyddtctbtatx

|)(|)(

dcbatydcbatx

+++=+++=

|)(|)(

ytyyyt

xtxxxt

cctbtadtdy

cctbtadtdx

|)23(|)(

Hermite Curves (cont.)

ddccbbaa

0123010011111000

−−−

ddccbbaa

Hermite

000101001233

Geometry VectorBasis Matrix

Bézier Curves

P1(x1,y1,z1)P4(x4,y4,z4)

P2(x2,y2,z2)

P3(x3,y3,z3)

A cubic Bézier curve indirectly specifies the endpoint tangent-vector by specifying two intermediate points that are not on the curve.

BezierHB

Hermite

yxyxyxyx

−−

3300003310000001

)3()()( 344121 =−=∇−=∇ kPPkPPPkP

Bézier Curves (cont.)

−−

−−−

3300003310000001

000101001233

ddccbbaa

Hermite

Bézier Curves (cont.)

−−

0001003303631331

yxyxyxyx

ddccbbaa

BezierM

A Bézier Curve

For example, if we are given four control points (0,0), (0.2,0.8), (0.9, 0.1), (1,1). Then we have

And the parametric equation will be

At any point on this curve, the tangent vector to the curve is

−−

004.26.05.45.1

1.31.1

111.09.08.02.0

0001003303631331

ddccbbaa

ttttyttttx

4.25.41.3)(6.05.11.1)(

+−+=

++−=

00|])(,)([|)(' tttt dt

tdxtQ == =

Parametric Bicubic Surfaces

The equations that describe a parametric curve depend on a variable t that is not explicitly part of the geometry.

By sweeping through t, in our case 0 ≤ t ≤ 1, it is possible to evaluate the equations and determine the x and y values for points on the curve.

tgytfx

t = 0.0

t = 1.0

Parameter space Object space

Parametric Bicubic Surfaces

Parametric Bicubic Surfaces are a generalisation of parametric cubic curves

1010)]()()([)( ≤≤≤≤= vuu, v, zu, v, yu, vx u, vP• If one parameter, say v, is held at a constant value then the above willrepresent a curve.

• The surface is then generated by sweeping all points on the boundary curveP(u,0) (say) through cubic trajectories, defined using the parameter v, to theboundary curve P(u,1).

v=0u=0

The representation of the bicubic surface patch can be illustrated by considering the Bézier Surface Patch. The edge P(0,v) of a Bezier patch is defined by giving four control points P00, P01, P02 and P03. Similarly the opposite edge P(1,v) can be represented by a Bezier curve with four control points. The surface patch is generated by sweeping the curve P(0,v) through a cubic trajectory in the parameter u to P(1,v). To define this trajectory we need four control points, hence the Bezier surface patch requires a mesh of 4×4 control points as illustrated below.

Bézier Surface Patch

Komputer Grafik

Documents

Transcript of Komputer Grafik

TUGAS PRAKTIKUM KOMPUTER GRAFIK

Komputer grafik

komputer grafik farah.docx

Grafik Komputer : PENDAHULUAN - ftp.gunadarma.ac.idftp.gunadarma.ac.id/handouts/S1-Sistem Komputer/Grafik komputer da… · Grafik Komputer dan Pengolahan Citra Revolusi Lingkungan

Pengantar Grafik Komputer

Laporan Pratikum Komputer Grafik

Grafik Komputer : PENDAHULUANnuraini.staff.gunadarma.ac.id/Downloads/files/35308/2+Grafik+Komp-Pendahuluan.pdf · Grafik Komputer : Pendahuluan 6/19 Grafik Komputer dan Pengolahan

PENDAHULUAN Grafik Komputer dan Pengolahan Citraopenstorage.gunadarma.ac.id/handouts/S1-Sistem Komputer/Grafik...Grafik Komputer dan Pengolahan Citra Bidang Ilmu yang Berkaitan dengan

materi komputer grafik

KOMPUTER GRAFIK SALSABILA

Grafik Komputer & Pengolahan Citra

Komputer Grafik Informatika

Grafik Komputer : PENDAHULUANopenstorage.gunadarma.ac.id/handouts/S1-Sistem Komputer... · 2009. 2. 9. · Grafik Komputer : Pendahuluan 2/19 Grafik Komputer dan Pengolahan Citra

modul grafik komputer

GRAFIK KOMPUTER MODUL 1

Grafik Komputer

Grafik Komputer : KONSEP DASARasmaya.staff.gunadarma.ac.id/Downloads/files/50537/3... · Grafik Komputer : Konsep Dasar 9/14 Grafik Komputer dan Pengolahan Citra Elemen-elemen Pembentuk

Laporan Praktikum Komputer Grafik

Menggambar LINGKARAN (1/) - Gunadarmaftp.gunadarma.ac.id/handouts/S1-Sistem Komputer/Grafik...Grafik Komputer : Geometri Primitive 2/11 Grafik Komputer dan Pengolahan Citra Menggambar

Project Komputer Grafik