SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Extrude to an edge or corner ends at the requested plane (#3729) (#3748)
Colin Faulkingham29369a0bb5bb
diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex 7b6ca2e32a..59a5ffae72 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -3587,14 +3587,14 @@ fn feature_tools_with_constructor(// The face names follow `face_points`: To, then From.let name = |k: usize| f.face_names.get(k).map(String::as_str);let (to_name, from_name) = if extent.to.is_some() { (name(0), name(1)) } else { (None, name(0)) };- let to_face = extent.to.and_then(|p| object_face(&tst, to_name, p.0));+ let to_face = extent.to.and_then(|p| object_face(&tst, to_name, p.0, Some(n)));let centre = {let pts: Vec<Vec2> = regions.iter().flat_map(|r| r.outer.polyline(1e-2)).collect();let c = pts.iter().fold(Vec2::default(), |a, p| a + *p) * (1.0 / pts.len().max(1) as f64);ss.plane.to_world(c)};let from = match extent.from {- Some(p) => height_at(&tst, object_face(&tst, from_name, p.0), &ss.plane, centre, p.0),+ Some(p) => height_at(&tst, object_face(&tst, from_name, p.0, Some(n)), &ss.plane, centre, p.0),None => 0.0,};let d = match extent.to {@@ -4011,7 +4011,7 @@ fn feature_tools_with_constructor(.collect::<Result<Vec<_>>>()?;// To a curved face: turn past the whole target body, then cut back to its surface// (the piece that starts at the profile).- let curved = curved_face(&tst, to.and_then(|p| object_face(&tst, f.face_names.first().map(String::as_str), p.0)), None);+ let curved = curved_face(&tst, to.and_then(|p| object_face(&tst, f.face_names.first().map(String::as_str), p.0, None)), None);let curved_body = curved.and_then(|bi| tst.bodies.get(bi));// Each region's body: its sides named by the sketch curves, its caps start and end.let tool = |r: &Region2, body: Body, built: Option<&Body>| crate::lineage::ProfileRoles::swept(Some(&ss), Some(r)).tool(body, built);@@ -4867,7 +4867,7 @@ mod surface;/// there if it is planar and parallel (its plane), else where a ray from `centre` along the/// normal meets the body there, else the point itself.pub fn object_height(st: &ModelState, plane: &Plane, centre: Vec3, p: Vec3) -> f64 {- height_at(st, face_at(st, p), plane, centre, p)+ height_at(st, face_at(st, p, Some(plane.normal())), plane, centre, p)}/// [`object_height`] of the point `p` on `face` (`(body index, face index)`, see [`object_face`]).@@ -4899,31 +4899,63 @@ fn height_at(st: &ModelState, face: Option<(usize, usize)>, plane: &Plane, centr/// face index)`, within that body's pick tolerance. Not the first body with any face within/// its tolerance: that is 5 % of the body's size, so a large body beside a small target (a/// plate under a post, a frame around a pin) would otherwise take a pick made on the target.-fn face_at(st: &ModelState, p: Vec3) -> Option<(usize, usize)> {+fn face_at(st: &ModelState, p: Vec3, normal: Option<Vec3>) -> Option<(usize, usize)> {st.bodies.iter().enumerate().filter(|(_, b)| !b.body.is_mesh()).filter_map(|(bi, b)| {- let (d, fi) = crate::appearance::nearest_face(b, p)?;+ let (d, fi) = nearest_object_face(b, p, normal)?;(d <= crate::appearance::pick_tolerance(b)).then_some((d, bi, fi))}).min_by(|a, b| a.0.total_cmp(&b.0)).map(|(_, bi, fi)| (bi, fi))}+/// At a shared edge or corner an extrusion's end plane and side wall can be equally near.+/// Prefer the plane square to the extrusion: choosing the wall would instead extend the tool+/// past the whole body and try to trim it, even when the tool never intersects that body.+/// Only settle a distance tie; a nearby plane must not steal a pick on another face.+fn nearest_object_face(b: &ModelBody, p: Vec3, normal: Option<Vec3>) -> Option<(f64, usize)> {+ let nearest = crate::appearance::nearest_face(b, p)?;+ let Some(n) = normal else { return Some(nearest) };+ if nearest.0 > crate::appearance::pick_tolerance(b) {+ return Some(nearest);+ }+ let tol = (b.body.size() * 1e-3).max(1e-3);+ let Ok(faces) = b.body.faces(tol) else { return Some(nearest) };+ let caps: std::collections::BTreeSet<usize> =+ faces.iter().filter(|f| f.plane_normal.is_some_and(|fnrm| fnrm.cross(n).len() < 1e-6)).map(|f| f.index).collect();+ if caps.is_empty() || caps.contains(&nearest.1) {+ return Some(nearest);+ }+ let tie = (b.body.size() * 1e-9).max(1e-7);+ let mesh = b.mesh();+ mesh.triangles+ .iter()+ .zip(&mesh.tri_face)+ .filter(|(_, fi)| caps.contains(&(**fi as usize)))+ .filter_map(|(tri, fi)| {+ let [a, b, c] = mesh.tri(tri)?;+ let d = crate::appearance::closest_on_triangle(p, a, b, c).dist(p);+ (d <= nearest.0 + tie).then_some((d, *fi as usize))+ })+ .min_by(|a, b| a.0.total_cmp(&b.0))+ .or(Some(nearest))+}+/// The face a To / From Object point stands for, `(body index, face index)`: the face its/// stored `name` finds when the point lies on it (evaluation has moved the point onto its named/// face), else the nearest face at the point. The name settles a tie: in an assembly a part of/// another component may rest on the target and touch it at the point.-fn object_face(st: &ModelState, name: Option<&str>, p: Vec3) -> Option<(usize, usize)> {+fn object_face(st: &ModelState, name: Option<&str>, p: Vec3, normal: Option<Vec3>) -> Option<(usize, usize)> {if let Some(n) = name.filter(|n| !n.is_empty())&& let Some(hit) = crate::naming::locate_face(st, n, p)&& hit.on_point{return Some((hit.body, hit.face));}- face_at(st, p)+ face_at(st, p, normal)}/// The body of `face` when that face is not a plane (with `n`: not a plane square to `n`), so To@@ -4942,7 +4974,7 @@ fn curved_face(st: &ModelState, face: Option<(usize, usize)>, n: Option<Vec3>) -/// The body at `p` when the face there is not planar.fn curved_target_any(st: &ModelState, p: Vec3) -> Option<usize> {- curved_face(st, face_at(st, p), None)+ curved_face(st, face_at(st, p, None), None)}/// Tools run through `target`, cut back to its surface: each tool less the body, keeping the@@ -6231,13 +6263,19 @@ pub fn face_point_names(doc: &Document, st: &ModelState, kind: &FeatureKind, comreturn crate::naming::face_names_at(st, &pts);}let fst = face_point_state(doc, st, kind, comp);+ let normal = match kind {+ FeatureKind::Extrude { sketch, .. } => {+ st.sketch(sketch.0).and_then(|ss| sketch_in_feature_frame(doc, ss, comp).ok()).map(|ss| ss.plane.normal())+ }+ _ => None,+ };pts.iter().map(|p| {fst.bodies.iter().filter(|b| !b.body.is_mesh()).filter_map(|b| {- let (d, fi) = crate::appearance::nearest_face(b, *p)?;+ let (d, fi) = nearest_object_face(b, *p, normal)?;(d <= (b.body.size() * 1e-3).max(1e-3)).then_some((d, b, fi))}).min_by(|a, b| a.0.total_cmp(&b.0))diff --git a/crates/engine/src/extent_tests.rs b/crates/engine/src/extent_tests.rsindex 961beccce8..852a271ef0 100644--- a/crates/engine/src/extent_tests.rs+++ b/crates/engine/src/extent_tests.rs@@ -17,6 +17,62 @@ fn body(s: &mut Session, b: &str) -> Value {run(s, "inspect.measure", json!({ "bodies": [b] }))["bodies"][0].clone()}+fn stepped_block() -> Session {+ let mut s = Session::default();+ run(&mut s, "parameters.add", json!({"name": "step_height", "expression": "10 mm"}));+ run(&mut s, "solid.box", json!({"corner": [-10, -10, 0], "length": 20, "width": 20, "height": 10, "body_name": "Block"}));+ run(&mut s, "sketch.create", json!({"plane": {"origin": [0, 0, 10], "x_dir": [1, 0, 0], "y_dir": [0, 1, 0]}}));+ run(&mut s, "sketch.rectangle.two_point", json!({"p0": [-5, -5], "p1": [5, 5]}));+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "solid.extrude", json!({"distance": "step_height", "operation": "join"}));+ s+}++/// A column beside a step ends at the step's top, including when the To point lies on an+/// edge or corner shared with a vertical wall (#3729).+#[test]+fn extrude_to_a_planar_face_boundary_ends_at_its_plane() {+ for to in [[5, 0, 20], [5, 5, 20], [0, 0, 20], [1000, 1000, 20]] {+ let mut s = stepped_block();+ run(&mut s, "sketch.create", json!({"plane": {"origin": [0, 0, 10], "x_dir": [1, 0, 0], "y_dir": [0, 1, 0]}}));+ run(&mut s, "sketch.circle.center", json!({"center": [8, 0], "radius": 1.5}));+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "solid.extrude", json!({"to": to, "operation": "join"}));+ let b = body(&mut s, "Block");+ let top = b["bbox"]["max"][2].as_f64().unwrap();+ let volume = b["volume_mm3"].as_f64().unwrap();+ assert!((top - 20.0).abs() < 1e-6, "To {to:?}: z max {top}");+ assert!((volume - (5000.0 + 10.0 * PI * 1.5 * 1.5)).abs() < 0.1, "To {to:?}: volume {volume}");+ }+}++/// The face chosen at an edge must also be the stored reference: raising the step must raise+/// the end of the extrusion, including after a save/reload.+#[test]+fn extrude_to_a_planar_face_boundary_follows_it_after_reload() {+ for to in [[5, 0, 20], [5, 5, 20]] {+ let mut s = stepped_block();+ run(&mut s, "sketch.create", json!({"plane": {"origin": [0, 0, 30], "x_dir": [1, 0, 0], "y_dir": [0, 1, 0]}}));+ run(&mut s, "sketch.circle.center", json!({"center": [8, 0], "radius": 1.5}));+ run(&mut s, "sketch.finish", json!({}));+ // A negative reach with an offset past the target, away from the start.+ run(&mut s, "solid.extrude", json!({"to": to, "to_offset": 2, "operation": "new", "body_name": "Post"}));+ let b = body(&mut s, "Post");+ assert!((b["bbox"]["min"][2].as_f64().unwrap() - 18.0).abs() < 1e-6, "{b}");+ let doc = solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap();+ let mut cold = Session::new(doc);+ for current in [&mut s, &mut cold] {+ run(current, "parameters.change", json!({"name": "step_height", "expression": "15 mm"}));+ let b = body(current, "Post");+ let volume = b["volume_mm3"].as_f64().unwrap();+ assert!((b["bbox"]["min"][2].as_f64().unwrap() - 23.0).abs() < 1e-6, "{b}");+ assert!((b["bbox"]["max"][2].as_f64().unwrap() - 30.0).abs() < 1e-6, "{b}");+ assert!((volume - 7.0 * PI * 1.5 * 1.5).abs() < 0.1, "{b}");+ assert!(current.model.results.iter().all(|r| r.error.is_none() && r.warning.is_none()), "{:?}", current.model.results);+ }+ }+}+/// A square post extruded up to a horizontal cylinder (axis along x, r 10, centre z 30): its/// top takes the cylinder's shape, so the post is shortest in the middle.#[test]