Why 3D Boolean
Operations May Fail
Boolean operations on meshes, aka 3D Boolean operations, allow you to manipulate two (or more) objects to craft new shapes. Being of fundamental importance in computational geometry, such operations build upon advanced computational geometry algorithms. These identify intersecting regions of meshes to merge or remove them correctly.
While these operations may seem straightforward in theory—combining or cutting shapes, as simple as that—they can become really complex when dealing with large polygon counts, intricate designs, or “messy” geometries (e.g., those containing self-intersections, degenerate triangles, or non-manifold edges).
In this article, we explain why well-defined geometry is critical for successful Boolean operations and highlight common pitfalls that cause them to fail.
To learn more about 3D Boolean Operations (and their union-based, intersection-based, and difference-based subtypes), check out this article by the MeshLib team.
What Could Possibly Go Wrong? Poor Geometries Leading to Boolean Failures
Here is a hard fact to consider: not all 3D meshes are generated equal. Whenever a given mesh contains such issues as self-intersections, non-manifold edges, holes, or overlapping polygons, it is considered to be poorly defined geometry. Boolean operations on such geometries frequently fail, producing unsatisfactory, even unpredictable, results.
Which sorts of geometries could be viewed as well-designed ones? We would summarize their properties as follows:
- No self-intersections within the mesh overlap zone, which means one observes no situations in which a polygon intersects another polygon of the same mesh (in an unintended way). When self-intersections are located outside the mesh overlap area, they do not impede your Boolean operations;
- Consistent normals maintained. That is, each polygon is oriented in the same direction and relies on the same vertex ordering convention;
- Only manifold edges and vertices are present. In other words, every edge belongs to exactly two polygons, and each vertex can be traversed smoothly around without topological breaks;
- No floating or duplicate vertices or edges. All vertices and edges that share the same physical space are merged, and every polygon is properly connected.
Note: Speaking of consistent normals, MeshLib always ensures the consistency of normals within a single component. This is particularly important when multiple components are present, as it guarantees proper alignment of their ‘inside’ and ‘outside’ orientations.
When these criteria are met, 3D Boolean operations work more reliably and yield cleaner, more exact, and practically dependable results.
What if not? In this case, 3D Boolean operations are very likely to fail for reasons tied to a mesh’s topology or geometry, encompassing:
- Self-intersections. If a mesh folds into itself, the algorithm cannot consistently resolve the internal collisions;
- Degenerate triangles, i.e., zero-area triangles, can cause issues if they are misinterpreted as self-intersections. These triangles may violate assumptions in Boolean operations. That , in turn, will lead to inaccuracies or unexpected results;
- Non-manifold edges. Edges that don’t conform to normal manifold rules could confuse Boolean algorithms, too;
- Holes. Incomplete surfaces prevent the algorithm from clearly distinguishing the mesh interior from its exterior.
Best 3D Boolean Strategies for Poorly Defined Geometries
The problem is clear: which library should you choose when dealing with flawed or messy geometries? Should you ignore the issues and use libraries tolerant of poorly defined meshes? Or should you opt for libraries that require well-defined geometry and thus mandate some initial cleanup?
Mixing theory and practice, we will attempt to clarify this issue.
Libraries That Tolerate Poor-Defined Geometries
3D Boolean libraries that tolerate poorly defined geometries might look convenient for quick operations. Yet, their weighty simultaneous downside is that the results are often unpredictable. You might end up spending a significant amount of time on post-processing, mesh repairs, or even re-meshing—sometimes multiple times—to correct any flaws introduced by the Boolean operation.
In the worst cases, you might have to go back and fix the original geometry before attempting any Boolean round again. This extra effort could easily negate the initial benefit of employing such a “plug-and-play” solution.
Pros: Instant availability, resource savings if it all succeeds
Cons: Unpredictability, risks of outright failures, high chances of post-processing or even re-meshing activities
Libraries That Mandate Well-Defined Geometries
While libraries that mandate well-defined geometries do require you to address mesh flaws (e.g., holes, self-intersections) upfront, they tend to produce more robust and accurate results. By insisting on manifold edges, consistent normals, and clean topology from the start, these libraries can handle more advanced tasks—like partial Booleans—with fewer errors.
If your mesh is already in good shape or if you invest time in repairing it beforehand, you can avoid the unpredictable failures and re-meshing cycles that often plague “plug-and-play” solutions. In the long run, this approach could save significant effort, especially if the same model is used for further processing steps.
Pros:
- Highly exact outputs
- Fewer surprises
- Advanced features become more feasible
Cons:
- Requires up-front mesh repair
- Potentially time-consuming (especially if the geometry has major flaws)
Check out MeshLib’s documentation as a representative of such libraries
Note: MeshLib also provides our Voxel Boolean option which is compatible with numerous significant geometric inconsistencies, but typically takes longer to process. If your geometry features defects you are unable to fix immediately, this approach may be an effective workaround.
For more details, again, we invite you to look through our overview of Advanced 3D Boolean Operations.
3D Boolean Operations: A Practical Test
Let’s explore how some popular libraries work under this type of pressure. For that, we present a selection of difficult-to-process cases that cause most failures.
Complex Geometries
Holed, Not Intersected: Performing a Boolean union of two meshes, with one featuring a hole separate from their overlapping area
Holed Intersected: Performing a Boolean union on two meshes, one of which has a hole located in the overlapping area.
Self-Intersections. Performing a Boolean union on two meshes, one of which exhibits self-intersections precisely where the surfaces overlap.
Heavy Mesh Simplification Details
Library | Holed, Not Intersected | Holed, Intersected | Self-Intersections |
|---|---|---|---|
Meshlib 2.4.0.85 | + | -* | -** |
MCut | + | – | – |
Manifold | – | – | + |
CinoLib + RobustMesh | + | + | + |
CGAL | + | – | – |
Libigl | – | – | + |
Trimesh-Manifold | – | – | + |
Trimesh-Blender | + | + | + |
- Clarifications
- “+” — operation is feasible.
- “-” — operation is not feasible.
- Orange — operation runs but yields an incorrect result.
* Nota bene. MeshLib does not handle non-manifold meshes as-is. It automatically converts them to a manifold structure.
** Caution. Such operations are inherently ambiguous, often producing meshes with errors like self-intersections or degenerate triangles.
Our table shows, at a glance, which libraries offer feasible Boolean operations under certain problematic conditions. However, feasibility does not guarantee error-free or predictable results in your particular case—libraries that handle flawed meshes often still produce imperfect or partial outcomes. Thus, it’s crucial to evaluate whether further mesh repair or cleanup is mandated before and after any Boolean operation.
Conclusion
Ill-defined geometries can—and likely will—disrupt your efforts. While there are some libraries that claim to be ready to tackle this challenge in existence, producing more or less decent results from time to time, the best course of action is to refine your geometries first.
MeshLib is a great candidate for that. Through our library, you can resolve such issues as self-intersections and holes quickly and with comfort, to make sure your 3D Boolean operations will give you the very results you expect!