adding distance_factor parameter

benoit2776 · benoit2776 · commit fc77b1939ce2 · 2025-03-11T14:32:10.000+01:00
diff --git a/bindings/python/src/geometry/nn_search.cpp b/bindings/python/src/geometry/nn_search.cpp
@@ -43,8 +43,8 @@
                 &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::* )(                                   \
+                const Frame##dimension##D&, const double ) const >(            \
                 &NNSearch##dimension##D::colocated_index_mapping ) );          \
                                                                                \
     const auto info##dimension =                                               \
diff --git a/include/geode/geometry/nn_search.hpp b/include/geode/geometry/nn_search.hpp
@@ -118,7 +118,8 @@ namespace geode
          */
         [[nodiscard]] std::vector< index_t > frame_neighbors(
             const Point< dimension >& point,
-            const Frame< dimension >& epsilons_frame ) const;
+            const Frame< dimension >& epsilons_frame,
+            const double factor_distance ) const;
 
         /*!
          * Get a number ol close neighbors from the given point
@@ -141,7 +142,8 @@ namespace geode
             const double epsilon ) const;
 
         [[nodiscard]] ColocatedInfo colocated_index_mapping(
-            const Frame< dimension >& epsilon ) const;
+            const Frame< dimension >& epsilon,
+            const double factor_distance ) const;
 
     private:
         IMPLEMENTATION_MEMBER( impl_ );
diff --git a/include/geode/mesh/helpers/detail/curve_merger.hpp b/include/geode/mesh/helpers/detail/curve_merger.hpp
@@ -71,7 +71,8 @@ namespace geode
                 double epsilon );
 
             [[nodiscard]] std::unique_ptr< EdgedCurve< dimension > > merge(
-                const Frame< dimension >& epsilons_frame );
+                const Frame< dimension >& epsilons_frame,
+                const double factor_distance );
 
             [[nodiscard]] index_t edge_in_merged(
                 index_t curve, index_t edge ) const;
diff --git a/include/geode/mesh/helpers/detail/solid_merger.hpp b/include/geode/mesh/helpers/detail/solid_merger.hpp
@@ -76,7 +76,8 @@ namespace geode
                 double epsilon );
 
             [[nodiscard]] std::unique_ptr< SolidMesh< dimension > > merge(
-                const Frame< dimension >& epsilons_frame );
+                const Frame< dimension >& epsilons_frame,
+                const double factor_distance );
 
             [[nodiscard]] index_t polyhedron_in_merged(
                 index_t solid, index_t polyhedron ) const;
diff --git a/include/geode/mesh/helpers/detail/surface_merger.hpp b/include/geode/mesh/helpers/detail/surface_merger.hpp
@@ -72,7 +72,8 @@ namespace geode
                 double epsilon );
 
             [[nodiscard]] std::unique_ptr< SurfaceMesh< dimension > > merge(
-                const Frame< dimension >& epsilons_frame );
+                const Frame< dimension >& epsilons_frame,
+                const double factor_distance );
 
             [[nodiscard]] index_t polygon_in_merged(
                 index_t surface, index_t polygon ) const;
diff --git a/include/geode/mesh/helpers/detail/vertex_merger.hpp b/include/geode/mesh/helpers/detail/vertex_merger.hpp
@@ -82,7 +82,8 @@ namespace geode
 
             void create_points( double epsilon );
 
-            void create_points( const Frame< dimension >& epsilons_frame );
+            void create_points( const Frame< dimension >& epsilons_frame,
+                const double factor_distance );
 
         private:
             IMPLEMENTATION_MEMBER( impl_ );
diff --git a/src/geode/geometry/nn_search.cpp b/src/geode/geometry/nn_search.cpp
@@ -79,7 +79,8 @@ namespace geode
         }
 
         std::vector< index_t > frame_neighbors( const Point< dimension >& point,
-            const Frame< dimension >& epsilons_frame ) const
+            const Frame< dimension >& epsilons_frame,
+            const double factor_distance ) const
         {
             std::vector< nanoflann::ResultItem< index_t, double > > results;
             nanoflann::SearchParameters params;
@@ -88,7 +89,8 @@ namespace geode
                 epsilons_frame.max_elongation_direction();
             const auto max_elongation =
                 epsilons_frame.direction( max_elongation_direction ).length();
-            const auto radius = max_elongation * max_elongation;
+            const auto radius = factor_distance * factor_distance
+                                * max_elongation * max_elongation;
             const auto nb_results = nn_tree_.radiusSearch(
                 &copy( point )[0], radius, results, params );
             std::vector< index_t > indices;
@@ -191,12 +193,14 @@ namespace geode
         typename geode::NNSearch< dimension >::ColocatedInfo
             colocated_index_mapping(
                 const geode::NNSearch< dimension >& nn_search,
-                const Frame< dimension >& epsilons_frame ) const
+                const Frame< dimension >& epsilons_frame,
+                const double factor_distance ) const
         {
             for( const auto d : LRange{ dimension } )
             {
                 OPENGEODE_EXCEPTION(
-                    epsilons_frame.direction( d ).length() >= GLOBAL_EPSILON,
+                    epsilons_frame.direction( d ).length() * factor_distance
+                        >= GLOBAL_EPSILON,
                     "[NNSearch::colocated_index_mapping] Given epsilon too "
                     "small, "
                     "should be bigger than GLOBAL_EPSILON (i.e. ",
@@ -207,14 +211,15 @@ namespace geode
             std::vector< index_t > mapping( nb_points, NO_ID );
             std::mutex mutex;
             async::parallel_for( async::irange( index_t{ 0 }, nb_points ),
-                [&nn_search, &epsilons_frame, &mapping, &mutex, this](
-                    index_t point_id ) {
+                [&nn_search, &epsilons_frame, &factor_distance, &mapping,
+                    &mutex, this]( index_t point_id ) {
                     if( mapping[point_id] != NO_ID )
                     {
                         return;
                     }
-                    const auto vertices_around = frame_neighbors(
-                        nn_search.point( point_id ), epsilons_frame );
+                    const auto vertices_around =
+                        frame_neighbors( nn_search.point( point_id ),
+                            epsilons_frame, factor_distance );
                     std::lock_guard< std::mutex > lock( mutex );
                     if( mapping[point_id] != NO_ID )
                     {
@@ -352,9 +357,10 @@ namespace geode
     template < index_t dimension >
     std::vector< index_t > NNSearch< dimension >::frame_neighbors(
         const Point< dimension >& point,
-        const Frame< dimension >& epsilons_frame ) const
+        const Frame< dimension >& epsilons_frame,
+        const double factor_distance ) const
     {
-        return impl_->frame_neighbors( point, epsilons_frame );
+        return impl_->frame_neighbors( point, epsilons_frame, factor_distance );
     }
 
     template < index_t dimension >
@@ -375,9 +381,11 @@ namespace geode
     template < geode::index_t dimension >
     typename geode::NNSearch< dimension >::ColocatedInfo
         NNSearch< dimension >::colocated_index_mapping(
-            const Frame< dimension >& epsilons_frame ) const
+            const Frame< dimension >& epsilons_frame,
+            const double factor_distance ) const
     {
-        return impl_->colocated_index_mapping( *this, epsilons_frame );
+        return impl_->colocated_index_mapping(
+            *this, epsilons_frame, factor_distance );
     }
 
     template class opengeode_geometry_api NNSearch< 2 >;
diff --git a/src/geode/mesh/helpers/detail/curve_merger.cpp b/src/geode/mesh/helpers/detail/curve_merger.cpp
@@ -71,9 +71,10 @@ namespace geode
 
             std::unique_ptr< EdgedCurve< dimension > > merge(
                 EdgedCurveMerger< dimension >& merger,
-                const Frame< dimension >& epsilons_frame )
+                const Frame< dimension >& epsilons_frame,
+                const double factor_distance )
             {
-                merger.create_points( epsilons_frame );
+                merger.create_points( epsilons_frame, factor_distance );
                 create_edges( merger );
                 clean_curve( merger );
                 curve_id_.clear();
@@ -218,9 +219,10 @@ namespace geode
         template < index_t dimension >
         std::unique_ptr< EdgedCurve< dimension > >
             EdgedCurveMerger< dimension >::merge(
-                const Frame< dimension >& epsilons_frame )
+                const Frame< dimension >& epsilons_frame,
+                const double factor_distance )
         {
-            return impl_->merge( *this, epsilons_frame );
+            return impl_->merge( *this, epsilons_frame, factor_distance );
         }
 
         template < index_t dimension >
diff --git a/src/geode/mesh/helpers/detail/solid_merger.cpp b/src/geode/mesh/helpers/detail/solid_merger.cpp
@@ -97,9 +97,10 @@ namespace geode
 
             std::unique_ptr< SolidMesh< dimension > > merge(
                 SolidMeshMerger< dimension >& merger,
-                const Frame3D& epsilons_frame )
+                const Frame3D& epsilons_frame,
+                const double factor_distance )
             {
-                merger.create_points( epsilons_frame );
+                merger.create_points( epsilons_frame, factor_distance );
                 create_polyhedra( merger );
                 create_adjacencies( merger );
                 clean_solid( merger );
@@ -350,9 +351,10 @@ namespace geode
         template < index_t dimension >
         std::unique_ptr< SolidMesh< dimension > >
             SolidMeshMerger< dimension >::merge(
-                const Frame< dimension >& epsilons_frame )
+                const Frame< dimension >& epsilons_frame,
+                const double factor_distance )
         {
-            return impl_->merge( *this, epsilons_frame );
+            return impl_->merge( *this, epsilons_frame, factor_distance );
         }
 
         template < index_t dimension >
diff --git a/src/geode/mesh/helpers/detail/surface_merger.cpp b/src/geode/mesh/helpers/detail/surface_merger.cpp
@@ -97,9 +97,10 @@ namespace geode
 
             std::unique_ptr< SurfaceMesh< dimension > > merge(
                 SurfaceMeshMerger< dimension >& merger,
-                const Frame< dimension >& epsilons_frame )
+                const Frame< dimension >& epsilons_frame,
+                const double factor_distance )
             {
-                merger.create_points( epsilons_frame );
+                merger.create_points( epsilons_frame, factor_distance );
                 create_polygons( merger );
                 create_adjacencies( merger );
                 clean_surface( merger );
@@ -332,9 +333,10 @@ namespace geode
         template < index_t dimension >
         std::unique_ptr< SurfaceMesh< dimension > >
             SurfaceMeshMerger< dimension >::merge(
-                const Frame< dimension >& epsilons_frame )
+                const Frame< dimension >& epsilons_frame,
+                const double factor_distance )
         {
-            return impl_->merge( *this, epsilons_frame );
+            return impl_->merge( *this, epsilons_frame, factor_distance );
         }
 
         template < index_t dimension >
diff --git a/src/geode/mesh/helpers/detail/vertex_merger.cpp b/src/geode/mesh/helpers/detail/vertex_merger.cpp
@@ -222,8 +222,7 @@ namespace geode
                 return *builder_;
             }
 
-            template < typename Epsilon >
-            void create_points( const Epsilon& epsilon )
+            void create_points( const double epsilon )
             {
                 auto info = create_colocated_index_mapping( epsilon );
                 vertices_ = std::move( info.colocated_mapping );
@@ -243,10 +242,30 @@ namespace geode
                 }
             }
 
+            void create_points( const Frame< dimension >& epsilon,
+                const double factor_distance )
+            {
+                auto info =
+                    create_colocated_index_mapping( epsilon, factor_distance );
+                vertices_ = std::move( info.colocated_mapping );
+                builder_->create_vertices( info.nb_unique_points() );
+                for( const auto p : Range{ info.nb_unique_points() } )
+                {
+                    builder_->set_point( p, info.unique_points[p] );
+                }
+                for( const auto m : Indices{ meshes_ } )
+                {
+                    const auto& mesh = meshes_[m].get();
+                    for( const auto v : Range{ mesh.nb_vertices() } )
+                    {
+                        vertices_origins_[vertex_in_merged( m, v )]
+                            .emplace_back( m, v );
+                    }
+                }
+            }
+
         private:
-            template < typename Epsilon >
-            ColocatedInfo create_colocated_index_mapping(
-                const Epsilon& epsilon )
+            ColocatedInfo create_colocated_index_mapping( const double epsilon )
             {
                 index_t nb_points{ 0 };
                 for( const auto& mesh : meshes_ )
@@ -266,6 +285,29 @@ namespace geode
                 return nnsearch.colocated_index_mapping( epsilon );
             }
 
+            ColocatedInfo create_colocated_index_mapping(
+                const Frame< dimension >& epsilon,
+                const double factor_distance )
+            {
+                index_t nb_points{ 0 };
+                for( const auto& mesh : meshes_ )
+                {
+                    nb_points += mesh.get().nb_vertices();
+                }
+                std::vector< Point< dimension > > points;
+                points.reserve( nb_points );
+                for( const auto& mesh : meshes_ )
+                {
+                    for( const auto v : Range{ mesh.get().nb_vertices() } )
+                    {
+                        points.emplace_back( mesh.get().point( v ) );
+                    }
+                }
+                NNSearch< dimension > nnsearch{ std::move( points ) };
+                return nnsearch.colocated_index_mapping(
+                    epsilon, factor_distance );
+            }
+
         private:
             absl::Span< const std::reference_wrapper< const Mesh > > meshes_;
             std::unique_ptr< Mesh > mesh_;
@@ -336,9 +378,10 @@ namespace geode
 
         template < typename Mesh, index_t dimension >
         void VertexMerger< Mesh, dimension >::create_points(
-            const Frame< dimension >& epsilons_frame )
+            const Frame< dimension >& epsilons_frame,
+            const double factor_distance )
         {
-            impl_->create_points( epsilons_frame );
+            impl_->create_points( epsilons_frame, factor_distance );
         }
 
         template class opengeode_mesh_api VertexMerger< PointSet2D, 2 >;
