computer graphics implementation i

C O M P U T E R G R A P H I C S

Guoying Zhao 1 / 51


Guoying Zhao 1 / 51

Computer Graphics

Implementation I


Guoying Zhao 2 / 51


Guoying Zhao 2 / 51

Algorithms for Drawing 2D Primitives

• Line Drawing Algorithms– DDA algorithm– Midpoint algorithm– Bresenham’s line algorithm

• Circle Generating Algorithms– Bresenham’s circle algorithm– Extension to Ellipse drawing


Guoying Zhao 3 / 51

Line Drawing


Guoying Zhao 4 / 51

Line Drawing

• Draw a line on a raster screen between two points

• What’s wrong with statement of problem?– doesn’t say anything about which points are allowed as endpoints

– doesn’t give a clear meaning of “draw”

– doesn’t say what constitutes a “line” in raster world

– doesn’t say how to measure success of proposed algorithms

Problem Statement

• Given two points P and Q in XY plane, both with integer coordinates, determine which pixels on raster screen should be on in order to make picture of a unit-width line segment starting at P and ending at Q

Scan Converting Lines


Guoying Zhao 5 / 51

Special case:

• Horizontal Line:

Draw pixel P and increment x coordinate value by 1 to get next pixel.

• Vertical Line:

Draw pixel P and increment y coordinate value by 1 to get next pixel.

• Diagonal Line:

Draw pixel P and increment both x and y coordinate by 1 to get next pixel.

• What should we do in general case? => Fast

- Digital differential analyzer (DDA) algorithm

- Mid-point algorithm

- Bresenham algorithm

Finding next pixel:


Guoying Zhao 6 / 51


Guoying Zhao 6 / 516

Scan Conversion of Line Segments

• Start with line segment in window coordinates with integer values for endpoints

• Assume implementation has a write_pixel function

y = mx + h

x

ym


Guoying Zhao 7 / 51

Basic Algorithm• Find equation of line that connects two points P(x1,y1) and

Q(x2,y2)• Starting with leftmost point P, increment xi by 1 to calculate yi =

m*xi + hwhere m = slope, h = y intercept

• Draw pixel at (xi, Round(yi)) where

Round (yi) = Floor (0.5 + yi)


Guoying Zhao 8 / 51



Strategy 1 – DDA Algorithm

• Digital Differential Analyzer

– DDA was a mechanical device for numerical solution of differential equations

– Line y=mx+ h satisfies differential equation dy/dx = m = Dy/Dx = (y2-y1)/(x2-x1)

• Along scan line Dx = 1

for(x=x1; x<=x2;x++) { y+=m; write_pixel(x, round(y), line_color);}


Guoying Zhao 9 / 51

Example Code// Incremental Line Algorithm

// Assume x0 < x1

void Line(int x0, int y0,

int x1, int y1) {

int x, y;

float dy = y1 – y0;

float dx = x1 – x0;

float m = dy / dx;

y = y0;

for (x = x0; x < x1; x++) {

WritePixel(x, Round(y));

y = y + m;

}

}



),( ii yx ))(,1( myRoundx ii

))(,( ii yRoundx ),1( myx ii





Problem

• DDA = for each x plot pixel at closest y– Problems for steep lines





Using Symmetry

• Use for 1 m 0

• For m > 1, swap role of x and y– For each y, plot closest x



Problem

void Line(int x0, int y0,

int x1, int y1) {

int x, y;

float dy = y1 – y0;

float dx = x1 – x0;

float m = dy / dx;

y = y0;

for (x = x0; x < x1; x++) {

WritePixel(x, Round(y));

y = y + m;

}

}

Rounding takes time



• Assume that line’s slope is shallow and positive (0 < slope < 1); other slopes can be handled by suitable reflections about principle axes

• Call lower left endpoint (x0, y0) and upper right endpoint (x1, y1)

• Assume that we have just selected pixel P at (xp, yp)

• Next, we must choose between pixel to right (E pixel) (xp+1, yp), or one right and one up (NE pixel) (xp+1, yp+1)

• Let Q be intersection point of line being scan-converted and vertical line x=xp+1

Strategy 2 – Midpoint Line Algorithm (1/3)




),( pp yxP 1 pxx

Previous pixel Choices for current pixel

Choices for next pixel

E pixel

NE pixel

Midpoint MQ



• Line passes between E and NE

• Point that is closer to intersection point Q must be chosen

• Observe on which side of line midpoint M lies:– E is closer to line if midpoint M lies above line, i.e., line crosses

bottom half

– NE is closer to line if midpoint M lies below line, i.e., line crosses top half

• Error (vertical distance between chosen pixel and actual line) is always <= ½


• Algorithm chooses NE as next pixel for line shown

• Now, need to find a way to calculate on which side of line midpoint lies E

pixel

NE pixel

MQ



Line equation as function f(x):

Line equation as implicit function:

for coefficients a, b, c, where a, b ≠ 0

from above,

Properties (proof by case analysis):• f(xm, ym) = 0 when any point M is on line• f(xm, ym) < 0 when any point M is above line• f(xm, ym) > 0 when any point M is below line• Our decision will be based on value of function at midpoint M at (xp +

1, yp + ½)

Line

Bxdx

dyy

Bmxy

0),( cbyaxyxf

dxBcdxbdya

dxBdxyxdy

dxBxdydxy

,,

0



void MidpointLine(int x0, int y0, int x1, int y1) {

int dx = x1 - x0;

int dy = y1 - y0;

int x = x0;

int y = y0;

float c = y0 * dx – dy * x0;

writePixel(x, y);

x++;

while (x < x1) {

d = dy * x – (y + 0.5) * dx + c;

if (d > 0) { // Northeast Case

y++;

}

writePixel(x, y);

x++;

} /* while */

}



Decision Variable d:

• We only need sign of f(xp + 1, yp + ½) to see where line lies,

and then pick nearest pixel

• d = f(xp + 1, yp + ½)

- if d > 0 choose pixel NE

- if d < 0 choose pixel E

- if d = 0 choose either one consistently

How do we incrementally update d?

• On basis of picking E or NE, figure out location of M for that

pixel, and corresponding value d for next grid line

• We can derive d for the next pixel based on our current

decision

Decision Variable



Increment M by one in x direction

dnew = f(xp + 2, yp + ½)

= a(xp + 2) + b(yp + ½) + c

dold = a(xp + 1) + b(yp + ½) + c

• dnew - dold is the incremental difference E

dnew = dold + a E = a = dy

• We can compute value of decision variable at next step incrementally without computing F(M) directly

dnew = dold + E = dold + dy

E can be thought of as correction or update factor to take dold to dnew • It is referred to as forward difference

If E was chosen:Strategy 3 – Bresenham algorithm



Increment M by one in both x and y directions

dnew = F(xp + 2, yp + 3/2)

= a(xp + 2) + b(yp + 3/2) + c

NE = dnew – dold

dnew = dold + a + b

NE = a + b = dy – dx

• Thus, incrementally,

dnew = dold + NE = dold + dy – dx

If NE was chosen:



• At each step, algorithm chooses between 2 pixels based on sign of decision variable calculated in previous iteration.

• It then updates decision variable by adding either E or NE to old value depending on choice of pixel. Simple additions only!

• First pixel is first endpoint (x0, y0), so we can directly calculate initial value of d for choosing between E and NE.

Summary (1/2)



• First midpoint for first d = dstart is at (x0 + 1, y0 + ½)

• f(x0 + 1, y0 + ½) = a(x0 + 1) + b(y0 + ½) + c = a * x0 + b * y0 + c + a + b/2 = f(x0, y0) + a + b/2

• But (x0, y0) is point on line and f(x0, y0) = 0

• Therefore, dstart = a + b/2 = dy – dx/2 – use dstart to choose second pixel, etc.

• To eliminate fraction in dstart : – redefine f by multiplying it by 2; f(x,y) = 2(ax + by + c)– this multiplies each constant and decision variable by 2, but does not

change sign

Summary (2/2)



Example Codevoid Bresenham(int x0, int y0, int x1, int y1) {

int dx = x1 - x0;

int dy = y1 - y0;

int d = 2 * dy - dx;

int incrE = 2 * dy;

int incrNE = 2 * (dy - dx);

int x = x0;

int y = y0;

writePixel(x, y);

while (x < x1) {

if (d <= 0) { // East Case

d = d + incrE;

} else { // Northeast Case

d = d + incrNE;

y++;

}

x++;

writePixel(x, y);

} /* while */

} /* MidpointLine */



Drawing Circles





Bresenham’s Circle Algorithm

• Circle Equation– (x-xc)2 + (y- yc)2 = R2

• Problem simplifying– Making the circle

origin (xc, yc) in the coordinate origin

– Symmetry points(y,x), (y,-x),(x,-y),(-x,-y),(-y,-x),(-y,x),(-x,y)



Version 1: really bad

For x = – R to R

y = sqrt(R * R – x * x);

Pixel (round(x), round(y));

Pixel (round(x), round(-y));

Version 2: slightly less bad

For x = 0 to 360

Pixel (round (R • cos(x)), round(R • sin(x)));

(17, 0)

(0, 17)

(17, 0)

(0, 17)

Scan Converting Circles



Suppose circle origin is (xc,yc),

radius is R.

Let D(x, y) = (x-xc)2+(y-yc)

2–R2

• If point(x,y) is outside the circle, D(x,y)>0 。

• If point(x,y) is inside the circle, D(x,y)<0 。

(xc, yc)



Bresenham’s Circle Algorithm

Two choice: (xi+1, yi) or (xi+1, yi-1)

(xi, yi) (xi+1, yi)

(xi+1, yi-1)

(xi, yi-1)

(xi+1, yi)

(xi+1, yi-1)

(xi, yi)

(xi, yi-1)



• Symmetry: If (x0 + a, y0 + b) is on circle

– also (x0 ± a, y0 ± b) and (x0 ± b, y0 ± a); hence 8-way symmetry.

• Reduce the problem to finding the pixels for 1/8 of the circle

R

(x0 + a, y0 + b)

(x-x0)2 + (y-y0)2 = R2

(x0, y0)

Use Symmetry



• Scan top right 1/8 of circle of radius R

• Circle starts at (x0, y0 + R)

• Let’s use another incremental algorithm with decision variable evaluated at midpoint

(x0, y0)

Using the Symmetry



E

SE

x = x0; y = y0 + R; Pixel(x, y);for (x = x0+1; (x – x0) < (y – y0); x++) {

if (decision_var < 0) {/* move east */update decision_var;

}else {

/* move south east */update decision_var;y--;

}Pixel(x, y);

}

Sketch of Incremental Algorithm



• Decision variable– negative if we move E, positive if we move SE (or vice versa).

• Follow line strategy: Use implicit equation of circle

f(x,y) = x2 + y2 – R2 = 0

f(x,y) is zero on circle, negative inside, positive outside

• If we are at pixel (x, y)– examine (x + 1, y) and (x + 1, y – 1)

• Compute f at the midpoint

What we need for Incremental Algorithm



P = (xp, yp)M ME

MSE

SE

Decision VariableE

• Evaluate f(x,y) = x2 + y2 – R2

at the point

• We are asking: “Is

positive or negative?” (it is zero on circle)

• If negative, midpoint inside circle, choose E– vertical distance to the circle is less at

(x + 1, y) than at (x + 1, y–1).• If positive, opposite is true, choose SE

22

2

21)1(

21,1 Ryxyxf

21,1 yx



• Decision based on vertical distance

• Ok for lines, since d and dvert are proportional

• For circles, not true:

• Which d is closer to zero? (i.e. which of the two values below is closer to R):

RyxCircyxd

RyxCircyxd

22

22

)1()1()),1,1((

)1()),,1((

2222 )1()1()1( yxoryx

The right decision variable?



• We could ask instead:“Is (x + 1)2 + y2 or (x + 1)2 + (y – 1)2 closer to R2?”

• The two values in equation above differ by

12])1()1[(])1[( 2222 yyxyx

fE – fSE = 290 – 257 = 33

(0, 17) (1, 17)

(1, 16)

fE = 12 + 172 = 290E

SE

fSE = 12 + 162 = 257

2y – 1 = 2(17) – 1 = 33

Alternate Phrasing (1/3)



• The second value, which is always less,

is closer if its difference from R2 is less than

i.e., if

then

so

so

so

2 )12(1 y])1()1[( 222 yxR

)12(21

y

21)1(0 222 Ryyx

2112)1(0 222 Ryyyx

)1()1(210 222 Ryxy

22

2

41

21)1(0 Ryx




• The radial distance decision is whether

is positive or negative

• And the vertical distance decision is whether

•

is positive or negative; d1 and d2 are apart.

• The integer d1 is positive only if d2 + is

positive (except special case where d2 = 0).4

1

4

1

22

2

41

21)1(1 Ryxd

22

2

21)1(2 Ryxd




• How to compute the value of

at successive points?• Answer: Note that

is just

and that

is just

(1/2)

22

2

21)1(),( Ryxyxf

2232),(

),()1,1(

32),(

),(),1(

SE

E

yxyx

yxfyxf

xyx

yxfyxf

Incremental Computation, Again



F F’

F’’

Incremental Computation (2/2)• If we move E, update by adding 2x + 3

• If we move SE, update by adding 2x + 3 – 2y + 2.

• Forward differences of a 1st degree polynomial are constants and those of a 2nd degree polynomial are 1st degree polynomials – this “first order forward difference,” like a partial derivative, is one

degree lower



• The function is linear, hence amenable to incremental computation, viz:

• Similarly

Second Differences (1/2)

32),(E xyx

2),()1,1( EE yxyx

2),(),1( EE yxyx

4),()1,1( SESE yxyx2),(),1( SESE yxyx



• For any step, can compute new ΔE(x, y) from old ΔE(x, y) by adding appropriate second constant increment – update delta terms as we move.

– This is also true of ΔSE(x, y)

• Having drawn pixel (a,b), decide location of new pixel at (a + 1, b) or (a + 1, b – 1), using previously computed d(a, b).

• Having drawn new pixel, must update d(a, b) for next iteration; need to find either d(a + 1, b) or d(a + 1, b – 1) depending on pixel choice

• Must add ΔE(a, b) or ΔSE(a, b) to d(a, b)

• So we…– Look at d(i) to decide which to draw next, update x and y– Update d using ΔE(a,b) or ΔSE(a,b) – Update each of ΔE(a,b) and ΔSE(a,b) for future use– Draw pixel

Second Differences (2/2)



Bresenham’s Eighth Circle Algorithmvoid MEC (int R) /* 1/8th of a circle w/ radius R */

{ int x = 0, y = R;

int delta_E, delta_SE;

float decision;

delta_E = 2*x + 3;

delta_SE = 2*(x-y) + 5;

decision = (x+1)*(x+1) + (y - 0.5)*(y - 0.5) –R*R;

Pixel(x, y);

while( y > x ) {

if (decision < 0) {/* Move east */

decision += delta_E;

delta_E += 2; delta_SE += 2; /*Update delta*/

}

else {/* Move SE */

y--;

decision += delta_SE;

delta_E += 2; delta_SE += 4; /*Update delta*/}

x++;

Pixel(x, y);

}

}



• Uses floats!

• 1 test, 3 or 4 additions per pixel

• Initialization can be improved

• Multiply everything by 4 No Floats!– Makes the components even, but sign of decision variable remains

same

Questions

• Are we getting all pixels whose distance from the circle is less than ½?

• Why is y > x the right stopping criterion?

• What if it were an ellipse?

Analysis



• Equation is

i.e,

• Computation of and is similar

• Only 4-fold symmetry

• When do we stop stepping horizontally and switch to vertical?

Aligned Ellipses

12

2

2

2

by

ax

222222bayaxb

E SE



• When absolute value of slope of ellipse is more than 1, viz:

• How do you check this? At a point (x,y) for which f(x,y) = 0, a vector perpendicular to the level set is f(x,y) which is

• This vector points more right than up when

Direction Changing Criterion (1/2)

),(),,( yxyfyx

xf

0),(),(

yx

yfyx

xf



• In our case,

and

so we check for

i.e.

• This, too, can be computed incrementally

Direction Changing Criterion (2/2)

xayxx

f 22),(

ybyxy

f 22),(

022 22 ybxa

022 ybxa



• Patterned primitives

• Non-integer primitives

• General conics

Other Scan Conversion Problems



• Patterned line from P to Q is not same as patterned line from Q to P.

• Patterns can be geometric or cosmetic– Cosmetic: Texture applied after transformations– Geometric: Pattern subject to transformations

Cosmetic patterned line

Geometric patterned line

Patterned Lines

P Q

P Q



Geometric Pattern vs. Cosmetic Pattern

+

Geometric (Perspectivized/Filtered) Cosmetic





Next Lecture

• Polygon Filling– Scan-line Conversion Approaches– Area Filling Approaches

• Antialiasing

• Clipping

computer graphics implementation i

Documents