Add new implementation of Boolean operations on triangle soups

Installation/CHANGES.md

@@ -26,6 +26,9 @@ Release date: December 2026
 - The corefinement based operations (including Boolean operations) has been optimized to better
   handle cases when some identical faces are shared between the input meshes. This leads to a significant speed up
   in those cases.
+- Added new multithreading compatible functions operating directly on triangle soups, enabling the handling of non-manifold input and output volumes:
+  `CGAL::Polygon_mesh_processing::compute_union()`, `CGAL::Polygon_mesh_processing::compute_intersection()`, and
+  `CGAL::Polygon_mesh_processing::compute_difference()`.
 
 ## [Release 6.2](https://github.com/CGAL/cgal/releases/tag/v6.2)
 

PMP_Boolean_operations/doc/PMP_Boolean_operations/Doxyfile.in

@@ -8,5 +8,3 @@ HIDE_UNDOC_CLASSES         =  true
 WARN_IF_UNDOCUMENTED       =  false
 
 EXCLUDE_SYMBOLS += experimental
-
-HTML_EXTRA_FILES           = ${CGAL_PACKAGE_DOC_DIR}/fig/kernel.png

PMP_Boolean_operations/doc/PMP_Boolean_operations/PMP_Boolean_operations.txt

@@ -18,7 +18,7 @@ of the geometry processing toolkit, with numerous applications in CAD and
 computer graphics. As an example, it constitutes the essential operation of Constructive Solid Geometry (CSG).
 
 This \cgal package offers functions to compute the union, intersection, and difference
-of volumes bounded by triangle meshes. The core of the method is the <em>corefinement</em> technique,
+of volumes bounded by triangle meshes and triangle soups. The core of the method is the <em>corefinement</em> technique,
 which refines two meshes such that they become conformal.
 This technique is re-used to also propose functions that enable trimming a mesh ("clipping")
 and bisecting a mesh ("splitting") with a plane, a box, or another mesh.
@@ -145,7 +145,7 @@ possible, the input mesh will still be corefined.
 
 If the input meshes contain triangles that are coplanar, it is guaranteed that the triangulations of those triangles
 in the two corefined meshes will be identical. Also all edges of those refined triangles will be reported as intersection
-edges (both in the function `CGAL::Polygon_mesh_processing::surface_intersection()` and in the named parameter
+edges (both in the function `CGAL::Polygon_mesh_processing::intersection_polylines()` and in the named parameter
 `edge_is_constrained_map()` of corefine prefixed functions).
 
 \subsubsection coref_bolop_input_autorefsub Autorefinement
@@ -154,6 +154,22 @@ There is no restriction on the input for the function `CGAL::Polygon_mesh_proces
 Degenerate triangles will be eliminated, duplicated points will be merged. If several triangles are coplanar,
 the output will contain as many copies of the triangulation of those refined triangles.
 
+\subsection tsoup_bolop_subsec Computing Boolean Operations on Triangle Soups
+The Boolean operation functions based on corefine operate on triangle meshes. This data structure is not meant to
+handle non-manifold edges. As it is sometime desirable to handle such cases, we also provide operations that are
+taking as input triangle soups, representing possibly non-manifold volumes, and providing the result of a Boolean
+operation as a triangle soup. In the following example, we use the function `CGAL::Polygon_mesh_processing::compute_difference()`
+to iteratively subtract pieces of a puzzle.
+
+\cgalFigureAnchor{nm_no_fig}
+<center>
+<img src="i_nm_bo.png" style="max-width:70%;"/>
+</center>
+\cgalFigureCaptionBegin{nm_no_fig}
+Iterative subtraction of the pieces of a puzzle from David's torso. The result of the second operation is non-manifold and
+so are all subsequent operations, until the last one.
+\cgalFigureCaptionEnd
+
 
 \subsection coref_valid_subsec Kernel Choice and Output Validity
 
@@ -323,5 +339,7 @@ The kernel functions and the specialization of clipping and plane refinement to
 inputs were implemented in 2025 by Léo Valque, inspired by the work of Sorgente et al.
 \cgalCite{sorgente2022polyhedron}.
 
+The illustrations of the package pay homage to French sculptor and painter Sacha Sosno.
+
 */
 } /* namespace CGAL */

PMP_Boolean_operations/doc/PMP_Boolean_operations/PackageDescription.txt

@@ -6,8 +6,12 @@
 /// Functions to corefine triangulated surface meshes and triangle soups.
 /// \ingroup PkgPMPBooleanOperationsRef
 
-/// \defgroup PMP_boolop_grp Boolean Operations
-/// Functions to compute triangulated the union, difference, and intersection of meshes.
+/// \defgroup PMP_boolop_grp Boolean Operations on Triangle Meshes
+/// Functions to compute the union, difference, and intersection of triangle meshes.
+/// \ingroup PkgPMPBooleanOperationsRef
+
+/// \defgroup PMP_boolop_soup_grp Boolean Operations on Triangle Soups
+/// Functions to compute triangulated the union, difference, and intersection of triangle soups (possibly non-manifold).
 /// \ingroup PkgPMPBooleanOperationsRef
 
 /// \defgroup PMP_clip_grp Clipping and Splitting
@@ -66,6 +70,11 @@ The page \ref bgl_namedparameters "Named Parameters" describes their usage.
 - `CGAL::Polygon_mesh_processing::surface_intersection()` (deprecated)
 - `CGAL::Polygon_mesh_processing::intersection_polylines()`
 
+\cgalCRPSection{General Boolean Operations}
+- `CGAL::Polygon_mesh_processing::compute_union()`
+- `CGAL::Polygon_mesh_processing::compute_difference()`
+- `CGAL::Polygon_mesh_processing::compute_intersection()`
+
 \cgalCRPSection{Clipping and Splitting}
 - `CGAL::Polygon_mesh_processing::clip()`
 - `CGAL::Polygon_mesh_processing::split()`

PMP_Boolean_operations/examples/PMP_Boolean_operations/CMakeLists.txt

@@ -18,6 +18,7 @@ create_single_source_cgal_program("corefinement_mesh_union_with_attributes.cpp")
 create_single_source_cgal_program("corefinement_polyhedron_union.cpp")
 create_single_source_cgal_program("corefinement_LCC.cpp")
 create_single_source_cgal_program("soup_autorefinement.cpp")
+create_single_source_cgal_program("soup_union.cpp")
 create_single_source_cgal_program("surface_mesh_intersection.cpp")
 create_single_source_cgal_program("triangle_mesh_autorefinement.cpp")
 create_single_source_cgal_program("snap_polygon_soup.cpp")
@@ -49,6 +50,7 @@ find_package(TBB QUIET)
 include(CGAL_TBB_support)
 if(TARGET CGAL::TBB_support)
   target_link_libraries(soup_autorefinement PRIVATE CGAL::TBB_support)
+  target_link_libraries(soup_union PRIVATE CGAL::TBB_support)
   target_link_libraries(snap_polygon_soup PRIVATE CGAL::TBB_support)
 
   create_single_source_cgal_program("corefinement_parallel_union_meshes.cpp")

PMP_Boolean_operations/examples/PMP_Boolean_operations/soup_union.cpp

@@ -0,0 +1,52 @@
+#include <CGAL/Exact_predicates_exact_constructions_kernel.h>
+
+#include <CGAL/Polygon_mesh_processing/triangle_soup_boolean_operations_3.h>
+#include <CGAL/IO/polygon_soup_io.h>
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+typedef CGAL::Exact_predicates_exact_constructions_kernel K;
+typedef K::Point_3 Point;
+
+namespace PMP = CGAL::Polygon_mesh_processing;
+
+int main(int argc, char* argv[])
+{
+  const std::string filename1 =
+    (argc > 1) ? argv[1] : CGAL::data_file_path("meshes/blobby.off");
+  const std::string filename2 =
+    (argc > 2) ? argv[2] : CGAL::data_file_path("meshes/eight.off");
+
+  std::vector<Point> points1, points2;
+  std::vector<std::array<std::size_t, 3>> triangles1, triangles2;
+
+  if(!CGAL::IO::read_polygon_soup(filename1, points1, triangles1))
+  {
+    std::cerr << "Failed to read file: " << filename1 << std::endl;
+    return 1;
+  }
+
+  if(!CGAL::IO::read_polygon_soup(filename2, points2, triangles2))
+  {
+    std::cerr << "Failed to read file: " << filename2 << std::endl;
+    return 1;
+  }
+
+  std::vector<Point> points_output;
+  std::vector<std::array<std::size_t, 3>> triangles_output;
+
+  PMP::compute_union(points1, triangles1,
+                     points2, triangles2,
+                     points_output, triangles_output,
+                    CGAL::parameters::concurrency_tag(CGAL::Parallel_if_available_tag()));
+
+  std::cout << "Union was successfully computed\n";
+
+  CGAL::IO::write_polygon_soup(
+    "union.off", points_output, triangles_output,
+    CGAL::parameters::stream_precision(17));
+
+  return 0;
+}