Sketch: offset corners trim when they cross and extend when they fall short (#10089)
The chain walk follows ends that share a point, a coincident constraint, or the same position. The offset then meets at the intersection.
This commit is contained in:
committed by
GitHub
parent
31a0c99a2c
commit
5e265089c7
@@ -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)>, bool
|
||||
let 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)>, bool
|
||||
break;
|
||||
}
|
||||
}
|
||||
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)>, bool
|
||||
let 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 {
|
||||
|
||||
@@ -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:?}");
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user