GeomPP

A modern C++20 geometry library for 2D and 3D spatial computation — fast, mathematically correct, thoroughly tested, and usable from C++, C# (.Net 8/9/10 or .Net Framework 4.8), and Python 3.

You may be a CAD or a Game developer using C#.Net, and you use APIs native to the platform you develop into. These native APIs are easy to get in, but may contain bugs that have not been fixed, or simply lack some functionalities. You may be a Data Scientist using Python on a GIS project, and having to import 3+ libraries, and covert from data-structure to data-structure to use it. You may be a C++ developer who wants to import a more lightweight library than those which already exist, and possibly more user friendly.

This library was born a few years ago to solve all these problems. It was recently augmented with the aim of using the most modern algorithms to solve a variety of geometrical problems.

The sources of these algorithms are to be found in several textbooks, such as

• Practical Geometry Algorithms (Danniel Sunday)
• Computational Geometry in C (Joseph O'Rourke)
• Computational Geometry (Mark de Berg, Marc van Kreveld, Mark Overmars, Otfried Schwarzkopf)

Finally, the help of AI was used to validate algorithms (bug-free, guarantee the desired big-O), bind into other languages than C++, add edge cases to achieve a high test coverage, and build documentation.

Python Bindings

Python bindings for geompp — a C++ 2D/3D geometry library.

Changelog — full release notes for every version.

Install

pip install geompp

Platform note

Pre-built wheels are available for:

If your platform or Python version is not in the table above, pip will compile from source — you will need CMake ≥ 3.15 and a C++20-capable compiler.

Test Coverage

This is the summary of the current test coverage. More on test coverage.

How to use it

You can look at the test suite to see detailed usage.

A quick list of code examples per topic is provided here.

👉 Visual Documentation and Code Examples on Github

What it provides

Serialization

All primitives support:

• WKT (Well-Known Text) — to_wkt() / from_wkt() for standard text interchange
• Binary file I/O — to_file() / from_file() for compact storage

Precision

Floating-point comparisons use a thread-local DECIMAL_PRECISION constant via AlmostEquals() methods, making the library robust against rounding errors while remaining configurable per thread.

Classes

Where not explicitely specified, both 2D and 3D variants are available for all core types:

Algorithm overview

Each class supports a consistent set of spatial operations where applicable:

• Containment — does a shape contain a given point?
• Intersection — do two shapes strike through each other, and what is the resulting geometry? Also available as the free function find_intersections() on a free set of segments. The meaning of this operation changes from 2D to 3D — check the class docs.
• Overlap — do two shapes have a portion in common, and what is the resulting geometry? Meaning changes from 2D to 3D.
• Touch — do two shapes have a point in common, and which is it? Meaning changes from 2D to 3D.
• Distance — closest distance from a point to a shape.
• Plane operations — projection of a point from 3D to 2D, and re-projection from 2D to 3D, via the Plane class or the faster View2D (one of the 3 world planes XY/YZ/ZX, or a custom plane).
• Interpolation / Location — lerp(p0, p1, t) retrieves a point at parameter t between two points (not clamped); interpolate(t) does the same along a segment or polyline; the opposite operation finds the parameter t for a point already on a shape.
• Area / Perimeter / Centroid — geometric properties for closed shapes.
• Signed area — encodes orientation (clockwise vs. counter-clockwise in 2D, surface normal direction in 3D).
• Simplicity / self-intersection — Polygon2D.is_simple() and the free functions has_intersections(segments) (Shamos–Hoey, boolean) / find_intersections(segments) (Bentley–Ottmann, every crossing point).
• Convex hull — convex_hull(points) — Andrew's monotone chain, returns hull vertices in CCW order.
• Bounding containers — tight-fitting containers around point clouds: axis-aligned bounding box, bounding ball, minimal oriented rectangle, convex hull.
• Polyline operations — Polyline.reduce() (decimation) and Polyline.expand() (Bezier corner smoothing), or the underlying free functions (dist_decimation()/rdp_decimation()/vw_decimation(), bezier_smoothing_2(), polyline_expansion()) for a plain point list.
• Polygon boolean operations — intersection(), union(), difference(), xor() between two polygons (map-overlay method), or the free function clip(clipper_loop, subject_loop) for raw point loops without constructing a Polygon first.
• Point cloud operations — principal_axes() (PCA) finds the empirical 3 directive axes of a list of points in space.
• Triangulation — decomposition of a polygon into n-triangles. Four strategies: EarClipping, EarClippingBestFit (default), MonotonePolygon (O(n log n) y-monotone sweep — check precondition with is_axis_monotone), ConstrainedDelaunay (O(n²) ear clipping + Lawson flips — boundary kept, all triangles inside, minimum angle maximized, verify with in_circumcircle). Point clouds: delaunay(points) / delaunay(points, normal) — unconstrained Delaunay covering the convex hull.
• Polygonization — the reverse of triangulation: merges coplanar, edge-adjacent triangles back into polygons, via Mesh2D/3D.polygonize() / ConnectedMesh2D/3D.polygonize() or the free polygonize(triangles, settings), under 3 strategies (PlanarBoundaryExtraction — O(n) external boundary of a triangle set, PlanarQuads — O(n) pairs of coplanar triangles into quads, HertelMehlhorn — merges coplanar triangles into convex n-gons). A related free function merge(polygons) welds a set of non-overlapping polygons that tile a plane (3D: grouped by plane first) into fewer, bigger polygons, including merging any of their holes that touch along the same seam.
• Linear algebra (geompp.maths) — a small fixed-size linear algebra submodule, independent of the geometry classes above: Vector2/Vector3/Vector4, Matrix2/Matrix3/Matrix4, and the solve_gauss() / solve_cramer() system solvers for Ax = b.
• Affine transformations (geompp.transformations) — translate(), rotate(), scale(), shear(), reflect() (fast, single-point, no matrix needed), and the general transform(primitive, matrix) for every primitive from Point2D/Point3D to PolyMesh2D/PolyMesh3D. Use TransformBuilder2D/TransformBuilder3D to fluently chain several transforms (e.g. .translate(...).rotate(...).scale(...)) into a single Matrix3/Matrix4, then apply it once with .build()/transform().

Return values are None on no-intersection, and sometimes a Point/list[LineSegment]/list[Polygon] depending on what the operation produced — check each method's docstring for the exact shape.

Free functions