CG Unit-1(output primitives)

CSE 411
Computer Graphics
Lecture #4 Attributes of Output Primitives and Algorithms

Objectives (cont.)
 Line drawing algorithms

 Circle generating algorithms
 Ellipse generating algorithms
 Scan-line polygon fill algorithms
 For convex polygons
 For regions with curved boundaries
 Implementation methods for antialiasing
Attributes of Output Primitives and Algorithms 2

Attributes
 Attribute parameter: A parameter that effects
the way the primitive is to be displayed.
 Color (common for all attributes)
 Style
 Dotted, dashed, thick, thin
 One approach is to extend the function calls
for primitives
 Another alternative is to have the system to
have a list of current attribute values
 State variables or state parameters
Color and Gray Scale
 RGB color buffer
 Store RGB color codes in frame buffer or in a
separate table
 Color code placed at pixel location
 Minimum number of colors for 3-bits
Left bit  Red, Middle bit  Green, Left bit 
Blue
0  black, 1  blue, …, 7  white
 More color bits increase the size of the frame
buffer: 24-bits * 1024 * 1024 = 3MB

Example: Color table

Color and Gray Scale
 Color tables
 Color map (color look-up table)
 Each pixel in the frame buffer contains a value (Ex.
196) corresponding to an entry in the color table
(Ex. 2081), which has 256 entries.
 Color table contains a 3-byte color code that
represents an RGB color – 1-byte for the Red, 1-
byte for the Green, 1-byte for the Blue.
 Pick 256 colors from a total of 17 million, and save
storage: 8 bits * 1024 * 1024 = 1MB
Attributes of Output Primitives and

Algorithms 6
Color and Gray Scale (cont.)
A color lookup table with 24 bits per entry that is accessed from a frame buffer with 8
bits per pixel. A value of 196 stored at pixel position (x, y) references the location in this
table containing the hexadecimal value 0x0821 (a decimal value of 2081). Each 8-bit
segment of this entry controls the intensity level of one of the three electron guns in an
RGB monitor. Attributes of Output Primitives and Algorithms 7
Line Drawing Algorithms (cont.)

Closer Look

 Line equation
 Slope-intercept form
y=mx+b
slope m
y-intercept b
𝑦 𝑒𝑛𝑑 − 𝑦 0 𝛿 𝑦
 Slope 𝑚= =
𝑥 𝑒𝑛𝑑 − 𝑥 0 𝛿 𝑥
y-intercept
𝑏= 𝑦 0 − 𝑚 𝑥 0


Calculating the values


Setting Deflection Values


Line Sampling
Straight-line segment with five sampling positions along the x axis

between x0 and xend. Attributes of Output Primitives and Algorithms 13
 DDA (Digital Differential Analyzer)

 Scan conversion line algorithm based on calculating
either δx or δy
 Line sampled at regular intervals of x, then
corresponding y is calculated and rounded

 From left to right
if m  1.0, y k +1 = y k + m ( δ x = 1)
1
if m > 1.0, x k +1 = x k + ( δ y = 1)
m
if m  1.0, y k +1 = y k - m ( δ x = -1)
1
if m > 1.0, x k +1 = x k - ( δ y = -1)
m 14
Attributes of Output Primitives and Algorithms
DDA Algorithm
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));
}
}

DDA Algorithm (cont.)
 Advantage
 Does not calculate coordinates based on the
complete equation (uses offset method)
 Disadvantage
 Round-off errors are accumulated, thus line
diverges more and more from straight line
 Round-off operations take time
 Perform integer arithmetic by storing float as integers
in numerator and denominator and performing
integer arithmetic.

A section of a display screen where a straight-line segment is to be plotted, starting

from the pixel at column 10Attributes
on scan line 11.
of Output Primitives and Algorithms
17
A section of a display screen where a negative slope line segment is to be plotted,

starting from the pixel at column 50of on
Attributes scan
Output lineand
Primitives 50. 18
Algorithms
A section of the screen showing

Attributesaofpixel
Output in column
Primitives and xk on scan line yk that is to be
plotted along the path of a Algorithms
line segment with slope 0 < m < 1. 19
 Considering all examples in previous
slides:
 Which pixel should be choosen to be
displayed?
 Answer: The closest one
 Which one is closer?
 Answer: Calculate the distance to the line and
perform an efficiency test
 Fine, but how?
 Answer: Given by Jack Bresenham 1962
(programmer at IBM at that time)

Vertical Distances
Vertical distances between pixel positions and the line y

coordinate at sampling position xk + 1.and Algorithms
Attributes of Output Primitives
21
Bresenham’s Line Drawing
Algorithm
 Bresenham’s line drawing algorithm
(positive slope less than 1)
y = m (xk + 1)+b
dlower = y – yk = m (xk + 1)+b – yk
dupper = (yk + 1) – y = yk + 1 - m (xk + 1)-b
dlower – dupper = 2m(xk+1) – 2yk + 2b –1
decision parameter:
pk= Δx (dlower – dupper )
pk = 2Δy xk- 2Δx yk + c
sign of pk is the same as sign of dlower – dupper
Bresenham’s Line Drawing
Algorithm (cont.)
1. Input the two line endpoints and store the left
endpoint in (x0, y0).
2. Set the color for the frame-buffer position (x0, y0)
– i.e. plot the first point.
3. Calculate the constant 2Δy –Δx, and set the
starting value for the decision parameter as p0 =
2Δy –Δx.
4. At each xk along the line, from k=0, perform the
following test:
if pk<0, next point to plot is (xk + 1, yk) and pk+1 = pk + 2Δy
otherwise, next point to plot is (xk + 1, yk + 1 )
and pk+1 = pk + 2Δy- 2Δx
5. Repeat step 4 Δx - 1 times.

Example: Bresenham Line
Drawing
Example 6-1 Bresenham Line

Drawing
From HB p. 166-168

Example: Bresenham Line
Drawing (cont.)
From HB p. 166-168 25
Example: Bresenham Line Drawing
(cont.)
Pixel positions along the line path between endpoints (20, 10) and (30, 18), plotted
with Bresenham’s line algorithm. 26
 All algorithms above are given for a given
slope
 What about arbitrary slopes?
 Answer: Think about it (Hint: see next slide)

 To draw a line:
– For 1: step through x, increment y
3 2
– For 2: step through y, increment x
4 1 – For 3: step through y, decrement
5 8 x
6 7
– For 8: step through x, decrement
y
– For 4,5,6,7: swap end coordinates
& use the algorithm for the
symmetric quadrants

Circle Drawing Algorithms
 Properties of circle:
2 2 2
(x - x c ) + (y - y c ) = r
unit steps from x c - r to xc + r
2 2
y = yc ± r - (x c - x)

Circle Drawing Algorithms (cont.)
 Problems:
1. Complexity
2. Non-uniform spacing

 Solutions?:
1. Complexity: Adjust spacing by interchanging x
and y whenever absolute value of slope of circle
is greater than 1  increasing complexity
2. Non-uniform spacing: Using polar coordinates
31


Symmetry of a circle
.Calculation of a circle point (x, y) in one octant yields the circle points
shown for the other seven octants.
Using Symmetry
 Calculate points in section x = 0 to x = y
 In this section |slope| ≤ 1

 at x = 0  slope = 0
 at x = y  slope = -1
 Reduces computational complexity

Midpoint Circle Algorithm
 General procedure:
1. Calculate pixel positions for a circle with center at
(0, 0) (origin)
2. Move to proper position, i.e. add xc and yc
3. Use decision parameter to determine closest pixel
4. For other 7 octants use symmetry

Midpoint Circle Algorithm (cont.)
 In other terms:
 Principle of the midpoint algorithm
 Reason from octants of a circle centered in
(0,0), then find the remaining octants by
symmetry, then translate to (xc, yc).
 The circle function is the decision parameter.
 Calculate the circle function for the midpoint
between two pixels.

 Circle function:
2 2 2
𝑓 𝑐𝑖𝑟𝑐 ( 𝑥 , 𝑦)= 𝑥 + 𝑦 −𝑟
If any point (x,y) is inside the circle, fcirc(x,y)<0
If any point (x,y) is on the circle, fcirc(x,y)=0
If any point (x,y) is outside the circle, fcirc(x,y)>0

Midpoint
Candidate pixels at sampling position xk + 1 along a circular path

Midpoint Circle Algorithm (cont.):
Decision parameter 1
pk  f circ ( xk  1, y k  )
2
1 2
 ( xk  1)  ( y k  )  r 2
2
2
 If pk<0, midpoint is inside the circle and yk is
closer -> we select yk
 If pk>=0, midpoint is outside or on the circle and
yk-1 is closer -> we select yk-1

Midpoint Circle Algorithm (cont.):
Decision parameter
 We can find a recursive expression for the
next decision parameter as:
2 2
𝑝𝑘+1=𝑝𝑘 +2(𝑥𝑘+1)+(𝑦 −𝑦 )−(𝑦𝑘+1−𝑦𝑘)+1 𝑘+1 𝑘
 We can obtain the initial decision parameter
as:
5
𝑝 0= − 𝑟
4

1. Input radius r and circle center (xc, yc), then set the
coordinates for the first point on the circumference
of a circle centered on the origin as (x0, y0) = (0, r).
2. Calculate the initial value of the decision parameter

as p0 = 5/4 – r (1 – r if an integer)
3. At each xk, from k=0, perform the following test:

 if pk<0, next point to plot along the circle centered on (0,0) is
(xk+1, yk) and pk+1 = pk + 2 xk+1 + 1
 otherwise, next point to plot is (xk+ 1, yk - 1)
and pk+1 = pk + 2 xk+1 + 1 - 2 yk+1
41
where 2 xk+1 =Attributes
2 xk of+Output
2, and 2 yandk+1Algorithms
Primitives = 2 yk - 2
4. Determine symmetry points in the other

seven octants.
5. Move each calculated pixel position (x, y)
onto the circular path centered at (xc, yc)
and plot the coordinate values:
x = x + x c, y = y + y c
6. Repeat steps 3 through 5 until x >= y.

Example: Midpoint Circle
Drawing
From HB p. 175-177
Drawing (cont.)
From HB p. 175-177
Drawing (cont.)
Pixel positions (solid circles) along a circle path centered on the origin and with radius
r = 10, as calculated by the midpoint circle algorithm. Open (“hollow”) circles show the
45
symmetry positions in the firstAttributes
quadrant.
of Output Primitives and Algorithms
General Curve Functions
 Ellipses can be drawn similarly using a

modified midpoint algorithm.
 Similar algorithms can be used to display
polynomials, exponential functions,
trigonometric functions, conics,
probability distributions, etc.

Ellipse Generating Algorithms
 What is an ellipse?
 An elongated circle
 Describe as a modified circle whose
radius varies from a maximum value in
one direction to a minimum value in the
perpendicular direction
 Major and minor axis
 Two foci

An Ellipse
Generated about foci F1 and F2

An Ellipse (cont.)


An Ellipse (cont.)
Centered at (xc, yc) with semimajor axis rx and semiminor axis ry.
The Bounding Circle
and eccentric
Attributes of angle θ forandan ellipse with rx > ry .
Output Primitives
Algorithms 51
Midpoint Ellipse Algorithm
 General procedure (same like circle):
1. Determine curve positions for an ellipse with
center at (0, 0) (origin)
2. Move to proper position, i.e. add xc and yc
3. If required perform rotation
4. Use decision parameter to determine closest pixel
5. For other 3 quadrants use symmetry
 3 Quadrants? In circle 7 octants!
 So what is wrong?
 Warning: Symmetry for ellipse only in
quadrants

Symmetry of an Ellipse
Calculation of a point (x, y) in one quadrant yields the ellipse points shown
for the other three quadrants. 53
Ellipse Processing Regions
Over region 1, the magnitude of the ellipse slope is less than 1.0; over region 2, the
magnitude of the slope is greater than 1.0. 54
(cont.)
 Ellipse function:
f ellip se ( x , y )  r x  r y  r r
y
2 2
x
2 2 2 2
x y
If any point (x,y) is inside the ellipse, fellipse(x,y)<0
If any point (x,y) is on the ellipse, fellipse(x,y)=0
If any point (x,y) is outside the ellipse, fellipse(x,y)>0

Midpoint
Between candidate pixels at sampling position xk + 1 along an

elliptical path.
Midpoint (cont.)
Between candidate pixels at sampling position yk − 1 along an

57
elliptical path. Attributes of Output Primitives and Algorithms
(cont.): Decision Parameter
2 2 2
𝑝 1 𝑘+1=𝑝 1𝑘 +2 𝑟 ( 𝑥 𝑘 +1)+ 𝑟 +𝑟 ¿
𝑦 𝑦 𝑥
 We can obtain the initial decision parameter
as:
2 1 2
2
𝑝 1 0=𝑟 −𝑟 𝑟 𝑦 + 𝑟 𝑥
𝑦 𝑥
4

2 2 2
𝑝 2𝑘+1=𝑝 2𝑘 +2 𝑟 ( 𝑦 𝑘 −1)+𝑟 + 𝑟 ¿
𝑥 𝑥 𝑦
 We can obtain the initial decision parameter
as:
2
𝑝 20 =𝑟 𝑦 ¿
 Incrementing the decision parameter:
{
2 2
2𝑟 𝑦 𝑥 𝑘+1 +𝑟 𝑦 , if 𝑝 1𝑘 <0
𝑖𝑛𝑐𝑟𝑒𝑚𝑒𝑛𝑡=
2 𝑟 2𝑦 𝑥𝑘 +1+ 𝑟 2𝑦 −2 𝑟 2𝑥 𝑦 𝑘+1 , if 𝑝 1𝑘 ≥ 0

(cont.): Region 1-Region 2?
 When to move from region 1 to region 2?
 Answer: Decide on slope
 But how to calculate slope?
 Answer: dy 2ry2 x
 2
dx 2r yX
 At the boundary dy / dx = -1.0

 If 2r 2 x  2r 2 y move from region1 to
y x
region 2
Midpoint Ellipse Algorithm (cont.)
1. Input radii rx, ry and ellipse center (xc, yc), and obtain
the first point on the origin as (x0, y0) = (0, ry).
2. Calculate the initial value of the decision parameter in
1
region 1 as 𝑝1 0=𝑟 2𝑦 −𝑟 2𝑥 𝑟 𝑦 + 𝑟 2𝑥
4
3. At each xk in region 1, from k=0, perform the following
test:
 if p1k<0, next p
point
1k 1 to pplot
1k along
2ry2 xk the ellipse
r 2 centered on (0,0) is
1 y
(xk+1, yk) and
 otherwise, next point to plot is (xk+ 1, y - 1)
p1k 1  p1k  2ry2 xk k1  2rx2 yk 1  ry2
and
2ry2 xk 1  2ry2 xk  2ry2 , 2rx2 yk 1  2rx2 yk  2rX2
with
and continue until y
2 r 2
x  2 r 2
x y
(cont.)
4. Calculate the initial value of the decision parameter in
( )2 +𝑟 ( 𝑦 −1) +𝑟 𝑟
2
region 1 as 2 1 2 2 2 2
𝑝 20=𝑟 𝑦 𝑥 0 + 𝑥 0 𝑥 𝑦
(x0, y0) is last calculated point from region 1
5. At each yk position in region 2, starting at k=0,

perform the following test:
 if p2k>0, next point to plot along the ellipse centered on (0,0) is (xk,
p 2 k 1  p 2 k  rx2 (1  2( yk  1))
yk-1) and
 otherwise, next point to plot is (xk+ 1, yk - 1)
andp 2  p 2  2r 2 x  rx2 (1  2( yk  1))
k 1 k y k 1
and continue until y = 0

(cont.)
6. Determine symmetry points in the other three
quadrants.
7. Move each calculated pixel position (x, y) onto the

elliptical path centered at (xc, yc) and plot the
coordinate values: x = x + x c, y = y + y c

Example: Midpoint Ellipse
Drawing
From HB p. 182-184
Drawing (cont.)
From HB p. 182-184

Drawing (cont.)
From HB p. 182-184
Drawing (cont.)
Pixel positions along an elliptical path centered on the origin with rx = 8 and ry = 6,
using the midpoint algorithm Attributes
to calculate
of Outputlocations within
Primitives and the first quadrant
Algorithms
68
Fill-Area Algorithms
 Standard output primitives – solid, pattern,

hollow
 Fill primitive – solid circle, rectangle, triangle, …
 Two ways of filling:
 Find where each scanline overlaps area (scan-line fill)
 Start from interior position and paint outward until
boundary is reached
 Used in general purpose packages and paint
programs.

Area Filling
 General idea:
1. Determine boundary intersection
2. Fill interior

Scan-line Polygon-fill Algorithm
 For convex polygons.

 Determine the intersection positions of the
boundaries of the fill region with the screen
scan lines.
A B
y
F C
E D

(cont.)
 For convex polygons.
 Pixel positions between pairs of intersections
between scan line and edges are filled with
color, including the intersection pixels.
A B
y
F C
E D

(cont.)
 For concave polygons.
 Scan line may intersect more than once:
 Intersects an even number of edges
 Even number of intersection vertices yields to pairs
of intersections, which can be filled as previously
A C
B
y D
G
F E

(cont.)
 Intersects an even number of edges
 Even number of intersection vertices yields to pairs
of intersections, which can be filled as previously
A C
y B D
G
F E

(cont.)
 Intersects an odd number of edges
 Not all pairs are interior: (3,4) is not interior
A B C
y 1 2 3 4 5
G D
F E

(cont.)
Interior pixels along aAttributes

scan ofline passing
Output through a polygon fill area.
Primitives and
Algorithms 76
(cont.)
Intersection points along scan lines that intersect polygon vertices. Scan line y
generates an odd number of intersections, but scan line y’ generates an even number
of intersections that can be paired to identify correctly the interior pixel spans. 77
(cont.)
 Generate 2 intersections when at a local
minimum, else generate only one intersection.
 Algorithm to determine whether to generate one
intersection or 2 intersections.
 If the y-coordinate is monotonically increasing or
decreasing, decrease the number of vertices by
shortening the edge.
 If it is not monotonically increasing or decreasing, leave
the number of vertices as it is.

(cont.)
scan line
y+1
y
y decreasing:
y increasing:
y-1 decrease by 1
decrease by 1
The y-coordinate of the upper The y-coordinate of the upper

endpoint of the current edge endpoint of the next edge
is decreased by 1. is decreased by 1.

(cont.)
 In previous slide edges are shortened and
vertices are counted only once because
edges are adjusted
 But how to do it?
 Answer: Using coherence properties

(cont.)
 Coherence properties: Certain properties of one
part of the scene related to properties of other
parts, e.g. slope
 Sequential fill algorithm with incremental
coordinate calculations
y k +1 - y k Δy
m = =
x k +1 - x k Δx
y k +1 - y k = 1
1 Δx
x k +1 = x k + = xk +
m Δy 81
Using Coherence Properties
Two successive scan lines intersecting a polygon boundary. At both

positions same slopes

Fill-Area Algorithms
 Polygon fill-in algorithm:
1. store the edges in a sorted edge table where each entry
corresponds to a scan line (sorted on the smallest y
value on each edge)
For sorting, e.g. Bucket sort
2. shorten the edges that have vertex-intersection issues
by processing scan lines from bottom of polygon to top
(active edge list)
3. for each scan line, fill-in the pixel spans for each pair of
x intercepts.

Example: Fill-Area Algorithms
__
A polygon and its sorted edge table, with edge DC shortened by one unit in
the y direction.
Other Fill-Area Algorithms
 For areas with irregular boundaries
 Boundary-fill algorithm
start at an inside position and paint color point by
point until reaching the boundary (of different
color):
void boundaryFill4 (int x, int y, int fillColor, int borderColor)
{
int interiorColor;
/* Set current color to fillColor, then perform following oprations. */
getPixel (x, y, interiorColor);
if ((interiorColor != borderColor) && (interiorColor != fillColor)) {
setPixel (x, y); // Set color of pixel to fillColor.
boundaryFill4 (x + 1, y , fillColor, borderColor);
boundaryFill4 (x - 1, y , fillColor, borderColor);
boundaryFill4 (x , y + 1, fillColor, borderColor);
boundaryFill4 (x , y - 1, fillColor, borderColor)
}
85
} Attributes of Output Primitives and Algorithms
Boundary-Fill Algorithm
 General idea:
1. Start at position (x, y)
2. Test color of neighboring pixels
3. If neighbor pixel’s color is not boundary color, change

color
4. Proceed until all pixels processed

Neighbors?
(a) 4-connected area

(b) 8-connected area
Hollow circles represent pixels to be tested from the current test position, shown as a solid
color.
Boundary Fill: 4-connected vs. 8-
connected

Start point
 4-connected  8-connected

Implementing Boundary-Fill
Boundary fill across pixel spans for a 4-connected area:

(a) Initial scan line with a filled pixel span, showing the position of the initial point (hollow) and the
stacked positions for pixel spans on adjacent scan lines.
(b) Filled pixel span on the first scan line above the initial scan line and the current contents of the
stack.
(c) Filled pixel spans on the first two scan lines above the initial scan line and the current contents
of the stack.
(d) Completed pixel spans for the upper-right portion of the defined region and the remaining 89
stacked positions to be processed.Attributes of Output Primitives and Algorithms
Other Fill-Area Algorithms (cont.)
 For areas with irregular boundaries
 Flood-fill algorithm
start at an inside position and reassign all pixel
values currently set to a given interior color with
the desired fill color.
void floodFill4 (int x, int y, int fillColor, int interiorColor)
{
int color;
/* Set current color to fillColor, then perform following operations. */
getPixel (x, y, color);
if (color = interiorColor) {
setPixel (x, y); // Set color of pixel to fillColor.
floodFill4 (x + 1, y, fillColor, interiorColor);
floodFill4 (x - 1, y, fillColor, interiorColor);
floodFill4 (x, y + 1, fillColor, interiorColor);
floodFill4 (x, y - 1, fillColor, interiorColor)
}
}
Flood-Fill Algorithm
 Set pixel to fill color value until bounds.

 An interior point (x, y)
 A boundary color
 A fill color
 
Fill color
Boundary color

Interior point (x, y)

Algorithms 91
Implementation of Antialiasing
 (Remember) Aliasing: Information loss due to
low-frequency sampling (undersampling)
 How to avoid it?
 Answer: Using Nyquist sampling
frequency/rate
 or
 Answer: Using Nyquist sampling interval

Nyquist?
 Harry Nyquist: 7. February 1889 in Nilsby,
Sweden; † 4. April 1976 in Harlingen, Texas
 Claude Elwood Shannon: 30. April 1916 in
Petoskey, Michigan; † 24. Februar 2001 in
Medford, Massachusetts
 Nyquist-Shannon-Sample Theorem: Set the
sampling frequency to at least twice that of
the highest frequency occurring in the object
 Nyquist sampling frequency: fs = 2fmax
 Nyquist sampling interval: ∆x = ∆xcycle / 2

Sampling
Sampling the periodic shape in (a) at the indicated positions produces the
aliased lower-frequency representation in (b). 94
Antialiasing Methods
1. Supersampling (postfiltering): Sample at
hşgh resolution (at subpixel level) but show
on lower resolution
2. Area sampling (prefiltering): Antialiasing by

computing overlap areas
3. Pixel phasing (for raster objects): Shift

display location of pixel areas

Supersampling
 General idea (for straight line segments):
1. Divide each pixel into a number subpixels
2. Count number of subpixels overlapping the line

path
3. Set intensity of each pixel to a value proportional

to subpixel count

Example: Supersampling
Supersampling subpixel positions along a straight-line segment whose left

endpoint is at screen coordinates (10, 20).
97
Weighting Subpixels
 Multiply each pixel with a weighted mask
  
1 2 1
  
2 4 2
  
1 2 1

Subpixel

weighting

mask
Areasampling
 General idea (for straight line segments):
 Set pixel intensities proportional to the area of

overlap of the pixel with the finite-width line

Algorithms 99
Example: Areas Sampling
Supersampling subpixel positions in relation to the interior of a line of

finite width. Attributes of Output Primitives and Algorithms 100
Filtering Techniques
 Similar to weighting but here continuous
weighting surface (filter function)
 Multiply each pixel with the function
 What kind of function?
 Answer: Next slide

Common Filter Functions
Filters used to antialias line paths. The volume of each filter is normalized to
1.0, and the height gives the relative weight at any subpixel position.
102
Next Lecture
Interactive Input Methods

References
 Donald Hearn, M. Pauline Baker, Warren R.
Carithers, “Computer Graphics with OpenGL, 4th
Edition”; Pearson, 2011
 Sumanta Guha, “Computer Graphics Through
OpenGL: From Theory to Experiments”, CRC Press,
2010
 Edward Angel, “Interactive Computer Graphics. A
Top-Down Approach Using OpenGL”, Addison-
Wesley, 2005

CG Unit-1(output primitives)

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

CG Unit-1(output primitives)

Uploaded by

Copyright:

Available Formats

CSE 411

Lecture #4 Attributes of Output Primitives and Algorithms

 Line drawing algorithms

Attributes of Output Primitives and Algorithms 2

Attributes of Output Primitives and Algorithms 4

Attributes of Output Primitives and Algorithms 5

Attributes of Output Primitives and

Attributes of Output Primitives and Algorithms 8

Attributes of Output Primitives and Algorithms 9

Attributes of Output Primitives and Algorithms 10

Attributes of Output Primitives and Algorithms 11

Attributes of Output Primitives and Algorithms 12

Straight-line segment with five sampling positions along the x axis

 DDA (Digital Differential Analyzer)

corresponding y is calculated and rounded

Attributes of Output Primitives and Algorithms 15

Attributes of Output Primitives and Algorithms 16

A section of a display screen where a straight-line segment is to be plotted, starting

A section of a display screen where a negative slope line segment is to be plotted,

A section of the screen showing

Attributes of Output Primitives and Algorithms 20

Vertical distances between pixel positions and the line y

Attributes of Output Primitives and Algorithms 23

Example 6-1 Bresenham Line

Attributes of Output Primitives and Algorithms 24

Attributes of Output Primitives and Algorithms 27

Attributes of Output Primitives and Algorithms 28

Attributes of Output Primitives and Algorithms 29

Attributes of Output Primitives and Algorithms 30

Attributes of Output Primitives and Algorithms 32

 In this section |slope| ≤ 1

 Reduces computational complexity

Attributes of Output Primitives and Algorithms 34

Attributes of Output Primitives and Algorithms 35

Attributes of Output Primitives and Algorithms 36

If any point (x,y) is inside the circle, fcirc(x,y)<0

If any point (x,y) is on the circle, fcirc(x,y)=0

If any point (x,y) is outside the circle, fcirc(x,y)>0

Attributes of Output Primitives and Algorithms 37

Candidate pixels at sampling position xk + 1 along a circular path

Attributes of Output Primitives and Algorithms 39

Attributes of Output Primitives and Algorithms 40

2. Calculate the initial value of the decision parameter

3. At each xk, from k=0, perform the following test:

4. Determine symmetry points in the other

Attributes of Output Primitives and Algorithms 42

 Ellipses can be drawn similarly using a

Attributes of Output Primitives and Algorithms 46

Attributes of Output Primitives and Algorithms 47

Generated about foci F1 and F2

Attributes of Output Primitives and Algorithms 49

Attributes of Output Primitives and Algorithms 52

If any point (x,y) is inside the ellipse, fellipse(x,y)<0

If any point (x,y) is on the ellipse, fellipse(x,y)=0

If any point (x,y) is outside the ellipse, fellipse(x,y)>0

Attributes of Output Primitives and Algorithms 55

Between candidate pixels at sampling position xk + 1 along an

Between candidate pixels at sampling position yk − 1 along an

Attributes of Output Primitives and Algorithms 58

Attributes of Output Primitives and Algorithms 60

 At the boundary dy / dx = -1.0

(x0, y0) is last calculated point from region 1

5. At each yk position in region 2, starting at k=0,

and continue until y = 0