diff --git a/crates/kernel/src/boolean_history_tests.rs b/crates/kernel/src/boolean_history_tests.rs index 3c6aa88ee..7635f2b42 100644 --- a/crates/kernel/src/boolean_history_tests.rs +++ b/crates/kernel/src/boolean_history_tests.rs @@ -539,13 +539,33 @@ mod smlib { #[test] fn operands_number_as_their_records() { - let bodies = [boxed(0.0, 0.0, 0.0, 10.0, 10.0, 10.0), crate::cylinder(Vec3::new(5.0, 5.0, -1.0), Vec3::Z, 2.0, 12.0).unwrap()]; + let bodies = [ + boxed(0.0, 0.0, 0.0, 10.0, 10.0, 10.0), + crate::cylinder(Vec3::new(5.0, 5.0, -1.0), Vec3::Z, 2.0, 12.0).unwrap(), + crate::sphere(Vec3::new(10.0, 10.0, 10.0), 4.0).unwrap(), + crate::torus(Vec3::new(0.0, 0.0, 0.0), 10.0, 2.0).unwrap(), + ]; for (i, b) in bodies.iter().enumerate() { let (_, order) = crate::native::smlib_body_ordered(b).unwrap(); assert!(order.is_some(), "body {i}"); } } + #[test] + fn box_minus_sphere() { + let a = boxed(0.0, 0.0, 0.0, 10.0, 10.0, 10.0); + let b = crate::sphere(Vec3::new(10.0, 10.0, 10.0), 4.0).unwrap(); + let r = through_smlib(&a, &b, BoolOp::Cut); + let h = verified(&r, &[&a, &b], 0.02); + // The three notched box faces, the three untouched, and the sphere's patches inside. + assert_eq!(changes(h)[..2].iter().sum::() + changes(h)[2], h.faces.len(), "{}", show(h)); + assert!( + meets(h).iter().all(|(x, y)| matches!((x, y), (FaceOrigin::Face { operand: 0, .. }, FaceOrigin::Face { operand: 1, .. }))), + "{}", + show(h) + ); + } + #[test] fn box_minus_cylinder() { let a = boxed(0.0, 0.0, 0.0, 10.0, 10.0, 10.0); diff --git a/crates/kernel/src/native.rs b/crates/kernel/src/native.rs index 409f56824..239b58be9 100644 --- a/crates/kernel/src/native.rs +++ b/crates/kernel/src/native.rs @@ -169,9 +169,8 @@ pub(crate) fn body_from_smlib_ordered(brep: &solidcraft_smlib::Brep) -> Result<( guard("decode SMLib B-rep", || { let (solid, numbering) = adapter::decode_numbered(record, adapter::Producer::Foreign)?; let body = Body::oriented(solid)?; - let faces_kept = body.solid.face_iter().map(|f| f.id()).eq(numbering.faces.iter().copied()); - let edges_kept = crate::body::edge_order(body.solid.face_iter()).0.iter().map(|e| e.id()).eq(numbering.edges.iter().copied()); - Ok((body, (faces_kept && edges_kept).then_some(order))) + let kept = numbering.kept_by(&body.solid); + Ok((body, kept.then_some(order))) }) } diff --git a/crates/kernel/src/native/adapter.rs b/crates/kernel/src/native/adapter.rs index 8a647c834..55971cd1e 100644 --- a/crates/kernel/src/native/adapter.rs +++ b/crates/kernel/src/native/adapter.rs @@ -333,13 +333,28 @@ pub(super) fn decode_from(body: b::Brep, producer: Producer) -> Result, + pub faces: Vec<(mt::FaceID, std::collections::HashSet)>, pub edges: Vec, } +#[cfg_attr(not(feature = "smlib"), allow(dead_code))] +impl Numbering { + /// Whether `solid` lists its faces and edges in the record's order. + pub fn kept_by(&self, solid: &mt::Solid) -> bool { + let faces_kept = solid.face_iter().count() == self.faces.len() + && solid + .face_iter() + .zip(&self.faces) + .all(|(f, (id, edges))| f.id() == *id || f.edge_iter().map(|e| e.id()).collect::>() == *edges); + faces_kept && crate::body::edge_order(solid.face_iter()).0.iter().map(|e| e.id()).eq(self.edges.iter().copied()) + } +} + /// [`decode_from`], with each record face's and edge's identity in the solid: a caller holding /// indices into the record (an SMLib history) checks with them that the solid's face and edge /// order is the record's. @@ -354,7 +369,7 @@ pub(super) fn decode_numbered(body: b::Brep, producer: Producer) -> Result<(mt:: .into_iter() .map(|e| Ok(mt::Edge::new_unchecked(vertex(e.vertices[0])?, vertex(e.vertices[1])?, load_edge_curve(e.curve, e.interval)?))) .collect::>>()?; - let mut face_ids: Vec> = vec![None; faces.len()]; + let mut face_ids: Vec)>> = vec![None; faces.len()]; let mut faces: Vec> = faces.into_iter().map(Some).collect(); let shells = shells .into_iter() @@ -366,7 +381,7 @@ pub(super) fn decode_numbered(body: b::Brep, producer: Producer) -> Result<(mt:: let f = faces.get_mut(u.face as usize).and_then(Option::take).ok_or_else(|| unsupported("a face in two shells"))?; let made = face(f, u.forward, &edges)?; if let Some(slot) = face_ids.get_mut(u.face as usize) { - *slot = Some(made.id()); + *slot = Some((made.id(), made.edge_iter().map(|e| e.id()).collect())); } Ok(made) }) diff --git a/crates/kernel/src/native/smlib_import_tests.rs b/crates/kernel/src/native/smlib_import_tests.rs index 0443c3531..d34f3acaf 100644 --- a/crates/kernel/src/native/smlib_import_tests.rs +++ b/crates/kernel/src/native/smlib_import_tests.rs @@ -27,14 +27,37 @@ fn primitives_keep_their_analytic_volume() { assert!(solid && (got - 28.0 * PI).abs() <= 1e-6 * 28.0 * PI, "tilted cylinder: SMLib volume {got}, manifold {solid}"); } -/// Truck holds spheres and tori as revolutions (`PlacedRevolution`); they go to SMLib as their -/// exact rational B-spline surfaces. +/// Truck holds spheres and tori as revolutions (`PlacedRevolution`): SMLib gets them as its +/// analytic sphere and torus, faces turned over where the revolution's normal points inward. #[test] fn revolutions_keep_their_analytic_volume() { - let (got, solid) = in_smlib(&sphere(v(1., 2., 3.), 5.0).unwrap()).unwrap(); - let ball = 4.0 / 3.0 * PI * 125.0; - assert!(solid && (got - ball).abs() <= 1e-6 * ball, "sphere: SMLib volume {got}, manifold {solid}"); - let (got, solid) = in_smlib(&torus(v(0., 0., 0.), 10.0, 2.0).unwrap()).unwrap(); - let ring = 2.0 * PI * PI * 10.0 * 4.0; - assert!(solid && (got - ring).abs() <= 1e-6 * ring, "torus: SMLib volume {got}, manifold {solid}"); + let cases = [ + ("sphere", sphere(v(1., 2., 3.), 5.0).unwrap(), 4.0 / 3.0 * PI * 125.0), + ("torus", torus(v(0., 0., 0.), 10.0, 2.0).unwrap(), 2.0 * PI * PI * 10.0 * 4.0), + ]; + for (name, body, exact) in cases { + let s = super::smlib_body(&body).unwrap_or_else(|e| panic!("{name}: {e}")); + let check = s.check(solidcraft_smlib::CheckLevel::All).unwrap(); + assert!(check.is_valid(), "{name}: {check}"); + let got = s.volume(1e-7).unwrap(); + assert!(s.is_manifold_solid().unwrap_or(false) && (got - exact).abs() <= 1e-6 * exact, "{name}: SMLib volume {got}, exact {exact}"); + } +} + +/// A body SMLib made (analytic faces) comes back from truck as revolutions, and goes into SMLib +/// again as the same analytic faces: a second boolean on a first one's result. +#[test] +fn smlib_results_go_back_into_smlib() { + for (name, body, exact) in [ + ("cylinder", cylinder(v(1., 2., 3.), v(0., 0., 1.), 5.0, 10.0).unwrap(), 250.0 * PI), + ("sphere", sphere(v(0., 0., 0.), 3.0).unwrap(), 36.0 * PI), + ] { + let first = super::smlib_body(&body).unwrap(); + let back = super::body_from_smlib(&first).unwrap_or_else(|e| panic!("{name}: {e}")); + let again = super::smlib_body(&back).unwrap_or_else(|e| panic!("{name}: {e}")); + let check = again.check(solidcraft_smlib::CheckLevel::All).unwrap(); + assert!(check.is_valid(), "{name}: {check}"); + let got = again.volume(1e-7).unwrap(); + assert!((got - exact).abs() <= 1e-6 * exact, "{name}: SMLib volume {got}, exact {exact}"); + } } diff --git a/crates/smlib/src/import.rs b/crates/smlib/src/import.rs index c8e103949..1a2a97425 100644 --- a/crates/smlib/src/import.rs +++ b/crates/smlib/src/import.rs @@ -84,6 +84,8 @@ fn z_axis(f: &b::Frame) -> [f64; 3] { /// rules (SMLib then skips its healer); otherwise SMLib heals it on import. pub fn arrays(brep: &b::Brep, trusted: bool) -> R { brep.validate().map_err(|e| Unsupported::Invalid(e.0))?; + let brep = revolved::analytic(brep)?; + let brep = brep.as_ref(); let mut a = Arrays::default(); // Regions and shells. Each region gets its own copy of each shell it lists. @@ -481,6 +483,8 @@ fn curve(a: &mut Arrays, c: &b::Curve) -> R<()> { Ok(()) } +mod revolved; + #[cfg(test)] mod tests; diff --git a/crates/smlib/src/import/revolved.rs b/crates/smlib/src/import/revolved.rs new file mode 100644 index 000000000..917a00cf7 --- /dev/null +++ b/crates/smlib/src/import/revolved.rs @@ -0,0 +1,368 @@ +//! Revolutions as SMLib's analytic surfaces. A `placed_revolution` record holds a surface the +//! way truck does (a profile turned about an axis, then placed); SMLib has no such surface, but +//! every one truck makes for a cylinder, cone, sphere or torus is one of those exactly: a line +//! along the axis, a line in a plane through it, a circle centred on it, a circle in a plane +//! through it. Each such face becomes that analytic surface, its range mapped from the +//! revolution's parameters, and checked point by point over the face's range; where the +//! analytic surface's natural normal is the other way round, the face is turned over (its loops +//! reversed, its uses in the shells flipped), which leaves the solid as it was. +//! +//! A revolution of any other profile, or one placed by a matrix that is not a rigid motion, is +//! refused. + +use std::borrow::Cow; +use std::f64::consts::{FRAC_PI_2, TAU}; + +use solidcraft_geom::Vec3; +use solidcraft_geom::brep as b; +use solidcraft_geom::brep::eval::{CurveEval, SurfaceEval}; + +use super::{R, Unsupported}; + +const NOT_ANALYTIC: Unsupported = Unsupported::NotYet("revolved surfaces other than cylinders, cones, spheres and tori"); + +/// `brep` with every revolution replaced by its analytic surface (borrowed when it has none). +pub(super) fn analytic(brep: &b::Brep) -> R> { + if !brep.faces.iter().any(|f| matches!(f.surface, b::Surface::PlacedRevolution { .. })) { + return Ok(Cow::Borrowed(brep)); + } + let mut out = brep.clone(); + let size = extent(brep); + let mut turned = Vec::new(); + for (i, f) in out.faces.iter_mut().enumerate() { + let b::Surface::PlacedRevolution { profile, origin, axis, matrix, forward } = &f.surface else { continue }; + let rev = Revolution::new(profile, *origin, *axis, matrix, *forward)?; + let (surface, mut domain, v) = rev.analytic(f.domain)?; + // Angles start within the first turn, where SMLib's degree domains are at home. + domain[0] = first_turn(domain[0]); + if matches!(surface, b::Surface::Torus { .. }) { + domain[1] = first_turn(domain[1]); + } + let flip = agree(&f.surface, f.domain, &surface, domain, &rev, &v, brep.tolerance.max(1e-9 * size))?; + f.surface = surface; + f.domain = domain; + if flip { + turned.push(i); + } + } + for i in turned { + turn_over(&mut out, i)?; + } + Ok(Cow::Owned(out)) +} + +/// An angle range moved by whole turns to start in [0, 2π). +fn first_turn([a, z]: [f64; 2]) -> [f64; 2] { + let shift = (a / TAU).floor() * TAU; + [a - shift, z - shift] +} + +/// The body's size from its vertices (1 where it has none). +fn extent(brep: &b::Brep) -> f64 { + let mut lo = [f64::INFINITY; 3]; + let mut hi = [f64::NEG_INFINITY; 3]; + for v in &brep.vertices { + for k in 0..3 { + lo[k] = lo[k].min(v.point[k]); + hi[k] = hi[k].max(v.point[k]); + } + } + let d = (0..3).map(|k| (hi[k] - lo[k]).powi(2)).sum::().sqrt(); + if d.is_finite() && d > 0.0 { d } else { 1.0 } +} + +fn v3(p: [f64; 3]) -> Vec3 { + Vec3::new(p[0], p[1], p[2]) +} +fn arr(v: Vec3) -> [f64; 3] { + [v.x, v.y, v.z] +} + +/// A revolution in world space: its profile placed, its axis placed, the turning sense. +struct Revolution { + profile: CurveEval, + line: Option<[Vec3; 2]>, + /// A point on the axis and the axis, oriented so that the revolution's angle turns about it + /// by the right-hand rule. + o: Vec3, + z: Vec3, + /// The record's (u, v) is (profile, angle). + forward: bool, +} + +impl Revolution { + fn new(profile: &b::Curve, origin: [f64; 3], axis: [f64; 3], m: &[[f64; 4]; 4], forward: bool) -> R { + // Column-major: m[column][row]. A rigid motion only (a mirror reverses the turning). + let col = |c: usize| Vec3::new(m[c][0], m[c][1], m[c][2]); + let (c0, c1, c2, t) = (col(0), col(1), col(2), col(3)); + let unit = |v: Vec3| (v.len() - 1.0).abs() <= 1e-9; + if !(m[0][3] == 0.0 && m[1][3] == 0.0 && m[2][3] == 0.0 && m[3][3] == 1.0) + || !(unit(c0) && unit(c1) && unit(c2)) + || c0.dot(c1).abs() > 1e-9 + || c0.dot(c2).abs() > 1e-9 + || c1.dot(c2).abs() > 1e-9 + { + return Err(Unsupported::NotYet("revolved surfaces placed by a matrix that is no rigid motion")); + } + let det = c0.dot(c1.cross(c2)); + let place = |p: Vec3| c0 * p.x + c1 * p.y + c2 * p.z + t; + let turn = |d: Vec3| c0 * d.x + c1 * d.y + c2 * d.z; + let z = turn(v3(axis)).normalized().ok_or(Unsupported::Invalid("revolution axis"))? * det.signum(); + let placed_curve = |c: &b::Curve| -> R { + let p = |q: [f64; 3]| arr(place(v3(q))); + Ok(match c { + b::Curve::Line { start, end } => b::Curve::Line { start: p(*start), end: p(*end) }, + b::Curve::Circle { frame, radius } => b::Curve::Circle { + frame: b::Frame { origin: p(frame.origin), x_axis: arr(turn(v3(frame.x_axis))), y_axis: arr(turn(v3(frame.y_axis))) }, + radius: *radius, + }, + b::Curve::Spline { knots, points } => b::Curve::Spline { knots: knots.clone(), points: points.iter().map(|q| p(*q)).collect() }, + b::Curve::RationalSpline { knots, homogeneous } => b::Curve::RationalSpline { + knots: knots.clone(), + homogeneous: homogeneous + .iter() + .map(|h| { + let w = h[3]; + let q = place(Vec3::new(h[0], h[1], h[2]) * (1.0 / w)); + [q.x * w, q.y * w, q.z * w, w] + }) + .collect(), + }, + _ => return Err(NOT_ANALYTIC), + }) + }; + let world = placed_curve(profile)?; + let line = match &world { + b::Curve::Line { start, end } => Some([v3(*start), v3(*end)]), + _ => None, + }; + let profile = CurveEval::new(&world).map_err(|_| Unsupported::Invalid("revolution profile"))?; + Ok(Revolution { profile, line, o: place(v3(origin)), z, forward }) + } + + /// The profile's parameter range and the angle range of a face's domain. + fn ranges(&self, domain: [[f64; 2]; 2]) -> ([f64; 2], [f64; 2]) { + if self.forward { (domain[0], domain[1]) } else { (domain[1], domain[0]) } + } + + /// `p` relative to the axis: its foot on the axis, its height along z and its radial part. + fn split(&self, p: Vec3) -> (Vec3, f64, Vec3) { + let h = (p - self.o).dot(self.z); + let foot = self.o + self.z * h; + (foot, h, p - foot) + } + + /// The analytic surface and the face's range on it: u the angle about z from the profile's + /// half-plane, v as the surface's kind has it. + fn analytic(&self, domain: [[f64; 2]; 2]) -> R<(b::Surface, [[f64; 2]; 2], V)> { + let (t, angle) = self.ranges(domain); + let at = |s: f64| self.profile.point(s).ok_or(Unsupported::Invalid("revolution profile")); + let samples: Vec = (0..=16).map(|i| at(t[0] + (t[1] - t[0]) * f64::from(i) / 16.0)).collect::>()?; + // The profile's half-plane: the radial direction of its point farthest from the axis. + let far = samples.iter().map(|p| self.split(*p).2).fold(Vec3::ZERO, |best, r| if r.len() > best.len() { r } else { best }); + let x = far.normalized().ok_or(NOT_ANALYTIC)?; + let y = self.z.cross(x); + let frame = |o: Vec3| b::Frame { origin: arr(o), x_axis: arr(x), y_axis: arr(y) }; + let sorted = |a: f64, b: f64| if a <= b { [a, b] } else { [b, a] }; + if let Some([s, e]) = self.line { + let d = e - s; + let len = d.len(); + if !(len > 0.0) { + return Err(NOT_ANALYTIC); + } + // In a plane through the axis: no component out of the (z, x) plane. + if (s - self.o).dot(y).abs() > 1e-9 * len.max(1.0) || d.dot(y).abs() > 1e-9 * len { + return Err(NOT_ANALYTIC); + } + let (foot, _, _) = self.split(s); + let height = |p: Vec3| (p - foot).dot(self.z); + let radial = |p: Vec3| (p - foot).dot(x); + let (h0, h1) = (height(at(t[0])?), height(at(t[1])?)); + let (dh, dr) = (d.dot(self.z), d.dot(x)); + if dh.abs() <= 1e-12 * len { + return Err(NOT_ANALYTIC); // a disc: a plane, which a revolution face never is in the kernel + } + let r0 = radial(s) - dr / dh * height(s); + let v = sorted(h0, h1); + if dr.abs() <= 1e-12 * len { + if !(r0 > 0.0) { + return Err(NOT_ANALYTIC); + } + return Ok((b::Surface::Cylinder { frame: frame(foot), radius: r0 }, [angle, v], V::Height { foot, z: self.z })); + } + // A cone on one side of its apex only. + let r = |h: f64| r0 + h * dr / dh; + if r(v[0]) < 0.0 || r(v[1]) < 0.0 { + return Err(NOT_ANALYTIC); + } + let cone = b::Surface::Cone { frame: frame(foot), radius_at_origin: r0, half_angle: (dr / dh).atan() }; + return Ok((cone, [angle, v], V::Height { foot, z: self.z })); + } + // A circular profile. + let (center, radius, normal) = circle(&self.profile, t).ok_or(NOT_ANALYTIC)?; + let slack = 1e-9 * radius.max(1.0); + if normal.dot(self.z).abs() > 1e-9 || normal.dot(x).abs() > 1e-9 || (center - self.o).dot(y).abs() > slack { + return Err(NOT_ANALYTIC); + } + let (foot, _, off) = self.split(center); + // The meridian angle of each sample about the circle's centre in the (x, z) plane, unwrapped. + let meridian = |p: Vec3| { + let q = p - center; + q.dot(self.z).atan2(q.dot(x)) + }; + let mut angles = Vec::with_capacity(samples.len()); + for p in &samples { + let mut a = meridian(*p); + if let Some(prev) = angles.last().copied() { + while a - prev > std::f64::consts::PI { + a -= TAU; + } + while a - prev < -std::f64::consts::PI { + a += TAU; + } + } + angles.push(a); + } + let (first, last) = (angles.first().copied().ok_or(NOT_ANALYTIC)?, angles.last().copied().ok_or(NOT_ANALYTIC)?); + if off.len() <= slack { + // A sphere: the latitude is the meridian angle, within the half-plane's [-π/2, π/2]. + let v = sorted(first, last); + if v[0] < -FRAC_PI_2 - 1e-9 || v[1] > FRAC_PI_2 + 1e-9 { + return Err(NOT_ANALYTIC); + } + let v = [v[0].max(-FRAC_PI_2), v[1].min(FRAC_PI_2)]; + return Ok((b::Surface::Sphere { frame: frame(foot), radius }, [angle, v], V::Angle { center, x, z: self.z })); + } + let major = off.dot(x); + if !(major > radius) { + return Err(NOT_ANALYTIC); + } + let torus = b::Surface::Torus { frame: frame(foot), major_radius: major, minor_radius: radius }; + Ok((torus, [angle, sorted(first, last)], V::Angle { center, x, z: self.z })) + } + + /// The analytic (u, v) of the record's (u, v): the angle is the revolution's own, v that of + /// the profile's point (at angle 0), unwrapped to within half a turn of `near`. + fn map(&self, v: &V, uv: [f64; 2], near: f64) -> Option<[f64; 2]> { + let (t, angle) = if self.forward { (uv[0], uv[1]) } else { (uv[1], uv[0]) }; + let p = self.profile.point(t)?; + Some([angle, v.of(p, near)]) + } +} + +/// How the analytic v of a profile point is found. +enum V { + /// Height along `z` above `foot` (cylinder, cone). + Height { foot: Vec3, z: Vec3 }, + /// The angle about `center` from `x` towards `z` (sphere latitude, torus meridian). + Angle { center: Vec3, x: Vec3, z: Vec3 }, +} + +impl V { + fn of(&self, p: Vec3, near: f64) -> f64 { + match self { + V::Height { foot, z } => (p - *foot).dot(*z), + V::Angle { center, x, z } => { + let q = p - *center; + let mut a = q.dot(*z).atan2(q.dot(*x)); + while a - near > std::f64::consts::PI { + a -= TAU; + } + while a - near < -std::f64::consts::PI { + a += TAU; + } + a + } + } + } +} + +/// Checks the analytic surface against the revolution over the face's range, 5 × 5 points +/// within `tol`, and says whether their natural normals are opposite (the face must be turned +/// over), read at the range's middle. +fn agree(record: &b::Surface, domain: [[f64; 2]; 2], analytic: &b::Surface, range: [[f64; 2]; 2], rev: &Revolution, v: &V, tol: f64) -> R { + let bad = Unsupported::Invalid("a revolution its analytic surface does not match"); + let s = SurfaceEval::new(record).map_err(|_| bad.clone())?; + let a = SurfaceEval::new(analytic).map_err(|_| bad.clone())?; + let [[u0, u1], [v0, v1]] = domain; + let near = 0.5 * (range[1][0] + range[1][1]); + let normals = |u: f64, w: f64| -> R { + let (p, du, dv) = s.derivs(u, w).ok_or(bad.clone())?; + let uv = rev.map(v, [u, w], near).ok_or(bad.clone())?; + let (q, au, av) = a.derivs(uv[0], uv[1]).ok_or(bad.clone())?; + if !((p - q).len() <= tol) { + return Err(bad.clone()); + } + Ok(du.cross(dv).dot(au.cross(av))) + }; + for i in 0..=4 { + for j in 0..=4 { + normals(u0 + (u1 - u0) * f64::from(i) / 4.0, v0 + (v1 - v0) * f64::from(j) / 4.0)?; + } + } + let d = normals(0.5 * (u0 + u1), 0.5 * (v0 + v1))?; + if !(d.abs() > 0.0) { + return Err(bad); + } + Ok(d < 0.0) +} + +/// The circle a curve runs along over `t`: centre, radius and unit normal (its turning sense), +/// checked at 65 points within 10⁻⁹ of the radius (at least 1 mm). +fn circle(c: &CurveEval, t: [f64; 2]) -> Option<(Vec3, f64, Vec3)> { + let at = |s: f64| c.point(t[0] + (t[1] - t[0]) * s); + let (p, q, r) = (at(0.0)?, at(1.0 / 3.0)?, at(2.0 / 3.0)?); + let (u, w) = (q - p, r - p); + let normal = u.cross(w); + let nn = normal.dot(normal); + if !(nn > 0.0) { + return None; + } + let center = p + (normal.cross(u) * w.dot(w) + w.cross(normal) * u.dot(u)) * (0.5 / nn); + let radius = (p - center).len(); + let k = normal.normalized()?; + let slack = 1e-9 * radius.max(1.0); + for i in 0..=64 { + let s = at(f64::from(i) / 64.0)?; + if ((s - center).len() - radius).abs() > slack || (s - center).dot(k).abs() > slack { + return None; + } + } + Some((center, radius, k)) +} + +/// Face `face` turned over: its loops run the other way, each use of it in a shell flips, and +/// each of its edges' uses names its new place. The solid is unchanged. +fn turn_over(brep: &mut b::Brep, face: usize) -> R<()> { + use std::collections::HashMap; + let index = |x: usize| u32::try_from(x).map_err(|_| Unsupported::Invalid("index")); + let fi = index(face)?; + let f = brep.faces.get_mut(face).ok_or(Unsupported::Invalid("face"))?; + // (loop, old position) -> (new position, the use's new direction). + let mut moved: HashMap<(u32, u32), (u32, bool)> = HashMap::new(); + for (li, l) in f.loops.iter_mut().enumerate() { + if let b::Loop::Edges { edges } = l { + let n = edges.len(); + edges.reverse(); + for (p, e) in edges.iter_mut().enumerate() { + e.forward = !e.forward; + moved.insert((index(li)?, index(n - 1 - p)?), (index(p)?, e.forward)); + } + } + } + for e in &mut brep.edges { + for u in e.uses.iter_mut().filter(|u| u.face == fi) { + let &(position, forward) = moved.get(&(u.r#loop, u.position)).ok_or(Unsupported::Invalid("edge use"))?; + u.position = position; + u.upper = !forward; + } + } + for s in &mut brep.shells { + if let b::Shell::Faces { faces, .. } = s { + for o in faces.iter_mut().filter(|o| o.face == fi) { + o.forward = !o.forward; + } + } + } + Ok(()) +}