SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sketch: allow dimension edits with tangent caps (#4823) (#9494)
Colin Faulkingham2e981d66e89d
diff --git a/crates/doc/src/document.rs b/crates/doc/src/document.rsindex 1e0a633997..e41ceaeb17 100644--- a/crates/doc/src/document.rs+++ b/crates/doc/src/document.rs@@ -4211,6 +4211,14 @@ impl Document {} else {solidcraft_sketch::solve_after_edit_with_analysis(sk, stored, was(sk).as_deref(), analysis)};+ // An attachment to the old offset can prevent the source from moving at all.+ // Retry from a source-only seed, adopting it only if every constraint still holds.+ if !report.ok()+ && report.oversized.is_none()+ && let Some(retried) = sk.solve_after_offset_edit(stored, was(sk).as_deref(), analysis)+ {+ report = retried;+ }}Ok(report)}diff --git a/crates/engine/src/cmd/parameters.rs b/crates/engine/src/cmd/parameters.rsindex 3f22f176bf..d8b89d0e5e 100644--- a/crates/engine/src/cmd/parameters.rs+++ b/crates/engine/src/cmd/parameters.rs@@ -230,7 +230,18 @@ fn keep_dimension_start(s: &mut Session, name: &str) {}let reference: Vec<_> = stored.points.iter().map(|p| p.pos).collect();let hold = Hold { points: vec![start], radii: Vec::new() };- if !solve_with(&mut trial, &hold, Some(&reference), Analysis::StatusOnly, None).keeps_orientation() {+ let solved = if trial.offsets.is_empty() && trial.freeform_offsets.is_empty() {+ solve_with(&mut trial, &hold, Some(&reference), Analysis::StatusOnly, None).keeps_orientation()+ } else {+ // A solve against stale offset points can stretch an attached cap into a different+ // tangency branch. Keep the start through the complete solve/refresh sequence.+ let Some(p) = trial.points.get_mut(start) else { continue };+ p.fixed = true;+ s.doc+ .solve_sketch_with_analysis(&vals, &mut trial, &stored.driving_values(), Some(stored), Analysis::StatusOnly)+ .is_ok_and(|report| report.keeps_orientation())+ };+ if !solved {continue;}if stored.points.len() == trial.points.len() {diff --git a/crates/engine/src/cmd/sketch_modify_tests.rs b/crates/engine/src/cmd/sketch_modify_tests.rsindex e5c8e6ee65..83f3c18f49 100644--- a/crates/engine/src/cmd/sketch_modify_tests.rs+++ b/crates/engine/src/cmd/sketch_modify_tests.rs@@ -2420,6 +2420,167 @@ fn an_offset_slot_still_moves_with_the_dimension_that_places_it() {}}+fn capped_line_offset(fixed_cap: bool) -> Session {+ let mut s = Session::default();+ run(+ &mut s,+ "timeline.add",+ json!({+ "feature": {"id":1,"name":"Capped offset","type":"sketch","plane":{"type":"origin","name":"XY"},"sketch":{+ "points":[+ {"id":"origin","pos":[0,0],"fixed":true},+ {"id":"end","pos":[0,50],"fixed":false},+ {"id":"oa","pos":[-2,0],"fixed":true},+ {"id":"ob","pos":[-2,50],"fixed":true},+ {"id":"center","pos":[-1,50],"fixed":false},+ {"id":"cap_end","pos":[-2,50],"fixed":fixed_cap}+ ],+ "curves":[+ {"id":"source","type":"line","a":0,"b":1},+ {"id":"offset","type":"line","a":2,"b":3},+ {"id":"cap","type":"arc","c":4,"a":1,"b":5}+ ],+ "constraints":[+ {"id":"vertical","type":"vertical","l":0},+ {"id":"length","type":"length","l":0,"value":50,"param":"height"},+ {"id":"source_tangent","type":"tangent","a":0,"b":2},+ {"id":"offset_tangent","type":"tangent","a":1,"b":2},+ {"id":"end_join","type":"coincident","p":3,"q":5}+ ],+ "offsets":[{"sources":[["source",true]],"outputs":["offset"],"distance":2,"closed":false}]+ }},+ "params":[{"name":"height","expression":"50","unit":"mm"}]+ }),+ );+ run(&mut s, "sketch.edit", json!({"sketch":1}));+ s+}++#[test]+fn a_tangent_cap_follows_its_offset_when_the_source_length_changes() {+ // #4823: the cap joins the source to the offset's held endpoint. Solving against the old+ // endpoint first makes every length change look contradictory, before the offset can move.+ let mut s = capped_line_offset(false);+ let check = |s: &Session, height: f64| {+ let world = s.world_state();+ let solved = world.sketch(1).unwrap();+ assert!(solved.report.keeps_orientation(), "{:?}", solved.report);+ assert!(solved.report.fully_constrained());+ let sk = &solved.sketch;+ for (id, expected) in [+ ("origin", Vec2::ZERO),+ ("end", Vec2::new(0.0, height)),+ ("oa", Vec2::new(-2.0, 0.0)),+ ("ob", Vec2::new(-2.0, height)),+ ("center", Vec2::new(-1.0, height)),+ ("cap_end", Vec2::new(-2.0, height)),+ ] {+ let point = sk.points.iter().find(|p| p.id == id).unwrap();+ assert!(point.pos.dist(expected) < 1e-6, "{id}: {:?}, expected {expected:?}", point.pos);+ }+ assert_eq!(sk.constraints.len(), 5);+ assert_eq!(sk.offsets.len(), 1);+ };+ check(&s, 50.0);+ let mut previous = 50.0;+ for height in [60.0, 40.0, 70.0] {+ run(&mut s, "parameters.change", json!({"name":"height","expression":height.to_string()}));+ check(&s, height);+ run(&mut s, "edit.undo", json!({}));+ check(&s, previous);+ run(&mut s, "edit.redo", json!({}));+ check(&s, height);+ previous = height;+ }+ let reopened = Session::new(solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap());+ check(&reopened, 70.0);+}++#[test]+fn an_offset_cap_fixed_at_the_old_height_still_refuses_a_length_change() {+ let mut s = capped_line_offset(true);+ let before = s.doc.to_json();+ let undo = s.undo.len();+ assert!(s.execute("parameters.change", &json!({"name":"height","expression":"60"})).is_err());+ assert_eq!(s.doc.to_json(), before);+ assert_eq!(s.undo.len(), undo);+}++#[test]+fn a_cap_on_an_offset_arc_keeps_its_radius_through_large_length_edits() {+ // Two externally tangent source arcs: radii 3 and 6, centres separated by (4, -sqrt(65)).+ // Their inward/outward offsets share those centres; a radius-1 cap closes the 2 mm gap.+ // The preliminary keep-start solve used to stretch that cap onto another tangency branch.+ let dy = 65.0_f64.sqrt();+ let end_dy = 11.0_f64.sqrt();+ for batch in [false, true] {+ let mut s = Session::default();+ run(+ &mut s,+ "timeline.add",+ json!({+ "feature":{"id":1,"name":"Curved cap","type":"sketch","plane":{"type":"origin","name":"XY"},"sketch":{+ "points":[+ {"id":"origin","pos":[0,0],"fixed":true},+ {"id":"end","pos":[0,50]},+ {"id":"bend_center","pos":[3,50]},+ {"id":"bend_join","pos":[3.0+4.0/3.0,50.0-dy/3.0]},+ {"id":"tip_center","pos":[7,50.0-dy]},+ {"id":"tip_end","pos":[2,50.0-dy-end_dy]},+ {"id":"oa","pos":[-2,0],"fixed":true},+ {"id":"ob","pos":[-2,50],"fixed":true},+ {"id":"offset_join","pos":[3.0+20.0/9.0,50.0-dy*5.0/9.0],"fixed":true},+ {"id":"offset_end","pos":[7.0-10.0/3.0,50.0-dy-end_dy*2.0/3.0],"fixed":true},+ {"id":"cap_center","pos":[7.0-25.0/6.0,50.0-dy-end_dy*5.0/6.0]},+ {"id":"cap_end","pos":[7.0-10.0/3.0,50.0-dy-end_dy*2.0/3.0]}+ ],+ "curves":[+ {"id":"source","type":"line","a":0,"b":1},+ {"id":"bend","type":"arc","c":2,"a":3,"b":1},+ {"id":"tip","type":"arc","c":4,"a":3,"b":5},+ {"id":"offset","type":"line","a":6,"b":7},+ {"id":"bend_offset","type":"arc","c":2,"a":8,"b":7},+ {"id":"tip_offset","type":"arc","c":4,"a":8,"b":9},+ {"id":"cap","type":"arc","c":10,"a":5,"b":11}+ ],+ "constraints":[+ {"id":"vertical","type":"vertical","l":0},+ {"id":"length","type":"length","l":0,"value":50,"param":"height"},+ {"id":"bend_tangent","type":"tangent","a":0,"b":1},+ {"id":"tip_tangent","type":"tangent","a":1,"b":2},+ {"id":"tip_distance","type":"line_circle_distance","l":0,"c":2,"value":1},+ {"id":"bend_radius","type":"radius","c":1,"value":3},+ {"id":"tip_radius","type":"radius","c":2,"value":6},+ {"id":"end_distance","type":"point_line_distance","p":5,"l":0,"value":2},+ {"id":"cap_tangent","type":"tangent","a":2,"b":6},+ {"id":"end_join","type":"coincident","p":9,"q":11}+ ],+ "offsets":[{"sources":[["source",true],["bend",false],["tip",true]],+ "outputs":["offset","bend_offset","tip_offset"],"distance":2,"closed":false}]+ }},+ "params":[{"name":"height","expression":"50","unit":"mm"}]+ }),+ );+ run(&mut s, "sketch.edit", json!({"sketch":1}));+ let initial = sketch(&s);+ for height in [55.0, 60.0, 70.0, 40.0] {+ let params =+ if batch { json!({"changes":{"height":height.to_string()}}) } else { json!({"name":"height","expression":height.to_string()}) };+ run(&mut s, "parameters.change", params);+ let world = s.world_state();+ let solved = world.sketch(1).unwrap();+ assert!(solved.report.keeps_orientation() && solved.report.fully_constrained(), "{:?}", solved.report);+ for (p, before) in solved.sketch.points.iter().zip(&initial.points) {+ let shift = if matches!(p.id.as_str(), "origin" | "oa") { 0.0 } else { height - 50.0 };+ let expected = before.pos + Vec2::new(0.0, shift);+ assert!(p.pos.dist(expected) < 1e-6, "batch={batch}, height={height}, {}: {:?}, expected {expected:?}", p.id, p.pos);+ assert_eq!(p.fixed, before.fixed, "temporary source holds must not be saved");+ }+ assert_eq!(solved.sketch.constraints.len(), 10);+ }+ }+}+#[test]fn offset_driver_covers_disconnected_selections_and_refuses_bad_values_atomically() {let mut s = new_sketch();diff --git a/crates/sketch/src/offset.rs b/crates/sketch/src/offset.rsindex 23b013dab4..5378f34724 100644--- a/crates/sketch/src/offset.rs+++ b/crates/sketch/src/offset.rs@@ -115,6 +115,80 @@ impl Sketch {}}+ /// Retry a failed solve whose source edit was blocked by attachments to an offset's old+ /// fixed points. Seed the sources without those attachments, rebuild the offsets, then+ /// solve every attachment with the sources held. Nothing is adopted unless the complete+ /// sketch solves with its original constraints and orientation.+ pub fn solve_after_offset_edit(+ &mut self,+ old: &crate::DrivingValues,+ reference: Option<&[Vec2]>,+ analysis: crate::Analysis,+ ) -> Option<crate::SolveReport> {+ let source =+ |id: &str| self.offsets.iter().any(|o| o.sources.iter().any(|(s, _)| s == id)) || self.freeform_offsets.iter().any(|o| o.source == id);+ let output = |id: &str| self.offsets.iter().any(|o| o.owns_output(id)) || self.freeform_offsets.iter().any(|o| o.output == id);+ let source_points: std::collections::BTreeSet<usize> =+ self.curves.iter().filter(|c| source(&c.id)).flat_map(|c| c.kind.point_ids()).collect();+ let outputs: std::collections::BTreeSet<usize> = self.curves.iter().enumerate().filter(|(_, c)| output(&c.id)).map(|(i, _)| i).collect();+ let output_points: std::collections::BTreeSet<usize> =+ outputs.iter().filter_map(|i| self.curves.get(*i)).flat_map(|c| c.kind.point_ids()).filter(|p| !source_points.contains(p)).collect();+ let mut candidate = self.clone();+ candidate.constraints.retain(|c| {+ !c.kind.indices().1.iter().any(|i| outputs.contains(i)) && !self.constraint_points(&c.kind).iter().any(|p| output_points.contains(p))+ });+ if candidate.constraints.len() == self.constraints.len() {+ return None;+ }+ let before: Vec<Vec2> = reference.map_or_else(|| self.points.iter().map(|p| p.pos).collect(), <[Vec2]>::to_vec);+ if !crate::solve_after_edit_with_analysis(&mut candidate, old, Some(&before), crate::Analysis::StatusOnly).keeps_orientation() {+ return None;+ }+ candidate.constraints.clone_from(&self.constraints);+ candidate.refresh_offsets().ok()?;+ // Keep the freshly rebuilt offset exact while its attached geometry catches up.+ // Refresh may retire output curves or refine a dependent spline: resolve holds again.+ let hold = crate::Hold {+ points: candidate.curves.iter().filter(|c| source(&c.id)).flat_map(|c| c.kind.point_ids()).collect(),+ radii: candidate.curves.iter().enumerate().filter(|(_, c)| source(&c.id) || output(&c.id)).map(|(i, _)| i).collect(),+ };+ if !crate::solve_with(&mut candidate, &hold, Some(&before), crate::Analysis::StatusOnly, None).keeps_orientation() {+ // A cap tangent to an arc can land on the other tangency branch after a large+ // jump. Walk the held source and output points from their stored positions.+ // Their own dimensions are restored after the walk, not imposed at each step.+ let mut walking = candidate.clone();+ walking.constraints.retain(|c| candidate.constraint_points(&c.kind).iter().any(|p| !hold.points.contains(p)));+ for i in &hold.points {+ if let Some(p) = walking.points.get_mut(*i) {+ p.fixed = true;+ }+ }+ for i in &hold.radii {+ if let Some(c) = walking.curves.get_mut(*i) {+ c.fixed = true;+ }+ }+ let mut from = walking.clone();+ for (p, pos) in from.points.iter_mut().zip(&before) {+ p.pos = *pos;+ }+ crate::solve_after_link_move(&mut walking, &from, old, crate::Analysis::StatusOnly)?;+ for (p, q) in candidate.points.iter_mut().zip(&walking.points) {+ p.pos = q.pos;+ }+ for (c, d) in candidate.curves.iter_mut().zip(&walking.curves) {+ c.kind.clone_from(&d.kind);+ }+ }+ // Publish ordinary freedom/redundancy diagnostics, without the temporary holds.+ let report = crate::solve_after_edit_with_analysis(&mut candidate, old, Some(&before), analysis);+ if !report.keeps_orientation() {+ return None;+ }+ *self = candidate;+ Some(report)+ }+pub fn refresh_offsets(&mut self) -> Result<(), SketchError> {if self.offsets.is_empty() && self.freeform_offsets.is_empty() {return Ok(());