Post on 09-Jan-2017
CONVEX HULLSChan's optimal output sensitivealgorithms for convex hulls
Alberto ParraviciniUniversité libre de Bruxelles
December 15, 2016
What's on themenu?
→ Basic notions
→ Algorithms for convex hulls
→ Optimal 2D algorithm
→ Optimal 3D algorithm
2
What's on themenu?
→ Basic notions
→ Algorithms for convex hulls
→ Optimal 2D algorithm
→ Optimal 3D algorithm
2
What's on themenu?
→ Basic notions
→ Algorithms for convex hulls
→ Optimal 2D algorithm
→ Optimal 3D algorithm
2
What's on themenu?
→ Basic notions
→ Algorithms for convex hulls
→ Optimal 2D algorithm
→ Optimal 3D algorithm
2
basic notions
Crash course on convex hulls
A convex set S is a set in which, ∀ x, y ∈ S, thesegment xy ⊆ S.
Given a set of points P in d dimensions, theConvex Hull CH(P) of P is:
→ theminimal convex set containing P.
→ the union of all convex combinations ofpoints in P, i.e. the points CH(P) are s.t.|P|∑i=1
wi · xi, ∀xi ∈ P, ∀wi : wi ≥ 0 and|P|∑i=1
wi = 1
4
Crash course on convex hulls
A convex set S is a set in which, ∀ x, y ∈ S, thesegment xy ⊆ S.
Given a set of points P in d dimensions, theConvex Hull CH(P) of P is:
→ theminimal convex set containing P.
→ the union of all convex combinations ofpoints in P, i.e. the points CH(P) are s.t.|P|∑i=1
wi · xi, ∀xi ∈ P, ∀wi : wi ≥ 0 and|P|∑i=1
wi = 1
4
Crash course on convex hulls
A convex set S is a set in which, ∀ x, y ∈ S, thesegment xy ⊆ S.
Given a set of points P in d dimensions, theConvex Hull CH(P) of P is:
→ theminimal convex set containing P.
→ the union of all convex combinations ofpoints in P, i.e. the points CH(P) are s.t.|P|∑i=1
wi · xi, ∀xi ∈ P, ∀wi : wi ≥ 0 and|P|∑i=1
wi = 1
4
Output sensitive algorithm
The complexity of an output-sensitivealgorithm is a function of both the input size
and the output size.
5
algorithms for convex hulls
Jarvis's march
→ Core idea: given an edge pq of the convexhull, the next edge qr to be added willmaximize the angle ∠∠∠pqr
→ At each step we scan all the n points.
→ How many steps? h, size of the hull.
→ Complexity: O(nh)
7
Jarvis's march
→ Core idea: given an edge pq of the convexhull, the next edge qr to be added willmaximize the angle ∠∠∠pqr
→ At each step we scan all the n points.
→ How many steps? h, size of the hull.
→ Complexity: O(nh)
7
Jarvis's march
→ Core idea: given an edge pq of the convexhull, the next edge qr to be added willmaximize the angle ∠∠∠pqr
→ At each step we scan all the n points.
→ How many steps? h, size of the hull.
→ Complexity: O(nh)
7
Jarvis's march
→ Core idea: given an edge pq of the convexhull, the next edge qr to be added willmaximize the angle ∠∠∠pqr
→ At each step we scan all the n points.
→ How many steps? h, size of the hull.
→ Complexity: O(nh)
7
One step, visually
Figure: A step of the Jarvis March. The red line is the nextsegment that will be added to the hull.
8
Jarvis's march
Algorithm 1: Jarvis MarchInput: a list S of bidimensional points.Output: the convex hull of the set, sorted counterclockwise.hull =[]x0 = the leftmost point.hull.push(x0)Loop hull.last() != hull.first()
candidate = S.first()foreach p in S do
if p != hull.last() and p is on the right of the segment”hull.last(), candidate” thencandidate = p
if candidate != hull.first then hull.push(candidate) else breakreturn hull
9
Graham's scan
→ Sort the points in clockwise order aroundthe leftmost point - Cost: O(n log n)
→ Keep the current hull in a stackH = {h0, . . . , hcurr}.
→ Inspect each point p in order - Cost: O(n)
→ While hcurr−1hcurrp is a right turn, pop hcurr.→ Push p to H.
→ Overall complexity: O(n log n)
10
Graham's scan
→ Sort the points in clockwise order aroundthe leftmost point - Cost: O(n log n)
→ Keep the current hull in a stackH = {h0, . . . , hcurr}.
→ Inspect each point p in order - Cost: O(n)
→ While hcurr−1hcurrp is a right turn, pop hcurr.→ Push p to H.
→ Overall complexity: O(n log n)
10
Graham's scan
→ Sort the points in clockwise order aroundthe leftmost point - Cost: O(n log n)
→ Keep the current hull in a stackH = {h0, . . . , hcurr}.
→ Inspect each point p in order - Cost: O(n)
→ While hcurr−1hcurrp is a right turn, pop hcurr.→ Push p to H.
→ Overall complexity: O(n log n)
10
Graham's scan
→ Sort the points in clockwise order aroundthe leftmost point - Cost: O(n log n)
→ Keep the current hull in a stackH = {h0, . . . , hcurr}.
→ Inspect each point p in order - Cost: O(n)→ While hcurr−1hcurrp is a right turn, pop hcurr.
→ Push p to H.
→ Overall complexity: O(n log n)
10
Graham's scan
→ Sort the points in clockwise order aroundthe leftmost point - Cost: O(n log n)
→ Keep the current hull in a stackH = {h0, . . . , hcurr}.
→ Inspect each point p in order - Cost: O(n)→ While hcurr−1hcurrp is a right turn, pop hcurr.→ Push p to H.
→ Overall complexity: O(n log n)
10
Graham's scan
→ Sort the points in clockwise order aroundthe leftmost point - Cost: O(n log n)
→ Keep the current hull in a stackH = {h0, . . . , hcurr}.
→ Inspect each point p in order - Cost: O(n)→ While hcurr−1hcurrp is a right turn, pop hcurr.→ Push p to H.
→ Overall complexity: O(n log n)
10
Graham's scan
Algorithm 2: Graham ScanInput: a list S of bidimensional points.Output: the convex hull of the set, sorted counterclockwise.hull =[]x0 = the leftmost point.Put x0 as the first element of S.Sort the remaining points in counter-clockwise order, withrespect to x0.Add the first 3 points in S to the hull.forall the remaining points in S do
while hull.second_to_last(), hull.last(), p form a right turn dohull.pop()
hull.push(p)return hull
11
Canwe do better?
So far:
→ Jarvis’s march: O(nh)→ Graham’s scan: O(n log n)
→ How do we compare their complexity?
→ We would like to do even better!
Can we get to O(n log h)?
12
Canwe do better?
So far:→ Jarvis’s march: O(nh)
→ Graham’s scan: O(n log n)
→ How do we compare their complexity?
→ We would like to do even better!
Can we get to O(n log h)?
12
Canwe do better?
So far:→ Jarvis’s march: O(nh)→ Graham’s scan: O(n log n)
→ How do we compare their complexity?
→ We would like to do even better!
Can we get to O(n log h)?
12
Canwe do better?
So far:→ Jarvis’s march: O(nh)→ Graham’s scan: O(n log n)
→ How do we compare their complexity?
→ We would like to do even better!
Can we get to O(n log h)?
12
Canwe do better?
So far:→ Jarvis’s march: O(nh)→ Graham’s scan: O(n log n)
→ How do we compare their complexity?
→ We would like to do even better!
Can we get to O(n log h)?
12
Canwe do better?
So far:→ Jarvis’s march: O(nh)→ Graham’s scan: O(n log n)
→ How do we compare their complexity?
→ We would like to do even better!
Can we get to O(n log h)?
12
chan's 2d algorithm
Chan's 2D algorithm
→ Idea: Some points will never be in the hull!Discard them to speed up Jarvis’s march.
→ Combine Jarvis’s march and Graham’s scan.
→ Algorithm (Chan 2D):
→ Split the n points in groups of sizem(⌈n/m⌉ groups).
→ Compute the hull Hi of each groupCost: O((n/m) · (m log m)) = O(n log m)
→ Until the hull is complete, repeat:
→ Given the current hull Htot = {h0, . . . , hcurr},find for each Hi the point right tangent tohcurr (binary search, O(log m)⌈n/m⌉).
→ Pick the tangent point p that maximizes∠hcurr−1hcurrp.
14
Chan's 2D algorithm
→ Idea: Some points will never be in the hull!Discard them to speed up Jarvis’s march.
→ Combine Jarvis’s march and Graham’s scan.
→ Algorithm (Chan 2D):
→ Split the n points in groups of sizem(⌈n/m⌉ groups).
→ Compute the hull Hi of each groupCost: O((n/m) · (m log m)) = O(n log m)
→ Until the hull is complete, repeat:
→ Given the current hull Htot = {h0, . . . , hcurr},find for each Hi the point right tangent tohcurr (binary search, O(log m)⌈n/m⌉).
→ Pick the tangent point p that maximizes∠hcurr−1hcurrp.
14
Chan's 2D algorithm
→ Idea: Some points will never be in the hull!Discard them to speed up Jarvis’s march.
→ Combine Jarvis’s march and Graham’s scan.
→ Algorithm (Chan 2D):→ Split the n points in groups of sizem
(⌈n/m⌉ groups).
→ Compute the hull Hi of each groupCost: O((n/m) · (m log m)) = O(n log m)
→ Until the hull is complete, repeat:
→ Given the current hull Htot = {h0, . . . , hcurr},find for each Hi the point right tangent tohcurr (binary search, O(log m)⌈n/m⌉).
→ Pick the tangent point p that maximizes∠hcurr−1hcurrp.
14
Chan's 2D algorithm
→ Idea: Some points will never be in the hull!Discard them to speed up Jarvis’s march.
→ Combine Jarvis’s march and Graham’s scan.
→ Algorithm (Chan 2D):→ Split the n points in groups of sizem
(⌈n/m⌉ groups).→ Compute the hull Hi of each group
Cost: O((n/m) · (m log m)) = O(n log m)
→ Until the hull is complete, repeat:
→ Given the current hull Htot = {h0, . . . , hcurr},find for each Hi the point right tangent tohcurr (binary search, O(log m)⌈n/m⌉).
→ Pick the tangent point p that maximizes∠hcurr−1hcurrp.
14
Chan's 2D algorithm
→ Idea: Some points will never be in the hull!Discard them to speed up Jarvis’s march.
→ Combine Jarvis’s march and Graham’s scan.
→ Algorithm (Chan 2D):→ Split the n points in groups of sizem
(⌈n/m⌉ groups).→ Compute the hull Hi of each group
Cost: O((n/m) · (m log m)) = O(n log m)→ Until the hull is complete, repeat:
→ Given the current hull Htot = {h0, . . . , hcurr},find for each Hi the point right tangent tohcurr (binary search, O(log m)⌈n/m⌉).
→ Pick the tangent point p that maximizes∠hcurr−1hcurrp.
14
Chan's 2D algorithm
→ Idea: Some points will never be in the hull!Discard them to speed up Jarvis’s march.
→ Combine Jarvis’s march and Graham’s scan.
→ Algorithm (Chan 2D):→ Split the n points in groups of sizem
(⌈n/m⌉ groups).→ Compute the hull Hi of each group
Cost: O((n/m) · (m log m)) = O(n log m)→ Until the hull is complete, repeat:
→ Given the current hull Htot = {h0, . . . , hcurr},find for each Hi the point right tangent tohcurr (binary search, O(log m)⌈n/m⌉).
→ Pick the tangent point p that maximizes∠hcurr−1hcurrp.
14
Chan's 2D algorithm
→ Idea: Some points will never be in the hull!Discard them to speed up Jarvis’s march.
→ Combine Jarvis’s march and Graham’s scan.
→ Algorithm (Chan 2D):→ Split the n points in groups of sizem
(⌈n/m⌉ groups).→ Compute the hull Hi of each group
Cost: O((n/m) · (m log m)) = O(n log m)→ Until the hull is complete, repeat:
→ Given the current hull Htot = {h0, . . . , hcurr},find for each Hi the point right tangent tohcurr (binary search, O(log m)⌈n/m⌉).
→ Pick the tangent point p that maximizes∠hcurr−1hcurrp.
14
One step, visually
Figure: A step of Chan’s algorithm. In blue, the existinghull, in orange, the tangents, in red, the new edge thatwill be added.
15
Chan's 2D algorithm, part 2
Complexity: O(n log m+ (h(n/m)log m))
What aboutm? Let’s pretend the size h ofthe final hull is know.Withm = h, we get complexityO(n log h+ (h(n/h)log h)) = O(n log h)But h is not known!
→ Reiterate the algorithm, withm = 22i
→ Iteration cost: O(n log H) = O(n2i)→ O
(∑⌈log log h⌉i=1 n2i
)= O(n2⌈log log h⌉+1) = O(n log h)
16
Chan's 2D algorithm, part 2
Complexity: O(n log m+ (h(n/m)log m))
What aboutm? Let’s pretend the size h ofthe final hull is know.
Withm = h, we get complexityO(n log h+ (h(n/h)log h)) = O(n log h)But h is not known!
→ Reiterate the algorithm, withm = 22i
→ Iteration cost: O(n log H) = O(n2i)→ O
(∑⌈log log h⌉i=1 n2i
)= O(n2⌈log log h⌉+1) = O(n log h)
16
Chan's 2D algorithm, part 2
Complexity: O(n log m+ (h(n/m)log m))
What aboutm? Let’s pretend the size h ofthe final hull is know.Withm = h, we get complexityO(n log h+ (h(n/h)log h)) = O(n log h)
But h is not known!
→ Reiterate the algorithm, withm = 22i
→ Iteration cost: O(n log H) = O(n2i)→ O
(∑⌈log log h⌉i=1 n2i
)= O(n2⌈log log h⌉+1) = O(n log h)
16
Chan's 2D algorithm, part 2
Complexity: O(n log m+ (h(n/m)log m))
What aboutm? Let’s pretend the size h ofthe final hull is know.Withm = h, we get complexityO(n log h+ (h(n/h)log h)) = O(n log h)But h is not known!
→ Reiterate the algorithm, withm = 22i
→ Iteration cost: O(n log H) = O(n2i)→ O
(∑⌈log log h⌉i=1 n2i
)= O(n2⌈log log h⌉+1) = O(n log h)
16
Chan's 2D algorithm, part 2
Complexity: O(n log m+ (h(n/m)log m))
What aboutm? Let’s pretend the size h ofthe final hull is know.Withm = h, we get complexityO(n log h+ (h(n/h)log h)) = O(n log h)But h is not known!→ Reiterate the algorithm, withm = 22
i
→ Iteration cost: O(n log H) = O(n2i)→ O
(∑⌈log log h⌉i=1 n2i
)= O(n2⌈log log h⌉+1) = O(n log h)
16
Chan's 2D algorithm, part 2
Complexity: O(n log m+ (h(n/m)log m))
What aboutm? Let’s pretend the size h ofthe final hull is know.Withm = h, we get complexityO(n log h+ (h(n/h)log h)) = O(n log h)But h is not known!→ Reiterate the algorithm, withm = 22
i
→ Iteration cost: O(n log H) = O(n2i)
→ O(∑⌈log log h⌉
i=1 n2i)= O(n2⌈log log h⌉+1) = O(n log h)
16
Chan's 2D algorithm, part 2
Complexity: O(n log m+ (h(n/m)log m))
What aboutm? Let’s pretend the size h ofthe final hull is know.Withm = h, we get complexityO(n log h+ (h(n/h)log h)) = O(n log h)But h is not known!→ Reiterate the algorithm, withm = 22
i
→ Iteration cost: O(n log H) = O(n2i)→ O
(∑⌈log log h⌉i=1 n2i
)= O(n2⌈log log h⌉+1) = O(n log h)
16
Chan's 2D pseudo-code
Algorithm 3: ChanHullStep, a step of Chan’salgorithmInput: a list S of bidimensional points, the parametersm,HOutput: the convex hull of the set, sorted counterclockwise, or an empty list, if H
is < hPartition S into subsets S1, . . . , S⌈n/m⌉.for i = 1, . . . , ⌈n/m⌉ do
Compute the convex hull of Si by using Graham Scan, store the output in acounter-clockwise sorted list.
p0 = (0,−∞)p1 = the leftmost point of S.for k = 1, . . . , H do
for i = 1, . . . , ⌈n/m⌉ doCompute the points qi ∈ S that maximizes ∠pk−1pkqi, with qi ̸= pk, byperforming binary search on the vertices of the partial hull Si.
pk+1 = the point q ∈ {q1, . . . , q⌈n/m⌉}.if pk+1 = pt then return {p1, . . . , pk}
return incomplete
17
Chan's 2D pseudo-code, reprise
Algorithm 4: Chan’s algorithmInput: a list S of bidimensional pointsOutput: the convex hull of the setfor i = 1, 2, . . . do
L = ChanHullStep(S, m, H), wherem = H = min{|S|, 22i}if L ̸= incomplete then return L
18
Chan's 2D - Empirical analysisIs a real implementation O(n log h)?Test 1: fixed hull size (1000), increasing number ofpoints.
0
10
20
30
40
5050
000
1000
00
1500
00
2000
00
Number of Points
Exe
cutio
n tim
e [s
ec]
Linear Model Real Data
19
Chan's 2D - Empirical analysisIs a real implementation O(n log h)?Test 2: fixed number of points (40000), increasinghull size.
8
9
10
1150
00
1000
0
1500
0
2000
0
Size of the Hull
Exe
cutio
n tim
e [s
ec]
Logarithmic Model Real Data
20
chan's 3d algorithm
Chan's 3D algorithm
→ Idea: The structure of the algorithm doesn’tchange, just the ingredients.
Given a set S of n points with an hull of size h:→ Jarvis's march −→ Chand and Kapur's gift
wrapping - O(nh).→ Graham's scan −→ Preparata and Hong 3D
Algorithm - O(n log n).→ Finding tangents in 2D −→ Supporting planes
in 3D with Dobkin-Kirkpatrick hierarchy -O(log n).
The overall complexity is still O(n log h).
22
Chan's 3D algorithm
→ Idea: The structure of the algorithm doesn’tchange, just the ingredients.
Given a set S of n points with an hull of size h:
→ Jarvis's march −→ Chand and Kapur's giftwrapping - O(nh).
→ Graham's scan −→ Preparata and Hong 3DAlgorithm - O(n log n).
→ Finding tangents in 2D −→ Supporting planesin 3D with Dobkin-Kirkpatrick hierarchy -O(log n).
The overall complexity is still O(n log h).
22
Chan's 3D algorithm
→ Idea: The structure of the algorithm doesn’tchange, just the ingredients.
Given a set S of n points with an hull of size h:→ Jarvis's march −→ Chand and Kapur's gift
wrapping - O(nh).
→ Graham's scan −→ Preparata and Hong 3DAlgorithm - O(n log n).
→ Finding tangents in 2D −→ Supporting planesin 3D with Dobkin-Kirkpatrick hierarchy -O(log n).
The overall complexity is still O(n log h).
22
Chan's 3D algorithm
→ Idea: The structure of the algorithm doesn’tchange, just the ingredients.
Given a set S of n points with an hull of size h:→ Jarvis's march −→ Chand and Kapur's gift
wrapping - O(nh).→ Graham's scan −→ Preparata and Hong 3D
Algorithm - O(n log n).
→ Finding tangents in 2D −→ Supporting planesin 3D with Dobkin-Kirkpatrick hierarchy -O(log n).
The overall complexity is still O(n log h).
22
Chan's 3D algorithm
→ Idea: The structure of the algorithm doesn’tchange, just the ingredients.
Given a set S of n points with an hull of size h:→ Jarvis's march −→ Chand and Kapur's gift
wrapping - O(nh).→ Graham's scan −→ Preparata and Hong 3D
Algorithm - O(n log n).→ Finding tangents in 2D −→ Supporting planes
in 3D with Dobkin-Kirkpatrick hierarchy -O(log n).
The overall complexity is still O(n log h).
22
Chan's 3D algorithm
→ Idea: The structure of the algorithm doesn’tchange, just the ingredients.
Given a set S of n points with an hull of size h:→ Jarvis's march −→ Chand and Kapur's gift
wrapping - O(nh).→ Graham's scan −→ Preparata and Hong 3D
Algorithm - O(n log n).→ Finding tangents in 2D −→ Supporting planes
in 3D with Dobkin-Kirkpatrick hierarchy -O(log n).
The overall complexity is still O(n log h).
22
Chan's 3D algorithm
→ 3D Gift wrapping
→ Pick an edge ej of a face f of the partial hull.→ Find p that maximizes the angle between f and
the new face given by ej and p. Repeat for the 3edges of f.
→ Use breadth first visit to build the entire hull.→ Preparata and Hong 3D algorithm, a
divide-and-conquer algorithm for convexhulls
→ Split the set of points S in S1 and S2.→ Recursively split until the base case, then build
the convex hull.→ Merge the partial hulls.
23
Chan's 3D algorithm
→ 3D Gift wrapping→ Pick an edge ej of a face f of the partial hull.
→ Find p that maximizes the angle between f andthe new face given by ej and p. Repeat for the 3edges of f.
→ Use breadth first visit to build the entire hull.→ Preparata and Hong 3D algorithm, a
divide-and-conquer algorithm for convexhulls
→ Split the set of points S in S1 and S2.→ Recursively split until the base case, then build
the convex hull.→ Merge the partial hulls.
23
Chan's 3D algorithm
→ 3D Gift wrapping→ Pick an edge ej of a face f of the partial hull.→ Find p that maximizes the angle between f and
the new face given by ej and p. Repeat for the 3edges of f.
→ Use breadth first visit to build the entire hull.→ Preparata and Hong 3D algorithm, a
divide-and-conquer algorithm for convexhulls
→ Split the set of points S in S1 and S2.→ Recursively split until the base case, then build
the convex hull.→ Merge the partial hulls.
23
Chan's 3D algorithm
→ 3D Gift wrapping→ Pick an edge ej of a face f of the partial hull.→ Find p that maximizes the angle between f and
the new face given by ej and p. Repeat for the 3edges of f.
→ Use breadth first visit to build the entire hull.
→ Preparata and Hong 3D algorithm, adivide-and-conquer algorithm for convexhulls
→ Split the set of points S in S1 and S2.→ Recursively split until the base case, then build
the convex hull.→ Merge the partial hulls.
23
Chan's 3D algorithm
→ 3D Gift wrapping→ Pick an edge ej of a face f of the partial hull.→ Find p that maximizes the angle between f and
the new face given by ej and p. Repeat for the 3edges of f.
→ Use breadth first visit to build the entire hull.→ Preparata and Hong 3D algorithm, a
divide-and-conquer algorithm for convexhulls
→ Split the set of points S in S1 and S2.→ Recursively split until the base case, then build
the convex hull.→ Merge the partial hulls.
23
Chan's 3D algorithm
→ 3D Gift wrapping→ Pick an edge ej of a face f of the partial hull.→ Find p that maximizes the angle between f and
the new face given by ej and p. Repeat for the 3edges of f.
→ Use breadth first visit to build the entire hull.→ Preparata and Hong 3D algorithm, a
divide-and-conquer algorithm for convexhulls→ Split the set of points S in S1 and S2.
→ Recursively split until the base case, then buildthe convex hull.
→ Merge the partial hulls.
23
Chan's 3D algorithm
→ 3D Gift wrapping→ Pick an edge ej of a face f of the partial hull.→ Find p that maximizes the angle between f and
the new face given by ej and p. Repeat for the 3edges of f.
→ Use breadth first visit to build the entire hull.→ Preparata and Hong 3D algorithm, a
divide-and-conquer algorithm for convexhulls→ Split the set of points S in S1 and S2.→ Recursively split until the base case, then build
the convex hull.
→ Merge the partial hulls.
23
Chan's 3D algorithm
→ 3D Gift wrapping→ Pick an edge ej of a face f of the partial hull.→ Find p that maximizes the angle between f and
the new face given by ej and p. Repeat for the 3edges of f.
→ Use breadth first visit to build the entire hull.→ Preparata and Hong 3D algorithm, a
divide-and-conquer algorithm for convexhulls→ Split the set of points S in S1 and S2.→ Recursively split until the base case, then build
the convex hull.→ Merge the partial hulls.
23
Chan's 3D algorithm→ To find supporting planes, store each partial
hull as a Dobkin-Kirkpatrick hierarchy
→ Sequence P0, . . . , Pk of increasingly smallerapproximations of a polyhedron P = P0.
→ Build Pi+1 from Pi by picking a maximal set ofindependent vertices of Pi.
→ Overall, building the hierarchies takes O(n).
→ Finding supporting planes in 3D
→ Goal: given an edge ej and the DK hierarchy of apartial hull Hi, find the plane passing through ejand tangent to Hi in pt.
→ Find pt in constant time in Pk→ Step up in the hierarchy: if pt changes, it will
move to a neighbour (constant time check).→ The DK hierarchy has O(log m) height.
24
Chan's 3D algorithm→ To find supporting planes, store each partial
hull as a Dobkin-Kirkpatrick hierarchy→ Sequence P0, . . . , Pk of increasingly smaller
approximations of a polyhedron P = P0.
→ Build Pi+1 from Pi by picking a maximal set ofindependent vertices of Pi.
→ Overall, building the hierarchies takes O(n).
→ Finding supporting planes in 3D
→ Goal: given an edge ej and the DK hierarchy of apartial hull Hi, find the plane passing through ejand tangent to Hi in pt.
→ Find pt in constant time in Pk→ Step up in the hierarchy: if pt changes, it will
move to a neighbour (constant time check).→ The DK hierarchy has O(log m) height.
24
Chan's 3D algorithm→ To find supporting planes, store each partial
hull as a Dobkin-Kirkpatrick hierarchy→ Sequence P0, . . . , Pk of increasingly smaller
approximations of a polyhedron P = P0.→ Build Pi+1 from Pi by picking a maximal set of
independent vertices of Pi.
→ Overall, building the hierarchies takes O(n).
→ Finding supporting planes in 3D
→ Goal: given an edge ej and the DK hierarchy of apartial hull Hi, find the plane passing through ejand tangent to Hi in pt.
→ Find pt in constant time in Pk→ Step up in the hierarchy: if pt changes, it will
move to a neighbour (constant time check).→ The DK hierarchy has O(log m) height.
24
Chan's 3D algorithm→ To find supporting planes, store each partial
hull as a Dobkin-Kirkpatrick hierarchy→ Sequence P0, . . . , Pk of increasingly smaller
approximations of a polyhedron P = P0.→ Build Pi+1 from Pi by picking a maximal set of
independent vertices of Pi.→ Overall, building the hierarchies takes O(n).
→ Finding supporting planes in 3D
→ Goal: given an edge ej and the DK hierarchy of apartial hull Hi, find the plane passing through ejand tangent to Hi in pt.
→ Find pt in constant time in Pk→ Step up in the hierarchy: if pt changes, it will
move to a neighbour (constant time check).→ The DK hierarchy has O(log m) height.
24
Chan's 3D algorithm→ To find supporting planes, store each partial
hull as a Dobkin-Kirkpatrick hierarchy→ Sequence P0, . . . , Pk of increasingly smaller
approximations of a polyhedron P = P0.→ Build Pi+1 from Pi by picking a maximal set of
independent vertices of Pi.→ Overall, building the hierarchies takes O(n).
→ Finding supporting planes in 3D
→ Goal: given an edge ej and the DK hierarchy of apartial hull Hi, find the plane passing through ejand tangent to Hi in pt.
→ Find pt in constant time in Pk→ Step up in the hierarchy: if pt changes, it will
move to a neighbour (constant time check).→ The DK hierarchy has O(log m) height.
24
Chan's 3D algorithm→ To find supporting planes, store each partial
hull as a Dobkin-Kirkpatrick hierarchy→ Sequence P0, . . . , Pk of increasingly smaller
approximations of a polyhedron P = P0.→ Build Pi+1 from Pi by picking a maximal set of
independent vertices of Pi.→ Overall, building the hierarchies takes O(n).
→ Finding supporting planes in 3D→ Goal: given an edge ej and the DK hierarchy of a
partial hull Hi, find the plane passing through ejand tangent to Hi in pt.
→ Find pt in constant time in Pk→ Step up in the hierarchy: if pt changes, it will
move to a neighbour (constant time check).→ The DK hierarchy has O(log m) height.
24
Chan's 3D algorithm→ To find supporting planes, store each partial
hull as a Dobkin-Kirkpatrick hierarchy→ Sequence P0, . . . , Pk of increasingly smaller
approximations of a polyhedron P = P0.→ Build Pi+1 from Pi by picking a maximal set of
independent vertices of Pi.→ Overall, building the hierarchies takes O(n).
→ Finding supporting planes in 3D→ Goal: given an edge ej and the DK hierarchy of a
partial hull Hi, find the plane passing through ejand tangent to Hi in pt.
→ Find pt in constant time in Pk
→ Step up in the hierarchy: if pt changes, it willmove to a neighbour (constant time check).
→ The DK hierarchy has O(log m) height.
24
Chan's 3D algorithm→ To find supporting planes, store each partial
hull as a Dobkin-Kirkpatrick hierarchy→ Sequence P0, . . . , Pk of increasingly smaller
approximations of a polyhedron P = P0.→ Build Pi+1 from Pi by picking a maximal set of
independent vertices of Pi.→ Overall, building the hierarchies takes O(n).
→ Finding supporting planes in 3D→ Goal: given an edge ej and the DK hierarchy of a
partial hull Hi, find the plane passing through ejand tangent to Hi in pt.
→ Find pt in constant time in Pk→ Step up in the hierarchy: if pt changes, it will
move to a neighbour (constant time check).
→ The DK hierarchy has O(log m) height.
24
Chan's 3D algorithm→ To find supporting planes, store each partial
hull as a Dobkin-Kirkpatrick hierarchy→ Sequence P0, . . . , Pk of increasingly smaller
approximations of a polyhedron P = P0.→ Build Pi+1 from Pi by picking a maximal set of
independent vertices of Pi.→ Overall, building the hierarchies takes O(n).
→ Finding supporting planes in 3D→ Goal: given an edge ej and the DK hierarchy of a
partial hull Hi, find the plane passing through ejand tangent to Hi in pt.
→ Find pt in constant time in Pk→ Step up in the hierarchy: if pt changes, it will
move to a neighbour (constant time check).→ The DK hierarchy has O(log m) height.
24
THANK YOU!
References I
[1] C. Bradford Barber, David P. Dobkin, and Huhdanpaa Hannu.The quickhull algorithm for convex hulls.1995.
[2] T. M. Chan.Optimal output-sensitive convex hull algorithms in two and threedimensions.Discrete & Computational Geometry, 16(4):361–368, 1996.
[3] Donald R. Chand and Sham S. Kapur.
[4] Ioannis Z. Emiris and John F. Canny.An efficient approach to removing geometric degeneracies.Technical report, 1991.
[5] Christer Ericson.Real-Time Collision Detection.CRC Press, Inc., Boca Raton, FL, USA, 2004.
[6] A. Goshtasby and G. C. Stockman.Point pattern matching using convex hull edges.IEEE Transactions on Systems, Man, and Cybernetics, SMC-15(5), 1985.
26
References II
[7] David G. Kirkpatrick and Raimund Seidel.The ultimate planar convex hull algorithm ?Technical report, 1983.
[8] Joseph O’Rourke.Computational Geometry in C.Cambridge University Press, 2nd edition, 1998.
[9] F. P. Preparata and S. J. Hong.Convex hulls of finite sets of points in two and three dimensions.Commun. ACM, 20(2):87–93, February 1977.
[10] Franco P. Preparata and Michael I. Shamos.Computational Geometry: An Introduction.Springer-Verlag New York, Inc., 1985.
[11] Franco P. Preparata and Michael I. Shamos.Computational Geometry: An Introduction.Springer-Verlag New York, Inc., 1985.
Beamer theme: Presento, by Ratul Saha. The research system in Germany, byHazem Alsaied
27