Skip to content

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

Wave 396/509: Kernel: a mitred sweep carries a slanted section all the way to each mitre (and 3 more)

jyvikoe4ebb8c82028
diff --git a/crates/engine/src/cmd/face_tests.rs b/crates/engine/src/cmd/face_tests.rs
index 5af20f9c2f..e9afe13893 100644
--- a/crates/engine/src/cmd/face_tests.rs
+++ b/crates/engine/src/cmd/face_tests.rs
@@ -137,20 +137,23 @@ fn generated_profiles_and_press_pull_convert_rotated_occurrence_picks_once() {
}
/// A 40 x 30 x 20 box whose top is split at x = 20 and its left half raised 5 by Offset Face:
-/// the raised top has no construction certificate and no exact history name yet (#494).
+/// the raised top has no construction certificate, and an exact history name from SMLib's
+/// offset history.
fn raised_half(s: &mut Session, body: &str) {
run(s, "solid.box", json!({"length":40,"width":30,"height":20,"body_name":body}));
run(s, "solid.split_face", json!({"faces":[[10,15,20]],"plane":{"origin":[20,0,0],"normal":[1,0,0]}}));
run(s, "solid.offset_face", json!({"faces":[[10,15,20]],"distance":5}));
}
+/// Internal capture of a face in another component whose occurrence has an uncaptured move:
+/// the raised top has no construction certificate, but its exact history name keeps it, so the
+/// capture is an exact (lineage) anchor on that occurrence's path, whose pending position is
+/// captured when the attachment is made (`capture_positions`). Capturing changes nothing.
#[test]
-fn legacy_internal_capture_refuses_an_uncaptured_source_in_another_component() {
+fn internal_capture_in_another_component_anchors_an_offset_face_by_its_history_name() {
let mut s = Session::default();
let component = run(&mut s, "component.create", json!({"name":"Source","grounded":false}));
let occurrence = component["occurrence"].as_u64().unwrap();
- // A face Offset Face raised has no construction certificate or exact history name yet:
- // the legacy path.
raised_half(&mut s, "Stock");
run(&mut s, "component.activate", json!({"component":0}));
run(&mut s, "occurrence.move", json!({"occurrence":occurrence,"translate":[30,0,0],"capture":false}));
@@ -165,15 +168,20 @@ fn legacy_internal_capture_refuses_an_uncaptured_source_in_another_component() {
.into_iter()
.find(|face| face.plane_normal.is_some_and(|normal| normal.z > 0.999) && (face.centroid.z - 25.0).abs() < 1e-6)
.unwrap();
+ assert!(state.body("Stock").unwrap().body.face_plane(end.index).is_none(), "the raised top has no construction certificate");
let before = s.doc.to_json();
- let error = super::super::sketch::face::capture_internal(
+ let pending = s.pending_moves.clone();
+ let plane = super::super::sketch::face::capture_internal(
&s,
&json!({"face":[40,15,25],"body":"Stock","index":end.index,"path":[occurrence]}),
"internal",
)
- .unwrap_err();
- assert!(error.to_string().contains("capture the source occurrence position"), "{error}");
+ .unwrap();
+ let anchor = super::super::sketch::face::anchor(&plane).expect("an exact attachment");
+ assert_eq!(anchor.target.certificate, Some(solidcraft_doc::config::FaceCertificate::Lineage));
+ assert_eq!(anchor.path, vec![occurrence]);
assert_eq!(s.doc.to_json(), before);
+ assert_eq!(s.pending_moves, pending);
}
#[test]
diff --git a/crates/kernel/src/mesh_memo_tests.rs b/crates/kernel/src/mesh_memo_tests.rs
index 55bb81c5b9..adef8c5481 100644
--- a/crates/kernel/src/mesh_memo_tests.rs
+++ b/crates/kernel/src/mesh_memo_tests.rs
@@ -14,8 +14,9 @@ fn plate() -> Body {
plate
}
-/// Regions cut from a body that keeps its meshes come out as from the body itself, to the bit,
-/// and the body is meshed once for all of them.
+/// Regions cut from a body that keeps its meshes come out as from the body itself, to the bit.
+/// SMLib's booleans read the exact record and mesh neither operand, so they leave the memo
+/// empty; the body's own meshing then fills it once per tolerance and reuses it.
#[test]
fn regions_cut_from_a_body_keeping_its_meshes_are_unchanged() {
let plate = plate();
@@ -35,10 +36,11 @@ fn regions_cut_from_a_body_keeping_its_meshes_are_unchanged() {
);
}
let memo = kept.meshes.as_ref().unwrap();
- assert_eq!(memo.made.lock().unwrap().len(), 1, "one tolerance, one meshing");
+ assert_eq!(memo.made.lock().unwrap().len(), 0, "a boolean meshes neither operand");
// A mesh from the memo is the mesh made afresh.
let (a, b) = (kept.mesh(&crate::MeshTolerance::chord(0.05)).unwrap(), plate.mesh(&crate::MeshTolerance::chord(0.05)).unwrap());
let (a2, _) = (kept.mesh(&crate::MeshTolerance::chord(0.05)).unwrap(), ());
+ assert_eq!(memo.made.lock().unwrap().len(), 1, "one tolerance, one meshing");
for m in [&a, &a2] {
assert_eq!(m.triangles, b.triangles);
assert!(
diff --git a/crates/kernel/src/provenance.rs b/crates/kernel/src/provenance.rs
index 89b7c61546..4a47d718bb 100644
--- a/crates/kernel/src/provenance.rs
+++ b/crates/kernel/src/provenance.rs
@@ -309,7 +309,10 @@ pub fn offset_origins(result: &Body, input: &Body, thickness: f64, prov: &mut Hi
/// Origins of any swept tool's faces (sweep, loft, pipe; extrude and revolve too) from where
/// they start: the face lying in the profile's plane is the start cap, a face with an edge in
-/// that plane sweeps the profile segment under the edge, and the rest are end caps.
+/// that plane sweeps the profile segment under the edge, and the rest are end caps. That holds
+/// for a tool whose every wall runs the whole path; one swept piece by piece along its path
+/// (SMLib's sweep along lines and arcs, mitred at each corner) has walls starting further on,
+/// which only the tool's own history names ([`sweep_origins`]).
pub fn swept_origins(tool: &Body, plane: &Plane, regions: &[Region2]) -> Result<Vec<FaceOrigin>> {
let size = tool.size().max(1e-9);
let m = tool.mesh(&crate::MeshTolerance::chord(size * 2e-4))?;
@@ -339,32 +342,20 @@ pub fn swept_origins(tool: &Body, plane: &Plane, regions: &[Region2]) -> Result<
Ok(out)
}
-/// Origins of a [`crate::sweep_path`] tool's faces. Its walls come in profile order (once for
-/// smooth walls, once per station for ruled ones) followed by the start and end caps; checked
-/// against the start cap lying in the profile's plane, else found as [`swept_origins`] does.
+/// Origins of a [`crate::sweep_path`] tool's faces: the ones the sweep recorded as it built them
+/// ([`Body::history`]: the start and end caps, each wall from the profile segment it sweeps,
+/// along every piece of the path), the first of each face's; a face the tool names no origin
+/// for (or a tool without a history) found as [`swept_origins`] does.
pub fn sweep_origins(tool: &Body, plane: &Plane, regions: &[Region2]) -> Result<Vec<FaceOrigin>> {
- let n = tool.face_count();
- let k = segments(regions).len();
- let size = tool.size().max(1e-9);
- if k > 0 && n >= 2 && (n - 2).is_multiple_of(k) {
- let m = tool.mesh(&crate::MeshTolerance::chord(size * 2e-4))?;
- let faces = face_tris(&m);
- let start_flat = faces.get(n - 2).is_some_and(|f| f.tris.iter().all(|(t, _)| t.iter().all(|p| plane.height(*p).abs() <= size * 1e-6)));
- if start_flat {
- return Ok((0..n)
- .map(|i| {
- if i + 2 == n {
- FaceOrigin::Cap { end: false }
- } else if i + 1 == n {
- FaceOrigin::Cap { end: true }
- } else {
- FaceOrigin::Profile { segment: i % k }
- }
- })
- .collect());
- }
+ let recorded: Vec<Option<FaceOrigin>> = match tool.history() {
+ Some(h) if h.faces.len() == tool.face_count() => h.faces.iter().map(|f| f.origins.first().copied()).collect(),
+ _ => vec![None; tool.face_count()],
+ };
+ if recorded.iter().all(Option::is_some) {
+ return Ok(recorded.into_iter().flatten().collect());
}
- swept_origins(tool, plane, regions)
+ let found = swept_origins(tool, plane, regions)?;
+ Ok(recorded.into_iter().zip(found).map(|(r, f)| r.unwrap_or(f)).collect())
}
/// Replace origins on operand `operand` (a tool made by the operation) with that tool's own
diff --git a/crates/kernel/src/smlib_sweeps.rs b/crates/kernel/src/smlib_sweeps.rs
index 008b981ac3..cbaf1e922f 100644
--- a/crates/kernel/src/smlib_sweeps.rs
+++ b/crates/kernel/src/smlib_sweeps.rs
@@ -765,6 +765,7 @@ mod imp {
s.and_then(crate::PathSeg::tangents).ok_or_else(|| KernelError::Invalid("a path segment has no direction".into()))
};
let (first_t, _) = tangent(path.first())?;
+ let offsets = section_offsets(plane, pieces, start, first_t, 1.0);
let (_, last_t) = tangent(path.last())?;
let end = path.last().map(seg_ends).transpose()?.map(|(_, b)| b).ok_or_else(|| KernelError::Invalid("empty path".into()))?;
// A closed path ends where it starts, with no caps; at a corner there the last run and the
@@ -803,12 +804,10 @@ mod imp {
inside.extend(seeds(&pose, pieces, |q| apply(&middle, q)));
(piece, placed(&pose, &last))
} else {
- // On past each mitre: the profile's reach times the tangent of half the turn takes
- // every point of it to the mitre's plane; a little further, so the cut back runs
- // through the walls, never along the run's own end.
- let over = |turn: f64| reach * (turn * 0.5).tan() * 1.1 + reach * 1e-3 + 1e-6;
- let pre = entry.map_or(0.0, |(_, _, turn)| over(turn));
- let post = exit.map(|(_, turn)| over(turn)).unwrap_or(0.0);
+ // On past each mitre, far enough to take every point of the section to the
+ // mitre's plane ([`mitre_lead`]).
+ let pre = entry.map_or(0.0, |(_, _, turn)| mitre_lead(&offsets, reach, turn, false));
+ let post = exit.map(|(_, turn)| mitre_lead(&offsets, reach, turn, true)).unwrap_or(0.0);
let mut route = Vec::with_capacity(segs.len() + 2);
if pre > 0.0 {
route.push(crate::PathSeg::Line { a: a0 - t0 * pre, b: a0 });
@@ -819,7 +818,18 @@ mod imp {
}
let from = moved_plane(&pose, t0 * -pre);
let (mut piece, [_, middle, last]) = swept(&from, pieces, &route, false)?;
- inside.extend(seeds(&from, pieces, |q| apply(&middle, q)));
+ // Each wall is known by its piece's middle half way along the stretch of the run
+ // that point keeps between the mitres: a point standing `s` ahead of the path
+ // keeps the stretch `s` back from the run's (a profile at a slant to a run shorter
+ // than its slant reaches past the mitres from the run's middle section).
+ let run_length: f64 = segs.iter().map(seg_len).sum();
+ let origin = a0 - t0 * pre;
+ inside.extend(pieces.iter().enumerate().map(|(piece, x)| {
+ let q = from.to_world(x.seg.point_at(0.5));
+ let ahead = (q - origin).dot(t0);
+ let at = carried_along(&route, pre + 0.5 * run_length - ahead).map_or_else(|| apply(&middle, q), |m| apply(&m, q));
+ Seed { at, piece }
+ }));
if let Some((at, toward, _)) = entry {
piece = combined(&piece, &half_space(at, -toward, size)?, solidcraft_smlib::BooleanOp::Subtract, "sweep mitre")?;
}
@@ -847,6 +857,31 @@ mod imp {
with_history(body, &roles, pieces)
}
+ /// The rigid motion carrying a section from the start of `route` to `along` (clamped to the
+ /// route) along it, as SMLib's sweep turning with a path of lines and arcs carries it: moved
+ /// along each line, turned about each arc's axis. None for a route with another curve before
+ /// that point, whose frame only the sweep knows.
+ fn carried_along(route: &[crate::PathSeg], along: f64) -> Option<Affine> {
+ let mut m = IDENTITY;
+ let mut left = along.max(0.0);
+ for s in route {
+ if left <= 0.0 {
+ break;
+ }
+ let length = seg_len(s);
+ let d = left.min(length);
+ m = match *s {
+ crate::PathSeg::Line { a, b } => affine_moved(&m, (b - a).normalized()? * d),
+ crate::PathSeg::Arc { center, axis, angle, .. } if length > 0.0 => {
+ affine_after(&affine_turned(center, axis.normalized()?, angle * d / length), &m)
+ }
+ _ => return None,
+ };
+ left -= d;
+ }
+ Some(m)
+ }
+
/// The length of a path segment.
fn seg_len(s: &crate::PathSeg) -> f64 {
match *s {
@@ -1074,6 +1109,7 @@ mod imp {
.flat_map(|x| (0..=8).map(move |i| x.seg.point_at(f64::from(i) / 8.0)))
.map(|q| plane.to_world(q).dist(start) * ctl.scale.max(1.0))
.fold(0.0f64, f64::max);
+ let offsets = section_offsets(plane, &pieces, start, first_t, ctl.scale.max(1.0));
let size = 4.0 * (total + reach) + 1.0;
let law = |u: f64| 1.0 + (ctl.scale - 1.0) * u;
let n0 = plane.normal().normalized().ok_or_else(|| KernelError::Invalid("profile plane".into()))?;
@@ -1129,8 +1165,18 @@ mod imp {
})
.collect();
let (Some(&first_map), Some(&end_map)) = (maps.first(), maps.last()) else { return Err(KernelError::Invalid("sweep path".into())) };
- let mid = maps.get(maps.len() / 2).copied().unwrap_or(end_map);
- inside.extend(seeds(plane, &pieces, |q| affine_apply(&mid, q)));
+ // Each wall is known by its piece's middle at the station half way along the stretch
+ // of the run that point keeps between the mitres (the stations are evenly spaced by
+ // length): a point standing `s` ahead of the path keeps the stretch `s` back from the
+ // run's, as in the plain sweep ([`cornered`]).
+ let last_station = maps.len().saturating_sub(1);
+ inside.extend(pieces.iter().enumerate().map(|(piece, x)| {
+ let q = plane.to_world(x.seg.point_at(0.5));
+ let ahead = (affine_apply(&first_map, q) - a0).dot(t0);
+ let share = if translate || !(length > 0.0) { 0.5 } else { (0.5 - ahead / length).clamp(0.0, 1.0) };
+ let station = ((share * last_station as f64).round() as usize).min(last_station);
+ Seed { at: affine_apply(maps.get(station).unwrap_or(&end_map), q), piece }
+ }));
let mut piece = Brep::sweep_stations(&c, &maps, Ends::Capped).map_err(|e| failed("sweep", e))?;
let next = match runs.get(ri + 1).and_then(|r| path.get(r.start)) {
Some(s) => Some(tangent(Some(s))?.0),
@@ -1138,18 +1184,19 @@ mod imp {
};
let exit = next.map(|t2| mitre_of(t1, t2)).transpose()?;
if !translate {
- // On past each mitre, the run's section there held still.
- let over = |turn: f64| reach * (turn * 0.5).tan() * 1.1 + reach * 1e-3 + 1e-6;
+ // On past each mitre, the run's section there held still, far enough to take
+ // every point of it to the mitre's plane ([`mitre_lead`]).
let prism = |map: Affine, toward: Vec3, by: f64| -> Result<Brep> {
Brep::sweep_stations(&c, &[map, affine_moved(&map, toward * by)], Ends::Capped).map_err(|e| failed("sweep corner", e))
};
if let Some((at, m, turn)) = entry {
- let lead = prism(affine_moved(&first_map, t0 * -over(turn)), t0, over(turn))?;
+ let pre = mitre_lead(&offsets, reach, turn, false);
+ let lead = prism(affine_moved(&first_map, t0 * -pre), t0, pre)?;
piece = combined(&piece, &lead, solidcraft_smlib::BooleanOp::Union, "sweep corner")?;
piece = combined(&piece, &half_space(at, -m, size)?, solidcraft_smlib::BooleanOp::Subtract, "sweep mitre")?;
}
if let Some((m, turn)) = exit {
- let tail = prism(end_map, t1, over(turn))?;
+ let tail = prism(end_map, t1, mitre_lead(&offsets, reach, turn, true))?;
piece = combined(&piece, &tail, solidcraft_smlib::BooleanOp::Union, "sweep corner")?;
piece = combined(&piece, &half_space(b1, m, size)?, solidcraft_smlib::BooleanOp::Subtract, "sweep mitre")?;
}
@@ -1275,6 +1322,39 @@ mod imp {
Ok(out)
}
+ /// Where the profile's points sit from the path, as a section carries them along it: for
+ /// each sampled point of `pieces` on `plane`, its distance ahead of the path's `start` along
+ /// the unit direction of travel `t` there, and its distance square to that direction, both
+ /// times `scale`. A section that turns with the path (along a smooth run, and through a
+ /// corner about the line square to both directions) keeps both, a twist keeps both, and an
+ /// end scale grows them by at most its largest scale.
+ fn section_offsets(plane: &Plane, pieces: &[Piece], start: Vec3, t: Vec3, scale: f64) -> Vec<(f64, f64)> {
+ pieces
+ .iter()
+ .flat_map(|x| (0..=8).map(move |i| x.seg.point_at(f64::from(i) / 8.0)))
+ .map(|q| {
+ let d = plane.to_world(q) - start;
+ let s = d.dot(t);
+ (s * scale, (d - t * s).len() * scale)
+ })
+ .collect()
+ }
+
+ /// How far a run's section is carried straight on past a corner turning by `turn` (`ahead`),
+ /// or back before one (else), so that each of its points reaches the plane halving the
+ /// corner. A point `s` ahead of the path and `w` from it, the plane's unit normal `m` at half
+ /// the turn from the direction of travel `t`: `m · (s t + w) >= s cos(turn / 2) - w sin(turn /
+ /// 2)`, so carried on `e` along `t` it reaches the plane once `e >= w tan(turn / 2) - s` (and
+ /// back before the corner once `e >= w tan(turn / 2) + s`). A profile square to the path has
+ /// `s = 0`: its reach times the tangent of half the turn; one standing at a slant to the path
+ /// reaches across the mitre by its slant as well. A little further than the farthest point,
+ /// so the cut back runs through the walls, never along the run's own end.
+ fn mitre_lead(offsets: &[(f64, f64)], reach: f64, turn: f64, ahead: bool) -> f64 {
+ let k = (turn * 0.5).tan();
+ let need = offsets.iter().map(|(s, w)| w * k + if ahead { -s } else { *s }).fold(0.0f64, f64::max);
+ need * 1.1 + reach * 1e-3 + 1e-6
+ }
+
/// The plane halving the corner from direction `t1` to `t2` (its unit normal) and the turn
/// there; a path that turns back on itself has none.
fn mitre_of(t1: Vec3, t2: Vec3) -> Result<(Vec3, f64)> {
diff --git a/crates/kernel/src/sweep_path.rs b/crates/kernel/src/sweep_path.rs
index 6729f6d6ad..c5504368e7 100644
--- a/crates/kernel/src/sweep_path.rs
+++ b/crates/kernel/src/sweep_path.rs
@@ -484,6 +484,30 @@ mod tests {
assert!(sweep_path(&plane, &region, &[Vec3::ZERO, Vec3::new(f64::NAN, 0.0, 0.0)]).is_err());
}
+ /// A profile at a slant to its path (drawn flat, the path rising steeply from it) swept
+ /// along a polyline whose lines are shorter than the slant: each section reaches past both
+ /// mitres of its line, so each line's walls are carried on far enough past the corner for
+ /// all of it to meet the mitre. The square's centre is on the path, so the volume is the
+ /// section square to the path times the path's length, `16 cos(slant) L`; a line carried
+ /// short of a mitre leaves a notch with a face of its section in it. Every face is named.
+ #[test]
+ fn a_slanted_profile_meets_itself_at_every_mitre() {
+ use crate::history::FaceOrigin;
+ let path: Vec<Vec3> = (0..=20).map(|i| Vec3::new((f64::from(i) * 0.2).sin() * 10.0, 0.0, f64::from(i))).collect();
+ let b = sweep_path(&Plane::XY, &square(2.0), &path).unwrap();
+ let len: f64 = path.windows(2).map(|w| w[0].dist(w[1])).sum();
+ let slant = (path[1] - path[0]).normalized().unwrap().z;
+ let want = 16.0 * slant * len;
+ let v = b.mesh(&crate::MeshTolerance::chord(0.01)).unwrap().measure().volume;
+ assert!((v - want).abs() < 1e-6 * want, "{v} vs {want}");
+ let h = b.history().unwrap();
+ let caps = |end: bool| h.faces.iter().filter(|f| f.origins == [FaceOrigin::Cap { end }]).count();
+ assert_eq!((caps(false), caps(true)), (1, 1));
+ for (i, f) in h.faces.iter().enumerate() {
+ assert!(matches!(f.origins[..], [FaceOrigin::Profile { .. }] | [FaceOrigin::Cap { .. }]), "face {i}: {f:?}");
+ }
+ }
+
fn square(h: f64) -> Region2 {
Region2 { outer: Loop2::polygon(&[Vec2::new(-h, -h), Vec2::new(h, -h), Vec2::new(h, h), Vec2::new(-h, h)]), holes: Vec::new() }
}