SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
feat: sketches on a sheet metal face attach to its panel (#474)
NOWN-DEVaf0440aaab70
diff --git a/ROADMAP.md b/ROADMAP.mdindex 0ecfa01a90..7e3e0ec2e1 100644--- a/ROADMAP.md+++ b/ROADMAP.md@@ -321,6 +321,8 @@ PCB / Package, Render, Animation, Simulation, Manufacture/CAM, Drawings.exact holes and retained islands, including the union of multiple selected profiles, andrecords complementary depth layers as pockets while retaining the stock gauge. Unsupportedtapered or bend-crossing machining refuses atomically instead of restoring material later.+ Sketches attach to a sheet's flat faces (base and flanges, either side) by panel, in the+ flat pattern's coordinates, and follow it through rebuilds and unfold/refold.- Rolling-ball fillet accuracy: independent offset-cylinder tee references check surfacedistance, actual trimmed tessellation, supporting-cylinder contacts and tangency at twoscales. The measured trimmed-part error is below 0.0001 mm; this is an analytic geometrydiff --git a/crates/doc/src/clipboard.rs b/crates/doc/src/clipboard.rsindex 63d4e1a986..2e0f7d0fd4 100644--- a/crates/doc/src/clipboard.rs+++ b/crates/doc/src/clipboard.rs@@ -84,6 +84,10 @@ pub fn remap_topology(name: &str, ids: &BTreeMap<u64, u64>, bodies: &BTreeMap<Stif let Some(old) = crate::naming::legacy_name(name) {return format!("{}{}", crate::naming::LEGACY_MARK, remap_topology(old, ids, bodies));}+ // A flat face of a sheet: `sheet:<body>:<panel>:<side>`, the panel a flange's feature token.+ if let Some((body, face)) = crate::sheet::split_sheet_face_name(name) {+ return crate::sheet::sheet_face_name(bodies.get(body).map_or(body, String::as_str), &remap_topology(face, ids, bodies));+ }// Imported names belong to the complete canonical body prefix, even when that prefix// happens to contain text resembling a feature token.if let Some((body, suffix)) = name.rsplit_once(":face:")@@ -464,6 +468,14 @@ mod clone_tests {assert_eq!(remap_topology("UserF1:label", &ids, &bodies), "UserF1:label");}#[test]+ fn a_sheet_face_follows_its_body_and_its_flange() {+ let ids = BTreeMap::from([(1, 2), (10, 20)]);+ let bodies = BTreeMap::from([("Body1".into(), "Body1 (copy)".into())]);+ assert_eq!(remap_topology("sheet:Body1:F1.0:top", &ids, &bodies), "sheet:Body1 (copy):F2.0:top");+ assert_eq!(remap_topology("sheet:Body1:base:bottom", &ids, &bodies), "sheet:Body1 (copy):base:bottom");+ assert_eq!(remap_topology("sheet:Other:F10.1:top", &ids, &bodies), "sheet:Other:F20.1:top");+ }+ #[test]fn parameter_remap_is_simultaneous_and_token_scoped() {let map = BTreeMap::from([("d1".into(), "d2".into()), ("d2".into(), "d3".into())]);assert_eq!(clone_expression("d1 + d2 + d10 + 2 mm", &map), "d2 + d3 + d10 + 2 mm");diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex 88362813f6..ed87037401 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -3074,6 +3074,38 @@ fn smooth_chain(b: &ModelBody, picks: &[Vec3]) -> Vec<Vec3> {out}+/// `plane` with the sheet face it names (see `sheet::plane_sheet_face`) replaced by that face's current+/// plane in the frame of component `comp`, or an error when the face is gone: a lost+/// attachment is reported, never moved to the nearest face.+pub(crate) fn sheet_face_plane_in_frame(doc: &Document, st: &ModelState, comp: u64, plane: &PlaneRef) -> Result<PlaneRef> {+ Ok(match plane {+ PlaneRef::Face { name: Some(name), anchor: None, .. } if crate::sheet::plane_sheet_face(plane).is_some() => {+ let lost = || DocError::Invalid(format!("lost face attachment: the sheet face `{name}` no longer exists; reattach the sketch to a face"));+ let (body, face) = crate::sheet::sheet_face_plane(st, name).ok_or_else(lost)?;+ if doc.occurrences.is_empty() && doc.body_offsets.is_empty() {+ return Ok(PlaneRef::Custom { plane: face });+ }+ // The body's own coordinates into the component's frame, as `state_in_frame` places its bodies.+ let source = st.body(&body).ok_or_else(lost)?;+ let inverse = crate::mat_inverse(&doc.component_transform(comp)).ok_or_else(lost)?;+ let m = crate::mat_mul(&inverse, &doc.component_transform(doc.model_body_component(source)));+ let m = doc.model_body_offset(source).map(|offset| crate::mat_mul(&m, offset)).unwrap_or(m);+ let placed = Plane::new(crate::apply_point(&m, face.origin), crate::apply_vector(&m, face.x), crate::apply_vector(&m, face.y));+ PlaneRef::Custom { plane: placed.ok_or_else(lost)? }+ }+ PlaneRef::Offset { base, distance } => {+ PlaneRef::Offset { base: Box::new(sheet_face_plane_in_frame(doc, st, comp, base)?), distance: distance.clone() }+ }+ PlaneRef::AtAngle { base, axis_origin, axis_dir, angle } => PlaneRef::AtAngle {+ base: Box::new(sheet_face_plane_in_frame(doc, st, comp, base)?),+ axis_origin: *axis_origin,+ axis_dir: *axis_dir,+ angle: angle.clone(),+ },+ other => other.clone(),+ })+}+/// The plane of the body face a sketch sits on, found again: among planar faces with the/// picked plane's normal, the one nearest `at`. The picked frame moves along its normal onto it.fn face_plane(st: &ModelState, picked: &Plane, at: Vec3, name: Option<&str>) -> (Plane, Option<String>) {@@ -3205,6 +3237,10 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:};let (plane, face_warning) = match (anchor, plane) {(Some(_), plane) => (doc.resolve_attached_plane(vals, plane, f.component, st, &fst)?, None),+ // A flat face of a sheet: the panel's exact plane, from its flat region and fold.+ (None, plane) if crate::sheet::plane_sheet_face(plane).is_some() => {+ (doc.resolve_plane_in(vals, &sheet_face_plane_in_frame(doc, st, f.component, plane)?, 0, Some(&fst))?, None)+ }(None, PlaneRef::Face { plane: picked, at, name, anchor: None }) => face_plane(&fst, picked, *at, name.as_deref()),(None, other) => (doc.resolve_plane_in(vals, other, 0, Some(&fst))?, None),};diff --git a/crates/doc/src/face_anchor.rs b/crates/doc/src/face_anchor.rsindex 39961fd66d..c60d8ed5e4 100644--- a/crates/doc/src/face_anchor.rs+++ b/crates/doc/src/face_anchor.rs@@ -117,11 +117,13 @@ impl Document {}}-/// All status planes are world-space. A lost plane is a repair guide only.+/// All status planes are world-space. A lost plane is a repair guide only. `Sheet` is a sketch on+/// a flat face of a sheet metal body, attached by the name of its panel (`sheet::sheet_face_name`).#[derive(Clone, Debug)]pub enum FaceAttachmentStatus {Fixed { plane: Option<Plane> },Legacy { plane: Option<Plane> },+ Sheet { plane: Option<Plane> },Healthy { plane: Plane, target: ConfigFaceTarget, path: Vec<u64> },Lost { message: String, repair_plane: Option<Plane> },}@@ -210,6 +212,13 @@ impl Document {self.resolve_plane(&vals, plane, 0).ok()});let current = world.and_then(|world| current.and_then(|plane| map_plane(&world, &plane).ok()));+ if crate::sheet::plane_sheet_face(plane).is_some() {+ let state = model.state_before(feature.id);+ return match crate::eval::sheet_face_plane_in_frame(self, &state, feature.component, plane) {+ Ok(_) => FaceAttachmentStatus::Sheet { plane: current },+ Err(error) => FaceAttachmentStatus::Lost { message: error.to_string(), repair_plane: current },+ };+ }return if has_face_reference(plane) {FaceAttachmentStatus::Legacy { plane: current }} else {diff --git a/crates/doc/src/sheet.rs b/crates/doc/src/sheet.rsindex cb64abfbdc..f554975ca0 100644--- a/crates/doc/src/sheet.rs+++ b/crates/doc/src/sheet.rs@@ -2025,6 +2025,72 @@ impl SheetBody {best.map(|(_, q)| q)}+ /// The persistent name of a panel: `base`, a flange's tag, or `#<index>` for an untagged+ /// flange; `flat` for the whole sheet while it is unfolded.+ fn panel_name(&self, pi: Option<usize>) -> String {+ match pi {+ _ if self.flat => "flat".into(),+ None => "base".into(),+ Some(i) => match self.flanges.get(i) {+ Some(f) if !f.tag.is_empty() => f.tag.clone(),+ _ => format!("#{i}"),+ },+ }+ }++ /// The plane of a flat face of a panel (`top`: the face at the thickness, else the bottom+ /// one), facing out of the sheet. Its coordinates are the flat pattern's (the bottom+ /// face's mirrored in y), so a sketch on it measures as the flat pattern does.+ fn panel_face_plane(&self, world: &Mat, top: bool) -> Option<Plane> {+ let (x, y) = (apply_vector(world, Vec3::X), apply_vector(world, Vec3::Y));+ Plane::new(apply_point(world, Vec3::new(0.0, 0.0, if top { self.t } else { 0.0 })), x, if top { y } else { y * -1.0 })+ }++ /// The flat face of the sheet that a point lies on (sheet coordinates, within `tol`, which+ /// stays below a quarter of the thickness): its persistent name (`<panel>:top` or+ /// `<panel>:bottom`) and its plane (see [`panel_face`](Self::panel_face)).+ pub fn panel_face_at(&self, p: Vec3, tol: f64) -> Option<(String, Plane)> {+ let tol = tol.min(self.t * 0.25);+ let flat = if self.flat { self.flat_regions().ok()? } else { Vec::new() };+ let panels = if self.flat { vec![(None, self.base.clone())] } else { self.panels() };+ for (pi, region) in panels {+ let world = self.world(pi);+ let Some(inverse) = mat_inverse(&world) else { continue };+ let q = apply_point(&inverse, p);+ let top = (q.z - self.t).abs() < q.z.abs();+ if (if top { (q.z - self.t).abs() } else { q.z.abs() }) > tol {+ continue;+ }+ let q2 = Vec2::new(q.x, q.y);+ if if self.flat { flat.iter().any(|r| r.contains(q2)) } else { region.contains(q2) } {+ return Some((format!("{}:{}", self.panel_name(pi), if top { "top" } else { "bottom" }), self.panel_face_plane(&world, top)?));+ }+ }+ None+ }++ /// The plane of the flat face with this persistent name (see [`panel_face_at`](Self::panel_face_at)).+ /// A face named while the sheet was folded follows its panel; one named unfolded (`flat`)+ /// is the flat sheet's own plane.+ pub fn panel_face(&self, name: &str) -> Option<Plane> {+ let (panel, side) = name.rsplit_once(':')?;+ let top = match side {+ "top" => true,+ "bottom" => false,+ _ => return None,+ };+ let pi = match panel {+ "flat" | "base" => None,+ tag => Some(+ self.flanges+ .iter()+ .position(|f| f.tag == tag)+ .or_else(|| tag.strip_prefix('#')?.parse::<usize>().ok().filter(|i| *i < self.flanges.len()))?,+ ),+ };+ self.panel_face_plane(&self.world(pi), top)+ }+/// Map a region in a world plane to flat coordinates through a panel's placement.pub fn region_to_flat(&self, panel: Option<usize>, plane: &Plane, r: &Region2) -> Result<Region2> {region_complexity(std::slice::from_ref(r))?;@@ -2323,6 +2389,52 @@ pub fn contour_flange(body: &str, rule: &str, rv: &RuleValues, plane: &Plane, ptOk(sheet)}+/// The name a sketch keeps for a flat face of a sheet: `sheet:<body>:<panel>:<top|bottom>`.+pub fn sheet_face_name(body: &str, face: &str) -> String {+ format!("sheet:{body}:{face}")+}++/// Point the sheet face a sketch plane is attached to (also beneath an offset or a rotation)+/// at body `new`, when it is on body `old`.+pub fn rename_plane_sheet_body(plane: &mut crate::PlaneRef, old: &str, new: &str) {+ match plane {+ crate::PlaneRef::Face { name: Some(name), anchor: None, .. } => {+ let renamed = split_sheet_face_name(name).filter(|(body, _)| *body == old).map(|(_, face)| sheet_face_name(new, face));+ if let Some(renamed) = renamed {+ *name = renamed;+ }+ }+ crate::PlaneRef::Offset { base, .. } | crate::PlaneRef::AtAngle { base, .. } => rename_plane_sheet_body(base, old, new),+ _ => {}+ }+}++/// The sheet face a sketch plane is attached to (also beneath an offset or a rotation): its+/// [`sheet_face_name`].+pub fn plane_sheet_face(plane: &crate::PlaneRef) -> Option<&str> {+ match plane {+ crate::PlaneRef::Face { name: Some(name), anchor: None, .. } if split_sheet_face_name(name).is_some() => Some(name),+ crate::PlaneRef::Offset { base, .. } | crate::PlaneRef::AtAngle { base, .. } => plane_sheet_face(base),+ _ => None,+ }+}++/// The body and the `<panel>:<side>` of a [`sheet_face_name`].+pub fn split_sheet_face_name(name: &str) -> Option<(&str, &str)> {+ let rest = name.strip_prefix("sheet:")?;+ let (head, side) = rest.rsplit_once(':')?;+ let (body, panel) = head.rsplit_once(':')?;+ (!body.is_empty() && !panel.is_empty() && !side.is_empty()).then_some(())?;+ Some((body, rest.get(body.len() + 1..)?))+}++/// The plane of the sheet face with a [`sheet_face_name`], in the body's own coordinates.+pub fn sheet_face_plane(st: &crate::ModelState, name: &str) -> Option<(String, Plane)> {+ let (body, face) = split_sheet_face_name(name)?;+ let plane = st.sheets.iter().find(|s| s.body == body)?.panel_face(face)?;+ Some((body.to_string(), plane))+}+/// Persistent names of the sheet edges nearest each world point (empty when none).pub fn sheet_edge_names(st: &crate::ModelState, pts: &[Vec3]) -> Vec<String> {pts.iter()@@ -2393,6 +2505,85 @@ mod tests {assert!((s.flat_size().unwrap().1 - 73.685298).abs() < 1e-5);}+ #[test]+ fn flat_faces_of_a_sheet_are_found_and_named_by_panel() {+ use std::f64::consts::FRAC_PI_2;+ // Steel, 2.5 thick, R = T: a 90° flange on the y = 0 edge stands between the planes+ // y = 0 (its outer face) and y = 2.5 (its inner face) from z = 5 up.+ let mut s = plate(100.0, 60.0);+ s.add_flange(Vec3::new(50.0, 0.0, 2.5), 20.0, FRAC_PI_2, 2.5, "inside", false).unwrap();+ s.flanges[0].tag = "F7.0".into();+ let face = |s: &SheetBody, p: Vec3| s.panel_face_at(p, 1e-6);+ let (name, plane) = face(&s, Vec3::new(50.0, 30.0, 2.5)).unwrap();+ assert_eq!(name, "base:top");+ assert!(plane.normal().dist(Vec3::Z) < 1e-12 && (plane.origin.z - 2.5).abs() < 1e-12);+ // The top face's coordinates are the flat pattern's; the bottom face's mirror y.+ assert!(plane.to_local(Vec3::new(30.0, 20.0, 2.5)).dist(Vec2::new(30.0, 20.0)) < 1e-12);+ let (name, plane) = face(&s, Vec3::new(50.0, 30.0, 0.0)).unwrap();+ assert_eq!(name, "base:bottom");+ assert!(plane.normal().dist(Vec3::Z * -1.0) < 1e-12 && plane.origin.z.abs() < 1e-12);+ assert!(plane.to_local(Vec3::new(30.0, 20.0, 0.0)).dist(Vec2::new(30.0, -20.0)) < 1e-12);+ // The flange's inner face is the sheet's top side there; 7 mm up it is flat y = 5 − BA − 7.+ let ba = FRAC_PI_2 * (2.5 + 0.44 * 2.5);+ let (inner, plane) = face(&s, Vec3::new(30.0, 2.5, 12.0)).unwrap();+ assert_eq!(inner, "F7.0:top");+ assert!(plane.normal().dist(Vec3::Y) < 1e-12, "{:?}", plane.normal());+ assert!(plane.to_local(Vec3::new(30.0, 2.5, 12.0)).dist(Vec2::new(30.0, 5.0 - ba - 7.0)) < 1e-9);+ let (outer, plane) = face(&s, Vec3::new(30.0, 0.0, 12.0)).unwrap();+ assert_eq!(outer, "F7.0:bottom");+ assert!(plane.normal().dist(Vec3::Y * -1.0) < 1e-12, "{:?}", plane.normal());+ // A name gives the same plane again.+ for p in [Vec3::new(50.0, 30.0, 2.5), Vec3::new(50.0, 30.0, 0.0), Vec3::new(30.0, 2.5, 12.0), Vec3::new(30.0, 0.0, 12.0)] {+ let (name, plane) = face(&s, p).unwrap();+ assert_eq!(s.panel_face(&name), Some(plane), "{name}");+ }+ // Inside the sheet, on the bend, beside the sheet, above the flange: no flat face.+ for p in [Vec3::new(50.0, 30.0, 1.0), Vec3::new(50.0, 1.0, 1.0), Vec3::new(150.0, 30.0, 2.5), Vec3::new(30.0, 2.5, 40.0)] {+ assert!(face(&s, p).is_none(), "{p:?}");+ }+ // Names that are no face, or no flange, give no plane.+ for name in ["base", "base:side", "nobody:top", "#7:top", "F8.0:top", ""] {+ assert!(s.panel_face(name).is_none(), "{name}");+ }+ // A flange without a tag is named by its index.+ s.flanges[0].tag.clear();+ assert_eq!(face(&s, Vec3::new(30.0, 2.5, 12.0)).map(|f| f.0).as_deref(), Some("#0:top"));+ assert!(s.panel_face("#0:bottom").is_some());+ // Unfolded, the whole sheet is one panel.+ s.flat = true;+ assert_eq!(face(&s, Vec3::new(50.0, -10.0, 2.5)).map(|f| f.0).as_deref(), Some("flat:top"));+ assert!(s.panel_face("flat:bottom").is_some());+ }++ #[test]+ fn a_pick_beside_a_thin_sheet_takes_the_nearer_face() {+ // The tolerance of a pick on a large part is far above a thin sheet's thickness, and+ // never reaches a quarter of it here: the nearer side wins, the middle is no face.+ let rv = RuleValues { thickness: 0.5, ..steel() };+ let s = base_flange(+ "Thin",+ "Sheet",+ &rv,+ Plane::XY,+ rect(Vec2::new(0.0, 0.0), Vec2::new(100.0, 0.0), Vec2::new(100.0, 60.0), Vec2::new(0.0, 60.0)),+ );+ let at = |z: f64| s.panel_face_at(Vec3::new(50.0, 30.0, z), 5.0).map(|f| f.0);+ assert_eq!(at(0.4).as_deref(), Some("base:top"));+ assert_eq!(at(0.1).as_deref(), Some("base:bottom"));+ assert_eq!(at(0.25), None);+ assert_eq!(at(3.0), None);+ }++ #[test]+ fn sheet_face_names_split_from_the_right() {+ assert_eq!(split_sheet_face_name(&sheet_face_name("Body1", "F7.0:top")), Some(("Body1", "F7.0:top")));+ // A body name may hold colons; the panel and the side never do.+ assert_eq!(split_sheet_face_name("sheet:Part:2:base:bottom"), Some(("Part:2", "base:bottom")));+ for name in ["", "sheet", "sheet:Body1", "sheet:Body1:top", "sheet::base:top", "sheet:Body1::top", "sheet:Body1:base:", "Body1:base:top"] {+ assert_eq!(split_sheet_face_name(name), None, "{name}");+ }+ }+#[test]fn contour_flange_matches_fusion() {// Oracle 72: XZ chain (0,0)→(40,0)→(40,−30)→(70,−30), 50 wide.diff --git a/crates/engine/src/cmd/browser.rs b/crates/engine/src/cmd/browser.rsindex 016f4301bf..ff667feb1f 100644--- a/crates/engine/src/cmd/browser.rs+++ b/crates/engine/src/cmd/browser.rs@@ -464,6 +464,9 @@ fn rename_body(s: &mut Session, p: &Value) -> Result<Value> {// Later features refer to bodies by name.let mut failed = None;for f in d.features.iter_mut().filter(|f| f.id != fid) {+ if let FeatureKind::Sketch { plane, .. } = &mut f.kind {+ solidcraft_doc::sheet::rename_plane_sheet_body(plane, &old, name);+ }if let FeatureKind::Sketch { plane, sketch } = &mut f.kind&& let Some(anchor) = super::sketch::face::anchor_mut(plane)&& anchor.target.body == old@@ -614,7 +617,13 @@ fn redefine_sketch(s: &mut Session, p: &Value) -> Result<Value> {s.pending_moves = trial.pending_moves;let attachment = s.doc.feature(id).and_then(|feature| match &feature.kind {- FeatureKind::Sketch { plane, .. } => Some(if super::sketch::face::anchor(plane).is_some() { "exact_face" } else { "fixed" }),+ FeatureKind::Sketch { plane, .. } => Some(if super::sketch::face::anchor(plane).is_some() {+ "exact_face"+ } else if solidcraft_doc::sheet::plane_sheet_face(plane).is_some() {+ "sheet_face"+ } else {+ "fixed"+ }),_ => None,});Ok(json!({ "sketch": id,"attachment":attachment }))diff --git a/crates/engine/src/cmd/sheet_tests.rs b/crates/engine/src/cmd/sheet_tests.rsindex 26297aa8e5..01b3bccdb0 100644--- a/crates/engine/src/cmd/sheet_tests.rs+++ b/crates/engine/src/cmd/sheet_tests.rs@@ -709,6 +709,212 @@ fn fold_keeps_the_larger_side_either_way() {}}+/// A 100 x 60 plate with a 90° flange up from its y = 0 edge (steel: 2.5 thick, R = T, K 0.44).+/// The flange's inner face is the plane y = 2.5 and its outer face y = 0; it stands from z = 5.+fn plate_with_flange(s: &mut Session) {+ base(s, 100.0, 60.0);+ run(s, "sheet.flange", json!({"edges": [[50, 0, 2.5]], "height": 20}));+}++/// A circle sketch on `plane`, finished.+fn circle_sketch(s: &mut Session, name: &str, plane: Value, center: [f64; 2], diameter: f64) -> Value {+ let made = run(s, "sketch.create", json!({"plane": plane, "name": name}));+ run(s, "sketch.circle.center", json!({"center": center, "diameter": diameter}));+ run(s, "sketch.finish", json!({}));+ made+}++fn cut_through(s: &mut Session, sketch: &str) {+ run(s, "solid.extrude", json!({"sketch": sketch, "through_all": true, "direction": "negative", "operation": "cut"}));+}++fn contains(s: &Session, p: [f64; 3]) -> bool {+ s.model.state().bodies.first().is_some_and(|b| b.body.contains(solidcraft_geom::Vec3::new(p[0], p[1], p[2])))+}++#[test]+fn a_sketch_on_a_flange_face_attaches_to_its_panel() {+ // Sketch coordinates on a sheet face are the flat pattern's: the flange panel starts at+ // y = 5 − BA and runs on toward −y, so a hole 7 mm up the face is at y = 5 − BA − 7.+ let ba = FRAC_PI_2 * (2.5 + 0.44 * 2.5);+ let hole = PI * 1.8 * 1.8 * 2.5;+ let mut s = Session::default();+ plate_with_flange(&mut s);+ let v0 = volume(&mut s);+ let made = circle_sketch(&mut s, "Holes", json!({"face": [50, 2.5, 12]}), [30.0, 5.0 - ba - 7.0], 3.6);+ assert_eq!(made["attachment"], "sheet_face");+ // The sketch keeps the face's name: the body, the panel (its flange) and the side of the sheet.+ let sketch = s.doc.find_feature("Holes").cloned().unwrap();+ let solidcraft_doc::FeatureKind::Sketch { plane, .. } = &sketch.kind else { panic!("{:?}", sketch.kind) };+ let name = solidcraft_doc::sheet::plane_sheet_face(plane).unwrap_or_default();+ assert!(name.starts_with("sheet:Body1:F") && name.ends_with(":top"), "{name}");+ // A cut through the flange from that sketch is a round hole 7 mm up the face, at x = 30.+ run(&mut s, "solid.extrude", json!({"sketch": "Holes", "distance": 2.5, "direction": "negative", "operation": "cut"}));+ assert!((v0 - volume(&mut s) - hole).abs() < 0.1, "{}", v0 - volume(&mut s));+ assert!(!contains(&s, [30.0, 1.25, 12.0]) && contains(&s, [30.0, 1.25, 14.5]) && contains(&s, [33.0, 1.25, 12.0]));+ let f = flat(&mut s);+ let cut = f["cutouts"][0].as_array().cloned().unwrap_or_default();+ assert!(!cut.is_empty(), "{f}");+ for p in &cut {+ let (x, y) = (p[0].as_f64().unwrap_or(f64::NAN), p[1].as_f64().unwrap_or(f64::NAN));+ assert!(((x - 30.0).hypot(y - (5.0 - ba - 7.0)) - 1.8).abs() < 1e-3, "({x}, {y})");+ }+ // `fixed: true` still freezes the picked plane instead of attaching to the panel.+ let frozen = circle_sketch(&mut s, "Frozen", json!({"face": [50, 2.5, 12], "fixed": true}), [0.0, 0.0], 1.0);+ assert_eq!(frozen["attachment"], "fixed");+}++/// The thickness of a sheet comes from a parameter: the flange's face moves with it, and a+/// sketch frozen on the old plane cuts a blind pocket in the thicker sheet. The attached+/// sketch cuts the same hole as one drawn on the thicker sheet in the first place.+#[test]+fn a_sketch_on_a_sheet_face_follows_the_sheet_when_its_thickness_changes() {+ let build = |t: f64, then: Option<f64>| {+ let mut s = Session::default();+ run(&mut s, "parameters.add", json!({"name": "T", "expression": format!("{t} mm")}));+ run(&mut s, "sheet.manage_rules", json!({"name": "AL", "thickness": "T", "k_factor": "0.5", "bend_radius": "1 mm", "active": true}));+ base(&mut s, 100.0, 60.0);+ run(&mut s, "sheet.flange", json!({"edges": [[50, 0, t]], "height": 20}));+ // The hole is drawn 10 mm up the 2 mm flange, in the flat pattern: its bend ends at+ // y = T + R = 3 and the bend allowance is (R + T/2)·π/2 = π. The coordinates stay as they are.+ let flat_y = 3.0 - PI - 10.0;+ circle_sketch(&mut s, "Holes", json!({"face": [50, t, 12]}), [30.0, flat_y], 6.0);+ run(&mut s, "sketch.create", json!({"plane": {"face": [10, 30, t]}, "offset": "5 mm", "name": "Above"}));+ run(&mut s, "sketch.finish", json!({}));+ let v0 = volume(&mut s);+ cut_through(&mut s, "Holes");+ if let Some(t2) = then {+ let r = run(&mut s, "parameters.change", json!({"name": "T", "expression": format!("{t2} mm")}));+ assert_eq!(r["errors"], json!([]), "{r}");+ }+ (s, v0)+ };+ let (mut grown, _) = build(2.0, Some(3.0));+ let (mut direct, v_direct) = build(3.0, None);+ let (vg, vd) = (volume(&mut grown), volume(&mut direct));+ // The hole is the cylinder Ø6 × 3 through the thicker sheet, as if drawn there at first.+ assert!((v_direct - vd - PI * 9.0 * 3.0).abs() < 0.1, "{}", v_direct - vd);+ assert!(rel(vg, vd) < 1e-9, "{vg} {vd}");+ let (fg, fd) = (flat(&mut grown), flat(&mut direct));+ assert_eq!(fg["pockets"], json!([]), "a blind pocket instead of the hole: {fg}");+ assert_eq!(fg["cutouts"], fd["cutouts"]);+ // The thicker flange's panel starts at flat y = 4 − 3.927 and z = T + R = 4, so the hole is+ // 10.215 mm up it: through the whole 3 mm.+ assert!(!contains(&grown, [30.0, 1.5, 14.2]) && !contains(&grown, [30.0, 0.2, 14.2]) && contains(&grown, [30.0, 1.5, 19.0]));+ // The sketch offset from the base's top face moved up with it: 3 + 5.+ let plane = run(&mut grown, "sketch.inspect", json!({"sketch": "Above"}))["plane"]["origin"][2].as_f64().unwrap_or(f64::NAN);+ assert!((plane - 8.0).abs() < 1e-9, "{plane}");+}++#[test]+fn sketches_on_the_top_and_bottom_faces_of_a_sheet_survive_unfold_refold_and_reopen() {+ let mut s = Session::default();+ base(&mut s, 100.0, 60.0);+ // The top face's coordinates are the base sketch's; the bottom face's mirror y, as seen from below.+ circle_sketch(&mut s, "Top", json!({"face": [30, 20, 2.5]}), [30.0, 20.0], 4.0);+ circle_sketch(&mut s, "Bottom", json!({"face": [60, 20, 0]}), [60.0, -20.0], 4.0);+ cut_through(&mut s, "Top");+ cut_through(&mut s, "Bottom");+ let want = 15000.0 - 2.0 * PI * 4.0 * 2.5;+ assert!((volume(&mut s) - want).abs() < 0.1, "{}", volume(&mut s));+ let holes = |f: &Value| {+ let mut centres: Vec<(f64, f64)> = f["cutouts"]+ .as_array()+ .cloned()+ .unwrap_or_default()+ .iter()+ .map(|c| {+ let pts: Vec<(f64, f64)> = c+ .as_array()+ .cloned()+ .unwrap_or_default()+ .iter()+ .map(|p| (p[0].as_f64().unwrap_or(f64::NAN), p[1].as_f64().unwrap_or(f64::NAN)))+ .collect();+ let n = pts.len().max(1) as f64;+ (pts.iter().map(|p| p.0).sum::<f64>() / n, pts.iter().map(|p| p.1).sum::<f64>() / n)+ })+ .collect();+ centres.sort_by(|a, b| a.0.total_cmp(&b.0));+ centres+ };+ for command in [None, Some("sheet.unfold"), Some("sheet.refold")] {+ if let Some(command) = command {+ run(&mut s, command, json!({}));+ }+ let centres = holes(&flat(&mut s));+ assert_eq!(centres.len(), 2, "{centres:?}");+ assert!((centres[0].0 - 30.0).abs() < 0.01 && (centres[0].1 - 20.0).abs() < 0.01, "{centres:?}");+ assert!((centres[1].0 - 60.0).abs() < 0.01 && (centres[1].1 - 20.0).abs() < 0.01, "{centres:?}");+ assert!((volume(&mut s) - want).abs() < 0.1);+ }+ let mut reopened = Session::new(solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap());+ assert!((volume(&mut reopened) - want).abs() < 0.1);+ assert_eq!(holes(&flat(&mut reopened)), holes(&flat(&mut s)));+}++#[test]+fn a_sketch_made_on_the_unfolded_sheet_lands_on_the_flange_after_refolding() {+ let ba = FRAC_PI_2 * (2.5 + 0.44 * 2.5);+ let mut s = Session::default();+ plate_with_flange(&mut s);+ let v0 = volume(&mut s);+ run(&mut s, "sheet.unfold", json!({}));+ // Unfolded, the flange lies in the sheet's plane: the one flat face covers it too.+ let y = 5.0 - ba - 7.0;+ circle_sketch(&mut s, "Holes", json!({"face": [30, y, 2.5]}), [30.0, y], 3.6);+ cut_through(&mut s, "Holes");+ run(&mut s, "sheet.refold", json!({}));+ assert!((v0 - volume(&mut s) - PI * 1.8 * 1.8 * 2.5).abs() < 0.1, "{}", v0 - volume(&mut s));+ assert!(!contains(&s, [30.0, 1.25, 12.0]) && contains(&s, [30.0, 1.25, 14.5]));+}++#[test]+fn a_sketch_on_a_sheet_face_reports_a_lost_attachment_instead_of_moving_to_another_face() {+ let mut s = Session::default();+ plate_with_flange(&mut s);+ circle_sketch(&mut s, "Holes", json!({"face": [50, 2.5, 12]}), [30.0, -8.0], 3.6);+ let id = s.doc.find_feature("Holes").map(|f| f.id).unwrap_or(0);+ let status = |s: &Session| s.placed_document().sketch_face_attachment(id, &s.model);+ assert!(matches!(status(&s), solidcraft_doc::FaceAttachmentStatus::Sheet { plane: Some(_) }));+ // With the flange suppressed there is no such face; the base's top face is not a substitute.+ run(&mut s, "timeline.suppress", json!({"feature": "EdgeFlange1", "suppressed": true}));+ let error = run(&mut s, "timeline.inspect", json!({"feature": "Holes"}))["error"].as_str().unwrap_or_default().to_string();+ assert!(error.contains("lost face attachment") && error.contains("reattach"), "{error}");+ let solidcraft_doc::FaceAttachmentStatus::Lost { message, repair_plane } = status(&s) else { panic!("{:?}", status(&s)) };+ assert!(message.contains("sheet face") && repair_plane.is_some(), "{message}");+ // Redefine Sketch Plane repairs it on another face, here the base's top (its sketch keeps its geometry).+ let repaired = run(&mut s, "sketch.redefine", json!({"sketch": "Holes", "plane": {"face": [10, 30, 2.5]}}));+ assert_eq!(repaired["attachment"], "sheet_face");+ assert!(run(&mut s, "timeline.inspect", json!({"feature": "Holes"}))["error"].is_null());+ assert!(matches!(status(&s), solidcraft_doc::FaceAttachmentStatus::Sheet { .. }));+ // The flange is back, and a sketch attached to it again is healthy.+ run(&mut s, "timeline.suppress", json!({"feature": "EdgeFlange1", "suppressed": false}));+ let again = run(&mut s, "sketch.redefine", json!({"sketch": "Holes", "plane": {"face": [50, 2.5, 12]}}));+ assert_eq!(again["attachment"], "sheet_face");+ assert!(run(&mut s, "timeline.inspect", json!({"feature": "Holes"}))["error"].is_null());+ assert!(matches!(status(&s), solidcraft_doc::FaceAttachmentStatus::Sheet { .. }));+}++#[test]+fn renaming_a_sheet_body_keeps_its_sketches_on_their_faces() {+ let mut s = Session::default();+ plate_with_flange(&mut s);+ let v0 = volume(&mut s);+ circle_sketch(&mut s, "Holes", json!({"face": [50, 2.5, 12]}), [30.0, -8.0], 3.6);+ run(&mut s, "sketch.create", json!({"plane": {"face": [10, 30, 2.5]}, "offset": "5 mm", "name": "Above"}));+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "body.rename", json!({"body": "Body1", "name": "Bracket"}));+ for (sketch, face) in [("Holes", "sheet:Bracket:F"), ("Above", "sheet:Bracket:base:top")] {+ let feature = s.doc.find_feature(sketch).cloned().unwrap();+ let solidcraft_doc::FeatureKind::Sketch { plane, .. } = &feature.kind else { panic!("{:?}", feature.kind) };+ assert!(solidcraft_doc::sheet::plane_sheet_face(plane).is_some_and(|name| name.starts_with(face)), "{sketch}: {:?}", feature.kind);+ assert!(run(&mut s, "timeline.inspect", json!({"feature": sketch}))["error"].is_null(), "{sketch}");+ }+ cut_through(&mut s, "Holes");+ assert!((v0 - volume(&mut s) - PI * 1.8 * 1.8 * 2.5).abs() < 0.1, "{}", v0 - volume(&mut s));+}+/// A tray shrunk by a parameter change unfolds like the same tray built at that size. The/// sketch solved again leaves its corners ~1e-13 mm off, and the flat pattern's planar/// arrangement used to drop a bend zone through a gap that small: "planar region arrangementdiff --git a/crates/engine/src/cmd/sketch.rs b/crates/engine/src/cmd/sketch.rsindex b2d4c73294..f575beb164 100644--- a/crates/engine/src/cmd/sketch.rs+++ b/crates/engine/src/cmd/sketch.rs@@ -29,7 +29,7 @@ pub static COMMANDS: &[CommandSpec] = &[CommandSpec::new("sketch.create", "Create Sketch", create_sketch).at("SOLID", "CREATE").icon("sketch")- .params("plane: XY|XZ|YZ | construction plane name or id | {origin, x_dir, y_dir} | {face: [world x,y,z], body?: exact world body, index?: face index, path?: complete occurrence ids, fixed?: bool}; new face attachments require a unique certified source, fixed:true explicitly freezes the selected plane; offset?: expr, project_edges?: bool, name?"),+ .params("plane: XY|XZ|YZ | construction plane name or id | {origin, x_dir, y_dir} | {face: [world x,y,z], body?: exact world body, index?: face index, path?: complete occurrence ids, fixed?: bool}; new face attachments require a unique certified source (a flat face of a sheet metal body attaches to its panel instead, in the flat pattern's coordinates), fixed:true explicitly freezes the selected plane; offset?: expr, project_edges?: bool, name?"),CommandSpec::new("sketch.edit", "Edit Sketch", edit_sketch).noundo().icon("sketch").params("sketch: id or name"),CommandSpec::new("sketch.finish", "Finish Sketch", finish_sketch).at("SKETCH", "FINISH SKETCH").icon("finish").enabled(in_sketch).noundo(),CommandSpec::new("sketch.line", "Line", draw_line)@@ -662,6 +662,8 @@ fn create_sketch_with_plane(s: &mut Session, p: &Value, plane: PlaneRef, internalet attachment = s.doc.feature(id).and_then(|feature| match &feature.kind {FeatureKind::Sketch { plane, .. } => Some(if face::anchor(plane).is_some() {"exact_face"+ } else if solidcraft_doc::sheet::plane_sheet_face(plane).is_some() {+ "sheet_face"} else if internal_body.is_some() {"internal_legacy_face"} else {diff --git a/crates/engine/src/cmd/sketch_face.rs b/crates/engine/src/cmd/sketch_face.rsindex 94f0f0f965..42395abf0d 100644--- a/crates/engine/src/cmd/sketch_face.rs+++ b/crates/engine/src/cmd/sketch_face.rs@@ -79,6 +79,7 @@ fn capture_impl(s: &Session, value: &Value, cmd: &str, internal: bool) -> Resultby_component.entry(doc.model_body_component(body)).or_default().push(body);}let mut chosen = None;+ let mut sheet_face: Option<(String, Plane)> = None;let mut work = state.bodies.len().saturating_add(doc.occurrences.len());for (component, path, placement) in placements {let Some(bodies) = by_component.get(&component) else {@@ -104,6 +105,22 @@ fn capture_impl(s: &Session, value: &Value, cmd: &str, internal: bool) -> Resultlet inverse = mat_inverse(&frame).ok_or_else(|| bad(cmd, "invalid selected face frame"))?;let local_point = apply_point(&inverse, point);let tolerance = (body.body.size() * 1e-4).max(1e-5);+ // A flat face of a sheet metal body attaches to its panel: the exact plane comes from+ // the panel's flat region and fold, and the sketch keeps the face's name to follow it.+ if !fixed+ && !internal+ && let Some(sheet) = state.sheets.iter().find(|sheet| sheet.body == body.name)+ && let Some((face, plane)) = sheet.panel_face_at(local_point, tolerance * 10.0)+ {+ if chosen.is_some() || sheet_face.is_some() {+ return Err(bad(cmd, "face point is ambiguous; pick an exact body and face index"));+ }+ let relative = mat_mul(&author_inverse, &frame);+ let plane = Plane::new(apply_point(&relative, plane.origin), apply_vector(&relative, plane.x), apply_vector(&relative, plane.y))+ .ok_or_else(|| bad(cmd, "invalid sheet face plane"))?;+ sheet_face = Some((solidcraft_doc::sheet::sheet_face_name(&body.name, &face), plane));+ continue;+ }let faces = body.body.faces(tolerance)?;let mesh = body.body.tessellate(tolerance)?;work = work.saturating_add(mesh.triangles.len().saturating_mul(if requested_index.is_some() { 1 } else { faces.len() }));@@ -138,6 +155,12 @@ fn capture_impl(s: &Session, value: &Value, cmd: &str, internal: bool) -> Result}}}+ if let Some((name, plane)) = sheet_face {+ if chosen.is_some() {+ return Err(bad(cmd, "face point is ambiguous; pick an exact body and face index"));+ }+ return Ok(PlaneRef::Face { plane, at: apply_point(&author_inverse, point), name: Some(name), anchor: None });+ }let (body, index, path, plane) =chosen.ok_or_else(|| bad(cmd, "the selected planar face no longer exists; choose another face or an explicit fixed plane"))?;if fixed {diff --git a/crates/ui-egui/src/sketch_attachment_ui.rs b/crates/ui-egui/src/sketch_attachment_ui.rsindex 1435760f2a..9cec8a6efa 100644--- a/crates/ui-egui/src/sketch_attachment_ui.rs+++ b/crates/ui-egui/src/sketch_attachment_ui.rs@@ -167,6 +167,10 @@ pub fn panel(app: &mut SolveApp, ctx: &egui::Context, at: Pos2) {ui.label("Legacy face attachment. Rebinding to a certified face creates an exact attachment.");*plane}+ FaceAttachmentStatus::Sheet { plane } => {+ ui.label("Attached to a flat face of a sheet metal body; it follows that panel when the sheet changes.");+ *plane+ }FaceAttachmentStatus::Fixed { plane } => {ui.label("Sketch plane has no body-face attachment.");*planediff --git a/crates/ui-egui/tests/scenarios/s22_sheet_metal_fold.json b/crates/ui-egui/tests/scenarios/s22_sheet_metal_fold.jsonindex 0bbcd4f864..718226ab5f 100644--- a/crates/ui-egui/tests/scenarios/s22_sheet_metal_fold.json+++ b/crates/ui-egui/tests/scenarios/s22_sheet_metal_fold.json@@ -81,16 +81,7 @@}},{- "note": "The sheet flange face is uncertified; choose the displayed fixed-plane option explicitly before drawing the fold line."- },- {- "expect": {- "sketching": false,- "dialog": "this face has no exact planar source"- }- },- {- "widget": "Use fixed plane"+ "note": "A flat face of a sheet attaches the sketch to its panel (by name), in the flat pattern's coordinates."},{"expect": {diff --git a/docs/book/src/guide/sheet-metal.md b/docs/book/src/guide/sheet-metal.mdindex 8d73337b50..9552dcd47d 100644--- a/docs/book/src/guide/sheet-metal.md+++ b/docs/book/src/guide/sheet-metal.md@@ -89,3 +89,15 @@ tool with varying depth is refused before changing sheet geometry. Pocket profilbut a pocket crossing a bend zone cannot yet be refolded. Machining folded bend material,tapered sheet cuts and other unsupported 3D sheet Cut/Intersect operations report an error before changingthe design; they cannot silently restore removed material during a later sheet rebuild.++A sketch can be drawn on a flat face of the sheet: the base or a flange, on either side. Pick+the face (or give `sketch.create` the point `plane: {face: [x, y, z]}`) and the sketch attaches+to that panel instead of to a certified source face. It keeps the face's name,+`sheet:<body>:<panel>:<top|bottom>` (the panel is `base` or the flange's feature tag), and finds+the face again whenever the sheet is rebuilt: after a parameter change such as the thickness or+a flange angle, through Unfold / Refold, after the file is reopened and when the body is+renamed. Sketch coordinates are the flat pattern's, so a point drawn on a flange lies where the+flat pattern and its DXF have it, and on the bottom face y runs the other way, as seen from+below. When the face is gone (its flange is suppressed or deleted) the sketch reports a lost+attachment instead of moving to another face; **Redefine Sketch Plane** attaches it to another+face. `fixed: true` still freezes the picked plane in space.diff --git a/docs/face-attachments.md b/docs/face-attachments.mdindex fd155cab3b..d8747995cd 100644--- a/docs/face-attachments.md+++ b/docs/face-attachments.md@@ -14,6 +14,11 @@ Edited surfaces without retained construction provenance, ambiguous sources, andgenerators require an explicit fixed plane instead. A nearby or parallel face is never usedto repair a new attachment automatically.+The flat faces of a sheet metal body are the exception: they have no construction+certificate, so a sketch on one attaches to its panel by name (`sheet:<body>:<panel>:<side>`)+and finds it again after every rebuild, unfold and refold. If that panel no longer exists the+sketch reports a lost attachment, as above. See the sheet metal guide.+## Create and repairSelect a supported planar face and create a sketch. The desktop selection supplies the exact