Add capped TPMS solid meshing

Author: timschmidt

examples/readme_renders.rs

@@ -274,9 +274,9 @@ fn render_readme_meshes() {
     );
 
     let tpms_box = Mesh::<()>::cube(2.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("gyroid", &tpms_box.gyroid_solid(24, 2.0, 0.0, 0.18, ()));
+    render_mesh("schwarz_p", &tpms_box.schwarz_p_solid(24, 2.0, 0.0, 0.18, ()));
+    render_mesh("schwarz_d", &tpms_box.schwarz_d_solid(24, 2.0, 0.0, 0.18, ()));
     render_mesh(
         "spur_gear_involute",
         &Mesh::<()>::spur_gear_involute(0.18, 22, 20.0, 0.0, 0.0, 8, 0.35, ()),

readme.md

@@ -239,9 +239,9 @@ If either radius is within EPSILON of 0.0, a cone terminating at a point is cons
 - <img src="docs/metaballs_3d.png" width="128"/> **`Mesh::metaballs(balls: &[MetaBall], resolution: (usize, usize, usize), iso_value: Real, padding: Real, metadata: Option<S>)`**
 - <img src="docs/sdf.png" width="128"/> **`Mesh::sdf<F>(sdf: F, resolution: (usize, usize, usize), min_pt: Point3, max_pt: Point3, iso_value: Real, metadata: Option<S>)`** - Return a CSG created by meshing a signed distance field within a bounding box
 - <img src="docs/mesh_arrow.png" width="128"/> **`Mesh::arrow(start: Point3, direction: Vector3, segments: usize, orientation: bool, metadata: Option<S>)`** - Create an arrow at start, pointing along direction
-- <img src="docs/gyroid.png" width="128"/> **`Mesh::gyroid(resolution: usize, period: Real, iso_value: Real, metadata: Option<S>)`** - Generate a Triply Periodic Minimal Surface (Gyroid) inside the volume of `self`
-- <img src="docs/schwarz_p.png" width="128"/> **`Mesh::schwarz_p(resolution: usize, period: Real, iso_value: Real, metadata: Option<S>)`** - Generate a Triply Periodic Minimal Surface (Schwarz P) inside the volume of `self`
-- <img src="docs/schwarz_d.png" width="128"/> **`Mesh::schwarz_d(resolution: usize, period: Real, iso_value: Real, metadata: Option<S>)`** - Generate a Triply Periodic Minimal Surface (Schwarz D) inside the volume of `self`
+- <img src="docs/gyroid.png" width="128"/> **`Mesh::gyroid_solid(resolution: usize, period: Real, iso_value: Real, thickness: Real, metadata: Option<S>)`** - Generate a capped, finite-thickness Gyroid solid inside the bounding box of `self`
+- <img src="docs/schwarz_p.png" width="128"/> **`Mesh::schwarz_p_solid(resolution: usize, period: Real, iso_value: Real, thickness: Real, metadata: Option<S>)`** - Generate a capped, finite-thickness Schwarz P solid inside the bounding box of `self`
+- <img src="docs/schwarz_d.png" width="128"/> **`Mesh::schwarz_d_solid(resolution: usize, period: Real, iso_value: Real, thickness: Real, metadata: Option<S>)`** - Generate a capped, finite-thickness Schwarz D solid inside the bounding box of `self`
 - <img src="docs/spur_gear_involute.png" width="128"/> **`Mesh::spur_gear_involute(module: Real, teeth: usize, pressure_angle_deg: Real, clearance: Real, backlash: Real, segments_per_flank: usize, thickness: Real, helix_angle_deg: Real, slices: usize, metadata: Option<S>,)`** - Generate an involute spur gear
 - **`Mesh::helical_involute_gear(module_: Real, teeth: usize, pressure_angle_deg: Real, clearance: Real, backlash: Real, segments_per_flank: usize, thickness: Real, helix_angle_deg: Real, slices: usize, metadata: Option<S>)`** - under construction
 

src/mesh/tpms.rs

@@ -35,6 +35,54 @@ impl<M: Clone + Debug + Send + Sync> Mesh<M> {
         Mesh::sdf(sdf_fn, resolution, min_pt, max_pt, iso_value, metadata)
     }
 
+    /// Build a capped, finite-thickness TPMS solid inside `self`'s bounding box.
+    ///
+    /// The implicit solid is:
+    ///
+    /// `max(abs(f(p) - iso_value) - thickness / 2, box_sdf(p)) <= 0`
+    ///
+    /// This creates a wall around the TPMS sheet and caps it where it meets the
+    /// bounding box. That makes a closed mesh suitable for solid workflows,
+    /// unlike the raw zero-level TPMS sheet.
+    #[inline]
+    fn tpms_solid_from_sdf<F>(
+        &self,
+        sdf_fn: F,
+        resolution: (usize, usize, usize),
+        iso_value: Real,
+        thickness: Real,
+        metadata: M,
+    ) -> Mesh<M>
+    where
+        F: Fn(&Point3<Real>) -> Real + Send + Sync,
+    {
+        if !thickness.is_finite() || thickness <= 0.0 {
+            return Mesh::empty(metadata);
+        }
+
+        let aabb = self.bounding_box();
+        let min_pt = aabb.mins;
+        let max_pt = aabb.maxs;
+        let half_thickness = thickness * 0.5;
+        let step = max_axis_step(&min_pt, &max_pt, resolution);
+        let padding = step.max(thickness);
+        let sample_min = Point3::from(min_pt.coords - nalgebra::Vector3::repeat(padding));
+        let sample_max = Point3::from(max_pt.coords + nalgebra::Vector3::repeat(padding));
+
+        Mesh::sdf(
+            move |p: &Point3<Real>| {
+                let sheet = (sdf_fn(p) - iso_value).abs() - half_thickness;
+                let bounds = axis_aligned_box_sdf(p, &min_pt, &max_pt);
+                sheet.max(bounds)
+            },
+            resolution,
+            sample_min,
+            sample_max,
+            0.0,
+            metadata,
+        )
+    }
+
     // ------------  Specific minimal‑surface flavours  --------------------
 
     /// Gyroid surface:  `sin x cos y + sin y cos z + sin z cos x = iso`
@@ -75,6 +123,35 @@ impl<M: Clone + Debug + Send + Sync> Mesh<M> {
         )
     }
 
+    /// Generate a capped, finite-thickness gyroid solid inside `self`'s
+    /// bounding box.
+    pub fn gyroid_solid(
+        &self,
+        resolution: usize,
+        period: Real,
+        iso_value: Real,
+        thickness: Real,
+        metadata: M,
+    ) -> Mesh<M> {
+        let res = (resolution.max(2), resolution.max(2), resolution.max(2));
+        let scale = std::f64::consts::TAU as Real / period;
+        self.tpms_solid_from_sdf(
+            move |p: &Point3<Real>| {
+                let x_scaled = p.x * scale;
+                let y_scaled = p.y * scale;
+                let z_scaled = p.z * scale;
+                let (sin_x, cos_x) = x_scaled.sin_cos();
+                let (sin_y, cos_y) = y_scaled.sin_cos();
+                let (sin_z, cos_z) = z_scaled.sin_cos();
+                (sin_x * cos_y) + (sin_y * cos_z) + (sin_z * cos_x)
+            },
+            res,
+            iso_value,
+            thickness,
+            metadata,
+        )
+    }
+
     /// 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.
@@ -105,6 +182,32 @@ impl<M: Clone + Debug + Send + Sync> Mesh<M> {
         )
     }
 
+    /// Generate a capped, finite-thickness Schwarz-P solid inside `self`'s
+    /// bounding box.
+    pub fn schwarz_p_solid(
+        &self,
+        resolution: usize,
+        period: Real,
+        iso_value: Real,
+        thickness: Real,
+        metadata: M,
+    ) -> Mesh<M> {
+        let res = (resolution.max(2), resolution.max(2), resolution.max(2));
+        let scale = std::f64::consts::TAU as Real / period;
+        self.tpms_solid_from_sdf(
+            move |p: &Point3<Real>| {
+                let x_scaled = p.x * scale;
+                let y_scaled = p.y * scale;
+                let z_scaled = p.z * scale;
+                x_scaled.cos() + y_scaled.cos() + z_scaled.cos()
+            },
+            res,
+            iso_value,
+            thickness,
+            metadata,
+        )
+    }
+
     /// 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.
@@ -142,4 +245,57 @@ impl<M: Clone + Debug + Send + Sync> Mesh<M> {
             metadata,
         )
     }
+
+    /// Generate a capped, finite-thickness Schwarz-D solid inside `self`'s
+    /// bounding box.
+    pub fn schwarz_d_solid(
+        &self,
+        resolution: usize,
+        period: Real,
+        iso_value: Real,
+        thickness: Real,
+        metadata: M,
+    ) -> Mesh<M> {
+        let res = (resolution.max(2), resolution.max(2), resolution.max(2));
+        let scale = std::f64::consts::TAU as Real / period;
+        self.tpms_solid_from_sdf(
+            move |p: &Point3<Real>| {
+                let x_scaled = p.x * scale;
+                let y_scaled = p.y * scale;
+                let z_scaled = p.z * scale;
+                let (sin_x, cos_x) = x_scaled.sin_cos();
+                let (sin_y, cos_y) = y_scaled.sin_cos();
+                let (sin_z, cos_z) = z_scaled.sin_cos();
+                (sin_x * sin_y * sin_z)
+                    + (sin_x * cos_y * cos_z)
+                    + (cos_x * sin_y * cos_z)
+                    + (cos_x * cos_y * sin_z)
+            },
+            res,
+            iso_value,
+            thickness,
+            metadata,
+        )
+    }
+}
+
+fn axis_aligned_box_sdf(p: &Point3<Real>, min: &Point3<Real>, max: &Point3<Real>) -> Real {
+    let center = Point3::from((min.coords + max.coords) * 0.5);
+    let half = (max.coords - min.coords) * 0.5;
+    let q = (p - center).abs() - half;
+    let outside = q.map(|component| component.max(0.0)).norm();
+    let inside = q.x.max(q.y).max(q.z).min(0.0);
+    outside + inside
+}
+
+fn max_axis_step(
+    min: &Point3<Real>,
+    max: &Point3<Real>,
+    resolution: (usize, usize, usize),
+) -> Real {
+    let span = max - min;
+    let dx = span.x.abs() / (resolution.0.max(2) as Real - 1.0);
+    let dy = span.y.abs() / (resolution.1.max(2) as Real - 1.0);
+    let dz = span.z.abs() / (resolution.2.max(2) as Real - 1.0);
+    dx.max(dy).max(dz)
 }

tests/sdf_tpms_diagnostics.rs

@@ -374,9 +374,15 @@ fn readme_sdf_examples_mesh_non_empty_surfaces() {
 
     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")),
+        ("gyroid", box_mesh.gyroid_solid(24, 2.0, 0.0, 0.18, "gyroid")),
+        (
+            "schwarz_p",
+            box_mesh.schwarz_p_solid(24, 2.0, 0.0, 0.18, "schwarz_p"),
+        ),
+        (
+            "schwarz_d",
+            box_mesh.schwarz_d_solid(24, 2.0, 0.0, 0.18, "schwarz_d"),
+        ),
     ] {
         assert_mesh_vertices_finite(&mesh);
         assert_sdf_mesh_is_triangular(&mesh);
@@ -385,5 +391,58 @@ fn readme_sdf_examples_mesh_non_empty_surfaces() {
             "{name} README TPMS example emitted too few triangles: {}",
             mesh.polygons.len()
         );
+        assert_eq!(
+            boundary_edge_count(&mesh),
+            0,
+            "{name} README TPMS solid should be capped and closed"
+        );
+    }
+}
+
+#[test]
+fn tpms_solid_helpers_emit_closed_capped_meshes() {
+    let cube = Mesh::<&'static str>::cube(2.0, "solid");
+    for (name, mesh) in [
+        ("gyroid", cube.gyroid_solid(22, 2.0, 0.0, 0.2, "gyroid")),
+        (
+            "schwarz_p",
+            cube.schwarz_p_solid(22, 2.0, 0.0, 0.2, "schwarz_p"),
+        ),
+        (
+            "schwarz_d",
+            cube.schwarz_d_solid(22, 2.0, 0.0, 0.2, "schwarz_d"),
+        ),
+    ] {
+        assert_mesh_vertices_finite(&mesh);
+        assert_sdf_mesh_is_triangular(&mesh);
+        assert!(
+            mesh.polygons.len() > 100,
+            "{name} solid emitted too few triangles: {}",
+            mesh.polygons.len()
+        );
+        assert_eq!(
+            boundary_edge_count(&mesh),
+            0,
+            "{name} solid should not have open boundary edges"
+        );
+        assert!(
+            mesh.polygons
+                .iter()
+                .all(|poly| triangle_area2(poly) > Real::EPSILON),
+            "{name} solid emitted degenerate triangles"
+        );
+    }
+}
+
+#[test]
+fn tpms_solid_helpers_reject_non_positive_thickness() {
+    let cube = Mesh::<&'static str>::cube(2.0, "solid");
+    for thickness in [0.0, -0.1, Real::NAN, Real::INFINITY] {
+        assert!(
+            cube.gyroid_solid(12, 2.0, 0.0, thickness, "gyroid")
+                .polygons
+                .is_empty(),
+            "invalid thickness {thickness:?} should return an empty gyroid solid"
+        );
     }
 }