Correct SDF preview examples

Author: timschmidt

examples/readme_renders.rs

@@ -264,19 +264,19 @@ fn render_readme_meshes() {
     render_mesh(
         "sdf",
         &Mesh::<()>::sdf(
-            |p| p.coords.norm() - 1.0,
-            (16, 16, 16),
-            Point3::new(-1.2, -1.2, -1.2),
-            Point3::new(1.2, 1.2, 1.2),
+            |p| p.coords.norm() - 0.75,
+            (20, 20, 20),
+            Point3::new(-1.1, -1.1, -1.1),
+            Point3::new(1.1, 1.1, 1.1),
             0.0,
             (),
         ),
     );
 
     let tpms_box = Mesh::<()>::cube(2.0, ());
-    render_mesh("gyroid", &tpms_box.gyroid(14, 0.75, 0.0, ()));
-    render_mesh("schwarz_p", &tpms_box.schwarz_p(14, 0.75, 0.0, ()));
-    render_mesh("schwarz_d", &tpms_box.schwarz_d(14, 0.75, 0.0, ()));
+    render_mesh("gyroid", &tpms_box.gyroid(20, 2.0, 0.0, ()));
+    render_mesh("schwarz_p", &tpms_box.schwarz_p(20, 2.0, 0.0, ()));
+    render_mesh("schwarz_d", &tpms_box.schwarz_d(20, 2.0, 0.0, ()));
     render_mesh(
         "spur_gear_involute",
         &Mesh::<()>::spur_gear_involute(0.18, 22, 20.0, 0.0, 0.0, 8, 0.35, ()),

readme.md

@@ -270,7 +270,7 @@ let faces = vec![
     vec![2, 3, 4],
     vec![3, 0, 4],
 ];
-let pyramid = Mesh::polyhedron(points, &faces, None);
+let pyramid = Mesh::<()>::polyhedron(points, &faces, ());
 
 // Metaballs https://en.wikipedia.org/wiki/Metaballs
 use csgrs::mesh::metaballs::MetaBall;
@@ -283,12 +283,12 @@ let resolution = (60, 60, 60);
 let iso_value = 1.0;
 let padding = 1.0;
 
-let metaball_csg = CSG::from_metaballs(
+let metaball_csg = Mesh::<()>::metaballs(
     &balls,
     resolution,
     iso_value,
     padding,
-    None,
+    (),
 );
 
 // Example Signed Distance Field for a sphere of radius 1.5 centered at (0,0,0)
@@ -299,7 +299,7 @@ let min_pt = Point3::new(-2.0, -2.0, -2.0);
 let max_pt = Point3::new( 2.0,  2.0,  2.0);
 let iso_value = 0.0; // Typically zero for SDF-based surfaces
 
-let csg_shape = Mesh::from_sdf(my_sdf, resolution, min_pt, max_pt, iso_value, None);
+let csg_shape = Mesh::<()>::sdf(my_sdf, resolution, min_pt, max_pt, iso_value, ());
 ```
 
 ### CSG Boolean Operations

src/mesh/tpms.rs

@@ -37,8 +37,11 @@ impl<M: Clone + Debug + Send + Sync> Mesh<M> {
 
     // ------------  Specific minimal‑surface flavours  --------------------
 
-    /// Gyroid surface:  `sin x cos y + sin y cos z + sin z cos x = iso`  
-    /// (`period` rescales the spatial frequency; larger => slower repeat)
+    /// Gyroid surface:  `sin x cos y + sin y cos z + sin z cos x = iso`
+    /// after scaling coordinates by `2π / period`.
+    ///
+    /// `period` is a spatial wavelength in model units; larger values repeat
+    /// more slowly.
     /// **Mathematical Foundation**: Gyroid is a triply periodic minimal surface with zero mean curvature.
     /// **Optimization**: Pre-compute trigonometric values for better performance.
     pub fn gyroid(
@@ -49,13 +52,13 @@ impl<M: Clone + Debug + Send + Sync> Mesh<M> {
         metadata: M,
     ) -> Mesh<M> {
         let res = (resolution.max(2), resolution.max(2), resolution.max(2));
-        let period_inv = 1.0 / period;
+        let scale = std::f64::consts::TAU as Real / period;
         self.tpms_from_sdf(
             move |p: &Point3<Real>| {
                 // Pre-compute scaled coordinates for efficiency
-                let x_scaled = p.x * period_inv;
-                let y_scaled = p.y * period_inv;
-                let z_scaled = p.z * period_inv;
+                let x_scaled = p.x * scale;
+                let y_scaled = p.y * scale;
+                let z_scaled = p.z * scale;
 
                 // Pre-compute trigonometric values to avoid redundant calculations
                 let (sin_x, cos_x) = x_scaled.sin_cos();
@@ -73,6 +76,7 @@ impl<M: Clone + Debug + Send + Sync> Mesh<M> {
     }
 
     /// Schwarz‑P surface:  `cos x + cos y + cos z = iso`  (default iso = 0)
+    /// after scaling coordinates by `2π / period`.
     /// **Mathematical Foundation**: Schwarz P-surface has constant mean curvature and cubic symmetry.
     /// **Optimization**: Use direct cosine computation for this simpler surface equation.
     pub fn schwarz_p(
@@ -83,13 +87,13 @@ impl<M: Clone + Debug + Send + Sync> Mesh<M> {
         metadata: M,
     ) -> Mesh<M> {
         let res = (resolution.max(2), resolution.max(2), resolution.max(2));
-        let period_inv = 1.0 / period;
+        let scale = std::f64::consts::TAU as Real / period;
         self.tpms_from_sdf(
             move |p: &Point3<Real>| {
                 // Pre-compute scaled coordinates
-                let x_scaled = p.x * period_inv;
-                let y_scaled = p.y * period_inv;
-                let z_scaled = p.z * period_inv;
+                let x_scaled = p.x * scale;
+                let y_scaled = p.y * scale;
+                let z_scaled = p.z * scale;
 
                 // **Mathematical Formula**: Schwarz P-surface equation
                 // P(x,y,z) = cos(x) + cos(y) + cos(z)
@@ -102,6 +106,7 @@ impl<M: Clone + Debug + Send + Sync> Mesh<M> {
     }
 
     /// Schwarz‑D (Diamond) surface:  `sin x sin y sin z + sin x cos y cos z + ... = iso`
+    /// after scaling coordinates by `2π / period`.
     /// **Mathematical Foundation**: Diamond surface exhibits tetrahedral symmetry and is self-intersecting.
     /// **Optimization**: Pre-compute all trigonometric values for maximum efficiency.
     pub fn schwarz_d(
@@ -112,13 +117,13 @@ impl<M: Clone + Debug + Send + Sync> Mesh<M> {
         metadata: M,
     ) -> Mesh<M> {
         let res = (resolution.max(2), resolution.max(2), resolution.max(2));
-        let period_inv = 1.0 / period;
+        let scale = std::f64::consts::TAU as Real / period;
         self.tpms_from_sdf(
             move |p: &Point3<Real>| {
                 // Pre-compute scaled coordinates
-                let x_scaled = p.x * period_inv;
-                let y_scaled = p.y * period_inv;
-                let z_scaled = p.z * period_inv;
+                let x_scaled = p.x * scale;
+                let y_scaled = p.y * scale;
+                let z_scaled = p.z * scale;
 
                 // Pre-compute all trigonometric values once
                 let (sin_x, cos_x) = x_scaled.sin_cos();

tests/sdf_tpms_diagnostics.rs

@@ -91,20 +91,23 @@ fn assert_sdf_diagnostics_consistent(mesh: &Mesh<&'static str>, diagnostics: &Sd
 }
 
 fn gyroid_value(point: &Point3<Real>, period: Real) -> Real {
-    let x = point.x / period;
-    let y = point.y / period;
-    let z = point.z / period;
+    let scale = std::f64::consts::TAU as Real / period;
+    let x = point.x * scale;
+    let y = point.y * scale;
+    let z = point.z * scale;
     x.sin() * y.cos() + y.sin() * z.cos() + z.sin() * x.cos()
 }
 
 fn schwarz_p_value(point: &Point3<Real>, period: Real) -> Real {
-    (point.x / period).cos() + (point.y / period).cos() + (point.z / period).cos()
+    let scale = std::f64::consts::TAU as Real / period;
+    (point.x * scale).cos() + (point.y * scale).cos() + (point.z * scale).cos()
 }
 
 fn schwarz_d_value(point: &Point3<Real>, period: Real) -> Real {
-    let (sx, cx) = (point.x / period).sin_cos();
-    let (sy, cy) = (point.y / period).sin_cos();
-    let (sz, cz) = (point.z / period).sin_cos();
+    let scale = std::f64::consts::TAU as Real / period;
+    let (sx, cx) = (point.x * scale).sin_cos();
+    let (sy, cy) = (point.y * scale).sin_cos();
+    let (sz, cz) = (point.z * scale).sin_cos();
     sx * sy * sz + sx * cy * cz + cx * sy * cz + cx * cy * sz
 }
 
@@ -345,3 +348,42 @@ fn closed_sdf_sphere_has_no_boundary_edges_or_degenerate_triangles() {
         "sphere SDF emitted degenerate triangles: {diagnostics:#?}"
     );
 }
+
+#[test]
+fn readme_sdf_examples_mesh_non_empty_surfaces() {
+    let (sphere, sphere_diagnostics) = Mesh::<&'static str>::sdf_with_diagnostics(
+        |p| p.coords.norm() - 0.75,
+        (20, 20, 20),
+        Point3::new(-1.1, -1.1, -1.1),
+        Point3::new(1.1, 1.1, 1.1),
+        0.0,
+        "readme_sdf",
+    );
+    assert_sdf_diagnostics_consistent(&sphere, &sphere_diagnostics);
+    assert_mesh_vertices_finite(&sphere);
+    assert_sdf_mesh_is_triangular(&sphere);
+    assert!(
+        sphere_diagnostics.emitted_triangle_count > 0,
+        "README SDF sphere emitted no triangles: {sphere_diagnostics:#?}"
+    );
+    assert_eq!(
+        boundary_edge_count(&sphere),
+        0,
+        "README SDF sphere should be closed: {sphere_diagnostics:#?}"
+    );
+
+    let box_mesh = Mesh::<&'static str>::cube(2.0, "tpms");
+    for (name, mesh) in [
+        ("gyroid", box_mesh.gyroid(20, 2.0, 0.0, "gyroid")),
+        ("schwarz_p", box_mesh.schwarz_p(20, 2.0, 0.0, "schwarz_p")),
+        ("schwarz_d", box_mesh.schwarz_d(20, 2.0, 0.0, "schwarz_d")),
+    ] {
+        assert_mesh_vertices_finite(&mesh);
+        assert_sdf_mesh_is_triangular(&mesh);
+        assert!(
+            mesh.polygons.len() > 100,
+            "{name} README TPMS example emitted too few triangles: {}",
+            mesh.polygons.len()
+        );
+    }
+}