Comparison of the different algorithms for Polygon Boolean operations.

Michael Leonov


When writing my BS degree work I tested the following software libraries for speed and robustness of performing polygon Boolean operations:

Library name Principal author Language
Boolean (v. 1.34) Klaas HolwerdaC++
Boolean Operations On Polygons (v. 2.0) (BOPS) Matej Gombosi C++
CGAL (r. 1.1) Joint project of 7 sites C++
Clippoly (pl. 7) Klamer Schutte C++
Constructive Planar Geometry (CPG) Dave Eberly C++
GPC (v. 2.22) Alan Murta C
LEDA (v. R-3.6.1) Max-Planck-Institut fuer Informatik C++
PolyBoolean v0.0 Michael Leonov, Alexey Nikitin C++


Boolean + + + + + + - + +
BOPS + - + - + - - - +
CGAL + + + - - - - - -
Clippoly + + - - - - - - -
CPG + + + + + - - + -
GPC + + + + + + + + -
LEDA + + + + + - - + -
PolyBoolean + + + + + + - + -

First 4 columns denote supported Boolean operations. HOLES means that a library can handle polygons with holes. KH I means that a library can handle polygons with 'keyholed' edges, which are sometimes used to describe a polygon with holes by means of single contour. SI means that a library allows self-intersecting polygons at its input. DV means that a library supports polygons with vertices of high degree, i.e. self-touching polygons. KH O means that a library's output can contain keyholed edges (I think this is the library's disadvantage).


For testing I used PC with CPU Pentium II (233 MHz) and 96Mb RAM running Windows NT Workstation 4.0 SP4. All source code was compiled with Microsoft Visual C++ 6.0 using the same alignment (8 bytes) and optimization options. Sample polygons were extracted from True Type Font contours using different levels of Bezier curves polygonal approximation. The test program was executed 5 times for every Boolean operation. The results are summarized in the table below (N denotes the total number of vertices in input polygons, all timings are measured in seconds, best times for each N are bold):

Library N=3885 N=7076 N=20190 N=69839 N=174239
Boolean 1.084 1.773 5.923 23.219 65.927
Clippoly 15.482 51.965 487.942 ... ...
GPC 0.160 0.381 8.570 64.463 133.670
LEDA 0.806 1.422 3.801 16.636 ...
PolyBoolean 0.158 0.255 0.721 3.532 16.011

For N=69839, 174239 Clippoly caused stack overflow due to the O(N) recursion depth. For N=174239 LEDA caused memory overflow (despite the presence of the extra 100 Mb of virtual memory) due to the extensive use of the rational ariphmetic.

Like Clippoly, CGAL and CPG have quadratic running time. BOPS produced incorrect results on test polygons so I did not include its timings.

Numerical robustness

Most of the programs listed above are not strictly robust and use floating point arithmetic with some tolerance values. CGAL, CPG and LEDA use exact rational arithmetic to achieve robustness. In this case, required memory size grows exponentially with a number of cascaded operations, and this seems not to be satisfactory for practical applications. PolyBoolean uses John Hobby's rounding cell technique to avoid extraneous intersections and is therefore completely robust. Boolean also rounds the intersection points to the integer grid, then repeats until no new intersection points are found.


Algorithm used in Boolean is described in [Holwerda 98]. Some additional information can be found in [Preparata and Shamos 85] (a must-have Computational Geometry book).

Algorithm used in BOPS is described in [Zalik, Gombosi and Podgorelec 98].

Algorithm used in CGAL is not documented.

Algorithm used in Clippoly is described in [Schutte 94] and [Schutte 95].

Algorithm used in CPG is described in [Eberly 98].

GPC uses a modified version of [Vatti 92]. Implementation details are discussed in [Murta 98]. Alan Murta is currently working on a paper describing GPC.

Polygon Boolean algorithm used in LEDA is not documented by itself. The segment intersection part is described in [Mehlhorn and Naher 94].

Polygon Boolean algorithm used in PolyBoolean is described in [Leonov and Nikitin 97]. Additional algorithmic and implementation issues are discussed in [Leonov 98]. The segment intersection part is based on [Bentley and Ottmann 79] and [Hobby 99].

Bentley and Ottmann 1979
J. L. Bentley and T. A. Ottmann. Algorithms for reporting and counting geometric intersections. IEEE Trans. Comput., C-28:643-647, 1979.
Eberly 1998
D. Eberly. Polysolids and Boolean Operations.
Hobby 1999
J. Hobby. Practical segment intersection with finite precision output. Computation Geometry Theory and Applications, 13(4), 1999.
Holwerda 1998
K. Holwerda et al. Complete Boolean Description.
Leonov and Nikitin 1997
M. V. Leonov and A. G. Nikitin. An Efficient Algorithm for a Closed Set of Boolean Operations on Polygonal Regions in the Plane (draft English translation). A. P. Ershov Institute of Informatics Systems, Preprint 46, 1997.
Leonov 1998
M. V. Leonov. Implementation of Boolean operations on sets of polygons in the plane (in Russian). BS Thesis, Novosibirsk State University, 1998.
Mehlhorn and Naher 1994
K. Mehlhorn and S. Naher. Implementation of a Sweep Line Algorithm for the Straight Line Segment Intersection Problem. Max-Planck-Institut fur Informatik, MPI-I-94-160, 1994.
Murta 1998
A. Murta. A Generic Polygon Clipping Library.
Preparata and Shamos 1985
F. P. Preparata and M. I. Shamos. Computational Geometry: An Introduction. Springer-Verlag, New York, NY, 1985
Schutte 1994
K. Schutte. Knowledge Based Recognition of Man-Made Objects. PhD Thesis, University of Twente, 1994. ISBN90-9006902-X.
Schutte 1995
K. Schutte. An edge labeling approach to concave polygon clipping. Manuscript, 1995.
Vatti 1992
B. R. Vatti. A generic solution to polygon clipping. Commun. ACM, 35(7):56-63, 1992.
Zalik, Gombosi and Podgorelec 1998
B. Zalik, M. Gombosi and D. Podgorelec. A Quick Intersection Algorithm for Arbitrary Polygons. In L. Szirmay-Kalos (Ed.), SCCG98 Conf. on Comput. Graphics and it's Applicat., 195-204, 1998. ISBN 80-223-0837-4.


All tested libraries are very good for educational purposes and for studying different approaches to the polygon Boolean operations. PolyBoolean, Boolean and GPC are probably the fastest publicly available libraries. The correct rounding of intersection points is performed only in PolyBoolean and Boolean. Of course, all these opinions are only mine, and I don't attempt to make strong assertions about usefulness of these programs. Click here to get the polygons I used for testing. Soon I will make the source code of the test program (with all necessary modifications of the tested libraries) publicly available.