fix(SurfaceMeshInspection): Inspector to compute negative polygons wa…

include/geode/inspector/criterion/negative_elements/surface_negative_elements.hpp

@@ -39,10 +39,9 @@
      * Class for inspecting the negative elements of a SurfaceMesh
      */
     template < index_t dimension >
     class opengeode_inspector_inspector_api SurfaceMeshNegativeElements
     {
         OPENGEODE_DISABLE_COPY( SurfaceMeshNegativeElements );
-        OPENGEODE_TEMPLATE_ASSERT_2D( dimension );
 
     public:
         explicit SurfaceMeshNegativeElements(

include/geode/inspector/surface_inspector.hpp

@@ -30,6 +30,7 @@
 #include <geode/inspector/criterion/intersections/surface_intersections.hpp>
 #include <geode/inspector/criterion/manifold/surface_edge_manifold.hpp>
 #include <geode/inspector/criterion/manifold/surface_vertex_manifold.hpp>
+#include <geode/inspector/criterion/negative_elements/surface_negative_elements.hpp>
 #include <geode/inspector/mixin/add_inspectors.hpp>
 
 namespace geode
@@ -57,6 +58,9 @@
         InspectionIssues< std::pair< index_t, index_t > > intersecting_elements{
             "Intersection between mesh elements not tested"
         };
+        InspectionIssues< index_t > negative_polygons{
+            "Negative polygons not tested"
+        };
 
         [[nodiscard]] index_t nb_issues() const;
 
@@ -71,20 +75,23 @@
      * @extends SurfaceMeshDegeneration
      * @extends SurfaceMeshEdgeManifold
      * @extends SurfaceMeshVertexManifold
+     * @extends SurfaceMeshIntersections
+     * @extends SurfaceMeshNegativeElements
      */
     template < index_t dimension >
     class SurfaceMeshInspector : public AddInspectors< SurfaceMesh< dimension >,
                                      SurfaceMeshAdjacency< dimension >,
                                      SurfaceMeshColocation< dimension >,
                                      SurfaceMeshDegeneration< dimension >,
                                      SurfaceMeshEdgeManifold< dimension >,
                                      SurfaceMeshVertexManifold< dimension >,
-                                     SurfaceMeshIntersections< dimension > >
+                                     SurfaceMeshIntersections< dimension >,
+                                     SurfaceMeshNegativeElements< dimension > >
     {
         OPENGEODE_DISABLE_COPY( SurfaceMeshInspector );
 
     public:
         SurfaceMeshInspector( const SurfaceMesh< dimension >& mesh );
 
         virtual ~SurfaceMeshInspector() = default;
 

src/geode/inspector/criterion/negative_elements/surface_negative_elements.cpp

@@ -40,43 +40,44 @@
     class SurfaceMeshNegativeElements< dimension >::Impl
     {
     public:
         Impl( const SurfaceMesh< dimension >& mesh ) : mesh_( mesh ) {}
 
         bool mesh_has_negative_elements() const
         {
-            for( const auto polygon_id : Range{ mesh_.nb_polygons() } )
+            if constexpr( dimension == 2 )
             {
-                if( polygon_has_negative_area( polygon_id ) )
+                for( const auto polygon_id : Range{ mesh_.nb_polygons() } )
                 {
-                    return true;
+                    if( polygon_area_sign( mesh_.polygon( polygon_id ) )
+                        == Sign::negative )
+                    {
+                        return true;
+                    }
                 }
             }
             return false;
         }
 
         InspectionIssues< index_t > negative_polygons() const
         {
             InspectionIssues< index_t > wrong_polygons{
                 "negative area polygons"
             };
-            for( const auto polygon_id : Range{ mesh_.nb_polygons() } )
+            if constexpr( dimension == 2 )
             {
-                if( polygon_has_negative_area( polygon_id ) )
+                for( const auto polygon_id : Range{ mesh_.nb_polygons() } )
                 {
-                    wrong_polygons.add_issue( polygon_id,
-                        absl::StrCat( "negative polygon ", polygon_id ) );
+                    if( polygon_area_sign( mesh_.polygon( polygon_id ) )
+                        == Sign::negative )
+                    {
+                        wrong_polygons.add_issue( polygon_id,
+                            absl::StrCat( "negative polygon ", polygon_id ) );
+                    }
                 }
             }
             return wrong_polygons;
         }
 
-    private:
-        bool polygon_has_negative_area( index_t polygon_id ) const
-        {
-            return polygon_area_sign( mesh_.polygon( polygon_id ) )
-                   == Sign::negative;
-        }
-
     private:
         const SurfaceMesh< dimension >& mesh_;
     };
@@ -108,4 +109,6 @@
 
     template class opengeode_inspector_inspector_api
         SurfaceMeshNegativeElements< 2 >;
+    template class opengeode_inspector_inspector_api
+        SurfaceMeshNegativeElements< 3 >;
 } // namespace geode

src/geode/inspector/surface_inspector.cpp

@@ -37,15 +37,17 @@ namespace geode
                + degenerated_polygons.nb_issues()
                + non_manifold_edges.nb_issues()
                + non_manifold_vertices.nb_issues()
-               + intersecting_elements.nb_issues();
+               + intersecting_elements.nb_issues()
+               + negative_polygons.nb_issues();
     }
 
     std::string SurfaceInspectionResult::string() const
     {
         return absl::StrCat( polygon_edges_with_wrong_adjacency.string(),
             colocated_points_groups.string(), degenerated_edges.string(),
             degenerated_polygons.string(), non_manifold_edges.string(),
-            non_manifold_vertices.string(), intersecting_elements.string() );
+            non_manifold_vertices.string(), intersecting_elements.string(),
+            negative_polygons.string() );
     }
 
     std::string SurfaceInspectionResult::inspection_type() const
@@ -62,7 +64,8 @@ namespace geode
               SurfaceMeshDegeneration< dimension >,
               SurfaceMeshEdgeManifold< dimension >,
               SurfaceMeshVertexManifold< dimension >,
-              SurfaceMeshIntersections< dimension > >{ mesh }
+              SurfaceMeshIntersections< dimension >,
+              SurfaceMeshNegativeElements< dimension > >{ mesh }
     {
     }
 
@@ -94,6 +97,9 @@ namespace geode
             },
             [&result, this] {
                 result.intersecting_elements = this->intersecting_elements();
+            },
+            [&result, this] {
+                result.negative_polygons = this->negative_polygons();
             } );
         return result;
     }