1 COMPUTER GRAPHICS CHAPTER 3 2D GRAPHICS ALGORITHMS.

11

COMPUTER COMPUTER GRAPHICSGRAPHICS

CHAPTER 3CHAPTER 32D GRAPHICS ALGORITHMS2D GRAPHICS ALGORITHMS

22

2D Graphics Algorithms2D Graphics Algorithms

Output PrimitivesOutput Primitives Line Drawing AlgorithmsLine Drawing Algorithms

DDA AlgorithmDDA Algorithm Midpoint AlgorithmMidpoint Algorithm Bersenhem’s AlgorithmBersenhem’s Algorithm

Circle Drawing AlgorithmsCircle Drawing Algorithms Midpoint Circle AlgorithmMidpoint Circle Algorithm

AntialisingAntialising Fill-Area AlgorithmsFill-Area Algorithms

33

Output PrimitivesOutput Primitives

44

Output PrimitivesOutput Primitives The basic objects out of which a The basic objects out of which a

graphics display is created are graphics display is created are called. called.

Describes the geometry of objects Describes the geometry of objects and – typically referred to as and – typically referred to as geometric primitivesgeometric primitives..

Examples: Examples: point, line, text, filled point, line, text, filled region, images, quadric surfaces, region, images, quadric surfaces, spline curvesspline curves

Each of the output primitives has its Each of the output primitives has its own set of own set of attributesattributes. .


PointsPoints

Attributes: Size, Color.Attributes: Size, Color.

glPointSize(p);glBegin(GL_POINTS);

glVertex2d(x1, y1);

glVertex2d(x2, y2);

glVertex2d(x3, y3);

glEnd()


LinesLines

Attributes: Color, Thickness, TypeAttributes: Color, Thickness, Type

glLineWidth(p);glBegin(GL_LINES);

glVertex2d(x1, y1);

glVertex2d(x2, y2);

glVertex2d(x3, y3);

glVertex2d(x4, y4);

glEnd()

Output PrimitivesOutput Primitives Polylines (open)Polylines (open)

A set of line segments joined end to end.A set of line segments joined end to end.


glLineWidth(p);

glBegin(GL_LINE_STRIP);glVertex2d(x1,

y1);glVertex2d(x2,

y2);glVertex2d(x3,

y3);glVertex2d(x4,

y4);glEnd()

Output PrimitivesOutput Primitives Polylines (closed)Polylines (closed)

A polyline with the last point connected to A polyline with the last point connected to the first point .the first point .


Note: A closed polyline cannot be filled.

glBegin(GL_LINE_LOOP);glVertex2d(x1, y1);glVertex2d(x2, y2);glVertex2d(x3, y3);glVertex2d(x4, y4);

glEnd()

Output PrimitivesOutput Primitives PolygonsPolygons

A set of line segments joined end to end.A set of line segments joined end to end.

Attributes: Fill color, Thickness, Fill patternAttributes: Fill color, Thickness, Fill pattern

Note: Polygons can be filled.

glBegin(GL_POLYGON);glVertex2d(x1, y1);glVertex2d(x2, y2);glVertex2d(x3, y3);glVertex2d(x4, y4);

glEnd()

1010


TextText

Attributes: Font, Color, Size, Attributes: Font, Color, Size, Spacing, Orientation.Spacing, Orientation.

Font: Font: Type (Helvetica, Times, Courier etc.)Type (Helvetica, Times, Courier etc.)

Size (10 pt, 14 pt etc.)Size (10 pt, 14 pt etc.)

Style (Bold, Italic, Underlined)Style (Bold, Italic, Underlined)

1111

Output PrimitivesOutput Primitives ImagesImages

Attributes: Image Size, Image Attributes: Image Size, Image Type, Color Depth.Type, Color Depth.

Image Type: Image Type: Binary (only two levels)Binary (only two levels)

MonochromeMonochrome

Color.Color.

Color Depth:Color Depth:

Number of bits used to represent Number of bits used to represent color.color.

12

TCS2111

Output PrimitivesOutput Primitive Attributes

Point SizeColor

Line Thickness (1pt, 2pt …)Type (Dashed, Dotted, Solid)Color

Text Font (Arial, Courier, Times Roman…)Size (12pt, 16pt ..)SpacingOrientation (Slant angle)Style (Bold, Underlined, Double lined)Color

Filled Region Fill PatternFill Type (Solid Fill, Gradient Fill)Fill Color

Images Color Depth (Number of bits/pixel)

1313

Line Drawing AlgorithmsLine Drawing Algorithms

Line DrawingLine Drawing

• Line drawing is fundamental to computer graphics.• We must have fast and efficient line drawing functions.

Rasterization Problem: Given only the two end points, how to compute the intermediate pixels, so that the set of pixels closely approximate the ideal line.

Line Drawing - Analytical MethodLine Drawing - Analytical Method

y y

x x

y x

b am

b a

c a ma

y

x

y=mx+c

ax bx

A(ax,ay)

B(bx,by)

• Directly based on the analytical equation of a line. • Involves floating point multiplication and addition• Requires round-off function.

double m = (double)(by-ay)/(bx-ax);double c = ay - m*ax;

double y; int iy;

for (int x=ax ; x <=bx ; x++) { y = m*x + c;

iy = round(y);setPixel (x, iy);

}

Line Drawing - Analytical MethodLine Drawing - Analytical Method

Compute one point based on the previous point:(x0, y0)…….…………..(xk, yk) (xk+1, yk+1) …….

I have got a pixel on the line (Current Pixel).How do I get the next pixel on the line?

Next pixel on next column(when slope is small)

Next pixel on next row(when slope is large)

Incremental AlgorithmsIncremental Algorithms

CurrentPixel(xk, yk)

To find (xk+1, yk+!):

xk+1 = xk+1

yk+1 = ?

(5,2)

(6,1)

(6,2)

(6,3)

• Assumes that the next pixel to be set is on the next column of

pixels (Incrementing the value of x !)

• Not valid if slope of the line is large.

Incrementing along xIncrementing along x

Digital Differential Analyzer Algorithm is an incremental algorithm.

Assumption: Slope is less than 1 (Increment along x).Current Pixel = (xk, yk).

(xk, yk) lies on the given line. yk = m.xk + c

Next pixel is on next column. xk+1 = xk+1Next point (xk+1, yk+1) on the line yk+1 = m.xk+1 + c

= m (xk+1) +c = yk + m

Given a point (xk, yk) on a line, the next point is given by xk+1 = xk+1 yk+1 = yk + m

Line Drawing - DDALine Drawing - DDA

• Does not involve any floating point multiplication.• Involves floating point addition.• Requires round-off function

Line Drawing - DDALine Drawing - DDA

double m = (double) (by-ay)/(bx-ax);double y = ay;int iy;for (int x=ax ; x <=bx ; x++) { iy = round(y); setPixel (x, iy); y+ = m;}

xk+1 = xk+1

yk+1 = Either yk or yk+1

Midpoint algorithm is an incremental algorithm

Midpoint AlgorithmMidpoint Algorithm

Assumption:Slope < 1

CurrentPixel

Candidate Pixels

Current Pixel( xk, yk)

Midpoint

Line

Coordinates of Midpoint = ( xk+1, yk+(1/2) )

( xk+1, yk)

( xk+1, yk+1)

Midpoint Algorithm - NotationsMidpoint Algorithm - Notations

Midpoint Below Line Midpoint Above Line

Midpoint Algorithm:Midpoint Algorithm:Choice of the next pixelChoice of the next pixel

•If the midpoint is below the line, then the next pixel is (xk+1, yk+1).

•If the midpoint is above the line, then the next pixel is (xk+1, yk).

A(ax,ay)

B(bx,by)

Equation of a line revisited.Equation of a line revisited.

Let w = bx ax, and h = by ay.

Then, h (x ax) w (y ay) = 0.

(h, w , ax , ay are all integers).

In other words, every point (x, y) on the line satisfies the equation F(x, y) =0, where

F(x, y) = h (x ax) w (y ay).

Equation of the line:y x

y y x x

y a x a

b a b a

Midpoint Algorithm:Midpoint Algorithm:Regions below and above the line.Regions below and above the line.

F (x,y) > 0(for any point below line)

F(x,y) < 0(for any point above line)

F(x,y) = 0

F(MP) > 0

0),( yxf

Midpoint below line

F(MP) < 0

Midpoint above line

Midpoint AlgorithmMidpoint AlgorithmDecision CriteriaDecision Criteria

Midpoint AlgorithmMidpoint AlgorithmDecision CriteriaDecision Criteria

F(MP) = F(xk+1, yk+ ½) = Fk (Notation)

If Fk < 0 : The midpoint is above the line. So the next

pixel is (xk+1, yk).

If Fk 0 : The midpoint is below or on the line. So

the next pixel is (xk+1, yk+1).

Decision Parameter

Midpoint Algorithm – Story so far.Midpoint Algorithm – Story so far.

Midpoint Below Line

Next pixel = (xk+1, yk+1)

Fk > 0

yk+1 = yk+1

Midpoint Above Line

Next pixel = (xk+1, yk)

Fk < 0

yk+1 = yk

Midpoint AlgorithmMidpoint AlgorithmUpdate EquationUpdate Equation

Fk = F(xk+1, yk+ ½) = h (xk+1 ax) w (yk+½ ay)

But, Fk+1 = Fk + h w (yk+1 yk). (Refer notes)

So,

Fk< 0 : yk+1 = yk.Hence, Fk+1 = Fk + h .

Fk 0 : yk+1 = yk+1. Hence, Fk+1 = Fk + h w.

F0 = h w/2.

Update Equation

3030

Midpoint AlgorithmMidpoint Algorithm

int h = by-ay;int w = bx-ax;float F=h-w/2;int x=ax, y=ay;for (x=ax; x<=bx; x++){ setPixel(x, y);

if(F < 0) F+ = h; else{

F+ = h-w; y++;

}}

3131

Bresenham’s AlgorithmBresenham’s Algorithm

int h = by-ay;int w = bx-ax;int F=2*h-w;int x=ax, y=ay;for (x=ax; x<=bx; x++){ setPixel(x, y);

if(F < 0)F+ = 2*h;

else{F+ = 2*(h-w);y++;

}}

3232

Circle Drawing Circle Drawing AlgorithmsAlgorithms

3333

To determine the closest pixel position to To determine the closest pixel position to the specified circle path at each step.the specified circle path at each step.

For given radius r and screen center For given radius r and screen center position (xposition (xcc, y, ycc), calculate pixel positions ), calculate pixel positions around a circle path centered at the around a circle path centered at the coodinate origin (0,0)coodinate origin (0,0)..

Then, move each calculated position (x, y) Then, move each calculated position (x, y) to its proper screen position by adding to its proper screen position by adding xxc c to to xx andand yycc to y to y..

Along the circle section from x=0 to x=y in Along the circle section from x=0 to x=y in the the first quadrantfirst quadrant, the gradient varies from , the gradient varies from 0 to -1.0 to -1.

Midpoint Circle Drawing AlgorithmMidpoint Circle Drawing Algorithm

34

TCS2111

Midpoint Circle Drawing Algorithm 8 segments of octants for a circle:

35

TCS2111

Midpoint Circle Drawing Algorithm Circle function: fcircle (x,y) = x2 + y2 –r2

> 0, (x,y) outside the circle

< 0, (x,y) inside the circle

= 0, (x,y) is on the circle boundary

{fcircle (x,y) =

36

TCS2111

Midpoint Circle Drawing Algorithm

yk

yk-1

midpoint

Next pixel = (xk+1, yk)

Fk < 0

yk+1 = yk

yk

yk-1

midpoint

Next pixel = (xk+1, yk-1)

Fk >= 0

yk+1 = yk - 1

37

TCS2111

Midpoint Circle Drawing AlgorithmWe know xk+1 = xk+1,

Fk = F(xk+1, yk- ½)

Fk = (xk +1)2 + (yk - ½)2 - r2 -------- (1)

Fk+1 = F(xk+1, yk- ½)

Fk+1 = (xk +2)2 + (yk+1 - ½)2 - r2 -------- (2)

(2) – (1)

Fk+1 = Fk + 2(xk+1) + (y2k+1 – y2

k) - (yk+1 – yk) + 1

If Fk < 0, Fk+1 = Fk + 2xk+1+1

If Fk >= 0, Fk+1 = Fk + 2xk+1+1 – 2yk+1

38

TCS2111


For the initial point, (x0 , y0) = (0, r)

f0 = fcircle (1, r-½ )

= 1 + (r-½ )2 – r2

= 5 – r 4≈ 1 – r

39

TCS2111

Midpoint Circle Drawing AlgorithmExample:

Given a circle radius = 10, determine the circle octant in the first quadrant from x=0 to x=y.

Solution:

f0 = 5 – r 4

= 5 – 10 4= -8.75

≈ –9

40

TCS2111


Initial (x0, y0) = (1,10)Decision parameters are: 2x0 = 2, 2y0 = 20

k Fk x y 2xk+1 2yk+1

0 -9 1 10 2 20

1 -9+2+1=-6 2 10 4 20

2 -6+4+1=-1 3 10 6 20

3 -1+6+1=6 4 9 8 18

4 6+8+1-18=-3 5 9 10 18

5 -3+10+1=8 6 8 12 16

6 8+12+1-16=5 7 7 14 14

41

TCS2111

Midpoint Circle Drawing Algorithmvoid circleMidpoint (int xCenter, int yCenter, int radius){

int x = 0;Int y = radius;int f = 1 – radius;

circlePlotPoints(xCenter, yCenter, x, y);while (x < y) {

x++;if (f < 0)

f += 2*x+1;else {

y--;f += 2*(x-y)+1; }

}circlePlotPoints(xCenter, yCenter, x, y);

}

42

TCS2111


void circlePlotPoints (int xCenter, int yCenter, int x, int y){

setPixel (xCenter + x, yCenter + y);setPixel (xCenter – x, yCenter + y);setPixel (xCenter + x, yCenter – y);setPixel (xCenter – x, yCenter – y);setPixel (xCenter + y, yCenter + x);setPixel (xCenter – y, yCenter + x);setPixel (xCenter + y, yCenter – x);setPixel (xCenter – y, yCenter – x);

}

4343

AntialiasingAntialiasing

4444

AntialiasingAntialiasing

Antialiasing is a technique used to diminish the jagged edges of an image or a line, so that the line appears to be smoother; by changing the pixels around the edges to intermediate colors or gray scales.

Eg. Antialiasing disabled:

Eg. Antialiasing enabled:

Antialiasing (OpenGL)Antialiasing (OpenGL)

Antialiasing disabled Antialiasing enabled

Setting antialiasing option for lines:glEnable (GL_LINE_SMOOTH);

4646

Fill Area AlgorithmsFill Area Algorithms

4747

Fill Area AlgorithmsFill Area Algorithms

Fill-Area algorithms are used to fill the Fill-Area algorithms are used to fill the interior of a polygonal shape.interior of a polygonal shape.

Many algorithms perform fill operations Many algorithms perform fill operations by first identifying the interior points, by first identifying the interior points, given the polygon boundary.given the polygon boundary.

4848

The basic filling algorithm is commonly used in interactive graphics packages, where the user specifies an interior point of the region to be filled.

Basic Filling AlgorithmBasic Filling Algorithm

4-connected pixels

4949

[1] Set the user specified point.[1] Set the user specified point.

[2] Store the four neighboring pixels in a [2] Store the four neighboring pixels in a stack.stack.

[3] Remove a pixel from the stack.[3] Remove a pixel from the stack.

[4] If the pixel is not set,[4] If the pixel is not set,

Set the pixelSet the pixel

Push its four neighboring pixels into Push its four neighboring pixels into the stackthe stack

[5] Go to step 3[5] Go to step 3

[6] Repeat till the stack is empty.[6] Repeat till the stack is empty.


5050

void fill(int x, int y) { if(getPixel(x,y)==0){

setPixel(x,y);fill(x+1,y);fill(x-1,y);fill(x,y+1);fill(x,y-1);

}}

Basic Filling Algorithm (Code)Basic Filling Algorithm (Code)

5151

Requires an interior point.Requires an interior point.

Involves considerable amount of Involves considerable amount of stack operations.stack operations.

The boundary has to be closed.The boundary has to be closed.

Not suitable for self-intersecting Not suitable for self-intersecting polygonspolygons


5252

Boundary Fill AlgorithmBoundary Fill Algorithm For filling a region with a single For filling a region with a single

boundary color.boundary color. Condition for setting pixels:Condition for setting pixels:

Color is not the same as border colorColor is not the same as border color Color is not the same as fill colorColor is not the same as fill color

Flood Fill AlgorithmFlood Fill Algorithm For filling a region with multiple For filling a region with multiple

boundary colors.boundary colors. Condition for setting pixels:Condition for setting pixels:

Color is same as the old interior colorColor is same as the old interior color

Types of Basic Filling AlgorithmsTypes of Basic Filling Algorithms

53

TCS2111

void boundaryFill(int x, int y, int fillColor, int borderColor) { getPixel(x, y, color); if ((color != borderColor)

&& (color != fillColor)) {setPixel(x,y);boundaryFill(x+1,y,fillColor,borderColor);boundaryFill(x-1,y,fillColor,borderColor);boundaryFill(x,y+1,fillColor,borderColor);boundaryFill(x,y-1,fillColor,borderColor);

}}

Boundary Fill Algorithm (Code)

54

TCS2111

void floodFill(int x, int y, int fillColor, int oldColor) { getPixel(x, y, color); if (color != oldColor) {

setPixel(x,y);floodFill(x+1, y, fillColor, oldColor);floodFill(x-1, y, fillColor, oldColor);floodFill(x, y+1, fillColor, oldColor);floodFill(x, y-1, fillColor, oldColor);

}}

Flood Fill Algorithm (Code)

Filling Polygons (OpenGL)Filling Polygons (OpenGL)

Enabling polygon fill (Default):glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

Disabling polygon fill:glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

1 COMPUTER GRAPHICS CHAPTER 3 2D GRAPHICS ALGORITHMS.

Documents

Transcript of 1 COMPUTER GRAPHICS CHAPTER 3 2D GRAPHICS ALGORITHMS.