UMass Lowell Computer Science 91.503 Graduate Algorithms Prof. Karen Daniels Spring, 2009 Computational Geometry Overview from Cormen, et al. Chapter 33

UMass Lowell Computer Science 91.503 Graduate Algorithms

Prof. Karen Daniels Spring, 2009

UMass Lowell Computer Science 91.503 Graduate Algorithms

Prof. Karen Daniels Spring, 2009

Computational GeometryComputational GeometryOverview from Cormen, et al.Overview from Cormen, et al.

Chapter 33Chapter 33

OverviewOverview

Computational Geometry IntroductionComputational Geometry Introduction

Line Segment Intersection Line Segment Intersection

Convex Hull AlgorithmsConvex Hull Algorithms

Nearest Neighbors/Closest PointsNearest Neighbors/Closest Points

IntroductionIntroduction

What is What is

Computational Geometry?Computational Geometry?

Applied Computational Geometry ResearchAssoc. Prof. Karen Daniels & CollaboratorsApplied Computational Geometry ResearchAssoc. Prof. Karen Daniels & Collaborators

Clustering, Clustering, for for Data Data MiningMining

Packing for Packing for ManufacturingManufacturing

Design Analyze

Apply

for for covering, clustering, packing, layout, geometric covering, clustering, packing, layout, geometric

modelingmodeling

feasibility, estimation, optimization problemsfeasibility, estimation, optimization problemsCovering for Covering for Geometric Geometric ModelingModeling

Meshing Meshing for for Geometric Geometric Modeling Modeling

Courtesy of Cadence Design SystemsCourtesy of Cadence Design Systems

Topological Invariant Topological Invariant Estimation for Estimation for Geometric Modeling Geometric Modeling

Typical ProblemsTypical Problems

bin packingbin packing

Voronoi diagramVoronoi diagram simplifying simplifying

polygonspolygons

shape similarityshape similarity

convex hullconvex hull

maintaining line maintaining line arrangementsarrangements

polygon partitioningpolygon partitioning nearest neighbor nearest neighbor

searchsearch

kd-treeskd-trees

SOURCESOURCE: Steve Skiena’s Algorithm Design Manual : Steve Skiena’s Algorithm Design Manual

(for problem descriptions, see graphics gallery at (for problem descriptions, see graphics gallery at http://www.cs.sunysb.edu/~algorith))

Common Computational Geometry StructuresCommon Computational Geometry Structures

Voronoi DiagramVoronoi DiagramConvex HullConvex Hull

New PointNew Point

source: O’Rourke, Computational Geometry in Csource: O’Rourke, Computational Geometry in C

Delaunay TriangulationDelaunay Triangulation

Sample Tools of the TradeSample Tools of the Trade

Algorithm Design Patterns/Techniques:Algorithm Design Patterns/Techniques:binary searchbinary search divide-and-conquerdivide-and-conquer dualitydualityrandomizationrandomization sweep-linesweep-line incremental incrementalderandomizationderandomization parallelismparallelism

Algorithm Analysis Techniques:Algorithm Analysis Techniques:asymptotic analysis, amortized analysisasymptotic analysis, amortized analysis

Data Structures:Data Structures:winged-edge, quad-edge, winged-edge, quad-edge, range tree, kd-treerange tree, kd-tree

Theoretical Computer ScienceTheoretical Computer Science principles:principles:NP-completeness, hardnessNP-completeness, hardness

Growth of FunctionsGrowth of Functions

SummationsSummations

RecurrencesRecurrences

SetsSets

ProbabilityProbability

MATHMATH ProofsProofs GeometryGeometry

Graph TheoryGraph TheoryCombinatoricsCombinatorics

Linear AlgebraLinear Algebra

Computational Geometryin Context

Computational Geometryin Context

TheoreticalTheoreticalComputerComputer

ScienceScience

Applied Computer ScienceApplied Computer Science

AppliedAppliedMathMath

GeometryGeometry

ComputationalComputationalGeometryGeometry

Efficient Efficient Geometric AlgorithmsGeometric Algorithms

Design Analyze

Apply

Line Segment Intersections(2D)

Line Segment Intersections(2D)

Intersection of 2 Line SegmentsIntersection of 2 Line SegmentsIntersection of > 2Line SegmentsIntersection of > 2Line Segments

Cross-Product-Based Geometric PrimitivesCross-Product-Based Geometric Primitives

source: 91.503 textbook Cormen et al.source: 91.503 textbook Cormen et al.

pp00

pp22

pp11

(1)(1)

pp11

pp33

pp22

(2)(2)

pp22

pp11

pp33

pp44

(3)(3)

Some fundamental geometric questions:Some fundamental geometric questions:

Cross-Product-Based Geometric Primitives: (1)Cross-Product-Based Geometric Primitives: (1)

source: 91.503 textbook Cormen et al.source: 91.503 textbook Cormen et al.AdvantageAdvantage: less sensitive to accumulated round-off error: less sensitive to accumulated round-off error

122121

2121 det yxyx

yy

xxpp

pp00

pp22

pp11

(1)(1)

33.1

Cross-Product-Based Geometric Primitives: (2)Cross-Product-Based Geometric Primitives: (2)


pp00

pp22

pp11

(2)(2)

33.2

Intersection of 2 Line SegmentsIntersection of 2 Line Segments


pp22

pp11

pp33

pp44

(3)(3)

Step 1Step 1: : Bounding Box Bounding Box TestTest

Step 2Step 2: Does each : Does each segment straddle segment straddle the line containing the line containing the other?the other?

33.3

p3 and p4 on opposite sides of p1p2p3 and p4 on opposite sides of p1p2

Segment-Segment IntersectionSegment-Segment Intersection

Finding the Finding the actual intersection pointactual intersection point Approach: parametric vs. slope/interceptApproach: parametric vs. slope/intercept

parametric generalizes to more complex intersectionsparametric generalizes to more complex intersections e.g. segment/trianglee.g. segment/triangle

Parameterize each segmentParameterize each segment

Intersection: values of Intersection: values of ss, , tt such that such that p(s)p(s) = =q(t)q(t) : : a+sAa+sA==c+tCc+tC

aa

bbcc

dd

LLababLLcdcd

aa

bbcc

dd

LLababLLcdcd

A=b-aA=b-a

p(s)=a+sAp(s)=a+sA

q(t)=c+tCq(t)=c+tCC=d-cC=d-c


2 equations in unknowns 2 equations in unknowns ss, , tt : 1 for x, 1 for y : 1 for x, 1 for y

Segment/Segment IntersectionSegment/Segment Intersectionhttp://cs.smith.edu/~orourke/books/CompGeom/http://cs.smith.edu/~orourke/books/CompGeom/

CompGeom.htmlCompGeom.html

Intersection of >2 Line SegmentsIntersection of >2 Line Segments


Sweep-Line Algorithmic Paradigm:Sweep-Line Algorithmic Paradigm:

33.4



Sweep-Line Algorithmic Paradigm:Sweep-Line Algorithmic Paradigm:



Time to Time to detectdetect if any 2 if any 2

segments intersect:segments intersect:O(n lg n)O(n lg n)

source: 91.503 textbook Cormen et al.

33.5

Note that it exits as soon as Note that it exits as soon as oneone intersection is detected. intersection is detected.

Balanced BST stores segments in order Balanced BST stores segments in order of intersection with sweep line. of intersection with sweep line. Associated operations take O(lgn) time.Associated operations take O(lgn) time.

Intersection of SegmentsIntersection of Segments

GoalGoal: “Output-size sensitive” line segment intersection algorithm : “Output-size sensitive” line segment intersection algorithm that actually computes that actually computes allall intersection points intersection points

Bentley-Ottmann plane sweep: Bentley-Ottmann plane sweep: O((n+k)log(n+k))= O((n+k)logn) O((n+k)log(n+k))= O((n+k)logn) timetime k = number of intersection points in outputk = number of intersection points in output Intuition: sweep horizontal line downwardsIntuition: sweep horizontal line downwards

just before intersection, 2 segments are adjacent in sweep-line intersection structurejust before intersection, 2 segments are adjacent in sweep-line intersection structure check for intersection check for intersection onlyonly adjacent segments adjacent segments insert intersection event into sweep-line structureinsert intersection event into sweep-line structure event types:event types:

top endpoint of a segmenttop endpoint of a segment bottom endpoint of a segmentbottom endpoint of a segment intersection between 2 segmentsintersection between 2 segments

swap order swap order

Improved to O(nlogn+k) [Chazelle/Edelsbrunner]Improved to O(nlogn+k) [Chazelle/Edelsbrunner]source: O’Rourke, Computational Geometry in Csource: O’Rourke, Computational Geometry in C

Convex Hull AlgorithmsConvex Hull Algorithms

DefinitionsDefinitionsGift WrappingGift WrappingGraham ScanGraham Scan

QuickHullQuickHullIncrementalIncremental

Divide-and-ConquerDivide-and-ConquerLower Bound in Lower Bound in (nlgn)(nlgn)

Convexity & Convex HullsConvexity & Convex Hulls

A convex combination of points A convex combination of points xx11, ..., , ..., xxkk is a sum of the form is a sum of the form

11xx11+...++...+ kkxxkk where where

Convex hull of a set of points is the Convex hull of a set of points is the set of all convex combinations of set of all convex combinations of points in the set.points in the set.

nonconvex polygonnonconvex polygon

convex hull of a point setconvex hull of a point set

10 1 ki andi



Naive Algorithms for Extreme PointsNaive Algorithms for Extreme Points

AlgorithmAlgorithm: INTERIOR POINTS: INTERIOR POINTSfor each i dofor each i do for each j = i dofor each j = i do for each k = j = i dofor each k = j = i do

for each L = k = j = i do for each L = k = j = i do if pif pL L in triangle(pin triangle(pii, p, pjj, p, pkk))

then pthen pLL is nonextreme is nonextreme O(nO(n44))

AlgorithmAlgorithm: EXTREME EDGES: EXTREME EDGESfor each i dofor each i do for each j = i dofor each j = i do for each k = j = i dofor each k = j = i do

if pif pk k is not left or on (pis not left or on (pii, p, pjj))

then (pthen (pi i , p, pjj) is not extreme) is not extreme O(nO(n33))source: O’Rourke, Computational Geometry in Csource: O’Rourke, Computational Geometry in C

Algorithms: 2D Gift WrappingAlgorithms: 2D Gift Wrapping

Use one extreme edge as an Use one extreme edge as an anchor for finding the nextanchor for finding the next

O(nO(n22))

AlgorithmAlgorithm: GIFT WRAPPING: GIFT WRAPPING

ii00 index of the lowest point index of the lowest point

i ii i00repeatrepeat for each j = ifor each j = i Compute counterclockwise angle Compute counterclockwise angle from previous hull edge from previous hull edge k index of point with smallest k index of point with smallest Output (pOutput (pi i , p, pkk) as a hull edge) as a hull edge i ki kuntil i = iuntil i = i00


Gift WrappingGift Wrapping source: 91.503 textbook Cormen et al.source: 91.503 textbook Cormen et al.

33.9

Output SensitivityOutput Sensitivity: O(n: O(n22) run-time is actually O(nh) ) run-time is actually O(nh) where h is the number of vertices of the convex hull.where h is the number of vertices of the convex hull.

Algorithms: 3D Gift Wrapping Algorithms: 3D Gift Wrapping

CxHull AnimationsCxHull Animations: http://www.cse.unsw.edu.au/~lambert/java/3d/hull.html: http://www.cse.unsw.edu.au/~lambert/java/3d/hull.html

O(nO(n22)) time time

[output sensitive: O(nF) for F faces on hull][output sensitive: O(nF) for F faces on hull]

Algorithms: 2D QuickHullAlgorithms: 2D QuickHull

Concentrate on points close to Concentrate on points close to hull boundaryhull boundary

Named for similarity to Named for similarity to Quicksort Quicksort

aa

bb

O(nO(n22))

AlgorithmAlgorithm: QUICK HULL: QUICK HULL

function QuickHull(a,b,S)function QuickHull(a,b,S)

if S = 0 return()if S = 0 return() elseelse c index of point with max distance from abc index of point with max distance from ab A points strictly right of (a,c)A points strictly right of (a,c) B points strictly right of (c,b)B points strictly right of (c,b) return QuickHull(a,c,A) + (c) + QuickHull(c,b,B)return QuickHull(a,c,A) + (c) + QuickHull(c,b,B)


finds one of upper or lower hullfinds one of upper or lower hull

cc

AA

Algorithms: 3D QuickHullAlgorithms: 3D QuickHull


Algorithms: >= 2D Algorithms: >= 2D

Qhull: http://www.qhull.org/Qhull: http://www.qhull.org/

Convex Hull Convex Hull boundary is boundary is intersection of intersection of hyperplanes, so hyperplanes, so worst-case worst-case combinatorial size combinatorial size (not necessarily running (not necessarily running

time)time) complexity is complexity is in:in: )( 2/dn

Graham’s AlgorithmGraham’s Algorithm

Points sorted angularly provide Points sorted angularly provide “star-shaped” starting point“star-shaped” starting point

Prevent “dents” as you go via Prevent “dents” as you go via convexity testingconvexity testing

O(nlgn)O(nlgn)

AlgorithmAlgorithm: GRAHAM SCAN: GRAHAM SCAN

Find rightmost lowest point; label it pFind rightmost lowest point; label it p00..

Sort all other points angularly about pSort all other points angularly about p00.. In case of tie, delete point(s) closer to pIn case of tie, delete point(s) closer to p00..Stack S (pStack S (p11, p, p00) = (p) = (ptt, p, pt-1t-1); t indexes top); t indexes topi 2i 2while i < n dowhile i < n do

if pif pii is strictly left of p is strictly left of pt-1t-1pptt

then Push(pthen Push(pii, S) and set i i +1, S) and set i i +1else Pop(S)else Pop(S)


““multipop”multipop”

pp00

Graham ScanGraham Scan




33.7



33.7





Algorithms: 2D IncrementalAlgorithms: 2D Incremental

Add points, one at a timeAdd points, one at a time update hull for each new pointupdate hull for each new point

Key step becomes adding a single point Key step becomes adding a single point to an existing hull.to an existing hull. Find 2 tangentsFind 2 tangents

Results of 2 consecutive LEFT tests differResults of 2 consecutive LEFT tests differ

Idea can be extended to 3D.Idea can be extended to 3D.

O(nO(n22))

AlgorithmAlgorithm: INCREMENTAL ALGORITHM: INCREMENTAL ALGORITHM

Let HLet H22 ConvexHull{p ConvexHull{p0 0 , p, p1 1 , p, p2 2 }}

for k 3 to n - 1 dofor k 3 to n - 1 do HHkk ConvexHull{ H ConvexHull{ Hk-1 k-1 U pU pk k }}

can be improved to O(nlgn)can be improved to O(nlgn)


Algorithms: 3D Incremental Algorithms: 3D Incremental


O(nO(n22)) time time

Algorithms: 2D Divide-and-ConquerAlgorithms: 2D Divide-and-Conquer

Divide-and-Conquer in a geometric settingDivide-and-Conquer in a geometric setting O(n) merge step is the challengeO(n) merge step is the challenge

Find upper and lower tangentsFind upper and lower tangents Lower tangent: find rightmost pt of A & Lower tangent: find rightmost pt of A &

leftmost pt of B; then “walk it downwards”leftmost pt of B; then “walk it downwards” Idea can be extended to 3D.Idea can be extended to 3D.

AlgorithmAlgorithm: DIVIDE-and-CONQUER: DIVIDE-and-CONQUER

Sort points by x coordinateSort points by x coordinate

Divide points into 2 sets A and B:Divide points into 2 sets A and B:

A contains left n/2 pointsA contains left n/2 points

B contains right n/2 pointsB contains right n/2 points

Compute ConvexHull(A) and ConvexHull(B) recursivelyCompute ConvexHull(A) and ConvexHull(B) recursively

Merge ConvexHull(A) and ConvexHull(B) Merge ConvexHull(A) and ConvexHull(B) O(nlgn)O(nlgn)

AABB


Algorithms: 3D Divide and Conquer Algorithms: 3D Divide and Conquer


O(n log n)O(n log n) time ! time !

Lower Bound of O(nlgn)Lower Bound of O(nlgn)

Worst-case time to find convex hull of n points Worst-case time to find convex hull of n points in algebraic decision tree model is in in algebraic decision tree model is in (nlgn)(nlgn)

Proof uses sorting reduction:Proof uses sorting reduction: Given unsorted list of n numbers: (xGiven unsorted list of n numbers: (x11,x,x2 2 ,…, x,…, xnn)) Form unsorted set of points: (xForm unsorted set of points: (xii, x, xii

22) for each x) for each xii

Convex hull of points produces Convex hull of points produces sorted listsorted list!! Parabola: every point is on convex hullParabola: every point is on convex hull

Reduction is O(n) (which is in o(nlgn))Reduction is O(n) (which is in o(nlgn)) Finding convex hull of n points is therefore at least Finding convex hull of n points is therefore at least

as hard as sorting n points, so worst-case time is in as hard as sorting n points, so worst-case time is in (nlgn)(nlgn)

Parabola for sorting 2,1,3Parabola for sorting 2,1,3


Nearest Neighbor/Closest Pair of Points

Nearest Neighbor/Closest Pair of Points

Closest PairClosest Pair


GoalGoal: Given n (2D) points in a set Q, find the closest pair : Given n (2D) points in a set Q, find the closest pair under the Euclidean metric in under the Euclidean metric in O(n lgn)O(n lgn) time. time.

Divide-and-Conquer Strategy:-X = points sorted by increasing x-Y = points sorted by increasing y-Divide: partition with vertical line L into PL, PR

-Conquer: recursively find closest pair in PL, PR

- L, R are closest-pair distances- min( L, R )-Combine: closest-pair is either or pair straddles partition line L- Check for pair straddling partition line L- both points must be within of L- create array Y’ = Y with only points in 2 strip- for each point p in Y’- find (<= 7) points in Y’ within of p



Correctness

33.11


Running Time:

Key PointKey Point: Presort points, then at each step form : Presort points, then at each step form sorted subset of sorted array in linear timesorted subset of sorted array in linear time

)lg(3 if)1(

3 if)()2/(2)( nnO

nO

nnOnTnT

Like opposite of MERGE step in MERGESORT…Like opposite of MERGE step in MERGESORT…

source: 91.503 textbook Cormen et al.source: 91.503 textbook Cormen et al.RR

LL

Additional Computational Geometry ResourcesAdditional Computational Geometry Resources

Computational Geometry in C, 2nd editionComputational Geometry in C, 2nd edition by Joseph O’Rourkeby Joseph O’Rourke Cambridge University PressCambridge University Press 19981998

Computational Geometry: Algorithms & ApplicationsComputational Geometry: Algorithms & Applications by deBerg by deBerg et alet al.. SpringerSpringer 19981998

web site: http://cs.smith.edu/~orourke/books/compgeom.html

See also 91.504 Course Web Site (and its additional resources): http://www.cs.uml.edu/~kdaniels/courses/ALG_504.html

Documents

UMass Lowell Computer Science 91.503 Graduate Algorithms Prof. Karen Daniels Spring, 2009 Computational Geometry Overview from Cormen, et al. Chapter 33