Graphics Output Primitives

1
COMPUTER GRAPHICS

• Graphics Output Primitives
• Hearn Baker Chapter 3

Some slides are taken from Robert Thomsons notes.
2
OVERVIEW

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

3
Basic Elements

• Three basic elements
• Scalars
• Vectors
• Points
• Develop mathematical operations among them
• Define basic primitives
• Points
• Line segments

4
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.

5
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 coordinate extents are
  sometimes called its bounding rectangle.

6
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.

7
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.

8
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.

9
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)

10
3-5 LINE-DRAWING ALGORITHMS

• A straight-line segment in a scene is defined by
  the coordinate positions for the endpoints of the
  segment.
• 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.
• Then the line color is loaded into the frame
  buffer at the corresponding pixel coordinates.
• 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.

11
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.

12
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

13
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

14
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

15
Line-Drawing Algorithms DDA Bresenhams
Midpoint Algorithm
16

• 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

y1
y0
x0
x1
17
Simple Line
Based on slope-intercept algorithm from algebra
y mx b Simple approach
increment x, solve for y Floating point
arithmetic required
18
Does it Work?
It works for lines with a slope of 1 or
less, but doesnt 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.
19
Modify algorithm per octant
OR, increment along x-axis if dyltdx else
increment along y-axis
20
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.

21
Line with positive slope

• If mlt1,
• Sample at unit x intervals (dx1)
• Compute successive y values as
• yk1ykm 0ltkltxend-x0
• Increment k by 1 for each step
• Round y to nearest integer value.
• If mgt1,
• Sample at unit y intervals (dy1)
• Compute successive x values as
• xk1xk1/m 0ltkltyend-y0
• Increment k by 1 for each step
• Round x to nearest integer value.

22
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)
gt 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 lt
steps k) x xIncrement
y yIncrement setPixel (round (x),
round (y))
23
DDA algorithm

• Need a lot of floating point arithmetic.
• 2 rounds and 2 adds per pixel.
• Is there a simpler way ?
• Can we use only integer arithmetic ?
• Easier to implement in hardware.

24
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

25
Bresenham's line algorithm

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

Specified line path
13
12
11
10
10
11
12
13
26
Illustrating Bresenhams Approach

• For the pixel position xk1xk1, which one we
  should choose
• (xk1,yk) or (xk1, yk1)

yk3
yk2
ymxb
yk1
yk
xk
xk1
xk2
xk3
27
Bresenhams Approach

• ym(xk 1)b
• dlowery-yk
• m(xk 1)b-yk
• dupper(yk1)-y
• yk1 -m(xk 1)-b

• dlower- dupper 2m(xk 1)2yk2b-1
• Rearrange it to have integer calculations
• m?y/?x
• Decision parameter pk ?x(dlower- dupper)2?y.xk
  - 2?x. yk c

28
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
  ?xgt0.
• 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 dlowerlt dupper then pk is negative.
• Plot the lower pixel (East)
• Otherwise
• Plot the upper pixel (North East)

29
Succesive decision parameter

• At step k1
• pk1 2?y.xk1 - 2?x. yk1 c
• Subtracting two subsequent decision parameters
  yields
• pk1-pk 2?y.(xk1-xk) - 2?x. (yk1-yk)
• xk1xk1 so
• pk1 pk 2?y - 2?x. (yk1-yk)
• yk1-yk is either 0 or 1 depending on the sign of
  pk
• First parameter p0
• p02 ?y - ?x

30
Bresenham's Line-Drawing Algorithm for I m I lt 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
• p02 ?y - ?x
• 4. At each xk along the line, starting at k 0,
  perform the following test
• If pk lt 0, the next point to plot is (xk1, yk)
  and
• pk1pk 2?y
• Otherwise, the next point to plot is (xk1,
  yk1) and
• pk1pk 2?y - 2?x
• 5. Repeat step 4 ?x -1 times.

31
Trivial Situations Do not need Bresenham
32
Example

• Draw the line with endpoints (20,10) and (30,
  18).
• ?x30-2010, ?y18-108,
• p0 2?y ?x16-106
• 2?y16, and 2?y - 2?x-4
• Plot the initial position at (20,10), then

33
(No Transcript)
34
Example

• Line end points
• Deltas

initially
35
Graph
13 12 11 10 9 8 7 6
4 5 6 7 8 9 10 11
36
Continue the process...
13 12 11 10 9 8 7 6
4 5 6 7 8 9 10 11
37
Graph
13 12 11 10 9 8 7 6
4 5 6 7 8 9 10 11
38
Graph
13 12 11 10 9 8 7 6
4 5 6 7 8 9 10 11
39
Graph
13 12 11 10 9 8 7 6
4 5 6 7 8 9 10 11
40
/ Bresenham line-drawing procedure for m lt
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 gt xEnd) x xEnd y yEnd
xEnd x0 else x
x0 y y0 setPixel (x, y)
while (x lt xEnd) x if
(p lt 0) p twoDy else
y p twoDyMinusDx
setPixel (x, y)
41
Line-drawing algorithm should work in every
octant, and special cases
mgt1
mlt-1
0gtmgt-1
0ltmlt1
0ltmlt1
0gtmgt-1
mgt1
mlt-1
42
Simulating the Bresenham algorithm in drawing 8
radii on a circle of radius 20 Horizontal,
vertical and ?45? radii handled as special cases
43
Scan Converting Circles

• Explicit y f(x)

We could draw a quarter circle by incrementing x
from 0 to R in unit steps and solving for y for
each step.
Method needs lots of computation, and gives
non-uniform pixel spacing
44
Scan Converting Circles

• Parametric

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

45
Scan Converting Circles

• Implicit f(x,y) x2y2-R2

If f(x,y) 0 then it is on the circle. f(x,y)
gt 0 then it is outside the circle. f(x,y) lt 0
then it is inside the circle.
Try to adapt the Bresenham midpoint approach
Again, exploit symmetries
46
(No Transcript)
47
Generalising the Bresenham midpoint approach

• Set up decision parameters for finding the
  closest pixel to the circumference 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

48
Eight-way Symmetry- only one octants
calculation needed
49
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) gt 0 ? (x,y) Outside
• F(x,y) lt 0 ? (x,y) Inside

50
Choose E or SE

• Decision variable d is x 2 y 2 r 2
• Then d F(M) ? 0 ? SE
• Or d F(M) lt 0 ? E

51
F (M) ? 0 ? SE
current pixel
ideal curve
52
F (M) lt 0 ? E
ideal curve
53
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

54
Midpoint coordinates are
55
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 lt0 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
56
If pk gt0 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.
57
recursive definition for successive decision
parameter values p
Where yk1 yk if plt0 (move E)
yk1 yk-1 if pgt0 (move SE) yk1 and xk1 can
also be defined recursively
58
Initialisation x0 0, y0 r Initial decision
variable found by evaluating circle function at
first midpoint test position
For integer radius r p0 can be rounded to p0
1-r since all increments are integer.
59
(No Transcript)
60
Midpoint Circle Algorithm (cont.)
61
Example

• r10

62

• Another method Approximate it using a polyline.

63
Fill area an area that is filled with solid
colour or pattern
64
(No Transcript)
65
Identifying a concave polygon

• has at least one interior angle gt180 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

66
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

67
Normals

• Every plane has a vector n normal (perpendicular,
  orthogonal) to it
• n u x v (vector cross product)

v
u
P
68
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

69
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

70
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.

71
E5
E4
E6
E2
E3
E1
72
E5
E6
E1
E2
E4
E3
73
(No Transcript)
74
Inside-Outside? nonzero winding-number rule
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

75
Winding Number

• Count clockwise encirclements of point
• Alternate definition of inside inside if winding
  number ? 0

winding number 1
winding number 2
76
Polygon tables

• store descriptions of polygon geometry and
  topology, and surface parameters colour,
  transparency, light-reflection
• organise in 2 groups
• geometric data
• attribute data

77
Polygon Tables Geometric data

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

78
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

79
(No Transcript)
80
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