Now Playing:

California Stars
Billy Bragg & Wilco
from Mermaid Avenue
Released June 23, 1998
 Vertex Processing:
Clipping

Rick Skarbez, Instructor

COMP 575
October 2, 2007
Some slides and images courtesy Jeremy Wendt (2005)
 Announcements

• Assignment 2 is out today

• Due next Tuesday by the end of class
 Last Time

• Reviewed the OpenGL pipeline

• Discussed classical viewing and presented a
taxonomy of different views
• Talked about how projections and viewport
transforms are used in OpenGL
 Today

• Discuss clipping
• Points

• Lines

• Polygons
 Rendering Pipeline

• OpenGL rendering works like an assembly

line
• Each stage of the pipeline performs a distinct
function on the data flowing by

• Each stage is applied to every vertex to

determine its contribution to output pixels

Geometry Vertex Fragment

Rasterizer Pixels
(Vertices) Processing Processing
 Vertex Processing
Vertices

Modelview
Transform

Projection
Transform
Vertex
Lighting
Processing
Viewport
Transform

Clipping & Primitive Assembly

Determining What’s in
the Viewport
• Not all primitives map to inside the
viewport
• Some are entirely outside

• Need to cull

• Some are partially inside and partially outside

• Need to clip

• There must be NO DIFFERENCE to the final

rendered image
 Why Clip?
• Rasterization is very expensive
• Approximately linear with number of fragments
created

• Math and logic per pixel

• If we only rasterize what is actually

viewable, we can save a lot
• A few operations now can save many later
 Clipping Primitives

• Different primitives can be handled in

different ways
• Points

• Lines

• Polygons
 Point Clipping
• This one is easy
• How to determine if a point (x, y, z) is in the
viewing volume (xnear, ynear, znear), (xfar, yfar,
zfar)?
• Who wants to tell me how?

• if ((x > xfar II x < xnear) ||

(y > yfar II y < ynear) ||
(z > zfar II z < znear))
cull the point
else
keep it
 Line Clipping
• What happens when a line passes out of the
viewing volume/plane?
• Part is visible, part is not

• Need to find the entry/exit points, and

shorten the line
• The shortened line is what gets passed to
rasterization
Line Clipping Example
• Let’s do 2D first (x1, y1)
• Clip a line against 1 edge C
(x’, y’) ???
of the viewport
A D
• What do we know?
• Similar triangles
• A/B=C/D (x2, y2)
•
B = (x2 - x1) B
•
A = (y2 - y1)
•
C = (y1 - ymax)
➡D = BC / A
➡(x’, y’) = (x1 - D, ymax)
 Line Clipping
• The other cases are handled similarly
• The algorithm extends easily to 3D
• The problem?
• Too expensive! (these numbers are for 2D)
• 3 floating point subtracts
• 2 floating point multiplies
• 1 floating point divide
• 4 times! (once for each edge)
• We need to do better
 Cohen-Sutherland
Line Clipping
• Split plane into 9 regions 1001 1000 1010

• Assign each a 4-bit tag

• (above, below, right, left) 0001 0000
Viewport
0010

• Assign each endpoint a

tag 0101 0100 0100
 Cohen-Sutherland
• Algorithm: Line Clipping
1. if (tag1 == tag2 == 0000)
accept the line 1001 1000 1010

2. if ((tag1 & tag2) != 0)

reject the line
0001 0000 0010
3. Clip the line against an edge Viewport
(where both bits are
nonzero)
0101 0100 0110
4. Assign the new vertex a 4-
bit value
N.B.:
N.B.: &
& is
is the
the bitwise
bitwise
5. Return to 1 AND
AND operator
 Cohen-Sutherland
Example
• What are the vertex codes for these lines?
 Cohen-Sutherland
Line Clipping
• Lets us eliminate many edge clips early
• Extends easily to 3D
• 27 regions

• 6 bits

• Similar triangles still works in 3D

• Just have to do it for 2 sets of similar triangles
 Liang-Barsky
Line Clipping
• Consider the parametric definition of a line:
• x = x1 + u∆x

• y = y1 + u∆y

• ∆x = (x2 - x1), ∆y = (y2 - y1), 0 ≤ (u, v) ≤ 1

• What if we could find the range for u and v in

which both x and y are inside the viewport?
 Liang-Barsky
Line Clipping
• Mathematically, this means
• xmin ≤ x1 + u∆x ≤ xmax

• ymin ≤ y1 + u∆y ≤ ymax

• Rearranging, we get
• -u∆x ≤ (x1 - xmin)
• u∆x ≤ (xmax - x1)
• -v∆y ≤ (y1 - ymin)
• v∆y ≤ (ymax - y1)
• In general: u * pk ≤ qk
 Liang-Barsky
Line Clipping
• Cases:
1. pk = 0

• Line is parallel to boundaries

• If for the same k, qk < 0, reject
• Else, accept
• pk < 0
1. Line starts outside this boundary
• rk = qk / pk
• u1 = max(0, rk, u1)
 Liang-Barsky
Line Clipping
• Cases: (cont’d)
3. pk > 0
• Line starts outside this boundary
• rk = qk / pk
• u2 = min(1, rk, u2)
• If u1 > u2, the line is completely outside
 Liang-Barsky
Line Clipping

• Also extends to 3D
• Just add equations for z = z1 + u∆z
➡ 2 more p’s and q’s
 Liang-Barsky
Line Clipping
• Inmore
most cases, Liang-Barsky is slightly
efficient
• According to the Hearn-Baker textbook
• Avoids multiple shortenings of line segments

• However, Cohen-Sutherland is much easier

to understand (I think)
• An important issue if you’re actually
implementing
 Nicholl-Lee-Nicholl
Line Clipping
• This is a theoretically optimal clipping
algorithm (at least in 2D)
• However, it only works well in 2D

• More complicated than the others

• Just do an overview here
 Nicholl-Lee-Nicholl
Line Clipping
• Partition the region based Case 1
T
on the first point (p1):
p1
• Case 1: p 1 inside region L R
• Case 2: p 1 across edge
•p Case 3: p
1
1 across corner B

Case 2 LT
T L
Case 3 L
T TR p1 L LR
L
LB TB LB
 Nicholl-Lee-Nicholl
Line Clipping
• Can use symmetry to handle all other cases
• “Algorithm” (really just a sketch):
• Find slopes of the line and the 4 region bounding
lines

• Determine what region p2 is in

• If not in a labeled region, discard

• If in a labeled region, clip against the

indicated sides
A Note on Redundancy
• Why am I presenting multiple forms of
clipping?
• Why do you learn multiple sorts?
•Fastest can be harder to understand / implement
•Best for the general case may not be for the
specific case
• Bubble sort is really great on mostly sorted
lists

• “History repeats itself”

• You may need to use a similar algorithm for
something else; grab the closest match
Polygon Inside/Outside

• Polygons have a distinct inside and outside

• How do you tell, just from a list of
vertices/edges?
• Even/odd

• Winding number
Polygon Inside/Outside:
Even / Odd
• Count edge crossings
• If the number is even, that area is outside

• If odd, it is inside

2 2
1
0 1 3
0 1 2
4
2 1 3

2
Polygon Inside/Outside:
Winding Number
• Each line segment is assigned a direction by
walking around the edges in some pre-
defined order
• OpenGL walks counter-clockwise

• Count right->left edge crossings and

left->right edge crossings
• If equal, the point is outside
 Polygon Clipping
• Polygons are just composed of lines. Why
do we need to treat them differently?
• Need to keep track of what is inside NOTE:

Lines Polygons
 Polygon Clipping
• Many tricky bits
• Maintaining inside/outside

• Introduces variable number of vertices

• Need to handle screen corners correctly

Sutherland-Hodgeman
Polygon Clipping
• Simplify via separation
• Clip the entire polygon with one edge
• Clip the output polygon against the next edge

• Repeat for all edges

• Extends easily to 3D (6 edges instead of 4)

• Can create intermediate vertices that get
thrown out later
 Sutherland-Hodgeman
Polygon Clipping
• Example 1:

Out -> In
In -> In In -> Out Out -> Out
Save new clip vertex
Save ending vertex Save new clip vertex Save nothing
and ending vertex
 Sutherland-Hodgeman
Polygon Clipping
• Example 2: NOTE:

Clip Clip Clip Clip

Start
Left Right Bottom Top
 Weiler-Atherton
Polygon Clipping
• When using Sutherland-Hodgeman, concavities
can end up linked

Remember
this?

• A different clipping algorithm, the Weiler-

Atherton algorithm, creates separate polygons
 Weiler-Atherton
Polygon Clipping
• Example:

Follow clip edge until

Out -> In In -> Out
In -> In (a) new crossing found
Add clip vertex Add clip vertex
Add end vertex (b) reach vertex already
Add end vertex Cache old direction
added
 Weiler-Atherton
Polygon Clipping
• Example (cont’d):

Continue from Follow clip edge until

Out -> In In -> Out
cached vertex and (a) new crossing found
Add clip vertex Add clip vertex
direction (b) reach vertex already
Add end vertex Cache old direction
added
 Weiler-Atherton
Polygon Clipping
• Example (cont’d):

Final Result:
Continue from
Nothing added
2 unconnected
cached vertex and polygons
Finished
direction
 Weiler-Atherton
Polygon Clipping
• Difficulties:
• What if the polygon recrosses
an edge?

• How big should your cache be?

• Geometry step must be able to create new

polygons

• Not 1 in, 1 out

 Done with Clipping
• Point Clipping (really just culling)
• Easy, just do inequalities

• Line Clipping
• Cohen-Sutherland
Any
Any Questions?
Questions?
• Liang-Barsky

• Nicholl-Lee-Nicholl

• Polygon Clipping
• Sutherland-Hodgeman

• Weiler-Atherton
 Next Time

• Moving on down the pipeline

• Rasterization
• Line drawing