From 1a9a821193754e3ae5f19ba77093aa2cab767b90 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= <sebastien.loriot@cgal.org>
Date: Tue, 27 Apr 2021 19:24:07 +0200
Subject: [PATCH] add a way to get a direct access to primitive in a box when
 below a given nb of primitives

---
 AABB_tree/include/CGAL/AABB_tree.h            | 16 ++++
 .../CGAL/internal/AABB_tree/AABB_node.h       | 88 +++++++++++++++++++
 2 files changed, 104 insertions(+)

diff --git a/AABB_tree/include/CGAL/AABB_tree.h b/AABB_tree/include/CGAL/AABB_tree.h
index 3364403c245..48be3009460 100644
--- a/AABB_tree/include/CGAL/AABB_tree.h
+++ b/AABB_tree/include/CGAL/AABB_tree.h
@@ -542,6 +542,22 @@ public:
       }
     }
 
+    template <class Query, class Traversal_traits>
+    void traversal_with_priority_and_group_traversal(const Query& query, Traversal_traits& traits, double group_traversal_bound) const
+    {
+      switch(size())
+      {
+      case 0:
+        break;
+      case 1:
+        traits.intersection(query, singleton_data());
+        break;
+      default: // if(size() >= 2)
+        if ( traits.do_intersect(query, *root_node()) && traits.go_further() )
+          root_node()->template traversal_with_priority_and_group_traversal(m_primitives, query, traits, m_primitives.size(), 0, group_traversal_bound);
+      }
+    }
+
   private:
     typedef AABB_node<AABBTraits> Node;
 
diff --git a/AABB_tree/include/CGAL/internal/AABB_tree/AABB_node.h b/AABB_tree/include/CGAL/internal/AABB_tree/AABB_node.h
index 3f64d69c22e..bfef12b85ab 100644
--- a/AABB_tree/include/CGAL/internal/AABB_tree/AABB_node.h
+++ b/AABB_tree/include/CGAL/internal/AABB_tree/AABB_node.h
@@ -73,6 +73,15 @@ public:
                                Traversal_traits& traits,
                                const std::size_t nb_primitives) const;
 
+  template<class Primitive_vector, class Traversal_traits, class Query>
+  void traversal_with_priority_and_group_traversal(const Primitive_vector& primitives,
+                                                   const Query& query,
+                                                   Traversal_traits& traits,
+                                                   const std::size_t nb_primitives,
+                                                   std::size_t first_primitive_index,
+                                                   const std::size_t group_size_bound) const;
+
+
 private:
   typedef AABBTraits AABB_traits;
   typedef AABB_node<AABB_traits> Node;
@@ -225,6 +234,85 @@ AABB_node<Tr>::traversal_with_priority(const Query& query,
   }
 }
 
+
+//TODO: find a better name
+template<typename Tr>
+template<class Primitive_vector, class Traversal_traits, class Query>
+void
+AABB_node<Tr>::traversal_with_priority_and_group_traversal(const Primitive_vector& primitives,
+                                                           const Query& query,
+                                                           Traversal_traits& traits,
+                                                           const std::size_t nb_primitives,
+                                                           std::size_t first_primitive_index,
+                                                           const std::size_t group_size_bound) const
+{
+  if (nb_primitives <= group_size_bound)
+  {
+    traits.traverse_group(query, primitives.begin()+first_primitive_index, primitives.begin()+first_primitive_index+nb_primitives);
+    return;
+  }
+
+  // Recursive traversal
+  switch(nb_primitives)
+  {
+  case 2:
+    traits.intersection(query, left_data());
+    if( traits.go_further() )
+    {
+      traits.intersection(query, right_data());
+    }
+    break;
+  case 3:
+    traits.intersection(query, left_data());
+    if( traits.go_further() && traits.do_intersect(query, right_child()) )
+    {
+      right_child().traversal_with_priority_and_group_traversal(primitives, query, traits, 2, first_primitive_index+1, group_size_bound);
+    }
+    break;
+  default:
+    bool ileft, iright;
+    typename Traversal_traits::Priority pleft, pright;
+    std::tie(ileft, pleft) = traits.do_intersect_with_priority(query, left_child());
+    std::tie(iright, pright) = traits.do_intersect_with_priority(query, right_child());
+    CGAL_precondition( (ileft || iright) ? traits.do_intersect(query, *this) : true );
+
+    if(ileft)
+    {
+      if(iright)
+      {
+        // Both children have to be inspected.
+        if(pleft >= pright)
+        {
+          // Inspect the left child first, has higher priority.
+          left_child().traversal_with_priority_and_group_traversal(primitives,query, traits, nb_primitives/2, first_primitive_index, group_size_bound);
+          if( traits.go_further() )
+            right_child().traversal_with_priority_and_group_traversal(primitives,query, traits, nb_primitives-nb_primitives/2, first_primitive_index+nb_primitives/2, group_size_bound);
+        }
+        else
+        {
+          // Inspect the right child first, has higher priority.
+          right_child().traversal_with_priority_and_group_traversal(primitives,query, traits, nb_primitives-nb_primitives/2, first_primitive_index+nb_primitives/2, group_size_bound);
+          if( traits.go_further() )
+            left_child().traversal_with_priority_and_group_traversal(primitives,query, traits, nb_primitives/2, first_primitive_index, group_size_bound);
+        }
+      }
+      else
+      {
+        // Only the left child has to be inspected.
+        left_child().traversal_with_priority_and_group_traversal(primitives,query, traits, nb_primitives/2, first_primitive_index, group_size_bound);
+      }
+    }
+    else
+    {
+      if(iright)
+      {
+        // Only the right child has to be inspected.
+        right_child().traversal_with_priority_and_group_traversal(primitives,query, traits, nb_primitives-nb_primitives/2, first_primitive_index+nb_primitives/2, group_size_bound);
+      }
+    }
+  }
+}
+
 } // end namespace CGAL
 
 #endif // CGAL_AABB_NODE_H