GeomPP 0.17.3

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.

C# Bindings

C++/CLI bindings for geompp, targeting Windows x64.

Available on NuGet as GeomPP.

Supports .NET 8, .NET 9, .NET 10, and .NET Framework 4.8.

Changelog — full release notes for every version.

Install

dotnet add package GeomPP

or in your .csproj:

<PackageReference Include="GeomPP" Version="0.8.0" />

Platform note

GeomPP is built with C++/CLI and is Windows x64 only. It will not run on Linux, macOS, or 32-bit processes.

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) — ToWkt() / FromWkt() for standard text interchange
• Binary file I/O — ToFile() / FromFile() 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 GeomUtil.FindIntersections() 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 — GeomUtil.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.IsSimple() and GeomUtil.HasIntersections(segments) (Shamos–Hoey, boolean) / GeomUtil.FindIntersections(segments) (Bentley–Ottmann, every crossing point).
• Convex hull — GeomUtil.ConvexHull(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 GeomUtil.DistDecimation()/RdpDecimation()/VwDecimation()/BezierSmoothing2()/PolylineExpansion() for a plain point list.
• Polygon boolean operations — Intersection(), Union(), Difference(), Xor() between two polygons (map-overlay method), or GeomUtil.Clip(clipperLoop, subjectLoop) for raw point loops without constructing a Polygon first.
• Point cloud operations — GeomUtil.PrincipalAxes() (PCA) finds the empirical 3 directive axes of a list of points in space.
• Triangulation — decomposition of a polygon into n-triangles, using several possible algorithms such as the Ear Clip, a Best Fit Ear Clip, Monotone Polygon or Constrained Delaunay.
• Linear algebra (GeomPP.Maths) — a small fixed-size linear algebra namespace, independent of the geometry classes above: Vector2/Vector3/Vector4, Matrix2/Matrix3/Matrix4, and the Solvers.SolveGauss() / Solvers.SolveCramer() system solvers for Ax = b.
• Affine transformations (GeomPP.Transformations) — Transform.Translate(), .Rotate(), .Scale(), .Shear(), .Reflect() (fast, single-Point, no matrix needed), and the general Transform.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.Transform().

Intersection-style methods return object (null on no intersection) — see the pattern-matching example above.

Free functions

GeomUtil is a static class wrapping the geompp free functions that operate on point/segment lists directly, without needing a class instance first:

Build on Windows x64 manually

Build the C# DLL

# from the main directory, geompp

# .NET 8 (LTS, supported until Nov 2026)
msbuild geompp_csharp\GeomPP_Net8.vcxproj /p:Platform=x64 /p:GeomppBuildRoot="$PWD\build_win" [/p:Configuration=Release]

# .NET 9 (STS)
msbuild geompp_csharp\GeomPP_Net9.vcxproj /p:Platform=x64 /p:GeomppBuildRoot="$PWD\build_win" [/p:Configuration=Release]

# .NET 10 (LTS)
msbuild geompp_csharp\GeomPP_Net10.vcxproj /p:Platform=x64 /p:GeomppBuildRoot="$PWD\build_win" [/p:Configuration=Release]

# .NET Framework 4.8
msbuild geompp_csharp\GeomPP_Net48.vcxproj /p:Platform=x64 /p:GeomppBuildRoot="$PWD\build_win" [/p:Configuration=Release]

# run smoke tests, after build from the main directory geompp
# (GeomPPTests.csproj is an Exe-type console harness, not a Test SDK project —
# `dotnet test` reports success but runs nothing; use `dotnet run`)
dotnet run --project geompp_csharp\tests\GeomPPTests.csproj [-p:GeomPPConfiguration=Release]