Merge pull request #1107 from Geode-solutions/feat_add_ellipsoid_radius_neighbors_in_nnsearch

Feat_add_ellipsoid_radius_neighbors_in_nnsearch

Author: MelchiorSchuh

bindings/python/src/geometry/nn_search.cpp

@@ -35,9 +35,17 @@
         .def( "point", &NNSearch##dimension##D::point )                        \
         .def( "closest_neighbor", &NNSearch##dimension##D::closest_neighbor )  \
         .def( "radius_neighbors", &NNSearch##dimension##D::radius_neighbors )  \
+        .def( "frame_neighbors", &NNSearch##dimension##D::frame_neighbors )    \
         .def( "neighbors", &NNSearch##dimension##D::neighbors )                \
-        .def( "colocated_index_mapping",                                       \
-            &NNSearch##dimension##D::colocated_index_mapping );                \
+        .def( "radius_colocated_index_mapping",                                \
+            static_cast< NNSearch##dimension##D::ColocatedInfo (               \
+                NNSearch##dimension##D::* )( double ) const >(                 \
+                &NNSearch##dimension##D::colocated_index_mapping ) )           \
+        .def( "frame_colocated_index_mapping",                                 \
+            static_cast< NNSearch##dimension##D::ColocatedInfo (               \
+                NNSearch##dimension##D::* )( const Frame##dimension##D& )      \
+                    const >(                                                   \
+                &NNSearch##dimension##D::colocated_index_mapping ) );          \
                                                                                \
     const auto info##dimension =                                               \
         "ColocatedInfo" + std::to_string( dimension ) + "D";                   \
@@ -50,7 +58,7 @@
         .def( "nb_unique_points",                                              \
             &NNSearch##dimension##D::ColocatedInfo::nb_unique_points )         \
         .def( "nb_colocated_points",                                           \
-            &NNSearch##dimension##D::ColocatedInfo::nb_colocated_points )
+            &NNSearch##dimension##D::ColocatedInfo::nb_colocated_points );
 
 namespace geode
 {

bindings/python/tests/geometry/test-py-nnsearch.py

@@ -22,16 +22,23 @@
 import os
 import sys
 import platform
+
 if sys.version_info >= (3, 8, 0) and platform.system() == "Windows":
-    for path in [x.strip() for x in os.environ['PATH'].split(';') if x]:
+    for path in [x.strip() for x in os.environ["PATH"].split(";") if x]:
         os.add_dll_directory(path)
 
 import opengeode_py_basic as basic
 import opengeode_py_geometry as geom
 
-if __name__ == '__main__':
-    search = geom.NNSearch2D([geom.Point2D([0.1, 4.2]), geom.Point2D(
-        [5.9, 7.3]), geom.Point2D([1.8, -5]), geom.Point2D([-7.3, -1.6])])
+if __name__ == "__main__":
+    search = geom.NNSearch2D(
+        [
+            geom.Point2D([0.1, 4.2]),
+            geom.Point2D([5.9, 7.3]),
+            geom.Point2D([1.8, -5]),
+            geom.Point2D([-7.3, -1.6]),
+        ]
+    )
 
     if search.closest_neighbor(geom.Point2D([0, 0])) != 0:
         raise ValueError("[Test] Error in closest neighbor")
@@ -52,6 +59,6 @@
     p3 = geom.Point3D([3.1, 9.4, 9.7])
     colocator = geom.NNSearch3D([p0, p0, p1, p0, p2, p1, p3])
 
-    colocated_info = colocator.colocated_index_mapping(basic.GLOBAL_EPSILON)
+    colocated_info = colocator.radius_colocated_index_mapping(basic.GLOBAL_EPSILON)
     if colocated_info.nb_colocated_points() != 3:
         raise ValueError("[Test] Should be 3 colocated points")

include/geode/geometry/frame.hpp

@@ -52,6 +52,10 @@ namespace geode
 
         [[nodiscard]] std::string string() const;
 
+        [[nodiscard]] local_index_t max_elongation_direction() const;
+
+        [[nodiscard]] local_index_t min_elongation_direction() const;
+
     private:
         friend class bitsery::Access;
         template < typename Archive >

include/geode/geometry/nn_search.hpp

@@ -26,11 +26,14 @@
 #include <geode/basic/mapping.hpp>
 #include <geode/basic/pimpl.hpp>
 
+#include <geode/geometry/basic_objects/ellipse.hpp>
 #include <geode/geometry/common.hpp>
 #include <geode/geometry/point.hpp>
 
 namespace geode
 {
+    FORWARD_DECLARATION_DIMENSION_CLASS( Frame );
+
     /*!
      * Given a list of points, this class returns neighboring points.
      */
@@ -108,7 +111,18 @@ namespace geode
             const Point< dimension >& point, double threshold_distance ) const;
 
         /*!
-         * Get a number ol close neighbors from the given point
+         * Get the neighbors within an ellipse described by its frame, centered
+         * on the given point
+         * @param[in] point The center of the ellipse
+         * @param[in] epsilons_frame The frame describing the ellipse
+         * @return the list of points inside this distance
+         */
+        [[nodiscard]] std::vector< index_t > frame_neighbors(
+            const Point< dimension >& point,
+            const Frame< dimension >& epsilons_frame ) const;
+
+        /*!
+         * Get a number of close neighbors from the given point
          * @param[in] point The requested point
          * @param[in] nb_neighbors The number of neighbors to return
          * @return the list of points, it can be smaller than the requested
@@ -127,6 +141,9 @@ namespace geode
         [[nodiscard]] ColocatedInfo colocated_index_mapping(
             double epsilon ) const;
 
+        [[nodiscard]] ColocatedInfo colocated_index_mapping(
+            const Frame< dimension >& epsilon ) const;
+
     private:
         IMPLEMENTATION_MEMBER( impl_ );
     };

include/geode/mesh/helpers/detail/curve_merger.hpp

@@ -62,12 +62,15 @@ namespace geode
             using EdgeOrigins = absl::InlinedVector< EdgeOrigin, 1 >;
 
             EdgedCurveMerger( absl::Span< const std::reference_wrapper<
-                                  const EdgedCurve< dimension > > > curves,
-                double epsilon );
+                    const EdgedCurve< dimension > > > curves );
             EdgedCurveMerger( EdgedCurveMerger&& ) noexcept;
             ~EdgedCurveMerger();
 
-            [[nodiscard]] std::unique_ptr< EdgedCurve< dimension > > merge();
+            [[nodiscard]] std::unique_ptr< EdgedCurve< dimension > > merge(
+                double epsilon );
+
+            [[nodiscard]] std::unique_ptr< EdgedCurve< dimension > > merge(
+                const Frame< dimension >& epsilons_frame );
 
             [[nodiscard]] index_t edge_in_merged(
                 index_t curve, index_t edge ) const;

include/geode/mesh/helpers/detail/point_set_merger.hpp

@@ -42,12 +42,15 @@ namespace geode
         {
         public:
             PointSetMerger( absl::Span< const std::reference_wrapper<
-                                const PointSet< dimension > > > pointsets,
-                double epsilon );
+                    const PointSet< dimension > > > pointsets );
             PointSetMerger( PointSetMerger&& ) noexcept;
             ~PointSetMerger();
 
-            [[nodiscard]] std::unique_ptr< PointSet< dimension > > merge();
+            [[nodiscard]] std::unique_ptr< PointSet< dimension > > merge(
+                double epsilon );
+
+            [[nodiscard]] std::unique_ptr< PointSet< dimension > > merge(
+                const Frame< dimension >& frame );
         };
         ALIAS_2D_AND_3D( PointSetMerger );
     } // namespace detail

include/geode/mesh/helpers/detail/solid_merger.hpp

@@ -31,6 +31,8 @@
 #include <geode/mesh/common.hpp>
 #include <geode/mesh/helpers/detail/vertex_merger.hpp>
 
+#include <geode/geometry/frame.hpp>
+
 namespace geode
 {
     FORWARD_DECLARATION_DIMENSION_CLASS( SolidMesh );
@@ -65,12 +67,15 @@ namespace geode
                 absl::InlinedVector< PolyhedronOrigin, 1 >;
 
             SolidMeshMerger( absl::Span< const std::reference_wrapper<
-                                 const SolidMesh< dimension > > > solids,
-                double epsilon );
+                    const SolidMesh< dimension > > > solids );
             SolidMeshMerger( SolidMeshMerger&& ) noexcept;
             ~SolidMeshMerger();
 
-            [[nodiscard]] std::unique_ptr< SolidMesh< dimension > > merge();
+            [[nodiscard]] std::unique_ptr< SolidMesh< dimension > > merge(
+                double epsilon );
+
+            [[nodiscard]] std::unique_ptr< SolidMesh< dimension > > merge(
+                const Frame< dimension >& epsilons_frame );
 
             [[nodiscard]] index_t polyhedron_in_merged(
                 index_t solid, index_t polyhedron ) const;

include/geode/mesh/helpers/detail/surface_merger.hpp

@@ -64,12 +64,15 @@ namespace geode
             using PolygonOrigins = absl::InlinedVector< PolygonOrigin, 1 >;
 
             SurfaceMeshMerger( absl::Span< const std::reference_wrapper<
-                                   const SurfaceMesh< dimension > > > surfaces,
-                double epsilon );
+                    const SurfaceMesh< dimension > > > surfaces );
             SurfaceMeshMerger( SurfaceMeshMerger&& ) noexcept;
             ~SurfaceMeshMerger();
 
-            [[nodiscard]] std::unique_ptr< SurfaceMesh< dimension > > merge();
+            [[nodiscard]] std::unique_ptr< SurfaceMesh< dimension > > merge(
+                double epsilon );
+
+            [[nodiscard]] std::unique_ptr< SurfaceMesh< dimension > > merge(
+                const Frame< dimension >& epsilons_frame );
 
             [[nodiscard]] index_t polygon_in_merged(
                 index_t surface, index_t polygon ) const;

include/geode/mesh/helpers/detail/vertex_merger.hpp

@@ -28,6 +28,8 @@
 
 #include <geode/basic/pimpl.hpp>
 
+#include <geode/geometry/frame.hpp>
+
 namespace geode
 {
     namespace detail
@@ -58,8 +60,9 @@ namespace geode
 
         protected:
             VertexMerger(
-                absl::Span< const std::reference_wrapper< const Mesh > > meshes,
-                double epsilon );
+                absl::Span< const std::reference_wrapper< const Mesh > >
+                    meshes );
+
             VertexMerger( VertexMerger&& ) noexcept;
             ~VertexMerger();
 
@@ -73,7 +76,9 @@ namespace geode
 
             [[nodiscard]] Builder& builder();
 
-            void create_points();
+            void create_points( double epsilon );
+
+            void create_points( const Frame< Mesh::dim >& epsilons_frame );
 
         private:
             IMPLEMENTATION_MEMBER( impl_ );

src/geode/geometry/frame.cpp

@@ -27,6 +27,8 @@
 
 #include <geode/geometry/vector.hpp>
 
+#include <absl/algorithm/container.h>
+
 namespace
 {
     template < geode::index_t dimension >
@@ -174,6 +176,18 @@ namespace geode
         return output;
     }
 
+    template < index_t dimension >
+    local_index_t Frame< dimension >::max_elongation_direction() const
+    {
+        return std::distance( frame_.begin(), absl::c_max_element( frame_ ) );
+    }
+
+    template < index_t dimension >
+    local_index_t Frame< dimension >::min_elongation_direction() const
+    {
+        return std::distance( frame_.begin(), absl::c_min_element( frame_ ) );
+    }
+
     template < index_t dimension >
     template < typename Archive >
     void Frame< dimension >::serialize( Archive& archive )