Computational Geometry: Basic structures, Convex Hulls and Randomized Algorithms§

author:	David Coeurjolly

Context§

Objects

Point sets in $\mathbb{R}^d$
Point sets with combinatorial structures
- Triangular mesh (combinatorial manifold)
- Tetrahedral mesh
- Simplicial characterization
Family of shapes (segments, circles, …)

Geometrical problems

Collision/Intersection/Proximity tests
Point localization queries
Manifold reconstruction from point sets
…

Theoretical questions

Computational cost/size of data structure to answer given class of queries
Correctness of given geometry processing algorithm
Degeneracies and Robustness analysis
…

Geometrical Predicate Approach§

Idea

Rewrite geometrical algorithms in terms of series of
- Elementary geometrical operations (e.g. point/line creation, …)
- Elementary geometrical predicates (e.g. does two lines intersect?)
Robustness and correctness rely on robust and correct implementation of such elementary predicate

Example


$Orientation(p,q,r)$	$InCircle(p,q,r,s)$

Segment processing§

Cross product

$\vec{u}\times\vec{v}$ ‘norm’ is the signed area of the parallelogram $\vec{u}, \vec{v}$ . Obviously, $\vec{u}\times\vec{v}=-\vec{v}\times\vec{u}$

Orientation predicate = sign of the determinant

$Orientation(p,q,r) = sign( det\left ( \vec{pq},\vec{pr} \right ))$

$\Rightarrow$ {+, 0, - } output

Notations§

Sometimes, Orientation is defined as the sign of the determinant of the following matrix

$\left [ \begin{array}{ccc} 1 & p_x & p_y\\1 & q_x & q_y\\1& r_x &r_y\end{array}\right]$

Use-case 1: Detect segment intersection§

Problem

Given $\{p_1,p_2,p_3,p_4\}$ , decide if $[p_1p_2]$ intersects $[p_3p_4]$

Algorithm

Simple reject case: if bounding box of $[p_1p_2]$ does not intersect the bounding box of $[p_3p_4]$
- requires exact predicates $x_1 < x_2$ on point coordinates
Segments intersects if each segment intersects the straight line defined by the other one
- intersects iff
  - $Orientation(p_3,p_4,p_1) \neq Orientation(p_3,p_4,p_2)$
  - or specific cases when $Orientation(p_3,p_4,p_1) = Orientation(p_3,p_4,p_2) =0$ (aligned segments)
- We need exact orientation predicates to handle all cases

Robustness§

Orientation predicate implementation

Beside capacity issues ( $x*y$ must be representable), exact computations for integer built-in types (int, long int, …)
IEEE 754 “double”: specific bit for sign but issues may appear in product and subtraction $\Rightarrow$ uncertainty

$\Rightarrow$ Error control, filtered predicates, formal rewritting, interval computations …

Convex Hull 1: Graham’s Scan§

Step 1

Given a set of point $\{p_0,\ldots,p_n\}$ in $\mathbb{R}^2$ ,

W.l.o.g., let $p_0$ be the leftmost bottom points
We sort remaining points $\{p_1,\ldots,p_n\}$ by polar angles

Implementation

$Orientation(p_0,p_i,p_j)$ induces an polar order on points

$p_i \prec p_j$

Step 1 is in $O(N\log N)$

Convex Hull 1: Graham’s Scan 2§

Step 2

$p_0$ is necessarily a point in the convex hull (we assume $p_i$ are sorted)
We scan each point triplet and reject those inducing concave parts

Algo

Push(p0) to S
Push(p1) to S
Push(p2) to  S
For i from 3 to N
  While the angle (head(S / {head(S)}) , head(S), p_i) is convex
    Pop(S);
  Push(p_i) to S;

Step 2 is in $O(N)$

Graham’s scan§

$O(N\log N)$ algorithm
Stack + Orientation predicate
Can be transformed to be incremental
- Point insertion in a sorted list
- Local update of the convex hull (but could be in O(N) )

Convex Hull 2: QuickHull§

Idea Recursive approach with decimation principle

function  QuickHull(Set S, Point pLeft, Point pRight)
{
  if S == {pLeft, pRight} return edge [pLeft,pRight]

  pH = FurthestPoint(S, pLeft, pRight)
  S1 = points of S on the left of vector [pLeft,pH]
  S2 = points of S on the right of vector [pH,pRight]

  return QuickHull(S1,pLeft,pH) + QuickHull(S2,pH,pRight)
}
//starting from two points on the convex hull (details skipped but not tricks here)

QuickHull is in $O(N^2)$ (but really fast)

Dynamic convex hulls§

Problem we want to update CH(S + {p}) from CH(S)

Key object: supporting lines

Supporting lines can be extracted in $O(\log N)$ with Orientation predicate

$\Rightarrow$ incremental convex hull in $O(N \log N)$

Specific convex hulls: Simple polygonal chain§

Problem settings Let $\{s_0, \ldots, s_{n-1}\}$ be a simple polygonal chain (no self-intersection)

Solution Melkman’s algorithm

Data structure : double ended queue (push/pop on top and insert/remove from the bottom)
Incremental construction: $C_i=\{s_0,\ldots, s_i\}$ and $Q_i=CH(C_i)$
The deque $D_i=<d_b,d_{b-1},\ldots,d_{t-1},d_t>$ stores the sequence of points in $Q_i$ (with $d_b=d_t$ )

Melkman’s algorithm§

//Init
if Orientation(v0,v1,v2) then D=<v2,v0,v1,v2> else D=<v2,v1,v0,v2>
i = 3;

while (i<N)
{
  //Simple case, no update required
  while (Orientation(d_{t-1},d_t,vi)) and Orientation(d_b,d_{b+1}, vi))
    i++;

  //Ok, vi is exterior to Q_i, we restore the convexity
  repeat
    pop(d_t)
  until Orientation(d_{t-1},d_t,vi);
  push(vi);
  repeat
    remove(d_b)
  until Orientation(vi,d_b,d_{b+1});
  insert(vi);
}
//Done

Thanks to the simplicity of the polygonal chain, correctness can be demonstrated with $O(N)$ complexity

Convex hulls in higher dimension§

Given a set S pf N points in space

Dimension 2 CH(S) has O(N) vertices/edges

Dimension 3

any convex polytope with n vertices has
- at most 3n-6 edges
- at most 2n-4 facets
(proof: convex polytope $\rightarrow$ planar graph $\rightarrow$ Euler’s formula $n-n_e+n_f = 2$ and $2n_e\geq 3n_f$ )
$\Rightarrow$ complexity of CH(S) in 3-space is O(N)

Dimension d

CH(S) as a complexity in $O(N^{\lfloor d/2\rfloor})$

Convex hull algorithms in 3-Space§

Visibility based approaches

Extract visibility horizon and update the convex hull

Output sensitive algorithms§

Idea

Computational cost proportional to the output size.

Dim 2

Jarvis’s march $O(Nh)$
Kirkpatrick and Seidel $O(N\log h)$

Dim 3

Gift-Wrapping method $O(Nh)$
Chan’s algorithm $O(N\log h)$

Dim d

Chan’s algorithm $O(N\log h + (Nh)^{1-\frac{1}{\lfloor d/2\rfloor+1}}\log^{O(1)} N)$

QuickHull in 3-space§

Simple construction

Recursive construction starting from a tetrahedron and decimation principle
At each step, construct a tetrahedron from a base triangle and its furthest point
Iterative construction of the convex hull
Quadratic complexity but very efficient*

Randomization on Computational Geometry§

Introduction§

Idea

For some algorithms, randomized algorithm can be defined with expected computational cost

E.g. “the expected computational cost of algorithm A is O(N)”

Keep in mind that

Usually, the input set is not random set (e.g. convex hull for a uniform distribution of points in space …)
but randomness in the order of which the points are processed

Why?

In some algorithms, computational bottlenecks occur for specific sequences/configurations of points
Shuffling the input sequence points implies that we can prove that bottlenecks cannot occur often

Example: Binary Space Partitions§

Idea

Given a set of segments $\{s_i\}$ , we construct a binary tree partitioning the space such that each segment splits the space by its associated line $l(s_i)$

Widely used in many applications for fast visibility tests (first introduced in Doom ;))

Simple Tree construction§

$S=\{s_1,\ldots,s_n\}$

function 2DBSP(S)
{
   if (Card(S) <= 1)
      Create a tree T consisting of a single leaf node containing S
   else
   {
     //We split along l(s1) (first element of S)
     S+ = { s\cap l(s1)+, s in S);
     S- = { s\cap l(s1)-, s in S);
     T+ = 2DBSP(S+)
     T- = 2DBSP(S-)
     Create a tree T with root node v (S(v)={s in S, s subset l(s1)})
     and sub-trees T+ and T-
   }
   return T;
}

By construction, some segments can be decomposed into parts
For specific sequences of segments, each “split” can generate $O(|S|)$ new segments (called fragments)

Randomization§

function Random2DBSP(S)
{
  Generate random permutation S'=s1, ..., sn of the set S
  return 2DBSP(S')
}

Nice, but does it help to bound the number of fragments ?

Main result

Thm.

The expected number of fragments generated by Random2DBSP is $O(n\log n)$

(instead of $O(n^2)$ with naive approach)

Observation: The order matters§

Proof§

We want to compute how many fragments are induced by $s_i$
We define $dist_{s_i}(s_j)$ the number of segments intersecting $l(s_i)$ in between $s_i$ and $s_j$

( $dist_{s_i}(s_j)=+\infty$ if $l(s_i)$ does not intersect $s_j$ )

Let us define $k = dist_{s_i}(s_j)$ and let $s_{j1}, s_{j2}, \ldots, s_{jk}$ be such segments between $s_i$ and $s_j$ .

Question what is the probability that $l(s_i)$ cut $s_j$ ?

$s_i$ must be before $s_j$ is the random sequence. Moreover, $s_i$ must be before all segments $\{s_{jk}\}$
By uniformity hypothesis on the random permutation

$\Rightarrow Prob[l(s_i)\text{ cut }s_j] = \frac{1}{dist_{s_i}(s_j) + 2}$

Proof (bis)§

Some segments $s_m$ may exist such that $l(s_m)$ shield $s_j$ from $s_i$ . Hence, we do not have an equality in the Expectation expression:

$E[\text{number of fragments generated by }s_i] \leq \sum_{j\neq i} \frac{1}{dist_{s_i}(s_j) + 2}\\ \quad\quad\quad \leq 2\sum_{k=0}^{n-2} \frac{1}{k + 2}\\ \quad\quad\quad \leq 2 \ln(n)$

$\Rightarrow$ By linearity of expectation, the expected number of segments is $n + 2n \ln(n)$

Computational Geometry: Basic structures, Convex Hulls and Randomized Algorithms§

Basic elements§

Context§

Geometrical Predicate Approach§

Segment processing§

Notations§

Use-case 1: Detect segment intersection§

Robustness§

Convex Hulls§

Convex Hull 1: Graham’s Scan§

Convex Hull 1: Graham’s Scan 2§

Illustration§

Illustration§

Graham’s scan§

Convex Hull 2: QuickHull§

Dynamic convex hulls§

Specific convex hulls: Simple polygonal chain§

Melkman’s algorithm§

Convex hulls in higher dimension§

Convex hull algorithms in 3-Space§

Output sensitive algorithms§

QuickHull in 3-space§

Randomization on Computational Geometry§

Introduction§

Example: Binary Space Partitions§

Simple Tree construction§

Randomization§

Observation: The order matters§

Proof§

Proof (bis)§

Computational Geometry: Basic structures, Convex Hulls and Randomized Algorithms§

Basic elements§

Context§

Geometrical Predicate Approach§

Segment processing§

Notations§

Use-case 1: Detect segment intersection§

Robustness§

Convex Hulls§

Convex Hull 1: Graham’s Scan§

Convex Hull 1: Graham’s Scan 2§

Illustration§

Illustration§

Graham’s scan§

Convex Hull 2: QuickHull§

Dynamic convex hulls§

Related problem: Line - Convex intersection§

Specific convex hulls: Simple polygonal chain§

Melkman’s algorithm§

Convex hulls in higher dimension§

Convex hull algorithms in 3-Space§

Output sensitive algorithms§

QuickHull in 3-space§

Randomization on Computational Geometry§

Introduction§

Example: Binary Space Partitions§

Simple Tree construction§

Randomization§

Observation: The order matters§

Proof§

Proof (bis)§