SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sketch: offset corners trim when they cross and extend when they fall short (#10089)
Thodoris Tsagkogeorgas5e265089c74b
diff --git a/crates/engine/src/cmd/sketch_modify.rs b/crates/engine/src/cmd/sketch_modify.rsindex d67dd1aa80..846dfddc59 100644--- a/crates/engine/src/cmd/sketch_modify.rs+++ b/crates/engine/src/cmd/sketch_modify.rs@@ -46,7 +46,7 @@ pub static COMMANDS: &[CommandSpec] = &[.key("O").enabled(in_sketch).params(concat!(- "curves: [ids], distance: number in mm or length expression (creates an editable dimension; positive = left of the chain, or toward `side`), side?: [x,y], chain?: bool (default true: the connected chain); ",+ "curves: [ids], distance: number in mm or length expression (creates an editable dimension; positive = left of the chain, or toward `side`), side?: [x,y], chain?: bool (default true: the connected chain, including ends that only coincide). A corner is trimmed back to the crossing when the offset runs past it, and extended until the offset curves intersect when the corner falls short; ","direction?: one_side|symmetric (default one_side) or symmetric?: bool (the same distance each way; no `side`, whose job it takes over), ","distance2?: positive length expression (Two Sides: an independent distance the other way, as for `solid.extrude`). Each side is its own offset association, listed in `sides`; flip?: bool reverses the primary side; `param`/`param2` name the driving dimensions",created_doc!()@@ -1876,13 +1876,40 @@ fn chamfer_dist_angle(s: &mut Session, p: &Value) -> Result<Value> {// ---------------------------------------------------------------------------------------------// Offset+/// Ends this close are one corner. Profile finding joins ends at the same distance, so a loop+/// the sketch already treats as one profile offsets as one chain.+const ENDPOINT_JOIN: f64 = 1e-4;+/// Curves of the connected chain through `start` (joined where exactly two curves meet), in/// order, with whether each is walked from its stored start (`a`) to its end (`b`).+///+/// A corner counts when the curves share the point, when a coincident constraint makes the two+/// ends one point, or when the ends simply lie on each other. The offset then trims a corner+/// that runs past the crossing and extends one that stops short, so the new curves intersect.fn chain(sk: &Sketch, start: usize, pool: &[usize]) -> (Vec<(usize, bool)>, bool) {let ends = |c: usize| sk.curves.get(c).and_then(|c| c.kind.ends());let Some((s0, s1)) = ends(start) else { return (vec![(start, true)], true) };+ let mut parent: Vec<usize> = (0..sk.points.len()).collect();+ for constraint in &sk.constraints {+ if let ConstraintKind::Coincident { p, q } = constraint.kind {+ union_points(&mut parent, p, q);+ }+ }+ let group: Vec<usize> = (0..parent.len()).map(|i| find_point(&mut parent, i)).collect();+ let same = |a: usize, b: usize| -> bool {+ if a == b {+ return true;+ }+ if group.get(a).zip(group.get(b)).is_some_and(|(x, y)| x == y) {+ return true;+ }+ match (sk.point(a), sk.point(b)) {+ (Some(p), Some(q)) if p.is_finite() && q.is_finite() => p.dist(q) <= ENDPOINT_JOIN,+ _ => false,+ }+ };let next = |from: usize, at: usize, used: &[usize]| -> Option<usize> {- let users: Vec<usize> = pool.iter().copied().filter(|c| ends(*c).is_some_and(|(a, b)| a == at || b == at)).collect();+ let users: Vec<usize> = pool.iter().copied().filter(|c| ends(*c).is_some_and(|(a, b)| same(a, at) || same(b, at))).collect();if users.len() != 2 {return None;}@@ -1894,7 +1921,7 @@ fn chain(sk: &Sketch, start: usize, pool: &[usize]) -> (Vec<(usize, bool)>, boollet mut closed = false;while let Some(n) = next(cur, at, &used) {let Some((a, b)) = ends(n) else { break };- let forward = a == at;+ let forward = same(a, at);fwd.push((n, forward));used.push(n);cur = n;@@ -1903,7 +1930,7 @@ fn chain(sk: &Sketch, start: usize, pool: &[usize]) -> (Vec<(usize, bool)>, boolbreak;}}- if at == s0 && fwd.len() > 1 {+ if fwd.len() > 1 && same(at, s0) {closed = true;} else {// Walk backwards from the start.@@ -1911,7 +1938,7 @@ fn chain(sk: &Sketch, start: usize, pool: &[usize]) -> (Vec<(usize, bool)>, boollet mut back = Vec::new();while let Some(n) = next(cur, at, &used) {let Some((a, b)) = ends(n) else { break };- let forward = b == at;+ let forward = same(b, at);back.push((n, forward));used.push(n);cur = n;@@ -1927,6 +1954,33 @@ fn chain(sk: &Sketch, start: usize, pool: &[usize]) -> (Vec<(usize, bool)>, bool(fwd, closed)}+fn find_point(parent: &mut [usize], mut i: usize) -> usize {+ let mut top = i;+ while parent.get(top).copied().unwrap_or(top) != top {+ top = parent[top];+ }+ while i != top {+ let next = parent.get(i).copied().unwrap_or(top);+ if let Some(slot) = parent.get_mut(i) {+ *slot = top;+ }+ i = next;+ }+ top+}++fn union_points(parent: &mut [usize], a: usize, b: usize) {+ if a >= parent.len() || b >= parent.len() {+ return;+ }+ let (a, b) = (find_point(parent, a), find_point(parent, b));+ if a != b+ && let Some(slot) = parent.get_mut(b)+ {+ *slot = a;+ }+}+/// An offset piece: shape walked in chain direction, offset by `d` to the left.#[derive(Clone)]enum Piece {diff --git a/crates/engine/src/cmd/sketch_modify_tests.rs b/crates/engine/src/cmd/sketch_modify_tests.rsindex bdd89943c0..e5c8e6ee65 100644--- a/crates/engine/src/cmd/sketch_modify_tests.rs+++ b/crates/engine/src/cmd/sketch_modify_tests.rs@@ -3545,3 +3545,181 @@ fn a_tangent_arc_can_end_on_an_existing_point() {assert!(s.execute("sketch.arc.tangent", &json!({"start": format!("{down}.end"), "curve": down, "end": format!("{down}.end")})).is_err());assert_eq!(s.doc.to_json(), before);}++/// Where a circle of radius `r1` at the origin meets a circle of radius `r2` at `(-d, 0)`,+/// then the same on the right. `(top-left, bottom-left, top-right, bottom-right)`.+fn lobe_corners(r1: f64, r2: f64, d: f64) -> (Vec2, Vec2, Vec2, Vec2) {+ let a = (r1 * r1 - r2 * r2 + d * d) / (2.0 * d);+ let h = (r1 * r1 - a * a).sqrt();+ (Vec2::new(-a, h), Vec2::new(-a, -h), Vec2::new(a, h), Vec2::new(a, -h))+}++fn arc_ends(sk: &solidcraft_sketch::Sketch, id: &str) -> (usize, usize, Vec2, Vec2, Vec2) {+ match sk.curves[sk.curve_index(id).unwrap()].kind {+ CurveKind::Arc { c, a, b } => (a, b, sk.point(c).unwrap(), sk.point(a).unwrap(), sk.point(b).unwrap()),+ ref other => panic!("{id} is {other:?}"),+ }+}++fn line_ends(sk: &solidcraft_sketch::Sketch, id: &str) -> (usize, Vec2, usize, Vec2) {+ match sk.curves[sk.curve_index(id).unwrap()].kind {+ CurveKind::Line { a, b } => (a, sk.point(a).unwrap(), b, sk.point(b).unwrap()),+ ref other => panic!("{id} is {other:?}"),+ }+}++/// Midpoint of the counter-clockwise arc from `a` to `b` around `c`.+fn ccw_mid(c: Vec2, a: Vec2, b: Vec2) -> Vec2 {+ let start = (a - c).angle();+ let mut sweep = (b - c).angle() - start;+ if sweep <= 1e-12 {+ sweep += std::f64::consts::TAU;+ }+ c + Vec2::from_angle(start + sweep * 0.5) * c.dist(a)+}++/// Corners whose ends are separate points offset as one chain. An offset that runs past the+/// crossing is trimmed back to it; one that stops short is extended until the curves intersect.+#[test]+fn offset_corners_trim_the_overlap_and_extend_the_gap() {+ let (big, small, apart) = (27.5, 12.5, 27.95);+ let (tl, bl, tr, br) = lobe_corners(big, small, apart);+ let mut s = new_sketch();+ let draw = |s: &mut Session, id: &str, center: [f64; 2], start: Vec2, end: Vec2| {+ run(+ s,+ "sketch.arc.center_point",+ json!({+ "id": id, "center": center, "start": [start.x, start.y], "end": [end.x, end.y], "connect": false,+ }),+ );+ };+ draw(&mut s, "top", [0.0, 0.0], tr, tl);+ draw(&mut s, "left", [-apart, 0.0], tl, bl);+ draw(&mut s, "bottom", [0.0, 0.0], bl, br);+ draw(&mut s, "right", [apart, 0.0], br, tr);+ let sk = sketch(&s);+ let (top_end, left_start) = (sk.resolve_point("top.end").unwrap(), sk.resolve_point("left.start").unwrap());+ assert_ne!(top_end, left_start, "the corner is two points");+ assert!(sk.point(top_end).unwrap().dist(sk.point(left_start).unwrap()) < 1e-9);+ assert!(!sk.constraints.iter().any(|c| matches!(c.kind, ConstraintKind::Coincident { p, q } if p == top_end || q == top_end)));+ assert_eq!(profiles(&s).len(), 1, "the four arcs are one profile");++ // Chain off copies the one arc, source angle and all, so the corner stays open.+ let alone = run(&mut s, "sketch.offset", json!({"curves": ["top"], "distance": -3, "chain": false}));+ assert_eq!(ids(&alone["curves"]).len(), 1);+ let radial = tl.normalized().unwrap() * (big + 3.0);+ let (_, _, _, _, open_end) = arc_ends(&sketch(&s), &ids(&alone["curves"])[0]);+ assert!(open_end.dist(radial) < 1e-4, "untrimmed end {open_end:?}, radial {radial:?}");+ run(&mut s, "edit.undo", json!({}));++ let out = run(&mut s, "sketch.offset", json!({"curves": ["top"], "distance": -3}));+ assert_eq!(ids(&out["curves"]).len(), 4, "{out}");+ assert_eq!(out["sides"].as_array().unwrap().len(), 1);+ let sk = sketch(&s);+ assert_eq!(sk.offsets.len(), 1);+ let rec = &sk.offsets[0];+ assert!(rec.closed);+ assert_eq!(+ rec.sources.iter().map(|(id, forward)| (id.as_str(), *forward)).collect::<Vec<_>>(),+ vec![("top", true), ("left", true), ("bottom", true), ("right", true)]+ );+ let (meet_tl, meet_bl, meet_tr, meet_br) = lobe_corners(big + 3.0, small + 3.0, apart);+ let mut prev_end = arc_ends(&sk, rec.outputs.last().unwrap()).1;+ for (id, radius, center) in [+ ("top", big + 3.0, Vec2::ZERO),+ ("left", small + 3.0, Vec2::new(-apart, 0.0)),+ ("bottom", big + 3.0, Vec2::ZERO),+ ("right", small + 3.0, Vec2::new(apart, 0.0)),+ ] {+ let i = rec.sources.iter().position(|(source, _)| source == id).unwrap();+ let (a, b, c, start, _) = arc_ends(&sk, &rec.outputs[i]);+ assert_eq!(prev_end, a, "{id} starts where the previous arc ends");+ assert!((c.dist(start) - radius).abs() < 1e-4 && c.dist(center) < 1e-6, "{id} at {c:?} radius {}", c.dist(start));+ prev_end = b;+ }+ let (_, _, _, _, trimmed) = arc_ends(&sk, &rec.outputs[0]);+ assert!(trimmed.dist(meet_tl) < 1e-4, "top-left corner {trimmed:?}, intersection {meet_tl:?}");+ assert!(trimmed.dist(radial) > 1.0, "trimmed back from the untrimmed end {radial:?} to {trimmed:?}");+ let (_, _, c, a, b) = arc_ends(&sk, &rec.outputs[0]);+ let mid = ccw_mid(c, a, b);+ assert!(mid.dist(Vec2::new(0.0, big + 3.0)) < 1e-3, "the top arc stays the short one, mid {mid:?}");+ let left_i = rec.sources.iter().position(|(source, _)| source == "left").unwrap();+ let (_, _, c, a, b) = arc_ends(&sk, &rec.outputs[left_i]);+ let mid = ccw_mid(c, a, b);+ assert!(mid.dist(Vec2::new(-apart - (small + 3.0), 0.0)) < 1e-3, "the left arc stays the outer one, mid {mid:?}");+ // The other three crossings, so a closed chain joins the last corner as well.+ let corners: Vec<Vec2> = rec+ .outputs+ .iter()+ .map(|id| {+ let (_, _, _, _, end) = arc_ends(&sk, id);+ end+ })+ .collect();+ for want in [meet_tl, meet_bl, meet_tr, meet_br] {+ assert!(corners.iter().any(|q| q.dist(want) < 1e-4), "missing {want:?} in {corners:?}");+ }++ // Editing the distance keeps the corners on the new intersection.+ let param = out["param"].as_str().unwrap();+ run(&mut s, "parameters.change", json!({"name": param, "expression": "4 mm"}));+ let sk = sketch(&s);+ assert!((sk.offsets[0].distance + 4.0).abs() < 1e-6, "distance {}", sk.offsets[0].distance);+ let (grown, _, _, _) = lobe_corners(big + 4.0, small + 4.0, apart);+ let top_i = sk.offsets[0].sources.iter().position(|(source, _)| source == "top").unwrap();+ let top_out = sk.offsets[0].outputs[top_i].clone();+ let (_, _, _, _, trimmed) = arc_ends(&sk, &top_out);+ assert!(trimmed.dist(grown) < 1e-4, "after the edit {trimmed:?}, intersection {grown:?}");++ // An L of two lines. Negative (outward) stops short of the corner and must be extended.+ // Positive runs past it and must be trimmed back. The ends only share a position.+ let corner_of = |distance: f64| -> Vec2 {+ let mut s = new_sketch();+ run(&mut s, "sketch.line", json!({"points": [[0.0, 0.0], [20.0, 0.0]], "connect": false, "infer": false}));+ run(&mut s, "sketch.line", json!({"points": [[20.0, 0.0], [20.0, 20.0]], "connect": false, "infer": false}));+ let sk = sketch(&s);+ assert_ne!(sk.resolve_point("l1.end").unwrap(), sk.resolve_point("l2.start").unwrap());+ let out = run(&mut s, "sketch.offset", json!({"curves": ["l1"], "distance": distance}));+ assert_eq!(ids(&out["curves"]).len(), 2, "distance {distance}: {out}");+ let sk = sketch(&s);+ let (first, second) = (&sk.offsets[0].outputs[0], &sk.offsets[0].outputs[1]);+ let (_, _, end_i, end) = line_ends(&sk, first);+ let (start_i, start, _, _) = line_ends(&sk, second);+ assert_eq!(end_i, start_i, "one corner point");+ assert!(end.dist(start) < 1e-9);+ end+ };+ let extended = corner_of(-3.0);+ assert!(extended.dist(Vec2::new(23.0, -3.0)) < 1e-6, "extended to {extended:?}");+ let trimmed = corner_of(3.0);+ assert!(trimmed.dist(Vec2::new(17.0, 3.0)) < 1e-6, "trimmed to {trimmed:?}");++ let mut s = new_sketch();+ run(&mut s, "sketch.line", json!({"points": [[0.0, 0.0], [20.0, 0.0]], "connect": false, "infer": false}));+ run(&mut s, "sketch.line", json!({"points": [[20.0, 0.0], [20.0, 20.0]], "connect": false, "infer": false}));+ let alone = run(&mut s, "sketch.offset", json!({"curves": ["l1"], "distance": -3, "chain": false}));+ assert_eq!(ids(&alone["curves"]).len(), 1);+ let (_, _, _, end) = line_ends(&sketch(&s), &ids(&alone["curves"])[0]);+ assert!(end.dist(Vec2::new(20.0, -3.0)) < 1e-6, "chain off leaves the gap, end {end:?}");++ // The same L, joined only by a coincident constraint across a gap the tolerance would not.+ let mut s = new_sketch();+ run(&mut s, "sketch.line", json!({"points": [[0.0, 0.0], [20.0, 0.0]], "connect": false, "infer": false}));+ run(&mut s, "sketch.line", json!({"points": [[20.5, 0.5], [20.5, 20.0]], "connect": false, "infer": false}));+ let gap = {+ let sk = sketch(&s);+ sk.point(sk.resolve_point("l1.end").unwrap()).unwrap().dist(sk.point(sk.resolve_point("l2.start").unwrap()).unwrap())+ };+ assert!(gap > 0.4, "the ends start {gap} mm apart");+ run(&mut s, "sketch.constraint.fix", json!({"entity": "l1.start"}));+ run(&mut s, "sketch.constraint.fix", json!({"entity": "l2.end"}));+ run(&mut s, "sketch.constraint.horizontal_vertical", json!({"line": "l1", "mode": "horizontal"}));+ run(&mut s, "sketch.constraint.horizontal_vertical", json!({"line": "l2", "mode": "vertical"}));+ run(&mut s, "sketch.constraint.coincident", json!({"a": "l1.end", "b": "l2.start"}));+ let out = run(&mut s, "sketch.offset", json!({"curves": ["l1"], "distance": -3}));+ assert_eq!(ids(&out["curves"]).len(), 2, "{out}");+ let sk = sketch(&s);+ let (_, _, _, end) = line_ends(&sk, &sk.offsets[0].outputs[0]);+ assert!(end.dist(Vec2::new(23.5, -3.0)) < 1e-4, "coincident corner extended to {end:?}");+}