Gilbert–Johnson–Keerthi distance algorithm

Jump to navigation Jump to search

The Gilbert–Johnson–Keerthi distance algorithm is a method of determining the minimum distance between two convex sets. Unlike many other distance algorithms, it does not require that the geometry data be stored in any specific format, but instead relies solely on a support function to iteratively generate closer simplices to the correct answer using the Minkowski sum (CSO) of two convex shapes.

"Enhanced GJK" algorithms use edge information to speed up the algorithm by following edges when looking for the next simplex. This improves performance substantially for polytopes with large numbers of vertices.

GJK algorithms are often used incrementally in simulation systems and video games. In this mode, the final simplex from a previous solution is used as the initial guess in the next iteration, or "frame". If the positions in the new frame are close to those in the old frame, the algorithm will converge in one or two iterations. This yields collision detection systems which operate in near-constant time.

The algorithm's stability, speed, and small storage footprint make it popular for realtime collision detection, especially in physics engines for video games.

Overview

GJK relies on two functions:

• ${\displaystyle Support(shape,{\vec {d}})}$, which returns the point on ${\displaystyle shape}$ which has the highest dot product with ${\displaystyle {\vec {d}}}$.
• ${\displaystyle NearestSimplex(s)}$, which takes a simplex ${\displaystyle s}$ and returns the simplex on ${\displaystyle s}$ closest to the origin, and a direction toward the origin normal to the new simplex. If ${\displaystyle s}$ itself contains the origin, ${\displaystyle NearestSimplex}$ accepts ${\displaystyle s}$ and the two shapes are determined to intersect.

The simplices handled by ${\displaystyle NearestSimplex}$ may each be any simplex sub-space of Rn. For example in 3D, they may be a point, a line segment, a triangle, or a tetrahedron; each defined by 1, 2, 3, or 4 points respectively.

Pseudocode

    function GJK_intersection(shape p, shape q, vector initial_axis):
vector  A = Support(p, initial_axis) - Support(q, -initial_axis)
simplex s = {A}
vector  D = -A
loop:
A = Support(p, D) - Support(q, -D)
if dot(A, D) < 0:
reject
s = s ∪ A
s, D, contains_origin = NearestSimplex(s)
if contains_origin:
accept

Illustration

The two types of collision and corresponding CSO face: face-vertex (top) and edge-edge (bottom).