Incremental Convex Hulls
Computational Geometry II
Lecturer: Gill Barequet
Gadi Aleksandrowicz
Convex Set - Definition
• A set S of points is convex if for any two
points P and Q in S, the segment PQ is
entirely contained in S.
P
S
Q
1
Convex Hull - Definition
• The convex hull of a finite set of points in
Ed is called a polytope.
• A polytope of dimension k is also called kpolytope.
A 3-polytope:
Affine Combinations
• Let S={a1,…, an} be a set of points. A linear
combination of the points with coefficients
{λ1,…, λn} is affine if
n
∑λ
i =1
i
=1
• The set of affine combinations of S if called
the affine hull of S – it is a subspace of Ed.
• k+1 points are affinely independent if they
generate an affine hull of dimension k.
2
Simplex
• The convex hull of k+1 affinely independent
points is a particular k-polytope called a
simplex or also k-simplex.
Faces of a Polytope
• A hyperplane H divides the space Ed into
two half spaces. Write H+ and H- for these
spaces (including H).
3
Faces of a Polytope (Cont.)
• A hyperplane H supports a d-polytope P and
H is called a supporting hyperplane of P if
H∩P is not empty and P is entirely contained
in one of the half spaces H+ or H-.
Faces of a Polytope (Cont.)
• The intersection H∩P of the polytope P with
a supporting hyperplane H is called a face of
the polytope P.
• Faces are convex subsets of Ed with
dimension ranging from 0 to d-1.
4
Faces of a Polytope (Cont.)
•
•
•
•
A face of dimension j is also called a j-face.
A 0-face is called a vertex.
A 1-face is called an edge.
A d-1 face (in Ed) is called a facet of the
polytope.
Representation of a Polytope
• A polytope is generally represented by the
incidence graph of its faces.
• Faces are incident if their dimensions differ
by one and one of them is contained in the
other.
5
Representation of a Polytope (Cont.)
• Theorem: In a d-polytope, every (d-2)-face is
incident to exactly two (d-1)-faces.
• Two (d-1)-faces of a polytope are said to be
adjacent if they are incident to common (d-2)
face.
• Thus, the incidence graph of a polytope also
encodes the adjacency graph, which has a
node for each facet and an arc for each pair
of adjacent faces.
A Lower Bound for the Problem
• Theorem: The time complexity of computing
the convex hull of n points in d dimensions
is:
d / 2
(
Ω n log n + n 

)
• The first term comes from a known fact: The
problem of sorting n real numbers can be
reduced into the problem of computing the
convex hull of n points in E2.
• Also, any set of points in E2 can be
embedded into E3.
6
A Lower Bound for the Algorithm
(
Ω n log n + n 
d / 2 
)
• The second term comes from the fact
that the convex hull of n points in Ed
may have Ω ( n d / 2 ) faces (not proven
here).
The Incremental Algorithm
• The basic method: Maintain the sequence of
convex hulls of the consecutive sets
obtained by adding the points in A one by
one.
• Let C be the convex hull of the current
subset and P the point to be inserted next.
The problem is thus to obtain the incidence
graph of conv(CU{P}).
• First we need to see the relations between C
and conv(CU{P}).
7
Red, Blue and Purple Faces
• Suppose a point P and polytope C are in
general position.
• The facets of C can be separated into two
classes with respect to P.
• Red facets are facets that can be seen from P.
• Blue facets are facets that cannot be seen
from P.
P
Red, Blue and Purple Faces (Cont.)
• Formally, let F be a facet and HF the hyperplane
that supports C along F.
• Let H+ be the half space bounded by HF that
contains C.
• F is red if P belongs to H- or blue if it belongs to
H+.
8
Red, Blue and Purple Faces (Cont.)
• P never belongs to HF itself, because of the
general position assumption.
• Theorem: Any face of C is the intersection of the
facets of C which contain it.
• Thus, we define the color of a face by the facets
that contain it.
P
Red, Blue and Purple Faces (Cont.)
• Face is defined by its containing facets:
Facets
All Red
All Blue
Red And Blue
Face
Red
Blue
Purple
P
9
How C Changes
• Theorem: Every face of conv(CU{P}) is either
blue or purple face of C, or the convex hull
conv(GU{P}) of P and a purple face G of C.
P
• The proof is technical, but the idea is
straightforward.
How C Changes (Cont.)
•
•
•
•
When updating C, the following things happen:
All the red faces are removed.
All the blue and purple faces remain.
We add new faces which are the result of
computing the convex hull of a purple face and
the point P.
P
10
The Incidence Relations
• If F and G are two incident faces of C and are
either blue or purple with respect to P, then F
and G are incident faces of conv(CU{P}).
• If G is a purple face, then G and conv(GU{P})
are incident faces of conv(CU{P}).
P
The Incidence Relations (Cont.)
• If F and G are incident purple faces of F, then
conv(FU{P}) and conv(GU{P}) are incident
faces of conv(CU{P}).
F
G
conv(FU{P})
conv(GU{P})
P
11
The Incidence Relations (Cont.)
• This incidence relations mean that the set of
faces that were added is isomorphic to the set
of purple faces!
• This will help us later, when we prove the
complexity bound on the algorithm.
P
Adjacency Relations
• Yet more lemmas (important to the algorithm!)
• The set of facets of C that are red with respect
to P is connected, and the set of facets of C
that are blue with respect to P is also
connected.
P
12
Adjacency Relations (Cont.)
• If C has n vertices and does not contain P,
then the set of the faces of C that are purple
with respect to P is isomorphic, for the
incidence relationship, to the set of faces of a
(d-1) polytope whose number of vertices is at
most n.
P
(Finally!) The Incremental Algorithm
• Let A be a set of n points. To find the convex
hull we first sort A lexicographically. We denote
by {A1,A2,…,An} the points of A indexed by
lexicographic order. Let Ai be the set of the first
i points.
13
The Incremental Algorithm (Cont.)
• The general idea of the algorithm is as follows:
1. Sort the points of A lexicographically.
2. Initialize the convex hull to be the simplex
conv(Ad+1).
3. The incremental step – build conv(Ai) from
conv(Ai-1) and the point Ai
The Incremental Step
• Because of the lexicographic order on the
points of A, the point Ai never belongs to the
convex hull conv(Ai-1), and is therefore a vertex
of conv(Ai).
• We saw that all the blue faces that were in
conv(Ai-1) remain unchanged in conv(Ai), so
that part of the incidence graph does not
change.
14
The Incremental Step (Cont.)
• The efficiency of the incremental algorithm
follows from the fact that the incidence graph of
the current convex hull can be updated without
looking at the blue faces or their incidences.
The Incremental Step (Cont.)
• To perform the incremental step, we proceed in
four phases:
1. We first identify a facet of conv(Ai-1) that is red
with respect to Ai.
2. The red facets and the red or purple (d-2)
faces of conv(Ai-1) are traversed.
3. Using the information gathered in phase 2, we
identify all the other red or purple faces of
conv(Ai-1).
4. The incidence graph is updated.
15
The Incidence Graph Data Structure
• For each face F of dimension k of the convex
hull, the data structure of the incidence graph
holds:
• The list of sub-faces of F, which are faces of
dimension k-1 incident to F.
• The list of super-faces of F, which are faces of
dimension k+1 incident to F.
• The color of the face (red, blue, purple) in the
current step.
• A pointer p(F) whose use will be clarified.
Phase 1
• We want to find an initial red facet with
respect to Ai in conv(Ai-1).
• Because of the lexicographic order on the
points of A:
1. The point Ai-1 is always a vertex of conv(Ai-1)
2. There is at least one facet of conv(Ai-1)
containing Ai-1 which is red with respect to
Ai.
Ai
16
Phase 1 (Cont.)
• All the facets of conv(Ai-1) that contain Ai-1
were created in the last step of the algorithm
(in which we added Ai-1).
• So we simply store them and search them
for a red facet during the next incremental
step.
Ai
Phase 2
• Now we use the connectedness of the set of
red facets.
• We perform a DFS on the subgraph of red
facets in the adjacency graph.
• Remember the adjacency graph is a graph
whose nodes are facets only and there is an
edge between two adjacent facets.
17
Phase 2 (Cont.)
• During the DFS we color red all facets
visible from Ai.
• We also color red all (d-2) faces if they are
incident to two red facets, and purple if they
are not.
• The traversal backtracks whenever the facet
encountered was already colored red, or if it
is a blue facet.
Phase 2 (Cont.)
•
•
•
•
18
Three separate lists are set up:
The red facets.
The red (d-2)-faces.
The purple (d-2)-faces.
Phase 3
• We now know all the red and purple (d-2)
faces and the red facets.
• For each dimension k between d-3 and 0 we
create:
1. A list Rk of the red k-faces
2. A list Pk of the purple k-faces.
Phase 3 (Cont.)
• The lists are set up in decreasing order of
dimensions.
• Assume inductively that all the red and
purple faces of dimension bigger than k
have already been identified and colored.
19
Phase 3 (Cont.)
• We process the k-faces in the following way:
• Each sub-face of a face of Pk+1 that has not
yet been colored is colored purple and
added to the list Pk.
• Afterwards, each sub-face of Rk+1 that has
not yet been colored is colored red and
added to the list Rk.
Phase 4
• Now we need to update the incidence graph.
• First, all the red faces are removed, and so
are all the arcs adjacent to these faces in the
graph.
• Now the purple faces are processed in order
of increasing dimension k.
Ai
20
Phase 4 (Cont.)
• If F is a k-face purple with respect to P, a new
node is created for the (k+1)-face
conv(FU{Ai}) and linked by an arc to the node
for F in the incidence graph.
Ai
Phase 4 (Cont.)
• The pointer p(F) is set to point to the new
node created for conv(FU{Ai}).
• It remains to link this node to all the incident
k-faces of the form conv(GU{Ai}), where G is
a (k-1)-face incident to F.
Ai
21
Phase 4 (Cont.)
• For each sub-face G of F, its pointer p(G)
gives a direct access to the node
corresponding to conv(GU{Ai}), and the
incidence arc can be created.
Ai
Analysis of the Algorithm
• Phase 1 (finding a red face) can be carried
out in time proportional to the number of
facets created at the previous step.
• Thus, the total cost of phase 1 over all the
steps is dominated by the total number of
facets created.
22
Analysis of the Algorithm (Cont.)
• Phase 2 (traversing the red facets) can be
carried out in time proportional to the number
of nodes visited during the traversal of the
adjacency graph.
• The nodes visited in step i correspond to the
red facets of conv(Ai-1) and to the blue faces
adjacent to them.
• Thus, the total cost of this phase is
proportional to the number of the red facets
of conv(Ai-1) and their incidences.
Analysis of the Algorithm (Cont.)
• The cost of Phase 3 (creating lists of all red
and purple faces) is bounded by constant
times the number of arcs in the incidence
graph that are visited, which is the number of
incidences between red or purple faces
conv(Ai-1).
23
Analysis of the Algorithm (Cont.)
• The cost of Phase 4 (removing red faces and
adding new faces) is proportional to:
1. The number of red faces and their
incidences.
2. The number of purple faces and their
incidences to purple faces.
Analysis of the Algorithm (Cont.)
• We have seen that when adding a point to
the convex hull, the cost of phases 2,3,4 is
proportional to:
1. The number of red and purple faces.
2. The number of faces incident to red faces.
3. The number of incident purple faces.
24
Analysis of the Algorithm (Cont.)
• Red faces and their incidences correspond to
the nodes and arcs that are removed from
the incidence graph.
• Purple faces and incidences between two
purple faces correspond to the nodes and
arcs that are added to the incidence graph.
• Thus, the total cost of phases 2,3,4 is
proportional to the number of changes
undergone by the incidence graph.
Analysis of the Algorithm (Cont.)
• The number of changes the graph undergoes
is proportional to the number of arcs and
nodes of the incidence graph that are created
during the algorithm.
• This also includes the cost of phase 1 (which
depends on the facets created in the last
step).
25
Analysis of the Algorithm (Cont.)
• Lemma: the total number of faces and
incidences created during the execution of
the algorithm building the convex hull of n
points in d dimensions is:
(
( d +1) / 2 
O n
)
• This is not the complexity of the convex hull
created by the algorithm.
Proof of the Lemma
• Reminder: The set of the faces created at
step i is isomorphic to the set of purple faces
in step i.
• The number of incidences created between a
new face and a purple face of the old convex
hull is proportional to the number of purple
faces.
• Another lemma we showed earlier shows that
the set of purple faces in step i is isomorphic
to a (d-1) polytope with at most i-1 vertices.
26
Proof of the Lemma (Cont.)
• An upper bound (we shall not prove here) for
the number of faces on a d-polytope with n
vertices:
(
O n 
d / 2 
)
• So the number of purple faces at step i is
bounded by:
(
( d −1) / 2
O i
)
Proof of the Lemma (Cont.)
• Summing over all the steps in the algorithm,
we have:
n
(

O
i
∑
i =1
27
( d −1) / 2
) (
( d +1) / 2
= O n
)
Proof of the Lemma (Cont.)
• Storage is bounded by:
(
O n 
d / 2 
)
• Reason: The storage needed by the
algorithm is the maximum size of the
incidence graph at any time.
Conclusion of the Incremental
Algorithm
• The incremental algorithm builds the convex
hull of n points in d dimensions in
d /2
time O n log n + n ( d +1) / 2 and in space O n  
• Optimal in the worst case – when d is even.
• Remember the lower bound is:
(
)
(
Ω n log n + n 
28
(
d / 2 
)
)
On-Line Convex Hull
• A similar problem, but this time we do not
have control on the order in which the points
are given.
• Similar solution: for each point, identify
whether it’s in or out of the current convex
hull.
• If it’s in, there’s nothing to do.
• If it’s out, find a red facet and proceed as
before.
On-Line Convex Hull (Cont.)
• To find a red facet, use an additional data
structure – the influence graph.
• First recast the problem in terms of objects,
regions, and conflicts.
• The objects are naturally the points of Ed.
• A region is defined in a more complex way.
29
Defining Regions
• A region is defined as a union of two open
half-spaces.
• Such a region is determined by a set of d+1
points in general position.
• Let {P0,…,Pd-1,Pd} stand for such a d+1 tuple.
Defining Regions (Cont.)
• Define a hyperplane H as the hyperplane
containing {P0,…,Pd-1}, and H- be the half
space bounded by H which does not contain
Pd.
30
Defining Regions (Cont.)
• Define another hyperplane T and a half
space T- using {P1,…,Pd}
• The region defined by {P0,…,Pd-1,Pd} is the
union H-UT-.
Defining Regions (Cont.)
• The definition may seem unnatural, but we
need it to show the update condition holds.
• A point conflicts with a region if it belongs to
at least one of the two open half spaces that
define it.
31
Defining Regions (Cont.)
• There is a bijection between regions defined
and without conflict over S with the d-2 faces
of conv(S).
The Influence Graph
• Besides the data structures of the previous
algorithm, the on-line algorithm also
maintains an influence graph.
32
The Influence Graph (Cont.)
• A directed acyclic graph
• Node for each region that at some step of the
algorithm was defined and without conflict
over the current subset of points.
The Influence Graph (Cont.)
• Each node’s influence region is contained in
the union of regions of its parents.
33
Using the Influence Graph
• A depth-first traversal of the influence graph
can detect all the conflicts between a point P
and the nodes of the graph.
• Next, find a facet of conv(S) that is red with
respect to P.
Using the Influence Graph (Cont.)
• A region defined and without conflict over S
that is in conflict with P represents a red or
purple d-2 face.
• So it is contained in at least one red facet.
34
On-Line Algorithm - Description
• Initial step: The incidence graph is set to that
of the d-simplex formed by the first d+1 points
• The influence graph is initialized with a node
for each of the regions that correspond to the
d-2 faces of this simplex.
On-Line Algorithm – Description (Cont.)
• Let S be the current set of points already
inserted, and P the new point inserted.
• The current step consists of a location phase
and an update phase.
35
On-Line Algorithm – Description (Cont.)
• The location phase detects all regions killed
by the new point P.
• Visit recursively all nodes in conflict with P,
starting from the root.
The Update Phase
• If none of the regions defined and without
conflict over S is found to conflict with P, then
P is inside conv(S) and there is nothing to do.
36
The Update Phase (Cont.)
• If we have found a conflicting leaf which
represents a region defined and without
conflict on S, it is in bijection with some d-2
purple face of conv(S), and this face is
contained in a red facet.
The Update Phase (Cont.)
• We proceed as in the incremental algorithm
and update conv(S).
37
Updating the Influence Graph
• It remains to update the influence graph.
• First consider the d-2 purple faces of conv(S),
then the d-3 faces incident to them.
Updating the Influence Graph (Cont.)
• Why are these changes enough?
• Because new node in the influence graph
mean that:
• A new d-2 face was created (from a d-3 face).
• One of the facets containing a d-2 face was
changed.
38
Updating the Influence Graph (Cont.)
• G1: a purple d-2 face of conv(S).
• (F1,F1’): the corresponding region.
• F1 and F1’: the two facets of conv(S) that are
incident to G1.
• WLOG assume F1 is blue and F1’ is red.
Updating the Influence Graph (Cont.)
• The face G1 is also a d-2 face of conv(SU{P})
that corresponds to the new region (F1,F1’’),
where F1’’ is the convex hull conv(G1U{P}).
• A new node of the influence graph is created
for the region (F1,F1’’) as the child of (F1,F1’).
• This satisfies the inclusion property.
39
Updating the Influence Graph (Cont.)
• K: a purple d-3 face of conv(S).
• G1,G2: the purple d-2 faces which contain it.
• (F1,F1’), (F2,F2’): the corresponding regions.
Updating the Influence Graph (Cont.)
• The convex hull conv(KU{P}) is a new d-2
face, which is incident to the new d-1 faces
F1’’ and F2’’.
• In the influence graph, we create a new node
for the region (F1’’, F2’’), whose fathers are
(F1,F1’), (F2,F2’).
40
Updating the Influence Graph (Cont.)
• (F1’’, F2’’) is contained in the union of (F1,F1’)
and (F2,F2’).
• That’s because the half plane defined by F1’’
is contained in the region of (F,F1’)
• The same holds for F2’’ and (F,F2’).
Updating the Influence Graph (Cont.)
• In the two dimensional case there is only one
d-3 face: The “empty” face of dimension -1,
which is incident to all vertices.
• If P is not contained within conv(S), the
empty face is purple and incident to the two
purple vertices of conv(S).
41
Randomized Analysis of the Algorithm
• We assume that the points are inserted in a
random order, and that all permutations are
equally likely.
• The performance of the algorithm is
estimated on the average.
• We apply the results of the previous chapter.
• To do so, we need to show the update
condition holds.
The Update Condition
• The update condition consists of four
separate conditions:
1. A conflict can be detected in constant time.
2. The number of children of each node of the
influence graph is upper bounded by a
constant.
3. The parents of a node created by an object O
are the nodes killed by O.
4. Updating the influence graph takes time
linear in the number of nodes killed or
created at each step.
42
The Update Condition - 1
• Testing conflicts between a point and a
region:
• Simply test if the point belongs to two half
spaces.
• This can be done in constant time.
The Update Condition - 2
• The number of children of each node in the
influence graph is bounded.
• Each node has exactly d children, or none!
43
The Update Condition – 2 (Cont.)
• Proof: When inserting a point P, the node
corresponding to a purple d-2 face G of
conv(S) receives d children.
• One child for the d-2 face G of conv(SU{P}).
• In the figure, G is A, and P is D. The child is
BAD.
The Update Condition – 2 (Cont.)
• d-1 more children corresponding to
conv(KU{P}) for each d-3 subface K of G.
• Here there is only the empty face, so
conv(KU{P})={P}, and so the child is ADC.
44
The Update Condition – 2 (Cont.)
• Why d-1 children?
• Since G is a d-2 face, so it is defined by d-1
points and every d-3 face it contains is
defined by d-2 points from that set.
• We simply choose one point to remove from
the defining set of G, for each K.
The Update Condition – 2 (Cont.)
• After being updated, the purple nodes are
killed, so they can’t receive more children.
• Nodes corresponding to red or blue d-2 faces
do not receive children.
45
The Update Condition - 3
• The parents of a region created by P are
recruited among the ones killed by P.
• Why? Because that’s exactly how the
algorithm works: It finds the regions killed,
and adds children only to them.
The Update Condition - 4
• We’ll add a bidirectional pointer which
connects every (d-2)-face in the incidence
graph to the corresponding region in the
influence graph.
• Using this, updating the influence graph takes
about the same time as updating the
incidence graph.
• The time to update the incidence graph is
proportional to the number of red and purple
faces and their incidences.
46
The Update Condition – 4 (Cont.)
• The number of red and purple faces and their
incidences is proportional to the number of
red facets (not proven here).
• Each red facet is incident to d red or purple
(d-2)-faces (e.g. in 3D, a facet contains 3
lines).
• Each of those (d-2)-faces corresponds to a
region defined and without conflict with S,
which is in conflict with P.
The Update Condition – 4 (Cont.)
• Also, each region defined and without conflict
with S which is in conflict with P corresponds
to a (d-2)-face which is incident to at least
one red facet.
• So the number of red facets is proportional to
the number of regions killed.
• Therefore, the complexity of the update of the
influence graph is proportional to the number
of regions killed.
• Thus, the update condition is fully satisfied.
47
Complexity Results
• Using the general theorem about randomized
algorithms satisfying the update condition, we
have:
• The expected running time of the algorithm
is:
(
O n log n + n 
d / 2 
)
• The expected storage is:
(
O n 
d / 2 
)
Dynamic Algorithm
• Similar to the on-line algorithm, only now we
also want to allow deletion of points.
• This makes the problem much more complex.
• Why? Because when deleting a point we
depend not only on the current convex hull,
but also on points “hidden” within the convex
hull.
48
Dynamic Algorithm (Cont.)
• We must keep information about all the
points in the current set.
• For this we use “augmented influence graph”.
• Again, we rely on general results (not proven
here) about such graphs.
The Augmented Influence Graph
• The algorithm maintains a graph whose
nodes correspond to regions defined over the
current set.
• After each deletion, we rebuild the graph into
the state it would have been in had the
deleted point never been inserted.
• Therefore, the graph depends only on the
insertion order of the points in the current set.
• Label those points P1,…,Pn.
49
The Augmented Influence Graph (Cont.)
• Denote by Σ={P1,…,Pn} the sequence of
points sorted by insertion order.
• By T(Σ) we denote the graph obtained from
the sequence Σ.
• T(Σ) is exactly like the influence graph of the
preceding section, i.e, it is the graph we
would have obtained if we had run the
previous algorithm on Σ.
The Augmented Influence Graph (Cont.)
• There are two inclusion properties satisfied
by the graph.
1. The influence zone of a node is contained in
the union of influence zones of its parents.
2. An object that belongs to the set of objects
which define a node (its determinants) is
either its creator or a determinant of one of its
parents.
• Why? Because of the way we build the
graph.
50
The Conflict Graph
• The new feature of the augmented graph is
the addition of a conflict graph which is built
upon it.
• Each node of the influence graph represents
a region. For each such region we save a list
of all the objects that conflict with it.
• The list is sorted chronologically.
• Each object has a list of pointers to the nodes
it conflicts with.
Insertion
• Insertion of a point is done almost exactly in
the same way it is done in the on-line
algorithm.
• The only difference is that while we locate an
object’s conflicts in the influence graph, each
detected conflict is added to the conflict lists.
51
Deletion
• Suppose we delete the point Pk.
• For m=k,…,n we denote by S’m the subset
Sm\{Pk} (all points up to Pm except Pk).
• By Σ’ we denote {P1,…Pk-1,Pk+1,…,Pn}.
• When deleting Pk we transform T(Σ) into
T(Σ’).
Deletion (Cont.)
• In the transformation we do three things:
1. Remove from T(Σ) the destroyed nodes –
nodes that have Pk as determinant.
2. Create a new node for each region defined
and without conflict over Sm’ for some
m=k+1,…,n that conflicts with Pk.
3. Connect new nodes to their parents (which
might not be new). Connect “unhooked” old
nodes (whose parents were destroyed) to
other parents.
52
Creators and Killers
• Let G be a region of T(Σ) and Pm a point.
• G is created by Pm if Pm is a determinant of G
with highest chronological rank.
• G is killed by Pm if Pm has the lowest rank
among the points in conflict with G.
Locating
• The deletion algorithm is made of two
phases: Locating and Rebuilding.
• During the locating phase, the algorithm
identifies the nodes in T(Σ) that are killed by
Pk and the destroyed or unhooked nodes.
• For this, the algorithm recursively visits all
nodes in conflict or determined by Pk starting
at the root.
• During the traversal we remove Pk from the
conflict lists and build a dictionary of
destroyed or unhooked nodes.
53
Rebuilding
•
1.
2.
3.
4.
During the rebuilding phase, we:
Create new nodes.
Hook new nodes to the graph.
Build conflict lists for the new nodes.
Rehook the unhooked nodes.
Rebuilding (Cont.)
• We consider in turn all the points Pm of rank
m>k that are the creators of some new or
unhooked node.
• A point Pm is such a creator if and only if
there exists a region defined and without
conflict over S’m-1 which conflicts both with Pm
and Pk.
54
Critical Regions and Zones
• A region is critical in respect to Pm if it is
defined and without conflict over S’m-1 but
conflicts with Pk.
• This means that after Pk is removed, that
region might be killed by Pm instead!
• The critical zone is the set of all critical
regions.
Critical Regions and Zones (Cont.)
• At the beginning of the rebuilding phase, the
critical regions are the regions of T(Σ) that
are killed by Pk.
• This is because if a region was killed by Pk, it
had to be defined and without conflicts before
it was killed.
• During the phase, new regions in T(Σ’) may
also be critical regions.
55
The Rebuilding Phase
• In each step, the next point to be processed
is the point of smallest rank among all points
that conflict with some of the current critical
regions.
• To find this point we use a priority queue Q of
points in Σ’ that are killers of critical regions.
• Each point in Q also stores a list of the critical
regions it kills.
The Rebuilding Phase (Cont.)
• We initialize Q with the killers in Σ’ of the
regions in the original graph that were killed
by Pk.
• This can be computed easily since Pk has
links to all the regions it kills, and all these
regions have lists of all objects conflicting
with them – sorted chronologically.
56
The Rebuilding Phase (Cont.)
• At each step we extract the point Pm of
smallest rank from Q.
• We create new nodes for new regions
created by Pm.
• We hook those regions to the influence
graph.
• We rehook unhooked regions created by Pm.
The Rebuilding Phase (Cont.)
• The new and unhooked regions created by
Pm can be found by examining critical faces –
(d-2)-faces of conv(S’m-1) that correspond to a
critical region.
• These faces are either blue, red, or purple
with respect to Pm.
• It is enough to check the critical purple (d-2)faces and their (d-3)-subfaces.
57
The Critical (d-2)-faces
• Given Pm, we can find all the critical (d-2)faces purple with respect to Pm.
• To do this simply traverse the list of all the
critical regions that Pm conflicts with.
The Critical (d-2)-faces (Cont.)
• Let G be a critical purple (d-2)-face and (F,F’)
the corresponding critical region.
• F and F’ are facets of conv(S’m-1) incident to
G.
• Assume F is blue and F’ is red.
58
The Critical (d-2)-faces (Cont.)
• What we do now is check what regions the
addition of Pm creates, and whether this
regions are truly new (i.e, they conflict with Pk
and thus were never created yet).
The Critical (d-2)-faces (Cont.)
• In conv(S’m), G is a (d-2)-face that
corresponds to (F,F’’), where F’’ is
conv(GU{Pm}).
• If (F,F’’) conflicts with Pk, it is a new region
created by Pm (since because of Pk, it was
never created before).
59
The Critical (d-2)-faces (Cont.)
• If (F,F’’) conflicts with Pk, we create a new
node for it in the augmented graph, with
(F,F’) as parent.
• The conflict list for (F,F’’) is set up from the
conflict list of (F,F’) – we take only objects
that conflict with (F,F’’) from there.
The Critical (d-2)-faces (Cont.)
• If the conflict list is not empty, the first item in
it is the killer of (F,F’’).
• We add the killer of (F,F’’) to Q (if it’s not
there yet), and add (F,F’’) to the regions killed
by this point.
60
The Critical (d-2)-faces (Cont.)
• If (F,F’’) does not conflict with Pk, it
corresponds to an unhooked node. We find
that node by the dictionary we set for
destroyed and unhooked nodes, and hook it
as a child of (F,F’).
The Critical (d-3)-faces
• Handling the (d-3)-faces is very technical and
so we’ll skip it.
61
Analysis of the Algorithm
• Deterministic algorithm, yet randomized
analysis.
• We assume:
1. The sequence Σ is random and every of the
n! permutations is equally likely.
2. Each insertion concerns, with equal
probability, any of the objects in the set
immediately after the insertion.
3. Each deletion concerns, with equal
probability, any of the objects in the set
immediately before the deletion.
Analysis of the Algorithm (Cont.)
•
1.
2.
3.
4.
Under these assumption:
Storage complexity: O n log n + n d / 2
d / 2 −1
Insertion time: O log n + n  
Deletion time in 2D and 3D: O ( log n )
Deletion time in d>3: O tn d / 2 −1
(
(
)
(
)
)
• All of the above are expected results.
• t is the time complexity of operations on the
dictionaries used by the algorithm.
62