Merge branch 'next' into fix/segmentation

Author: panquez

include/geode/geometry/sign.hpp

@@ -28,7 +28,9 @@
 namespace geode
 {
     FORWARD_DECLARATION_DIMENSION_CLASS( Triangle );
+    FORWARD_DECLARATION_DIMENSION_CLASS( Polygon );
     ALIAS_2D_AND_3D( Triangle );
+    ALIAS_2D( Polygon );
     class Tetrahedron;
     enum struct SIDE;
     using Sign = SIDE;
@@ -48,6 +50,9 @@ namespace geode
     [[nodiscard]] Sign opengeode_geometry_api triangle_area_sign(
         const Triangle2D& triangle );
 
+    [[nodiscard]] Sign opengeode_geometry_api polygon_area_sign(
+        const Polygon2D& polygon );
+
     /*!
      * Return the sign of a 3D triangle area aligned on X- Y- or Z-axis.
      */

include/geode/mesh/helpers/ray_tracing.hpp

@@ -35,12 +35,63 @@
 
 namespace geode
 {
+    FORWARD_DECLARATION_DIMENSION_CLASS( EdgedCurve );
     FORWARD_DECLARATION_DIMENSION_CLASS( SurfaceMesh );
+    ALIAS_2D( EdgedCurve );
     ALIAS_3D( SurfaceMesh );
 } // namespace geode
 
 namespace geode
 {
+    class opengeode_mesh_api RayTracing2D
+    {
+    public:
+        struct EdgeDistance
+        {
+            EdgeDistance() = default;
+
+            EdgeDistance( index_t edge_in,
+                double distance_in,
+                POSITION position_in,
+                Point2D point_in )
+                : edge{ edge_in },
+                  distance{ distance_in },
+                  position{ position_in },
+                  point{ std::move( point_in ) }
+            {
+            }
+
+            [[nodiscard]] bool operator<( const EdgeDistance& other ) const
+            {
+                return std::fabs( distance ) < std::fabs( other.distance );
+            }
+
+            index_t edge{ NO_ID };
+            double distance{ 0 };
+            POSITION position{ POSITION::outside };
+            Point2D point;
+        };
+
+    public:
+        RayTracing2D( const EdgedCurve2D& mesh, const Ray2D& ray );
+        RayTracing2D(
+            const EdgedCurve2D& mesh, const InfiniteLine2D& infinite_line );
+        RayTracing2D( RayTracing2D&& other ) noexcept;
+        ~RayTracing2D();
+
+        [[nodiscard]] std::optional< EdgeDistance > closest_edge() const;
+
+        [[nodiscard]] std::optional< absl::FixedArray< EdgeDistance > >
+            closest_edges( index_t nb_closest_wanted ) const;
+
+        [[nodiscard]] std::vector< EdgeDistance > all_intersections() const;
+
+        [[nodiscard]] bool operator()( index_t edge_id );
+
+    private:
+        IMPLEMENTATION_MEMBER( impl_ );
+    };
+
     class opengeode_mesh_api RayTracing3D
     {
     public:
@@ -80,7 +131,7 @@ namespace geode
         [[nodiscard]] std::optional< PolygonDistance > closest_polygon() const;
 
         [[nodiscard]] std::optional< absl::FixedArray< PolygonDistance > >
-            closest_polygons( index_t size ) const;
+            closest_polygons( index_t nb_closest_wanted ) const;
 
         [[nodiscard]] std::vector< PolygonDistance > all_intersections() const;
 

include/geode/model/helpers/ray_tracing.hpp

@@ -32,10 +32,11 @@
 namespace geode
 {
     FORWARD_DECLARATION_DIMENSION_CLASS( Block );
-    ALIAS_3D( Block );
     FORWARD_DECLARATION_DIMENSION_CLASS( Surface );
-    ALIAS_3D( Surface );
+    ALIAS_3D( Block );
+    ALIAS_2D( Surface );
     class BRep;
+    class Section;
     struct uuid;
 } // namespace geode
 
@@ -57,4 +58,12 @@ namespace geode
 
     [[nodiscard]] std::optional< uuid > opengeode_model_api
         block_containing_point( const BRep& brep, const Point3D& point );
+
+    bool opengeode_model_api is_point_inside_surface( const Section& section,
+        const Surface2D& surface,
+        const Point2D& point );
+
+    [[nodiscard]] std::optional< uuid >
+        opengeode_model_api surface_containing_point(
+            const Section& section, const Point2D& point );
 } // namespace geode

src/geode/geometry/sign.cpp

@@ -23,6 +23,7 @@
 
 #include <geode/geometry/sign.hpp>
 
+#include <geode/geometry/basic_objects/polygon.hpp>
 #include <geode/geometry/basic_objects/tetrahedron.hpp>
 #include <geode/geometry/basic_objects/triangle.hpp>
 #include <geode/geometry/internal/position_from_sides.hpp>
@@ -53,6 +54,24 @@ namespace geode
             GEO::PCK::orient_2d( vertices[0], vertices[1], vertices[2] ) );
     }
 
+    Sign polygon_area_sign( const Polygon2D& polygon )
+    {
+        const auto& polygon_vertices = polygon.vertices();
+        const auto& p1 = polygon_vertices[0];
+        for( const auto other_index : LRange{ 1, polygon_vertices.size() - 1 } )
+        {
+            const auto& p2 = polygon_vertices[other_index];
+            const auto& p3 = polygon_vertices[static_cast< local_index_t >(
+                other_index + 1 )];
+            const auto sign = triangle_area_sign( { p1, p2, p3 } );
+            if( sign != Sign::zero )
+            {
+                return sign;
+            }
+        }
+        return geode::Sign::zero;
+    }
+
     Sign triangle_area_sign( const Triangle3D& triangle, local_index_t axis )
     {
         const auto axis1 = new_axis[axis][0];