Updated the S1 distance function coordinate range from [-pi...+pi] to [0...1].

Added search_box for topological spaces.
* Wrapping box support added for topological metrics.

Author: Jaybro

examples/kd_tree/kd_tree_search.cpp

@@ -73,23 +73,25 @@ void search_r3() {
   }
 }
 
-// Search on the circle.
+// This example shows how to search on the unit circle. Point coordinates must
+// lie within the range of [0...1]. Point coordinates wrap at 0 or 1. A point
+// with a coordinate value of 0 is considered the same as one with a coordinate
+// value of 1.
 void search_s1() {
   using point = pico_tree::point_1f;
+  using scalar = typename pico_tree::point_1f::scalar_type;
   using space = std::vector<point>;
   using neighbor =
       pico_tree::kd_tree<space, pico_tree::metric_so2>::neighbor_type;
 
-  const auto pi = typename point::scalar_type(3.1415926537);
-
   pico_tree::kd_tree<space, pico_tree::metric_so2> tree(
-      pico_tree::generate_random_n<point>(512, -pi, pi),
+      pico_tree::generate_random_n<point>(512, scalar(0.0), scalar(1.0)),
       pico_tree::max_leaf_size_t(10));
 
   std::array<neighbor, 8> knn;
-  tree.search_knn(point{pi}, knn.begin(), knn.end());
+  tree.search_knn(point{1.0}, knn.begin(), knn.end());
 
-  // These prints show that wrapping around near point -PI ~ PI is supported.
+  // These prints show that wrapping near values 0 ~ 1 is supported.
   std::cout << "Closest angles (index, distance, value): " << std::endl;
   for (auto const& nn : knn) {
     std::cout << "  " << nn.index << ", " << nn.distance << ", "

setup.py

@@ -1,18 +1,18 @@
 #!/usr/bin/env python3
-
 from skbuild import setup
 
 
-setup(name='pico_tree',
-      # The same as the CMake project version.
-      version='0.8.3',
-      description='PicoTree Python Bindings',
-      author='Jonathan Broere',
-      url='https://github.com/Jaybro/pico_tree',
-      license='MIT',
-      packages=['pico_tree'],
-      package_dir={'': 'src/pyco_tree'},
-      cmake_install_dir='src/pyco_tree/pico_tree',
-      python_requires='>=3.10',
-      install_requires=['numpy'],
-      )
+setup(
+    name='pico_tree',
+    # The same as the CMake project version.
+    version='0.8.3',
+    description='PicoTree Python Bindings',
+    author='Jonathan Broere',
+    url='https://github.com/Jaybro/pico_tree',
+    license='MIT',
+    packages=['pico_tree'],
+    package_dir={'': 'src/pyco_tree'},
+    cmake_install_dir='src/pyco_tree/pico_tree',
+    python_requires='>=3.10',
+    install_requires=['numpy'],
+)

src/pico_tree/pico_tree/internal/kd_tree_search.hpp

@@ -165,12 +165,14 @@ class search_nearest_topological {
           v,
           node->data.branch.left_min,
           node->data.branch.left_max,
-          node->data.branch.split_dim);
+          node->data.branch.split_dim,
+          euclidean_space_tag{});
       scalar_type const d2 = metric_(
           v,
           node->data.branch.right_min,
           node->data.branch.right_max,
-          node->data.branch.split_dim);
+          node->data.branch.split_dim,
+          euclidean_space_tag{});
       node_type const* node_1st;
       node_type const* node_2nd;
       scalar_type new_offset;
@@ -210,27 +212,28 @@ class search_nearest_topological {
   Visitor_& visitor_;
 };
 
-//! \brief A functor that provides range searches for Euclidean spaces. Query
-//! time is bounded by O(n^(1-1/dimension)+k).
+//! \brief A functor that provides range searches for both Euclidean and
+//! topological spaces. Query time is bounded by O(n^(1-1/dimension)+k).
 //! \details Many tree nodes are excluded by checking if they intersect with the
 //! box of the query. We don't store the bounding box of each node but calculate
 //! them at run time. This slows down search_box in favor of having faster
 //! nearest neighbor searches.
 template <typename SpaceWrapper_, typename Metric_, typename Index_>
-class search_box_euclidean {
- public:
-  // TODO Perhaps we can support it for both topological and Euclidean spaces.
-  static_assert(
-      std::is_same_v<typename Metric_::space_category, euclidean_space_tag>,
-      "SEARCH_BOX_ONLY_SUPPORTED_FOR_EUCLIDEAN_SPACES");
+class search_box {
+  using space_category = typename Metric_::space_category;
+  static constexpr bool is_euclidean_space_v =
+      std::is_same_v<space_category, euclidean_space_tag>;
 
+ public:
   using index_type = Index_;
   using scalar_type = typename SpaceWrapper_::scalar_type;
   static size_t constexpr dim = SpaceWrapper_::dim;
   using box_type = box<scalar_type, dim>;
   using box_map_type = box_map<scalar_type const, dim>;
+  using node_type = typename kd_tree_space_tag_traits<
+      space_category>::template node_type<index_type, scalar_type>;
 
-  inline search_box_euclidean(
+  inline search_box(
       SpaceWrapper_ space,
       Metric_ metric,
       std::vector<index_type> const& indices,
@@ -245,13 +248,12 @@ class search_box_euclidean {
         idxs_(idxs) {}
 
   //! \brief Range search starting from \p node.
-  template <typename Node_>
-  inline void operator()(Node_ const* const node) {
+  inline void operator()(node_type const* const node) {
     if (node->is_leaf()) {
       auto begin = indices_.begin() + node->data.leaf.begin_idx;
       auto const end = indices_.begin() + node->data.leaf.end_idx;
       for (; begin < end; ++begin) {
-        if (query_.contains(space_[*begin])) {
+        if (contains(*begin)) {
           idxs_.push_back(*begin);
         }
       }
@@ -265,7 +267,7 @@ class search_box_euclidean {
       // down the left node.
       if (query_.contains(box_)) {
         report_node(node->left);
-      } else if (query_.min(split_dim) <= node->data.branch.left_max) {
+      } else if (intersects_left(split_dim, node)) {
         operator()(node->left);
       }
 
@@ -276,7 +278,7 @@ class search_box_euclidean {
       // Same as the left side.
       if (query_.contains(box_)) {
         report_node(node->right);
-      } else if (query_.max(split_dim) >= node->data.branch.right_min) {
+      } else if (intersects_right(split_dim, node)) {
         operator()(node->right);
       }
 
@@ -285,9 +287,61 @@ class search_box_euclidean {
   }
 
  private:
+  // TODO We could add an extra class layer to the box_base, box, and box_map
+  // hierarchy, to support topological boxes. However, this is a lot more
+  // code/work and we currently only use this feature here and in a unit test.
+  bool contains(scalar_type const* const p) const {
+    for (size_t i = 0; i < query_.size(); ++i) {
+      if (metric_(
+              p[i],
+              query_.min(i),
+              query_.max(i),
+              static_cast<int>(i),
+              topological_space_tag{}) > scalar_type(0.0)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool contains(index_type const idx) const {
+    if constexpr (is_euclidean_space_v) {
+      return query_.contains(space_[idx]);
+    } else {
+      return contains(space_[idx]);
+    }
+  }
+
+  bool contains() const {
+    if constexpr (is_euclidean_space_v) {
+      return query_.contains(box_);
+    } else {
+      return contains(box_.min()) && contains(box_.max());
+    }
+  }
+
+  bool intersects_left(
+      size_t const split_dim, node_type const* const node) const {
+    if constexpr (is_euclidean_space_v) {
+      return query_.min(split_dim) <= node->data.branch.left_max;
+    } else {
+      return query_.min(split_dim) <= node->data.branch.left_max ||
+             query_.max(split_dim) >= node->data.branch.left_min;
+    }
+  }
+
+  bool intersects_right(
+      size_t const split_dim, node_type const* const node) const {
+    if constexpr (is_euclidean_space_v) {
+      return query_.max(split_dim) >= node->data.branch.right_min;
+    } else {
+      return query_.max(split_dim) >= node->data.branch.right_min ||
+             query_.min(split_dim) <= node->data.branch.right_max;
+    }
+  }
+
   //! \brief Reports all indices contained by \p node.
-  template <typename Node_>
-  inline void report_node(Node_ const* const node) const {
+  inline void report_node(node_type const* const node) const {
     index_type begin;
     index_type end;
 
@@ -309,17 +363,15 @@ class search_box_euclidean {
         std::back_inserter(idxs_));
   }
 
-  template <typename Node_>
-  inline index_type report_left(Node_ const* const node) const {
+  inline index_type report_left(node_type const* const node) const {
     if (node->is_leaf()) {
       return node->data.leaf.begin_idx;
     } else {
       return report_left(node->left);
     }
   }
 
-  template <typename Node_>
-  inline index_type report_right(Node_ const* const node) const {
+  inline index_type report_right(node_type const* const node) const {
     if (node->is_leaf()) {
       return node->data.leaf.end_idx;
     } else {

src/pico_tree/pico_tree/kd_tree.hpp

@@ -71,8 +71,12 @@ class kd_tree {
       splitter_rule_t<Rule_> const& rule = Rule_{})
       : space_(std::move(space)),
         metric_(),
-        data_(internal::build_kd_tree<kd_tree_data_type, dim>()(
-            space_wrapper_type(space_), stop_condition, start_bounds, rule)) {}
+        data_(
+            internal::build_kd_tree<kd_tree_data_type, dim>()(
+                space_wrapper_type(space_),
+                stop_condition,
+                start_bounds,
+                rule)) {}
 
   //! \brief The kd_tree cannot be copied.
   //! \details The kd_tree uses pointers to nodes and copying pointers is not
@@ -287,7 +291,7 @@ class kd_tree {
     // now it is assumed that this check is not worth it: If there is any
     // overlap then the search is slower. So unless many queries don't intersect
     // there is no point in adding it.
-    internal::search_box_euclidean<space_wrapper_type, Metric_, index_type>(
+    internal::search_box<space_wrapper_type, Metric_, index_type>(
         space,
         metric_,
         data_.indices,