line drawing algorithms COMPUTER GRAPHICS & Graphical Programming

Bridge kloud
Line Drawing Algorithms
Lesson 3
1Bridgekloud: https://www.bridgekloud.com Unit: Computer Graphics ICS2311

ArchitectureOfAGraphicsSystem
 [remember this?]
System Bus
CPU
Display
Processor
System
Memory
Display
Processor
Memory
Frame
Buffer
Video
Controller
MonitorMonitor

BasicDefinitions
 A line drawing algorithm is a graphical
algorithm for approximating a line segment
on discrete graphical media.
 On discrete media, such as pixel-based
displays and printers, line drawing requires
such an approximation (in nontrivial cases).
Bridgekloud: https://www.bridgekloud.com Unit: Computer Graphics ICS2311 3

 2D Raster Scan Conversion
 'Scan conversion' is a general term for
drawing methods which create (or 'digitise')
raster images according to given picture
'primitives'.
 The term is mainly used for drawing methods
for 2D picture elements or primitives such as
lines, polygons and text.
 All three of these are used in Java and C++
programs we shall be considering.

 Most (straight) lines and curves drawn in
computer graphics satisfy equating a function of
x and y with zero.
 For example, we can re-express the line equation
y=mx+c as 0=mx+c−y.
 Most line and curve drawing methods effectively
hunt along a pixel at a time, steering left or right
as needed to find a trail of pixels to be drawn, by
calculating which next pixel will keep the
relevant function closest to zero.

TheProblemOfScanConversion
 A line segment in a scene is defined by the
coordinate positions of the line end-points
x
y
(2, 2)
(7, 5)

TheProblem(cont…)
 But what happens when we try to draw this on a
pixel based display?
How do we choose which pixels to turn on?

Considerations
 Considerations to keep in mind:
 The line has to look good
 Avoid jaggies
 It has to be lightening fast!
 How many lines need to be drawn in a typical scene?
 This is going to come back to bite us again and again

Aliasing
 Simply choosing some pixels to draw often
results in the familiar 'jaggies'.
 This is a form of aliasing.
 Aliasing in computing generally is
substitution of something (e.g. some pixels)
for something else (e.g. an ideal area to
draw).
 In computer graphics, aliasing denotes
distortion or noise in images due to
approximation.

Aliasing….
 Three main forms of aliasing:
 Outline aliasing
 Motion aliasing
 Color aliasing

Outlinealiasing:
 Outline aliasing refers to the
unintended jagged appearance of
lines, curves or area boundaries.
 This can be overcome using 'anti-
aliasing' methods
 These provide smoothness at the cost
of slight blurring, by altering pixel
colors in proportion to how well they
match the ideal area to be drawn.
 Scan-conversion using such methods
is relatively slow.

Motionaliasing:
 The use of integers in scan-conversion methods is
usually taken to the logical extreme of eliminating
any use of floating point numbers, thus using only
integer pixel coordinates as parameters of the
method.
 This often results in motion aliasing,
 This is most noticeable when using 2D scan
conversion in 3D rendering.
 A different kind of motion aliasing can come from
irregularity in the timing of repainting of successive
frames.

Coloraliasing:
 Color aliasing is due to
color approximation in
pseudo-color displays.
 This creates distinct color
bands where there
should be smoothly
graduated color.
 Moreover these color
bands tend to look darker
near lighter bands and
vice versa, giving a
misleading impression of
color.

LineDrawingalgorithms:
 The screen of a computer is a rectangular grid
of evenly aligned pixels.
 The computer produces images on raster
devices only by turning the approximate
pixels ON or OFF.
 To draw a line on the screen, we first need to
determine which pixels are to be switched
ON.

 The process of determining which
combination of pixels provide the best
approximation to the desired line is called
rasterization.
 When rasterization is combined with
rendering of a picture in a scan-line order,
then it is known as scan-conversion.

 The choice of the pixels is determined by the
orientation of the line which is to be drawn:
 There is little difficulty for straight line.
 For other orientation of lines, selection of pixel is a
difficult process.

 There are four general requirements for line
drawing:
 Lines must appear to be straight
 Lines should start and end accurately
 Lines should have constant brightness along their
length
 Lines should be drawn rapidly.

 For straight lines, the equation of a straight
line is used to determine the pixels:
 y = mx + c
 Where:
 M = (y2 – y1)/(x2-x1)

 Several algorithms:
 A naïve line-drawing algorithm
 Digital Differential Analyzer (graphics algorithm) —
Similar to the naive line-drawing algorithm, with minor
variations.
 Bresenham's line algorithm — optimized to use only
additions (i.e. no divisions or multiplications); it also avoids
floating-point computations.
 The general breesenham’s algorithm
 The bresenham’s circle generation algorithm.
 Xiaolin Wu's line algorithm — can perform spatial anti-
aliasing
 The algorithms are discussed in class

LineEquations
 Let’s quickly review the equations involved in
drawing lines
x
y
y0
yend
xendx0
Slope-intercept line
equation:
bxmy 
where:
0
0
xx
yy
m
end
end



00 xmyb 

Lines&Slopes
 The slope of a line (m) is defined by its start and
end coordinates
 The diagram below shows some examples of
lines and their slopes
m = 0
m = -1/3
m = -1/2
m = -1
m = -2
m = -4
m = ∞
m = 1/3
m = 1/2
m = 1
m = 2
m = 4
m = 0 21Bridgekloud: https://www.bridgekloud.com Unit: Computer Graphics ICS2311

AVerySimpleSolution
 We could simply work out the corresponding
y coordinate for each unit x coordinate
 Let’s consider the following example:
x
y
(2, 2)
(7, 5)
2 7
2
5

AVerySimpleSolution(cont…)
1
2
3
4
5
0
1 2 3 4 5 60 7 23Bridgekloud: https://www.bridgekloud.com Unit: Computer Graphics ICS2311

x
y
(2, 2)
(7, 5)
2 3 4 5 6 7
2
5
5
3
27
25



m
5
4
2
5
3
2 b
 First work out m and b:
Now for each x value work out the y value:
5
3
2
5
4
3
5
3
)3( y
5
1
3
5
4
4
5
3
)4( y
5
4
3
5
4
5
5
3
)5( y
5
2
4
5
4
6
5
3
)6( y

 Now just round off the results and turn on
these pixels to draw our line
3
5
3
2)3( y
3
5
1
3)4( y
4
5
4
3)5( y
4
5
2
4)6( y
0 1 2 3 4 5 6 7 8
0
1
2
3
4
5
6
7

 However, this approach is just way too slow
 In particular look out for:
 The equation y = mx + b requires the
multiplication of m by x
 Rounding off the resulting y coordinates
 We need a faster solution

AQuickNoteAboutSlopes
 In the previous example we chose to solve the
parametric line equation to give us the y
coordinate for each unit x coordinate
 What if we had done it the other way around?
 So this gives us:
 where: and
m
by
x


0
0
xx
yy
m
end
end


 00 xmyb 

AQuickNoteAboutSlopes(cont…)
 Leaving out the details this gives us:
 We can see easily that
this line doesn’t look
very good!
 We choose which way
to work out the line
pixels based on the
slope of the line
0 1 2 3 4 5 6 7 8
0
1
2
3
4
5
6
7
4
3
2
3)3( x 5
3
1
5)4( x

 If the slope of a line is between -1 and 1 then we
work out the y coordinates for a line based on it’s
unit x coordinates
 Otherwise we do the opposite – x coordinates are
computed based on unit y coordinates
m = 0
m = -1/3
m = -1/2
m = -1
m = -2
m = -4
m = ∞
m = 1/3
m = 1/2
m = 1
m = 2
m = 4
m = 0 29Bridgekloud: https://www.bridgekloud.com Unit: Computer Graphics ICS2311

1
2
3
4
5
0

TheDDAAlgorithm
 The digital differential
analyzer (DDA) algorithm
takes an incremental
approach in order to speed
up scan conversion
 Simply calculate yk+1
based on yk
The original differential analyzer
was a physical machine
developed by Vannevar Bush at
MIT in the 1930’s in order to
solve ordinary differential
e q u a t i o n s .
Mor e in fo r mation h e re .

TheDDAAlgorithm(cont…)
 Consider the list of points that we determined
for the line in our previous example:
 (2, 2), (3, 23/5), (4, 31/5), (5, 34/5), (6, 42/5), (7, 5)
 Notice that as the x coordinates go up by one,
the y coordinates simply go up by the slope of
the line
 This is the key insight in the DDA algorithm

 When the slope of the line is between -1 and 1
begin at the first point in the line and, by
incrementing the x coordinate by 1, calculate the
corresponding y coordinates as follows:
 When the slope is outside these limits, increment
the y coordinate by 1 and calculate the
corresponding x coordinates as follows:
myy kk 1
m
xx kk
1
1 

 Again the values calculated by the equations
used by the DDA algorithm must be rounded to
match pixel values
(xk, yk)
(xk+1, yk+m)
(xk, round(yk))
(xk+1, round(yk+m))
(xk, yk) (xk+ 1/m, yk+1)
(round(xk), yk)
(round(xk+ 1/m), yk+1)

DDAAlgorithmExample
 Let’s try out the following examples:
x
y
(2, 2)
(7, 5)
2 7
2
5
x
y (2, 7)
(3, 2)
2 3
2
7

DDAAlgorithmExample(cont…)
7
2
3
4
5
6

TheDDAAlgorithmSummary
 The DDA algorithm is much faster than our
previous attempt
 In particular, there are no longer any
multiplications involved
 However, there are still two big issues:
 Accumulation of round-off errors can make the
pixelated line drift away from what was intended
 The rounding operations and floating point
arithmetic involved are time consuming

Bresenham’salgorithm
 Chooses the corresponding integer Y that is
closest to the ideal (fractional) Y for the same
X; on successive columns Y can remain the
same or increase by 1:
 Which is……..
01
0
01
0
xx
xx
yy
yy






Bresenhampseudo code
Function line(X0, X1, Y0,Y1)
Int deltax:= X1-X0
Int deltay:=Y1-Y0
Real error:=0
Real deltaerr:=abs(deltay/deltax)//assume deltax !=0(line isnt vertical)
//note this division needs to be done in a way that preserves the fractional
part
Int Y:=0
For X from 0 to X1
Plot(X,Y)
Error:=error+deltaerr
If error>=0.5 then Y:=Y+1
Error:=error-1.0

 Bresenham's algorithm draws lines extremely
quickly, but it does not perform anti-aliasing. In
addition, it cannot handle any cases where the
line endpoints do not lie exactly on integer
points of the pixel grid.
 A naive approach to anti-aliasing the line would
take an extremely long time.
 This algorithm performs relatively slow on
fraction numbers like error and delta err
moreover errors can occur over many floating
point additions

 Working with integers will be faster and more
accurate.
 The trick is to multiply all fractional numbers
by deltax, which enables us to express them
as integers.

XiaolinWu'slinealgorithm
 Xiaolin Wu's line algorithm is an algorithm
for line antialiasing,
 presented in the article An Efficient
AntialiasingTechnique in the July 1991 issue of
Computer Graphics, as well as in the article
Fast Antialiasing in the June 1992 issue of Dr.
Dobb's Journal.
 Wu's algorithm is comparatively fast, but is
still slower than Bresenham's algorithm.

XiaolinWu'slinealgorithmcont…
 The algorithm consists of drawing pairs of
pixels straddling the line.
 each coloured according to its distance from
the line.
 Pixels at the line ends are handled separately.
 Lines less than one pixel long are handled as a
special case.

Conclusion
 In this lecture we took a very brief look at
how graphics hardware works
 Drawing lines to pixel based displays is time
consuming so we need good ways to do it
 The DDA algorithm is pretty good – but we
can do better

SummaryofDDAalgoritm
 input line endpoints, (x0,y0) and (xn, yn)
 set pixel at position (x0,y0)
 calculate slope m
 Case |m|≤1: repeat the following steps until (xn, yn) is
reached:
 yi+1 = yi + y/ x
 xi+1 = xi + 1
 set pixel at position (xi+1,Round(yi+1))
 Case |m|>1: repeat the following steps until (xn, yn) is
reached:
 xi+1 = xi + x/ y
 yi+1 = yi + 1
 set pixel at position (Round(xi+1), yi+1)

line drawing algorithms COMPUTER GRAPHICS & Graphical Programming

More Related Content

What's hot

Similar to line drawing algorithms COMPUTER GRAPHICS & Graphical Programming

Recently uploaded

line drawing algorithms COMPUTER GRAPHICS & Graphical Programming