perf(AABB): return only the distance from the closest_element query

BotellaA · BotellaA · commit 5fab6b964fb3 · 2024-07-11T14:15:05.000+02:00
BREAKING CHANGE: the return type of AABBTree::closest_element_box changed by losing the point
diff --git a/include/geode/geometry/aabb.h b/include/geode/geometry/aabb.h
@@ -89,19 +89,16 @@ namespace geode
          * - the distance between the \p query and \p nearest_point.
          *
          * @tparam EvalDistance this functor should have an operator()
-         * defined like this: std::tuple< double, Point< dimension > >
-         * operator()( const Point< dimension >& query, index_t
-         * curent_element_box ) const ; the output tuple contains
-         * - a double to store the distance between the point \p query and
-         * the element stored in the \p curent_element_box.
-         * - a Point< dimension > to store the nearest point from \p query
-         * on the object stored in the \p curent_element_box.
+         * defined like this: double operator()( const Point< dimension >&
+         * query, index_t curent_element_box ) const ; the output is the
+         * distance between the point \p query and the element stored in the
+         * \p curent_element_box.
          *
          * @note if several elements box match the
          * distance computation, then one of them will be randomly returned.
          */
         template < typename EvalDistance >
-        std::tuple< index_t, Point< dimension >, double > closest_element_box(
+        std::tuple< index_t, double > closest_element_box(
             const Point< dimension >& query, const EvalDistance& action ) const;
 
         /*!
diff --git a/include/geode/geometry/detail/aabb_impl.h b/include/geode/geometry/detail/aabb_impl.h
@@ -166,7 +166,6 @@ namespace geode
         template < typename ACTION >
         void closest_element_box_recursive( const Point< dimension >& query,
             index_t& nearest_box,
-            Point< dimension >& nearest_point,
             double& distance,
             index_t node_index,
             index_t element_begin,
@@ -274,23 +273,19 @@ namespace geode
 
     template < index_t dimension >
     template < typename EvalDistance >
-    std::tuple< index_t, Point< dimension >, double >
-        AABBTree< dimension >::closest_element_box(
-            const Point< dimension >& query, const EvalDistance& action ) const
+    std::tuple< index_t, double > AABBTree< dimension >::closest_element_box(
+        const Point< dimension >& query, const EvalDistance& action ) const
     {
         if( nb_bboxes() == 0 )
         {
-            return std::make_tuple( NO_ID, query, 0 );
+            return std::make_tuple( NO_ID, 0 );
         }
         auto nearest_box = impl_->closest_element_box_hint( query );
-        double distance;
-        Point< dimension > nearest_point;
-        std::tie( distance, nearest_point ) = action( query, nearest_box );
-
-        impl_->closest_element_box_recursive( query, nearest_box, nearest_point,
-            distance, Impl::ROOT_INDEX, 0, nb_bboxes(), action );
+        auto distance = action( query, nearest_box );
+        impl_->closest_element_box_recursive( query, nearest_box, distance,
+            Impl::ROOT_INDEX, 0, nb_bboxes(), action );
         OPENGEODE_ASSERT( nearest_box != NO_ID, "No box found" );
-        return std::make_tuple( nearest_box, nearest_point, distance );
+        return std::make_tuple( nearest_box, distance );
     }
 
     template < index_t dimension >
@@ -390,7 +385,6 @@ namespace geode
     void AABBTree< dimension >::Impl::closest_element_box_recursive(
         const Point< dimension >& query,
         index_t& nearest_box,
-        Point< dimension >& nearest_point,
         double& distance,
         index_t node_index,
         index_t box_begin,
@@ -407,13 +401,10 @@ namespace geode
         {
             const auto cur_box = mapping_morton( box_begin );
             Point< dimension > cur_nearest_point;
-            double cur_distance;
-            std::tie( cur_distance, cur_nearest_point ) =
-                action( query, cur_box );
+            const auto cur_distance = action( query, cur_box );
             if( cur_distance < distance )
             {
                 nearest_box = cur_box;
-                nearest_point = cur_nearest_point;
                 distance = cur_distance;
             }
             return;
@@ -431,30 +422,26 @@ namespace geode
         {
             if( distance_left < distance )
             {
-                closest_element_box_recursive( query, nearest_box,
-                    nearest_point, distance, it.child_left, box_begin,
-                    it.middle_box, action );
+                closest_element_box_recursive( query, nearest_box, distance,
+                    it.child_left, box_begin, it.middle_box, action );
             }
             if( distance_right < distance )
             {
-                closest_element_box_recursive( query, nearest_box,
-                    nearest_point, distance, it.child_right, it.middle_box,
-                    box_end, action );
+                closest_element_box_recursive( query, nearest_box, distance,
+                    it.child_right, it.middle_box, box_end, action );
             }
         }
         else
         {
             if( distance_right < distance )
             {
-                closest_element_box_recursive( query, nearest_box,
-                    nearest_point, distance, it.child_right, it.middle_box,
-                    box_end, action );
+                closest_element_box_recursive( query, nearest_box, distance,
+                    it.child_right, it.middle_box, box_end, action );
             }
             if( distance_left < distance )
             {
-                closest_element_box_recursive( query, nearest_box,
-                    nearest_point, distance, it.child_left, box_begin,
-                    it.middle_box, action );
+                closest_element_box_recursive( query, nearest_box, distance,
+                    it.child_left, box_begin, it.middle_box, action );
             }
         }
     }
diff --git a/include/geode/mesh/helpers/aabb_edged_curve_helpers.h b/include/geode/mesh/helpers/aabb_edged_curve_helpers.h
@@ -55,7 +55,7 @@ namespace geode
         {
         }
 
-        std::tuple< double, Point< dimension > > operator()(
+        double operator()(
             const Point< dimension >& query, index_t cur_box ) const;
 
     private:
diff --git a/include/geode/mesh/helpers/aabb_solid_helpers.h b/include/geode/mesh/helpers/aabb_solid_helpers.h
@@ -51,7 +51,7 @@ namespace geode
         {
         }
 
-        std::tuple< double, Point< dimension > > operator()(
+        double operator()(
             const Point< dimension >& query, index_t cur_box ) const;
 
     private:
diff --git a/include/geode/mesh/helpers/aabb_surface_helpers.h b/include/geode/mesh/helpers/aabb_surface_helpers.h
@@ -57,7 +57,7 @@ namespace geode
         {
         }
 
-        std::tuple< double, Point< dimension > > operator()(
+        double operator()(
             const Point< dimension >& query, index_t cur_box ) const;
 
     private:
diff --git a/src/geode/mesh/helpers/aabb_edged_curve_helpers.cpp b/src/geode/mesh/helpers/aabb_edged_curve_helpers.cpp
@@ -58,13 +58,11 @@ namespace geode
     }
 
     template < index_t dimension >
-    std::tuple< double, Point< dimension > >
-        DistanceToEdge< dimension >::operator()(
-            const Point< dimension >& query, index_t cur_box ) const
+    double DistanceToEdge< dimension >::operator()(
+        const Point< dimension >& query, index_t cur_box ) const
     {
         const auto segment = mesh_.segment( cur_box );
-        return std::make_tuple( point_segment_distance( query, segment ),
-            point_segment_projection( query, segment ) );
+        return point_segment_distance( query, segment );
     }
 
     template opengeode_mesh_api AABBTree2D create_aabb_tree< 2 >(
diff --git a/src/geode/mesh/helpers/aabb_solid_helpers.cpp b/src/geode/mesh/helpers/aabb_solid_helpers.cpp
@@ -53,12 +53,11 @@ namespace geode
     }
 
     template < index_t dimension >
-    std::tuple< double, Point< dimension > >
-        DistanceToTetrahedron< dimension >::operator()(
-            const Point< dimension >& query, index_t cur_box ) const
+    double DistanceToTetrahedron< dimension >::operator()(
+        const Point< dimension >& query, index_t cur_box ) const
     {
-        return point_tetrahedron_distance(
-            query, mesh_.tetrahedron( cur_box ) );
+        return std::get< 0 >(
+            point_tetrahedron_distance( query, mesh_.tetrahedron( cur_box ) ) );
     }
 
     template opengeode_mesh_api AABBTree3D create_aabb_tree< 3 >(
diff --git a/src/geode/mesh/helpers/aabb_surface_helpers.cpp b/src/geode/mesh/helpers/aabb_surface_helpers.cpp
@@ -60,11 +60,10 @@ namespace geode
     }
 
     template < index_t dimension >
-    std::tuple< double, Point< dimension > >
-        DistanceToTriangle< dimension >::operator()(
-            const Point< dimension >& query, index_t cur_box ) const
+    double DistanceToTriangle< dimension >::operator()(
+        const Point< dimension >& query, index_t cur_box ) const
     {
-        return point_triangle_distance( query, mesh_.triangle( cur_box ) );
+        return std::get< 0 >( point_triangle_distance( query, mesh_.triangle( cur_box ) ));
     }
 
     template opengeode_mesh_api AABBTree2D create_aabb_tree< 2 >(
diff --git a/src/geode/mesh/helpers/hausdorff_distance.cpp b/src/geode/mesh/helpers/hausdorff_distance.cpp
@@ -49,7 +49,7 @@ namespace
             const auto& query = mesh_A.point( v );
             const auto closest_element =
                 mesh_B_tree.closest_element_box( query, distance_action );
-            const auto distance = std::get< 2 >( closest_element );
+            const auto distance = std::get< 1 >( closest_element );
             if( distance > min_dist )
             {
                 min_dist = distance;
diff --git a/tests/geometry/test-aabb.cpp b/tests/geometry/test-aabb.cpp
@@ -101,16 +101,14 @@ class BoxAABBEvalDistance
     }
     ~BoxAABBEvalDistance() = default;
 
-    std::tuple< double, geode::Point< dimension > > operator()(
-        const geode::Point< dimension >& query,
+    double operator()( const geode::Point< dimension >& query,
         geode::index_t current_element_box ) const
     {
         const auto box_center =
             ( bounding_boxes_[current_element_box].min()
                 + bounding_boxes_[current_element_box].max() )
             / 2.;
-        return std::make_tuple(
-            geode::point_point_distance( box_center, query ), box_center );
+        return geode::point_point_distance( box_center, query );
     }
 
 private:
@@ -143,16 +141,12 @@ void test_nearest_neighbor_search()
             query.set_value( 0, i + box_size / 2. );
             query.set_value( 1, j + box_size / 2. );
             geode::index_t box_id;
-            geode::Point< dimension > nearest_point;
             double distance;
-            std::tie( box_id, nearest_point, distance ) =
+            std::tie( box_id, distance ) =
                 aabb.closest_element_box( query, disteval );
 
             OPENGEODE_EXCEPTION( box_id == global_box_index( i, j, nb_boxes ),
                 "[Test]  Nearest box to point AABB - Wrong nearest box index" );
-            OPENGEODE_EXCEPTION( nearest_point == box_center,
-                "[Test]  Nearest box to point AABB - Wrong nearest box "
-                "center " );
             OPENGEODE_EXCEPTION(
                 distance == geode::point_point_distance( box_center, query ),
                 "[Test]  Nearest box to point AABB - Wrong distance to nearest "
diff --git a/tests/mesh/test-aabb-edged-curve-helpers.cpp b/tests/mesh/test-aabb-edged-curve-helpers.cpp
@@ -80,7 +80,7 @@ void check_edgedcurve_tree( const geode::EdgedCurve< dimension >& edged_curve )
     {
         const auto barycenter = edged_curve.edge_barycenter( e );
         geode::index_t closest_edge;
-        std::tie( closest_edge, std::ignore, std::ignore ) =
+        std::tie( closest_edge, std::ignore ) =
             aabb_tree.closest_element_box( barycenter, distance_action );
 
         OPENGEODE_EXCEPTION( closest_edge == e, "[TEST] Wrong edge found" );
diff --git a/tests/mesh/test-aabb-tetrahedral-solid-helpers.cpp b/tests/mesh/test-aabb-tetrahedral-solid-helpers.cpp
@@ -61,41 +61,30 @@ void check_solid_tree( const geode::AABBTree3D& tree,
     const geode::DistanceToTetrahedron3D& distance_action )
 {
     geode::index_t tetrahedron_box_id;
-    geode::Point3D nearest_point;
     double distance;
-    std::tie( tetrahedron_box_id, nearest_point, distance ) =
-        tree.closest_element_box(
-            geode::Point3D{ { 0, 0, 0 } }, distance_action );
+    std::tie( tetrahedron_box_id, distance ) = tree.closest_element_box(
+        geode::Point3D{ { 0, 0, 0 } }, distance_action );
     OPENGEODE_EXCEPTION(
         tetrahedron_box_id == 0, "Wrong tetrahedron id on query 1" );
-    OPENGEODE_EXCEPTION( ( nearest_point == geode::Point3D{ { 0, 0, 0 } } ),
-        "Wrong nearest point on query 1" );
     OPENGEODE_EXCEPTION(
         inexact_equal( distance, 0., 1e-7 ), "Wrong distance on query 1" );
 
-    std::tie( tetrahedron_box_id, nearest_point, distance ) =
-        tree.closest_element_box(
-            geode::Point3D{ { 1, 0, 1 } }, distance_action );
+    std::tie( tetrahedron_box_id, distance ) = tree.closest_element_box(
+        geode::Point3D{ { 1, 0, 1 } }, distance_action );
     OPENGEODE_EXCEPTION(
         tetrahedron_box_id == 2, "Wrong tetrahedron id on query 2" );
-    OPENGEODE_EXCEPTION( ( nearest_point == geode::Point3D{ { 1, 0, 1 } } ),
-        "Wrong nearest point on query 2" );
     OPENGEODE_EXCEPTION(
         inexact_equal( distance, 0., 1e-7 ), "Wrong distance on query 2" );
 
-    std::tie( tetrahedron_box_id, nearest_point, distance ) =
-        tree.closest_element_box(
-            geode::Point3D{ { 0.5, 0.5, 0.5 } }, distance_action );
+    std::tie( tetrahedron_box_id, distance ) = tree.closest_element_box(
+        geode::Point3D{ { 0.5, 0.5, 0.5 } }, distance_action );
     OPENGEODE_EXCEPTION(
         tetrahedron_box_id == 4, "Wrong tetrahedron id on query 3" );
     OPENGEODE_EXCEPTION(
         inexact_equal( distance, 0., 1e-7 ), "Wrong distance on query 3" );
 
-    std::tie( tetrahedron_box_id, nearest_point, distance ) =
-        tree.closest_element_box(
-            geode::Point3D{ { -0.5, 0.5, 0.5 } }, distance_action );
-    OPENGEODE_EXCEPTION( ( nearest_point == geode::Point3D{ { 0, 0.5, 0.5 } } ),
-        "Wrong nearest point on query 4" );
+    std::tie( tetrahedron_box_id, distance ) = tree.closest_element_box(
+        geode::Point3D{ { -0.5, 0.5, 0.5 } }, distance_action );
     OPENGEODE_EXCEPTION(
         inexact_equal( distance, 0.5, 1e-7 ), "Wrong distance on query 4" );
 }
diff --git a/tests/mesh/test-aabb-triangulated-surface-helpers.cpp b/tests/mesh/test-aabb-triangulated-surface-helpers.cpp
@@ -94,35 +94,26 @@ void check_surface_tree( const geode::AABBTree< dimension >& tree,
             const auto query1 =
                 create_vertex< dimension >( i + offset, j + offset );
             geode::index_t triangle1;
-            geode::Point< dimension > nearest_point1;
-            std::tie( triangle1, nearest_point1, std::ignore ) =
+            std::tie( triangle1, std::ignore ) =
                 tree.closest_element_box( query1, distance_action );
             OPENGEODE_EXCEPTION(
                 triangle1 == id++, "[TEST] Wrong triangle found" );
-            OPENGEODE_EXCEPTION( nearest_point1.inexact_equal( query1 ),
-                "[TEST] Wrong nearest point found" );
 
             const auto query2 =
                 create_vertex< dimension >( i + 1 - offset, j + 1 - offset );
             geode::index_t triangle2;
-            geode::Point< dimension > nearest_point2;
-            std::tie( triangle2, nearest_point2, std::ignore ) =
+            std::tie( triangle2, std::ignore ) =
                 tree.closest_element_box( query2, distance_action );
             OPENGEODE_EXCEPTION(
                 triangle2 == id++, "[TEST] Wrong triangle found" );
-            OPENGEODE_EXCEPTION( nearest_point2.inexact_equal( query2 ),
-                "[TEST] Wrong nearest point found" );
         }
     }
 
     geode::Point< dimension > query;
     geode::index_t triangle;
-    geode::Point< dimension > nearest_point;
-    std::tie( triangle, nearest_point, std::ignore ) =
+    std::tie( triangle, std::ignore ) =
         tree.closest_element_box( query, distance_action );
     OPENGEODE_EXCEPTION( triangle == 0, "[TEST] Wrong triangle found" );
-    OPENGEODE_EXCEPTION( nearest_point == geode::Point< dimension >(),
-        "[TEST] Wrong nearest point found" );
 }
 
 template < geode::index_t dimension >

Original file line number	Diff line number	Diff line change
`@@ -166,7 +166,6 @@ namespace geode`
`166`	`166`	`template < typename ACTION >`
`167`	`167`	`void closest_element_box_recursive( const Point< dimension >& query,`
`168`	`168`	`index_t& nearest_box,`
`169`		`- Point< dimension >& nearest_point,`
`170`	`169`	`double& distance,`
`171`	`170`	`index_t node_index,`
`172`	`171`	`index_t element_begin,`
`@@ -274,23 +273,19 @@ namespace geode`
`274`	`273`
`275`	`274`	`template < index_t dimension >`
`276`	`275`	`template < typename EvalDistance >`
`277`		`- std::tuple< index_t, Point< dimension >, double >`
`278`		`- AABBTree< dimension >::closest_element_box(`
`279`		`- const Point< dimension >& query, const EvalDistance& action ) const`
	`276`	`+ std::tuple< index_t, double > AABBTree< dimension >::closest_element_box(`
	`277`	`+ const Point< dimension >& query, const EvalDistance& action ) const`
`280`	`278`	`{`
`281`	`279`	`if( nb_bboxes() == 0 )`
`282`	`280`	`{`
`283`		`- return std::make_tuple( NO_ID, query, 0 );`
	`281`	`+ return std::make_tuple( NO_ID, 0 );`
`284`	`282`	`}`
`285`	`283`	`auto nearest_box = impl_->closest_element_box_hint( query );`
`286`		`- double distance;`
`287`		`- Point< dimension > nearest_point;`
`288`		`- std::tie( distance, nearest_point ) = action( query, nearest_box );`
`289`		`-`
`290`		`- impl_->closest_element_box_recursive( query, nearest_box, nearest_point,`
`291`		`- distance, Impl::ROOT_INDEX, 0, nb_bboxes(), action );`
	`284`	`+ auto distance = action( query, nearest_box );`
	`285`	`+ impl_->closest_element_box_recursive( query, nearest_box, distance,`
	`286`	`+ Impl::ROOT_INDEX, 0, nb_bboxes(), action );`
`292`	`287`	`OPENGEODE_ASSERT( nearest_box != NO_ID, "No box found" );`
`293`		`- return std::make_tuple( nearest_box, nearest_point, distance );`
	`288`	`+ return std::make_tuple( nearest_box, distance );`
`294`	`289`	`}`
`295`	`290`
`296`	`291`	`template < index_t dimension >`
`@@ -390,7 +385,6 @@ namespace geode`
`390`	`385`	`void AABBTree< dimension >::Impl::closest_element_box_recursive(`
`391`	`386`	`const Point< dimension >& query,`
`392`	`387`	`index_t& nearest_box,`
`393`		`- Point< dimension >& nearest_point,`
`394`	`388`	`double& distance,`
`395`	`389`	`index_t node_index,`
`396`	`390`	`index_t box_begin,`
`@@ -407,13 +401,10 @@ namespace geode`
`407`	`401`	`{`
`408`	`402`	`const auto cur_box = mapping_morton( box_begin );`
`409`	`403`	`Point< dimension > cur_nearest_point;`
`410`		`- double cur_distance;`
`411`		`- std::tie( cur_distance, cur_nearest_point ) =`
`412`		`- action( query, cur_box );`
	`404`	`+ const auto cur_distance = action( query, cur_box );`
`413`	`405`	`if( cur_distance < distance )`
`414`	`406`	`{`
`415`	`407`	`nearest_box = cur_box;`
`416`		`- nearest_point = cur_nearest_point;`
`417`	`408`	`distance = cur_distance;`
`418`	`409`	`}`
`419`	`410`	`return;`
`@@ -431,30 +422,26 @@ namespace geode`
`431`	`422`	`{`
`432`	`423`	`if( distance_left < distance )`
`433`	`424`	`{`
`434`		`- closest_element_box_recursive( query, nearest_box,`
`435`		`- nearest_point, distance, it.child_left, box_begin,`
`436`		`- it.middle_box, action );`
	`425`	`+ closest_element_box_recursive( query, nearest_box, distance,`
	`426`	`+ it.child_left, box_begin, it.middle_box, action );`
`437`	`427`	`}`
`438`	`428`	`if( distance_right < distance )`
`439`	`429`	`{`
`440`		`- closest_element_box_recursive( query, nearest_box,`
`441`		`- nearest_point, distance, it.child_right, it.middle_box,`
`442`		`- box_end, action );`
	`430`	`+ closest_element_box_recursive( query, nearest_box, distance,`
	`431`	`+ it.child_right, it.middle_box, box_end, action );`
`443`	`432`	`}`
`444`	`433`	`}`
`445`	`434`	`else`
`446`	`435`	`{`
`447`	`436`	`if( distance_right < distance )`
`448`	`437`	`{`
`449`		`- closest_element_box_recursive( query, nearest_box,`
`450`		`- nearest_point, distance, it.child_right, it.middle_box,`
`451`		`- box_end, action );`
	`438`	`+ closest_element_box_recursive( query, nearest_box, distance,`
	`439`	`+ it.child_right, it.middle_box, box_end, action );`
`452`	`440`	`}`
`453`	`441`	`if( distance_left < distance )`
`454`	`442`	`{`
`455`		`- closest_element_box_recursive( query, nearest_box,`
`456`		`- nearest_point, distance, it.child_left, box_begin,`
`457`		`- it.middle_box, action );`
	`443`	`+ closest_element_box_recursive( query, nearest_box, distance,`
	`444`	`+ it.child_left, box_begin, it.middle_box, action );`
`458`	`445`	`}`
`459`	`446`	`}`
`460`	`447`	`}`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ namespace geode`
`55`	`55`	`{`
`56`	`56`	`}`
`57`	`57`
`58`		`- std::tuple< double, Point< dimension > > operator()(`
	`58`	`+ double operator()(`
`59`	`59`	`const Point< dimension >& query, index_t cur_box ) const;`
`60`	`60`
`61`	`61`	`private:`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ namespace geode`
`51`	`51`	`{`
`52`	`52`	`}`
`53`	`53`
`54`		`- std::tuple< double, Point< dimension > > operator()(`
	`54`	`+ double operator()(`
`55`	`55`	`const Point< dimension >& query, index_t cur_box ) const;`
`56`	`56`
`57`	`57`	`private:`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ namespace geode`
`57`	`57`	`{`
`58`	`58`	`}`
`59`	`59`
`60`		`- std::tuple< double, Point< dimension > > operator()(`
	`60`	`+ double operator()(`
`61`	`61`	`const Point< dimension >& query, index_t cur_box ) const;`
`62`	`62`
`63`	`63`	`private:`
Original file line number	Diff line number	Diff line change
`@@ -58,13 +58,11 @@ namespace geode`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`template < index_t dimension >`
`61`		`- std::tuple< double, Point< dimension > >`
`62`		`- DistanceToEdge< dimension >::operator()(`
`63`		`- const Point< dimension >& query, index_t cur_box ) const`
	`61`	`+ double DistanceToEdge< dimension >::operator()(`
	`62`	`+ const Point< dimension >& query, index_t cur_box ) const`
`64`	`63`	`{`
`65`	`64`	`const auto segment = mesh_.segment( cur_box );`
`66`		`- return std::make_tuple( point_segment_distance( query, segment ),`
`67`		`- point_segment_projection( query, segment ) );`
	`65`	`+ return point_segment_distance( query, segment );`
`68`	`66`	`}`
`69`	`67`
`70`	`68`	`template opengeode_mesh_api AABBTree2D create_aabb_tree< 2 >(`
Original file line number	Diff line number	Diff line change
`@@ -53,12 +53,11 @@ namespace geode`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`template < index_t dimension >`
`56`		`- std::tuple< double, Point< dimension > >`
`57`		`- DistanceToTetrahedron< dimension >::operator()(`
`58`		`- const Point< dimension >& query, index_t cur_box ) const`
	`56`	`+ double DistanceToTetrahedron< dimension >::operator()(`
	`57`	`+ const Point< dimension >& query, index_t cur_box ) const`
`59`	`58`	`{`
`60`		`- return point_tetrahedron_distance(`
`61`		`- query, mesh_.tetrahedron( cur_box ) );`
	`59`	`+ return std::get< 0 >(`
	`60`	`+ point_tetrahedron_distance( query, mesh_.tetrahedron( cur_box ) ) );`
`62`	`61`	`}`
`63`	`62`
`64`	`63`	`template opengeode_mesh_api AABBTree3D create_aabb_tree< 3 >(`
Original file line number	Diff line number	Diff line change
`@@ -60,11 +60,10 @@ namespace geode`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`template < index_t dimension >`
`63`		`- std::tuple< double, Point< dimension > >`
`64`		`- DistanceToTriangle< dimension >::operator()(`
`65`		`- const Point< dimension >& query, index_t cur_box ) const`
	`63`	`+ double DistanceToTriangle< dimension >::operator()(`
	`64`	`+ const Point< dimension >& query, index_t cur_box ) const`
`66`	`65`	`{`
`67`		`- return point_triangle_distance( query, mesh_.triangle( cur_box ) );`
	`66`	`+ return std::get< 0 >( point_triangle_distance( query, mesh_.triangle( cur_box ) ));`
`68`	`67`	`}`
`69`	`68`
`70`	`69`	`template opengeode_mesh_api AABBTree2D create_aabb_tree< 2 >(`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ namespace`
`49`	`49`	`const auto& query = mesh_A.point( v );`
`50`	`50`	`const auto closest_element =`
`51`	`51`	`mesh_B_tree.closest_element_box( query, distance_action );`
`52`		`- const auto distance = std::get< 2 >( closest_element );`
	`52`	`+ const auto distance = std::get< 1 >( closest_element );`
`53`	`53`	`if( distance > min_dist )`
`54`	`54`	`{`
`55`	`55`	`min_dist = distance;`