Good afternoon! My name is Dirk and I am a software engineer at Valve.

Some of you might have noticed that I changed the topic of my talk to:“Implementing Quickhull ”
When I was rehearsing the talk at Valve one question was: “Why a presentation about
Quickhull? Isn’t that a well understood algorithm?”
From my experience this is only partially true. You find some presentations about thebasic theory of Quickhull and some complexity analysis, but there is hardly anythingthat deals with implementing this algorithm. Especially not in a production
environment where you have to deal with all sorts of ill-defined input geometry! So
this talk will cover the basic theory of Quickhull of course, but we will also spend agood amount of time looking into problems you can run into when implementing
Quickhull and how to address those.

1

Before we start I like to quickly outline the talk:- After a short introduction I will first start with Quickhull in 2D- Then we continue with geometrical invariants which we need to maintain whileconstructing the hull to avoid numerical problems- After the 2D introduction we will directly dive into the 3D version of Quickhull- We then investigate geometrical and topological invariants while constructing thehull in 3D and close with some implementation details

2Before we start let’s figure out what a convex hull is and look at an example:- We call a shape convex, if for any two points that are *inside* the shape, the line
between these two points is also inside the shape- If you look at concave case you see that it is easy to find two points inside theshape where the line has to leave and then enter the shape again.

3

What is a convex hull?

Give a set of N input points we can now define what we are going to call a convex
hull:- Formally: A convex hull is the smallest convex set containing all input points- Informally: If your points would by nails sticking in some piece of wood, the convex
hull would be a rubber band wrapped around the outside nails.
-> This means in 2D the hull is a convex polygon defined by vertices and edges!

4

I also like to show a 3D convex hull of a well known object – Utah Teapot.
- In 2D we used the rubber band analogy to get some intuition for a convex hull
- In 3D you can think of shrink wrapping the object-> In 3D the hull is a convex polyhedron defined by vertices, edges and *polygonal*
faces! Note that we are not going to restrict ourselves to triangles faces only!

5

Why should we use convex hulls for collision detection in games?

- Dynamic game objects are usually approximated by simpler shapes for collision
detection since using the render geometry would NOT be efficient- Convex hulls are a good candidate since they can approximate even complex
geometry quite well
- Also, collision detection for convex polyhedra is well defined and robust. Think of
GJK and SAT which we discussed already here in earlier tutorials

6

Before we start I like to show two videos to give you some idea how convex hulls areused in games:- Show a movie of convex hulls in the game- Show how the physics engine sees the game
Sergiy will show you how to implement awesome physics visualization right after this
talk!

7

I hope the videos gave you an idea about the problem we are trying to solve here
today.
When I started looking in convex hulls I quickly came across an algorithm called
Quickhull:- Quickhull was published by Barber and Dobkin in 1995
- It is essentially an iterative algorithm that adds individual points one point at atime to an intermediate hull.
- When implementing an algorithm to build convex hulls you have to deal with input
geometry that pushes the limit of floating point precision.
- Quickhull uses so called fat planes and face merging to address these problems- The output is then a set of ‘fat’ faces that encloses the exact convex hullIn the remainder of the talk will try to explain what this means in detail!

8I will start outlining the algorithm in 2D first- I like to mention, that this is not the ‘real’ 2D Quickhull algorithm (which actuallyexists). You should think of it as an introduction of the 3D version we will
investigate later in the talk
- Personally I find it often helpful to think about things in 2D first, to get a goodunderstanding of the problem and to familiarize myself with the basic ideas

9Assume we are a given set of points and we are asked to build the convex hull using
the Quickhull algorithm:- The first thing we need to do in Quickhull is to build an initial hull from where wecan start adding points iteratively

10

To find this initial hull we start by identifying the extreme points along each cardinalaxis- This simply means we find the points with the smallest and largest x and y values.

11

From these four points we choose the pair which is furthest apart- In this example this would be the left- and right-most points

12

Finally we search for the furthest point from the line through these two extreme
points

13

These three points build our initial hull
- In 2D the initial hull is simply a triangle

14

Before we start adding new points to the initial hull we have to do some bookkeeping work:- The next step is to partition the remaining points and assign each point to its
closest face
- We can also remove internal points since those cannot be on the final hull
What that means is that each face maintains a list of points which are outside theface plane. We call those ‘conflict lists’ since the points can “see” the face andtherefore are potentially on the final hull. This is a clever way of managing thevertices since we don’t need to iterate all vertices when adding a new vertex to thehull. This makes Quickhull typically O(n log n) in both 2 and 3 dimensions!
NOTE:
Please don’t get confused here. Since I am presenting in 2D and 3D and someterminology overlaps I will use the terms ‘Edge’ and ‘Face’ interchangeable! This
will usually help when we go to 3D later in the talk!

15

The next step is to add a new point to our intermediate hull. We iterate our conflictlists and find the point p with the largest distance from the hull:- Let’s call this point the eye point- Adding this new point requires several sub steps

16

First we need to identify all faces that are visible from the newly added point sincethese faces cannot be on the hull:- A face is visible if the new point is in front of the face plane.
- We can use simple plane tests to classify the new point against each face!
- The next step is then two find the two vertices that connect a visible with a nonvisible face.
- We call these two vertices the horizon- The horizon is essentially the boundary between the visible and non–visible part ofthe current hull as seen from the new eye point

17

Once we identified the two horizon vertices we then create two new faces for eachhorizon vertex to connect the new vertex to hull18

After building the new faces some old faces became obsolete- Before we can delete these faces we need to handle their conflict lists since theseconflict points can still be on the final hull
- We handle this by simply partitioning these orphaned vertices to the new faces

19

Finally we can now remove all old faces which were visible from the new point andtherefore cannot be on the hull anymore- This closes the iteration and we repeat those steps until all conflict list are empty- In our example we continue and grab the next eye point and add it to hull as wejust learned20And we do it one more time to find our final hull…

21

When there are no more vertices (which means all conflict lists are empty) we are
done!

22

As you can see the basic ideas should be pretty easy to understand- In 3D the major implementation difficulties actually arise from managing the lists ofvertices, edges, faces and conflicts- The other difficulty is dealing with numerical imprecision when classifying points
using plane tests.

23

So far we pretended that our mathematical operations are exact- Of course this is *not* true in floating point arithmetic.
- Let’s investigate how we can deal with those problems.

24When building a convex hull we must maintain geometric invariants during
construction:- In 2D we must guarantee that every vertex is convex- This should be obvious since otherwise it would be simple to find a line between
two points inside the hull that would leave and enter as shown in the slide at the
beginning of the talk
- I tried to hint this with the dotted line between the outside pointing normals on
the slide25

Next we need to define what a convex vertex is and how we can test a vertex forconvexity:
For each vertex:- First test if right vertex is below the left face
- Then test if left vertex if it is below the right face
- If both tests are true the vertex is convex, otherwise it must be concave or
coplanar26

Let’s now look at an example where non-convex vertices might become an issue:- Whenever we add a point which is collinear with an existing face things canbecome fuzzy- A small variation of point P will define whether the vertex V will remain on the hullor not- Ideally we would like to have more stability such that for very small variations
within some tolerance we would get the same result- Note that the point P is not actually moving, but can end up on either side of theplane *just* due to numerical imprecision27

A common approach to deal with these kinds of numerical problems is to use socalled *fat* planes- Instead of comparing directly against zero we now compare against some epsilonvalue
We still can classify points when using fat planes as before:- A point is in front of the plane if its distance is larger than epsilon- A point is behind the plane if the distance is less than negative epsilon- Otherwise the point must on the plane.
We can now define a vertex to be convex if its distance is larger than epsilon. Allother points are either concave or coplanar and should be handled specially!

28

So what do we do when we encounter a non-convex vertex?
- The rule is essentially that we want every vertex of our hull to be clearly convex- We can enforce this rule by simply merging the left and right face across the nonconvex vertex into a new face.
- As you can see on the slide his will remove the concavity and correct thegeometrical defect.

29

The final question is what epsilon we should choose for our fat planes:- The CRT defines a floating point epsilon but this does NOT take our input set into
account.
- We like to define a relative tolerance which takes the size of the input object into
account- So one possible solution it to choose an epsilon relative to the sum of maximum
absolute coordinates- Note that when using FLT_EPSILON without scaling we would fail big time e.g. verysmall models (where FLT_EPSILON is much bigger than the entire model itself)- Or for very large models where the epsilon is too small to make any difference atall30

This closes the introduction of Quickhull in 2D:- I hope you now have some first idea how the algorithm operates- In 2D there already exist good algorithms to build convex hulls which are easy andstraight forward to implement.
- So if your game is 2D I recommend using one of those.
In the remainder of the talk we will discuss how we build convex hulls in 3D- Quickhull in 3D is very similar to the version I just showed you in 2D- The most notable difference is the construction of the horizon and we have to deal
with numerical imprecision more carefully31

As in 2D we need to build an initial hull
- We will find the initial triangle (v1, v2, v3) as we did in 2D before- Then we will also add the furthest point from the triangle plane (here v4)- In 3D the initial hull is now a tetrahedron- After we build the initial hull we then partition the remaining points into theconflict lists of the faces of our initial hull32

We then start iteratively adding new points to the hull and grab the point with thelargest distance from our conflict lists:- This will give us the next eye point- As in 2D we need to find the horizon again- In 3D the horizon is a list of edges that connect visible with non-visible faces.
- And again the horizon is the boundary between the visible and non–visible part ofthe current hull as seen from the current eye point- Finding the horizon is a bit more involved in 3D and we will look at it in more detailin just a second33

We then proceed with the iteration and create a new face for each horizon edge with
the new eye-point- This essentially connects the new vertex to the current hull
- Finally we partition the orphaned vertices to the new faces (F1 – F3)

34

Finding the horizon in 3D is not as easy as finding two vertices as it was in 2D.

- For finding the horizon we essentially perform a DFS starting from the conflict faceS
- At each step we cross one edge and visit a neighboring face
- If the face is visible, we cross another edge until we find a face that is not visible
from the current eye point- We store the offending edge as part of the horizon and continue the search in theprevious face
- On termination we have a list of all edges defining the horizon in a closed CCW
loop- On the slide we start at the face labeled with S and follow the arrows and on ourway back we collect the horizon edges- Since this is an essential operation of the hull construction let’s look at this step ina bit more detail
Explain arrows in slide!

35

I prepared a small animation which hopefully will help to understand the horizon
construction:36

- We test the visibility of the next face (and we assume here it is visible from the eye
point)- Since it is visible we continue our search and cross the next edge37

- We test the next face and since it is visible as well we continue and cross the next
edge

38

- We continue these tests until we cross an edge to an invisible face39

We would now cross an edge to a face we have already visited- Whenever we visit a face we will mark them as processed- This allows to simply test if a face was already processed and can be skipped40

We continue crossing edges…

41

42

43

44

Again we already visited this face so we don’t cross this edge as well

45

46

47

48

The next face was already visited so no need to cross here too

49

Finally we would cross the first edge that connects a visible and a non-visible face
- We add the edge to the horizon list and return to the previous face50

We then continue with the next edge and return to the previous face51

Again we cross an edge that connects a visible and invisible face
- We save that edge and add it to our horizon and return to the previous face52

The procedure continues and collects the horizon edges until we made our way backto the start face

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

This is edge we started with and we are done!

72

On termination we have a list of all horizon edges in CCW order- We can now simply create a new triangle face for each horizon edge in our list
- This essentially connects the new vertex to the current hull73

This closes the introduction of the 3D Quickhull algorithm and we continue looking
into invariants74

As in 2D we must maintain geometric invariants while constructing the hull:- In 3D we must now guarantee that every edge is convex- And the argumentation here is basically the same as it was earlier in 2D75

We now need to define what a convex edge is and how we can test an edge forconvexity:
For each edge:- First we test if the center of the right face is below the left face plane- The we test if the center of the left face is below the right face plane- If both tests are true the edge is convex, otherwise it must be concave or coplanar- This is very similar to the 2D test, but we now use the center point of the face
- The face center is simply the average of the face vertices76

As in 2D we need an epsilon to define the thickness of flat planes and we just expand
our formula to 3D!

77

So when we detect a non-convex edge we now merge the two adjacent faces- This adds another step to our iterative loop
- Let’s assume face1 and face2 were non-convex in our previous example- We would now merge face1 and face2 into a new polygonal face replacing theoriginal faces F1 and F2- As mentioned in the beginning we are not restricting ourselves to triangle faces

78

Let’s now investigate the example from the original Quickhull paper:- The message of the next slides is really to show what will happened if you DON’T
merge faces and how you can run into a bunch of geometrical and topologicalproblems!
- All you need to get here right now is that face merging is really a critical operation!
The situation presents itself like this: Faces F1 and F3 are visible from the new point 𝐏
while face F2 s not!
- Basically you can think of a simple tetrahedron here
- The front face is in the screen plane and was not merged into one big triangle face,but is essentially a fan of three faces- It appears to us as if faces F1 – F3 are coplanar- But the bad news is that coplanar only exists in an ideal world, but not in the worldof limited precision numbers!

79

What really happens is (and I am exaggerating the situation here a little bit) is that:- The two center points are actually moved inside- And the edges between F1 and F2 and also F2 and F3 are concave

80Now let’s rotate the tetrahedron and assume we are now looking from behind point P
and at the bottom :- You can hopefully see the new point and the bottom edges of the three faces- Due to the non-convexity the new point gets kind of locked behind the threeplanes that leads to this weird situation81

We continue and build now the horizon as we learned earlier using the DFS- The results in five horizon edges a, b, c, d, and e as sketched on the slide82

Next we replace 𝐹1 and 𝐹3 with 5 new faces for each edge a−e- Since the outcome of the operation is pretty interesting let’s look at each of the newfaces individually83

We build a face for edge a- Note how this face partially overlaps face2 which is still on the hull84

We build a face for edge b- Note that this face has flipped (CW) orientation and also shares and edge with FA85

We build a face for edge c- Hooray, nothing wrong here86

We build a face for edge d- Note that this face has flipped (CW) orientation again and also shares an edge with
FA and FB

87

We build a face for edge e- We now have four faces sharing the same edge and also partially overlapping each
other

88

- Due to numerical imprecision face2 was still identified as visible from P and willremain on the hull89

What happened here is that we introduced a couple of severe errors because our hull
was not in an healthy state when we started adding the new point.
As a result the new faces are violating a bunch geometrical and topological invariants:- Two faces are flipped upside down (that means the normals are pointing inside)- Four faces share the same edge (which make them partially and fully overlapping
each other)
As you can imagine repairing those errors would become pretty involved.
The good news are that I haven’t run into any of the described issues when properly
merging faces during the hull construction.
So hopefully you can see that it essential for a robust implementation to maintain ahealthy hull during construction.

90

We haven’t talked about a data structure for convex polyhedra yet. So before we start
looking into face merging in more detail, let’s talk about a possible data structure
first:- Obviously there are many ways to describe a convex polyhedron- A common data structure is the so called Half-Edge data structure which is an edge
centric mesh representation- The half edge data structure makes it easy to iterate edges of a face and to accessneighboring faces
For each face we store:- A half-edge that defines the entry into a circular list around the face
For each edge we store:- The previous and next edge that build the circular list around the face
- A twin edge to cross over to the adjacent face
- And the tail vertex of the edge
- Note that we don’t need to store the head vertex since it is simple the tail vertexof the twin edge91

We learned that face merging is the essential operation to maintain a healthy hull.
- Here is an example how to merge two faces using the half-edge data structure.
- The situation is that we are about to merge the left into the right face
- This means that edge e and its twin will go away and also the left face92

First we make sure that the absorbing right face does not reference the edge we areabout to delete (e.g. we use edge->prev here)93

Next we must make sure that all edges of the absorbed left face will now reference
the right face as their owner

94

Finally we need to connect the incoming and outgoing edges- Also note that we can access all necessary data for the merge operation just fromthe shared edge between the two adjacent faces we are about to merge

95

The result of two of merged faces is a polygonal face with its vertices not quite
coplanar- Remember that we are in the world of limited precision numbers- The Newell algorithm builds a best fit plane in the least square sense which
minimizes the distance of the vertices96

I added some formulas for completeness and convenience, but going into detail here
would get us off topic.
- Both Gino’s and Christer’s books cover Newell planes and I also added some
additional links in the references

97

Now let’s look at one important topological invariant of a convex hull.
- The most important one for us is that each vertex must have at least threeadjacent faces- We call a vertex redundant if it does not satisfy this invariant
Of course there are other topological invariants, like:- Each face must have at least three neighbors- Each edge is shared exactly between two faces- Each face of a convex polyhedron must be a convex polygon- But as is turns out we don’t need to deal with those directly98When merging faces we might violate topological invariants and need to fix those:

Consider the merge sequence in the above picture and how it can lead to topologicalerrors:- We merge face1 into face3
This creates a couple of problems:- Vertex v has now only two adjacent faces and has become redundant- Face2 has only two neighbors- Face13 is not convex

99

We detect this error by checking the adjacent faces of the in- and outgoing edges ->Both edges point to face2- Since face2 is a triangle we will not connect the in- and outgoing edge, but use thenon-shared edge instead- Note that face2 is redundant as well since all vertices are contained in face13 andcan be deleted- Vertex v has also become obsolete and will be deleted as well
The trick here is that when we merge two faces we check for this error and fix it
immediately!

100

Let’s look at the previous example again.

Consider now the slightly different merge sequence:- We now merge face2 into face1
Again:- Vertex v has now only two adjacent faces and has become redundant- Besides this I don’t notice any other problem in this case101

We detect this error again by checking the adjacent faces of the in- and outgoingedges -> Both edges point to face3 here
- Since face3 has now more than three vertices we cannot apply the same fixing
strategy as before- Instead we simply extend the incoming edge to the next vertex and delete theoutgoing edge
- Again vertex v has become obsolete and should be deleted as well
Again when we merge faces we check for this error and fix it immediately!

102

Another problem you will encounter when merging faces is that you might a large
number of new faces that should be all merged:- Let’s call this a merge cycle
Imagine we are building the convex of hull of a cylinder and we are about to add thefinal vertex of the top face:- This vertex of course presents itself as in the same plane as the other vertices.
- In this situation we create many new faces which are roughly coplanar and need tobe merged- Ideally we would like to merge all new faces into one face as shown on the righthand side103

The problem is now that we practically merge one face after the other:- Whenever we merge two faces we rebuild the face plane.
- Rebuilding the face can jiggle the plane and an edge between two faces canbecome temporarily convex and prevent us from merging the whole cycle- In the worst case this can introduce concave faces which are now NOT merged
properly
Here are some ideas how to address this:- The faces with the largest area should be the most stable w.r.t. the orientation of
the face plane. So merging into the largest faces first reduces jiggle. Think ofmerging the little sister into the big daddy- You can also introduce an absolute tolerance to increase your merge radius andmake your merge cycle less sensitive for these situations.
- This is basically how I handle this problem at the moment since for physics wewant as large faces as possible for stability reasons and do not aim for the tightest
hull.
- If you are working with collision margins it is probably a good idea to make thisabsolute tolerance a small percentage of that margin104

Another idea to deal with this problem is to NOT rebuild the face planes at all whenmerging to faces:- For both faces you have your best fit plane and the vertices (which I tried to sketchon the slide)- We can now compute the absolute distance of the right face’s vertices to the left
face’s plane and vice versa- Then we simply keep the face plane that minimizes the distance instead of
rebuilding it

105

Let’s close this part how we could use face merging to deal with defect hulls:- At each iteration the basic assumption is to start with a healthy hull
- When adding the vertex we need to inspect all new faces for possible defects attheir edges between each other and at the horizon- These are the weak spots where might have introduced new errors- An easy strategy is to iterate all new faces and repair each edge one by one

106

This closes the theory and in the remainder of this talk I like to share some quick tips
about a possible implementation

107

The major performance pitfall is bad memory management of the half-edge data
structure:- The convex hull for N vertices is bounded- Worst case is that all input vertices are on the hull:- The number of vertices is then at most V = N- The number of edges is then at most E = 3N – 6- The number of faces is then at most F = 2N – 4- Test with Euler’s formula: V – E + F = 2
In our implementation we can pre-allocate one buffer for vertices, half-edges, andfaces and manage this buffer in a free list
- Ideally we will just have one big allocation per hull construction!
- This becomes especially important if you plan to compute convex hulls at runtime(e.g. for destruction)
Here are some practical details:- Don’t forget that you need to allocate half-edges (which is twice the number ofedges)- We also need to account for temporary allocations (e.g. horizon faces)- In practice I just double the buffer size

108

Let’s start with the vertex structure.
- I am using an intrusive list to store the vertices- The vertices are either on the hull or in a conflict list
- So obviously we have to include the list pointers here.
- We can optionally also store an edge leaving the vertex.
- This is not needed for constructing the hull, but it can be useful for post-processing
if you like e.g. to iterate all adjacent faces of the vertex- Of course we also to need store the position of a vertex

109Now let’s have a quick look how we can potentially implement a half-edge:- As we would expect this definition maps pretty directly to a possible data structure- We store a pointer to the tail vertex of the edge
- The half-edges build a circular list around the face so we also need to store the list
pointers here
- And of course we also store the twin edge to cross over to the adjacent face
- Finally we also keep a reference to the parent face of the edge

110Finally the face structure:- I am also using an intrusive list here, so we have to include the list pointers again- And of course there is a pointer to the first edge starting the circular list aroundthe face- Finally it is possibly a good idea to store our conflict list here as well111

Finally some high-level code examples to give you an idea of a possible
implementation:- Assume we have some qhConvex class to store the hull after construction- This snippet shows the top level construction function
Explain a bit…

112

The code snippets shows the iterative AddVertex() function- We add new points until our conflict lists are empty
Explain a bit…

113

So you want to implement Qhull yourself and I talked now for nearly an hour andthere is no code!
- Luckily there is a beautiful open-source implementation in JAVA which you can use
to start- I also recommend looking at the original Qhull implementation which is not only agreat implementation, but also full of gems of computational geometry!!!
This closes the talk and hopefully my presentation will help you to understand andimplement a robust convex hull builder!
Thank you!

114

Before I close I like to thank a bunch of people!
- Thanks to Valve for giving me permission to present to you today- Thanks to Paul, Steve, Jeff and Anoush for spending time and rehearse thispresentation with me- Thanks to Randy for reading the presentation several times at an early stage andproviding valuable feedback- Special thanks to Bruce Dawson for helping with the numerical problems in
Quickhull and also providing all kinds of other valuable feedback- Special thanks to John Lloyd for sharing his beautiful JAVA Quickhull
implementation and making it open source

115

116

If you liked this talk and if you want to see more cool Valve presentations please visit
out website!

117

118

119