TCS2111

COMPUTER GRAPHICS

LECTURE 4
2D GRAPHICS ALGORITHMS 1
Note for the students:
 These slides are meant for the lecturers to
conduct lectures only. It is NOT suitable to
be used as a study material.
 Students are expected to study by reading
the textbook for this course:

Interactive Computer Graphics – A Top

Down Approach Using OPENGL (5th
Edition) by Edward Angel

 The textbook is available from MMU

Bookstore.
 Reading Assignments are given at the end
of these slides.
2
Content: 2D Graphics Algorithms
 Output Primitives
 Line Drawing Algorithms
 Analytical Method
 DDA Algorithm
 Midpoint Algorithm
 Bresenham's Algorithm
 Circle Drawing Algorithms (Extra note for
self-study!)
 Midpoint Circle Algorithm
 Anti-aliasing
 Fill-Area Algorithms
3
Output Primitives

4
Output Primitives
 The basic objects out of which a
graphics display is created are
called.
 Describes the geometry of objects
and – typically referred to as
geometric primitives.
 Examples: point, line, text, filled
region, images, quadric surfaces,
spline curves
 Each of the output primitives has its
own set of attributes.

5
Output Primitives
 Points
 Attributes: Size, Color.

v1 v2
glPointSize(p);
v3
glBegin(GL_POINTS);
glVertex2d(x1, y1);
glVertex2d(x2, y2);
glVertex2d(x3, y3);
glEnd()

6
Output Primitives
 Lines
 Attributes: Color, Thickness, Type

v1
v4 glLineWidth(p);
glBegin(GL_LINES);
v2 v3 glVertex2d(x1, y1);
glVertex2d(x2, y2);
glVertex2d(x3, y3);
glVertex2d(x4, y4);
glEnd()

7
Output Primitives
 Polylines (open)
 A set of line segments joined end to end.
 Attributes: Color, Thickness, Type

v1
v3
glLineWidth(p);
glBegin(GL_LINE_STRIP);
glVertex2d(x1, y1);
v2 v4
glVertex2d(x2, y2);
glVertex2d(x3, y3);
glVertex2d(x4, y4);
glEnd()

8
 Output Primitives
 Polylines (closed)
 A polyline with the last point connected to the
first point .
 Attributes: Color, Thickness, Type
v1
v3 Note: A closed polyline cannot be filled.
glBegin(GL_LINE_LOOP);
v2 v4 glVertex2d(x1, y1);
glVertex2d(x2, y2);
glVertex2d(x3, y3);
glVertex2d(x4, y4);
glEnd()
9
Output Primitives
 Polygons
 A set of line segments joined end to end.
 Attributes: Fill color, Thickness, Fill pattern
Note: Polygons can be filled
v4

v1 v3 glBegin(GL_POLYGON);
glVertex2d(x1, y1);
v2
glVertex2d(x2, y2);
glVertex2d(x3, y3);
glVertex2d(x4, y4);
glEnd()

10
Output Primitives
 Text
 Attributes: Font, Color, Size,
Spacing, Orientation.
 Font:
 Type (Helvetica, Times, Courier etc.)
 Size (10 pt, 14 pt etc.)
 Style (Bold, Italic, Underlined)

11
Output Primitives
 Images
 Attributes: Image Size, Image
Type, Color Depth.
 Image Type:
 Binary (only two levels)
 Monochrome
 Color.
 Color Depth:
Number of bits used to represent
color.
12
TCS2111
Output Primitives (Summary)
Output Primitive Attributes
Point Size
Color
Line Thickness (1pt, 2pt …)
Type (Dashed, Dotted, Solid)
Color
Text Font (Arial, Courier, Times Roman…)
Size (12pt, 16pt ..)
Spacing
Orientation (Slant angle)
Style (Bold, Underlined, Double lined)
Color
Filled Region Fill Pattern
Fill Type (Solid Fill, Gradient Fill)
Fill Color
Images Color Depth (Number of bits/pixel) 13
Line Drawing Algorithms

14
 Line Drawing
• Line drawing is fundamental to computer graphics.
• We must have fast and efficient line drawing functions.

Rasterization Problem: Given only the two end points,

how to compute the intermediate pixels, so that the set
of pixels closely approximate the ideal line.

15
Line Drawing - Analytical Method
by  a y
m
y bx  ax
c  a y  max B(bx,by)

y=mx+c

A(ax,ay)

ax bx x
16
Line Drawing - Analytical Method
//Given (ax, ay) and (bx, by)
double m = (double)(by-ay)/(bx-ax);
double c = ay - m*ax;
double y;
int iy;
for (int x=ax; x<=bx; x++) {
y = m*x + c;
iy = round(y);
setPixel(x, iy);
}
• Directly based on the analytical equation of a line.
• Involves floating point multiplication and addition
• Requires round-off function.
17
 Incremental Algorithms
I have got a pixel on the line (Current Pixel).
How do I get the next pixel on the line?

Compute one point based on the previous point:

(x0, y0)…….…………..(xk, yk) (xk+1, yk+1) …….

Next pixel on next column Next pixel on next row

18
(when slope is small) (when slope is large)
 Incrementing along x

Current (6,3)
Pixel To find (xk+1, yk+!):
(xk, yk) (5,2) (6,2)
xk+1 = xk+1
(6,1)
yk+1 = ?

• Assumes that the next pixel to be set is on the next

column of pixels (Incrementing the value of x !)
• Not valid if slope of the line is large
19
 Line Drawing - DDA
Digital Differential Analyzer Algorithm is an incremental
algorithm.

Assumption: Slope is less than 1 (Increment along x).

Current Pixel = (xk, yk).
(xk, yk) lies on the given line. yk = m.xk + c
Next pixel is on next column. xk+1 = xk+1
Next point (xk+1, yk+1) on the line yk+1 = m.xk+1 + c
= m (xk+1) +c
= yk + m
Given a point (xk, yk) on a line, the next point is given by
xk+1 = xk+1
yk+1 = yk + m 20
Line Drawing - DDA
double m = (double) (by-ay)/(bx-ax);
double y = ay;
int iy;
for (int x=ax; x<=bx; x++) {
iy = round(y);
setPixel(x, iy);
y += m;
}
• Does not involve any floating point multiplication
• Involves floating point addition.
• Requires round-off function

21
 Midpoint Algorithm
Midpoint algorithm is an incremental algorithm

Assumption:
Slope < 1

Current
Pixel

xk+1 = xk+1
yk+1 = Either yk or yk+1 22
 Midpoint Algorithm - Notations
Line
(xk+1, yk+1)
Candidate Pixels

Midpoint

Current Pixel
(xk, yk)
(xk+1, yk)

Coordinates of Midpoint = (xk+1, yk+½)

23
 Midpoint Algorithm:
Choice of the next pixel

Midpoint Below Line Midpoint Above Line

• If the midpoint is below the line,

then the next pixel is (xk+1, yk+1)
• If the midpoint is above the line,
then the next pixel is (xk+1, yk)
24
 Equation of a line revisited
y  ay x  ax
Equation of the line: 
by  a y bx  ax

Let w = bx  ax, and h = by  ay

B(bx, by)
Then, h (x  ax)  w (y  ay) = 0
(h, w , ax , ay are all integers)

In other words, every point (x, y) on the line

satisfies the equation F(x, y) =0, where A(ax, ay)

F(x, y) = h (x  ax)  w (y  ay)

25
 Midpoint Algorithm:
Regions below and above the line

F(x,y) < 0 F(x,y) = 0

(for any point above
line)

F (x,y) > 0
(for any point below line)

26
 Midpoint Algorithm:
Decision Criteria

f ( x, y )  0 F(MP) < 0

F(MP) > 0

Midpoint below line Midpoint above line

27
 Midpoint Algorithm
Decision Criteria
Decision Parameter

F(MP) = F(xk+1, yk+ ½) = Fk (Notation)

If Fk < 0 : The midpoint is above the line. So the

next pixel is (xk+1, yk)

If Fk  0 : The midpoint is below or on the line. So

the next pixel is (xk+1, yk+1)
28
 Midpoint Algorithm – Story so far

Midpoint Below Line Midpoint Above Line

Fk > 0 Fk < 0
yk+1 = yk+1 yk+1 = yk
Next pixel = (xk+1, yk+1) Next pixel = (xk+1, yk)
29
 Midpoint Algorithm:
Update Equation
Fk = F(xk+1, yk+ ½) = h (xk+1  ax)  w (yk+½  ay)
1

Fk+1 = F(xk+1+1, yk+1+ ½) = h (xk+1+1  ax)  w (yk+1+½  ay)

2

2 1 Fk+1 - Fk = h (xk+1  xk)  w (yk+1  yk)

Fk+1 - Fk = h (xk +1  xk)  w (yk+1  yk)
Fk+1 = Fk + h  w (yk+1  yk)
Thus, given Fk< 0, yk+1 = yk then Fk+1 = Fk + h

given Fk  0, yk+1 = yk+1 then Fk+1 = Fk + h  w

F0 = h (ax +1  ax)  w (ay +½  ay) = h  w/2 30

 Midpoint Algorithm:
Update Equation

Update Equation
Summary:
Fk+1 = Fk + h  w (yk+1  yk)

given Fk< 0, yk+1 = yk then Fk+1 = Fk + h

given Fk  0, yk+1 = yk+1 then Fk+1 = Fk + h  w

F0 = h  w/2
31
 Midpoint Algorithm
int h = by-ay;
int w = bx-ax;
float F = h-w/2;
int y = ay;
for (int x=ax; x<=bx; x++) {
setPixel(x, y);

if(F < 0)
F += h;
else {
F += h-w;
y++;
}
} 32
 Bresenham’s Algorithm
(Improved Midpoint Algorithm)
int h = by-ay;
int w = bx-ax;
int F = 2*h-w;
int y = ay;
for (int x=ax; x<=bx; x++) {
setPixel(x, y);

if(F < 0)
F += 2*h;
else {
F += 2*(h-w);
y++;
}
} 33
Circle Drawing
Algorithms
(Extra notes for self-study!)

34
Midpoint Circle Drawing Algorithm
 To determine the closest pixel position to
the specified circle path at each step.
 For given radius r and screen center
position (xc, yc), calculate pixel positions
around a circle path centered at the
coodinate origin (0,0).
 Then, move each calculated position (x, y)
to its proper screen position by adding xc to
x and yc to y.
 Along the circle section from x=0 to x=y in
the first quadrant, the gradient varies from
0 to -1.
35
TCS2111

Midpoint Circle Drawing Algorithm

 8 segments of octants for a circle:

36
TCS2111

Midpoint Circle Drawing Algorithm

 Circle function: fcircle (x,y) = x2 + y2 –r2

{
> 0, (x,y) outside the circle

fcircle (x,y) = < 0, (x,y) inside the circle

= 0, (x,y) is on the circle

boundary

37
TCS2111

Midpoint Circle Drawing Algorithm

yk yk
midpoint midpoint

yk-1 yk-1

Fk < 0 Fk >= 0
yk+1 = yk yk+1 = yk - 1
Next pixel = (xk+1, yk) Next pixel = (xk+1, yk-1)

38
TCS2111

Midpoint Circle Drawing Algorithm

We know xk+1 = xk+1,
Fk = F(xk+1, yk- ½)
Fk = (xk +1)2 + (yk - ½)2 - r2 -------- (1)
Fk+1 = F(xk+1+1, yk+1 - ½)
Fk+1 = (xk +2)2 + (yk+1 - ½)2 - r2 -------- (2)
(2) – (1)
Fk+1 = Fk + 2(xk+1) + (y2k+1 – y2k) - (yk+1 – yk) + 1

If Fk < 0, Fk+1 = Fk + 2xk+1+1

If Fk >= 0, Fk+1 = Fk + 2xk+1+1 – 2yk+1
39
TCS2111

Midpoint Circle Drawing Algorithm

For the initial point, (x0 , y0) = (0, r)

f0 = fcircle (1, r-½ )

= 1 + (r-½ )2 – r2
= 5–r
4
≈ 1–r

40
TCS2111

Midpoint Circle Drawing Algorithm

Example:
Given a circle radius = 10, determine the circle octant in
the first octant from x=0 to x=y.

Solution:
f0 = 5 – r
4
= 5 – 10
4
= -8.75
≈ –9
41
TCS2111

Midpoint Circle Drawing Algorithm

Initial (x0, y0) = (1,10)
Decision parameters are: 2x0 = 2, 2y0 = 20
k Fk x y 2xk+1 2yk+1
0 -9 1 10 2 20
1 -9+2+1=-6 2 10 4 20
2 -6+4+1=-1 3 10 6 20
3 -1+6+1=6 4 9 8 18
4 6+8+1-18=-3 5 9 10 18
5 -3+10+1=8 6 8 12 16
6 8+12+1-16=5 7 7 14 14

42
TCS2111

Midpoint Circle Drawing Algorithm

void circleMidpoint(int xCenter, int yCenter, int
radius)
{
int x = 0;
Int y = radius;
int f = 1 – radius;

circlePlotPoints(xCenter, yCenter, x, y);

while (x < y) {
x++;
if (f < 0)
f += 2*x + 1;
else {
y--;
f += 2*(x-y)+1;
}
circlePlotPoints(xCenter, yCenter, x, y);
43
}
TCS2111

Midpoint Circle Drawing Algorithm

void circlePlotPoints( int xCenter, int yCenter,
int x, int y)
{
setPixel (xCenter + x, yCenter + y);
setPixel (xCenter – x, yCenter + y);
setPixel (xCenter + x, yCenter – y);
setPixel (xCenter – x, yCenter – y);
setPixel (xCenter + y, yCenter + x);
setPixel (xCenter – y, yCenter + x);
setPixel (xCenter + y, yCenter – x);
setPixel (xCenter – y, yCenter – x);
}

44
Anti-aliasing

45
 Anti-aliasing
Anti-aliasing is a technique used to
diminish the jagged edges of an image or a
line, so that the line appears to be smoother;
by changing the pixels around the edges to
intermediate colors or gray scales.
E.g. Anti-aliasing disabled:

E.g. Anti-aliasing enabled:

46
 Anti-aliasing (OpenGL)

Anti-aliasing disabled Anti-aliasing enabled

Setting anti-aliasing option for lines:

glEnable (GL_LINE_SMOOTH);
47
Fill Area Algorithms

48
Fill Area Algorithms
 Fill-Area algorithms are used to fill the
interior of a polygonal shape.
 Many algorithms perform fill operations
by first identifying the interior points,
given the polygon boundary.

49
Basic Filling Algorithm
The basic filling algorithm is commonly used
in interactive graphics packages, where the
user specifies an interior point of the region to
be filled.

4-connected pixels

50
 Basic Filling Algorithm
[1] Set the user specified point.
[2] Store the four neighboring pixels in
a stack.
[3] Remove a pixel from the stack.
[4] If the pixel is not set,
- Set the pixel
- Push its four neighboring pixels
into the stack
[5] Go to step 3
[6] Repeat till the stack is empty.

51
Basic Filling Algorithm (Code)

void fill(int x, int y) {

if(getPixel(x,y)==0){
setPixel(x,y);
fill(x+1,y);
fill(x-1,y);
fill(x,y+1);
fill(x,y-1);
}
}

52
Basic Filling Algorithm: Conditions
 Requires an interior point.
 Involves considerable amount of
stack operations.
 The boundary has to be closed.
 Not suitable for self-intersecting
polygons

53
Types of Basic Filling Algorithms
 Boundary Fill Algorithm
 For filling a region with a single
boundary color.
 Condition for setting pixels:
 Color is not the same as border color
 Color is not the same as fill color

 Flood Fill Algorithm

 For filling a region with multiple
boundary colors.
 Condition for setting pixels:
 Color is same as the old interior color
54
TCS2111

Boundary Fill Algorithm (Code)

void boundaryFill(int x, int y,
int fillColor, int borderColor)
{
getPixel(x, y, color);
if ((color != borderColor)
&& (color != fillColor)) {
setPixel(x,y);
boundaryFill(x+1,y,fillColor,borderColor);
boundaryFill(x-1,y,fillColor,borderColor);
boundaryFill(x,y+1,fillColor,borderColor);
boundaryFill(x,y-1,fillColor,borderColor);
}
}
55
TCS2111

Flood Fill Algorithm (Code)

void floodFill(int x, int y,
int fillColor, int oldColor)
{
getPixel(x, y, color);
if (color == oldColor)
{
setPixel(x,y);
floodFill(x+1, y, fillColor, oldColor);
floodFill(x-1, y, fillColor, oldColor);
floodFill(x, y+1, fillColor, oldColor);
floodFill(x, y-1, fillColor, oldColor);
}
}
56
 Filling Polygons (OpenGL)

Enabling polygon fill (Default):

glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

Disabling polygon fill:

glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

57
Reading Assignment
 Edward Angel, Interactive Computer
Graphics (5th Edition):
 Chapter 7: 7.8 – 7.10
(From Vertices to Fragments)

58
Further Readings
 Hearn and Baker, Computer Graphics with
OpenGL (3rd Edition):
 Chapter 3: 3.1–3.5, 3.9, 3.14-3.17
 (Graphics Output Primitives)
 Chapter 4: 4.1-4.9, 4.13-4.14, 4.17-4.18
(Attributes of Graphics Primitives)

59