meshers 0.1.0__tar.gz → 0.2.0__tar.gz

{meshers-0.1.0 → meshers-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshers
-Version: 0.1.0
+Version: 0.2.0
 Requires-Dist: numpy>=1.23
 Requires-Dist: h5py>=3.8 ; extra == 'io'
 Requires-Dist: pytest>=8 ; extra == 'test'
@@ -18,7 +18,7 @@ Project-URL: Documentation, https://github.com/kmarchais/meshers/tree/main/docs/
 Project-URL: Issues, https://github.com/kmarchais/meshers/issues
 Project-URL: Repository, https://github.com/kmarchais/meshers
 
-# Meshers Python 0.1.0
+# Meshers Python 0.2.0
 
 In-process CPU float64 meshing of bounded implicit solids. No subprocess or intermediate mesh file is needed.
 
@@ -70,8 +70,9 @@ See the [graded example](https://github.com/kmarchais/meshers/blob/main/crates/m
 - Boundary tags: 0 implicit, 1/2 x-/x+, 3/4 y-/y+, 5/6 z-/z+.
 - Per-axis periodic node pairs plus geometry and quality diagnostics.
 - VTKHDF volume or `surface=True`, periodic master IDs and physical shift vectors.
-  Volume files include `Volume` and `MMGQuality`, computed using the MMG formula
-  in NumPy, not by calling mmgpy.
+  Linear volume files include `Volume` and `MMGQuality`. For Tet10, `Volume`
+  integrates the curved mapping, while `CornerVolume` and `CornerMMGQuality`
+  describe the linear parent. Quality is computed without calling mmgpy.
 - Invalid options raise `ValueError`; failed meshing raises `MeshingError`.
   Callback exceptions are preserved. `KeyboardInterrupt` is propagated.
 - Pass `cancel=CancellationToken()` and call `token.cancel()` from another thread

{meshers-0.1.0/meshers-python → meshers-0.2.0}/README.md

@@ -1,4 +1,4 @@
-# Meshers Python 0.1.0
+# Meshers Python 0.2.0
 
 In-process CPU float64 meshing of bounded implicit solids. No subprocess or intermediate mesh file is needed.
 
@@ -50,8 +50,9 @@ See the [graded example](https://github.com/kmarchais/meshers/blob/main/crates/m
 - Boundary tags: 0 implicit, 1/2 x-/x+, 3/4 y-/y+, 5/6 z-/z+.
 - Per-axis periodic node pairs plus geometry and quality diagnostics.
 - VTKHDF volume or `surface=True`, periodic master IDs and physical shift vectors.
-  Volume files include `Volume` and `MMGQuality`, computed using the MMG formula
-  in NumPy, not by calling mmgpy.
+  Linear volume files include `Volume` and `MMGQuality`. For Tet10, `Volume`
+  integrates the curved mapping, while `CornerVolume` and `CornerMMGQuality`
+  describe the linear parent. Quality is computed without calling mmgpy.
 - Invalid options raise `ValueError`; failed meshing raises `MeshingError`.
   Callback exceptions are preserved. `KeyboardInterrupt` is propagated.
 - Pass `cancel=CancellationToken()` and call `token.cancel()` from another thread

{meshers-0.1.0/meshers-python → meshers-0.2.0}/THIRDPARTY.json

@@ -531,7 +531,7 @@
     },
     {
       "package_name": "meshers-core",
-      "package_version": "0.1.0",
+      "package_version": "0.2.0",
       "repository": "https://github.com/kmarchais/meshers",
       "license": "MIT",
       "licenses": [

{meshers-0.1.0 → meshers-0.2.0}/meshers-core/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "meshers-core"
 description = "CPU tetrahedral meshing of implicit solids and constrained intersections"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2024"
 rust-version = "1.95.0"
 license = "MIT"
@@ -15,3 +15,11 @@ serde_json = "1"
 
 [lints.rust]
 unsafe_code = "forbid"
+
+[features]
+wide-constraints = []
+experimental-quads = []
+
+[[example]]
+name = "adapt_surface"
+required-features = ["experimental-quads"]

meshers-0.2.0/meshers-core/examples/adapt_gyroid.rs

@@ -0,0 +1,65 @@
+//! Periodic Gyroid sheet adaptation with per-phase timing.
+//! cargo run --release --example adapt_gyroid -- 1e-3
+use meshers_core::implicit::{Options, Region, generate};
+use meshers_core::{Point, tet_adapt};
+
+fn main() {
+    let mut args = std::env::args().skip(1);
+    let tolerance: f64 = args.next().map_or(1e-3, |v| v.parse().unwrap());
+    let passes: usize = args.next().map_or(1, |v| v.parse().unwrap());
+    let iterations: usize = args.next().map_or(4, |v| v.parse().unwrap());
+    let cells: usize = args.next().map_or(24, |v| v.parse().unwrap());
+    let field = |p: Point| {
+        let t = std::f64::consts::TAU;
+        ((t * p[0]).sin() * (t * p[1]).cos()
+            + (t * p[1]).sin() * (t * p[2]).cos()
+            + (t * p[2]).sin() * (t * p[0]).cos())
+            / 0.55
+    };
+    let base = Options {
+        bounds: [[-0.5; 3], [0.5; 3]],
+        cells: [cells; 3],
+        region: Region::Band {
+            lower: -1.,
+            upper: 1.,
+        },
+        periodic: [true; 3],
+        geometry_tolerance: tolerance,
+        optimize_passes: passes,
+        ..Default::default()
+    };
+    let start = std::time::Instant::now();
+    let out = generate(
+        &field,
+        Options {
+            adapt: Some(tet_adapt::Options {
+                tolerance,
+                min_length: tolerance,
+                max_length: 0.1,
+                iterations,
+                ..Default::default()
+            }),
+            ..base
+        },
+    )
+    .unwrap();
+    let total = start.elapsed().as_secs_f64();
+    let stats = out.diagnostics.adapt.unwrap();
+    println!(
+        "tets {} total {total:.2}s q_min {:.3}",
+        out.mesh.tets.len(),
+        out.diagnostics.minimum_mmg_quality
+    );
+    let names = [
+        "sizing",
+        "split",
+        "collapse",
+        "edge removal",
+        "face swap",
+        "relocate",
+        "enforce+unfold",
+    ];
+    for (name, s) in names.iter().zip(stats.seconds) {
+        println!("  {name:15} {s:.3}s");
+    }
+}

meshers-0.2.0/meshers-core/examples/adapt_surface.rs

@@ -0,0 +1,54 @@
+//! Adaptive Gyroid sheet surface with per-phase timing.
+//! cargo run --release --features experimental-quads --example adapt_surface -- 1e-3 32 8
+use meshers_core::{Point, quads::Band, remesh, triangles};
+
+fn main() {
+    let mut args = std::env::args().skip(1);
+    let tolerance: f64 = args.next().map_or(1e-3, |v| v.parse().unwrap());
+    let cells: usize = args.next().map_or(32, |v| v.parse().unwrap());
+    let iterations: usize = args.next().map_or(8, |v| v.parse().unwrap());
+    let field = |p: Point| {
+        let t = std::f64::consts::TAU;
+        ((t * p[0]).sin() * (t * p[1]).cos()
+            + (t * p[1]).sin() * (t * p[2]).cos()
+            + (t * p[2]).sin() * (t * p[0]).cos())
+            / 0.55
+    };
+    let band = Band {
+        field: &field,
+        bounds: [[-0.5; 3], [0.5; 3]],
+        levels: [-1., 1.],
+    };
+    let start = std::time::Instant::now();
+    let mut mesh = triangles::extract(&band, cells).unwrap();
+    let extraction = start.elapsed().as_secs_f64();
+    let extracted = mesh.faces.len();
+    let options = remesh::Options {
+        tolerance,
+        min_length: tolerance / 2.,
+        max_length: 0.25,
+        gradation: 0.3,
+        iterations,
+        balanced: std::env::args().any(|a| a == "balanced"),
+        fast: std::env::args().any(|a| a == "fast"),
+    };
+    let stats = remesh::adapt(&mut mesh, &band, &options).unwrap();
+    let total = start.elapsed().as_secs_f64();
+    println!(
+        "extracted {extracted} -> {} triangles, max error {:.2e}, total {total:.3}s",
+        mesh.faces.len(),
+        stats.maximum_error
+    );
+    println!("  {:15} {extraction:.3}s", "extraction");
+    let names = [
+        "sizing",
+        "split",
+        "collapse",
+        "flip",
+        "relax",
+        "enforce+validate",
+    ];
+    for (name, s) in names.iter().zip(stats.seconds) {
+        println!("  {name:15} {s:.3}s");
+    }
+}

{meshers-0.1.0 → meshers-0.2.0}/meshers-core/examples/curved_intersection.rs

@@ -11,7 +11,7 @@ struct Export<'a> {
     parameters: &'a [Point],
     tetrahedra: &'a [[usize; 4]],
     surface: &'a [[usize; 3]],
-    constraints: &'a [u8],
+    constraints: &'a [meshers_core::implicit::intersection::ConstraintMask],
     seconds: f64,
     minimum_quality: f64,
     elements_below_quality_01: usize,

{meshers-0.1.0 → meshers-0.2.0}/meshers-core/src/adaptive.rs

@@ -5,6 +5,128 @@ type Edge = [usize; 2];
 fn edge(a: usize, b: usize) -> Edge {
     if a < b { [a, b] } else { [b, a] }
 }
+
+/// One nested pass over disjoint interior edge stars, ranked by squared length.
+/// Boundary coordinates and triangles remain unchanged. The node budget is an upper limit.
+pub(crate) fn refine_interior(
+    mesh: &mut Mesh,
+    node_budget: usize,
+    minimum_quality: f64,
+    max_tets: usize,
+    geometry: &impl crate::geometry::Geometry,
+) -> Result<usize, String> {
+    if node_budget == 0 || mesh.tets.is_empty() {
+        return Ok(0);
+    }
+    geometry.check()?;
+    let boundary_edges: HashSet<_> = mesh
+        .surface
+        .iter()
+        .flat_map(|f| [edge(f[0], f[1]), edge(f[1], f[2]), edge(f[2], f[0])])
+        .collect();
+    let mut incidence = Vec::with_capacity(mesh.tets.len() * 6);
+    for (ci, t) in mesh.tets.iter().enumerate() {
+        for i in 0..4 {
+            for j in i + 1..4 {
+                incidence.push((edge(t[i], t[j]), ci));
+            }
+        }
+    }
+    incidence.sort_unstable();
+    geometry.check()?;
+    let [lo, hi] = geometry.bounds();
+    let midpoint = |e: Edge| {
+        std::array::from_fn::<_, 3, _>(|a| (mesh.points[e[0]][a] + mesh.points[e[1]][a]) * 0.5)
+    };
+    let mut candidates = Vec::new();
+    let mut start = 0;
+    while start < incidence.len() {
+        let e = incidence[start].0;
+        let mut end = start + 1;
+        while end < incidence.len() && incidence[end].0 == e {
+            end += 1;
+        }
+        let p = midpoint(e);
+        let delta = sub(mesh.points[e[0]], mesh.points[e[1]]);
+        let length2 = dot(delta, delta);
+        if !boundary_edges.contains(&e)
+            && (0..3).all(|a| {
+                p[a] > lo[a] + (hi[a] - lo[a]) * 1e-9 && p[a] < hi[a] - (hi[a] - lo[a]) * 1e-9
+            })
+            && length2 > 1e-20
+        {
+            candidates.push((e, start, end, length2));
+        }
+        start = end;
+    }
+    candidates.sort_unstable_by(|a, b| b.3.total_cmp(&a.3).then(a.0.cmp(&b.0)));
+    let mut removed = vec![false; mesh.tets.len()];
+    let mut additions = Vec::new();
+    let original_nodes = mesh.points.len();
+    let mut output_tets = mesh.tets.len();
+    for (index, (e, start, end, _)) in candidates.into_iter().enumerate() {
+        if mesh.points.len() - original_nodes >= node_budget {
+            break;
+        }
+        if index % 1024 == 0 {
+            geometry.check()?;
+        }
+        let star = &incidence[start..end];
+        if star.iter().any(|&(_, ci)| removed[ci])
+            || output_tets.saturating_add(star.len()) > max_tets
+        {
+            continue;
+        }
+        let p = std::array::from_fn(|a| (mesh.points[e[0]][a] + mesh.points[e[1]][a]) * 0.5);
+        let id = mesh.points.len();
+        let mut children = Vec::with_capacity(star.len() * 2);
+        for &(_, ci) in star {
+            for endpoint in e {
+                let mut t = mesh.tets[ci];
+                *t.iter_mut().find(|v| **v == endpoint).unwrap() = id;
+                let xyz = t.map(|i| if i == id { p } else { mesh.points[i] });
+                let det = determinant(xyz);
+                let edge_sum: f64 = (0..4)
+                    .flat_map(|i| {
+                        (i + 1..4).map(move |j| {
+                            let delta = sub(xyz[i], xyz[j]);
+                            dot(delta, delta)
+                        })
+                    })
+                    .sum();
+                let q = (432. * det * det / edge_sum.powi(3)).sqrt();
+                if !det.is_finite() || det <= 0. || !q.is_finite() || q < minimum_quality {
+                    children.clear();
+                    break;
+                }
+                children.push(t);
+            }
+            if children.is_empty() {
+                break;
+            }
+        }
+        if children.len() == star.len() * 2 {
+            mesh.points.push(p);
+            for &(_, ci) in star {
+                removed[ci] = true;
+            }
+            additions.extend(children);
+            output_tets += star.len();
+        }
+    }
+    mesh.tets = mesh
+        .tets
+        .iter()
+        .enumerate()
+        .filter_map(|(i, &t)| (!removed[i]).then_some(t))
+        .chain(additions)
+        .collect();
+    geometry.check()?;
+    if mesh.surface != boundary(&mesh.tets)? {
+        return Err("interior refinement changed the oriented boundary".into());
+    }
+    Ok(mesh.points.len() - original_nodes)
+}
 fn orbit(mesh: &Mesh, e: Edge, geometry: &impl crate::geometry::Geometry) -> [[i64; 3]; 2] {
     let mut k = e.map(|i| geometry.rank(mesh.points[i]));
     k.sort_unstable();
@@ -199,7 +321,9 @@ pub(crate) fn refine_for(
                         let mut t = mesh.tets[ci];
                         *t.iter_mut().find(|v| **v == endpoint).unwrap() = id;
                         let xyz = t.map(|i| if i == id { p } else { mesh.points[i] });
-                        if determinant(xyz) <= 0. || quality(xyz).powf(1.5) < 0.25 {
+                        if determinant(xyz) <= 0.
+                            || quality(xyz).powf(1.5) < geometry.refinement_quality_floor()
+                        {
                             valid = false;
                             break;
                         }
@@ -313,6 +437,27 @@ fn update_boundary(
 mod tests {
     use super::*;
     #[test]
+    fn interior_quality_rejection_leaves_mesh_unchanged() {
+        let mut mesh = crate::implicit::generate(
+            &|_| -1.,
+            crate::implicit::Options {
+                cells: [4; 3],
+                optimize_passes: 0,
+                ..Default::default()
+            },
+        )
+        .unwrap()
+        .mesh;
+        let points = mesh.points.clone();
+        let tets = mesh.tets.clone();
+        assert_eq!(
+            refine_interior(&mut mesh, 20, 1., 10000, &crate::geometry::Legacy).unwrap(),
+            0
+        );
+        assert_eq!(mesh.points, points);
+        assert_eq!(mesh.tets, tets);
+    }
+    #[test]
     fn incremental_boundary_matches_full_edge_bisection() {
         let old = [[0, 1, 2, 3]];
         let new = [[0, 4, 2, 3], [4, 1, 2, 3]];

{meshers-0.1.0 → meshers-0.2.0}/meshers-core/src/geometry.rs

@@ -1,6 +1,25 @@
 //! Internal geometry context shared by specialized and generic algorithms.
 use crate::Point;
 pub(crate) trait Geometry: Sync {
+    fn constraints(&self) -> Option<&[&dyn crate::implicit::ScalarField]> {
+        None
+    }
+    fn halfspaces(&self) -> Option<&[[f64; 4]]> {
+        None
+    }
+    fn halfspace_regions(&self) -> Option<&[crate::implicit::intersection::ConstraintMask]> {
+        None
+    }
+    /// Physical reference length for dimensionless optimizer penalties.
+    fn optimizer_length(&self) -> f64 {
+        1.
+    }
+    fn refinement_quality_floor(&self) -> f64 {
+        0.25
+    }
+    fn minimum_quality(&self) -> f64 {
+        0.
+    }
     fn value(&self, p: Point) -> f64;
     fn batched(&self) -> bool {
         false
@@ -8,6 +27,9 @@ pub(crate) trait Geometry: Sync {
     fn values(&self, points: &[Point]) -> Vec<f64> {
         points.iter().map(|&p| self.value(p)).collect()
     }
+    fn target_lengths(&self, _points: &[Point]) -> Option<Vec<f64>> {
+        None
+    }
     fn gradients(&self, points: &[Point]) -> Vec<Point> {
         points.iter().map(|&p| self.gradient(p)).collect()
     }
@@ -20,6 +42,10 @@ pub(crate) trait Geometry: Sync {
     fn band(&self) -> bool {
         true
     }
+    /// Implicit pipelines preserve this limit while improving element quality.
+    fn geometry_tolerance(&self) -> Option<f64> {
+        None
+    }
     fn locked(&self, p: Point) -> [bool; 3] {
         let [lo, hi] = self.bounds();
         std::array::from_fn(|a| p[a] == lo[a] || p[a] == hi[a])

{meshers-0.1.0 → meshers-0.2.0}/meshers-core/src/implicit/intersection/repair.rs

@@ -1,10 +1,14 @@
 //! Conservative short-edge removal, preserving constraint strata and periodic orbits.
-use super::Output;
+use super::{MAX_CONSTRAINTS, Output};
 use crate::implicit::Options;
 use crate::{Point, Tet, determinant, quality};
 use std::collections::{BTreeMap, BTreeSet};
 
 type Simplex = Vec<usize>;
+#[cfg(feature = "wide-constraints")]
+type StratumMask = u64;
+#[cfg(not(feature = "wide-constraints"))]
+type StratumMask = u16;
 fn subsets(vertices: &[usize], out: &mut BTreeSet<Simplex>) {
     for bits in 1..(1 << vertices.len()) {
         let mut s: Vec<_> = vertices
@@ -16,7 +20,7 @@ fn subsets(vertices: &[usize], out: &mut BTreeSet<Simplex>) {
         out.insert(s);
     }
 }
-fn link_ok(a: usize, b: usize, ids: &BTreeSet<usize>, tets: &[Tet], masks: &[u16]) -> bool {
+fn link_ok(a: usize, b: usize, ids: &BTreeSet<usize>, tets: &[Tet], masks: &[StratumMask]) -> bool {
     let mut la = BTreeSet::new();
     let mut lb = BTreeSet::new();
     let mut le = BTreeSet::new();
@@ -98,7 +102,7 @@ fn link_ok(a: usize, b: usize, ids: &BTreeSet<usize>, tets: &[Tet], masks: &[u16
 // A topologically valid solid collapse can still connect two separate rims.
 // Preserve the feature subcomplex too: no new labelled curve edge, no lost
 // curve edge except the collapsed one, and the 1D link condition on each rim.
-fn feature_link_ok(a: usize, b: usize, faces: &[[usize; 3]], masks: &[u16]) -> bool {
+fn feature_link_ok(a: usize, b: usize, faces: &[[usize; 3]], masks: &[StratumMask]) -> bool {
     let features = |faces: &[[usize; 3]]| {
         let mut edges = BTreeSet::new();
         for f in faces {
@@ -107,11 +111,11 @@ fn feature_link_ok(a: usize, b: usize, faces: &[[usize; 3]], masks: &[u16]) -> b
                 if common.count_ones() < 2 {
                     continue;
                 }
-                for x in 0..14 {
+                for x in 0..MAX_CONSTRAINTS + 6 {
                     if common & (1 << x) == 0 {
                         continue;
                     }
-                    for y in x + 1..14 {
+                    for y in x + 1..MAX_CONSTRAINTS + 6 {
                         let bits = (1 << x) | (1 << y);
                         if common & bits == bits {
                             edges.insert((bits, u.min(v), u.max(v)));
@@ -169,12 +173,12 @@ fn feature_link_ok(a: usize, b: usize, faces: &[[usize; 3]], masks: &[u16]) -> b
 fn q(points: &[Point], t: Tet) -> f64 {
     quality(t.map(|i| points[i])).powf(1.5)
 }
-fn cap(p: Point, o: &Options) -> u16 {
+fn cap(p: Point, o: &Options) -> StratumMask {
     (0..3).fold(0, |bits, a| {
         bits | if p[a] == o.bounds[0][a] {
-            1 << (8 + 2 * a)
+            1 << (MAX_CONSTRAINTS + 2 * a)
         } else if p[a] == o.bounds[1][a] {
-            1 << (9 + 2 * a)
+            1 << (MAX_CONSTRAINTS + 1 + 2 * a)
         } else {
             0
         }
@@ -214,7 +218,7 @@ pub(super) fn improve(output: &mut Output, o: &Options) -> Result<usize, String>
         .constraints
         .iter()
         .zip(&output.parameters)
-        .map(|(&m, &p)| u16::from(m) | cap(p, o))
+        .map(|(&m, &p)| StratumMask::from(m) | cap(p, o))
         .collect();
     let mut accepted = 0;
     for _ in 0..o.optimize_passes {
@@ -380,6 +384,7 @@ pub(super) fn smooth(
     o: &Options,
     fields: &[&dyn super::ScalarField],
     map: &impl Fn(Point) -> Point,
+    regions: Option<&[super::ConstraintMask]>,
 ) -> Result<usize, String> {
     let [lo, hi] = o.bounds;
     let h = (0..3)
@@ -468,7 +473,18 @@ pub(super) fn smooth(
             {
                 continue;
             }
-            if !active.is_empty() && fields.iter().any(|f| f.value(p) > 1e-9) {
+            let outside = |mask: super::ConstraintMask| {
+                fields
+                    .iter()
+                    .enumerate()
+                    .any(|(i, f)| mask & (1 << i) != 0 && f.value(p) > 1e-9)
+            };
+            if !active.is_empty()
+                && regions.map_or_else(
+                    || outside(super::ConstraintMask::MAX),
+                    |regions| regions.iter().all(|&mask| outside(mask)),
+                )
+            {
                 continue;
             }
             let parameters: Vec<Point> = group
@@ -719,4 +735,22 @@ mod tests {
         ];
         assert!(!feature_link_ok(0, 1, &faces, &masks));
     }
+    #[cfg(feature = "wide-constraints")]
+    #[test]
+    fn high_constraint_and_cap_bits_preserve_feature_links() {
+        let wall = 1 << 31;
+        let cap = 1 << (MAX_CONSTRAINTS + 5);
+        let masks = [wall | cap, wall | cap, wall | cap, wall | cap, wall, cap];
+        let faces = [
+            [2, 0, 4],
+            [2, 5, 0],
+            [0, 1, 4],
+            [0, 5, 1],
+            [1, 3, 4],
+            [1, 5, 3],
+        ];
+        assert!(feature_link_ok(0, 1, &faces, &masks));
+        let masks = [wall, wall | cap, wall | cap, wall, wall];
+        assert!(!feature_link_ok(0, 1, &[[0, 2, 3], [1, 3, 4]], &masks));
+    }
 }