#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Tpms {
Gyroid,
SchwarzP,
Diamond,
Neovius,
IWP,
FischerKochS,
Lidinoid,
SplitP,
Helicoid,
}
impl Tpms {
pub const ALL: [Tpms; 9] = [
Tpms::Gyroid,
Tpms::SchwarzP,
Tpms::Diamond,
Tpms::Neovius,
Tpms::IWP,
Tpms::FischerKochS,
Tpms::Lidinoid,
Tpms::SplitP,
Tpms::Helicoid,
];
pub fn value(self, x: f32, y: f32, z: f32) -> f32 {
let (sx, cx) = x.sin_cos();
let (sy, cy) = y.sin_cos();
let (sz, cz) = z.sin_cos();
match self {
Tpms::Helicoid => helicoid([(sx, cx), (sy, cy), (sz, cz)]).0,
Tpms::Gyroid => sx * cy + sy * cz + sz * cx,
Tpms::SchwarzP => cx + cy + cz,
Tpms::Diamond => sx * sy * sz + sx * cy * cz + cx * sy * cz + cx * cy * sz,
Tpms::Neovius => 3.0 * (cx + cy + cz) + 4.0 * cx * cy * cz,
Tpms::IWP => {
let (c2x, c2y, c2z) = (cos2(cx), cos2(cy), cos2(cz));
2.0 * (cx * cy + cy * cz + cz * cx) - (c2x + c2y + c2z)
}
Tpms::FischerKochS => {
let (c2x, c2y, c2z) = (cos2(cx), cos2(cy), cos2(cz));
c2x * sy * cz + c2y * sz * cx + c2z * sx * cy
}
Tpms::Lidinoid => {
let (s2x, s2y, s2z) = (sin2(sx, cx), sin2(sy, cy), sin2(sz, cz));
let (c2x, c2y, c2z) = (cos2(cx), cos2(cy), cos2(cz));
0.5 * (s2x * cy * sz + s2y * cz * sx + s2z * cx * sy)
- 0.5 * (c2x * c2y + c2y * c2z + c2z * c2x)
+ 0.15
}
Tpms::SplitP => {
let (s2x, s2y, s2z) = (sin2(sx, cx), sin2(sy, cy), sin2(sz, cz));
let (c2x, c2y, c2z) = (cos2(cx), cos2(cy), cos2(cz));
1.1 * (s2x * sz * cy + s2y * sx * cz + s2z * sy * cx)
- 0.2 * (c2x * c2y + c2y * c2z + c2z * c2x)
- 0.4 * (c2x + c2y + c2z)
}
}
}
pub fn value_and_gradient(self, x: f32, y: f32, z: f32) -> (f32, [f32; 3]) {
self.value_and_gradient_trig([x.sin_cos(), y.sin_cos(), z.sin_cos()])
}
pub fn value_and_gradient_trig(self, trig: [(f32, f32); 3]) -> (f32, [f32; 3]) {
let [(sx, cx), (sy, cy), (sz, cz)] = trig;
match self {
Tpms::Helicoid => helicoid(trig),
Tpms::Gyroid => (
sx * cy + sy * cz + sz * cx,
[cx * cy - sx * sz, cy * cz - sx * sy, cx * cz - sy * sz],
),
Tpms::SchwarzP => (cx + cy + cz, [-sx, -sy, -sz]),
Tpms::Diamond => (
sx * sy * sz + sx * cy * cz + cx * sy * cz + cx * cy * sz,
[
cx * sy * sz + cx * cy * cz - sx * sy * cz - sx * cy * sz,
sx * cy * sz - sx * sy * cz + cx * cy * cz - cx * sy * sz,
sx * sy * cz - sx * cy * sz - cx * sy * sz + cx * cy * cz,
],
),
Tpms::Neovius => (
3.0 * (cx + cy + cz) + 4.0 * cx * cy * cz,
[
-3.0 * sx - 4.0 * sx * cy * cz,
-3.0 * sy - 4.0 * cx * sy * cz,
-3.0 * sz - 4.0 * cx * cy * sz,
],
),
Tpms::IWP => {
let (c2x, c2y, c2z) = (cos2(cx), cos2(cy), cos2(cz));
let (s2x, s2y, s2z) = (sin2(sx, cx), sin2(sy, cy), sin2(sz, cz));
(
2.0 * (cx * cy + cy * cz + cz * cx) - (c2x + c2y + c2z),
[
-2.0 * sx * (cy + cz) + 2.0 * s2x,
-2.0 * sy * (cx + cz) + 2.0 * s2y,
-2.0 * sz * (cx + cy) + 2.0 * s2z,
],
)
}
Tpms::FischerKochS => {
let (c2x, c2y, c2z) = (cos2(cx), cos2(cy), cos2(cz));
let (s2x, s2y, s2z) = (sin2(sx, cx), sin2(sy, cy), sin2(sz, cz));
(
c2x * sy * cz + c2y * sz * cx + c2z * sx * cy,
[
-2.0 * s2x * sy * cz - c2y * sz * sx + c2z * cx * cy,
c2x * cy * cz - 2.0 * s2y * sz * cx - c2z * sx * sy,
-c2x * sy * sz + c2y * cz * cx - 2.0 * s2z * sx * cy,
],
)
}
Tpms::Lidinoid => {
let (s2x, s2y, s2z) = (sin2(sx, cx), sin2(sy, cy), sin2(sz, cz));
let (c2x, c2y, c2z) = (cos2(cx), cos2(cy), cos2(cz));
(
0.5 * (s2x * cy * sz + s2y * cz * sx + s2z * cx * sy)
- 0.5 * (c2x * c2y + c2y * c2z + c2z * c2x)
+ 0.15,
[
0.5 * (2.0 * c2x * cy * sz + s2y * cz * cx - s2z * sx * sy)
+ s2x * (c2y + c2z),
0.5 * (-s2x * sy * sz + 2.0 * c2y * cz * sx + s2z * cx * cy)
+ s2y * (c2x + c2z),
0.5 * (s2x * cy * cz - s2y * sz * sx + 2.0 * c2z * cx * sy)
+ s2z * (c2x + c2y),
],
)
}
Tpms::SplitP => {
let (s2x, s2y, s2z) = (sin2(sx, cx), sin2(sy, cy), sin2(sz, cz));
let (c2x, c2y, c2z) = (cos2(cx), cos2(cy), cos2(cz));
(
1.1 * (s2x * sz * cy + s2y * sx * cz + s2z * sy * cx)
- 0.2 * (c2x * c2y + c2y * c2z + c2z * c2x)
- 0.4 * (c2x + c2y + c2z),
[
1.1 * (2.0 * c2x * sz * cy + s2y * cx * cz - s2z * sy * sx)
+ 0.4 * s2x * (c2y + c2z)
+ 0.8 * s2x,
1.1 * (-s2x * sz * sy + 2.0 * c2y * sx * cz + s2z * cy * cx)
+ 0.4 * s2y * (c2x + c2z)
+ 0.8 * s2y,
1.1 * (s2x * cz * cy - s2y * sx * sz + 2.0 * c2z * sy * cx)
+ 0.4 * s2z * (c2x + c2y)
+ 0.8 * s2z,
],
)
}
}
}
pub fn clip_radius(self) -> Option<f32> {
match self {
Tpms::Helicoid => Some(0.45 * std::f32::consts::TAU),
_ => None,
}
}
pub fn name(self) -> &'static str {
match self {
Tpms::Gyroid => "gyroid",
Tpms::SchwarzP => "schwarz-p",
Tpms::Diamond => "diamond",
Tpms::Neovius => "neovius",
Tpms::IWP => "iwp",
Tpms::FischerKochS => "fischer-koch-s",
Tpms::Lidinoid => "lidinoid",
Tpms::SplitP => "split-p",
Tpms::Helicoid => "helicoid",
}
}
pub fn from_name(name: &str) -> Option<Tpms> {
Tpms::ALL.into_iter().find(|t| t.name() == name)
}
}
#[inline]
fn cos2(c: f32) -> f32 {
2.0 * c * c - 1.0
}
#[inline]
fn sin2(s: f32, c: f32) -> f32 {
2.0 * s * c
}
const HELICOID_STARTS: f32 = 2.0;
fn helicoid(trig: [(f32, f32); 3]) -> (f32, [f32; 3]) {
let [(sx, cx), (sy, cy), (sz, cz)] = trig;
let (x, y, z) = ((-sx).atan2(-cx), (-sy).atan2(-cy), sz.atan2(cz));
let r = x.hypot(y);
let n = HELICOID_STARTS;
let phase = n * (y.atan2(x) - z);
let (s, c) = phase.sin_cos();
if r < 1e-6 {
return (0.0, [s, -c, 0.0]);
}
let (ux, uy) = (x / r, y / r);
(
r * s,
[ux * s - n * uy * c, uy * s + n * ux * c, -n * r * c],
)
}
pub(crate) fn axis_radius(trig: [(f32, f32); 3]) -> f32 {
(-trig[0].0)
.atan2(-trig[0].1)
.hypot((-trig[1].0).atan2(-trig[1].1))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_helicoid_is_a_screw() {
use std::f32::consts::PI;
for i in 0..50 {
let z = -PI + i as f32 * 0.12;
let r = 0.3 + (i % 7) as f32 * 0.3;
for thread in 0..2 {
let theta = z + thread as f32 * PI;
let v = Tpms::Helicoid.value(PI + r * theta.cos(), PI + r * theta.sin(), z);
assert!(v.abs() < 1e-4, "off the surface by {v} at r {r}, z {z}");
}
}
for i in 0..40 {
let p = [
PI + 0.3 + i as f32 * 0.05,
PI - 0.7 + i as f32 * 0.03,
0.2 * i as f32 - 2.0,
];
let (_, g) = Tpms::Helicoid.value_and_gradient(p[0], p[1], p[2]);
let e = 1e-3;
for axis in 0..3 {
let (mut up, mut dn) = (p, p);
up[axis] += e;
dn[axis] -= e;
let numeric = (Tpms::Helicoid.value(up[0], up[1], up[2])
- Tpms::Helicoid.value(dn[0], dn[1], dn[2]))
/ (2.0 * e);
assert!(
(numeric - g[axis]).abs() < 2e-2 * g[axis].abs().max(1.0),
"axis {axis} at {p:?}: {numeric} vs {}",
g[axis]
);
}
}
}
use std::f32::consts::TAU;
#[test]
fn every_family_is_periodic() {
for f in Tpms::ALL {
for &(x, y, z) in &[(0.3, 1.1, 2.7), (-1.4, 0.2, 5.0), (2.0, 2.0, 2.0)] {
let base = f.value(x, y, z);
for shift in [
(TAU, 0.0, 0.0),
(0.0, TAU, 0.0),
(0.0, 0.0, TAU),
(-TAU, TAU, TAU),
] {
let moved = f.value(x + shift.0, y + shift.1, z + shift.2);
assert!(
(base - moved).abs() < 1e-3,
"{} is not periodic: {base} vs {moved}",
f.name()
);
}
}
}
}
#[test]
fn every_family_changes_sign() {
for f in Tpms::ALL {
let (mut lo, mut hi) = (f32::MAX, f32::MIN);
let n = 24;
for k in 0..n {
for j in 0..n {
for i in 0..n {
let s = |a: usize| a as f32 / n as f32 * TAU;
let v = f.value(s(i), s(j), s(k));
lo = lo.min(v);
hi = hi.max(v);
}
}
}
assert!(lo < 0.0 && hi > 0.0, "{} never crosses zero", f.name());
}
}
#[test]
fn balanced_families_split_space_evenly() {
for f in [
Tpms::Gyroid,
Tpms::SchwarzP,
Tpms::Diamond,
Tpms::Neovius,
Tpms::FischerKochS,
] {
let n = 40;
let mut positive = 0;
for k in 0..n {
for j in 0..n {
for i in 0..n {
let s = |a: usize| (a as f32 + 0.5) / n as f32 * TAU;
if f.value(s(i), s(j), s(k)) > 0.0 {
positive += 1;
}
}
}
}
let fraction = positive as f32 / (n * n * n) as f32;
assert!(
(fraction - 0.5).abs() < 0.02,
"{} splits {fraction:.3}, not half",
f.name()
);
}
}
#[test]
fn the_closed_form_gradient_matches_differencing_it() {
for f in Tpms::ALL {
let mut worst = 0.0f64;
let n = 11;
for k in 0..n {
for j in 0..n {
for i in 0..n {
let at = |a: usize| (a as f64 + 0.37) / n as f64 * TAU as f64;
let (x, y, z) = (at(i), at(j), at(k));
let value =
|x: f64, y: f64, z: f64| f.value(x as f32, y as f32, z as f32) as f64;
let h = 1e-3;
let numeric = [
(value(x + h, y, z) - value(x - h, y, z)) / (2.0 * h),
(value(x, y + h, z) - value(x, y - h, z)) / (2.0 * h),
(value(x, y, z + h) - value(x, y, z - h)) / (2.0 * h),
];
let (_, exact) = f.value_and_gradient(x as f32, y as f32, z as f32);
for a in 0..3 {
worst = worst.max((numeric[a] - exact[a] as f64).abs());
}
}
}
}
assert!(worst < 2e-2, "{}: gradient off by {worst}", f.name());
}
}
#[test]
fn the_two_value_paths_agree() {
for f in Tpms::ALL {
for i in 0..97 {
let at = |m: u32| (i as f32 * m as f32 * 0.137) % TAU;
let (x, y, z) = (at(1), at(3), at(7));
let (both, _) = f.value_and_gradient(x, y, z);
assert!(
(f.value(x, y, z) - both).abs() < 1e-5,
"{} disagrees with itself",
f.name()
);
}
}
}
#[test]
fn the_gradient_never_vanishes_on_the_surface() {
for f in Tpms::ALL {
let mut weakest = f32::MAX;
let n = 60;
for k in 0..n {
for j in 0..n {
for i in 0..n {
let at = |a: usize| (a as f32 + 0.5) / n as f32 * TAU;
let (x, y, z) = (at(i), at(j), at(k));
let (v, g) = f.value_and_gradient(x, y, z);
if v.abs() < 0.05 {
let len = (g[0] * g[0] + g[1] * g[1] + g[2] * g[2]).sqrt();
weakest = weakest.min(len);
}
}
}
}
assert!(weakest > 0.05, "{} flattens out at {weakest}", f.name());
}
}
#[test]
fn names_round_trip() {
for f in Tpms::ALL {
assert_eq!(Tpms::from_name(f.name()), Some(f));
}
assert_eq!(Tpms::from_name("not-a-surface"), None);
}
#[test]
fn double_angle_helpers_match_trig() {
for i in 0..64 {
let t = i as f32 / 64.0 * TAU - 3.0;
let (s, c) = t.sin_cos();
assert!((cos2(c) - (2.0 * t).cos()).abs() < 1e-5);
assert!((sin2(s, c) - (2.0 * t).sin()).abs() < 1e-5);
}
}
}