lecture04-Clipping.ppt

CSE 409:

Computer Graphics

Clipping

Dr. M. Mahfuzul Islam

Dr. M. Mahfuzul Islam

Dr. M. Mahfuzul Islam

Dr. M. Mahfuzul Islam

Why clip?

We don’t want to waste time rendering objects that are

We don’t want to waste time rendering objects that are

outside the

outside the

viewing window (or clipping window)

viewing window (or clipping window)

We don’t want to waste time rendering objects that are

We don’t want to waste time rendering objects that are

outside the

What is clipping?

Analytically calculating the portions of primitives

Analytically calculating the portions of primitives

within the view window

within the view window

Analytically calculating the portions of primitives

Analytically calculating the portions of primitives

within the view window

Clip to what?

View Window

Eye position (focal point)

Right

Back _Towards

Up

Why Clip?

Bad idea to rasterize outside of framebuffer

Bad idea to rasterize outside of framebuffer

bounds

bounds

Also, don’t waste time scan converting pixels

Also, don’t waste time scan converting pixels

outside window

outside window

Bad idea to rasterize outside of framebuffer

Bad idea to rasterize outside of framebuffer

bounds

bounds

Also, don’t waste time scan converting pixels

Also, don’t waste time scan converting pixels

outside window

Clipping

The naïve approach to clipping lines:

The naïve approach to clipping lines:

for each line segment

for each line segment

for each edge of view_windowfor each edge of view_window

find intersection pointfind intersection point

pick “nearest” pointpick “nearest” point

if anything is left, draw itif anything is left, draw it

What do we mean by “nearest”?

What do we mean by “nearest”?

How can we optimize this?

How can we optimize this?

The naïve approach to clipping lines:

The naïve approach to clipping lines:

for each line segment

for each line segment

for each edge of view_windowfor each edge of view_window

find intersection pointfind intersection point

pick “nearest” pointpick “nearest” point

if anything is left, draw itif anything is left, draw it

What do we mean by “nearest”?

What do we mean by “nearest”?

How can we optimize this?

How can we optimize this?

A

B

C

Trivial Accepts

Big optimization: trivial accept/rejects

Big optimization: trivial accept/rejects

How can we quickly determine whether a line segment is

How can we quickly determine whether a line segment is

entirely inside the view window?

entirely inside the view window?

A: test both endpoints.

A: test both endpoints.

Big optimization: trivial accept/rejects

Big optimization: trivial accept/rejects

How can we quickly determine whether a line segment is

How can we quickly determine whether a line segment is

entirely inside the view window?

entirely inside the view window?

A: test both endpoints.

Trivial Rejects

How can we know a line is outside view window?

How can we know a line is outside view window?

A: if both endpoints on wrong side of

A: if both endpoints on wrong side of

same

same

edge,

edge,

can trivially reject line

can trivially reject line

How can we know a line is outside view window?

How can we know a line is outside view window?

A: if both endpoints on wrong side of

A: if both endpoints on wrong side of

same

same

edge,

edge,

can trivially reject line

Clipping Lines To Viewport

Combining trivial accepts/rejects

Combining trivial accepts/rejects

• Trivially _Trivially acceptaccept lines with both endpoints lines with both endpoints inside all edges of the view windowinside all edges of the view window

• Trivially _Trivially reject reject lines with both endpoints lines with both endpoints outside the same edge of the view outside the same edge of the view window

window

• Otherwise, reduce to trivial cases_{Otherwise, reduce to trivial cases} by splitting into two segmentsby splitting into two segments

Combining trivial accepts/rejects

Combining trivial accepts/rejects

• Trivially _Trivially acceptaccept lines with both endpoints lines with both endpoints inside all edges of the view windowinside all edges of the view window • Trivially _Trivially reject reject lines with both endpoints lines with both endpoints outside the same edge of the view outside the same edge of the view

window

window

Cohen-Sutherland Line Clipping

• Divide _Divide view windowview window into regions defined by into regions defined by windowwindow edges edges • Assign each region a 4-bit _{Assign each region a 4-bit} outcodeoutcode::

–Bit 1 indicates y-value of points are above yBit 1 indicates y-value of points are above y_maxmax

• Divide _Divide view windowview window into regions defined by into regions defined by windowwindow edges edges

• Assign each region a 4-bit _{Assign each region a 4-bit} outcodeoutcode::

–Bit 1 indicates y-value of points are above yBit 1 indicates y-value of points are above y_maxmax

0000 0010

0001 1001

0101 0100

1000 1010

0110

y_max

Cohen-Sutherland Line Clipping

For each line segment

For each line segment

• Assign an outcode to each vertex _{Assign an outcode to each vertex} • If both outcodes = 0, trivial accept_{If both outcodes = 0, trivial accept}

–Same as performing _{Same as performing} if (bitwise _{if (bitwise} OR = 0)OR = 0)

• Else_Else

–bitwise _bitwise ANDAND vertex outcodes together vertex outcodes together –if result _{if result}  0, trivial reject 0, trivial reject

For each line segment

For each line segment

• Assign an outcode to each vertex _{Assign an outcode to each vertex}

• If both outcodes = 0, trivial accept_{If both outcodes = 0, trivial accept}

–Same as performing _{Same as performing} if (bitwise _{if (bitwise} OR = 0)OR = 0)

• Else_Else

–bitwise _bitwise ANDAND vertex outcodes together vertex outcodes together

Cohen-Sutherland Line Clipping

• If line cannot be trivially accepted or rejected, subdivide so _{If line cannot be trivially accepted or rejected, subdivide so} that one or both segments can be discarded

that one or both segments can be discarded

–Pick an edge of view window that the line crosses (_{Pick an edge of view window that the line crosses (}how?how?)) –Intersect line with edge (_{Intersect line with edge (}how?how?))

–Discard portion on wrong side of edge and assign new _{Discard portion on wrong side of edge and assign new} outcode to new vertex

outcode to new vertex

–Apply trivial accept/reject tests; repeat if necessary _{Apply trivial accept/reject tests; repeat if necessary}

• If line cannot be trivially accepted or rejected, subdivide so _{If line cannot be trivially accepted or rejected, subdivide so}

that one or both segments can be discarded

that one or both segments can be discarded

–Pick an edge of view window that the line crosses (_{Pick an edge of view window that the line crosses (}how?how?))

–Intersect line with edge (_{Intersect line with edge (}how?how?))

–_{Discard portion on wrong side of edge and assign new Discard portion on wrong side of edge and assign new}

outcode to new vertex

outcode to new vertex

Cohen-Sutherland Line Clipping

If line cannot be trivially accepted or rejected, subdivide

If line cannot be trivially accepted or rejected, subdivide

so that one or both segments can be discarded

so that one or both segments can be discarded

Pick an edge that the line crosses

Pick an edge that the line crosses

• Check against edges in same order each time_{Check against edges in same order each time}

– For example: top, bottom, right, left_{For example: top, bottom, right, left}

If line cannot be trivially accepted or rejected, subdivide

If line cannot be trivially accepted or rejected, subdivide

so that one or both segments can be discarded

so that one or both segments can be discarded

Pick an edge that the line crosses

Pick an edge that the line crosses

• Check against edges in same order each time_{Check against edges in same order each time}

– For example: top, bottom, right, left_{For example: top, bottom, right, left}

A

B

D E

Cohen-Sutherland Line Clipping

Intersect line with edge (

Intersect line with edge (

how?

how?

)

)

Intersect line with edge (

Intersect line with edge (

how?

how?

)

)

A

B

D E

Discard portion on wrong side of edge and assign outcode to

Discard portion on wrong side of edge and assign outcode to

new vertex

new vertex

Apply trivial accept/reject tests and repeat if necessary

Apply trivial accept/reject tests and repeat if necessary

Discard portion on wrong side of edge and assign outcode to

Discard portion on wrong side of edge and assign outcode to

new vertex

new vertex

Apply trivial accept/reject tests and repeat if necessary

Apply trivial accept/reject tests and repeat if necessary

Cohen-Sutherland Line Clipping

A

B

View Window Intersection Code

• (x(x₁₁, y, y₁₁), (x), (x₂₂, y, y₂₂) intersect with vertical edge at x) intersect with vertical edge at x_rightright

–yy_{intersectintersect} = y = y₁₁ + m(x + m(x_rightright – x1) – x1)

 where m=(ywhere m=(y₂₂-y-y₁₁)/(x)/(x₂₂-x-x₁₁))

• (x(x₁₁, y, y₁₁), (x), (x₂₂, y, y₂₂) intersect with horizontal edge at y) intersect with horizontal edge at y_bottombottom

–xx_{intersectintersect} = x = x₁₁ + (y + (y_bottombottom – y1)/m – y1)/m

 where m=(ywhere m=(y₂₂-y-y₁₁)/(x)/(x₂₂-x-x₁₁))

• (x(x₁₁, y, y₁₁), (x), (x₂₂, y, y₂₂) intersect with vertical edge at x) intersect with vertical edge at x_rightright

–yy_{intersectintersect} = y = y₁₁ + m(x + m(x_rightright – x1) – x1)

 where m=(ywhere m=(y₂₂-y-y₁₁)/(x)/(x₂₂-x-x₁₁))

• (x(x₁₁, y, y₁₁), (x), (x₂₂, y, y₂₂) intersect with horizontal edge at y) intersect with horizontal edge at y_bottombottom

–xx_{intersectintersect} = x = x₁₁ + (y + (y_bottombottom – y1)/m – y1)/m

Cohen-Sutherland Review

• Use opcodes to quickly eliminate/include lines_{Use opcodes to quickly eliminate/include lines}

– _{Best algorithm when trivial accepts/rejects are commonBest algorithm when trivial accepts/rejects are common} • Must compute viewing window clipping of remaining lines_{Must compute viewing window clipping of remaining lines}

– _{Non-trivial clipping costNon-trivial clipping cost}

– Redundant clipping of some lines_{Redundant clipping of some lines}

More efficient algorithms exist

More efficient algorithms exist

• Use opcodes to quickly eliminate/include lines_{Use opcodes to quickly eliminate/include lines}

– Best algorithm when trivial accepts/rejects are common_{Best algorithm when trivial accepts/rejects are common}

• _{Must compute viewing window clipping of remaining linesMust compute viewing window clipping of remaining lines} – Non-trivial clipping cost_{Non-trivial clipping cost}

– _{Redundant clipping of some linesRedundant clipping of some lines}

More efficient algorithms exist

Solving Simultaneous Equations

Equation of a line

Equation of a line

• Slope-intercept (explicit equation): y = mx + b_{Slope-intercept (explicit equation): y = mx + b} • Implicit Equation: Ax + By + C = 0_{Implicit Equation: Ax + By + C = 0}

• Parametric Equation: Line defined by two points, PParametric Equation: Line defined by two points, P₀₀ and P and P₁₁

–PP(t) = (t) = PP₀₀ + ( + (PP₁₁ - - PP₀₀) t, where ) t, where PP is a vector [x, y] is a vector [x, y]TT

–x(t) = xx(t) = x₀₀ + (x + (x_{1 1} - x- x₀₀) t) t

–y(t) = yy(t) = y₀₀ + (y + (y_{1 1} - y- y₀₀) t) t

Equation of a line

Equation of a line

• Slope-intercept (explicit equation): y = mx + b_{Slope-intercept (explicit equation): y = mx + b} • Implicit Equation: Ax + By + C = 0_{Implicit Equation: Ax + By + C = 0}

• Parametric Equation: Line defined by two points, PParametric Equation: Line defined by two points, P₀₀ and P and P₁₁

–PP(t) = (t) = PP₀₀ + ( + (PP₁₁ - - PP₀₀) t, where ) t, where PP is a vector [x, y] is a vector [x, y]TT

–x(t) = xx(t) = x₀₀ + (x + (x_{1 1} - x- x₀₀) t) t

Parametric Line Equation

Describes a finite line

Describes a finite line

Works with vertical lines (like the viewport edge)

Works with vertical lines (like the viewport edge)

• 0 <=t <= 1_{0 <=t <= 1}

– Defines line between PDefines line between P₀₀ and P and P₁₁

• t < 0_{t < 0}

– Defines line before PDefines line before P₀₀

• t > 1_{t > 1}

– Defines line after PDefines line after P₁₁

Describes a finite line

Describes a finite line

Works with vertical lines (like the viewport edge)

Works with vertical lines (like the viewport edge)

–Defines line between PDefines line between P₀₀ and P and P₁₁

• t < 0_{t < 0}

–Defines line before PDefines line before P₀₀

• t > 1_{t > 1}

Parametric Lines and Clipping

Define each line in parametric form:

Define each line in parametric form:

• PP₀₀(t)…P(t)…P_n-1n-1(t)(t)

Define each edge of view window in parametric

Define each edge of view window in parametric

form:

form:

• PP_LL(t), P(t), P_RR(t), P(t), P_TT(t), P(t), P_BB(t)(t)

Perform Cohen-Sutherland intersection tests

Perform Cohen-Sutherland intersection tests

using appropriate view window edge and line

using appropriate view window edge and line

Define each line in parametric form:

Define each line in parametric form:

• PP₀₀(t)…P(t)…P_n-1n-1(t)(t)

Define each edge of view window in parametric

Define each edge of view window in parametric

form:

form:

• PP_LL(t), P(t), P_RR(t), P(t), P_TT(t), P(t), P_BB(t)(t)

Perform Cohen-Sutherland intersection tests

Perform Cohen-Sutherland intersection tests

using appropriate view window edge and line

Line / Edge Clipping Equations

Faster line clippers use parametric equations

Faster line clippers use parametric equations

Line 0:

Line 0:

• xx00 = x _{= x}00 0

0 + (x + (x0011 - x - x0000) t) t00

• yy00 = y _{= y}00 0

0 + (y + (y0011 - y - y0000) t) t00

x

x

0

+ (x

+ (x

- x

- x

) t

) t

x

x

+ (x

+ (x

- x

- x

) t

) t

y

y

0

+ (y

+ (y

- y

- y

) t

) t

y

y

+ (y

+ (y

- y

- y

) t

) t

• Solve for t_{Solve for t}00 and/or t _{and/or t}LL

Faster line clippers use parametric equations

Faster line clippers use parametric equations

Line 0:

Line 0:

0

0 + (x + (x0011 - x - x0000) t) t00

• yy00 _{= y = y}00 0

0 + (y + (y0011 - y - y0000) t) t00

x

x

0

+ (x

+ (x

- x

- x

) t

) t

x

x

+ (x

+ (x

- x

- x

) t

) t

y

y

0

+ (y

+ (y

- y

- y

) t

) t

y

y

+ (y

+ (y

- y

- y

) t

) t

• Solve for t_{Solve for t}00 _{and/or t and/or t}LL

View Window Edge L:

View Window Edge L:

• _xxLL = x _{= x}LL 0

0 + (x + (xLL11 - x - xLL00) t) tLL

• _yyLL _{= y = y}LL 0

0 + (y + (yLL11 - y - yLL00) t) tLL

View Window Edge L:

View Window Edge L:

0

0 + (x + (xLL11 - x - xLL00) t) tLL

• _yyLL = y _{= y}LL

0

Cyrus-Beck Algorithm

We wish to optimize line/line intersection

We wish to optimize line/line intersection

• Start with parametric equation of line:_{Start with parametric equation of line:}

–P(t) = PP(t) = P₀₀ + (P + (P_{1 1} - P- P₀₀) t) t

• And a point and normal for each edge_{And a point and normal for each edge}

–PP_LL, N, N_LL

We wish to optimize line/line intersection

We wish to optimize line/line intersection

• Start with parametric equation of line:_{Start with parametric equation of line:}

–P(t) = PP(t) = P₀₀ + (P + (P_{1 1} - P- P₀₀) t) t

• And a point and normal for each edge_{And a point and normal for each edge}

Cyrus-Beck Algorithm

Find t such that

Find t such that

N

N_LL [P(t) - P [P(t) - P_LL] = 0] = 0

Substitute line equation for P(t):

Substitute line equation for P(t):

• NN_LL [ [PP₀₀ + (P + (P_{1 1} - P- P₀₀) t) t - P - P_LL] = 0] = 0

Solve for t

Solve for t

• t = Nt = N_LL [P [P_LL – P – P₀₀] / -N] / -N_LL [P [P₁₁ - P - P₀₀]]

Find t such that

Find t such that

N

N_LL [P(t) - P [P(t) - P_LL] = 0] = 0

Substitute line equation for P(t):

Substitute line equation for P(t):

• NN_LL [ [PP₀₀ + (P + (P_{1 1} - P- P₀₀) t) t - P - P_LL] = 0] = 0

Solve for t

Solve for t

• t = Nt = N_LL [P [P_LL – P – P₀₀] / -N] / -N_LL [P [P₁₁ - P - P₀₀]]

Cyrus-Beck Algorithm

Compute t for line intersection with all four edges

Compute t for line intersection with all four edges

Discard all (t < 0) and (t > 1)

Discard all (t < 0) and (t > 1)

Classify each remaining intersection as

Classify each remaining intersection as

• Potentially Entering (PE)_{Potentially Entering (PE)} • Potentially Leaving (PL)_{Potentially Leaving (PL)}

N

N

[P

[P

- P

- P

] > 0 implies PL

] > 0 implies PL

N

N

[P

[P

- P

- P

] < 0 implies PE

] < 0 implies PE

• Note that we computed this term when computing t so we can keep it _{Note that we computed this term when computing t so we can keep it} around

around

Compute t for line intersection with all four edges

Compute t for line intersection with all four edges

Discard all (t < 0) and (t > 1)

Discard all (t < 0) and (t > 1)

Classify each remaining intersection as

Classify each remaining intersection as

• Potentially Leaving (PL)_{Potentially Leaving (PL)}

N

N

[P

[P

- P

- P

] > 0 implies PL

] > 0 implies PL

N

N

[P

[P

- P

- P

] < 0 implies PE

] < 0 implies PE

• Note that we computed this term when computing t so we can keep it _{Note that we computed this term when computing t so we can keep it}

around

Compute PE with largest t

Compute PE with largest t

Compute PL with smallest t

Compute PL with smallest t

Clip to these two points

Clip to these two points

Cyrus-Beck Algorithm

PE

PL P1

PL

PE

Cyrus-Beck Algorithm

Because of horizontal and vertical clip lines:

Because of horizontal and vertical clip lines:

• Many computations reduce_{Many computations reduce}

Normals: (-1, 0), (1, 0), (0, -1), (0, 1)

Normals: (-1, 0), (1, 0), (0, -1), (0, 1)

Pick constant points on edges

Pick constant points on edges

solution for t:

solution for t:

• -(x-(x₀₀ - x - x_leftleft) / (x) / (x₁₁ - x - x₀₀))

• (x(x₀₀ - x - x_rightright) / -(x) / -(x₁₁ - x - x₀₀))

• -(y-(y₀₀ - y - y_bottombottom) / (y) / (y₁₁ - y - y₀₀))

• (y(y₀₀ - y - y_toptop) / -(y) / -(y₁₁ - y - y₀₀))

Because of horizontal and vertical clip lines:

Because of horizontal and vertical clip lines:

• Many computations reduce_{Many computations reduce}

Normals: (-1, 0), (1, 0), (0, -1), (0, 1)

Normals: (-1, 0), (1, 0), (0, -1), (0, 1)

Pick constant points on edges

Pick constant points on edges

solution for t:

solution for t:

• -(x-(x₀₀ - x - x_leftleft) / (x) / (x₁₁ - x - x₀₀))

• (x(x₀₀ - x - x_rightright) / -(x) / -(x₁₁ - x - x₀₀))

• -(y-(y₀₀ - y - y_bottombottom) / (y) / (y₁₁ - y - y₀₀))

Comparison

• Repeated clipping is expensive_{Repeated clipping is expensive}

• Best used when trivial acceptance and rejection is possible for most lines_{Best used when trivial acceptance and rejection is possible for most lines}

Cyrus-Beck Cyrus-Beck

• Computation of t-intersections is cheap_{Computation of t-intersections is cheap}

• Computation of (x,y) clip points is only done once_{Computation of (x,y) clip points is only done once} • Algorithm doesn’t consider trivial accepts/rejects_{Algorithm doesn’t consider trivial accepts/rejects} • Best when many lines must be clipped_{Best when many lines must be clipped}

Liang-Barsky: Optimized Cyrus-Beck Liang-Barsky: Optimized Cyrus-Beck Nicholl et al.: Fastest, but doesn’t do 3D Nicholl et al.: Fastest, but doesn’t do 3D Cohen-Sutherland

Cohen-Sutherland

• Repeated clipping is expensive_{Repeated clipping is expensive}

• Best used when trivial acceptance and rejection is possible for most lines_{Best used when trivial acceptance and rejection is possible for most lines}

Cyrus-Beck Cyrus-Beck

• Computation of t-intersections is cheap_{Computation of t-intersections is cheap}

• Computation of (x,y) clip points is only done once_{Computation of (x,y) clip points is only done once} • Algorithm doesn’t consider trivial accepts/rejects_{Algorithm doesn’t consider trivial accepts/rejects} • Best when many lines must be clipped_{Best when many lines must be clipped}

Liang-Barsky: Optimized Cyrus-Beck Liang-Barsky: Optimized Cyrus-Beck

Clipping Polygons

Clipping polygons is more complex than clipping

Clipping polygons is more complex than clipping

the individual lines

the individual lines

• Input: polygon_{Input: polygon}

• Output: original polygon, new polygon, or nothing_{Output: original polygon, new polygon, or nothing}

The biggest optimizer we had was trivial accept or

The biggest optimizer we had was trivial accept or

reject…

reject…

When can we trivially accept/reject a polygon as

When can we trivially accept/reject a polygon as

opposed to the line segments that make up the

opposed to the line segments that make up the

polygon?

polygon?

Clipping polygons is more complex than clipping

Clipping polygons is more complex than clipping

the individual lines

the individual lines

• Input: polygon_{Input: polygon}

• _{Output: original polygon, new polygon, or nothingOutput: original polygon, new polygon, or nothing}

The biggest optimizer we had was trivial accept or

The biggest optimizer we had was trivial accept or

reject…

reject…

When can we trivially accept/reject a polygon as

When can we trivially accept/reject a polygon as

opposed to the line segments that make up the

opposed to the line segments that make up the

polygon?

What happens to a triangle during clipping?

What happens to a triangle during clipping?

Possible outcomes

Possible outcomes

:

:

What happens to a triangle during clipping?

What happens to a triangle during clipping?

Possible outcomes

Possible outcomes

:

:

triangle  triangle

Why Is Clipping Hard?

triangle  quad _{triangle  5-gon}

How many sides can a clipped triangle have?

How many sides?

Seven…

Seven…

Seven…

A really tough case:

A really tough case:

A really tough case:

A really tough case:

A really tough case:

A really tough case:

A really tough case:

A really tough case:

Why Is Clipping Hard?

Sutherland-Hodgman Clipping

Basic idea:

Basic idea:

• Consider each edge of the view window individually_{Consider each edge of the view window individually}

• Clip the polygon against the view window edge’s equation_{Clip the polygon against the view window edge’s equation}

Basic idea:

Basic idea:

• Consider each edge of the view window individually_{Consider each edge of the view window individually}

Sutherland-Hodgman Clipping

Basic idea:

Basic idea:

• Consider each edge of the viewport individually_{Consider each edge of the viewport individually}

• Clip the polygon against the edge equation_{Clip the polygon against the edge equation}

Basic idea:

Basic idea:

• Consider each edge of the viewport individually_{Consider each edge of the viewport individually}

Sutherland-Hodgman Clipping

Basic idea:

Basic idea:

• Consider each edge of the viewport individually_{Consider each edge of the viewport individually}

• Clip the polygon against the edge equation_{Clip the polygon against the edge equation}

Basic idea:

Basic idea:

• Consider each edge of the viewport individually_{Consider each edge of the viewport individually}

Sutherland-Hodgman Clipping

Basic idea:

Basic idea:

• Consider each edge of the viewport individually_{Consider each edge of the viewport individually}

• Clip the polygon against the edge equation_{Clip the polygon against the edge equation}

Basic idea:

Basic idea:

• Consider each edge of the viewport individually_{Consider each edge of the viewport individually}

Sutherland-Hodgman Clipping

Basic idea:

Basic idea:

• Consider each edge of the viewport individually_{Consider each edge of the viewport individually}

• Clip the polygon against the edge equation_{Clip the polygon against the edge equation}

Basic idea:

Basic idea:

• Consider each edge of the viewport individually_{Consider each edge of the viewport individually}

Sutherland-Hodgman Clipping

Basic idea:

Basic idea:

• Consider each edge of the viewport individually_{Consider each edge of the viewport individually}

• Clip the polygon against the edge equation_{Clip the polygon against the edge equation}

Basic idea:

Basic idea:

• Consider each edge of the viewport individually_{Consider each edge of the viewport individually}

Sutherland-Hodgman Clipping

Basic idea:

Basic idea:

• Consider each edge of the viewport individually_{Consider each edge of the viewport individually}

• Clip the polygon against the edge equation_{Clip the polygon against the edge equation}

Basic idea:

Basic idea:

• Consider each edge of the viewport individually_{Consider each edge of the viewport individually}

Sutherland-Hodgman Clipping

Basic idea:

Basic idea:

• Consider each edge of the viewport individually_{Consider each edge of the viewport individually}

• Clip the polygon against the edge equation_{Clip the polygon against the edge equation}

Basic idea:

Basic idea:

• Consider each edge of the viewport individually_{Consider each edge of the viewport individually}

Sutherland-Hodgman Clipping

Basic idea:

Basic idea:

• Consider each edge of the viewport individually_{Consider each edge of the viewport individually}

• Clip the polygon against the edge equation_{Clip the polygon against the edge equation}

Basic idea:

Basic idea:

• Consider each edge of the viewport individually_{Consider each edge of the viewport individually}

Sutherland-Hodgman Clipping

Basic idea:

Basic idea:

• Consider each edge of the viewport individually_{Consider each edge of the viewport individually}

• Clip the polygon against the edge equation_{Clip the polygon against the edge equation}

• After doing all edges, the polygon is fully clipped_{After doing all edges, the polygon is fully clipped}

Basic idea:

Basic idea:

• Consider each edge of the viewport individually_{Consider each edge of the viewport individually}

• Clip the polygon against the edge equation_{Clip the polygon against the edge equation}

Sutherland-Hodgman Clipping

Input/output for algorithm:

Input/output for algorithm:

• Input: list of polygon vertices in order _{Input: list of polygon vertices in order}

• Output: list of clipped polygon vertices consisting of _{Output: list of clipped polygon vertices consisting of} old vertices (maybe) and new vertices (maybe)

old vertices (maybe) and new vertices (maybe)

Note: this is exactly what we expect from the

Note: this is exactly what we expect from the

clipping operation against each edge

clipping operation against each edge

Input/output for algorithm:

Input/output for algorithm:

• Input: list of polygon vertices in order _{Input: list of polygon vertices in order}

• Output: list of clipped polygon vertices consisting of _{Output: list of clipped polygon vertices consisting of}

old vertices (maybe) and new vertices (maybe)

old vertices (maybe) and new vertices (maybe)

Note: this is exactly what we expect from the

Note: this is exactly what we expect from the

clipping operation against each edge

Sutherland-Hodgman Clipping

Sutherland-Hodgman basic routine:

Sutherland-Hodgman basic routine:

• Go around polygon one vertex at a time_{Go around polygon one vertex at a time} • Current vertex has position _{Current vertex has position} pp

• Previous vertex had position _{Previous vertex had position} ss, and it has been added to , and it has been added to the output if appropriate

the output if appropriate

Sutherland-Hodgman basic routine:

Sutherland-Hodgman basic routine:

• Go around polygon one vertex at a time_{Go around polygon one vertex at a time}

• Current vertex has position _{Current vertex has position} pp

• Previous vertex had position _{Previous vertex had position} ss, and it has been added to , and it has been added to the output if appropriate

Sutherland-Hodgman Clipping

Edge from

Edge from

s

s

to

to

p

p

takes one of four cases:

takes one of four cases:

(Orange line can be a line or a plane) (Orange line can be a line or a plane)

Edge from

Edge from

s

s

to

to

p

p

takes one of four cases:

takes one of four cases:

(Orange line can be a line or a plane)

(Orange line can be a line or a plane) inside outside

s

p

p output

inside outside

s p

no output

inside outside

s p

i output

inside outside

s p

Sutherland-Hodgman Clipping

Four cases: Four cases:

• ss inside plane and inside plane and pp inside plane inside plane

– Add Add pp to output to output

– Note: Note: ss has already been added has already been added

• ss inside plane and inside plane and pp outside plane outside plane

– Find intersection point Find intersection point ii

– Add Add ii to output to output

• ss outside plane and outside plane and pp outside planeoutside plane

– Add nothingAdd nothing

• s_s outside plane and outside plane and pp inside plane inside plane

– Find intersection point Find intersection point ii

– Add Add ii to output, followed by to output, followed by pp

Four cases:

Four cases:

• ss inside plane and inside plane and pp inside plane inside plane

– Add Add pp to output to output

– Note: Note: ss has already been added has already been added

• ss inside plane and inside plane and pp outside plane outside plane

– Find intersection point Find intersection point ii

– Add Add ii to output to output

• ss outside plane and outside plane and pp outside planeoutside plane

– Add nothingAdd nothing

• ss outside plane and outside plane and pp inside plane inside plane

– Find intersection point Find intersection point ii

Point-to-Plane test

A very general test to determine if a point

A very general test to determine if a point

p

p

is “inside”

is “inside”

a plane

a plane

P

P

, defined by

, defined by

q

q

and

and

n

n

:

:

(

(pp - - qq) • ) • nn < 0: < 0: pp inside inside PP (

(pp - - qq) • ) • nn = 0: = 0: pp on on PP (

(pp - - qq) • ) • nn > 0: > 0: pp outside outside PP Remember: p

Remember: p • n = |p| |n| cos (• n = |p| |n| cos ())



 = angle between p and n= angle between p and n

A very general test to determine if a point

A very general test to determine if a point

p

p

is “inside”

is “inside”

a plane

a plane

P

P

, defined by

, defined by

q

q

and

and

n

n

:

:

(

(pp - - qq) • ) • nn < 0: < 0: pp inside inside PP (

(pp - - qq) • ) • nn = 0: = 0: pp on on PP (

(pp - - qq) • ) • nn > 0: > 0: pp outside outside PP Remember: p

Remember: p • n = |p| |n| cos (• n = |p| |n| cos ())



 = angle between p and n= angle between p and n

Finding Line-Plane Intersections

Edge intersects plane

Edge intersects plane

P

P

where

where

E

E

(t)

(t)

is on

is on

P

P

• q _q is a point on is a point on PP

• n_n is normal to is normal to PP

(

(LL(t) - q(t) - q) • ) • nn = 0 = 0

(L

(L₀₀ + (L + (L_{1 1} - L- L₀₀) t ) t - q- q) • ) • nn = 0 = 0

t

t = [( = [(q - Lq - L₀₀) • ) • nn] / [(] / [(LL₁₁ - L - L₀₀) • ) • nn]]

• The intersection point _{The intersection point} i = Li = L(t)(t) for this value of for this value of tt

Edge intersects plane

Edge intersects plane

P

P

where

where

E

E

(t)

(t)

is on

is on

P

P

• q _q is a point on is a point on PP

• n_n is normal to is normal to PP

(

(LL(t)(t) - q - q) • ) • nn = 0 = 0

(L

(L₀₀ + (L + (L_{1 1} - L- L₀₀) t ) t - q- q) • ) • nn = 0 = 0

t

t = [( = [(q - Lq - L₀₀) • ) • nn] / [(] / [(LL₁₁ - L - L₀₀) • ) • nn]]