4. Computational geometry

B. Convex Hull: divide and conquer ("Quick Hull")

• "Quick Hull" (something like Quicksort)

Quick_Hull_Top (P; P1, P2): { set of points P, points P1, P2}

   Find point with maximum d value >= 0 from line (P1, P2) 
     - if no point exists with d > 0,  
     then find one with d=0 that lays between P1 and P2 
    (use distance between points to determine if between)
   --> call it Pmax

   if no such point 
      then add edge (P1, P2) to convex hull

      else recurse: { 
         Quick_Hull_Top(P; P1, Pmax)
         Quick_Hull_Top(P; Pmax, P2)
}

• this finds the top part of convex hull only
• write a "Quick_Hull_Bottom" which is like above, except finds minimum d value (most negative)
• --> discovers bottom part of hull
• To initialize:

P1 = (a point with minimum X coord),
P2 = (a point with maximum X coord)
Quick_Hull_Top(P; P1, P2)
Quick_Hull_Bottom(P; P1, P2)

• Important time-saving note: collapse Quick_Hull_Top and Quick_Hull_Bottom into just "Quick_Hull": switch order of P1 and P2 arguments to derive opposite case!

B. Trisection Triangulation Algorithm (divide & conquer)

1. Compute convex hull for points P
2. Take a random interior point Q, and divide the hull polygon into triangles
3. For each triangle Ti created:
• call Trisect(Ti)

• 7 triangles created: T1=(P1,P2,Q), T2=(P2,P3,Q), etc.
• Suggestion: in step 2, choose a point in the middle (eg. point closest to the center of gravity)

• Note: If no interior point available in step 2, and point is on the hull, need to skip hull points that are colinear (consecutive hull edge on same line):

B. Trisection (cont)

• Trisect(triangle T)
• Find a point P interior to T, or on an edge of T.
• if no such P, then add triangle T to trisection
• else:
• create new triangles from vertices of T and P
• special case: when Pc is on an edge of T
• call Trisect on each new triangle from T and P
• Optimization 1 (for better triangulation):
• Find P which is closest to center of gravity of T

• Optimization 2 (for faster execution):
• Use extents of T to determine which points to test for being interior to T.

C. Triangulation cleanup algorithm

• Trisection output is not 'optimal'. A cleanup algorithm can be applied to make a Minimum-Weight Triangulation.
• Repeat until no changes possible:
• find 2 triangles that share an edge: tri1(p1, p3, p2), tri2(p1, p3, p4)
• d1 <- dist(P1, P3)
• d2 <- dist(P2, P4)
• if |d2| < |d1| AND P1, P3 on opposite sides of line (p2, P4)
• (ie. (*) signed dist of P1 and P3 from line (P2, P4) have opp. signs)
• then replace triangles with (P1, P2, P4) and (P2, P4, P3)

• Need step (*) to avoid this:

Example screendumps

• Example 1: Trisection 400 random points, starting from top-left.
• Example 2: Trisection 400 random points, starting from centre of gravity.
• Example 3: Cleaned up 400 random points. Example 1 took 1308 alterations, while example 2 took 1061.
• Example 4: Trisection of 10 by 10 grid.
• Example 5: Cleaned up 10 by 10 grid. 128 alterations.
• Random 30000 pt 2D triangulation by Ryan Van Luttikhuisen: before and after clean-up. 59922 triangles total, 149950 reconstructions.
• Example 20000 random pt triangulation by Will Barry. (108K gif)
• 100 by 100 lattice 2D triangulation by Sean Thompson (30K gif; OpenGL and Windows 95)

Trisection algorithm complexity

• The Greedy algorithm:
• Sorting edges: O(N log N)
• matching: O(N^3)
• approx. N^2 edges to process
• our naive matching uses f(N) = N time
• therefore O(N^3)
• More efficient methods use O(log N)
• Therefore our approach is: O(N^3)
• Better Greedy implementations: O(N^2 log N)
• Trisection algorithm: not sure!
• Creating the hull: O(N log N)
• Creating initial triangulation: O(N log N)  ?
• Clean up:
  • N^2 edges to match, a total of K times (number of times until cleaned).
  • O(N^3) or higher?
• However, more complex algorithms are much faster
• eg. Delaunay triangulation: O(N log N) 
• eg. for simple polygons (below) Chazelle (1991): O(n) 

Triangulating a simple polygon

• henceforth assume we are only dealing with simple polygons
• a triangulation of a simple polygon is a collection of edges and chords of that polygon such that the polygons defined by edges sharing vertices are all triangles
• Theorem: An n-vertex polygon can be triangulated by n-3 chords into n-2 triangles
• Proof: induction on n
• Base: n = 3 (a triangle)
• Inductive: assume polygon P has n >= 4 vertices
• Let b be a convex vertex (*), and a and c be its neighbours.
  (*) Convex vertex: angle between edges ba and bc <= 180 degrees. Can find extremum (min X, etc.) vertex of polygon; should be convex at that point.
• Case 1: edge a-c is a chord. Thus the rest of the polygon has n-1 vertices (take out vertex b), and by induction hypothesis, has n-4 chords that divide it into n-3 polygons
• Case 2: edge a-c is not a chord. Find the vertex within triangle b-a-c that has the furthest distance from line a-c, on same side of a-c as vertex b. Call this vertex d. The diagonal b-d must lie within tri b-a-c; if some edge intruded on b-d, then there would exist a vertex further from a-c, which is not possible. Hence b-d is a chord. Partition P into smaller polygons P1 and P2 using b-d. By the induction hyp, since P1 and P2 both have vertices less than n vertices, both P1 and P2 can be triangulated.

Application to 3D geometry

• convex hull, triangulations can also be extended to 3d space
• instead of saving edges, you save plane surfaces (polygons) in 3d space
• You can apply the 2d triangulation algorithms to 3d models:
• eg. Geographic data: altitude readings of a mountain at various (x, y) coords.
• can ignore the altitude data (z coordinate) and get a x-y triangulation
• then, when z coordinate incorporated, the triangles create a surface
• Convenient way to automatically generate surfaces for 3d objects
• 3D scanners: sample points manually or automatically from physical objects
• Require 3D triangulation algorithms to process these sampled geometric data and create polygonal surface
• Research in graphics is looking at how to optimize these meshes, since they may have lots of polygons.
• These are examples of triangulated surface meshes.
• Also example of polygon reduction algorithms: minimize polygon count while retaining features of original model.

Voronoi diagrams

• Voronoi Diagram: given a set of points P on the plane, a Voronoi diagram gives, for each point p in P, the region for which p is the closest point
• practical use (among many): post office problem
  • which post office is in the nearest proximity to different streets
• Algorithm to compute Voronoi diagram: divide & conquer, O(n log n)
• Once you have a Voronoi diagram:
  • (1) draw an edge between each pair of points that share a Voronoi edge
    • --> optimal triangulation!
  • (2) draw edges between points that share edges, but lay in "infinite" regions
    • --> convex hull!
• Illustration [Preparata]

References:

• Computer Graphics, F.S. Hill Jr, Macmillan 1990, ISBN 0-02-354860-6. (Good overview of 2D geometry.)
• Computational Geometry: an Introduction, F.P. Preparata and M.I. Shamos, Springer-Verlag 1985, ISBN 0-387-96131-3. (Comprehensive and advanced.)
• Computational Geometry in C , J. O'Rourke, Cambridge University Press 1993, ISBN 0-521-44592-2. (Excellent intro with C).
• Computational Geometry and Computer Graphics in C++, M.J. Laszlo, Prentice-Hall 1996, ISBN 0-13-290842-5. (Good introduction and lots of C implementation.)
• Computational geometry on the web

COSC 3P98 Computer Graphics
Brock University
Dept of Computer Science
Copyright © 2007 Brian J. Ross (Except noted figures).
http://www.cosc.brocku.ca/Offerings/3P98/course/lectures/comp_geom/
Last updated: March 1, 2010