Download presentation

Presentation is loading. Please wait.

Published byGage Ripley Modified about 1 year ago

1
CS 376 Introduction to Computer Graphics 02 / 02 / 2007 Instructor: Michael Eckmann

2
Michael Eckmann - Skidmore College - CS Spring 2007 Today’s Topics Questions? Line Drawing algorithms –DDA lines –Bresenham Line Drawing algorithm Circle drawing algorithm

3
Michael Eckmann - Skidmore College - CS Spring 2007 Parametric Equation of a Line This information appears in section 6.7 of text but is appropriate now because it is used in the DDA algorithm (discussed next slide). Given 2 points on a line (x 0, y 0 ) and (x end, y end ) x = x 0 + u (x end - x 0 ) y = y 0 + u (y end - y 0 ) u is the parameter If we consider only the values 0 <= u <= 1, we get all the points on the line segment between (x 0, y 0 ) and (x end, y end ). When u = 0, x=x 0 and y = y 0 When u = 1, x=x end and y = y end

4
Michael Eckmann - Skidmore College - CS Spring 2007 DDA – digital differential analyzer Consider a line with positive slope and x 0 < x end If slope <=1 then we will sample the line at unit x intervals and compute y. If slope > 1 then we will sample the line at unit y intervals and compute x. What does that mean? In the DDA, the parameter u (from the parametric equation of a line) is 1/steps. Let's take a look at the code for this algorithm and “execute” it with actual values on the board.

5
Michael Eckmann - Skidmore College - CS Spring 2007 From Hearn & Baker's Computer Graphics with OpenGL, 3 rd Edition. 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)); }

6
Michael Eckmann - Skidmore College - CS Spring 2007 DDA – digital differential analyzer It creates good lines. The lines aren't going to differ in “thickness” based on angle, etc. Can you comment on any efficiency issues with this algorithm?

7
Michael Eckmann - Skidmore College - CS Spring 2007 DDA – digital differential analyzer It creates good lines. The lines aren't going to differ in “thickness” based on angle, etc. Problems with this algorithm are –Rounding is expensive –Floating point arithmetic is expensive So, a goal is to do all integer arithmetic and reduce / eliminate divides.

8
Michael Eckmann - Skidmore College - CS Spring 2007 Bresenham's Line Algorithm Bresenham's Algorithm is efficient (fast) and accurate. The key part of Bresenham's algorithm lies in the determination of which pixel to turn on based on whether the line equation would lie more near one pixel or the other.

9
Michael Eckmann - Skidmore College - CS Spring 2007 Bresenham's Line Algorithm Think of a line fully contained in the first octant (the area of the coordinate plane between the positive x-axis and the line y=x.) Assume we have the pixel at (x k, y k ) turned on and we're trying to determine between the following: –Should (x k+1, y k ) or (x k+1, y k+1 ) be on? –That is, the choice is between either the pixel one to the right of (x k, y k ) or the pixel one to the right and one up. The decision can be made based on whether d lower - d upper is positive or not. The goal is to come up with an inexpensive way to determine the sign of (d lower – d upper )

10
Michael Eckmann - Skidmore College - CS Spring 2007 Bresenham's Line Algorithm The y coordinate on the line is calculated by: y = m(x k + 1) + b and d lower = y – y k d upper = y k+1 – y d lower – d upper = 2m(x k + 1) – 2y k + 2b – 1 Since m is < 1 (recall it's in the 1 st octant) it is a non-integer. That's not good so, replace it with dy/dx, where dy is the change in y endpoints and dx is the change in x endpoints – these will be integer values divided --- but we'll get rid of the division. d lower – d upper = 2 ( dy / dx )(x k + 1) – 2y k + 2b – 1 Multiply both sides by dx and get: dx (d lower – d upper ) = 2 dy (x k + 1) – 2 dx y k + 2 dx b – dx dx (d lower – d upper ) = 2 dy x k – 2 dx y k + 2 dy + 2 dx b – dx 2 dy + 2 dx b – dx is a constant which is independent of each iteration

11
Michael Eckmann - Skidmore College - CS Spring 2007 Bresenham's Line Algorithm So we end up with dx (d lower – d upper ) = 2 dy x k – 2 dx y k + c We only need to determine the sign of (d lower – d upper ) dx is positive so it doesn't have an effect on the sign (so now there's no need to divide) --- does that make sense? Let p k = dx (d lower – d upper ) p k is the decision parameter So, we check if 2 dy x k – 2 dx y k + c < 0 and if it is we turn on the lower pixel, so (x k+1, y k ) should be the pixel turned on and otherwise (x k+1, y k+1 ) is turned on As the algorithm iterates though it needs to then calculate the next value of p, which is p k+1

12
Michael Eckmann - Skidmore College - CS Spring 2007 Bresenham's Line Algorithm Recall that to calculate p k we had: p k = 2 dy x k – 2 dx y k + c So, p k+1 = 2 dy x k+1 – 2 dx y k+1 + c If we subtract p k+1 – p k = 2dy ( x k+1 – x k ) – 2dx ( y k+1 – y k ) But, x k+1 = x k + 1 because of the octant we're in we always increment x by 1 So, we have p k+1 – p k = 2dy – 2dx ( y k+1 – y k ) Then, p k+1 = p k + 2dy – 2dx ( y k+1 – y k ) Where ( y k+1 – y k ) is either 1 or 0 (why?) depending on the sign of p k. So, either p k+1 = p k + 2dy (when p k < 0) p k+1 = p k + 2dy – 2dx (when p k >= 0)

13
Michael Eckmann - Skidmore College - CS Spring 2007 Bresenham's Line Algorithm /* Bresenham line-drawing procedure for |m| < 1.0. */ void lineBres (int x0, int y0, int xEnd, int yEnd) { int dx = fabs (xEnd - x0), dy = fabs(yEnd - y0); int p = 2 * dy - dx; int twoDy = 2 * dy, twoDyMinusDx = 2 * (dy - dx); int x, y; /* Determine which endpoint to use as start position. */ if (x0 > xEnd) { x = xEnd; y = yEnd; xEnd = x0; } else { x = x0; y = y0; } setPixel (x, y); while (x < xEnd) { x++; if (p < 0) p += twoDy; else { y++; p += twoDyMinusDx; } setPixel (x, y); } /* From Hearn & Baker's Computer Graphics with OpenGL, 3 rd Edition */

14
Michael Eckmann - Skidmore College - CS Spring 2007 Circle Algorithms

15
Michael Eckmann - Skidmore College - CS Spring 2007 Circle Algorithms So, we only need to calculate the coordinates of an eighth of the circle and plot the following: (-x, -y), (-x, y), (x, -y), (x, y), (y, x), (y, -x), (-y, x), (-y, -x) Bresenham's Line Algorithm has been adapted to circles by deciding which pixel is closest to the actual circle at each sampling step. It should be able to draw circles with any center, but to make calculations easier, compute the pixel coordinates based on the same radius but centered at the origin. Then when you plot the pixel, add in the center coordinates. Consider only the octant between the lines x=0 and y=x. The slope of the curve varies from 0 (at the top) to -1 at the 45 degree angle. This implies that we should do unit steps on the x-axis and calculate y (I leave this for you to convince yourself that this is the right approach.) At each x, the decision is between which y is correct among two possible y's, the one to the right or the one to the right and down.

16
Michael Eckmann - Skidmore College - CS Spring 2007 Circle Algorithms

17
Michael Eckmann - Skidmore College - CS Spring 2007 Circle Algorithms The decision is always between the pixel one to the right or one to the right and one down. Respectively, y k or y k-1. The midpoint circle algorithm is a way to determine it using only integer arithmetic. Define a circle function as f(x,y) = x 2 + y 2 – r 2 A point x,y on the circle with radius r will cause f(x,y) = 0 A point x,y in the circle's interior will cause f(x,y) < 0. A point x,y outside the circle will cause f(x,y) > 0. The point we use is the midpoint between the two pixel choices. And f(x,y) as defined above is our decision variable p k The point is (x k + 1, y k – ½) If p k is < 0, it is inside the circle and closer to y k Otherwise choose y k-1

18
Michael Eckmann - Skidmore College - CS Spring 2007 Circle Algorithms p k = f(x k + 1, y k – ½) = (x k + 1) 2 + (y k – ½) 2 – r 2 If p k is < 0, it is inside the circle and closer to y k Otherwise choose y k-1 p k+1 = f(x k+1 + 1, y k+1 – ½) = (x k+1 + 1) 2 + (y k+1 – ½) 2 – r 2 p k+1 = ((x k + 1) + 1) 2 + (y k+1 – ½) 2 – r 2 (p k+1 can be expressed in terms of p k ) Similar to how we determined the recursive decision variable computation in Bresenham's Line Algorithm, we do for the Circle Algorithm as well: skipping a bunch of steps leads to: p k+1 = p k + 2x k (when p k < 0) p k+1 = p k + 2x k – 2y k+1 (otherwise) Assuming we start at point (0,r), we'll have p 0 = f(0 + 1, r – ½) = f(1, r – ½) which yields 5/4 – r (or 1– r for integer radii because of rounding) Let's plot some points as an example for a circle of radius 6, and center (-2, 4) We do calculations with center 0,0 and for each point we plot, we add in the center.

19
Michael Eckmann - Skidmore College - CS Spring 2007 Circle Algorithm Example p 0 = 1– r p k+1 = p k + 2x k (when p k < 0) p k+1 = p k + 2x k – 2y k+1 (otherwise) Plot: (-1, 10), (0, 10), (1, 9), (2, 8) Also, plot points in the other 7 octants for each of these four. e.g. The other 7 points for (-1, 10) to plot are: (-3, 10), (-1,-2), (-3,-2), (4,5), (4, 3), (-8, 5), (-8, 3) These were calculated by adding the center (-2,4) to (-1,6), (1,-6), (-1,-6), (6, 1), (6,-1), (-6,1), and (-6,-1)

20
Michael Eckmann - Skidmore College - CS Spring 2007 Circle Algorithms There's a figure in the text book (figure 3-20) and it looks to me like the red circle line is drawn incorrectly but the pixels are correct. It is showing the center of the circle at the bottom left corner of the 0,0 pixel box, but it should be in the center of the 0,0 pixel box. I noticed it because when x=3, based on the drawn red circle, the algorithm would “turn on” (3,9) not (3,10), because the midpoint is clearly outside the red circle there. I didn't verify it, but I trust the calculations in the table which says that p 2 = -1 which would be inside the circle.

21
Michael Eckmann - Skidmore College - CS Spring 2007 Ellipse Algorithm We can generalize the circle algorithm to generate ellipses but with only 4-way symmetry. The slope of the ellipse changes from > -1 to < -1 in one quadrant so that we will have to switch from –unit samples along the x-axis and calculate y –to unit samples along the y-axis and calculate x I'm not as concerned about the details of ellipses as I am with you understanding the details of the line and circle algorithms.

22
Michael Eckmann - Skidmore College - CS Spring 2007 Ellipse Algorithms

23
Michael Eckmann - Skidmore College - CS Spring 2007 Ellipse Algorithms

Similar presentations

© 2016 SlidePlayer.com Inc.

All rights reserved.

Ads by Google