You are on page 1of 28

# Line Drawing Algorithm

## Algorithms for Drawing line

Introduction - Pixel addressing - Primitives and attributes Line drawing algorithms - DDA - Bresenham

Pixel addressing in raster graphics and how does computer draw line?
Screen made of pixels High-level language specifies line System must color pixels
Pixel address y y+1 y+2 y+3 x x+1 x+2 x+3 x+4

Theoretical length

Pixel

Actual length

## Line drawing algorithms

symbols & descriptions y = 2x + 5 x0 = 100 y0 = 50 d = 100 thickness = 4 images

m<1

m>1

## Line Drawing Algorithms

Line drawn as pixels Graphics system
Projects the endpoints to their pixel locations in the frame buffer (screen coordinates as integers) Finds a path of pixels between the two Loads the color Plots the line on the monitor from frame buffer (video controller) Rounding causes all lines except horizontal or vertical to be displayed as jigsaw appearance (low resolution) Improvement: high resolution, or adjust pixel intensities on the line path.

## Line Drawing Algorithms

Line equation
Slope-intercept form y=m.x+ b slope m y-intercept b
Slope y-intercept

b y0 mx0

yend y0 y m xend x0 x

## Line Drawing Algorithms

y mx x

y
m

For lines with slope |m|<1, x can be set to a proportional to small deflection value, y can be calculated from the formula For lines with slope |m|<1, y can be set to a proportional to small deflection value, x can be calculated from the formula

## Line Drawing Algorithms

DDA (Digital Differential Analyzer)
Scan conversion line algorithm based on calculating either x or y Line sampled at regular intervals of x, then corresponding y is calculated and rounded From left to right
if m 1.0, if m > 1.0,
if m 1.0, if m > 1.0,

y k +1 = y k + m x k +1 = x k 1 + m
1 m

( x = 1) ( y = 1)
( x = -1) ( y = -1)

y k +1 = y k - m x k +1 = x k -

## Line Drawing Algorithms

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)); } }

Y_inc

X_inc

## but floating point operations and rounding operations are expensive

DDA Algorithm
Start with starting and ending coordinates of the line:
(x0, y0) and (x1, y1)

Color first pixel (round to nearest integer) Suppose x1-x0 > y1-y0 (gentle slope)
There will be x1-x0 steps (# pixels to be colored)

## Set x=x0, y=y0 At each step,

increment x by (x1-x0)/numsteps, and increment y by (y1-y0)/numsteps

For each step, round off x and y to nearest integer, and color pixel

DDA Pseudo-code
// assume that slope is gentle DDA(float x0, float x1, float y0, float y1) { float x, y; float xinc, yinc; int numsteps; numsteps = Round(x1) Round(x0); xinc = (x1 x0) / numsteps; yinc = (y1 y0) / numsteps; x = x0; y = y0; ColorPixel(Round(x),Round(y)); for (int i=0; i<numsteps; i++) { x += xinc; y += yinc; ColorPixel(Round(x),Round(y)); }

Q: For each step, how many floating point operations are there? A: 4 Q: For each step, how many integer operations are there? A: 2

DDA Example
Suppose we want to draw a line starting at pixel (2,3) and ending at pixel (12,8). What are the values of the variables x and y at each timestep? What are the pixels colored, according to the DDA algorithm?
numsteps = 12 2 = 10 xinc = 10/10 = 1.0 yinc = 5/10 = 0.5 t 0 1 2 3 4 5 6 7 8 9 10 x 2 3 4 5 6 7 8 9 10 11 12 y 3 3.5 4 4.5 5 5.5 6 6.5 7 7.5 8 R(x) 2 3 4 5 6 7 8 9 10 11 12 R(y) 3 4 4 5 5 6 6 7 7 8 8

DDA Algorithm
Advantage
Does not calculate coordinates based on the complete equation (uses offset method)

Disadvantage
Round-off errors are accumulated, thus line diverges more and more from straight line Round-off operations take time

Perform integer arithmetic by storing float as integers in numerator and denominator and performing integer arithmetic.

## Bresenhams Line Drawing Algorithm

Efficient line drawing algorithm using only incremental integer calculations Can be adapted to draw circles and other curves Principle
Vertical axes show scan line positions Horizontal axes show show pixel columns At each step, determine the best next pixel based on the sign of an integer parameter whose value is proportional to the difference between the vertical separations of the two pixel positions from the actual line.

Bresenhams Algorithm
Uses only integer calculations Uses distance between ideal y-coordinate and the upper and lower pixel (assuming gentle slope)

dupper dlower

## General idea how Bresenham works

first consider the scan-conversion process for lines with positive slope less than 1. Pixel positions along a line path are then determined by sampling at unit x intervals. Starting from the left endpoint (xo, yo) of a given line, we step to each successive column (x position) and plot the pixel whose scanline y value is closest to the line path. Figure 3-7 demonstrates the Kth step in this process. Assuming we have determined that the pixel at (xk, yk) is to be displayed, we next need to decide which pixel to plot in column xk+1, Our choices are the pixels at positions (Xk+l, Yk) and (Xk+l, Yk+l).

## Bresenhams Line Drawing Algorithm

Section of the screen grid showing a pixel in column xk on scan line yk that is to be plotted along the path of a line segment with slope O<m<l.

## Bresenhams Line Drawing Algorithm

Distances between pixel positions and the line y coordinate at sampling position xk+ I.

y = mx + b

y = m(x+1) + b y

d2
d1

x+1

## Bresenham's line algorithm (slope 1)

1. Input the two line endpoints and store the left endpoint in (x0, y0). 2. Set the color for the frame-buffer position (x0, y0) i.e. plot the first point. 3. Calculate the constant x, y, 2y and 2y 2x, and set the starting value for the decision parameter as p0 = 2y x 4. At each xk along the line, from k=0, perform the following test:
if pk<0, next point to plot is (xk + 1, yk) and pk+1 = pk + 2y otherwise, next point to plot is (xk + 1, yk + 1 ) and pk+1 = pk + 2y- 2x Repeat step-4 x times.

5.

## Number of Operations in Bresenhams Algorithm

Q: In each step, how many floating point operations are there? A: 0
Q: In each step, how many integer operations are there? A: 3 or 4

## Bresenhams Algorithm Example

Suppose we want to draw a line starting at pixel (2,3) and ending at pixel (12,8). What are the values of p0, dx and dy? What are the values of the variable p at each timestep? What are the pixels colored, according to Bresenhams algorithm?
dx = 12 2 = 10 dy = 8 3 = 5 p0 = 2dy dx = 15 t 0 1 2 3 p 0 -10 0 -10 P(x) 2 3 4 5 2dy = 10 2dy 2dx = -10 P(y) 3 4 4 5

4
5 6 7 8 9 10

0
-10 0 -10 0 -10 0

6
7 8 9 10 11 12

5
6 6 7 7 8 8

## DDA versus Bresenhams Algorithm

DDA works with floating point arithmetic Rounding to integers necessary
Bresenhams algorithm uses integer arithmetic Constants need to be computed only once Bresenhams algorithm generally faster than DDA