Fix meshing edge case (#54)

Fixes #53

This adds a relative cutoff for QEF eigenvalues, same as `libfive`:

https://github.com/libfive/libfive/blob/7af5f43684a8a497ac8610d39f7fca935364a9b9/libfive/include/libfive/render/brep/simplex/qef.hpp#L551

CHANGELOG.md

@@ -12,6 +12,8 @@
       change bounds for meshing (by translating + scaling the underlying model).
 - Move `Interval` and `Grad` to `fidget::types` module, instead of
   `fidget::eval::types`.
+- Fix an edge case in meshing where nearly-planar surfaces could produce
+  vertexes far from the desired position.
 
 # 0.2.2
 - Added many transcendental functions: `sin`, `cos`, `tan`, `asin`, `acos`,

fidget/src/mesh/octree.rs

@@ -1870,4 +1870,23 @@ mod test {
             "bad accumulated QEF in center"
         );
     }
+
+    #[test]
+    fn test_qef_near_planar() {
+        let ctx = BoundContext::new();
+        let shape = sphere(&ctx, [0.0; 3], 0.75);
+
+        let shape: VmShape = shape.convert();
+        let settings = Settings {
+            min_depth: 4,
+            max_depth: 4,
+            threads: 0,
+        };
+
+        let octree = Octree::build(&shape, settings).walk_dual(settings);
+        for v in octree.vertices.iter() {
+            let n = v.norm();
+            assert!(n > 0.7 && n < 0.8, "invalid vertex at {v:?}: {n}");
+        }
+    }
 }

fidget/src/mesh/qef.rs

@@ -72,13 +72,25 @@ impl QuadraticErrorSolver {
         let atb = self.atb - self.ata * center;
 
         let svd = nalgebra::linalg::SVD::new(self.ata, true, true);
+
+        // Skip any eigenvalues that are **extremely** small relative to the
+        // maximum eigenvalue.  Without this filter, we can see failures in
+        // near-planar situations.
+        const EIGENVALUE_CUTOFF_RELATIVE: f32 = 1e-12;
+        let cutoff = svd.singular_values[0].abs() * EIGENVALUE_CUTOFF_RELATIVE;
+        let start = (0..3)
+            .filter(|i| svd.singular_values[*i].abs() < cutoff)
+            .last()
+            .unwrap_or(0);
+
         // "Dual Contouring: The Secret Sauce" recomments a threshold of 0.1
         // when using normalized gradients, but I've found that fails on
         // things like the cone model.  Instead, we'll be a little more
         // clever: we'll pick the smallest epsilon that keeps the feature in
         // the cell without dramatically increasing QEF error.
         let mut prev = None;
-        for i in 0..4 {
+        for i in start..4 {
+            // i is the number of singular values to ignore
             let epsilon = if i == 3 {
                 f32::INFINITY
             } else {