Add parallelization to PMP_boolean_operation

AABB_tree/benchmark/AABB_tree/CMakeLists.txt

@@ -16,4 +16,4 @@ if(benchmark_FOUND)
   target_link_libraries(tree_creation PRIVATE benchmark::benchmark)
 else()
   message(STATUS "NOTICE: The benchmark 'tree_creation.cpp' requires the Google benchmark library, and will not be compiled.")
-endif()
+endif()

AABB_tree/doc/AABB_tree/PackageDescription.txt

@@ -50,4 +50,8 @@
 - `CGAL::AABB_primitive<Id,ObjectPropertyMap,PointPropertyMap,ExternalPropertyMaps,CacheDatum>`
 - `CGAL::AABB_halfedge_graph_segment_primitive<HalfedgeGraph,Vpm,OneHalfedgeGraphPerTree,CacheDatum>`
 - `CGAL::AABB_face_graph_triangle_primitive<FaceGraph,Vpm,OneFaceGraphPerTree,CacheDatum>`
+
+\cgalCRPSection{Functions}
+- `CGAL::AABB_trees::do_intersect()`
+- `CGAL::AABB_trees::all_pairs_of_intersecting_primitives()`
 */

AABB_tree/doc/AABB_tree/aabb_tree.txt

@@ -23,10 +23,10 @@ triangles, or plane objects (planes, triangles) against sets of
 segments. An example of a distance query consists of finding the
 closest point from a point query to a set of triangles.
 
-Note that this component is not suited to the problem of finding all
-intersecting pairs of objects. We refer to the component
+This component solves the problem of finding all
+intersecting pairs of objects and achieves better perfomance than
 \ref chapterBoxIntersection "Intersecting Sequences of dD Iso-oriented Boxes"
-which can find all intersecting pairs of iso-oriented boxes.
+when using parallell execution.
 
 The AABB tree data structure takes as input an iterator range of
 geometric data, which is then converted into primitives. From these
@@ -109,6 +109,13 @@ For example if one is using `CGAL::AABB_traits` with a Kernel from \cgal,
 having degenerate triangles or segments in the AABB-tree will result in an undefined
 behavior or a crash.
 
+\section two_aabb_tree_interface Operation between two trees
+
+Given two AABB trees, the functions `CGAL::AABB_trees::do_intersect()` and
+`CGAL::AABB_trees::all_pairs_of_intersecting_primitives()` can be used to compute,
+respectively, whether the two sets intersect and the list of all
+intersecting object pairs.
+
 \section aabb_tree_examples Examples
 
 \subsection aabb_tree_examples_1 Tree of Triangles, for Intersection and Distance Queries
@@ -206,6 +213,14 @@ triangle set stored through two arrays: one array of points and one
 array of indices which refer to the point array. Here also the
 primitive internally uses a `boost::iterator_adaptor`.
 
+\subsection aabb_tree_examples_9 Intersections of two trees
+
+In the following example, we compute all the intersections between two tetrahedron. The tetrahedron
+are stored as a vector of `Triangle_3`. We first compute if the tetrahedron do intersect and then we
+draw the indices of the intersecting triangle.
+
+\cgalExample{AABB_tree/AABB_intersection_example.cpp}
+
 \section aabb_tree_perf Performances
 
 We provide some performance numbers for the case where the AABB tree

AABB_tree/doc/AABB_tree/examples.txt

@@ -16,4 +16,5 @@
 \example AABB_tree/AABB_triangle_3_example.cpp
 \example AABB_tree/AABB_halfedge_graph_edge_example.cpp
 \example AABB_tree/AABB_face_graph_triangle_example.cpp
+\example AABB_tree/AABB_intersection_example.cpp
 */

AABB_tree/examples/AABB_tree/AABB_intersection_example.cpp

@@ -0,0 +1,59 @@
+#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
+
+#include <CGAL/AABB_tree.h>
+#include <CGAL/AABB_traits_3.h>
+#include <CGAL/AABB_triangle_primitive_3.h>
+#include <CGAL/AABB_trees/intersection.h>
+
+#include <iostream>
+#include <fstream>
+
+typedef CGAL::Exact_predicates_inexact_constructions_kernel K;
+
+typedef K::Point_3 Point;
+typedef K::Triangle_3 Triangle;
+
+typedef std::vector<Triangle>::iterator Iterator;
+typedef CGAL::AABB_triangle_primitive_3<K, Iterator> Primitive;
+typedef CGAL::AABB_traits_3<K, Primitive> AABB_triangle_traits;
+typedef CGAL::AABB_tree<AABB_triangle_traits> Tree;
+
+int main()
+{
+    Point a(1.0, 0.0, 0.0);
+    Point b(0.0, 1.0, 0.0);
+    Point c(0.0, 0.0, 1.0);
+    Point d(0.0, 0.0, 0.0);
+
+    Point e(1.2, 0.2, 0.2);
+    Point f(0.2, 1.2, 0.2);
+    Point g(0.2, 0.2, 1.2);
+    Point h(0.2, 0.2, 0.2);
+
+    std::vector<Triangle> tetra1;
+    tetra1.push_back(Triangle(a,b,c));
+    tetra1.push_back(Triangle(a,b,d));
+    tetra1.push_back(Triangle(a,d,c));
+    tetra1.push_back(Triangle(b,c,d));
+
+    std::vector<Triangle> tetra2;
+    tetra2.push_back(Triangle(e,f,g));
+    tetra2.push_back(Triangle(e,f,h));
+    tetra2.push_back(Triangle(e,h,g));
+    tetra2.push_back(Triangle(f,g,h));
+
+    // constructs AABB tree
+    Tree tree1(tetra1.begin(),tetra1.end());
+    Tree tree2(tetra2.begin(),tetra2.end());
+
+    // do intersect
+    std::cout << "Tetrahedrons do intersect: " << CGAL::AABB_trees::do_intersect(tree1, tree2) << std::endl;
+
+    std::vector< std::pair<Iterator, Iterator> > intersections;
+    CGAL::AABB_trees::all_pairs_of_intersecting_primitives(tree1, tree2, std::back_inserter(intersections));
+
+    for(auto [id1, id2]: intersections)
+      std::cout << "ids: " << std::distance(tetra1.begin(), id1) << " " << std::distance(tetra2.begin(), id2) << std::endl;
+
+    return EXIT_SUCCESS;
+}