perf(Global): several performance improvements

Author: BotellaA

include/geode/model/helpers/component_mesh_vertices.h

@@ -42,4 +42,9 @@ namespace geode
     ComponentMeshVertexPairs opengeode_model_api component_mesh_vertex_pairs(
         absl::Span< const ComponentMeshVertex > unique_vertices0,
         absl::Span< const ComponentMeshVertex > unique_vertices1 );
+
+    ComponentMeshVertexPairs opengeode_model_api component_mesh_vertex_pairs(
+        absl::Span< const ComponentMeshVertex > unique_vertices0,
+        absl::Span< const ComponentMeshVertex > unique_vertices1,
+        const geode::ComponentType& type );
 } // namespace geode

src/geode/geometry/barycentric_coordinates.cpp

@@ -33,18 +33,15 @@ namespace geode
     std::array< double, 4 > tetrahedron_barycentric_coordinates(
         const Point3D& point, const Tetrahedron& tetra )
     {
-        const auto volume0 =
-            tetrahedron_signed_volume( Tetrahedron{ tetra.vertices()[1],
-                tetra.vertices()[3], tetra.vertices()[2], point } );
-        const auto volume1 =
-            tetrahedron_signed_volume( Tetrahedron{ tetra.vertices()[0],
-                tetra.vertices()[2], tetra.vertices()[3], point } );
-        const auto volume2 =
-            tetrahedron_signed_volume( Tetrahedron{ tetra.vertices()[0],
-                tetra.vertices()[3], tetra.vertices()[1], point } );
-        const auto volume3 =
-            tetrahedron_signed_volume( Tetrahedron{ tetra.vertices()[0],
-                tetra.vertices()[1], tetra.vertices()[2], point } );
+        const auto& vertices = tetra.vertices();
+        const auto volume0 = tetrahedron_signed_volume(
+            Tetrahedron{ vertices[1], vertices[3], vertices[2], point } );
+        const auto volume1 = tetrahedron_signed_volume(
+            Tetrahedron{ vertices[0], vertices[2], vertices[3], point } );
+        const auto volume2 = tetrahedron_signed_volume(
+            Tetrahedron{ vertices[0], vertices[3], vertices[1], point } );
+        const auto volume3 = tetrahedron_signed_volume(
+            Tetrahedron{ vertices[0], vertices[1], vertices[2], point } );
         const auto total_volume = volume0 + volume1 + volume2 + volume3;
         OPENGEODE_EXCEPTION( std::fabs( total_volume ) > global_epsilon,
             "[tetrahedron_barycentric_coordinates] Volume of input tetrahedron "
@@ -69,15 +66,14 @@ namespace geode
             result.fill( 1. / 3. );
             return result;
         }
-        const auto area0 = triangle_signed_area(
-            { triangle.vertices()[1], triangle.vertices()[2], point },
-            triangle_normal.value() );
-        const auto area1 = triangle_signed_area(
-            { triangle.vertices()[2], triangle.vertices()[0], point },
-            triangle_normal.value() );
-        const auto area2 = triangle_signed_area(
-            { triangle.vertices()[0], triangle.vertices()[1], point },
-            triangle_normal.value() );
+        const auto& vertices = triangle.vertices();
+        const auto& normal = triangle_normal.value();
+        const auto area0 =
+            triangle_signed_area( { vertices[1], vertices[2], point }, normal );
+        const auto area1 =
+            triangle_signed_area( { vertices[2], vertices[0], point }, normal );
+        const auto area2 =
+            triangle_signed_area( { vertices[0], vertices[1], point }, normal );
 
         const auto total_area = area0 + area1 + area2;
         OPENGEODE_EXCEPTION( std::fabs( total_area ) > global_epsilon,
@@ -93,12 +89,13 @@ namespace geode
     std::array< double, 3 > triangle_barycentric_coordinates(
         const Point2D& point, const Triangle2D& triangle )
     {
-        const auto area0 = triangle_signed_area(
-            { triangle.vertices()[1], triangle.vertices()[2], point } );
-        const auto area1 = triangle_signed_area(
-            { triangle.vertices()[2], triangle.vertices()[0], point } );
-        const auto area2 = triangle_signed_area(
-            { triangle.vertices()[0], triangle.vertices()[1], point } );
+        const auto& vertices = triangle.vertices();
+        const auto area0 =
+            triangle_signed_area( { vertices[1], vertices[2], point } );
+        const auto area1 =
+            triangle_signed_area( { vertices[2], vertices[0], point } );
+        const auto area2 =
+            triangle_signed_area( { vertices[0], vertices[1], point } );
 
         const auto total_area = area0 + area1 + area2;
         OPENGEODE_EXCEPTION( std::fabs( total_area ) > global_epsilon,
@@ -116,9 +113,10 @@ namespace geode
     {
         const auto dir = segment.direction();
         const auto length = dir.length();
-        const Vector< dimension > v0p{ segment.vertices()[0], point };
+        const auto& vertices = segment.vertices();
+        const Vector< dimension > v0p{ vertices[0], point };
         const auto dot0 = v0p.dot( dir ) / length;
-        const Vector< dimension > v1p{ segment.vertices()[1], point };
+        const Vector< dimension > v1p{ vertices[1], point };
         const auto dot1 = -v1p.dot( dir ) / length;
         const auto sum = dot0 + dot1;
         OPENGEODE_EXCEPTION( std::fabs( sum ) > global_epsilon,

src/geode/geometry/basic_objects/triangle.cpp

@@ -34,16 +34,17 @@ namespace
     {
         try
         {
+            const auto& vertices = triangle.vertices();
             for( const auto pivot : geode::LRange{ 3 } )
             {
                 const auto next = pivot + 1 == 3 ? 0 : pivot + 1;
-                const auto edge0 = geode::Vector3D{ triangle.vertices()[pivot],
-                    triangle.vertices()[next] }
-                                       .normalize();
+                const auto edge0 =
+                    geode::Vector3D{ vertices[pivot], vertices[next] }
+                        .normalize();
                 const auto prev = pivot == 0 ? 2 : pivot - 1;
-                const auto edge1 = geode::Vector3D{ triangle.vertices()[pivot],
-                    triangle.vertices()[prev] }
-                                       .normalize();
+                const auto edge1 =
+                    geode::Vector3D{ vertices[pivot], vertices[prev] }
+                        .normalize();
 
                 const auto normal = edge0.cross( edge1 );
                 const auto length = normal.length();

src/geode/geometry/distance.cpp

@@ -47,15 +47,13 @@ namespace
     bool may_point_be_in_triangle(
         const geode::Point2D& point, const geode::Triangle2D& triangle )
     {
-        const auto signed_area_1 =
-            geode::triangle_signed_area( geode::Triangle2D{
-                triangle.vertices()[0], triangle.vertices()[1], point } );
-        const auto signed_area_2 =
-            geode::triangle_signed_area( geode::Triangle2D{
-                triangle.vertices()[1], triangle.vertices()[2], point } );
-        const auto signed_area_3 =
-            geode::triangle_signed_area( geode::Triangle2D{
-                triangle.vertices()[2], triangle.vertices()[0], point } );
+        const auto& vertices = triangle.vertices();
+        const auto signed_area_1 = geode::triangle_signed_area(
+            geode::Triangle2D{ vertices[0], vertices[1], point } );
+        const auto signed_area_2 = geode::triangle_signed_area(
+            geode::Triangle2D{ vertices[1], vertices[2], point } );
+        const auto signed_area_3 = geode::triangle_signed_area(
+            geode::Triangle2D{ vertices[2], vertices[0], point } );
 
         return ( signed_area_1 <= 0. && signed_area_2 <= 0.
                    && signed_area_3 <= 0 )
@@ -96,12 +94,11 @@ namespace geode
         /* Algorithm and code found on
          * http://geomalgorithms.com/a07-_distance.html
          */
-        const Vector< dimension > u{ segment0.vertices()[0],
-            segment0.vertices()[1] };
-        const Vector< dimension > v{ segment1.vertices()[0],
-            segment1.vertices()[1] };
-        const Vector< dimension > w{ segment1.vertices()[0],
-            segment0.vertices()[0] };
+        const auto& vertices0 = segment0.vertices();
+        const auto& vertices1 = segment1.vertices();
+        const Vector< dimension > u{ vertices0[0], vertices0[1] };
+        const Vector< dimension > v{ vertices1[0], vertices1[1] };
+        const Vector< dimension > w{ vertices1[0], vertices0[0] };
         const auto a = u.dot( u ); // always >= 0
         const auto b = u.dot( v );
         const auto c = v.dot( v ); // always >= 0
@@ -174,10 +171,8 @@ namespace geode
         tc = ( std::fabs( tN ) <= 0.0 ? 0.0 : tN / tD );
 
         // get the difference of the two closest points
-        const Point< dimension > closest0 =
-            segment0.vertices()[0].get() + u * sc;
-        const Point< dimension > closest1 =
-            segment1.vertices()[0].get() + v * tc;
+        const Point< dimension > closest0 = vertices0[0].get() + u * sc;
+        const Point< dimension > closest1 = vertices1[0].get() + v * tc;
         const Vector< dimension > dP{ closest0,
             closest1 }; // =  segment0(sc) - segment1(tc)
 
@@ -192,13 +187,14 @@ namespace geode
         auto min_distance = std::numeric_limits< double >::max();
         local_index_t min_p0{ 0 };
         local_index_t min_p1{ 0 };
+        const auto& vertices0 = segment0.vertices();
+        const auto& vertices1 = segment1.vertices();
         for( const auto p0 : LRange{ 2 } )
         {
             for( const auto p1 : LRange{ 2 } )
             {
-                const auto cur_dist =
-                    point_point_distance( segment0.vertices()[p0].get(),
-                        segment1.vertices()[p1].get() );
+                const auto cur_dist = point_point_distance(
+                    vertices0[p0].get(), vertices1[p1].get() );
                 if( cur_dist < min_distance )
                 {
                     min_distance = cur_dist;
@@ -212,16 +208,16 @@ namespace geode
             if( min_p1 == 1 )
             {
                 return compute_segment_segment_distance< dimension >(
-                    { segment0.vertices()[1], segment0.vertices()[0] },
-                    { segment1.vertices()[1], segment1.vertices()[0] } );
+                    { vertices0[1], vertices0[0] },
+                    { vertices1[1], vertices1[0] } );
             }
             return compute_segment_segment_distance(
-                { segment0.vertices()[1], segment0.vertices()[0] }, segment1 );
+                { vertices0[1], vertices0[0] }, segment1 );
         }
         if( min_p1 == 1 )
         {
             return compute_segment_segment_distance(
-                segment0, { segment1.vertices()[1], segment1.vertices()[0] } );
+                segment0, { vertices1[1], vertices1[0] } );
         }
         return compute_segment_segment_distance( segment0, segment1 );
     }
@@ -254,15 +250,14 @@ namespace geode
     {
         const auto v1 = v0 == 2 ? 0 : v0 + 1;
         const auto v2 = v1 == 2 ? 0 : v1 + 1;
-        const Vector3D edge0{ triangle.vertices()[v0],
-            triangle.vertices()[v1] };
-        const Vector3D edge1{ triangle.vertices()[v0],
-            triangle.vertices()[v2] };
+        const auto& vertices = triangle.vertices();
+        const Vector3D edge0{ vertices[v0], vertices[v1] };
+        const Vector3D edge1{ vertices[v0], vertices[v2] };
         const auto a00 = edge0.length2();
         const auto a01 = edge0.dot( edge1 );
         const auto a11 = edge1.length2();
         const auto det = std::fabs( a00 * a11 - a01 * a01 );
-        const Vector3D diff{ point, triangle.vertices()[v0] };
+        const Vector3D diff{ point, vertices[v0] };
         const auto b0 = diff.dot( edge0 );
         const auto b1 = diff.dot( edge1 );
         auto s = a01 * b1 - a11 * b0;
@@ -443,8 +438,7 @@ namespace geode
             }
         }
 
-        Point3D closest_point{ triangle.vertices()[v0].get() + edge0 * s
-                               + edge1 * t };
+        Point3D closest_point{ vertices[v0].get() + edge0 * s + edge1 * t };
         const auto distance = point_point_distance( point, closest_point );
         return std::make_tuple( distance, std::move( closest_point ) );
     }
@@ -460,11 +454,12 @@ namespace geode
         std::array< std::tuple< double, Point3D >, 3 > edge_distances;
         auto min_distance = std::numeric_limits< double >::max();
         local_index_t selected_edge{ NO_LID };
+        const auto& vertices = triangle.vertices();
         for( const auto e : LRange{ 3 } )
         {
             const auto next = e == 2 ? 0 : e + 1;
             edge_distances[e] = point_segment_distance(
-                point, { triangle.vertices()[e], triangle.vertices()[next] } );
+                point, { vertices[e], vertices[next] } );
             const auto& cur_distance = std::get< 0 >( edge_distances[e] );
             if( cur_distance < min_distance )
             {
@@ -483,14 +478,15 @@ namespace geode
         {
             return std::make_tuple( 0.0, point );
         }
+        const auto& vertices = triangle.vertices();
         std::array< Point2D, 3 > closest;
         std::array< double, 3 > distance;
-        std::tie( distance[0], closest[0] ) = point_segment_distance( point,
-            Segment2D{ triangle.vertices()[0], triangle.vertices()[1] } );
-        std::tie( distance[1], closest[1] ) = point_segment_distance( point,
-            Segment2D{ triangle.vertices()[1], triangle.vertices()[2] } );
-        std::tie( distance[2], closest[2] ) = point_segment_distance( point,
-            Segment2D{ triangle.vertices()[2], triangle.vertices()[0] } );
+        std::tie( distance[0], closest[0] ) = point_segment_distance(
+            point, Segment2D{ vertices[0], vertices[1] } );
+        std::tie( distance[1], closest[1] ) = point_segment_distance(
+            point, Segment2D{ vertices[1], vertices[2] } );
+        std::tie( distance[2], closest[2] ) = point_segment_distance(
+            point, Segment2D{ vertices[2], vertices[0] } );
         double result;
         Point2D closest_point;
         if( distance[0] < distance[1] )
@@ -528,18 +524,17 @@ namespace geode
         auto max_distance = MAX_DOUBLE;
         Point3D nearest_p;
         bool inside{ true };
+        const auto& vertices = tetra.vertices();
         for( const auto f : Range{ 4 } )
         {
+            const auto& facet_vertices =
+                Tetrahedron::tetrahedron_facet_vertex[f];
             double distance;
             Point3D cur_p;
-            std::tie( distance, cur_p ) = point_triangle_signed_distance( point,
-                Triangle3D{
-                    tetra.vertices()[Tetrahedron::tetrahedron_facet_vertex[f]
-                                                                          [0]],
-                    tetra.vertices()[Tetrahedron::tetrahedron_facet_vertex[f]
-                                                                          [1]],
-                    tetra.vertices()
-                        [Tetrahedron::tetrahedron_facet_vertex[f][2]] } );
+            std::tie( distance, cur_p ) = point_triangle_signed_distance(
+                point, Triangle3D{ vertices[facet_vertices[0]],
+                           vertices[facet_vertices[1]],
+                           vertices[facet_vertices[2]] } );
             if( distance > 0 )
             {
                 inside = false;

src/geode/geometry/intersection.cpp

@@ -202,8 +202,9 @@ namespace geode
         // http://www.geometrictools.com/LibMathematics/Intersection/Intersection.html
         // Compute the offset origin, edges, and normal.
         const auto seg_center = segment.barycenter();
-        const Vector3D edge1{ triangle.vertices()[0], triangle.vertices()[1] };
-        const Vector3D edge2{ triangle.vertices()[0], triangle.vertices()[2] };
+        const auto& vertices = triangle.vertices();
+        const Vector3D edge1{ vertices[0], vertices[1] };
+        const Vector3D edge2{ vertices[0], vertices[2] };
         const auto normal = edge1.cross( edge2 );
 
         // Solve Q + t*D = b1*E1 + b2*E2 (Q = diff, D = segment direction,
@@ -228,7 +229,7 @@ namespace geode
             return { IntersectionType::PARALLEL };
         }
 
-        const Vector3D diff{ triangle.vertices()[0], seg_center };
+        const Vector3D diff{ vertices[0], seg_center };
         const auto DdQxE2 =
             sign * segment.normalized_direction().dot( diff.cross( edge2 ) );
         if( DdQxE2 >= 0 )
@@ -280,9 +281,9 @@ namespace geode
                         tri_lambdas.fill( 1. / 3. );
                     }
                     correctness.second.second =
-                        triangle.vertices()[0].get() * tri_lambdas[0]
-                        + triangle.vertices()[1].get() * tri_lambdas[1]
-                        + triangle.vertices()[2].get() * tri_lambdas[2];
+                        vertices[0].get() * tri_lambdas[0]
+                        + vertices[1].get() * tri_lambdas[1]
+                        + vertices[2].get() * tri_lambdas[2];
                     correctness.second.first =
                         std::get< 0 >( point_triangle_distance(
                             correctness.second.second, triangle ) )
@@ -303,8 +304,9 @@ namespace geode
     {
         // http://www.geometrictools.com/LibMathematics/Intersection/Intersection.html
         // Compute the offset origin, edges, and normal.
-        const Vector3D edge1{ triangle.vertices()[0], triangle.vertices()[1] };
-        const Vector3D edge2{ triangle.vertices()[0], triangle.vertices()[2] };
+        const auto& vertices = triangle.vertices();
+        const Vector3D edge1{ vertices[0], vertices[1] };
+        const Vector3D edge2{ vertices[0], vertices[2] };
         const auto normal = edge1.cross( edge2 );
 
         // Solve Q + t*D = b1*E1 + b2*E2 (Q = diff, D = segment direction,
@@ -329,7 +331,7 @@ namespace geode
             return { IntersectionType::PARALLEL };
         }
 
-        const Vector3D diff{ triangle.vertices()[0], line.origin() };
+        const Vector3D diff{ vertices[0], line.origin() };
         const auto DdQxE2 = sign * line.direction().dot( diff.cross( edge2 ) );
         if( DdQxE2 >= 0 )
         {
@@ -360,9 +362,9 @@ namespace geode
                     tri_lambdas.fill( 1. / 3. );
                 }
                 correctness.second.second =
-                    triangle.vertices()[0].get() * tri_lambdas[0]
-                    + triangle.vertices()[1].get() * tri_lambdas[1]
-                    + triangle.vertices()[2].get() * tri_lambdas[2];
+                    vertices[0].get() * tri_lambdas[0]
+                    + vertices[1].get() * tri_lambdas[1]
+                    + vertices[2].get() * tri_lambdas[2];
                 correctness.second.first =
                     point_point_distance( result, correctness.second.second )
                     < global_epsilon;

src/geode/geometry/mensuration.cpp

@@ -60,17 +60,18 @@ namespace geode
 
     double triangle_signed_area( const Triangle2D& triangle )
     {
+        const auto& vertices = triangle.vertices();
         return dot_perpendicular(
-                   { triangle.vertices()[0], triangle.vertices()[1] },
-                   { triangle.vertices()[0], triangle.vertices()[2] } )
+                   { vertices[0], vertices[1] }, { vertices[0], vertices[2] } )
                / 2.;
     }
 
     double tetrahedron_signed_volume( const Tetrahedron& tetra )
     {
-        return Vector3D{ tetra.vertices()[0], tetra.vertices()[1] }.dot(
-                   Vector3D{ tetra.vertices()[0], tetra.vertices()[2] }.cross(
-                       { tetra.vertices()[0], tetra.vertices()[3] } ) )
+        const auto& vertices = tetra.vertices();
+        return Vector3D{ vertices[0], vertices[1] }.dot(
+                   Vector3D{ vertices[0], vertices[2] }.cross(
+                       { vertices[0], vertices[3] } ) )
                / 6.;
     }