Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd
Upload
144 views

Unit II Computer Graphics

The document discusses different techniques for drawing lines in computer graphics, including rasterization, DDA, incremental, and Bresenham's line algorithms. It provides details on each algorithm, such as: 1) DDA uses floating point calculations which are computationally expensive, while later algorithms use integer calculations. 2) Incremental algorithm exploits the line equation y=mx+b and increments x or y by 1 based on the slope. 3) Bresenham's algorithm moves across the x-axis and chooses the pixel closer to the line using a decision parameter that can be calculated with integers.

Uploaded by

Suhas
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
144 views

Unit II Computer Graphics

The document discusses different techniques for drawing lines in computer graphics, including rasterization, DDA, incremental, and Bresenham's line algorithms. It provides details on each algorithm, such as: 1) DDA uses floating point calculations which are computationally expensive, while later algorithms use integer calculations. 2) Incremental algorithm exploits the line equation y=mx+b and increments x or y by 1 based on the slope. 3) Bresenham's algorithm moves across the x-axis and chooses the pixel closer to the line using a decision parameter that can be calculated with integers.

Uploaded by

Suhas
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 30

Computer Graphics

Raster Scan Graphics


– Conversion of the vectorial information of the drawing
into its equivalent raster format is called as Rasterisation.

– Straight lines and circles are the most common forms of


geometric elements and the other geometric elements can
be converted into either of these two forms.
Basic Line and Circle Algorithms
1. Must compute integer coordinates of pixels which lie on or near a line or
circle.
2. Pixel level algorithms are invoked hundreds or thousands of times when an
image is created or modified.
3. Lines must create visually satisfactory images.
• Lines should appear straight
• Lines should terminate accurately
• Lines should have constant density
• Line density should be independent of line length and angle.
4. Line algorithm should always be defined.
Line Drawing Techniques
• Line:
– the shortest connection between the points
and is called a straight line.
Line w.r.t slope
• A line may have three forms with respect to slope i.e.

• slope = 1 can easly be drawn

– starting form one point and go on incrementing the x and y coordinates


till they reach the second point.

• if slope < 1 or is > 1 then there will be more computations.


Line drawing techniques

• There are three techniques to draw a line:

– Digital Differential Analyzer (DDA) line algorithm

– Incremental line algorithm

– Bresenham line algorithm


Simple DDA Line
Algorithm
{Based on the parametric equation of a
line}

DDA (digital differential analyzer) creates good lines but it is too time
consuming due to the round function and long operations on real
values.
Digital Differential Analyzer (DDA) Algorithm:

• Find difference dx and dy between x coordinates and y coordinates


respectively ending points of a line.

• If |dx| is greater than |dy|, than |dx| will be step and otherwise |dy| will be
step.

• if |dx|>|dy| then

• step = |dx|

• else

• step = |dy|

• step is the total number of pixel required for a line.


Digital Differential Analyzer (DDA) Algorithm:

• Next step is to divide dx and dy by step to get xIncrement and yIncrement


that is the increment required in each step to find next pixel value.

• xIncrement = dx/step

• yIncrement = dy/step

• Next a loop is required that will run step times. In the loop drawPixel and
add xIncrement in x1 by and yIncrement in y1.

• To sum-up all above in the algorithm, we will get,


Digital Differential Analyzer (DDA) Algorithm:

• DDA_Line (Point p1, Point p2)


• dx = p2.x – p1. x
• dy = p2.y – p1. y
• x1=p1.x
• y1=p1.y
• if |dx|>|dy| then
• step = |dx|
• else
• step = |dy|
• xIncrement = dx/step
• yIncrement = dy/step
• for counter = 1 to step
• drawPixel (x1, y1)
• x1 = x1 + xIncrement
• y1 = y1 + yIncrement
Example
Compute which pixels should be turned on to represent the line from (6,9) to
(11,12).

Length := Max of (ABS(11-6), ABS(12-9)) = 5

Xinc := 1

Yinc := 0.6
13

12
Values computed are:
11

(6,9), (7,9.6), 10

9
(8,10.2), (9,10.8),
6 7 8 9 10 11 12 13
(10,11.4), (11,12)
Criticism on Algorithm
• The algorithm uses floating point calculation. When we have to draw
points (i.e. Pixels), it should have integers as coordinates instead it uses
floating point calculation which requires more space as well as they have
more computational cost.

• Therefore there is need to develop an algorithm which would be based on


integer type calculations.
Incremental line algorithm
• This algorithm exploits simple line equation
y=mx+b
• Where m = dy / dx
• and b = y – m x
• Now check if |m| < 1 then starting at the first
point, simply increment x by 1 (unit increment) till
it reaches ending point; whereas calculate y
point by the equation for each x
Incremental line algorithm…
• conversely if |m|>1 then increment y by 1 till it
reaches ending point; whereas calculate x point
corresponding to each y, by the equation.

• First if |m| < 1 then it means that for every


subsequent pixel on the line there will be unit
increment in x direction and there will be less
than 1 increment in y direction and vice versa for
slope greater than 1.
Example:
• Suppose a line has two points
p1 (10, 10) and p2 (20, 18)
• Now difference between y coordinates
dy = y2 – y1 = 18 – 10 = 8
• Whereas difference between x coordinates
dx = x2 – x1 = 20 – 10= 10
• This means that there will be 10 pixels on the
line in which for x-axis there will be distance of 1
between each pixel and for y-axis the distance
will be 0.8.
Another example
• line with points
p1 (10, 10) and p2 (16, 20)
Now difference between y coordinates
dy = y2 – y1 = 20 – 10 = 10
• difference between x coordinates is
dx = x2 – x1 = 16 – 10 = 6
• This means that there will be 10 pixels on the line in
which for x-axis there will be distance of 0.6 between
each pixel and for y-axis the distance will be 1.

• using above technique, called incremental line algorithm:


incremental line algorithm:
• Incremental_Line (Point p1, Point p2)
• dx = p2.x – p1.x
• dy = p2.y – p1.y
• m = dy / dx
• x = p1.x
• y = p1.y
• b=y–m*x
• if |m| < 1
• for counter = p1.x to p2.x
• drawPixel (x, y)
• x=x+1
• y=m*x+b
• else
• for counter = p1.y to p2.y
• drawPixel (x, y)
• y=y+1
• x=(y–b)/m
Bresenham Line Drawing Algorithm
• Move across the x axis in unit intervals and at each step
choose between two different y coordinates

• For example, from


position (2, 3) we
5 have to choose
(xk+1, yk+1) between (3, 3) and
4
(3, 4)
(xk, yk)
3 • We would like the
(xk+1, yk) point that is closer
2 to the original line
2 3 4 5
Bresenham Line Algorithm
• At sample position
xk+1 the vertical yk+1
dupper
separations from the y
mathematical line are yk dlower
labelled dupper and
dlower xk+1
• The y coordinate on the mathematical line at
xk+1 is:
y  m( xk  1)  b
• So, dupper and dlower are given as follows:
dlower  y  yk
 m( xk  1)  b  yk
• and:
dupper  ( yk  1)  y
 yk  1  m( xk  1)  b
• We can use these to make a simple decision
about which pixel is closer to the
mathematical line
• This simple decision is based on the
difference between the two pixel positions:
dlower  dupper  2m( xk  1)  2 yk  2b  1
• Let’s substitute m with ∆y/∆x where ∆x and
∆y are the differences between the end-
points:
y
x(dlower  dupper)  x(2 ( xk  1)  2 yk  2b  1)
x
 2y  xk  2x  yk  2y  x(2b  1)

 2y  xk  2x  yk  c
• So, a decision parameter pk for the kth step
along a line is given by:
pk  x(d lower  d upper )
 2y  xk  2x  yk  c
• The sign of the decision parameter pk is
the same as that of dlower – dupper
• If pk is negative, then we choose the lower
pixel, otherwise we choose the upper pixel
• Remember coordinate changes occur
along the x axis in unit steps so we can do
everything with integer calculations
• At step k+1 the decision parameter is
given as:
pk 1  2y  xk 1  2x  yk 1  c
• Subtracting pk from this we get:

pk 1  pk  2y( xk 1  xk )  2x( yk 1  yk )
• But, xk+1 is the same as xk+1 so:
pk 1  pk  2y  2x( yk 1  yk )
• where yk+1 - yk is either 0 or 1 depending
on the sign of pk
• The first decision parameter p0 is
evaluated at (x0, y0) is given as:

p0  2y  x
• BRESENHAM’S LINE DRAWING ALGORITHM
(for |m| < 1.0)
• Input the two line end-points, storing the left end-point
in (x0, y0)
• Plot the point (x0, y0)
• Calculate the constants Δx, Δy, 2Δy, and (2Δy - 2Δx)
and get the first value for the decision parameter as:

• 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:
• Otherwise, the next point to plot is (xk+1, yk+1) and:
• Repeat step 4 (Δx – 1) times
• Let’s have a go at this
• Let’s plot the line from (20, 10) to (30, 18)
• First off calculate all of the constants:
– Δx: 10
– Δy: 8
– 2Δy: 16
– 2Δy - 2Δx: -4
• Calculate the initial decision parameter p0:
– p0 = 2Δy – Δx = 6
k pk (xk+1,yk+1)
18 0

17
1
2
16
3
15
4
14
5
13
6
12
7
11
8
10 9
20 21 22 23 24 25 26 27 28 29 30
• Bresenham line drawing algorithm for a
line going from (21,12) to (29,16)
Discussion on algorithm:

• Well above algorithm is quite simple and


easy
• but firstly it involves lot of mathematical
calculations
– for calculating coordinate using equation each
time
– secondly it works only in incremental
direction.
The End

You might also like