CS 430

Computer Graphics

Polygon Clipping and Filling

Week 3, Lecture 5

David Breen, William Regli and Maxim Peysakhov

Department of Computer Science
Drexel University

1
 Outline
• Polygon clipping
– Sutherland-Hodgman,
– Weiler-Atherton
• Polygon filling
– Scan filling polygons
– Flood filling polygons
• Introduction and discussion of homework #2

2
 Polygon

• Ordered set of vertices (points)

– Usually counter-clockwise
• Two consecutive vertices define an edge
• Left side of edge is inside
• Right side is outside
• Last vertex implicitly connected to first
• In 3D vertices should be co-planar
3
 Polygon Clipping
• Lots of different cases
• Issues
– Edges of polygon need
to be tested against
clipping rectangle
– May need to add new edges
– Edges discarded or divided
– Multiple polygons can result
from a single polygon

4
1994 Foley/VanDam/Finer/Huges/Phillips ICG
 The Sutherland-Hodgman
Polygon-Clipping Algorithm
• Divide and Conquer
• Idea:
– Clip single polygon using
single infinite clip edge
– Repeat 4 times
• Note the generality:
– 2D convex n-gons can clip
arbitrary n-gons
– 3D convex polyhedra can
clip arbitrary polyhedra
5
1994 Foley/VanDam/Finer/Huges/Phillips ICG
Sutherland-Hodgman Algorithm
• Input:
– v1, v2, … vn the vertices defining the polygon
– Single infinite clip edge w/ inside/outside info
• Output:
– v’1, v’2, … v’m, vertices of the clipped polygon
• Do this 4 (or ne) times
• Traverse vertices (edges)
• Add vertices one-at-a-time to output polygon
– Use inside/outside info
– Edge intersections
6
Sutherland-Hodgman Algorithm
• Can be done incrementally
• If first point inside add. If outside, don’t add
• Move around polygon from v1 to vn and back to v1
• Check vi,vi+1 wrt the clip edge
• Need vi,vi+1‘s inside/outside status
• Add vertex one at a time. There are 4 cases:

7
1994 Foley/VanDam/Finer/Huges/Phillips ICG
 Sutherland-Hodgman Algorithm
• Given polygon P P’ = P
– foreach clipping edge (there are 4) {
• Clip polygon P’ to clipping edge
–foreach edge in polygon P’
» Check clipping cases (there are 4)
» Case 1 : Output vi+1 to P’’
» Case 2 : Output intersection point to P’’
» Case 3 : No output
» Case 4 : Output intersection point & vi+1 to P’’
• P’ = P’’
} 8
Sutherland-Hodgman Algorithm

9
Animated by Max Peysakhov @ Drexel University
Final Result

Note: Edges
XY and ZW!

11
 Issues with Sutherland-
Hodgman Algorithm
• Clipping a concave polygon
• Can produce two CONNECTED areas

12
1994 Foley/VanDam/Finer/Huges/Phillips ICG
 Weiler-Atherton Algorithm
• General clipping algorithm for concave
polygons with holes
• Produces multiple polygons (with holes)
• Make linked list data structure
• Traverse to make new polygon(s)

13
1994 Foley/VanDam/Finer/Huges/Phillips ICG
 Weiler-Atherton Algorithm
• Given polygons A and B as linked list of
vertices (counter-clockwise order)
• Find all edge intersections & place in list
• Insert as “intersection” nodes
• Nodes point to A & B
• Determine in/out
status of vertices
14
 Linked
List Data
Structure

Intersection
Nodes

15
 Intersection Special Cases

• If “intersecting” edges are parallel, ignore

• Intersection point is a vertex
– Vertex of A lies on a vertex or edge of B
– Edge of A runs through a vertex of B
– Replace vertex with an intersection node

16
 Weiler-Atherton Algorithm:
Union
• Find a vertex of A outside of B
• Traverse linked list
• At each intersection point switch to
other polygon
• Do until return to
starting vertex
• All visited vertices and
nodes define union’ed polygon
17
 Example: Union

{V1, V2, V3, P0, V8, V4, P3, V0}, {V6, P1, P2}
18
Example

A
19
Result

20
 Weiler-Atherton Algorithm:
Intersection
• Start at intersection point
– If connected to an “inside” vertex, go there
– Else step to an intersection point
– If neither, stop
• Traverse linked list
• At each intersection point
switch to other polygon and
remove intersection point from
list
• Do until return to starting intersection point
• If intersection list not empty, pick another one
• All visited vertices and nodes define and’ed polygon
21
Example: Intersection

{P1, V7, P0}, {P3, V5, P2}

22
 Boolean Special Cases
If polygons don’t intersect
– Union
• If one inside the other, return polygon that
surrounds the other
• Else, return both polygons
– Intersection
• If one inside the other, return polygon inside
the other
• Else, return no polygons
23
 Point P Inside a Polygon?
• Connect P with another point P` that you know is
outside polygon
• Intersect segment PP` with polygon edges
• Watch out for vertices!
• If # intersections is even (or 0) ! Outside
• If odd ! Inside

24
 Point P Inside a Rectangle?

• Just re-use code from

Cohen-Sutherland
algorithm
• If a vertex’s bit code
equals zero, it’s inside
• Else, it’s outside

25
 Edge clipping
• Re-use line clipping from HW1
– Similar triangles method
– Cyrus-Beck line clipping
• Yet another technique

26
 Intersecting Two Edges (1)
• Edge 0 : (P0,P1)
• Edge 2 : (P2,P3)
• E0 = P0 + t0*(P1-P0) D0 º (P1-P0)
• E2 = P2 + t2*(P3-P2) D2 º (P3-P2)
• P0 + t0*D0 = P2 + t2*D2
• x0 +dx0 * t0 = x2 +dx2 * t2
• y0 +dy0 * t0 = y2 +dy2 * t2

30
 Intersecting Two Edges (2)
• Solve for t’s
• t0 = ((x0 - x2) * dy2+ (y2 - y0) * dx2) /
(dy0 * dx2- dx0 * dy2)
• t2 = ((x2 - x0) * dy0+ (y0 - y2) * dx0) /
(dy2 * dx0- dx2 * dy0)
• See http://www.vb-helper.com/howto_intersect_lines.html
for derivation
• Edges intersect if 0 £ t0,t2 £ 1
• Edges are parallel if denominator = 0
31
 Examples

0 £ t0,t2 £ 1

t0,t2 £ 0 t2 £ 0
0 £ t0 £ 1

32
Filling Primitives: Rectangles,
Polygons & Circles
• Two part process
– Which pixels to fill?
– What values to fill them with?
• Idea: Coherence
– Spatial: pixels are the
same from pixel-to-pixel
and scan-line to scan line;
– Span: all pixels on a span get the same value
– Scan-line: consecutive scan lines are the same
– Edge: pixels are the same along edges
33
 Scan Filling Primitives:
Rectangles
• Easy algorithm
– Fill from xmin to xmax
Fill from ymin to ymax
• Issues
– What if two adjacent
rectangles share an edge?
– Color the boundary pixels twice?
– Rules:
• Color only interior pixels
• Color left and bottom edges
34
 Scan Filling Primitives:
Polygons
• Observe:
– FA, DC intersections
are integer
– FE, ED intersections
are not integer
• For each scan line,
how to figure out
which pixels are
inside the polygon?
35
1994 Foley/VanDam/Finer/Huges/Phillips ICG
Scan Filling Polygons
• Idea #1: use midpoint
algo on each edge, fill
in between extrema
points
• Note: many extrema
pixels lie outside the
polygon
• Why: midpoint algo
has no sense of in/out
36
1994 Foley/VanDam/Finer/Huges/Phillips ICG
 Scan Filling Polygons
• Idea #2: draw pixels only strictly inside
– Find intersections of
scan line with edges
– Sort intersections by
increasing x coordinate
– Fill pixels on inside
based on a parity bit
• Bp initially even (off)
• Invert at each intersect
• Draw when odd,
do not draw when even

37
1994 Foley/VanDam/Finer/Huges/Phillips ICG
 Scan Filling Polygons
• Issues with Idea #2:
– If at a fractional x value, how to pick which
pixels are in interior?
– Intersections at integer vertex coordinates?
– Shared vertices?
– Vertices that define a horizontal edge?

38
 How to handle vertices?
• Problem:
– vertices are counted twice
• Solution:
– If both neighboring vertices are
on the same side of the scan
line, don’t count it
– If both neighboring vertices are
on different sides of a scan
line, count it once
– Compare current y value with y
value of neighboring vertices
39
Scan-Filling a Polygon

40
Animated by Max Peysakhov @ Drexel University
How to handle horizontal edges?
• Idea: don’t count their vertices
• Apply open and closed status
to vertices to other edges
– ymin vertex closed
– ymax vertex is open
• On AB, A is at ymin for JA; AB
does not contribute, Bp is odd
and draw AB
• Edge BC has ymin at B, but AB
does not contribute, Bp
becomes even and drawing
stops
41
1994 Foley/VanDam/Finer/Huges/Phillips ICG
How to handle horizontal edges?
• Start drawing at IJ
(Bp becomes odd).
• C is ymax (open) for BC.
Bp doesn’t change.
• Ignore CD. D is ymin (closed)
for DE. Bp becomes even.
Stop drawing.
• I is ymax (open) for IJ.
No drawing.
• Ignore IH. H is ymin (closed)
for GH. Bp becomes odd.
Draw to FE.
• Ignore GF. No drawing 42
1994 Foley/VanDam/Finer/Huges/Phillips ICG
 Polygon Filling Algorithm
• For each polygon
– For each edge, mark each scan-line y that the
edge crosses by examining its ymin and ymax
• If edge is horizontal, ignore it
• If ymax on scan-line, ignore it
• If ymin <= y < ymax add edge to scan-line y‘s edge list
– For each scan-line between polygon’s ymin and ymax
• Calculate intersections with edges on list
• Sort intersections in x
• Perform parity-bit scan-line filling
• Apply floor on first xsect and ceiling on second xsect
• Check for double intersection special case
– Clear scan-lines’ edge list
44
Example

45
 How to handle slivers?
• When the scan area does
not have an “interior”
• Solution: use anti-aliasing
• But, to do so will require
softening the rules about
drawing only interior
pixels

46
1994 Foley/VanDam/Finer/Huges/Phillips ICG
Scan Filling Curved Objects
• Hard in general case
• Easier for circles and
ellipses.
• Use midpoint Alg to
generate boundary points.
• Fill in horizontal pixel spans
• Use symmetry

47
1994 Foley/VanDam/Finer/Huges/Phillips ICG
Boundary-Fill Algorithm
• Start with some
internal point (x,y)
• Color it
• Check neighbors for
filled or border color
• Color neighbors if OK
• Continue recursively

48
 4 Connected Boundary-Fill Alg
Void BoundaryFill4( int x, int y, int fill,
int bnd)
{
If Color(x,y) != fill and Color(x,y) != bnd
{
SetColor(x,y) = fill;
BoundaryFill4(x+1, y, fill, bnd);
BoundaryFill4(x, y +1, fill, bnd);
BoundaryFill4(x-1, y, fill, bnd);
BoundaryFill4(x, y -1, fill, bnd);
}
} 49
 Boundary-Fill Algorithm
• Issues with recursive boundary-fill algorithm:
– May make mistakes if parts of the space already filled
with the Fill color
– Requires very big stack size

• More efficient algorithms

– First color contiguous span along one scan line
– Only stack beginning positions of neighboring scan
lines

50
1994 Foley/VanDam/Finer/Huges/Phillips ICG
Plain PBM Image files

51
 Plain PBM Image File
• There is exactly one image in a file
• File begins with ”magic number” “P1”
• Next line specifies pixel resolution
• Each pixel is represented by a byte
containing ASCII ‘1’ (black) or ‘0’ (white)
• All fields/values separated by
whitespace characters
• No line longer than 70 characters?
52
Plain PBM Image Example

53
 Course Status
So far everything straight lines!
• How to model 2D curved objects?
– Representation
• Circles
• Types of 2D Curves
• Parametric Cubic Curves
• Bézier Curves, (non)uniform, (non)rational
• NURBS
– Drawing of 2D Curves
• Line drawing algorithms for complex curves
• DeCasteljeau, Subdivision, De Boor

55
 Homework #2
• Modify homework #1
• Add reading “moveto” and “lineto”
commands
• They define closed polygons
• Transform polygon vertices
• Clip polygons against window with
Sutherland-Hodgman algorithm
• Display edges with HW1 line-drawing
code 56
 Programming assignment 3
• Input PostScript-like file.
• Output B/W PBM.
• Implement viewports.
• Use HW2 for polygon clipping.
• Implement scanline polygon filling. (You can
not use flood filling algorithms)

57