Computational Geometry Overview from Cormen, et al.

Transcription

1 UMass Lowell Computer Science Graduate Algorithms Prof. Karen Daniels Spring, 2014 Computational Geometry Overview from Cormen, et al. Chapter 33 (with additional material from other sources) 1

2 Overview Computational Geometry Introduction Line Segment Intersection Convex Hull Algorithms Nearest Neighbors/Closest Points 2

3 Introduction What is Computational Geometry? 3

4 Applied Algorithms Research Assoc. Prof. Karen Daniels Channel Assignment for Telecommunications Design Analyze feasibility, estimation, optimization problems for covering, assignment, clustering, packing, layout, geometric modeling Covering for Geometric Modeling Data Mining, Clustering, for Bioinformatics Radial Visualization Meshing for Geometric Modeling Apply Courtesy of Cadence Design Systems Containment Topological Invariant Estimation for Geometric Modeling

5 Typical Problems bin packing Voronoi diagram simplifying polygons shape similarity convex hull maintaining line arrangements polygon partitioning nearest neighbor search kd-trees SOURCE: Steve Skiena s Algorithm Design Manual (for problem descriptions, see graphics gallery at 5

6 Common Computational Geometry Structures Convex Hull Voronoi Diagram New Point Delaunay Triangulation 6 source: O Rourke, Computational Geometry in C

7 Sample Tools of the Trade Algorithm Design Patterns/Techniques: binary search divide-and-conquer duality randomization sweep-line incremental derandomization parallelism Algorithm Analysis Techniques: asymptotic analysis, amortized analysis Data Structures: winged-edge, quad-edge, range tree, kd-tree Theoretical Computer Science principles: NP-completeness, hardness Summations Sets Growth of Functions Combinatorics MATH Proofs Geometry Probability Linear Algebra Graph Theory Recurrences 7

8 Computational Geometry in Context Geometry Applied Math Design Computational Geometry Efficient Geometric Algorithms Apply Analyze Theoretical Computer Science Applied Computer Science 8

9 Line Segment Intersections (2D) Intersection of 2 Line Segments Intersection of > 2Line Segments 9

10 Cross-Product-Based Geometric Primitives Some fundamental geometric questions: source: textbook Cormen et al. p 2 p 3 p 3 p 2 p 1 p 2 p 4 p 0 (1) p 1 (2) p 1 (3) 10

11 Cross-Product-Based Geometric Primitives: (1) p p 1 p x p2 = det = x1 y2 x2 y1 y1 y 2 x p 0 (1) Advantage: less sensitive to accumulated round-off error 11 source: textbook Cormen et al.

12 Cross-Product-Based Geometric Primitives: (2) p 2 p p 0 (2) 12 source: textbook Cormen et al.

13 Intersection of 2 Line Segments Step 1: Bounding Box Test p3 and p4 on opposite sides of p1p2 p 3 p 2 p 4 p 1 (3) Step 2: Does each segment straddle the line containing the other? source: textbook Cormen et al.

14 Segment-Segment Intersection L cd Finding the actual intersection point Approach: parametric vs. slope/intercept parametric generalizes to more complex intersections e.g. segment/triangle Parameterize each segment c L L ab cd C=d-c b c L ab q(t)=c+tc b A=b-a d a d a p(s)=a+sa Intersection: values of s, t such that p(s) =q(t) : a+sa=c+tc 2 equations in unknowns s, t : 1 for x, 1 for y 14 source: O Rourke, Computational Geometry in C

15 Intersection of >2 Line Segments Sweep-Line Algorithmic Paradigm: source: textbook Cormen et al.

16 Intersection of >2 Line Segments Sweep-Line Algorithmic Paradigm: source: textbook Cormen et al. 16

17 Intersection of >2 Line Segments Time to detect if any 2 segments intersect:o(n lg n) Balanced BST stores segments in order of intersection with sweep line. Associated operations take O(lgn) time. Note that it exits as soon as one intersection is detected source: source: textbook Cormen et al.

18 Intersection of Segments Goal: Output-size sensitive line segment intersection algorithm that computes all intersection points Bentley-Ottmann plane sweep: O((n+k)log(n+k))= O((n+k)logn) time k = number of intersection points in output Intuition: sweep vertical line rightwards just before intersection, 2 segments are adjacent in sweep-line intersection structure check for intersection only adjacent segments insert intersection event into sweep-line structure event types: top endpoint of a segment bottom endpoint of a segment intersection between 2 segments swap order Improved to O(nlogn+k) [Chazelle/Edelsbrunner] 18 source: O Rourke, Computational Geometry in C

19 Convex Hull Algorithms Definitions Gift Wrapping Graham Scan QuickHull Incremental Divide-and-Conquer Lower Bound in Ω(nlgn) 19

20 Convexity & Convex Hulls source: O Rourke, Computational Geometry in C A convex combination of points x 1,..., x k is a sum of the form α 1 x α k x k where α 0 i and α1 + + α =1 i Convex hull of a set of points is the set of all convex combinations of points in the set. k nonconvex polygon source: textbook Cormen et al. 20 convex hull of a point set

21 Naive Algorithms for Extreme Points Algorithm: INTERIOR POINTS for each i do for each j = i do for each k = j = i do for each L = k = j = i do if p L in triangle(p i, p j, p k ) then p L is nonextreme O(n 4 ) Algorithm: EXTREME EDGES for each i do for each j = i do for each k = j = i do if p k is not left or on (p i, p j ) then (p i, p j ) is not extreme O(n 3 ) 21 source: O Rourke, Computational Geometry in C

22 Algorithms: 2D Gift Wrapping Use one extreme edge as an anchor for finding the next Algorithm: GIFT WRAPPING i 0 index of the lowest point i i 0 repeat for each j = i Compute counterclockwise angle θ from previous hull edge k index of point with smallest θ Output (p i, p k ) as a hull edge i k until i = i 0 source: O Rourke, Computational Geometry in C θ O(n 2 ) 22

23 source: textbook Cormen et al. Gift Wrapping: Jarvis March 33.9 Output Sensitivity: O(n 2 ) run-time is actually O(nh) where h is the number of vertices of the convex hull. 23

24 Algorithms: 3D Gift Wrapping O(n 2 ) time [output sensitive: O(nF) for F faces on hull] CxHull Animations: 24

25 Algorithms: 2D QuickHull Concentrate on points close to hull boundary Named for similarity to Quicksort Algorithm: QUICK HULL function QuickHull(a,b,S) if S = 0 return() else c index of point with max distance from ab A points strictly right of (a,c) B points strictly right of (c,b) return QuickHull(a,c,A) + (c) + QuickHull(c,b,B) a A b finds one of upper or lower hull O(n 2 ) 25 source: O Rourke, Computational Geometry in C c

26 Algorithms: 3D QuickHull CxHull Animations: 26

27 Graham s Algorithm source: O Rourke, Computational Geometry in C Points sorted angularly provide star-shaped starting point Prevent dents as you go via convexity testing θ Algorithm: GRAHAM SCAN Find rightmost lowest point; label it p 0. Sort all other points angularly about p 0. In case of tie, delete point(s) closer to p 0. Stack S (p 1, p 0 ) = (p t, p t-1 ); t indexes top i 2 while i < n do if p i is strictly left of p t-1 p t then Push(p i, S) and set i i +1 else Pop(S) multipop O(nlgn) p 0 27

28 Graham Scan 28 source: textbook Cormen et al.

29 Graham Scan source: textbook Cormen et al.

30 Graham Scan source: textbook Cormen et al.

31 Graham Scan p j cannot be on CH(Q) p i must be in shaded region, preserving convexity. 31 source: textbook Cormen et al.

32 Graham Scan 32 source: textbook Cormen et al.

33 Algorithms: 2D Incremental source: O Rourke, Computational Geometry in C Add points, one at a time update hull for each new point Key step becomes adding a single point to an existing hull. Find 2 tangents Results of 2 consecutive LEFT tests differ Idea can be extended to 3D. Algorithm: INCREMENTAL ALGORITHM Let H 2 ConvexHull{p 0, p 1, p 2 } for k 3 to n - 1 do H k ConvexHull{ H k-1 U p k } O(n 2 ) 33 can be improved to O(nlgn)

34 Algorithms: 3D Incremental O(n 2 ) time CxHull Animations: 34

35 Algorithms: 2D Divide-and-Conquer source: O Rourke, Computational Geometry in C Divide-and-Conquer in a geometric setting O(n) merge step is the challenge Find upper and lower tangents Lower tangent: find rightmost pt of A & leftmost pt of B; then walk it downwards Idea can be extended to 3D. A B Algorithm: DIVIDE-and-CONQUER Sort points by x coordinate Divide points into 2 sets A and B: A contains left n/2 points B contains right n/2 points Compute ConvexHull(A) and ConvexHull(B) recursively Merge ConvexHull(A) and ConvexHull(B) O(nlgn) 35

36 Algorithms: 3D Divide and Conquer O(n log n) time! CxHull Animations: 36

37 Combinatorial Size of Convex Hull Convex Hull boundary is intersection of hyperplanes, so worst-case combinatorial size complexity (number of features, not necessarily running time) is in: Θ( n d / 2 ) 2 d 8 Qhull: 37

38 Lower Bound of O(nlgn) source: O Rourke, Computational Geometry in C Worst-case time to find convex hull of n points in algebraic decision tree model is in Ω(nlgn) Proof uses sorting reduction: Given unsorted list of n numbers: (x 1,x 2,, x n ) Form unsorted set of points: (x i, x i2 ) for each x i Convex hull of points produces sorted list! Parabola: every point is on convex hull Reduction is O(n) (which is in o(nlgn)) Finding convex hull of n points is therefore at least as hard as sorting n points, so worst-case time is in Ω(nlgn) Parabola for sorting 2,1,3 38

39 CONVEX LAYERS DEMO Courtesy of David Wolfendale in , Spring 2010 For practical motivation behind this problem, please see the following link: (e.g. detection of outliers, study of atmospheric layers) 39

40 Nearest Neighbor/ Closest Pair of Points 40

41 Closest Pair Goal: Given n (2D) points in a set Q, find the closest pair under the Euclidean metric in O(n lgn) time. Divide-and-Conquer Strategy: -X = points sorted by increasing x -Y = points sorted by increasing y -Divide: partition with vertical line L into P L, P R -Conquer: recursively find closest pair in P L, P R - δ 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 source: textbook Cormen et al. 41

42 Closest Pair Correctness source: textbook Cormen et al. 42

43 Closest Pair Running Time: 2T ( n / 2) + O( n) if n > 3 T ( n) = = O( n lg n) O(1) if n 3 Key Point: Presort points, then at each step form sorted subset of sorted array in linear time Like opposite of MERGE step in MERGE-SORT L R source: textbook Cormen et al. 43

44 Additional Computational Geometry Resources Computational Geometry in C, 2 nd edition by Joseph O Rourke Cambridge University Press 1998 Computational Geometry: Algorithms & Applications, 3 rd edition by deberg et al. Springer 2008 See also Course Web Site (and its additional resources): 44