Merge branch 'next' into feat/add-ellipse-basic-object-ditance-and-intersection

Author: BenPinet

bindings/python/src/mesh/core/light_regular_grid.cpp

@@ -30,25 +30,39 @@
 
 #include <geode/mesh/core/light_regular_grid.hpp>
 
-#define PYTHON_LIGHT_REGULAR_GRID( dimension )                                 \
-    const auto name##dimension =                                               \
-        "LightRegularGrid" + std::to_string( dimension ) + "D";                \
-    pybind11::class_< LightRegularGrid##dimension##D, Grid##dimension##D,      \
-        Identifier >( module, name##dimension.c_str() )                        \
-        .def( pybind11::init< Point< dimension >,                              \
-            std::array< index_t, dimension >,                                  \
-            std::array< double, dimension > >() )                              \
-        .def( pybind11::init< Point< dimension >,                              \
-            std::array< index_t, dimension >,                                  \
-            std::array< Vector< dimension >, dimension > >() )                 \
-        .def( "native_extension",                                              \
-            &LightRegularGrid##dimension##D::native_extension )
+namespace
+{
+    template < geode::index_t dimension >
+    void define_python_light_regular_grid( pybind11::module& module )
+    {
+        const auto class_name =
+            absl::StrCat( "LightRegularGrid", dimension, "D" );
+        pybind11::class_< geode::LightRegularGrid< dimension >,
+            geode::Grid< dimension >, geode::Identifier >(
+            module, class_name.c_str() )
+            .def( pybind11::init< geode::Point< dimension >,
+                std::array< geode::index_t, dimension >,
+                std::array< double, dimension > >() )
+            .def( pybind11::init< geode::Point< dimension >,
+                std::array< geode::index_t, dimension >,
+                std::array< geode::Vector< dimension >, dimension > >() )
+            .def( "vertex_attribute_manager",
+                &geode::Grid< dimension >::grid_vertex_attribute_manager,
+                pybind11::return_value_policy::reference )
+            .def( dimension == 2 ? "polygon_attribute_manager"
+                                 : "polyhedron_attribute_manager",
+                &geode::Grid< dimension >::cell_attribute_manager,
+                pybind11::return_value_policy::reference )
+            .def( "native_extension",
+                &geode::LightRegularGrid< dimension >::native_extension );
+    }
+} // namespace
 
 namespace geode
 {
     void define_light_regular_grid( pybind11::module& module )
     {
-        PYTHON_LIGHT_REGULAR_GRID( 2 );
-        PYTHON_LIGHT_REGULAR_GRID( 3 );
+        define_python_light_regular_grid< 2 >( module );
+        define_python_light_regular_grid< 3 >( module );
     }
 } // namespace geode

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

@@ -55,10 +55,3 @@
     colocated_info = colocator.colocated_index_mapping(basic.GLOBAL_EPSILON)
     if colocated_info.nb_colocated_points() != 3:
         raise ValueError("[Test] Should be 3 colocated points")
-    mapping_answer = [0, 0, 1, 0, 2, 1, 3]
-    if colocated_info.colocated_mapping != mapping_answer:
-        raise ValueError("[Test] Error in colocated mapping")
-    points_answer = [p0, p1, p2, p3]
-    for p in range(4):
-        if colocated_info.unique_points[p] != points_answer[p]:
-            raise ValueError("[Test] Error in unique points")

bindings/python/tests/mesh/test-py-light-regular-grid.py

@@ -240,15 +240,44 @@ def test_closest_vertex( grid ):
     if result != answer:
         raise ValueError( "[Test] Wrong result for closest vertex for query p4" )
 
-def test_attribute( grid ):
+def test_attribute_3d( grid ):
     attribute = grid.cell_attribute_manager().find_or_create_attribute_variable_double( "toto", -1 )
     attribute.set_value( 10, 10 )
+    attribute = grid.polyhedron_attribute_manager().find_attribute_double( "toto" )
     if attribute.value( 0 ) != -1:
         raise ValueError( "[Test] Wrong attribute value" )
     if attribute.value( 10 ) != 10:
         raise ValueError( "[Test] Wrong attribute value" )
     if attribute.value( grid.nb_cells() - 1 ) != -1:
         raise ValueError( "[Test] Wrong attribute value" )
+    attribute = grid.vertex_attribute_manager().find_or_create_attribute_variable_double( "toto_vertex", 1 )
+    attribute.set_value( 10, 10 )
+    if attribute.value( 0 ) != 1:
+        raise ValueError( "[Test] Wrong attribute value" )
+    if attribute.value( 10 ) != 10:
+        raise ValueError( "[Test] Wrong attribute value" )
+    if attribute.value( grid.nb_cells() - 1 ) != 1:
+        raise ValueError( "[Test] Wrong attribute value" )
+
+def test_attribute_2d():
+    grid = mesh.LightRegularGrid2D(geom.Point2D([1.5, 0]), [5, 10], [1., 2.])
+    attribute = grid.cell_attribute_manager().find_or_create_attribute_variable_double( "toto", -1 )
+    attribute.set_value( 10, 10 )
+    attribute = grid.polygon_attribute_manager().find_attribute_double( "toto" )
+    if attribute.value( 0 ) != -1:
+        raise ValueError( "[Test] Wrong attribute value" )
+    if attribute.value( 10 ) != 10:
+        raise ValueError( "[Test] Wrong attribute value" )
+    if attribute.value( grid.nb_cells() - 1 ) != -1:
+        raise ValueError( "[Test] Wrong attribute value" )
+    attribute = grid.vertex_attribute_manager().find_or_create_attribute_variable_double( "toto_vertex", 1 )
+    attribute.set_value( 10, 10 )
+    if attribute.value( 0 ) != 1:
+        raise ValueError( "[Test] Wrong attribute value" )
+    if attribute.value( 10 ) != 10:
+        raise ValueError( "[Test] Wrong attribute value" )
+    if attribute.value( grid.nb_cells() - 1 ) != 1:
+        raise ValueError( "[Test] Wrong attribute value" )
 
 def test_io(grid, filename):
     mesh.save_light_regular_grid3D(grid, filename)
@@ -266,5 +295,6 @@ def test_io(grid, filename):
     test_cell_query( grid )
     test_boundary_box( grid )
     test_closest_vertex( grid )
-    test_attribute( grid )
+    test_attribute_3d( grid )
+    test_attribute_2d()
     test_io(grid, "test." + grid.native_extension())

include/geode/basic/attribute_manager.hpp

@@ -79,10 +79,11 @@ namespace geode
                 std::dynamic_pointer_cast< ReadOnlyAttribute< T > >(
                     find_attribute_base( name ) );
             OPENGEODE_EXCEPTION( attribute.get(),
-                "[AttributeManager::find_attribute] You have to create an "
-                "attribute before using it. "
-                "See find_or_create_attribute method and "
-                "derived classes of ReadOnlyAttribute." );
+                "[AttributeManager::find_attribute] Could not find attribute '",
+                name,
+                "'. You have to create an attribute before using it. See "
+                "find_or_create_attribute method and derived classes of "
+                "ReadOnlyAttribute." );
             return attribute;
         }
 

include/geode/basic/chronometer.hpp

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2019 - 2025 Geode-solutions
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#pragma once
+
+#include <absl/time/time.h>
+
+#include <geode/basic/common.hpp>
+#include <geode/basic/pimpl.hpp>
+
+namespace geode
+{
+    class opengeode_basic_api Chronometer
+    {
+    public:
+        Chronometer();
+        Chronometer( Chronometer&& other ) noexcept;
+        ~Chronometer();
+
+        void start();
+
+        void stop();
+
+        [[nodiscard]] absl::Duration raw_duration() const;
+
+        [[nodiscard]] std::string duration() const;
+
+        void reset();
+
+    private:
+        IMPLEMENTATION_MEMBER( impl_ );
+    };
+} // namespace geode

include/geode/basic/mapping.hpp

@@ -36,8 +36,6 @@ namespace geode
         class StorageType >
     class MappingBase
     {
-        OPENGEODE_DISABLE_COPY( MappingBase );
-
     public:
         template < typename T >
         using Storage = typename StorageType< T >::Type;
@@ -88,8 +86,10 @@ namespace geode
 
     protected:
         MappingBase() = default;
-        MappingBase( MappingBase&& other ) = default;
-        MappingBase& operator=( MappingBase&& other ) = default;
+        MappingBase( const MappingBase& ) = default;
+        MappingBase& operator=( const MappingBase& ) = default;
+        MappingBase( MappingBase&& ) noexcept = default;
+        MappingBase& operator=( MappingBase&& ) noexcept = default;
 
         [[nodiscard]] index_t size_input() const
         {
@@ -127,8 +127,10 @@ namespace geode
     {
     public:
         BijectiveMapping() = default;
-        BijectiveMapping( BijectiveMapping&& other ) = default;
-        BijectiveMapping& operator=( BijectiveMapping&& other ) = default;
+        BijectiveMapping( const BijectiveMapping& ) = default;
+        BijectiveMapping& operator=( const BijectiveMapping& ) = default;
+        BijectiveMapping( BijectiveMapping&& ) noexcept = default;
+        BijectiveMapping& operator=( BijectiveMapping&& ) noexcept = default;
 
         void map( const T1& in, const T2& out )
         {
@@ -189,8 +191,10 @@ namespace geode
     {
     public:
         GenericMapping() = default;
-        GenericMapping( GenericMapping&& other ) = default;
-        GenericMapping& operator=( GenericMapping&& other ) = default;
+        GenericMapping( const GenericMapping& ) = default;
+        GenericMapping& operator=( const GenericMapping& ) = default;
+        GenericMapping( GenericMapping&& ) noexcept = default;
+        GenericMapping& operator=( GenericMapping&& ) noexcept = default;
 
         void map( const T1& in, const T2& out )
         {

include/geode/basic/small_set.hpp

@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2019 - 2025 Geode-solutions
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#pragma once
+
+#include <absl/algorithm/container.h>
+#include <absl/container/inlined_vector.h>
+
+#include <geode/basic/common.hpp>
+#include <geode/basic/range.hpp>
+
+namespace geode
+{
+    template < typename Type, index_t capacity = 10 >
+    class SmallSet
+    {
+    public:
+        auto size() const
+        {
+            return container_.size();
+        }
+
+        auto empty() const
+        {
+            return container_.empty();
+        }
+
+        auto begin() const
+        {
+            return container_.begin();
+        }
+
+        auto end() const
+        {
+            return container_.end();
+        }
+
+        auto insert( const Type& element )
+        {
+            if( absl::c_contains( container_, element ) )
+            {
+                return false;
+            }
+            container_.push_back( element );
+            return true;
+        }
+
+    private:
+        absl::InlinedVector< Type, capacity > container_;
+    };
+} // namespace geode

include/geode/geometry/distance.hpp

@@ -23,6 +23,8 @@
 
 #pragma once
 
+#include <optional>
+
 #include <geode/geometry/common.hpp>
 
 namespace geode

include/geode/geometry/quality.hpp

@@ -36,4 +36,7 @@ namespace geode
         const Tetrahedron& tetra );
     [[nodiscard]] double opengeode_geometry_api
         tetrahedron_volume_to_edge_ratio( const Tetrahedron& tetra );
+
+    [[nodiscard]] double opengeode_geometry_api
+        tetrahedron_collapse_aspect_ratio( const Tetrahedron& tetra );
 } // namespace geode

include/geode/mesh/builder/edged_curve_builder.hpp

@@ -46,6 +46,8 @@ namespace geode
     public:
         static constexpr auto dim = dimension;
 
+        EdgedCurveBuilder( EdgedCurveBuilder&& ) noexcept = default;
+
         /*!
          * Create the builder associated with an EdgedCurve.
          * @param[in] mesh The EdgedCurve to build/modify