use super::Lattice;
use crate::math::Vector3;
#[derive(Clone, Copy, Debug, Default)]
pub struct LatticeMetrics {
pub relative_density: f32,
pub porosity: f32,
pub open_porosity: f32,
pub closed_porosity: f32,
pub percolates: [bool; 3],
pub largest_void_fraction: f32,
pub part_volume: f32,
pub solid_volume: f32,
pub surface_area: f32,
pub wetted_area: f32,
pub specific_surface_area: f32,
pub surface_area_to_volume: f32,
pub pore_diameter: f32,
pub ligament_thickness: f32,
pub hydraulic_diameter: f32,
pub permeability: f32,
pub sample_spacing: f32,
pub wall_samples: f32,
}
impl<'a> Lattice<'a> {
pub fn metrics(&self) -> LatticeMetrics {
let base = self.resolution.min(16);
let per_cell = match self.wall_width() {
Some(width) if width > 0.0 => {
let cell = self.resolved_cell();
let widest = cell.x.max(cell.y).max(cell.z);
let needed = (3.0 * widest / width).ceil();
let needed = if needed.is_finite() && needed > 0.0 {
(needed as usize).min(256)
} else {
base
};
base.max(needed)
}
_ => base,
};
self.metrics_at(per_cell)
}
pub fn metrics_at(&self, samples_per_cell: usize) -> LatticeMetrics {
let geometry = self.build();
let (surface_area, wetted_area) = self.areas(&geometry);
let cell = self.resolved_cell();
let size = self.bounds.size();
let res = samples_per_cell.max(2) as f32;
let count =
|extent: f32, cell: f32| (((extent / cell.max(1e-6)) * res).ceil() as usize).max(2);
let mut dims = [
count(size.x, cell.x),
count(size.y, cell.y),
count(size.z, cell.z),
];
while dims[0].saturating_mul(dims[1]).saturating_mul(dims[2]) > self.max_samples {
let next = [
(dims[0] / 2).max(2),
(dims[1] / 2).max(2),
(dims[2] / 2).max(2),
];
if next == dims {
break;
}
dims = next;
}
let spacing = Vector3::new(
size.x / dims[0] as f32,
size.y / dims[1] as f32,
size.z / dims[2] as f32,
);
let sampler = self.sampler(cell, spacing, false);
let total = dims[0] * dims[1] * dims[2];
let states = crate::utils::parallel::par_map_range(total, |n| {
let i = n % dims[0];
let j = (n / dims[0]) % dims[1];
let k = n / (dims[0] * dims[1]);
let p = Vector3::new(
self.bounds.min.x + (i as f32 + 0.5) * spacing.x,
self.bounds.min.y + (j as f32 + 0.5) * spacing.y,
self.bounds.min.z + (k as f32 + 0.5) * spacing.z,
);
let cut = self.trim.as_deref().map(|t| t(p));
if cut.is_some_and(|c| c <= 0.0) {
0u8
} else if sampler.value_at(p, cut) > 0.0 {
2
} else {
1
}
});
let connectivity = void_connectivity(&states, dims);
let voxel = spacing.x * spacing.y * spacing.z;
let inside = states.iter().filter(|&&s| s > 0).count();
let part_volume = inside as f32 * voxel;
let relative_density = self.relative_density();
let solid_volume = part_volume * relative_density;
let porosity = 1.0 - relative_density;
let pore_diameter = 2.0
* max_inscribed(
&states,
dims,
spacing,
|s| s == 2 || s == 0, |s| s == 1,
);
let ligament_thickness =
2.0 * max_inscribed(&states, dims, spacing, |s| s != 2, |s| s == 2);
let void_volume = part_volume - solid_volume;
let specific_surface_area = if part_volume > 0.0 {
wetted_area / part_volume
} else {
0.0
};
let hydraulic_diameter = if wetted_area > 0.0 {
4.0 * void_volume / wetted_area
} else {
0.0
};
let permeability = if specific_surface_area > 0.0 {
porosity.powi(3) / (5.0 * specific_surface_area * specific_surface_area)
} else {
0.0
};
LatticeMetrics {
relative_density,
porosity,
open_porosity: porosity * connectivity.open_fraction,
closed_porosity: porosity * (1.0 - connectivity.open_fraction),
percolates: connectivity.percolates,
largest_void_fraction: connectivity.largest_fraction,
part_volume,
solid_volume,
surface_area,
wetted_area,
specific_surface_area,
surface_area_to_volume: if solid_volume > 0.0 {
wetted_area / solid_volume
} else {
0.0
},
pore_diameter,
ligament_thickness,
hydraulic_diameter,
permeability,
sample_spacing: spacing.x.max(spacing.y).max(spacing.z),
wall_samples: match self.wall_width() {
Some(width) => width / spacing.x.max(spacing.y).max(spacing.z),
None => f32::INFINITY,
},
}
}
fn areas(&self, geometry: &crate::core::BufferGeometry) -> (f32, f32) {
let Some(positions) = geometry.get_attribute("position") else {
return (0.0, 0.0);
};
let verts: Vec<Vector3> = positions
.array
.as_chunks::<3>()
.0
.iter()
.map(|c| Vector3::new(c[0], c[1], c[2]))
.collect();
let indices: Vec<usize> = match &geometry.index {
Some(index) => index.iter().map(|i| *i as usize).collect(),
None => (0..verts.len()).collect(),
};
let step = self.grid().0 .2;
let near = step.x.max(step.y).max(step.z);
let mut total = 0.0f32;
let mut wetted = 0.0f32;
for tri in indices.as_chunks::<3>().0 {
let (a, b, c) = (verts[tri[0]], verts[tri[1]], verts[tri[2]]);
let area = (b - a).cross(c - a).length() * 0.5;
if !area.is_finite() {
continue;
}
total += area;
let centroid = (a + b + c) * (1.0 / 3.0);
let mut boundary = self.box_distance(centroid);
if let Some(trim) = self.trim.as_deref() {
boundary = boundary.min(trim(centroid));
}
if boundary.abs() > near {
wetted += area;
}
}
(total, wetted)
}
fn box_distance(&self, p: Vector3) -> f32 {
let lo = self.bounds.min;
let hi = self.bounds.max;
(p.x - lo.x)
.min(hi.x - p.x)
.min(p.y - lo.y)
.min(hi.y - p.y)
.min(p.z - lo.z)
.min(hi.z - p.z)
}
}
struct Connectivity {
open_fraction: f32,
percolates: [bool; 3],
largest_fraction: f32,
}
fn void_connectivity(states: &[u8], dims: [usize; 3]) -> Connectivity {
let [nx, ny, nz] = dims;
let total = nx * ny * nz;
let mut label = vec![u32::MAX; total];
let mut stack: Vec<u32> = Vec::new();
let (mut void, mut open, mut largest) = (0usize, 0usize, 0usize);
let mut percolates = [false; 3];
let mut next = 0u32;
for seed in 0..total {
if states[seed] != 1 || label[seed] != u32::MAX {
continue;
}
label[seed] = next;
stack.push(seed as u32);
let mut size = 0usize;
let mut exterior_component = false;
let mut low = [false; 3];
let mut high = [false; 3];
while let Some(v) = stack.pop() {
let v = v as usize;
size += 1;
let at = [v % nx, (v / nx) % ny, v / (nx * ny)];
let mut exterior = false;
for axis in 0..3 {
for step in [-1i32, 1] {
let moved = at[axis] as i32 + step;
if moved < 0 || moved >= dims[axis] as i32 {
exterior = true;
continue;
}
let mut to = at;
to[axis] = moved as usize;
let index = (to[2] * ny + to[1]) * nx + to[0];
match states[index] {
0 => exterior = true,
1 if label[index] == u32::MAX => {
label[index] = next;
stack.push(index as u32);
}
_ => {}
}
}
}
if exterior {
exterior_component = true;
for axis in 0..3 {
let end = (dims[axis] / 10).max(1);
if at[axis] < end {
low[axis] = true;
}
if at[axis] + end >= dims[axis] {
high[axis] = true;
}
}
}
}
void += size;
if exterior_component {
open += size;
}
for axis in 0..3 {
percolates[axis] |= low[axis] && high[axis];
}
largest = largest.max(size);
next = next.wrapping_add(1);
}
if void == 0 {
return Connectivity {
open_fraction: 0.0,
percolates: [false; 3],
largest_fraction: 0.0,
};
}
Connectivity {
open_fraction: open as f32 / void as f32,
percolates,
largest_fraction: largest as f32 / void as f32,
}
}
fn max_inscribed(
states: &[u8],
dims: [usize; 3],
spacing: Vector3,
barrier: impl Fn(u8) -> bool,
interior: impl Fn(u8) -> bool,
) -> f32 {
let squared = squared_distance_transform(states, dims, spacing, barrier);
let mut best = 0.0f32;
for (n, &s) in states.iter().enumerate() {
if interior(s) {
best = best.max(squared[n]);
}
}
let half = (spacing.x + spacing.y + spacing.z) / 6.0;
(best.max(0.0).sqrt() - half).max(0.0)
}
fn squared_distance_transform(
states: &[u8],
dims: [usize; 3],
spacing: Vector3,
barrier: impl Fn(u8) -> bool,
) -> Vec<f32> {
const FAR: f32 = 1e20;
let [nx, ny, nz] = dims;
let mut d: Vec<f32> = states
.iter()
.map(|&s| if barrier(s) { 0.0 } else { FAR })
.collect();
let step = [spacing.x, spacing.y, spacing.z];
let stride = [1usize, nx, nx * ny];
let len = [nx, ny, nz];
let mut line = Vec::new();
let mut out = Vec::new();
for axis in 0..3 {
let n = len[axis];
line.resize(n, 0.0);
out.resize(n, 0.0);
let (outer_a, outer_b) = match axis {
0 => (ny, nz),
1 => (nx, nz),
_ => (nx, ny),
};
let (stride_a, stride_b) = match axis {
0 => (stride[1], stride[2]),
1 => (stride[0], stride[2]),
_ => (stride[0], stride[1]),
};
for b in 0..outer_b {
for a in 0..outer_a {
let base = a * stride_a + b * stride_b;
for i in 0..n {
line[i] = d[base + i * stride[axis]];
}
envelope(&line, &mut out, step[axis]);
for i in 0..n {
d[base + i * stride[axis]] = out[i];
}
}
}
}
d
}
fn envelope(f: &[f32], out: &mut [f32], spacing: f32) {
let n = f.len();
if n == 0 {
return;
}
let a = (spacing * spacing) as f64;
let mut hull = vec![0usize; n];
let mut split = vec![0.0f64; n + 1];
let mut k = 0usize;
hull[0] = 0;
split[0] = f64::NEG_INFINITY;
split[1] = f64::INFINITY;
for q in 1..n {
if !f[q].is_finite() {
continue;
}
loop {
let p = hull[k];
let s = ((f[q] as f64 + a * (q * q) as f64) - (f[p] as f64 + a * (p * p) as f64))
/ (2.0 * a * (q as f64 - p as f64));
if s <= split[k] {
if k == 0 {
k = 0;
hull[0] = q;
split[0] = f64::NEG_INFINITY;
split[1] = f64::INFINITY;
break;
}
k -= 1;
} else {
k += 1;
hull[k] = q;
split[k] = s;
split[k + 1] = f64::INFINITY;
break;
}
}
}
let mut k = 0usize;
for (x, o) in out.iter_mut().enumerate() {
while split[k + 1] < x as f64 {
k += 1;
}
let p = hull[k];
let dx = x as f64 - p as f64;
*o = (f[p] as f64 + a * dx * dx) as f32;
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::geometries::lattice::{LatticeKind, LatticeStyle, Strut, Tpms};
#[test]
fn distance_transform_matches_brute_force() {
let dims = [9usize, 7, 5];
let spacing = Vector3::new(1.0, 2.0, 0.5);
let mut states = vec![1u8; dims[0] * dims[1] * dims[2]];
for (n, s) in states.iter_mut().enumerate() {
if n % 17 == 0 {
*s = 2;
}
}
let got = squared_distance_transform(&states, dims, spacing, |s| s == 2);
for k in 0..dims[2] {
for j in 0..dims[1] {
for i in 0..dims[0] {
let mut want = f32::INFINITY;
for kk in 0..dims[2] {
for jj in 0..dims[1] {
for ii in 0..dims[0] {
if states[(kk * dims[1] + jj) * dims[0] + ii] != 2 {
continue;
}
let d = Vector3::new(
(i as f32 - ii as f32) * spacing.x,
(j as f32 - jj as f32) * spacing.y,
(k as f32 - kk as f32) * spacing.z,
);
want = want.min(d.length_sq());
}
}
}
let n = (k * dims[1] + j) * dims[0] + i;
assert!(
(got[n] - want).abs() < 1e-3 * want.max(1.0),
"{i},{j},{k}: {} vs {want}",
got[n]
);
}
}
}
}
#[test]
fn a_solid_block_has_no_pores_and_no_internal_area() {
let m = crate::geometries::lattice::Lattice::new(LatticeKind::Tpms(Tpms::Gyroid))
.size(Vector3::new(4.0, 4.0, 4.0))
.cells([2, 2, 2])
.style(LatticeStyle::Sheet)
.thickness(8.0)
.metrics_at(8);
assert!(m.relative_density > 0.99, "{}", m.relative_density);
assert!(m.pore_diameter < 1e-3, "{}", m.pore_diameter);
assert!(
m.wetted_area < 0.05 * m.surface_area,
"{} of {}",
m.wetted_area,
m.surface_area
);
assert!((m.surface_area - 96.0).abs() < 5.0, "{}", m.surface_area);
assert!((m.part_volume - 64.0).abs() < 1.0, "{}", m.part_volume);
}
#[test]
fn a_thin_sheet_has_more_area_per_gram_than_a_fat_strut() {
let size = Vector3::new(20.0, 20.0, 20.0);
let build = |kind| {
crate::geometries::lattice::Lattice::new(kind)
.size(size)
.cells([4, 4, 4])
.fit_relative_density(0.2)
.metrics()
};
let sheet = build(LatticeKind::Tpms(Tpms::Gyroid));
let strut = build(LatticeKind::Strut(Strut::Cubic));
assert!(
sheet.surface_area_to_volume > 3.0 * strut.surface_area_to_volume,
"sheet {} vs strut {}",
sheet.surface_area_to_volume,
strut.surface_area_to_volume
);
for m in [sheet, strut] {
assert!(
(m.relative_density - 0.2).abs() < 0.02,
"{}",
m.relative_density
);
assert!((m.porosity - 0.8).abs() < 0.02, "{}", m.porosity);
assert!((m.part_volume - 8000.0).abs() < 100.0, "{}", m.part_volume);
assert!(
m.pore_diameter > 0.0 && m.pore_diameter < 20.0,
"{}",
m.pore_diameter
);
assert!(m.permeability > 0.0 && m.permeability.is_finite());
assert!(m.hydraulic_diameter > 0.0);
assert!(m.wall_samples > 2.0, "{}", m.wall_samples);
}
assert!(strut.pore_diameter > 2.0 * sheet.pore_diameter);
assert!(strut.permeability > sheet.permeability);
}
#[test]
fn a_sheet_tpms_has_two_labyrinths_and_an_open_cell_foam_has_one() {
use crate::geometries::lattice::Stochastic;
let size = Vector3::new(20.0, 20.0, 20.0);
let build = |kind| {
crate::geometries::lattice::Lattice::new(kind)
.size(size)
.cells([4, 4, 4])
.seed(3)
.fit_relative_density(0.25)
.metrics()
};
let gyroid = build(LatticeKind::Tpms(Tpms::Gyroid));
assert!(
(gyroid.largest_void_fraction - 0.5).abs() < 0.1,
"{}",
gyroid.largest_void_fraction
);
assert!(
gyroid.percolates.iter().all(|&p| p),
"{:?}",
gyroid.percolates
);
assert!(gyroid.open_porosity > 0.95 * gyroid.porosity);
let foam = build(LatticeKind::Stochastic(Stochastic::Voronoi));
assert!(
foam.largest_void_fraction > 0.9,
"{}",
foam.largest_void_fraction
);
assert!(foam.percolates.iter().all(|&p| p), "{:?}", foam.percolates);
}
#[test]
fn a_closed_cell_foam_is_porous_and_goes_nowhere() {
use crate::geometries::lattice::Stochastic;
let m = crate::geometries::lattice::Lattice::new(LatticeKind::Stochastic(
Stochastic::VoronoiWall,
))
.size(Vector3::new(24.0, 24.0, 24.0))
.cells([4, 4, 4])
.seed(5)
.fit_relative_density(0.2)
.metrics();
assert!(m.porosity > 0.75, "{}", m.porosity);
assert!(m.largest_void_fraction < 0.1, "{}", m.largest_void_fraction);
assert!(!m.percolates.iter().any(|&p| p), "{:?}", m.percolates);
assert!(
m.closed_porosity > 0.2 * m.porosity,
"open {} closed {} of {}",
m.open_porosity,
m.closed_porosity,
m.porosity
);
assert!((m.open_porosity + m.closed_porosity - m.porosity).abs() < 1e-5);
}
#[test]
fn a_skin_traps_the_powder() {
let build = |skin: f32| {
crate::geometries::lattice::Lattice::new(LatticeKind::Tpms(Tpms::Gyroid))
.size(Vector3::new(16.0, 16.0, 16.0))
.cells([4, 4, 4])
.fit_relative_density(0.3)
.skin(skin)
.metrics()
};
let bare = build(0.0);
let sealed = build(0.8);
assert!(bare.open_porosity > 0.9 * bare.porosity, "{bare:?}");
assert!(
sealed.open_porosity < 0.05 * sealed.porosity,
"open {} of porosity {}",
sealed.open_porosity,
sealed.porosity
);
assert!(
!sealed.percolates.iter().any(|&p| p),
"{:?}",
sealed.percolates
);
}
#[test]
fn thicker_walls_mean_fatter_ligaments_and_smaller_pores() {
let build = |density: f32| {
crate::geometries::lattice::Lattice::new(LatticeKind::Strut(Strut::Bcc))
.size(Vector3::new(12.0, 12.0, 12.0))
.cells([3, 3, 3])
.fit_relative_density(density)
.metrics()
};
let light = build(0.1);
let heavy = build(0.4);
assert!(heavy.ligament_thickness > light.ligament_thickness);
assert!(heavy.pore_diameter < light.pore_diameter);
assert!(heavy.permeability < light.permeability);
}
#[test]
fn a_strut_measures_the_thickness_it_was_given() {
let lattice = crate::geometries::lattice::Lattice::new(LatticeKind::Strut(Strut::Cubic))
.size(Vector3::new(20.0, 20.0, 20.0))
.cells([4, 4, 4])
.thickness(1.5);
let m = lattice.metrics();
assert!(
(m.ligament_thickness - 1.5).abs() < 0.15,
"{}",
m.ligament_thickness
);
}
}