fix(inspect_edgedcurve): Changed names towards inspect_edged_curve and inspect_point_set for homogenization.

MelchiorSchuh · MelchiorSchuh · commit a05b83866dfb · 2024-05-02T10:39:10.000+02:00
diff --git a/bindings/python/src/inspector/criterion/colocation/edgedcurve_colocation.h b/bindings/python/src/inspector/criterion/colocation/edgedcurve_colocation.h
@@ -31,7 +31,7 @@
 namespace geode
 {
     template < index_t dimension >
-    void do_define_edgedcurve_colocation( pybind11::module& module )
+    void do_define_edged_curve_colocation( pybind11::module& module )
     {
         using EdgedCurve = EdgedCurve< dimension >;
         using EdgedCurveColocation = EdgedCurveColocation< dimension >;
@@ -45,9 +45,9 @@ namespace geode
             .def( "colocated_points_groups",
                 &EdgedCurveColocation::colocated_points_groups );
     }
-    void define_edgedcurve_colocation( pybind11::module& module )
+    void define_edged_curve_colocation( pybind11::module& module )
     {
-        do_define_edgedcurve_colocation< 2 >( module );
-        do_define_edgedcurve_colocation< 3 >( module );
+        do_define_edged_curve_colocation< 2 >( module );
+        do_define_edged_curve_colocation< 3 >( module );
     }
 } // namespace geode
diff --git a/bindings/python/src/inspector/criterion/colocation/pointset_colocation.h b/bindings/python/src/inspector/criterion/colocation/pointset_colocation.h
@@ -29,7 +29,7 @@
 namespace geode
 {
     template < index_t dimension >
-    void do_define_pointset_colocation( pybind11::module& module )
+    void do_define_point_set_colocation( pybind11::module& module )
     {
         using PointSet = PointSet< dimension >;
         using PointSetColocation = PointSetColocation< dimension >;
@@ -41,9 +41,9 @@ namespace geode
             .def( "colocated_points_groups",
                 &PointSetColocation::colocated_points_groups );
     }
-    void define_pointset_colocation( pybind11::module& module )
+    void define_point_set_colocation( pybind11::module& module )
     {
-        do_define_pointset_colocation< 2 >( module );
-        do_define_pointset_colocation< 3 >( module );
+        do_define_point_set_colocation< 2 >( module );
+        do_define_point_set_colocation< 3 >( module );
     }
 } // namespace geode
diff --git a/bindings/python/src/inspector/criterion/degeneration/edgedcurve_degeneration.h b/bindings/python/src/inspector/criterion/degeneration/edgedcurve_degeneration.h
@@ -29,7 +29,7 @@
 namespace geode
 {
     template < index_t dimension >
-    void do_define_edgedcurve_degeneration( pybind11::module& module )
+    void do_define_edged_curve_degeneration( pybind11::module& module )
     {
         using EdgedCurve = EdgedCurve< dimension >;
         using EdgedCurveDegeneration = EdgedCurveDegeneration< dimension >;
@@ -42,9 +42,9 @@ namespace geode
             .def( "degenerated_edges",
                 &EdgedCurveDegeneration::degenerated_edges );
     }
-    void define_edgedcurve_degeneration( pybind11::module& module )
+    void define_edged_curve_degeneration( pybind11::module& module )
     {
-        do_define_edgedcurve_degeneration< 2 >( module );
-        do_define_edgedcurve_degeneration< 3 >( module );
+        do_define_edged_curve_degeneration< 2 >( module );
+        do_define_edged_curve_degeneration< 3 >( module );
     }
 } // namespace geode
diff --git a/bindings/python/src/inspector/edgedcurve_inspector.h b/bindings/python/src/inspector/edgedcurve_inspector.h
@@ -29,7 +29,7 @@
 namespace geode
 {
     template < index_t dimension >
-    void do_define_edgedcurve_inspector( pybind11::module& module )
+    void do_define_edged_curve_inspector( pybind11::module& module )
     {
         using EdgedCurve = EdgedCurve< dimension >;
         using EdgedCurveInspector = geode::EdgedCurveInspector< dimension >;
@@ -39,19 +39,19 @@ namespace geode
             EdgedCurveColocation< dimension >,
             EdgedCurveDegeneration< dimension > >( module, name.c_str() )
             .def( pybind11::init< const EdgedCurve& >() )
-            .def( "inspect_edgedcurve",
-                &EdgedCurveInspector::inspect_edgedcurve );
+            .def( "inspect_edged_curve",
+                &EdgedCurveInspector::inspect_edged_curve );
 
         const auto inspect_function_name =
-            absl::StrCat( "inspect_edgedcurve", dimension, "D" );
+            absl::StrCat( "inspect_edged_curve", dimension, "D" );
         module.def(
-            inspect_function_name.c_str(), []( const EdgedCurve& edgedcurve ) {
-                EdgedCurveInspector inspector{ edgedcurve };
-                return inspector.inspect_edgedcurve();
+            inspect_function_name.c_str(), []( const EdgedCurve& edged_curve ) {
+                EdgedCurveInspector inspector{ edged_curve };
+                return inspector.inspect_edged_curve();
             } );
     }
 
-    void define_edgedcurve_inspector( pybind11::module& module )
+    void define_edged_curve_inspector( pybind11::module& module )
     {
         pybind11::class_< EdgedCurveInspectionResult >(
             module, "EdgedCurveInspectionResult" )
@@ -64,7 +64,7 @@ namespace geode
             .def( "inspection_type",
                 &EdgedCurveInspectionResult::inspection_type );
 
-        do_define_edgedcurve_inspector< 2 >( module );
-        do_define_edgedcurve_inspector< 3 >( module );
+        do_define_edged_curve_inspector< 2 >( module );
+        do_define_edged_curve_inspector< 3 >( module );
     }
 } // namespace geode
diff --git a/bindings/python/src/inspector/inspector.cpp b/bindings/python/src/inspector/inspector.cpp
@@ -98,13 +98,13 @@ PYBIND11_MODULE( opengeode_inspector_py_inspector, module )
     geode::define_solid_adjacency( module );
     geode::define_section_meshes_adjacency( module );
     geode::define_brep_meshes_adjacency( module );
-    geode::define_edgedcurve_colocation( module );
-    geode::define_pointset_colocation( module );
+    geode::define_edged_curve_colocation( module );
+    geode::define_point_set_colocation( module );
     geode::define_surface_colocation( module );
     geode::define_solid_colocation( module );
     geode::define_models_meshes_colocation( module );
     geode::define_models_uv_colocation( module );
-    geode::define_edgedcurve_degeneration( module );
+    geode::define_edged_curve_degeneration( module );
     geode::define_solid_degeneration( module );
     geode::define_surface_degeneration( module );
     geode::define_brep_meshes_degeneration( module );
@@ -125,8 +125,8 @@ PYBIND11_MODULE( opengeode_inspector_py_inspector, module )
     geode::define_section_meshes_inspector( module );
     geode::define_brep_inspector( module );
     geode::define_section_inspector( module );
-    geode::define_pointset_inspector( module );
-    geode::define_edgedcurve_inspector( module );
+    geode::define_point_set_inspector( module );
+    geode::define_edged_curve_inspector( module );
     geode::define_surface_inspector( module );
     geode::define_solid_inspector( module );
 }
diff --git a/bindings/python/src/inspector/pointset_inspector.h b/bindings/python/src/inspector/pointset_inspector.h
@@ -29,26 +29,26 @@
 namespace geode
 {
     template < index_t dimension >
-    void do_define_pointset_inspector( pybind11::module& module )
+    void do_define_point_set_inspector( pybind11::module& module )
     {
         using PointSet = PointSet< dimension >;
         using PointSetInspector = PointSetInspector< dimension >;
         const auto name = absl::StrCat( "PointSetInspector", dimension, "D" );
         pybind11::class_< PointSetInspector, PointSetColocation< dimension > >(
             module, name.c_str() )
             .def( pybind11::init< const PointSet& >() )
-            .def( "inspect_pointset", &PointSetInspector::inspect_pointset );
+            .def( "inspect_point_set", &PointSetInspector::inspect_point_set );
 
         const auto inspect_function_name =
-            absl::StrCat( "inspect_pointset", dimension, "D" );
+            absl::StrCat( "inspect_point_set", dimension, "D" );
         module.def(
-            inspect_function_name.c_str(), []( const PointSet& pointset ) {
-                PointSetInspector inspector{ pointset };
-                return inspector.inspect_pointset();
+            inspect_function_name.c_str(), []( const PointSet& point_set ) {
+                PointSetInspector inspector{ point_set };
+                return inspector.inspect_point_set();
             } );
     }
 
-    void define_pointset_inspector( pybind11::module& module )
+    void define_point_set_inspector( pybind11::module& module )
     {
         pybind11::class_< PointSetInspectionResult >(
             module, "PointSetInspectionResult" )
@@ -59,7 +59,7 @@ namespace geode
             .def(
                 "inspection_type", &PointSetInspectionResult::inspection_type );
 
-        do_define_pointset_inspector< 2 >( module );
-        do_define_pointset_inspector< 3 >( module );
+        do_define_point_set_inspector< 2 >( module );
+        do_define_point_set_inspector< 3 >( module );
     }
 } // namespace geode
diff --git a/include/geode/inspector/edgedcurve_inspector.h b/include/geode/inspector/edgedcurve_inspector.h
@@ -59,7 +59,7 @@ namespace geode
     public:
         EdgedCurveInspector( const EdgedCurve< dimension >& mesh );
 
-        EdgedCurveInspectionResult inspect_edgedcurve() const;
+        EdgedCurveInspectionResult inspect_edged_curve() const;
     };
     ALIAS_2D_AND_3D( EdgedCurveInspector );
 } // namespace geode
diff --git a/include/geode/inspector/pointset_inspector.h b/include/geode/inspector/pointset_inspector.h
@@ -53,7 +53,7 @@ namespace geode
     public:
         PointSetInspector( const PointSet< dimension >& mesh );
 
-        PointSetInspectionResult inspect_pointset() const;
+        PointSetInspectionResult inspect_point_set() const;
     };
     ALIAS_2D_AND_3D( PointSetInspector );
 } // namespace geode
diff --git a/src/bin/geode-inspector-edgedcurve.cpp b/src/bin/geode-inspector-edgedcurve.cpp
@@ -42,10 +42,10 @@
 ABSL_FLAG( std::string, input, "/path/my/curve.og_edc3d", "Input edged curve" );
 
 template < geode::index_t dimension >
-void inspect_edgedcurve( const geode::EdgedCurve< dimension >& edgedcurve )
+void inspect_edged_curve( const geode::EdgedCurve< dimension >& edged_curve )
 {
-    const geode::EdgedCurveInspector< dimension > inspector{ edgedcurve };
-    const auto result = inspector.inspect_edgedcurve();
+    const geode::EdgedCurveInspector< dimension > inspector{ edged_curve };
+    const auto result = inspector.inspect_edged_curve();
 
     geode::Logger::info( result.string() );
 }
@@ -68,11 +68,11 @@ int main( int argc, char* argv[] )
 
         if( geode::EdgedCurveInputFactory3D::has_creator( ext ) )
         {
-            inspect_edgedcurve( *geode::load_edged_curve< 3 >( filename ) );
+            inspect_edged_curve( *geode::load_edged_curve< 3 >( filename ) );
         }
         else if( geode::EdgedCurveInputFactory2D::has_creator( ext ) )
         {
-            inspect_edgedcurve( *geode::load_edged_curve< 2 >( filename ) );
+            inspect_edged_curve( *geode::load_edged_curve< 2 >( filename ) );
         }
         else
         {
diff --git a/src/bin/geode-inspector-pointset.cpp b/src/bin/geode-inspector-pointset.cpp
@@ -42,10 +42,10 @@
 ABSL_FLAG( std::string, input, "/path/my/pointset.og_pts3d", "Input pointset" );
 
 template < geode::index_t dimension >
-void inspect_pointset( const geode::PointSet< dimension >& pointset )
+void inspect_point_set( const geode::PointSet< dimension >& pointset )
 {
     const geode::PointSetInspector< dimension > inspector{ pointset };
-    const auto result = inspector.inspect_pointset();
+    const auto result = inspector.inspect_point_set();
 
     geode::Logger::info( result.string() );
 }
@@ -66,11 +66,11 @@ int main( int argc, char* argv[] )
 
         if( geode::PointSetInputFactory3D::has_creator( ext ) )
         {
-            inspect_pointset( *geode::load_point_set< 3 >( filename ) );
+            inspect_point_set( *geode::load_point_set< 3 >( filename ) );
         }
         else if( geode::PointSetInputFactory2D::has_creator( ext ) )
         {
-            inspect_pointset( *geode::load_point_set< 2 >( filename ) );
+            inspect_point_set( *geode::load_point_set< 2 >( filename ) );
         }
         else
         {
diff --git a/src/geode/inspector/criterion/manifold/solid_edge_manifold.cpp b/src/geode/inspector/criterion/manifold/solid_edge_manifold.cpp
@@ -149,7 +149,7 @@ namespace geode
                                     "Edge between vertices with index ",
                                     polyhedron_edge_vertices[0], " and index ",
                                     polyhedron_edge_vertices[1],
-                                    ", is not manifold." ) );
+                                    " is not manifold." ) );
                         }
                     }
                     catch( const OpenGeodeException& )
diff --git a/src/geode/inspector/criterion/manifold/solid_facet_manifold.cpp b/src/geode/inspector/criterion/manifold/solid_facet_manifold.cpp
@@ -98,11 +98,11 @@ namespace geode
                 {
                     non_manifold_facets.add_issue(
                         nb_adjacent_polyhedra.first.vertices(),
-                        absl::StrCat( "Facet made of vertices with index",
+                        absl::StrCat( "Facet made of vertices with index ",
                             nb_adjacent_polyhedra.first.vertices()[0], ", ",
                             nb_adjacent_polyhedra.first.vertices()[1], ", ",
                             nb_adjacent_polyhedra.first.vertices()[2],
-                            ", is not manifold." ) );
+                            " is not manifold." ) );
                 }
             }
             return non_manifold_facets;
diff --git a/src/geode/inspector/criterion/manifold/solid_vertex_manifold.cpp b/src/geode/inspector/criterion/manifold/solid_vertex_manifold.cpp
@@ -109,10 +109,11 @@ namespace geode
                         polyhedra_around_vertices_list[vertex_id],
                         mesh_.polyhedra_around_vertex( vertex_id ) ) )
                 {
-                    non_manifold_vertices.add_issue( vertex_id,
-                        absl::StrCat( "Vertex with index ", vertex_id,
-                            ", at position ", mesh_.point( vertex_id ).string(),
-                            ", is not manifold." ) );
+                    non_manifold_vertices.add_issue(
+                        vertex_id, absl::StrCat( "Vertex with index ",
+                                       vertex_id, ", at position [",
+                                       mesh_.point( vertex_id ).string(),
+                                       "], is not manifold." ) );
                 }
             }
             return non_manifold_vertices;
diff --git a/src/geode/inspector/criterion/manifold/surface_edge_manifold.cpp b/src/geode/inspector/criterion/manifold/surface_edge_manifold.cpp
@@ -93,9 +93,7 @@ namespace geode
                     non_manifold_edges.add_issue( edge.first.vertices(),
                         absl::StrCat( "Edge between vertices with index ",
                             edge.first.vertices()[0], " and index ",
-                            edge.first.vertices()[1],
-                            ", is not manifold (Surface ", mesh_.id().string(),
-                            ")." ) );
+                            edge.first.vertices()[1], " is not manifold." ) );
                 }
             }
             return non_manifold_edges;
diff --git a/src/geode/inspector/criterion/manifold/surface_vertex_manifold.cpp b/src/geode/inspector/criterion/manifold/surface_vertex_manifold.cpp
@@ -119,9 +119,9 @@ namespace geode
                     {
                         non_manifold_vertices.add_issue(
                             vertex_id, absl::StrCat( "Vertex with index ",
-                                           vertex_id, ", at position ",
+                                           vertex_id, ", at position [",
                                            mesh_.point( vertex_id ).string(),
-                                           ", is not manifold." ) );
+                                           "], is not manifold." ) );
                     }
                 }
                 catch( const geode::OpenGeodeException& )
diff --git a/src/geode/inspector/edgedcurve_inspector.cpp b/src/geode/inspector/edgedcurve_inspector.cpp
@@ -49,7 +49,7 @@ namespace geode
 
     template < index_t dimension >
     EdgedCurveInspectionResult
-        EdgedCurveInspector< dimension >::inspect_edgedcurve() const
+        EdgedCurveInspector< dimension >::inspect_edged_curve() const
     {
         EdgedCurveInspectionResult result;
         result.colocated_points_groups = this->colocated_points_groups();
diff --git a/src/geode/inspector/pointset_inspector.cpp b/src/geode/inspector/pointset_inspector.cpp
@@ -47,7 +47,7 @@ namespace geode
 
     template < index_t dimension >
     PointSetInspectionResult
-        PointSetInspector< dimension >::inspect_pointset() const
+        PointSetInspector< dimension >::inspect_point_set() const
     {
         PointSetInspectionResult result;
         result.colocated_points_groups = this->colocated_points_groups();

Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@`
`31`	`31`	`namespace geode`
`32`	`32`	`{`
`33`	`33`	`template < index_t dimension >`
`34`		`- void do_define_edgedcurve_colocation( pybind11::module& module )`
	`34`	`+ void do_define_edged_curve_colocation( pybind11::module& module )`
`35`	`35`	`{`
`36`	`36`	`using EdgedCurve = EdgedCurve< dimension >;`
`37`	`37`	`using EdgedCurveColocation = EdgedCurveColocation< dimension >;`
`@@ -45,9 +45,9 @@ namespace geode`
`45`	`45`	`.def( "colocated_points_groups",`
`46`	`46`	`&EdgedCurveColocation::colocated_points_groups );`
`47`	`47`	`}`
`48`		`- void define_edgedcurve_colocation( pybind11::module& module )`
	`48`	`+ void define_edged_curve_colocation( pybind11::module& module )`
`49`	`49`	`{`
`50`		`- do_define_edgedcurve_colocation< 2 >( module );`
`51`		`- do_define_edgedcurve_colocation< 3 >( module );`
	`50`	`+ do_define_edged_curve_colocation< 2 >( module );`
	`51`	`+ do_define_edged_curve_colocation< 3 >( module );`
`52`	`52`	`}`
`53`	`53`	`} // namespace geode`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@`
`29`	`29`	`namespace geode`
`30`	`30`	`{`
`31`	`31`	`template < index_t dimension >`
`32`		`- void do_define_pointset_colocation( pybind11::module& module )`
	`32`	`+ void do_define_point_set_colocation( pybind11::module& module )`
`33`	`33`	`{`
`34`	`34`	`using PointSet = PointSet< dimension >;`
`35`	`35`	`using PointSetColocation = PointSetColocation< dimension >;`
`@@ -41,9 +41,9 @@ namespace geode`
`41`	`41`	`.def( "colocated_points_groups",`
`42`	`42`	`&PointSetColocation::colocated_points_groups );`
`43`	`43`	`}`
`44`		`- void define_pointset_colocation( pybind11::module& module )`
	`44`	`+ void define_point_set_colocation( pybind11::module& module )`
`45`	`45`	`{`
`46`		`- do_define_pointset_colocation< 2 >( module );`
`47`		`- do_define_pointset_colocation< 3 >( module );`
	`46`	`+ do_define_point_set_colocation< 2 >( module );`
	`47`	`+ do_define_point_set_colocation< 3 >( module );`
`48`	`48`	`}`
`49`	`49`	`} // namespace geode`
Original file line number	Diff line number	Diff line change
`@@ -42,10 +42,10 @@`
`42`	`42`	`ABSL_FLAG( std::string, input, "/path/my/curve.og_edc3d", "Input edged curve" );`
`43`	`43`
`44`	`44`	`template < geode::index_t dimension >`
`45`		`-void inspect_edgedcurve( const geode::EdgedCurve< dimension >& edgedcurve )`
	`45`	`+void inspect_edged_curve( const geode::EdgedCurve< dimension >& edged_curve )`
`46`	`46`	`{`
`47`		`- const geode::EdgedCurveInspector< dimension > inspector{ edgedcurve };`
`48`		`- const auto result = inspector.inspect_edgedcurve();`
	`47`	`+ const geode::EdgedCurveInspector< dimension > inspector{ edged_curve };`
	`48`	`+ const auto result = inspector.inspect_edged_curve();`
`49`	`49`
`50`	`50`	`geode::Logger::info( result.string() );`
`51`	`51`	`}`
`@@ -68,11 +68,11 @@ int main( int argc, char* argv[] )`
`68`	`68`
`69`	`69`	`if( geode::EdgedCurveInputFactory3D::has_creator( ext ) )`
`70`	`70`	`{`
`71`		`- inspect_edgedcurve( *geode::load_edged_curve< 3 >( filename ) );`
	`71`	`+ inspect_edged_curve( *geode::load_edged_curve< 3 >( filename ) );`
`72`	`72`	`}`
`73`	`73`	`else if( geode::EdgedCurveInputFactory2D::has_creator( ext ) )`
`74`	`74`	`{`
`75`		`- inspect_edgedcurve( *geode::load_edged_curve< 2 >( filename ) );`
	`75`	`+ inspect_edged_curve( *geode::load_edged_curve< 2 >( filename ) );`
`76`	`76`	`}`
`77`	`77`	`else`
`78`	`78`	`{`