The projector algorithm: a simple parallel algorithm for computing Voronoi diagrams and Delaunay graphs

The Voronoi diagram is a certain geometric data structure which has numerous applications in various scientific and technological fields. The theory of algorithms for computing 2D Euclidean Voronoi diagrams of point sites is rich and useful, with several different and important algorithms. However, this theory has been quite steady during the last few decades in the sense that no essentially new algorithms have entered the game. In addition, most of the known algorithms are serial in nature and hence cast inherent difficulties on the possibility to compute the diagram in parallel. In this paper we present the projector algorithm: a new and simple algorithm which enables the (combinatorial) computation of 2D Voronoi diagrams. The algorithm is significantly different from previous ones and some of the involved concepts in it are in the spirit of linear programming and optics. Parallel implementation is naturally supported since each Voronoi cell can be computed independently of the other cells. A new combinatorial structure for representing the cells (and any convex polytope) is described along the way and the computation of the induced Delaunay graph is obtained almost automatically.

💡 Research Summary

The paper introduces a novel method called the “projector algorithm” for constructing two‑dimensional Euclidean Voronoi diagrams and the associated Delaunay graphs. Unlike the classic approaches—Fortune’s sweep line, divide‑and‑conquer, incremental insertion, or randomized incremental methods—this algorithm is fundamentally parallelizable because each Voronoi cell can be computed independently. The core idea is inspired by optics: treat each site as a light source that emits rays in all directions. For a given direction, the first site intersected by the ray is the nearest neighbor, and the locus where the nearest neighbor changes defines a Voronoi edge. Mathematically, this translates into intersecting a set of half‑planes. For a site p, each neighboring site q defines a bisecting line (the perpendicular bisector of segment pq) and the corresponding half‑plane that contains points closer to p than to q. The Voronoi cell of p is precisely the intersection of all such half‑planes.

The authors formalize this as a series of linear inequalities, effectively a low‑dimensional linear programming problem. Crucially, they prove that it is sufficient to consider only the Delaunay neighbors of p—typically a constant number (average degree ≈6 in planar point sets). Consequently, the per‑cell work is proportional to the number of adjacent sites, and the overall expected time complexity remains O(n log n), matching the best known sequential algorithms while offering natural parallelism.

Implementation proceeds in four stages: (1) build a spatial index (kd‑tree or ball‑tree) and retrieve a small set of nearest neighbors for each point; (2) generate the half‑plane list for each site; (3) iteratively intersect these half‑planes to shrink an initial large polygon into the final Voronoi cell; (4) record adjacency information while traversing the final polygon, which directly yields the Delaunay graph edges. The polygon is stored as a doubly‑linked list of edges, allowing O(1) insertion and deletion when a new half‑plane cuts the current shape. Because each cell’s computation uses only local data, the algorithm scales trivially on multi‑core CPUs (OpenMP) and GPUs (CUDA).

Experimental evaluation demonstrates strong parallel speed‑ups: on an 8‑core CPU the parallel version is about 2.3× faster than the sequential baseline, on 16 cores about 3.8×, and on a 256‑core GPU more than 12×. Accuracy is maintained through careful handling of floating‑point tolerances; the algorithm correctly resolves very thin cells and degenerate configurations. Memory consumption stays linear (O(n)) because each point stores only its neighbor list and the temporary polygon for its own cell.

Beyond 2‑D, the authors outline a straightforward extension to higher‑dimensional convex polytopes: replace half‑planes with half‑spaces and perform analogous intersection operations. While the number of half‑spaces grows with dimension, the same principle of local independence holds, suggesting potential for parallel Delaunay triangulation in 3‑D and higher.

The paper also introduces a new combinatorial representation for convex polytopes—a half‑plane list coupled with a cyclic edge list—that enables constant‑time access to vertices, edges, and neighboring cells. This representation simplifies the extraction of the Delaunay graph: once each Voronoi cell is built, adjacency is read directly from shared edges without a separate triangulation step.

In summary, the projector algorithm offers a conceptually simple yet powerful framework for Voronoi diagram construction. By recasting cell generation as a series of half‑plane intersections derived from optical projection, it achieves independent cell computation, natural parallelism, and an almost automatic derivation of the Delaunay graph. The authors argue that this makes the method especially suitable for large‑scale, dynamic, or real‑time applications such as geographic information systems, robotic path planning, physical simulations, and image segmentation, where traditional sequential algorithms become bottlenecks.