SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Wave 135/509: kernel: raising a band (lip) and its rim profile on the schema 4 record
jyviko60fbf550b669
diff --git a/crates/kernel/src/lip.rs b/crates/kernel/src/lip.rsindex ec7c51b731..09dcd2dfa1 100644--- a/crates/kernel/src/lip.rs+++ b/crates/kernel/src/lip.rs@@ -1,20 +1,25 @@//! Raising a band of a planar face (a plastic part's lip): the band along one of the face's//! boundary loops, a set width into the face, is pushed out along the face's normal. Built-//! directly from the body's faces (the band's walls continue the walls below, which a boolean-//! union can't join: their faces would coincide).+//! directly on the body's schema 4 record (the band's walls continue the walls below, which a+//! boolean union can't join: their faces would coincide).+use solidcraft_geom::brep::{Brep, Curve, Frame, Surface};use solidcraft_geom::{Loop2, Plane, Region2, Ring, Seg2, Vec3};-use truck_modeling::{self as mt, builder};-use crate::body::{Body, Solid, from_p3, p3, v3};+use crate::assemble::{AFace, AUse, Assembly};+use crate::body::Body;use crate::history::{Change, FaceOrigin, FaceProv};-use crate::record::Operand;+use crate::offset::{Surf, surf_of};use crate::{KernelError, Result, guard};fn fail(m: &str) -> KernelError {KernelError::Failed(format!("raising a band: {m}"))}+fn arr(v: Vec3) -> [f64; 3] {+ [v.x, v.y, v.z]+}+/// A boundary edge of the face, as its ends and (for an arc) a point halfway.#[derive(Clone, Copy)]struct Piece {@@ -24,7 +29,7 @@ struct Piece {}/// The planar face of `body` at `at`: its index and outward normal.-fn face_at(body: &Body, at: Vec3) -> Result<(usize, Vec3)> {+fn face_at(body: &Body, rec: &Brep, at: Vec3) -> Result<(usize, Vec3)> {let size = body.size();let mesh = body.mesh(&crate::MeshTolerance::chord((size * 1e-3).max(1e-3)))?;let near = mesh@@ -43,12 +48,10 @@ fn face_at(body: &Body, at: Vec3) -> Result<(usize, Vec3)> {if d > size * 1e-3 {return Err(fail("no face there"));}- guard("rim face", || {- let face = body.solid.face_iter().nth(f).ok_or_else(|| fail("face"))?;- let mt::Surface::Plane(pl) = face.oriented_surface() else { return Err(fail("the face must be planar")) };- let n = pl.normal();- Ok((f, Vec3::new(n.x, n.y, n.z).normalized().ok_or_else(|| fail("normal"))?))- })+ match surf_of(rec, f) {+ Some(Surf::Plane { n, .. }) => Ok((f, n)),+ _ => Err(fail("the face must be planar")),+ }}/// The face's loop moved `w` into the face (to the left of its edges, as a face's boundary has@@ -125,13 +128,19 @@ fn circle_centre(a: Vec3, m: Vec3, b: Vec3) -> Option<Vec3> {Some(a + (v.cross(w) * u.len2() + w.cross(u) * v.len2()) * (1.0 / d))}-fn pieces(wire: &mt::Wire, size: f64) -> Result<Vec<Piece>> {- wire.edge_iter()- .map(|e| {- let (a, b) = (from_p3(e.front().point()), from_p3(e.back().point()));- match crate::offset::arc_mid(e, size * 1e-6) {- Some(mid) => Ok(Piece { a, b, mid }),- None => Err(fail("edges must be lines or arcs")),+/// The pieces of a loop (seen from outside the body), from its record edges: lines, and arcs+/// with their middle point.+fn pieces(asm: &Assembly, lp: &[AUse]) -> Result<Vec<Piece>> {+ lp.iter()+ .map(|u| {+ let e = asm.edges.get(u.edge as usize).ok_or_else(|| fail("edge"))?;+ let (s, t) = asm.ends(u).ok_or_else(|| fail("edge"))?;+ let (a, b) = (asm.point(s).ok_or_else(|| fail("vertex"))?, asm.point(t).ok_or_else(|| fail("vertex"))?);+ let [t0, t1] = e.interval;+ match e.curve {+ Curve::Line { .. } => Ok(Piece { a, b, mid: None }),+ Curve::Circle { .. } => Ok(Piece { a, b, mid: Some(asm.edge_point(u.edge, 0.5 * (t0 + t1)).ok_or_else(|| fail("arc"))?) }),+ _ => Err(fail("edges must be lines or arcs")),}}).collect()@@ -139,22 +148,17 @@ fn pieces(wire: &mt::Wire, size: f64) -> Result<Vec<Piece>> {/// Signed area ordering including arc midpoints: two semicircles have only two/// vertices, whose polygon has zero area for both the inner and outer loops.-fn turn(wire: &mt::Wire, n: Vec3) -> f64 {- use mt::{BoundedCurve, ParametricCurve};- let ring: Ring<Vec3> = wire- .edge_iter()- .flat_map(|e| {- let c = e.oriented_curve();- let (a, b) = c.range_tuple();- [from_p3(e.front().point()), from_p3(c.subs((a + b) * 0.5))]- })- .collect();+fn turn(pieces: &[Piece], n: Vec3) -> f64 {+ let ring: Ring<Vec3> = pieces.iter().flat_map(|p| [Some(p.a), p.mid]).flatten().collect();ring.area_vector().dot(n)}-fn rim_loops(wires: &[mt::Wire], n: Vec3) -> Result<(&mt::Wire, &mt::Wire)> {- let [a, b] = wires else { return Err(fail("the face must have an outer and one inner loop (a rim)")) };- Ok(if turn(a, n) >= turn(b, n) { (a, b) } else { (b, a) })+/// The face's two loops, outer then inner (a rim), as uses seen from outside.+fn rim_loops(asm: &Assembly, fi: usize, n: Vec3) -> Result<(Vec<AUse>, Vec<AUse>)> {+ let f = asm.faces.get(fi).and_then(Option::as_ref).ok_or_else(|| fail("face"))?;+ let [a, b] = f.loops.as_slice() else { return Err(fail("the face must have an outer and one inner loop (a rim)")) };+ let (ta, tb) = (turn(&pieces(asm, a)?, n), turn(&pieces(asm, b)?, n));+ Ok(if ta >= tb { (a.clone(), b.clone()) } else { (b.clone(), a.clone()) })}fn profile(pieces: &[Piece], plane: &Plane) -> Result<Loop2> {@@ -188,13 +192,13 @@ pub fn rim_band(body: &Body, at: Vec3, width: f64, free: f64, outside: bool) ->if !(width.is_finite() && width > 0.0 && free.is_finite() && free >= 0.0) {return Err(KernelError::Invalid("invalid rim band width".into()));}- let (fi, n) = face_at(body, at)?;+ let rec = crate::native::brep_record(body)?;+ let (fi, n) = face_at(body, &rec, at)?;guard("rim band", || {- let face = body.solid.face_iter().nth(fi).ok_or_else(|| fail("face"))?;- let wires = face.boundaries();- let (outer, inner) = rim_loops(&wires, n)?;+ let asm = Assembly::from_record(&rec)?;+ let (outer, inner) = rim_loops(&asm, fi, n)?;let along = if outside { outer } else { inner };- let p = pieces(along, body.size())?;+ let p = pieces(&asm, &along)?;let tol = (body.size() * 1e-5).max(1e-7);let plane = Plane::from_normal(at, n).ok_or_else(|| fail("rim plane"))?;let into = profile(&offset_loop(&p, n, width, tol)?, &plane)?;@@ -204,6 +208,58 @@ pub fn rim_band(body: &Body, at: Vec3, width: f64, free: f64, outside: bool) ->})}+/// An edge from vertex `a` to vertex `b` along `p` (a line, or an arc about `n` through its+/// middle point): the use that runs from `a` to `b`.+fn piece_edge(asm: &mut Assembly, a: u32, b: u32, p: &Piece, n: Vec3) -> Result<AUse> {+ let Some(m) = p.mid else { return Ok(AUse { edge: asm.line(a, b)?, forward: true, given: None }) };+ let c = circle_centre(p.a, m, p.b).ok_or_else(|| fail("arc"))?;+ let r = c.dist(p.a);+ let x = (p.a - c).normalized().ok_or_else(|| fail("arc"))?;+ let y = n.cross(x);+ let at = |q: Vec3| (q - c).dot(y).atan2((q - c).dot(x)).rem_euclid(std::f64::consts::TAU);+ let (tm, tb) = (at(m), at(p.b));+ let frame = Frame { origin: arr(c), x_axis: arr(x), y_axis: arr(y) };+ // Counter-clockwise about n from a (angle 0) through the middle to b, or the other way.+ let (interval, ends, forward) = if tm < tb { ([0.0, tb], (a, b), true) } else { ([tb, std::f64::consts::TAU], (b, a), false) };+ Ok(AUse { edge: asm.edge(Curve::Circle { frame, radius: r }, interval, ends.0, ends.1)?, forward, given: None })+}++/// The wall raised along `p` (from `bottom` to `top`, joined by `up_a` and `up_b` from its+/// ends), its outside on the right of `p` seen from `n` (`right`) or on its left.+fn wall(p: &Piece, n: Vec3, bottom: &AUse, top: &AUse, up_a: u32, up_b: u32, right: bool, shell: usize) -> Result<AFace> {+ let mut lp = vec![+ bottom.clone(),+ AUse { edge: up_b, forward: true, given: None },+ AUse { edge: top.edge, forward: !top.forward, given: None },+ AUse { edge: up_a, forward: false, given: None },+ ];+ let (surface, natural_out) = match p.mid {+ None => {+ let d = (p.b - p.a).normalized().ok_or_else(|| fail("zero edge"))?;+ // Natural normal d × n: the right of the piece.+ (Surface::Plane { origin: arr(p.a), u_axis: arr(d), v_axis: arr(n) }, right)+ }+ Some(m) => {+ let c = circle_centre(p.a, m, p.b).ok_or_else(|| fail("arc"))?;+ let x = (p.a - c).normalized().ok_or_else(|| fail("arc"))?;+ let surface = Surface::Cylinder { frame: Frame { origin: arr(c), x_axis: arr(x), y_axis: arr(n.cross(x)) }, radius: c.dist(p.a) };+ // The piece's direction at its middle, and which side of it is away from the axis.+ let along = (p.b - p.a).normalized().ok_or_else(|| fail("arc"))?;+ let rightward = along.cross(n);+ let away = (m - c).dot(rightward) > 0.0;+ (surface, away == right)+ }+ };+ // The loop runs up the piece's right: the outside there. On its left it runs the other way.+ if !right {+ lp.reverse();+ for u in &mut lp {+ u.forward = !u.forward;+ }+ }+ Ok(AFace { surface, natural_out, loops: vec![lp], shell, domain: None })+}+/// Raise the band of the planar face at `at` that runs `width` wide along its outer loop/// (`outside`) or its inner loop, by `height` along the face's normal.pub fn raise_band(body: &Body, at: Vec3, width: f64, height: f64, outside: bool) -> Result<Body> {@@ -211,96 +267,99 @@ pub fn raise_band(body: &Body, at: Vec3, width: f64, height: f64, outside: bool)if !(width > 1e-6 && height > 1e-6 && width.is_finite() && height.is_finite()) {return Err(KernelError::Invalid("the band's width and height must be positive".into()));}- if body.solid.boundaries().len() != 1 {+ let rec = crate::native::brep_record(body)?;+ if rec.shells.len() != 1 {return Err(fail("a body in one piece"));}let size = body.size();let tol = (size * 1e-7).max(1e-9) * 100.0;- let (fi, n) = face_at(body, at)?;+ let (fi, n) = face_at(body, &rec, at)?;guard("lip", || {- let faces: Vec<mt::Face> = body.solid.face_iter().cloned().collect();- let f = faces.get(fi).ok_or_else(|| fail("face"))?;- let wires = f.boundaries();- let (outer, inner) = rim_loops(&wires, n)?;+ let mut asm = Assembly::from_record(&rec)?;+ let (outer, inner) = rim_loops(&asm, fi, n)?;let (along, other) = if outside { (outer, inner) } else { (inner, outer) };- let pieces = pieces(along, size)?;- let moved = offset_loop(&pieces, n, width, tol)?;- // The band's other edge, on the face.- let verts: Vec<mt::Vertex> = moved.iter().map(|p| builder::vertex(p3(p.a))).collect();- let k = verts.len();- let mut cedges: Vec<mt::Edge> = Vec::with_capacity(k);- for (i, p) in moved.iter().enumerate() {- let (Some(a), Some(b)) = (verts.get(i), verts.get((i + 1) % k)) else { return Err(fail("vertex")) };- cedges.push(match p.mid {- None => builder::line(a, b),- Some(m) => builder::circle_arc(a, b, p3(m)),- });- }- // The loop's edges and the band's edge beside each, by the loop edge's index in the body.- let operand = Operand::new(body);- let mut wall_edge: std::collections::HashMap<mt::EdgeID, usize> = std::collections::HashMap::new();- for (e, ce) in along.edge_iter().zip(&cedges) {- if let Some(i) = operand.edges.get(&e.id()) {- wall_edge.insert(e.id(), *i);- wall_edge.insert(ce.id(), *i);- }+ let face = asm.faces.get_mut(fi).and_then(Option::take).ok_or_else(|| fail("face"))?;+ let below = pieces(&asm, &along)?;+ let moved = offset_loop(&below, n, width, tol)?;+ let k = moved.len();+ let up = n * height;+ // The band's other edge, on the face, and the band's top edges above both.+ let cverts: Vec<u32> = moved.iter().map(|p| asm.vertex(p.a)).collect::<Result<_>>()?;+ let averts: Vec<u32> = along.iter().map(|u| asm.ends(u).map(|e| e.0).ok_or_else(|| fail("edge"))).collect::<Result<_>>()?;+ let atop: Vec<u32> = below.iter().map(|p| asm.vertex(p.a + up)).collect::<Result<_>>()?;+ let ctop: Vec<u32> = moved.iter().map(|p| asm.vertex(p.a + up)).collect::<Result<_>>()?;+ let lift = |p: &Piece| Piece { a: p.a + up, b: p.b + up, mid: p.mid.map(|m| m + up) };+ let (mut cedges, mut aup, mut cup, mut atops, mut ctops) = (Vec::new(), Vec::new(), Vec::new(), Vec::new(), Vec::new());+ for i in 0..k {+ let j = (i + 1) % k;+ let (Some(&ca), Some(&cb), Some(&ta), Some(&tb), Some(&da), Some(&db), Some(&va)) =+ (cverts.get(i), cverts.get(j), atop.get(i), atop.get(j), ctop.get(i), ctop.get(j), averts.get(i))+ else {+ return Err(fail("vertex"));+ };+ let (Some(pb), Some(pc)) = (below.get(i), moved.get(i)) else { return Err(fail("piece")) };+ cedges.push(piece_edge(&mut asm, ca, cb, pc, n)?);+ atops.push(piece_edge(&mut asm, ta, tb, &lift(pb), n)?);+ ctops.push(piece_edge(&mut asm, da, db, &lift(pc), n)?);+ aup.push(asm.line(va, ta)?);+ cup.push(asm.line(ca, da)?);}- let c: mt::Wire = cedges.into();// The rest of the face: its other loop, and the band's edge as a loop of its own.// (The band's edge runs the face's way round: a hole when the band follows the inner// loop, the outer loop when it follows the outer.)- let rest = mt::Face::try_new(vec![other.clone(), c.clone()], f.oriented_surface()).map_err(|e| fail(&e.to_string()))?;- // Walls: the face's loop and the band's edge swept out; the band's top.- let up = v3(n * height);- let wall_along: mt::Shell = builder::tsweep(along, up);- let wall_c: mt::Shell = builder::tsweep(&c, up);- let top_of = |sh: &mt::Shell| -> Vec<mt::Wire> {- sh.extract_boundaries().into_iter().filter(|w| w.vertex_iter().all(|v| (from_p3(v.point()) - at).dot(n) > height * 0.5)).collect()- };- let flipped = |sh: &mt::Shell, yes: bool| -> mt::Shell {- if yes { sh.face_iter().map(|x| x.inverse()).collect::<Vec<_>>().into() } else { sh.clone() }+ let rest_loops = if outside { vec![cedges.clone(), other] } else { vec![other, cedges.clone()] };+ let rest = AFace { surface: face.surface.clone(), natural_out: face.natural_out, loops: rest_loops, shell: face.shell, domain: face.domain };+ // Walls: along the face's loop (the band's outside continues the walls below, on the+ // loop's right) and along the band's edge (its outside on that edge's left).+ let mut walls = Vec::with_capacity(2 * k);+ for (right, (pieces, (bottoms, (tops, ups)))) in [(true, (&below, (&along, (&atops, &aup)))), (false, (&moved, (&cedges, (&ctops, &cup))))] {+ for i in 0..k {+ let j = (i + 1) % k;+ let (Some(p), Some(bottom), Some(top), Some(&ua), Some(&ub)) = (pieces.get(i), bottoms.get(i), tops.get(i), ups.get(i), ups.get(j))+ else {+ return Err(fail("wall"));+ };+ let bottom = AUse { edge: bottom.edge, forward: bottom.forward, given: None };+ walls.push(wall(p, n, &bottom, top, ua, ub, right, face.shell)?);+ }+ }+ // The band's top: above the face's loop as it runs, above the band's edge the other way.+ let reversed = |l: &[AUse]| -> Vec<AUse> { l.iter().rev().map(|u| AUse { edge: u.edge, forward: !u.forward, given: None }).collect() };+ let top_loops = if outside { vec![atops.clone(), reversed(&ctops)] } else { vec![reversed(&ctops), atops.clone()] };+ let origin = below.first().map(|p| p.a + up).ok_or_else(|| fail("piece"))?;+ let u = n.any_perp();+ let top = AFace {+ surface: Surface::Plane { origin: arr(origin), u_axis: arr(u), v_axis: arr(n.cross(u)) },+ natural_out: true,+ loops: top_loops,+ shell: face.shell,+ domain: None,};// History (one operand, the body), face by face as gathered below: the other faces- // kept, the face trimmed to what the band leaves, each wall made along the loop- // edge it rises from (the band's inner wall along the edge it runs beside), and the- // band's top an offset of the face. (Flipping a face keeps its edges.)- let history: Option<Vec<FaceProv>> = crate::record::kept_except(faces.len(), fi)- .map(Some)- .chain([Some(crate::record::from_face(0, fi, Change::Modified))])- .chain(wall_along.face_iter().chain(wall_c.face_iter()).map(|w| {- let edge = w.absolute_boundaries().iter().flatten().find_map(|e| wall_edge.get(&e.id()))?;- Some(crate::record::generated(vec![FaceOrigin::Edge { operand: 0, edge: *edge }]))- }))- .chain([Some(crate::record::generated(vec![FaceOrigin::Offset { operand: 0, face: fi }]))])- .collect();- let mut last = String::new();- for flip in 0..8u32 {- let (wa, wc) = (flipped(&wall_along, flip & 1 == 1), flipped(&wall_c, flip & 2 == 2));- let mut tops = top_of(&wa);- tops.extend(top_of(&wc));- if tops.len() != 2 {- return Err(fail("the band's top"));- }- // The top closes both walls: its loops run against theirs.- let tops: Vec<mt::Wire> = tops.iter().map(|w| w.inverse()).collect();- let Ok(top) = builder::try_attach_plane(&tops) else { continue };- let top = if flip & 4 == 4 { top.inverse() } else { top };- let mut all: Vec<mt::Face> = faces.iter().enumerate().filter(|(i, _)| *i != fi).map(|(_, x)| x.clone()).collect();- all.push(rest.clone());- all.extend(wa.face_iter().cloned());- all.extend(wc.face_iter().cloned());- all.push(top);- match Solid::try_new(vec![all.into()]) {- Ok(s) => {- let b = Body::new(s)?;- if b.validity().is_empty() {- return crate::record::attach(b, std::slice::from_ref(&operand), history.clone(), Default::default());- }- last = b.validity().join("; ");- }- Err(e) => last = e.to_string(),+ // kept, the face trimmed to what the band leaves, each wall made along the loop edge it+ // rises from (the band's inner wall along the edge it runs beside), and the band's top+ // an offset of the face.+ let loop_edges: Vec<Option<usize>> = along.iter().map(|u| asm.edges.get(u.edge as usize).and_then(|e| e.source)).collect();+ let mut history: Vec<FaceProv> = crate::record::kept_except(rec.faces.len(), fi).collect();+ history.push(crate::record::from_face(0, fi, Change::Modified));+ for _ in 0..2 {+ for e in &loop_edges {+ let e = e.ok_or_else(|| fail("a loop edge the body doesn't have"))?;+ history.push(crate::record::generated(vec![FaceOrigin::Edge { operand: 0, edge: e }]));}}- Err(fail(&last))+ history.push(crate::record::generated(vec![FaceOrigin::Offset { operand: 0, face: fi }]));+ asm.face(rest);+ for w in walls {+ asm.face(w);+ }+ asm.face(top);+ let finished = asm.finish()?;+ let b = crate::assemble::body_with_history(&finished, &asm, body, history)?;+ let problems = b.validity();+ if !problems.is_empty() {+ return Err(fail(&problems.join("; ")));+ }+ Ok(b)})}