Computer Graphics: (CODE: ECS-504)
Computer Graphics: (CODE: ECS-504)
Computer Graphics: (CODE: ECS-504)
(CODE: ECS-504)
Introduction Computer Graphics & Its application Types of computer graphics Graphic display : random Scan & Raster Scan display Frame buffer and video Controller Points & Lines , line Drawing Algorithm Circle Generation algorithm Mid point circle generation algorithm Parallel version of these algorithm
Point Graphics programming packages provide functions to describe a scene in terms of these basic geometric structures, referred to as output primitives. Point plotting is accomplished by converting a single coordinate position function furnished by an application program into appropriate operation for the output device in use. Line drawing is accomplished by calculating intermediate position along the line path between to specified end point positions. An output device is then a random scan display , a straight line can be drawn smoothly form one endpoint to the other end point.
line
Must appear straight and continuous Must interpolate both defining end points Must have uniform density and intensity
Consistent within a line and over all lines
Line
Based on slope-intercept algorithm from algebra: y = mx + b Simple approach: increment x, solve for y Floating point arithmetic required
Continue..
M =y2-y1 / x2-xy b = y1-m.x1 for any given x interval x along a line , we can compute the corresponding y interval y from above equation y=mx and x = y/m For lines with slope magnitudes m<1 , x can be set proportional to a small horizontal deflection voltage and corresponding vertical deflection is then set proportional to y. For lines with slope magnitudes m>1 , y can be set proportional to a small horizontal deflection voltage and corresponding vertical deflection is then set proportional to x. If m=1 smooth line.
its is based on scan conversion line algorithm based on calculating x or y. if m < =1 then x=1 and successive y value yk+1 = yk+m if m >1 then y=1 and successive x value xk+1 = xk+1/m
DDA Algorithm
DDA algo.
1. Start. 2. Declare variables x,y,x1,y1,x2,y2,k,dx,dy,s,xi,yi and also declare gdriver=DETECT,gmode. 3. Initialise the graphic mode with the path location in TC folder. 4. Input the two line end-points and store the left end-points in (x1,y1). 5. Load (x1,y1) into the frame buffer;that is,plot the first point.put x=x1,y=y1. 6. Calculate dx=x2-x1 and dy=y2-y1. 7. If abs(dx) > abs(dy), do s=abs(dx). 8. Otherwise s= abs(dy). 9. Then xi=dx/s and yi=dy/s. 10. Start from k=0 and continuing till k<s,the points will be i. x=x+xi. ii. y=y+yi. 11. Place pixels using putpixel at points (x,y) in specified colour. 12. Close Graph. 13. Stop.
DDA algorithm
line(int x1, int y1, int x2, int y2) { float x,y; int dx = x2-x1, dy = y2-y1; int n = max(abs(dx),abs(dy)); float dt = n, dxdt = dx/dt, dydt = dy/dt; x = x1; y = y1; while( n-- ) { point(round(x),round(y)); x += dxdt; y += dydt; } }
DDA algorithm
Still 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.
Concept
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 have to choose between (3, 3) and (3, 4) We would like the point that is closer to the original line
5
(xk+1, yk+1)
4
(xk, yk)
3
(xk+1, yk)
2 2 3 4 5
Concept: The Bresenham Line Algorithm At sample position xk+1 the vertical separations from the mathematical line are labelled dupper and dlower
yk+1 y yk
dupp
er
dlower xk+1
d lower y yk
and:
m( xk 1) b yk
d upper ( 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
2y xk 2x yk c
So, a decision parameter pk for the kth step along a line is given by: pk x(dlower dupper )
2y xk 2x 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 2y xk 1 2x yk 1 c
Subtracting pk from this we get: pk 1 pk 2y ( xk 1 xk ) 2x( yk 1 yk )
The Bresenham Line Algorithm 1. 2. 3. BRESENHAMS 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, 2y, and (2y - 2x) and get the first value for the decision parameter as:
p0 2y x
4. 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:
pk 1 pk 2y
pk 1 pk 2y 2x
5. Repeat step 4 (x 1) times
The algorithm and derivation above assumes slopes are less than 1. for other slopes we need to adjust the algorithm slightly
Example
Lets have a go at this Lets plot the line from (20, 10) to (30, 18) First off calculate all of the constants: x: 10 y: 8 2y: 16 2y - 2x: -4 Calculate the initial decision parameter p0: p0 = 2y x = 6
k
0 1 2 3 4 5 6 7
pk
(xk+1,yk+1)
13
12
11
10 20 21 22 23 24 25 26 27 28 29 30
8 9