Graphics Output Primitives Hearn & Baker Chapter 3 Some slides are taken from Robert Thomson’s...

Graphics Output PrimitivesHearn & Baker Chapter 3

Some slides are taken from Robert Thomson’s notes.

OVERVIEW

• Coordinate reference frames• Line drawing algorithms• Curve drawing algorithms• Fill-area primitives• Pixel-array primitives• Character primitives• Picture Partitioning

Basic Elements

Three basic elements– Scalars– Vectors– Points

• Develop mathematical operations among them• Define basic primitives:

– Points– Line segments

Basic Elements

• Points are associated with locations in space• Vectors have magnitude and direction

– represent displacements between points, or directions• Points, vectors, and operators that combine them are the

common tools for solving many geometric problems that arise in – Geometric Modeling, – Computer Graphics, – Animation, – Visualization, and – Computational Geometry.

3.1 COORDINATE REFERENCE FRAMES

To describe a picture, we first decide upon

• A convenient Cartesian coordinate system, called the world-coordinate reference frame, which could be either 2D or 3D.

• We then describe the objects in our picture by giving their geometric specifications in terms of positions in world coordinates. – e.g., we define a straight-line segment with two endpoint positions,

and a polygon is specified with a set of positions for its vertices. – These coordinate positions are stored in the scene description along

with other info about the objects, such as their color and their coordinate extents

• coordinate extents are the minimum and maximum x, y, and z values for each object.

• A set of coordinate extents is also described as a bounding box for an object.

– For a 2D figure, the co ordinate extents are sometimes called its bounding rectangle.

3.1 COORDINATE REFERENCE FRAMES

• Objects are then displayed by passing the scene description to the viewing routines

• which identify visible surfaces and map the objects to the frame buffer positions and then on the video monitor.

• The scan-conversion algorithm stores info about the scene, such as color values, at the appropriate locations in the frame buffer, and then the scene is displayed on the output device.

• locations on a video monitor • are referenced in integer screen coordinates, which

correspond to the integer pixel positions in the frame buffer.

3.1 COORDINATE REFERENCE FRAMES

• Scan-line algorithms for the graphics primitives use the coordinate descriptions to determine the locations of pixels– E.g., given the endpoint coordinates for a line segment, a display

algorithm must calculate the positions for those pixels that lie along the line path between the endpoints.

• Since a pixel position occupies a finite area of the screen – the finite size of a pixel must be taken into account by the

implementation algorithms. – for the present, we assume that each integer screen position

references the centre of a pixel area.

3.1 COORDINATE REFERENCE FRAMES

• Once pixel positions have been identified the color values must be stored in the frame buffer

• Assume we have available a low-level procedure of the form

setPixel (x, y); stores the current color setting into the frame buffer at integer position

(x, y), relative to the position of the screen-coordinate origin

getPixel (x, y, color); retrieves the current frame-buffer setting for a pixel location;• parameter color receives an integer value corresponding to the

combined RGB bit codes stored for the specified pixel at position (x,y).

• additional screen-coordinate information is needed for 3D scenes. For a two-dimensional scene, all depth values are 0.

3.1 Absolute and Relative Coordinate Specifications

• So far, the coordinate references discussed are given as absolute coordinate values – values are actual positions wrt origin of current

coordinate system

• some graphics packages also allow positions to be specified using relative coordinates– as an offset from the last position that was

referenced (called the current position)

3-5 LINE-DRAWING ALGORITHMS

A straight-line segment in a scene is defined by the coordinate positions for the endpoints of the segment.

1. To display the line on a raster monitor, the graphics system must

– first project the endpoints to integer screen coordinates and – determine the nearest pixel positions along the line path

between the two endpoints.

2. Then the line color is loaded into the frame buffer at the corresponding pixel coordinates.

3. Reading from the frame buffer, the video controller plots the screen pixels.

– This process digitizes the line into a set of discrete integer positions that, in general, only approximates the actual line path.

3-5 LINE-DRAWING ALGORITHMS

• On raster systems, lines are plotted with pixels, and step sizes in the horizontal and vertical directions are constrained by pixel separations.

• That is, we must "sample" a line at discrete positions and determine the nearest pixel to the line at sampled position. – Sampling is measuring the values of the function at equal

intervals

• Idea: A line is sampled at unit intervals in one coordinate and the corresponding integer values nearest the line path are determined for the other coordinate.

Towards the Ideal Line• We can only do a discrete approximation

• Illuminate pixels as close to the true path as possible, consider bi-level display only– Pixels are either lit or not lit

• In the raster line alg., – we sample at unit intervals and – determine the closest pixel position to the specified

line path at each step

What is an ideal line

• Must appear straight and continuous– Only possible with axis-aligned and 45o lines

• Must interpolate both defining end points• Must have uniform density and intensity

– Consistent within a line and over all lines– What about anti-aliasing ?

• Aliasing is the jagged edges on curves and diagonal lines in a bitmap image.

• Anti-aliasing is the process of smoothing out those jaggies. – Graphics software programs have options for anti-aliasing text and

graphics. – Enlarging a bitmap image accentuates the effect of aliasing.

• Must be efficient, drawn quickly– Lots of them are required

Simple Line

The Cartesian slope-intercept equation for a straight line is :

y = mx + b

with m as the slope of the line and b as the y intercept.

Simple approach:

• increment x, solve for y

Line-Drawing Algorithms:

DDA

Bresenham’s Midpoint Algorithm

Algorithms for displaying lines are based on the Cartesian slope-intercept equation

y = m.x + b

where m and b can be calculated from the line endpoints:m = (y1-y0) / (x1-x0)

b = y0 - m. x0

For any x interval x along a line the corresponding y interval y = m.x

y0

y1

x0 x1

Simple Line

Based on slope-intercept algorithm from algebra:

y = mx + b

Simple approach:

increment x, solve for y

Floating point arithmetic required

Does it Work?

It works for lines with a slope of 1 or less,

but doesn’t work well for lines with slope greater than 1 – lines become more discontinuous in appearance and we must add more than 1 pixel per column to make it work.

Solution? - use symmetry.

Modify algorithm per octant

OR, increment along x-axis if dy<dx else increment along y-axis

DDA Algorithm

• The digital differential analyser (DDA) is a scan-conversion line algorithm based on using x or y.

• A line is sampled at unit intervals in one coordinate and the corresponding integer values nearest the line path are determined for the other coordinate.

Line with positive slope

• If m<=1, – Sample at unit x intervals (dx=1)– Compute successive y values as

• yk+1=yk+m 0<=k<=xend-x0

• Increment k by 1 for each step

• Round y to nearest integer value.

• If m>1,– Sample at unit y intervals (dy=1)– Compute successive x values as

• xk+1=xk+1/m 0<=k<=yend-y0

• Increment k by 1 for each step

• Round x to nearest integer value.

inline int round (const float a) { return int (a + 0.5); }

void lineDDA (int x0, int y0, int xEnd, int yEnd) { int dx = xEnd - x0, dy = yEnd - y0, steps, k; float xIncrement, yIncrement, x = x0, y = y0;

if (fabs (dx) > fabs (dy)) steps = fabs (dx); else steps = fabs (dy); xIncrement = float (dx) / float (steps); yIncrement = float (dy) / float (steps);

setPixel (round (x), round (y)); for (k = 0; k < steps; k++) { x += xIncrement; y += yIncrement; setPixel (round (x), round (y)); } }

DDA algorithm

• Need a lot of floating point arithmetic.– 2 ‘round’s and 2 adds per pixel.

• Is there a simpler way ?• Can we use only integer arithmetic ?

– Easier to implement in hardware.

Bresenham's line algorithm

• Accurate and efficient

• Uses only incremental integer calculations

The method is described for a line segment with a positive slope less than one

The method generalizes to line segments of other slopes by considering the symmetry between the various octants and quadrants of the xy plane

Bresenham's line algorithm

• Decide what is the next pixel position– (11,11) or

(11,12)

Specified

line path

10 11 12 13

10

11

12

13

Illustrating Bresenham’s Approach

• For the pixel position xk+1=xk+1, which one we should choose:

• (xk+1,yk) or (xk+1, yk+1)y=mx+b

yk

yk+1

yk+2

yk+3

xk xk+1 xk+2 xk+3

Bresenham’s Approach

• y=m(xk + 1)+b

• dlower=y-yk

=m(xk + 1)+b-yk

• dupper=(yk+1)-y

= yk+1 -m(xk + 1)-b

y

yk+1

xk+1

yk

dupper

dlower

• dlower- dupper= 2m(xk + 1)+2yk+2b-1

• Rearrange it to have integer calculations:

m=Δy/Δx

Decision parameter: pk= Δx(dlower- dupper)=2Δy.xk - 2Δx. yk + c

The Decision Parameter

Decision parameter: pk= Δx(dlower- dupper)=2Δy.xk - 2Δx. yk + c

• pk has the same sign with dlower- dupper since Δx>0.

• c is constant and has the value c= 2Δy + Δx(2b-1)– c is independent of the pixel positions and is eliminated from

decision parameter pk.

• If dlower< dupper then pk is negative.

– Plot the lower pixel (East)

• Otherwise– Plot the upper pixel (North East)

Succesive decision parameter

• At step k+1pk+1= 2Δy.xk+1 - 2Δx. yk+1 + c

• Subtracting two subsequent decision parameters yields:

pk+1-pk= 2Δy.(xk+1-xk) - 2Δx. (yk+1-yk)

• xk+1=xk+1 so

pk+1= pk + 2Δy - 2Δx. (yk+1-yk)

– yk+1-yk is either 0 or 1 depending on the sign of pk

• First parameter p0

– p0=2 Δy - Δx

Bresenham's Line-Drawing Algorithm for I m I < 1

1. Input the twoline endpoints and store the left endpoint in (x0 ,y0).

2. Load (x0 ,y0) into the frame buffer; that is, plot the first point.

3. Calculate constants Δx, Δy, 2Δy, and 2Δy - 2Δx, and obtain the starting value for the decision parameter as

p0=2 Δy - Δx

4. At each xk along the line, starting at k = 0, perform the following test:

If pk < 0, the next point to plot is (xk+1, yk) and

pk+1=pk + 2Δy

Otherwise, the next point to plot is (xk+1, yk+1) and

pk+1=pk + 2Δy - 2Δx

5. Repeat step 4 Δx -1 times.

Trivial Situations: Do not need Bresenham

line horizontal0 m

xym line1

line vertical m

Example

• Draw the line with endpoints (20,10) and (30, 18).– Δx=30-20=10, Δy=18-10=8,

– p0 = 2Δy – Δx=16-10=6

– 2Δy=16, and 2Δy - 2Δx=-4• Plot the initial position at (20,10), then

Example

• Line end points:

• Deltas:

)11,9(),;)8,5(), 1100 (( yxyx

3;4 dydx

NEp

dx-dy ,p

2

0246

)()(2)85(initially

Graph

13

12

11

10

9

8

7

64 5 6 7 8 9 10 11

Continue the process...

13

12

11

10

9

8

7

64 5 6 7 8 9 10 11

Graph

13

12

11

10

9

8

7

64 5 6 7 8 9 10 11

Graph

13

12

11

10

9

8

7

64 5 6 7 8 9 10 11

Graph

13

12

11

10

9

8

7

64 5 6 7 8 9 10 11

/* Bresenham line-drawing procedure for |m| < 1.0. */ void lineBres (int x0, int y0, int xEnd, int yEnd) { int dx = fabs (xEnd - x0), dy = fabs(yEnd - y0); int x, y, p = 2 * dy - dx; int twoDy = 2 * dy, twoDyMinusDx = 2 * (dy - dx);

/* Determine which endpoint to use as start position. */ if (x0 > xEnd) { x = xEnd; y = yEnd; xEnd = x0; } else { x = x0; y = y0; } setPixel (x, y);

while (x < xEnd) { x++; if (p < 0) p += twoDy; else { y++; p += twoDyMinusDx; } setPixel (x, y); } }

0<m<1

0>m>-1

m>1

m>1

0<m<1

0>m>-1

m<-1

m<-1

Line-drawing algorithm should work in every octant, and special cases

Simulating the Bresenham algorithm in drawing 8 radii on a circle of radius 20

Horizontal, vertical and 45 radii handled as special cases

• Explicit: y = f(x)

Scan Converting Circles

2 2y R x We could draw a quarter circle by incrementing x from 0 to R in unit steps and solving for +y for each step.

22

222

)(

)()(

cc

cc

xxRyy

Ryyxx

Method needs lots of computation, and gives non-uniform pixel spacing

Scan Converting Circles

• Parametric:cos

sin

x R

y R

Draw quarter circle by stepping through the angle from 0 to 90-avoids large gaps but still unsatisfactory-How to set angular incrementComputationally expensive trigonometric calculations

Scan Converting Circles

• Implicit: f(x,y) = x2+y2-R2

If f(x,y) = 0 then it is on the circle. f(x,y) > 0 then it is outside the circle. f(x,y) < 0 then it is inside the circle.

Try to adapt the Bresenham midpoint approach

Again, exploit symmetries

Generalising the Bresenham midpoint approach

• Set up decision parameters for finding the closest pixel to the cırcumference at each sampling step– Avoid square root calculations by considering the

squares of the pixel separation distances

• Use direct comparison without squaring.

Adapt the midpoint test idea: test the halfway position between pixels to determine if this midpoint is inside or outside the curve

This gives the midpoint algorithm for circles

Can be adapted to other curves: conic sections

Eight-way Symmetry- only one octant’s calculation needed

The 2nd Octant is a good arc to draw

• It is a well-defined function in this domain– single-valued

– no vertical tangents: |slope| 1• Lends itself to the midpoint approach

– only need consider E or SE

• Implicit formulation F(x,y) = x

2 + y

2 – r

2 – For (x,y) on the circle, F(x,y) = 0– F(x,y) > 0 (x,y) Outside

– F(x,y) < 0 (x,y) Inside

Choose E or SE

• Decision variable d is x 2 + y 2 – r 2 • Then d = F(M) 0 SE• Or d = F(M) < 0 E

E

SE

Mideal curve

F (M) 0 SE

current pixel

E

SE

Mideal curve

F (M) < 0 E

Decision Variable p

As in the Bresenham line algorithm we use a decision variable to direct the selection of pixels.

Use the implicit form of the circle equation

p = F (M ) = x

2 + y

2 – r

2

Midpoint coordinates are )21,1( kk yx

222 )21()1(

)21,1(

ryx

yxFp

kk

kkcirck

Assuming we have just plotted point at (xk,yk) we determine whether move E or SE by evaluating the circle function at the midpoint between the two candidate pixel positions

pk is the decision variable

if pk <0 the midpoint is inside the circle

Thus the pixel above the midpoint is closer to the ideal circle, and we select pixel on scan line yk. i.e. Go E

If pk >0 the midpoint is outside the circle.Thus the pixel below the midpoint is closer to the ideal circle, and we select pixel on scan line yk-1. i.e. Go SE

Calculate successive decision parameter values p by incremental calculations.

221

2

111

)21(]1)1[(

)21,1(

ryx

yxFp

kk

kkcirck

recursive definition for successive decision parameter values p

1)()()1(2

)21(]1)1[(

)21,1(

122

11

221

2

111

kkkkkkk

kk

kkcirck

yyyyxpp

ryx

yxFp

Where yk+1 = yk if p<0 (move E)

yk+1 = yk-1 if p>0 (move SE)

yk+1 and xk+1 can also be defined recursively

Initialisation

x0 = 0, y0 = r

Initial decision variable found by evaluating circle function at first midpoint test position

r

rr

rFp circ

4

5

)21(1

)21,1(

22

0

For integer radius r p0 can be rounded to p0 =1-rsince all increments are integer.

Midpoint Circle Algorithm (cont.)

Example

• r=10

Another method: Approximate it using a polyline.

Fill area : an area that is filled with solid colour or pattern

Identifying a concave polygon

• has at least one interior angle >180 degrees• extensions of some edges will intersect other

edges

One test:

Express each polygon edge as a vector, with a consistent orientation.

Can then calculate cross-products of adjacent edges

Identifying a concave polygon

• When polygon edges are oriented with an anti-clockwise sense– cross product at convex vertex has positive sign– concave vertex gives negative sign

Normals

• Every plane has a vector n normal (perpendicular, orthogonal) to it

• n = u x v (vector cross product)

u

v

P

xyyx

zxxz

yzzy

vuvu

vuvu

vuvu

vu

Vector method for splitting concave polygons

• E1=(1,0,0) E2=(1,1,0)• E3=(1,-1,0) E4=(0,3,0)• E5=(-3,0,0) E6=(0,-3,0)

• All z components have 0 value.

• Cross product of two vectors EjxEk is perpendicular to them with z component

EjxEky-EkxEjy

E1

E2 E3

E4

E5

E6

0 1 2 3

1

2

3

Example continued

• E1xE2= (0,0,1) E2xE3= (0,0,-2) E3xE4= … E4xE5= …

• E5xE6= … E6xE1= …

• Since E2xE3 has negative sign, split the polygon along the line of vector E2

E1

E2 E3

E4

E5

E6

0 1 2 3

1

2

3

Rotational method

• Rotate the polygon so that each vertex in turn is at coordinate origin.

• If following vertex is below the x axis, polygon is concave.

• Split the polygon by x axis.

E1

E2 E3

E4

E5

E6

E1

E2

E3

E4

E5

E6

A winding number is an attribute of a point with respect to a polygon that tells us how many times the polygon encloses (or wraps around) the point. It is an integer, greater than or equal to 0. Regions of winding number 0 (unenclosed) are obviously outside the polygon, and regions of winding number 1 (simply enclosed) are obviously inside the polygon.

Initially 0+1: edge crossing the line from right to left -1: left to right

Inside-Outside? nonzero winding-number rule

Winding Number

• Count clockwise encirclements of point

• Alternate definition of inside: inside if winding number 0

winding number = 2

winding number = 1

Polygon tables

• store descriptions of polygon geometry and topology, and surface parameters: colour, transparency, light-reflection

• organise in 2 groups– geometric data– attribute data

Polygon Tables:

Geometric data

•Data can be used for consistency checking•Additional geometric data stored: slopes, bounding boxes

Shared Edges

• Vertex lists will draw filled polygons correctly but if we draw the polygon by its edges, shared edges are drawn twice

• Can store mesh by edge list

Inward and Outward Facing Polygons

• The order {v1, v6, v7} and {v6, v7, v1} are equivalent in that the same polygon will be rendered by OpenGL but the order {v1, v7, v6} is different

• The first two describe outwardly

facing polygons

• Use the right-hand rule =

counter-clockwise encirclement

of outward-pointing normal

• OpenGL can treat inward and

outward facing polygons differently