Convex Hull Algorithms

Transcription

1 Convex Hull Algorithms Design and Analysis of Algorithms prof. F. Malucelli Villa Andrea e Ceriani Simone

2 Outline Problem Definition Basic Concepts Bruteforce Algorithm Graham Scan Algorithm Divide and conquer approach Gift Wrapping Algorithm Quick Hull Chan's Algorithm 2

3 Computational Geometry CG studies algorithms related to geometrical entities and problems Applications in many fields Robotics Computer Graphics Geographic Information Systems Computer aided design and manufacturing (CAD CAM) Integrated circuit design and verification Computer aided engineering (Numerical Controls) 3

4 Convex Hull Problem Given a set of n points, the convex hull is the smallest convex set containing all of them Planar case: imagine an elastic band stretched open to encompass the given object: when released, it will assume the shape of the required convex hull 4

5 Basic Concepts Frequently we will need to compute the position of a point wrt a vector. a x b p b a The orientation of the cross product between a and b answers the question 5

6 Bruteforce Algorithm Property: A segment defined by two consecutive points of the convex hull in clockwise order ensures that all the other points are on its right. Algorithm idea: Create the list of edges by considering each couple of points, defining the segment from one to the other and check whether there are no points on its left. p2 p 1 p E=0 3 For each p,q (p!=q) in P v=true for each r (r!=q and r!=p) p 4 if r is on the left of pq then v=false break if v=true add {pq} to E p 5 Sort E in clockwise order 6

7 Bruteforce Algorithm Time complexity is O(n 3 ) The first cycle will be executed n 2 times The inner cycle will be executed n times and each cycle has cost O(1) The final sort takes O(h log h) time, where h= CH The algorithm isn t robust If there are 3 collinear point in the convex hull, it is possible that because of numerical approximation problems, the algorithm generates an open polyline 7

8 Graham Scan Algorithm Incremental approach Starting from the left bottom point of P (name it p 0 ) Sort points in clockwise order respect to p 0 Add a point to CH(P) for each iteration Consider if a new point lies on the left or on the right of the segment connecting the two last added points. If it lies on the left, discard the last added point and add the new one Otherwise just add the new point. 8

9 Graham Scan Algorithm Identify p 0 p 4 p 2 p 4 Sort p 1 p n p 2 p 1 p 0 p 1 p 3 p 0 Add p 0, p 1, p 2 Add p 3 Add p 4, discard p 3 Close the polygon 9

10 Graham Scan Algorithm p 0 =bottom left point Sort P in clockwise order respect to p 0 Push(p 0,S) Push(p 1,S) Push(p 2,S) For i=3..n while p i is on the left of {S[top 1],S[top]} Pop(S) Push(p i,s) Return S Sorting P has cost O(n logn) For cycle is executed (n 3) times [O(n)] Each Push costs O(1) Number of Pop has O(n) upper bound One element can be popped out at most once Each pop costs O(1) Total complexity is O(n log n) 10

11 Graham Scan Algorithm It was developed in 1972 Good complexity To increase efficiency we have to wait More robust: it always generates a polygon Numerical approximation can introduce non convex polygons p 1 p 2 p 3 is on the left but we don't eliminate p 2 the resultant polygon is concave p 0 p 3 11

12 Divide and Conquer Based on Divide et Impera technique Compute convex hull for small problems Merge solution of smaller problems Generalization of MergeSort Begins by sorting the point by x coordinate Partition points in two sets Half points with the lowest x coordinate and greater Recursively analyze subproblems Use bruteforce approach with 3 point problems Merging hulls into common convex hull 12

13 Divide and Conquer Hull(P) Sort P wrt x coordinate HullRec(P) end HullRec(P) if P <=3 solve with bruteforce else partition P in A,B (half points) HA=HullRec(A) HB=HullRec(B) return merge(ha,hb) end x Sorting P has cost O(n log n) T(n)=2*T(n/2)+O(n) Master Theorem: T(n)=O(n log n) Total complexity: O(n log n) Merging solution in linear time 13

14 Divide and Conquer Merging solutions by finding lower and upper tangents Since the polygons are convex lower tangent is a local condition We can use a walking procedure upper tangent LowerTangent(HA,HB) a= rigthmost point of HA b= lefthmost point of HB valid=false while not valid valid=true while exists neighboor(a) on left of ba a=a+1 (move clockwise) valid=false while exists neighboor(b) on left of ba b=b 1 (move counterclockwise) valid=false return ba a a b b lower tangent b Each vertex of each convex hull can be visited at most once Complexity is <= HA + HB <=n 14

15 Quick Hull Quick Hull has some traits in common with quick sort algorithm The main idea is: If we know that A and B lie on the hull, any point on the left wrt to vector AB could be part of the solution We can now use some heuristics to choose another hull point C. We could for example find C maximizing its distance from AB. This can be done in O(n) A C B B A 15

16 Quick Hull C S2 The remaining points can be divided into three subsets Points in S0 can be discarded. The more the better! S1 S0 B QuickHull is now called on sets S1 and S2. A Complexity: T(n) = O(n) + T(n1) + T(n2) n1 + n2 <= n Like in quicksort, when the recursion tree is well balanced this resolves to a O(n log n) Otherwise it can easily reach O(n 2 ) 16

17 A great way to find the starting points / edges: We use the points with smaller and larger coordinates, as shown in the pictures to build a starting polygon Red points inside P can be safely discarded in linear time P's vertices can now be used to start the recursion P 17

18 Output Sensitive Algorithms All algorithms in the first part were essentially bound by the O(n log n) complexity of the sorting phase There are some cases where time complexity also depends on the dimension of the output, (that we named h). Sometimes this can be good Jarvis' march Chan's optimal output sensitive algorithm 18

19 Jarvis' March Jarvis' march (1973) can be seen as a variant of the Selection Sort algorithm It starts from any point in the solution and selects the next one from the input set. The process is also known as gift wrapping p 0 19

20 Jarvis' March Jarvis(S) CH < {} P0 < (inf, 0) // neg x axis P1 < point with minimum y p repeat compute angles for all n elements in S p < point minimizing the shown angle CH < CH U { p } until p=p1 The outer loop executes exactly once for each point on the hull The cost of the loop body is linear Total complexity is O( nh ) 20

21 Jarvis' March How good is O (nh)? Worst case is still O (n 2 ) but in practice h may also grow asymptotically slower than n 21

22 A Better Way? All algorithms have to consider each point at least once, and then apply some kind of sorting to the solution. Since only h <= n points have to be sorted one way or the other, it seems that O(n log h) would be a reasonable target complexity for an output sensitive algorithm 1986 Kirkpatrick & Seidel found a rather complex solution and gave a proof of its optimality. Then, 10 years later... 22

23 Chan's Algorithm In 1996 T. Chan invented a more simple output sensitive algorithm with the same O(n log h) complexity The idea was to combine any O(n log n) standard algorithm with a slightly modified Jarvis' march It is done in two phases 23

24 Chan's Algorithm phase one The first phase consists in building r equal partitions with m elements each. Then we can apply some standard algorithm to our r smaller partitions O( r m log (m) ) = O ( n log m ) notice that if we set m = h, then we get O( n log h ) 24

25 Chan's Algorithm phase two Now it's time to wrap together our little gifts Modify Jarvis' march to our advantage Start from P0 (lowest y coord) compute all tangents from the current point to the smaller hulls the next edge can be either the following edge on the current hull one of the O(r) computed tangents so we only need to compare O(r) angles repeat till we end up in P0 again. P0 25

26 Chan's Algorithm Since each of the m points is already sorted, tangents can be computed in O(log m) time using a binary search like approach To sum up phase 2: for each point in the solution we: compute O(r) tangents in O(log m) each evaluate O(r) angles choose next point in the hull So we end up with O( h r log m ) Again, when m = h it's O(n log h) Oh wait but... how do we know h in advance? We don't! 26

27 Chan's Algorithm PartialHull(S, m) r < ceil (n/m) divide S into r partitions for i = 1..r do // let CH[i] be the hull of P[i] CH[i] < Graham(P[i]) end p(0) < (inf, 0) // neg x axis as first // edge of the march p(1) < min_y(s) for k = 1..m do for i = 1..r do comp. tangency points to CH[i] end compute angles for all tangents p(k+1) < point minimizing the angle if p(k+1) = p(1) then return p end // fail if it didn't close after m iterations return m_too_small Let us write an initial version of the algorithm that returns an error code if the given m is less than h Complexity is O(n log(m)) 27

28 Chan's Algorithm We now have to guess m An idea would be starting with a small value m = 2 At each step we square the previous value till PartialHull succeeds Hull(S) for t = 1,2,... do m < max ( n, 2^(2^t) ) CH < PartialHull(S,m); if CH!= m_too_small then return CH; end 28

29 Chan's Algorithm Complexity Analysis PartialHull is O(n log m) that is O( n 2 t ) for a given t will stop when m >= h that is, when t = ceil (log 2 log 2 h) Hull(S) for t = 1,2,... do m < max ( n, 2^(2^t) ) CH < PartialHull(S,m); if CH!= m_too_small then return CH; end (t = 1..lg lg h) ( n 2 t ) = n (t = 1..lg lg h) ( 2 t ) <= n 2 (1 + lg lg h) = 2n lg h = O (n log h) 29

30 Webography About convex hulls and CG Some good java applets available online