fix(ErrorMessage): add component name in log message

include/geode/inspector/information.hpp

@@ -72,7 +72,7 @@ namespace geode
         {
             if( issues_.empty() )
             {
-                return absl::StrCat( description_, " -> No Issues :) \n" );
+                return absl::StrCat( "No issues with ", description_, "\n" );
             }
             auto message = absl::StrCat( description_ );
             for( const auto& issue : messages_ )
@@ -137,7 +137,7 @@ namespace geode
         {
             if( issues_map_.empty() )
             {
-                return absl::StrCat( description_, " -> No Issues :) \n" );
+                return absl::StrCat( "No issues with ", description_, "\n" );
             }
             auto message = absl::StrCat( description_ );
             for( const auto& issues : issues_map_ )

src/geode/inspector/criterion/adjacency/brep_meshes_adjacency.cpp

@@ -62,7 +62,7 @@ namespace geode
         {
             return message;
         }
-        return "No adjacency issues in model component meshes \n";
+        return "No adjacency issues in model \n";
     }
 
     std::string BRepMeshesAdjacencyInspectionResult::inspection_type() const
@@ -89,8 +89,9 @@ namespace geode
                 auto wrong_adjacencies =
                     inspector.polyhedron_facets_with_wrong_adjacency();
                 wrong_adjacencies.set_description(
-                    absl::StrCat( "Block with uuid ", block.id().string(),
-                        " polyhedron facets adjacencies issues" ) );
+                    absl::StrCat( "Block ", block.name(),
+                        " polyhedron facets adjacencies issues - uuid ",
+                        block.id().string() ) );
                 const auto& mesh = block.mesh();
                 for( const auto polyhedron_id : Range{ mesh.nb_polyhedra() } )
                 {

src/geode/inspector/criterion/adjacency/section_meshes_adjacency.cpp

@@ -53,7 +53,7 @@ namespace geode
         {
             return surfaces_edges_with_wrong_adjacencies.string();
         }
-        return "No adjacency issues in model component meshes \n";
+        return "No adjacency issues in model \n";
     }
 
     std::string SectionMeshesAdjacencyInspectionResult::inspection_type() const

src/geode/inspector/criterion/colocation/component_meshes_colocation.cpp

@@ -112,8 +112,8 @@ namespace
             if( !colocated_pts.empty() )
             {
                 geode::InspectionIssues< std::vector< geode::index_t > >
-                    line_issues{ absl::StrCat( "Line with uuid ",
-                        line.id().string(), " colocated vertices" ) };
+                    line_issues{ absl::StrCat( "Line ", line.name(),
+                        " colocated vertices - uuid ", line.id().string() ) };
                 const auto& line_mesh = line.mesh();
                 for( const auto& colocated_points_group : colocated_pts )
                 {
@@ -124,12 +124,12 @@ namespace
                             &point_group_string, " ", point_index );
                     }
                     line_issues.add_issue( colocated_points_group,
-                        absl::StrCat( "Line with uuid ", line.id().string(),
+                        absl::StrCat( "Line ", line.name(),
                             " has vertices with indices", point_group_string,
                             " which are colocated at position [",
                             line_mesh.point( colocated_points_group[0] )
                                 .string(),
-                            "]." ) );
+                            "] - uuid ", line.id().string() ) );
                 }
                 components_colocated_points.add_issues_to_map(
                     line.id(), std::move( line_issues ) );
@@ -147,8 +147,9 @@ namespace
             if( !colocated_pts.empty() )
             {
                 geode::InspectionIssues< std::vector< geode::index_t > >
-                    surface_issues{ absl::StrCat( "Surface with uuid ",
-                        surface.id().string(), " colocated vertices" ) };
+                    surface_issues{ absl::StrCat( "Surface ", surface.name(),
+                        " colocated vertices - uuid ",
+                        surface.id().string() ) };
                 const auto& surface_mesh = surface.mesh();
                 for( const auto& colocated_points_group : colocated_pts )
                 {
@@ -159,13 +160,12 @@ namespace
                             &point_group_string, " ", point_index );
                     }
                     surface_issues.add_issue( colocated_points_group,
-                        absl::StrCat( "Surface with uuid ",
-                            surface.id().string(), " has vertices with indices",
-                            point_group_string,
+                        absl::StrCat( "Surface ", surface.name(),
+                            " has vertices with indices", point_group_string,
                             " which are colocated at position [",
                             surface_mesh.point( colocated_points_group[0] )
                                 .string(),
-                            "]." ) );
+                            "] - uuid ", surface.id().string() ) );
                 }
                 components_colocated_points.add_issues_to_map(
                     surface.id(), std::move( surface_issues ) );
@@ -198,8 +198,8 @@ namespace
             if( !colocated_pts.empty() )
             {
                 geode::InspectionIssues< std::vector< geode::index_t > >
-                    block_issues{ absl::StrCat( "Block with uuid ",
-                        block.id().string(), " colocated vertices" ) };
+                    block_issues{ absl::StrCat( "Block ", block.name(),
+                        " colocated vertices - uuid ", block.id().string() ) };
                 const auto& block_mesh = block.mesh();
                 for( const auto& colocated_points_group : colocated_pts )
                 {
@@ -210,12 +210,12 @@ namespace
                             &point_group_string, " ", point_index );
                     }
                     block_issues.add_issue( colocated_points_group,
-                        absl::StrCat( "Block with uuid ", block.id().string(),
+                        absl::StrCat( "Block ", block.name(),
                             " has vertices with indices", point_group_string,
                             " which are colocated at position [",
                             block_mesh.point( colocated_points_group[0] )
                                 .string(),
-                            "]." ) );
+                            "] - uuid ", block.id().string() ) );
                 }
                 components_colocated_points.add_issues_to_map(
                     block.id(), std::move( block_issues ) );
@@ -238,7 +238,7 @@ namespace geode
         {
             return colocated_points_groups.string();
         }
-        return "No issues of colocation in model component meshes \n";
+        return "No issues of colocation in model \n";
     }
 
     std::string MeshesColocationInspectionResult::inspection_type() const

src/geode/inspector/criterion/degeneration/brep_meshes_degeneration.cpp

@@ -59,7 +59,7 @@ namespace geode
         }
         if( message.empty() )
         {
-            return "No degeneration issues in model component meshes \n";
+            return "No degeneration issues in model \n";
         }
         return message;
     }
@@ -101,14 +101,16 @@ namespace geode
                 }
                 const geode::SolidMeshDegeneration3D inspector{ mesh };
                 auto small_edges = inspector.small_edges( threshold );
-                small_edges.set_description( absl::StrCat(
-                    "Block ", block.id().string(), " small edges" ) );
+                small_edges.set_description(
+                    absl::StrCat( "Block ", block.name(),
+                        " small edges - uuid ", block.id().string() ) );
                 small_edges_map.add_issues_to_map(
                     block.id(), std::move( small_edges ) );
                 auto small_polyhedra =
                     inspector.small_height_polyhedra( threshold );
                 small_polyhedra.set_description( absl::StrCat( "Block ",
-                    block.id().string(), " small height polyhedra" ) );
+                    block.name(), " small height polyhedra - uuid ",
+                    block.id().string() ) );
                 small_polyhedra_map.add_issues_to_map(
                     block.id(), std::move( small_polyhedra ) );
             }

src/geode/inspector/criterion/degeneration/edgedcurve_degeneration.cpp

@@ -54,7 +54,7 @@ namespace geode
         InspectionIssues< index_t > small_edges( double threshold ) const
         {
             InspectionIssues< index_t > degenerated_edges_index{
-                "Degenerated Edges of EdgeCurve " + mesh_.id().string() + "."
+                "Degenerated Edges."
             };
             for( const auto edge_id : Range{ mesh_.nb_edges() } )
             {

src/geode/inspector/criterion/degeneration/section_meshes_degeneration.cpp

@@ -52,7 +52,7 @@ namespace geode
         {
             return message;
         }
-        return "No degeneration issues in model component meshes \n";
+        return "No degeneration issues in model \n";
     }
 
     std::string

src/geode/inspector/criterion/degeneration/solid_degeneration.cpp

@@ -78,7 +78,6 @@ namespace geode
                 {
                     wrong_polyhedra.add_issue( polyhedron_id,
                         absl::StrCat( "Polyhedron ", polyhedron_id,
-                            " of Solid ", this->mesh().id().string(),
                             " is degenerated." ) );
                 }
             }

src/geode/inspector/criterion/degeneration/surface_degeneration.cpp

@@ -74,9 +74,9 @@ namespace geode
                 if( this->mesh().polygon_minimum_height( polygon_id )
                     <= threshold )
                 {
-                    wrong_polygons.add_issue( polygon_id,
-                        absl::StrCat( "Polygon ", polygon_id, " of Surface ",
-                            this->mesh().id().string(), " is degenerated." ) );
+                    wrong_polygons.add_issue(
+                        polygon_id, absl::StrCat( "Polygon ", polygon_id,
+                                        " is degenerated." ) );
                 }
             }
             return wrong_polygons;

src/geode/inspector/criterion/internal/component_meshes_adjacency.cpp

@@ -79,9 +79,9 @@ namespace geode
                     surface.mesh()
                 };
                 auto issues = inspector.polygon_edges_with_wrong_adjacency();
-                issues.set_description(
-                    absl::StrCat( "Surface ", surface.id().string(),
-                        " polygon edges adjacency issues." ) );
+                issues.set_description( absl::StrCat( "Surface ",
+                    surface.name(), " polygon edges adjacency issues - uuid ",
+                    surface.id().string() ) );
                 const auto& mesh = surface.mesh();
                 for( const auto polygon_id : Range{ mesh.nb_polygons() } )
                 {

src/geode/inspector/criterion/internal/component_meshes_degeneration.cpp

@@ -72,8 +72,8 @@ namespace geode
                         line.mesh()
                     };
                     auto issues = inspector.small_edges( threshold );
-                    issues.set_description( absl::StrCat(
-                        "Line ", line.id().string(), " small edges" ) );
+                    issues.set_description( absl::StrCat( "Line ", line.name(),
+                        " small edges - uuid ", line.id().string() ) );
                     return std::make_pair( line.id(), std::move( issues ) );
                 } ) );
             }
@@ -103,7 +103,8 @@ namespace geode
                             inspector{ surface.mesh() };
                         auto issues = inspector.small_edges( threshold );
                         issues.set_description( absl::StrCat( "Surface ",
-                            surface.id().string(), " small edges" ) );
+                            surface.name(), " small edges - uuid ",
+                            surface.id().string() ) );
                         return std::make_pair(
                             surface.id(), std::move( issues ) );
                     } ) );
@@ -141,7 +142,8 @@ namespace geode
                         inspector{ surface.mesh() };
                     auto issues = inspector.small_height_polygons( threshold );
                     issues.set_description( absl::StrCat( "Surface ",
-                        surface.id().string(), " small polygons" ) );
+                        surface.name(), " small polygons - uuid ",
+                        surface.id().string() ) );
                     return std::make_pair( surface.id(), std::move( issues ) );
                 } ) );
             }

src/geode/inspector/criterion/internal/component_meshes_manifold.cpp

@@ -58,7 +58,8 @@ namespace geode
                 };
                 auto issues = inspector.non_manifold_vertices();
                 issues.set_description( absl::StrCat( "Surface ",
-                    surface.id().string(), " non manifold vertices" ) );
+                    surface.name(), " non manifold vertices - uuid ",
+                    surface.id().string() ) );
                 surfaces_non_manifold_vertices.add_issues_to_map(
                     surface.id(), std::move( issues ) );
             }
@@ -78,7 +79,8 @@ namespace geode
                 };
                 auto issues = inspector.non_manifold_edges();
                 issues.set_description( absl::StrCat( "Surface ",
-                    surface.id().string(), " non manifold edges" ) );
+                    surface.name(), " non manifold edges - uuid ",
+                    surface.id().string() ) );
                 surfaces_non_manifold_edges.add_issues_to_map(
                     surface.id(), std::move( issues ) );
             }

src/geode/inspector/criterion/intersections/model_intersections.cpp

@@ -516,13 +516,17 @@ namespace geode
                 AllModelSurfacesIntersection< Model > >();
             for( const auto& polygon_pair : intersections )
             {
+                const auto& surface1 =
+                    model_.surface( polygon_pair.first.component_id.id() );
+                const auto& surface2 =
+                    model_.surface( polygon_pair.second.component_id.id() );
                 intersection_issues.add_issue( polygon_pair,
-                    absl::StrCat( "Polygons ", polygon_pair.first.element_id,
-                        " of surface ",
+                    absl::StrCat( surface1.name(), " and ", surface2.name(),
+                        " intersect each other on polygons ",
+                        polygon_pair.first.element_id, " and ",
+                        polygon_pair.second.element_id, " - uuids ",
                         polygon_pair.first.component_id.id().string(), " and ",
-                        polygon_pair.second.element_id, " of surface ",
-                        polygon_pair.second.component_id.id().string(),
-                        " intersect each other." ) );
+                        polygon_pair.second.component_id.id().string() ) );
             }
         }
 
@@ -534,11 +538,14 @@ namespace geode
                 AllModelSurfacesAutoIntersection< Model > >();
             for( const auto& polygon_pair : intersections )
             {
+                const auto& surface =
+                    model_.surface( polygon_pair.first.component_id.id() );
                 intersection_issues.add_issue( polygon_pair,
-                    absl::StrCat( "Polygons ", polygon_pair.first.element_id,
-                        "and ", polygon_pair.second.element_id, " of surface ",
-                        polygon_pair.first.component_id.id().string(),
-                        " intersect each other." ) );
+                    absl::StrCat( "Surface ", surface.name(),
+                        "have self intersection on polygons ",
+                        polygon_pair.first.element_id, "and ",
+                        polygon_pair.second.element_id, " - uuid ",
+                        polygon_pair.first.component_id.id().string() ) );
             }
         }
 

src/geode/inspector/criterion/manifold/section_meshes_manifold.cpp

@@ -53,7 +53,7 @@ namespace geode
         {
             return message;
         }
-        return "No manifold issues in model component meshes \n";
+        return "No manifold issues in model \n";
     }
 
     std::string SectionMeshesManifoldInspectionResult::inspection_type() const

src/geode/inspector/criterion/manifold/solid_edge_manifold.cpp

@@ -159,8 +159,7 @@ namespace geode
                                           "between vertices with index ",
                                 polyhedron_edge_vertices[0], " and index ",
                                 polyhedron_edge_vertices[1],
-                                "; There are probably issues with solid "
-                                "adjacencies." ) );
+                                "; Check issues with solid adjacencies." ) );
                     }
                 }
             }

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

@@ -44,7 +44,7 @@ namespace geode
         {
             return negative_polyhedra.string();
         }
-        return "No negative elements issues in model component meshes \n";
+        return "No negative polyhedra issues in model \n";
     }
 
     std::string
@@ -68,8 +68,9 @@ namespace geode
                     block.mesh()
                 };
                 auto negative_elements = inspector.negative_polyhedra();
-                negative_elements.set_description( absl::StrCat(
-                    "Block ", block.id().string(), " negative polyhedra" ) );
+                negative_elements.set_description(
+                    absl::StrCat( "Block ", block.name(),
+                        " negative polyhedra - uuid ", block.id().string() ) );
                 result.negative_polyhedra.add_issues_to_map(
                     block.id(), std::move( negative_elements ) );
             }

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

@@ -46,7 +46,7 @@ namespace geode
         {
             return negative_polygons.string();
         }
-        return "No negative elements issues in model component meshes \n";
+        return "No negative polygons issues in model \n";
     }
 
     std::string
@@ -70,8 +70,9 @@ namespace geode
                     surface.mesh()
                 };
                 auto negative_elements = inspector.negative_polygons();
-                negative_elements.set_description( absl::StrCat(
-                    "Surface ", surface.id().string(), " negative polygons" ) );
+                negative_elements.set_description(
+                    absl::StrCat( "Surface ", surface.name(),
+                        " negative polygons - uuid ", surface.id().string() ) );
                 result.negative_polygons.add_issues_to_map(
                     surface.id(), std::move( negative_elements ) );
             }

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

@@ -64,7 +64,6 @@ namespace geode
                 {
                     wrong_polyhedra.add_issue( polyhedron_id,
                         absl::StrCat( "Polyhedron ", polyhedron_id,
-                            " of Solid ", mesh_.id().string(),
                             " has a negative volume." ) );
                 }
             }

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

@@ -61,9 +61,9 @@ namespace geode
             {
                 if( polygon_has_negative_area( polygon_id ) )
                 {
-                    wrong_polygons.add_issue( polygon_id,
-                        absl::StrCat( "Polygon ", polygon_id, " of Surface ",
-                            mesh_.id().string(), " has a negative area." ) );
+                    wrong_polygons.add_issue(
+                        polygon_id, absl::StrCat( "Polygon ", polygon_id,
+                                        " has a negative area." ) );
                 }
             }
             return wrong_polygons;