Fix leaf traversal yielding non-passing leaves (#372)

* Fix leaf traversal bug causing non-passing leaves to be yielded

The iterator did not check the parent node against the check fn.

* feat: avoid checking every leaves twice in leaf iterator.

* chore: cargo fmt

* fix warning

* fix test

---------

Co-authored-by: Sébastien Crozet <sebcrozet@dimforge.com>

Author: izzymg

src/partitioning/bvh/bvh_tests.rs

@@ -6,6 +6,31 @@ fn make_test_aabb(i: usize) -> Aabb {
     Aabb::from_half_extents(Vector::repeat(i as Real).into(), Vector::repeat(1.0))
 }
 
+#[test]
+fn test_leaves_iteration() {
+    let leaves = [
+        make_test_aabb(0), // mins at (0,0,0) - should pass
+        make_test_aabb(5), // mins at (5,5,5) - should be filtered out
+    ];
+    let bvh = Bvh::from_leaves(BvhBuildStrategy::Binned, &leaves);
+
+    // Only allow nodes with mins.x <= 3.0 (should only pass leaf 0)
+    let check = |node: &crate::partitioning::BvhNode| -> bool { node.mins.x <= 3.0 };
+
+    let mut found_invalid_leaf = false;
+    for leaf_index in bvh.leaves(check) {
+        if leaf_index == 1 {
+            // This is the leaf that should be filtered out
+            found_invalid_leaf = true;
+            break;
+        }
+    }
+
+    if found_invalid_leaf {
+        panic!("Leaves iterator returned an invalid leaf");
+    }
+}
+
 #[test]
 fn bvh_build_and_removal() {
     // Check various combination of building pattern and removal pattern.

src/partitioning/bvh/bvh_traverse.rs

@@ -12,6 +12,30 @@ pub struct Leaves<'a, Check: Fn(&BvhNode) -> bool> {
     check: Check,
 }
 
+impl<'a, Check: Fn(&BvhNode) -> bool> Leaves<'a, Check> {
+    pub fn new(tree: &'a Bvh, check: Check) -> Leaves<'a, Check> {
+        let mut stack = SmallVec::default();
+        let mut next = None;
+
+        if let Some(root) = tree.nodes.first() {
+            if check(&root.left) {
+                next = Some(&root.left);
+            }
+
+            if root.right.leaf_count() > 0 && check(&root.right) {
+                stack.push(&root.right);
+            }
+        }
+
+        Leaves {
+            tree,
+            next,
+            stack,
+            check,
+        }
+    }
+}
+
 impl<'a, Check: Fn(&BvhNode) -> bool> Iterator for Leaves<'a, Check> {
     type Item = u32;
     fn next(&mut self) -> Option<Self::Item> {
@@ -77,30 +101,11 @@ impl Bvh {
     /// See also the [`Bvh::traverse`] function which is slightly less convenient since it doesn’t
     /// rely on the iterator system, but takes a closure that implements [`FnMut`] instead of [`Fn`].
     pub fn leaves<F: Fn(&BvhNode) -> bool>(&self, check_node: F) -> Leaves<'_, F> {
-        if let Some(root) = self.nodes.first() {
-            let mut stack = SmallVec::default();
-            if root.right.leaf_count() > 0 {
-                stack.push(&root.right);
-            }
-
-            Leaves {
-                tree: self,
-                next: Some(&root.left),
-                stack,
-                check: check_node,
-            }
-        } else {
-            Leaves {
-                tree: self,
-                next: None,
-                stack: Default::default(),
-                check: check_node,
-            }
-        }
+        Leaves::new(self, check_node)
     }
 }
 
-/// Controls the execution flowo of [`Bvh::traverse`].
+/// Controls the execution flow of [`Bvh::traverse`].
 pub enum TraversalAction {
     /// The traversal will continue on the children of the tested node.
     Continue,

src/shape/shape.rs

@@ -1253,7 +1253,7 @@ impl Shape for ConvexPolygon {
         ShapeType::ConvexPolygon
     }
 
-    fn as_typed_shape(&self) -> TypedShape {
+    fn as_typed_shape(&self) -> TypedShape<'_> {
         TypedShape::ConvexPolygon(self)
     }
 

src/transformation/mesh_intersection/mesh_intersection.rs

@@ -439,7 +439,9 @@ fn triangulate_constraints_and_merge_duplicates(
         let p1_id = insert_into_set(point_pair[0], &mut point_set, epsilon);
         let p2_id = insert_into_set(point_pair[1], &mut point_set, epsilon);
 
-        edges.push([p1_id, p2_id]);
+        if p1_id != p2_id {
+            edges.push([p1_id, p2_id]);
+        }
     }
 
     let mut points: Vec<_> = point_set.iter().cloned().collect();
@@ -462,8 +464,7 @@ fn triangulate_constraints_and_merge_duplicates(
             utils::sanitize_spade_point(point_proj)
         })
         .collect();
-    let cdt_triangulation =
-        ConstrainedDelaunayTriangulation::bulk_load_cdt_stable(planar_points, edges)?;
+    let cdt_triangulation = ConstrainedDelaunayTriangulation::bulk_load_cdt(planar_points, edges)?;
     debug_assert!(cdt_triangulation.vertices().len() == points.len());
 
     let points = points.into_iter().map(|p| Point3::from(p.point)).collect();