From
Vertices to Fragments:
Rasterization
Reading Assignment: Chapter 7
Frame Buffer
• Special memory where pixel colors are stored.
System Bus
CPU Main Memory Graphics Card
-- Graphics
Processing Unit
(GPU)
-- Frame Buffer
The Graphics Pipeline
Modeling
Transformations
Illumination
(Shading)
Viewing Transformation
(Perspective / Orthographic)
Clipping
Projection
(to Screen Space)
Scan Conversion
(Rasterization)
Visibility / Display
Modeling Transformations
Modeling
Transformations
• 3D models defined in their own
Illumination
coordinate system (object space)
(Shading)
• Modeling transforms orient the
Viewing Transformation
(Perspective / Orthographic) models within a common
coordinate frame (world space)
Clipping
Projection
(to Screen Space)
Scan Conversion
(Rasterization)
Object space World space
Visibility / Display
Illumination (Shading) (Lighting)
Modeling • Vertices lit (shaded) according to
Transformations
material properties, surface
Illumination
(Shading) properties (normal) and light sources
Viewing Transformation • Local lighting model
(Perspective / Orthographic) (Diffuse, Ambient, Phong, etc.)
Clipping
Projection
(to Screen Space)
Scan Conversion
(Rasterization)
Visibility / Display
Viewing Transformation
Modeling
Transformations
• Maps world space to eye space
Illumination • Viewing position is transformed
(Shading)
to origin & direction is oriented
Viewing Transformation
(Perspective / Orthographic) along some axis (usually z)
Clipping
Eye space
Projection
(to Screen Space)
Scan Conversion
(Rasterization)
Visibility / Display World space
Clipping
Modeling • Transform to Normalized Device
Transformations
Coordinates (NDC)
Illumination
(Shading)
Viewing Transformation
(Perspective / Orthographic)
Clipping Eye space NDC
• Portions of the object
Projection
(to Screen Space) outside the view
volume
Scan Conversion
(Rasterization) (view frustum)
are removed
Visibility / Display
Projection
Modeling
Transformations
• The objects are projected to the
Illumination
2D image place (screen space)
(Shading)
Viewing Transformation
(Perspective / Orthographic)
Clipping NDC Screen Space
Projection
(to Screen Space)
Scan Conversion
(Rasterization)
Visibility / Display
Scan Conversion (Rasterization)
Modeling
Transformations
• Rasterizes objects into pixels
Illumination • Interpolate values as we go
(Shading)
(color, depth, etc.)
Viewing Transformation
(Perspective / Orthographic)
Clipping
Projection
(to Screen Space)
Scan Conversion
(Rasterization)
Visibility / Display
Visibility / Display
Modeling
Transformations
• Each pixel remembers the
Illumination
closest object (depth buffer)
(Shading)
Viewing Transformation
(Perspective / Orthographic)
Clipping • Almost every step in the
Projection
graphics pipeline involves a
(to Screen Space) change of coordinate system.
Scan Conversion Transformations are central to
(Rasterization)
understanding 3D computer
Visibility / Display
graphics.
From Geometry to Display
Rasterization
• How to draw primitives?
– Convert from geometric definition to pixels
– Rasterization = selecting the pixels
• Will be done frequently
• Must be fast:
• use integer arithmetic
• use addition instead of multiplication
Next
• Line-drawing algorithm
– naïve algorithm
– Bresenham algorithm
• Circle-drawing algorithm
– naïve algorithm
– Bresenham algorithm
Scan Converting 2D Line Segments
• Given:
– Segment endpoints (integers x1, y1; x2, y2)
• Identify:
– Set of pixels (x, y) to display for segment
(x2, y2)
(x1, y1)
Line Rasterization Requirements
• Transform continuous primitive into
discrete samples
• Uniform thickness & brightness
• Continuous appearance
• No gaps (x2, y2)
• Accuracy
• Speed
(x1, y1)
Simple Line
Based on slope-intercept (x2, y2)
algorithm from algebra:
y = mx + h h
Simple approach:
increment x, solve for y
(x1, y1)
Floating point arithmetic
required
Naive Line Rasterization Algorithm
• Simply compute y as a function of x
– Conceptually: move vertical scan line from x1 to x2
– What is the expression of y as function of x?
– Set pixel (x, round (y))
x − x1
y = y1 + ( y 2 − y1)
(x2, y2) x 2 − x1
= y1 + m( x − x1)
y
dy
m=
dx
(x1, y1)
Efficiency
• Computing y value is expensive
y = y1 + m( x − x1)
• Observe: y += m at each x step (m = dy/dx)
(x2, y2)
y(x+1)
y(x+1) m
y(x)
y(x)
x x+1
(x1, y1)
x x+1
Does it Work?
• It seems to work okay for
lines with a slope of 1 or less
• Doesn’t work well for lines
with slope greater than 1 –
lines become more
discontinuous in appearance
and we must add more than 1
pixel per column to make it
work.
• Solution? - use symmetry.
Modify Algorithm per Octant
OR, increment along x-axis if dy<dx else increment along y-axis
Bresenham's Algorithm
• Select pixel vertically closest to line segment
– intuitive, efficient,
pixel center always within 0.5 vertically
• Same answer as naive approach
Bresenham's Algorithm
• Observation:
– If we're at pixel P (xp, yp), the next pixel must be
either E (xp+1, yp) or NE (xp+1, yp+1)
– Why?
NE
P
E
Bresenham Step
• Which pixel to choose: E or NE?
• Error associated with a pixel:
NE
Error pixel NE
Error pixel E
E
• Pick the pixel with error < ½
• The sum of the 2 errors is _____
Bresenham Step
• How to compute the error?
• Line defined as y = mx + h
• Vertical distance from line to pixel (x, y):
e(x, y) = mx+h-y e <0
– negative if pixel above L e =0
– zero on L
e >0
– positive below L
L
e is called the error function.
Bresenham's Algorithm
• How to compute the error?
• Error Function: e’
e(x, y) = mx+h-y e
• Initialize error term e = 0
• On each iteration:
update x: x' = x+1
update e: e' = e + m
if (e ≤ 0.5): y' = y (choose pixel E)
if (e > 0.5): y' = y +1 (choose pixel NE) e' = e - 1
Summary of Bresenham
• Initialize e = 0
• for (x = x1; x ≤ x2; x++)
NE
– plot (x,y)
– update x, y, e
E
• Generalize to handle all eight octants using symmetry
• Still using floating point! e’ = e + m
• Can we use only integer arithmetic?
Bresenham with no Floating Point
y −y dy
• Error function e(x, y) = mx+h-y, m = 2 1 =
x2 − x1 dx
• At selected pixel (x,y): e(x, y) <= ½
2mx + 2h – 2y – 1 <= 0
2x·dy + 2h·dx – 2y·dx – dx <=0
NE
• If e <= 0 stay horizontal
E
If e > 0 move up
• Update for next pixel:
– If stay horizontal: x+=1, e += 2dy
– If move up: x+=1, y+=1, e += 2(dy –dx)
• Algorithm = single instruction on graphics chips!
Line Anti-aliasing
• Note: brightness can vary with slope √2 * L
– What is the maximum variation?
• How could we compensate for this?
L
– Answer: antialiasing
How do we remove aliasing?
• Solution 1 - Area Sampling:
– Treat line as a single-pixel wide rectangle
– Color pixels according to the percentage of each pixel
that is “covered” by the rectangle
How do we remove aliasing?
• Solution 2 – Super Sampling:
– Divide pixel up into “sub-pixels”: 2x 2, 3x3, 4x4, etc.
– Pixel color is the average of its sub-pixel colors
– Easy to implement (in SW and HW). But expensive.
No antialiasing Antialiasing (2×2 super-sampling)
OpenGL Antialiasing
• Can enable separately for points, lines, or polygons
• For points and lines:
glEnable(GL_POINT_SMOOTH);
glEnable(GL_LINE_SMOOTH);
• For triangles:
glEnable(GL_POLYGON_SMOOTH);
Next:
• Circle Rasterization
Circle Rasterization
• Generate pixels for 2nd octant only
• Slope progresses from 0 → –1
• Analog of Bresenham
Segment Algorithm
Circle Rasterization: Naïve algorithm
• Circle equation: x2+y2-R2 = 0
• Simple algorithm:
for x = xmin to xmax
y = sqrt(R*R - x*x)
draw pixel(x,y)
• Work by octants and use symmetry
Circle Rasterization: Bresenham
• Choice between two + + +
pixels, E and SE + E
SE
• Mid-point algorithm:
– If the midpoint between
pixels is inside the circle,
– E is closer, draw E
R
– If the midpoint is outside,
SE is closer, draw SE
Circle Rasterization: Bresenham
• In/Out decision function: +++
+ E
d(x, y) = x2 + y2 – R2
SE
• Compute d at midpoint btw E, SE
R
If the last pixel drawn is (x,y),
then E = (x+1, y), and SE = (x+1, y-1).
Hence, the midpoint = (x+1, y-1/2).
e(x,y) = (x+1)2 + (y - 1/2)2 - R2
e < 0: draw E
e ≥ 0: draw SE
Circle Rasterization: Bresenham
+++
• Error Function: + E
SE
e(x, y) = (x+1)2 + (y - 1/2)2 - R2
• On each iteration: R
update x: x' = x+1
update e: e' = e + 2x + 3
if (e < 0): y' = y (choose E)
if (e ≥ 0): y' = y - 1 (choose SE), e' = e’-2y+2
• Two multiplications, two additions per pixel
• Can you do better?
Circle Rasterization: Better Bresenham
• On each iteration:
update x: x' = x+1
update e: e' = e + 2x + 3
if (e < 0): y' = y (choose E)
if (e ≥ 0): y' = y - 1 (choose SE), e' = e’-2y+2
• The error is not linear
• However, what gets added to the error is
• Keep Δx and Δy. At each step:
Δx += 2, Δy += -2
e += Δx, and if y gets decremented, e += Δy
• 4 additions per pixel
Extensions to Other Functions
• Midpoint algorithm easy to extend to any curve
defined by: f(x,y) = 0
• If the curve is polynomial, can be reduced to only
additions using n-order differences
2D Scan Conversion
• Geometric primitive
– 2D: point, line, polygon, circle...
– 3D: point, line, polyhedron, sphere...
• Primitives are continuous; screen is discrete
Use line rasterization
• Compute the boundary pixels
Scan-line Rasterization
• Compute the boundary pixels
• Fill the spans
• Requires some initial setup to prepare
For modern graphics cards
• Triangles are usually very small
• Setup cost troublesome
• Brute force is tractable
Modern Rasterization
For every triangle
ComputeProjection
Compute bbox, clip bbox to screen limits
For all pixels in bbox
If pixel in triangle
Framebuffer[x,y]=triangleColor
