Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Wave 202/509: kernel: a raised band reads its arcs' circles from the record (and 3 more)

jyviko6354e472ed79
diff --git a/crates/geom/src/profile.rs b/crates/geom/src/profile.rs
index 7edc5985f1..f51cfcbd21 100644
--- a/crates/geom/src/profile.rs
+++ b/crates/geom/src/profile.rs
@@ -497,19 +497,14 @@ impl Loop2 {
pub fn inradius(&self, tol: f64) -> f64 {
max_clearance(&[self.polyline(tol)])
}
- /// Full circle as two half arcs (counter-clockwise).
+ /// Full circle as one arc from angle 0 (counter-clockwise): one closed curve, so a solid
+ /// swept from it has one wall, and an edge round it is one edge.
pub fn circle(center: Vec2, radius: f64) -> Loop2 {
- Loop2 {
- segs: vec![
- Seg2::Arc { center, radius, start: 0.0, sweep: std::f64::consts::PI },
- Seg2::Arc { center, radius, start: std::f64::consts::PI, sweep: std::f64::consts::PI },
- ],
- }
+ Loop2::circle_from(center, radius, 0.0)
}
- /// Full circle starting (and split) at angle `start`.
+ /// Full circle as one arc starting (and ending) at angle `start`, counter-clockwise.
pub fn circle_from(center: Vec2, radius: f64, start: f64) -> Loop2 {
- use std::f64::consts::PI;
- Loop2 { segs: vec![Seg2::Arc { center, radius, start, sweep: PI }, Seg2::Arc { center, radius, start: start + PI, sweep: PI }] }
+ Loop2 { segs: vec![Seg2::Arc { center, radius, start, sweep: TAU }] }
}
pub fn polygon(pts: &[Vec2]) -> Loop2 {
let n = pts.len();
diff --git a/crates/kernel/src/assemble.rs b/crates/kernel/src/assemble.rs
index b81478fd46..7963c794df 100644
--- a/crates/kernel/src/assemble.rs
+++ b/crates/kernel/src/assemble.rs
@@ -11,7 +11,6 @@
//! normal, as the record does.
use solidcraft_geom::Vec3;
-use solidcraft_geom::brep::eval::CurveEval;
use solidcraft_geom::brep::pcurve::{EdgeUse, pcurves_within};
use solidcraft_geom::brep::{Brep, Curve, Curve2, Edge, Face, Loop, Natural, OrientedEdge, OrientedFace, Region, Shell, Surface, VERSION, Vertex};
@@ -186,12 +185,6 @@ impl Assembly {
Some(if u.forward { (a, b) } else { (b, a) })
}
- /// The point of edge `e` at its parameter `t`.
- pub(crate) fn edge_point(&self, e: u32, t: f64) -> Option<Vec3> {
- let e = self.edges.get(e as usize)?;
- CurveEval::new(&e.curve).ok()?.point(t)
- }
-
/// The record of the faces left and added, in canonical order (`Brep::canonical`), checked:
/// each face's loops stored relative to its surface's natural normal with their pcurves and
/// parameter box, shells and regions as the source's (a region whose outer shell lost every
diff --git a/crates/kernel/src/emboss.rs b/crates/kernel/src/emboss.rs
index e4abdac275..11f65286af 100644
--- a/crates/kernel/src/emboss.rs
+++ b/crates/kernel/src/emboss.rs
@@ -20,15 +20,13 @@ fn angle(p: Vec3, o: Vec3, axis: Vec3, radial: Vec3, tangent: Vec3) -> f64 {
let w = w - axis * w.dot(axis);
w.dot(tangent).atan2(w.dot(radial))
}
-fn unwrap(a: f64, around: f64) -> f64 {
- around + (a - around + std::f64::consts::PI).rem_euclid(std::f64::consts::TAU) - std::f64::consts::PI
-}
fn arr(v: Vec3) -> [f64; 3] {
[v.x, v.y, v.z]
}
/// The angles a wall face spans about the axis, seen from `radial`: from one of its arcs about
-/// the axis (a face of one loop of four edges).
+/// the axis (a face of one loop of four edge uses: two arcs and two lines, or a whole turn's two
+/// circles and its seam used twice).
fn wall_angles(b: &Brep, face: usize, o: Vec3, axis: Vec3, radial: Vec3, tangent: Vec3) -> Option<(f64, f64)> {
let f = b.faces.get(face)?;
let [Loop::Edges { edges }] = f.loops.as_slice() else { return None };
@@ -42,12 +40,13 @@ fn wall_angles(b: &Brep, face: usize, o: Vec3, axis: Vec3, radial: Vec3, tangent
if z.dot(axis).abs() < 1.0 - 1e-9 {
continue;
}
+ // The circle's parameter is its angle: the wall spans the edge's interval about the
+ // angle of its middle (a whole turn, from the seam, for a wall in one piece).
let c = CurveEval::new(&e.curve).ok()?;
let [t0, t1] = e.interval;
let am = angle(c.point(0.5 * (t0 + t1))?, o, axis, radial, tangent);
- let aa = unwrap(angle(c.point(t0)?, o, axis, radial, tangent), am);
- let ab = unwrap(angle(c.point(t1)?, o, axis, radial, tangent), am);
- return Some((aa.min(ab), aa.max(ab)));
+ let half = 0.5 * (t1 - t0);
+ return Some((am - half, am + half));
}
None
}
diff --git a/crates/kernel/src/lip.rs b/crates/kernel/src/lip.rs
index a191a9b3c1..d512a0e4af 100644
--- a/crates/kernel/src/lip.rs
+++ b/crates/kernel/src/lip.rs
@@ -20,12 +20,39 @@ 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.
+/// A boundary edge of the face, as its ends and, for an arc, its circle: the centre and the
+/// angle it turns through about the face's normal from `a` to `b` (positive counter-clockwise;
+/// ±2π for a whole circle, whose ends are one point).
#[derive(Clone, Copy)]
struct Piece {
a: Vec3,
b: Vec3,
- mid: Option<Vec3>,
+ arc: Option<Arc>,
+}
+
+#[derive(Clone, Copy)]
+struct Arc {
+ centre: Vec3,
+ sweep: f64,
+}
+
+impl Piece {
+ /// The point a fraction `f` of the way along the piece (an arc turning about `n`).
+ fn at(&self, n: Vec3, f: f64) -> Vec3 {
+ match self.arc {
+ None => self.a + (self.b - self.a) * f,
+ Some(Arc { centre, sweep }) => {
+ let x = self.a - centre;
+ let (s, c) = (f * sweep).sin_cos();
+ centre + x * c + n.cross(x) * s
+ }
+ }
+ }
+
+ /// The piece moved by `d`.
+ fn moved(&self, d: Vec3) -> Piece {
+ Piece { a: self.a + d, b: self.b + d, arc: self.arc.map(|x| Arc { centre: x.centre + d, ..x }) }
+ }
}
/// The planar face of `body` at `at`: its index and outward normal.
@@ -60,25 +87,21 @@ fn offset_loop(pieces: &[Piece], n: Vec3, w: f64, tol: f64) -> Result<Vec<Piece>
let left = |a: Vec3, b: Vec3| n.cross(b - a).normalized();
let mut out: Vec<Piece> = Vec::new();
for p in pieces {
- out.push(match p.mid {
+ out.push(match p.arc {
None => {
let l = left(p.a, p.b).ok_or_else(|| fail("zero edge"))?;
- Piece { a: p.a + l * w, b: p.b + l * w, mid: None }
+ p.moved(l * w)
}
- Some(m) => {
- // Each point moves square to the arc (along its radius), to the left.
- let lm = left(p.a, p.b).ok_or_else(|| fail("arc"))?;
- let c = circle_centre(p.a, m, p.b).ok_or_else(|| fail("arc"))?;
- let r = m.dist(c);
- let shift = if (m - c).dot(lm) >= 0.0 { w } else { -w };
+ Some(arc) => {
+ // Each point moves along its radius, to the left: towards the centre of an arc
+ // turning counter-clockwise, away from that of one turning clockwise.
+ let r = p.a.dist(arc.centre);
+ let shift = if arc.sweep > 0.0 { -w } else { w };
if r + shift <= tol {
return Err(fail("the offset closes an arc"));
}
- // Use one radial scale for the whole arc. At a semicircle's ends the
- // radial is perpendicular to the chord's left, so its dot product cannot
- // reliably choose the side independently at each end.
- let moved = |q: Vec3| c + (q - c) * ((r + shift) / r);
- Piece { a: moved(p.a), b: moved(p.b), mid: Some(moved(m)) }
+ let moved = |q: Vec3| arc.centre + (q - arc.centre) * ((r + shift) / r);
+ Piece { a: moved(p.a), b: moved(p.b), arc: Some(arc) }
}
});
}
@@ -94,7 +117,7 @@ fn offset_loop(pieces: &[Piece], n: Vec3, w: f64, tol: f64) -> Result<Vec<Piece>
}
continue;
}
- match (pi.mid, pj.mid) {
+ match (pi.arc, pj.arc) {
(None, None) => {
let (d1, d2) = (pi.b - pi.a, pj.b - pj.a);
let w0 = pj.a - pi.a;
@@ -118,38 +141,38 @@ fn offset_loop(pieces: &[Piece], n: Vec3, w: f64, tol: f64) -> Result<Vec<Piece>
Ok(out)
}
-fn circle_centre(a: Vec3, m: Vec3, b: Vec3) -> Option<Vec3> {
- let (u, v) = (b - a, m - a);
- let w = u.cross(v);
- let d = 2.0 * w.len2();
- if d < 1e-300 {
- return None;
- }
- Some(a + (v.cross(w) * u.len2() + w.cross(u) * v.len2()) * (1.0 / d))
-}
-
-/// 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>> {
+/// The pieces of a loop (seen from outside the body, whose normal is `n`), from its record edges:
+/// lines, and arcs with their circle.
+fn pieces(asm: &Assembly, lp: &[AUse], n: Vec3) -> 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"))?) }),
+ match &e.curve {
+ Curve::Line { .. } => Ok(Piece { a, b, arc: None }),
+ Curve::Circle { frame, .. } => {
+ // The parameter is the angle about the frame's z, which lies along ±n.
+ let z = Vec3::from(frame.x_axis).cross(Vec3::from(frame.y_axis));
+ if z.cross(n).len() > 1e-9 {
+ return Err(fail("an arc not in the face's plane"));
+ }
+ let along = if u.forward { 1.0 } else { -1.0 };
+ let sweep = (t1 - t0) * along * z.dot(n).signum();
+ Ok(Piece { a, b, arc: Some(Arc { centre: Vec3::from(frame.origin), sweep }) })
+ }
_ => Err(fail("edges must be lines or arcs")),
}
})
.collect()
}
-/// Signed area ordering including arc midpoints: two semicircles have only two
-/// vertices, whose polygon has zero area for both the inner and outer loops.
+/// Signed area ordering, through points along the arcs: a whole circle has one vertex, two
+/// semicircles two, whose polygon has no area.
fn turn(pieces: &[Piece], n: Vec3) -> f64 {
- let ring: Ring<Vec3> = pieces.iter().flat_map(|p| [Some(p.a), p.mid]).flatten().collect();
+ let ring: Ring<Vec3> =
+ pieces.iter().flat_map(|p| if p.arc.is_some() { vec![p.a, p.at(n, 1.0 / 3.0), p.at(n, 2.0 / 3.0)] } else { vec![p.a] }).collect();
ring.area_vector().dot(n)
}
@@ -157,26 +180,21 @@ fn turn(pieces: &[Piece], n: Vec3) -> f64 {
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));
+ let (ta, tb) = (turn(&pieces(asm, a, n)?, n), turn(&pieces(asm, b, n)?, n));
Ok(if ta >= tb { (a.clone(), b.clone()) } else { (b.clone(), a.clone()) })
}
fn profile(pieces: &[Piece], plane: &Plane) -> Result<Loop2> {
- use std::f64::consts::TAU;
let segs = pieces
.iter()
.map(|p| {
let (a, b) = (plane.to_local(p.a), plane.to_local(p.b));
- Ok(match p.mid {
+ Ok(match p.arc {
None => Seg2::Line { a, b },
- Some(m) => {
- let center = plane.to_local(circle_centre(p.a, m, p.b).ok_or_else(|| fail("arc"))?);
- let mid = plane.to_local(m);
- let start = (a - center).angle();
- let end = (b - center).angle();
- let sweep = (end - start).rem_euclid(TAU);
- let sweep = if ((mid - center).angle() - start).rem_euclid(TAU) <= sweep { sweep } else { sweep - TAU };
- Seg2::Arc { center, radius: a.dist(center), start, sweep }
+ // The plane's normal is the face's: the arc turns the same way in it.
+ Some(arc) => {
+ let center = plane.to_local(arc.centre);
+ Seg2::Arc { center, radius: a.dist(center), start: (a - center).angle(), sweep: arc.sweep }
}
})
})
@@ -198,7 +216,7 @@ pub fn rim_band(body: &Body, at: Vec3, width: f64, free: f64, outside: bool) ->
let asm = Assembly::from_record(&rec)?;
let (outer, inner) = rim_loops(&asm, fi, n)?;
let along = if outside { outer } else { inner };
- let p = pieces(&asm, &along)?;
+ let p = pieces(&asm, &along, n)?;
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)?;
@@ -208,19 +226,16 @@ 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`.
+/// An edge from vertex `a` to vertex `b` along `p` (a line, or an arc of its circle about `n`):
+/// 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) };
+ let Some(arc) = p.arc else { return Ok(AUse { edge: asm.line(a, b)?, forward: true, given: None }) };
+ let r = arc.centre.dist(p.a);
+ let x = (p.a - arc.centre).normalized().ok_or_else(|| fail("arc"))?;
+ let frame = Frame { origin: arr(arc.centre), x_axis: arr(x), y_axis: arr(n.cross(x)) };
+ // Counter-clockwise about n from a (angle 0) to b, or clockwise: then from b to a.
+ let tau = std::f64::consts::TAU;
+ let (interval, ends, forward) = if arc.sweep > 0.0 { ([0.0, arc.sweep], (a, b), true) } else { ([tau + arc.sweep, tau], (b, a), false) };
Ok(AUse { edge: asm.edge(Curve::Circle { frame, radius: r }, interval, ends.0, ends.1)?, forward, given: None })
}
@@ -233,21 +248,18 @@ fn wall(p: &Piece, n: Vec3, bottom: &AUse, top: &AUse, up_a: u32, up_b: u32, rig
AUse { edge: top.edge, forward: !top.forward, given: None },
AUse { edge: up_a, forward: false, given: None },
];
- let (surface, natural_out) = match p.mid {
+ let (surface, natural_out) = match p.arc {
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)
+ Some(arc) => {
+ let x = (p.a - arc.centre).normalized().ok_or_else(|| fail("arc"))?;
+ let surface =
+ Surface::Cylinder { frame: Frame { origin: arr(arc.centre), x_axis: arr(x), y_axis: arr(n.cross(x)) }, radius: arc.centre.dist(p.a) };
+ // Right of an arc turning counter-clockwise about n is away from its axis.
+ (surface, (arc.sweep > 0.0) == right)
}
};
// The loop runs up the piece's right: the outside there. On its left it runs the other way.
@@ -279,7 +291,7 @@ pub fn raise_band(body: &Body, at: Vec3, width: f64, height: f64, outside: bool)
let (outer, inner) = rim_loops(&asm, fi, n)?;
let (along, other) = if outside { (outer, inner) } else { (inner, outer) };
let face = asm.faces.get_mut(fi).and_then(Option::take).ok_or_else(|| fail("face"))?;
- let below = pieces(&asm, &along)?;
+ let below = pieces(&asm, &along, n)?;
let moved = offset_loop(&below, n, width, tol)?;
let k = moved.len();
let up = n * height;
@@ -288,7 +300,7 @@ pub fn raise_band(body: &Body, at: Vec3, width: f64, height: f64, outside: bool)
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 lift = |p: &Piece| p.moved(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;