# Convex Hulls Revisited

I have written about 3D convex hull generation here before. I find it a very appealing problem because it is so well defined and to my knowledge there is no de facto standard algorithm or implementation. I come back to this topic every now and then since I need a good implementation myself.

Quickhull is probably the most popular algorithm, but it is hard to implement in a robust way. The qhull implementation has a somewhat questionable license and more significantly it is a really complex piece of software and contains a bunch of other features. I’m on a quest to create a fast, robust convex hull generator that is free to use and is self-contained in a single cpp file.

I’m currently experimenting with an algorithm based on the support mapping, often used in physics and collision detection. The support mapping for a point cloud for a given direction is the point that is farthest in that direction, which simply means finding the point with maximum `dot(dir, point)`

. The supporting point for any direction is guaranteed to be on the convex hull of the point cloud. Very convenient.

The algorithm starts with the smallest possible closed mesh - three vertices connected by two triangles facing in opposite directions. Any three points will do, as long as they are on the convex hull (supporting vertices). Each triangle is then exanded by the supporting vertex in the normal direction. This is done by splitting the triangle into three triangles, all connected to the new vertex. This expansion step may cause the mesh to become concave, so the expansion step needs to be followed by an unfolding step, where convave edges are “flipped” to make the mesh convex again.

Flipping one edge may cause nearby edges to become concave, so this step needs to be repeated until all edges are convex, effectively “untangling” any wrinkles introduced by the expansion. Below is a short clip visualising the construction of a hull through a series of expansion and unfolding steps. For clarity, there is only 12 points and they are all on the convex hull.

The interesting thing about this method is that it is based primarily on topology. Both the expansion and the unfolding step guarantee that the mesh is kept well-defined and closed, so there are no degenerate cases. The only critical computation is how to determine wether an edge is convex or not. I’m still investigating the most robust alternative here. My current one does not deal with all degenerate cases, but I’m pretty sure this can be done.

The algorithm has a number of desirable properties:

- Can be used with a tolerance in the expansion step for automatic simplification.
- Relatively easy to implement (mine is about 400 lines of code).
- Handles co-planar and degenerate input data.
- The output mesh is built entirely from the input vertices.
- Can be modified to use any support mapping function, not just point clouds.

I’m not entirely sure this is a novel idea. I’d actually be surprised if it is, given its simplicity, but I haven’t seen any references to it before. Please write a comment if you know. I’ll get back with more details and a performance comparison later.