fix(Geometry): robustness to degenerated primitives from in-dev stitching models

src/geode/geometry/intersection_detection.cpp

@@ -88,7 +88,7 @@
             if( length2 > max_length2 )
             {
                 max_length2 = length2;
                 normal = std::move( candidate );
             }
         }
         if( max_length2 > 0 )
@@ -106,14 +106,19 @@
             return max_abs_axis( normal.value() );
         }
         const auto& vertices = triangle.vertices();
+        const auto& segment_vertices = segment.vertices();
+        const geode::Vector3D segment_direction{ segment_vertices[0],
+            segment_vertices[1] };
         const auto longest_edge = triangle.longest_edge_index();
+        if( longest_edge == geode::NO_LID )
+        {
+            return coplanar_projection_axis(
+                segment_vertices[0], segment_direction, { vertices[0] } );
+        }
         const geode::Point3D& origin = vertices[longest_edge];
         const geode::Point3D& next =
             vertices[longest_edge == 2 ? 0 : longest_edge + 1];
         const geode::Vector3D direction{ origin, next };
-        const auto& segment_vertices = segment.vertices();
-        const geode::Vector3D segment_direction{ segment_vertices[0],
-            segment_vertices[1] };
         if( segment_direction.length2() > direction.length2() )
         {
             return coplanar_projection_axis( segment_vertices[0],
@@ -124,7 +129,7 @@
                 segment_vertices[1] } );
     }
 
     geode::SegmentSegmentIntersection segment_segment_intersection_detection2D(
         const geode::Segment2D& segment0, const geode::Segment2D& segment1 )
     {
         const auto s0_p0_side =
@@ -180,7 +185,7 @@
     }
 
     geode::SegmentTriangleIntersection
         segment_triangle_plane_intersection_detection(
             const geode::Segment3D& segment, const geode::Triangle3D& triangle )
     {
         const auto projection_axis = best_projection_axis( triangle, segment );
@@ -243,7 +248,7 @@
         return result;
     }
 
     geode::SegmentSegmentIntersection segment_segment_intersection_detection3D(
         const geode::Segment3D& segment0, const geode::Segment3D& segment1 )
     {
         if( geode::tetrahedron_volume_sign( geode::Tetrahedron{
@@ -312,7 +317,7 @@
         return segment_segment_intersection_detection3D( segment0, segment1 );
     }
 
     SegmentSegmentIntersection colinear_segment_segment_intersection_detection(
         const Segment2D& segment0, const Segment2D& segment1 )
     {
         OpenGeodeGeometryException::check_assertion(

src/geode/geometry/radial_sort.cpp

@@ -55,7 +55,7 @@
         }
 
     private:
         void recursive_sort( absl::FixedArray< geode::index_t >& result,
             geode::index_t begin,
             geode::index_t end )
         {
@@ -70,7 +70,7 @@
             std::vector< geode::index_t > same;
             for( const auto i : geode::Range{ size - 1 } )
             {
                 const auto id = begin + i + 1;
                 const auto side = geode::point_side_to_triangle(
                     points_[result[id]], { segment_.vertices()[0].get(),
                                              segment_.vertices()[1].get(),
@@ -107,7 +107,7 @@
                     }
                 }
             }
             for( const auto id : same )
             {
                 sorted[left_id++] = id;
             }
@@ -115,7 +115,7 @@
                 left_id == right_id, "[RadialSort::recursive_sort] left and "
                                      "right ids are different" );
             sorted[left_id] = result[begin];
             absl::c_copy( sorted, result.begin() + begin );
             const auto left_middle_id = begin + left_id - same.size();
             if( left_middle_id != begin )
             {
@@ -140,6 +140,12 @@
     absl::FixedArray< index_t > radial_sort(
         const Segment3D& segment, absl::Span< const Point3D > points )
     {
+        if( points.size() < 3 )
+        {
+            absl::FixedArray< index_t > identity( points.size() );
+            absl::c_iota( identity, 0 );
+            return identity;
+        }
         RadialSort radial_sort{ segment, points };
         return radial_sort.sort();
     }

tests/geometry/test-intersection-detection.cpp

@@ -224,6 +224,16 @@ void test_segment_degenerated_triangle_intersection_detection()
                 geode::POSITION::parallel, geode::POSITION::parallel ),
         "Wrong result for segment_triangle_intersection_detection with "
         "segment crossing a cap triangle in its plane" );
+
+    const geode::Triangle3D point_triangle{ c, c, c };
+    const auto far_from_point = geode::segment_triangle_intersection_detection(
+        geode::Segment3D{ d, e }, point_triangle );
+    geode::OpenGeodeGeometryException::test(
+        far_from_point
+            == std::make_pair(
+                geode::POSITION::outside, geode::POSITION::outside ),
+        "Wrong result for segment_triangle_intersection_detection with "
+        "triangle collapsed to a point far from the segment" );
 }
 
 void test_segment_line_intersection_detection()

tests/geometry/test-radial-sort.cpp

@@ -64,10 +64,23 @@ void test_2()
         sorted == answer, "Wrong radial sorting" );
 }
 
+void test_degenerated_segment()
+{
+    geode::Point3D s0{ { 0, 0, 1 } };
+    geode::Point3D a{ { 0, 0.5, 1.5 } };
+    geode::Point3D b{ { 0, 0, 0.5 } };
+
+    const auto sorted = geode::radial_sort( { s0, s0 }, { a, b } );
+    const absl::FixedArray< geode::index_t > answer{ 0, 1 };
+    geode::OpenGeodeGeometryException::test(
+        sorted == answer, "Wrong radial sorting on degenerated segment" );
+}
+
 void test()
 {
     test_1();
     test_2();
+    test_degenerated_segment();
 
     geode::Logger::info( "TEST SUCCESS" );
 }