diff --git a/crates/kernel/src/helix.rs b/crates/kernel/src/helix.rs
index f94b54c52..945533647 100644
--- a/crates/kernel/src/helix.rs
+++ b/crates/kernel/src/helix.rs
@@ -1,14 +1,9 @@
//! Helical sweeps (coils, springs) and lofts to a point (pyramids, cones).
-use mt::builder;
-use solidcraft_geom::{Grid, Loop2, Mesh, Plane, Region2, Seg2, Vec2, Vec3};
-use truck_modeling as mt;
+use solidcraft_geom::{Loop2, Mesh, Plane, Region2, Seg2, Vec2, Vec3};
-use crate::body::{Body, Solid, p3};
-use crate::build::{NetFit, cap_and_close, interpolate_net, uniform_wire};
-use crate::numbered::NumberedLoop;
-use crate::record::{self, Side};
-use crate::{KernelError, Result, guard};
+use crate::body::Body;
+use crate::{KernelError, Result};
/// Rotate `v` about the unit axis `k` by `ang` (Rodrigues).
fn rot(v: Vec3, k: Vec3, ang: f64) -> Vec3 {
@@ -17,9 +12,8 @@ fn rot(v: Vec3, k: Vec3, ang: f64) -> Vec3 {
/// Sweep a planar region's outer loop along a helix about `axis` through `axis_origin`:
/// `turns` revolutions (right-handed about `axis`), rising `pitch` per turn. The profile keeps
-/// its attitude relative to the axis, as a screw motion does. The walls are B-spline surfaces
-/// (one per profile segment); if those cannot be built, ruled walls between stations 3° apart
-/// stand in.
+/// its attitude relative to the axis, as a screw motion does: SMLib's screw sweep, one wall per
+/// profile segment.
pub fn sweep_helix(plane: &Plane, region: &Region2, axis_origin: Vec3, axis: Vec3, pitch: f64, turns: f64) -> Result
{
let k = axis.normalized().ok_or_else(|| KernelError::Invalid("helix axis".into()))?;
if !(pitch.is_finite() && turns.is_finite() && turns > 0.0 && turns <= 200.0 && pitch.abs() < 1e7 && axis_origin.is_finite()) {
@@ -38,34 +32,7 @@ pub fn sweep_helix(plane: &Plane, region: &Region2, axis_origin: Vec3, axis: Vec
if turns > 1.0 && pitch.abs() <= extent {
return Err(KernelError::Invalid(format!("the coil runs into itself: the pitch must exceed the section ({extent:.3} mm)")));
}
- if crate::backend()? == crate::Backend::Smlib {
- return crate::smlib_sweeps::screw(plane, &crate::smlib_sweeps::pieces([&profile]), axis_origin, k, pitch, turns);
- }
- // One smooth B-spline wall per profile segment; the ruled walls below are the fallback.
- if let Ok(b) = smooth_helix(plane, &profile, axis_origin, k, pitch, turns) {
- return Ok(b);
- }
- let n = ((turns * 120.0).ceil() as usize).clamp(4, 24_000);
- let total = std::f64::consts::TAU * turns;
- let mut wires = Vec::with_capacity(n + 1);
- for i in 0..=n {
- let a = total * i as f64 / n as f64;
- let lift = k * (pitch * a / std::f64::consts::TAU);
- let o = axis_origin + rot(plane.origin - axis_origin, k, a) + lift;
- let pl = Plane { origin: o, x: rot(plane.x, k, a), y: rot(plane.y, k, a) };
- wires.push(uniform_wire(&pl, lp)?);
- }
- guard("helix sweep", || {
- // Every station's wire has the profile's segments, edge for edge.
- let mut faces: Vec = Vec::new();
- for w in wires.windows(2) {
- let (Some(a), Some(b)) = (w.first(), w.get(1)) else { continue };
- let sides = builder::try_wire_homotopy(a, b).map_err(|e| KernelError::Failed(format!("helix: {e}")))?;
- faces.extend(record::ruled(&sides, a, b, &profile.from, &profile.from));
- }
- let (Some(first), Some(last)) = (wires.first(), wires.last()) else { return Err(KernelError::Failed("helix".into())) };
- cap_and_close(faces, std::slice::from_ref(first), std::slice::from_ref(last), false)
- })
+ crate::smlib_sweeps::screw(plane, &crate::smlib_sweeps::pieces([&profile]), axis_origin, k, pitch, turns)
}
/// A screw sweep of a convex polygon (in `plane`'s coordinates) as a closed triangle mesh,
@@ -107,84 +74,8 @@ pub fn sweep_helix_mesh(plane: &Plane, polygon: &[Vec2], axis_origin: Vec3, axis
Ok(mesh)
}
-/// Samples per profile segment and stations per turn of the smooth helical walls.
-const SEG_SAMPLES: usize = 12;
-const STATIONS_PER_TURN: f64 = 12.0;
-
-/// Helical walls as B-spline surfaces: each profile segment, sampled at every station of the
-/// screw motion, interpolated by cubics across the profile and then along the helix.
-fn smooth_helix(plane: &Plane, profile: &NumberedLoop, o: Vec3, k: Vec3, pitch: f64, turns: f64) -> Result {
- let lp = &profile.lp;
- let nseg = lp.segs.len();
- if nseg == 0 || nseg > 64 {
- return Err(KernelError::Invalid("helix profile".into()));
- }
- let n = ((turns * STATIONS_PER_TURN).ceil() as usize).clamp(4, 4800);
- let total = std::f64::consts::TAU * turns;
- let at = |i: usize, q: solidcraft_geom::Vec2| {
- let a = total * i as f64 / n as f64;
- let w = plane.to_world(q);
- o + rot(w - o, k, a) + k * (pitch * a / std::f64::consts::TAU)
- };
- let fail = |w: &str| KernelError::Failed(format!("smooth helix: {w}"));
- // Per segment: the wall surface through its samples at every station.
- let mut faces_data = Vec::with_capacity(nseg);
- for s in &lp.segs {
- // u along the helix (the stations), v along the profile segment.
- let samples =
- Grid::from_fn([n + 1, SEG_SAMPLES], |i, j| at(i, s.point_at(j as f64 / (SEG_SAMPLES - 1) as f64))).ok_or_else(|| fail("samples"))?;
- faces_data.push(interpolate_net(&samples).ok_or_else(|| fail("wall surface"))?);
- }
- guard("smooth helix", || {
- let start: Vec = lp.segs.iter().map(|s| builder::vertex(p3(at(0, s.start())))).collect();
- let end: Vec = lp.segs.iter().map(|s| builder::vertex(p3(at(n, s.start())))).collect();
- let mut e0 = Vec::with_capacity(nseg);
- let mut e1 = Vec::with_capacity(nseg);
- let mut seams = Vec::with_capacity(nseg);
- for (j, NetFit { u_ends: [c0, c1], v_ends: [seam, _], .. }) in faces_data.iter().enumerate() {
- let (Some(a0), Some(b0), Some(a1), Some(b1)) = (start.get(j), start.get((j + 1) % nseg), end.get(j), end.get((j + 1) % nseg)) else {
- return Err(fail("vertices"));
- };
- e0.push(mt::Edge::try_new(a0, b0, mt::Curve::BSplineCurve(c0.clone())).map_err(|e| fail(&e.to_string()))?);
- e1.push(mt::Edge::try_new(a1, b1, mt::Curve::BSplineCurve(c1.clone())).map_err(|e| fail(&e.to_string()))?);
- seams.push(mt::Edge::try_new(a0, a1, mt::Curve::BSplineCurve(seam.clone())).map_err(|e| fail(&e.to_string()))?);
- }
- let mut walls = Vec::with_capacity(nseg);
- for (j, NetFit { surface: surf, .. }) in faces_data.iter().enumerate() {
- let (Some(a), Some(b), Some(sa), Some(sb)) = (e0.get(j), e1.get(j), seams.get(j), seams.get((j + 1) % nseg)) else {
- return Err(fail("edges"));
- };
- // Counter-clockwise in the surface's (u along the helix, v along the profile) space.
- let w: mt::Wire = vec![sa.clone(), b.clone(), sb.inverse(), a.inverse()].into();
- let wall = mt::Face::try_new(vec![w], mt::Surface::BSplineSurface(surf.clone())).map_err(|e| fail(&e.to_string()))?;
- walls.push((wall, Some(record::profile(profile.numbers(j)))));
- }
- let w0: mt::Wire = e0.iter().cloned().collect();
- let w1: mt::Wire = e1.iter().cloned().collect();
- // Either orientation of the walls; keep the one that measures as a proper solid.
- let expected = lp_area_path(plane, lp, o, k, turns);
- // A coarse mesh (within ~10%) is enough to tell a proper solid from an empty or inside-out one.
- let section_tol = (lp.signed_area().abs().sqrt() * 0.05).max(1e-3);
- for ws in [walls.clone(), walls.iter().map(|(f, prov)| (f.inverse(), prov.clone())).collect()] {
- if let Ok(b) = cap_and_close(ws, std::slice::from_ref(&w0), std::slice::from_ref(&w1), false)
- && b.mesh(&crate::MeshTolerance::chord(section_tol)).is_ok_and(|m| (m.measure().volume - expected).abs() <= 0.15 * expected.abs())
- {
- return Ok(b);
- }
- }
- Err(fail("the walls do not close into the expected solid"))
- })
-}
-
-/// Pappus estimate of a screw sweep's volume: section area × the centroid's path around the axis.
-fn lp_area_path(plane: &Plane, lp: &Loop2, o: Vec3, k: Vec3, turns: f64) -> f64 {
- let c = plane.to_world(lp.centroid());
- let d = c - o;
- let r = (d - k * d.dot(k)).len();
- lp.signed_area().abs() * std::f64::consts::TAU * r * turns
-}
-
-/// A solid from a planar loop of straight segments to an apex point off its plane (a pyramid).
+/// A solid from a planar loop of straight segments to an apex point off its plane (a pyramid):
+/// SMLib's loft to a point.
pub fn loft_to_point(plane: &Plane, lp: &Loop2, apex: Vec3) -> Result {
if !apex.is_finite() || lp.segs.is_empty() || lp.segs.len() > 10_000 {
return Err(KernelError::Invalid("loft to a point: bad section or apex".into()));
@@ -198,46 +89,12 @@ pub fn loft_to_point(plane: &Plane, lp: &Loop2, apex: Vec3) -> Result {
// Wind the base so its normal points away from the apex.
let above = (apex - plane.origin).dot(plane.normal()) > 0.0;
let base = crate::numbered::number_loops([lp]).pop().ok_or_else(|| KernelError::Invalid("loft to a point: bad section".into()))?.oriented(above);
- if crate::backend()? == crate::Backend::Smlib {
- return crate::smlib_sweeps::loft_to_point(plane, &crate::smlib_sweeps::pieces([&base]), apex);
- }
- let lp = &base.lp;
- guard("loft to point", || {
- let verts: Vec = lp.segs.iter().map(|s| builder::vertex(p3(plane.to_world(s.start())))).collect();
- let top = builder::vertex(p3(apex));
- let m = verts.len();
- let edges: Vec = (0..m).filter_map(|i| Some(builder::line(verts.get(i)?, verts.get((i + 1) % m)?))).collect();
- let sides: Vec = verts.iter().map(|v| builder::line(v, &top)).collect();
- let mut faces = Vec::with_capacity(m + 1);
- // History as the faces are made: the base is the section (the start cap), each
- // triangle comes from its base segment.
- let mut history = Vec::with_capacity(m + 1);
- let bw: mt::Wire = edges.iter().cloned().collect();
- faces.push(builder::try_attach_plane(&[bw]).map_err(|e| KernelError::Failed(format!("loft base: {e}")))?);
- history.push(record::cap(false));
- for i in 0..m {
- let (Some(e), Some(up), Some(down)) = (edges.get(i), sides.get((i + 1) % m), sides.get(i)) else { continue };
- // Triangle i: along the base edge, up to the apex, back down — opposite to the base's winding.
- let w: mt::Wire = vec![e.inverse(), down.clone(), up.inverse()].into();
- faces.push(builder::try_attach_plane(&[w]).map_err(|e| KernelError::Failed(format!("loft side: {e}")))?);
- history.push(record::profile(base.numbers(i)));
- }
- let shell: mt::Shell = faces.into();
- let body = match Solid::try_new(vec![shell.clone()]) {
- Ok(s) => Body::new(s)?,
- Err(_) => {
- let inv: mt::Shell = shell.face_iter().map(|f| f.inverse()).collect();
- Body::new(Solid::try_new(vec![inv]).map_err(|e| KernelError::Failed(format!("loft to point: {e}")))?)?
- }
- };
- record::attach(body, &[], Some(history), Default::default())
- })
+ crate::smlib_sweeps::loft_to_point(plane, &crate::smlib_sweeps::pieces([&base]), apex)
}
#[cfg(test)]
mod tests {
use super::*;
- use solidcraft_geom::Vec2;
#[test]
fn coil_volume_is_section_times_helix_length() {