Coincident on two circles lays the second on the first (#5038)
Coincident with two circles (or arcs) picked was refused: "two curves must both be straight lines; otherwise choose a point and a curve". It now lays the second pick on the first: Concentric and Equal together, in one step, with the first staying put. A pair already concentric or equal gets only the other half; one already lying on the other is refused as nothing to add. Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -126,7 +126,7 @@ pub static COMMANDS: &[CommandSpec] = &[
|
||||
.at("SKETCH", "CONSTRAINTS")
|
||||
.icon("c_coincident")
|
||||
.enabled(in_sketch)
|
||||
.params("a, b: points, a point and a curve or sketch axis (x / y: the sketch's own axes, unless a curve has that id; an axis becomes a linked construction line on it, reported in created), or two distinct lines (joins their closest endpoints)"),
|
||||
.params("a, b: points, a point and a curve or sketch axis (x / y: the sketch's own axes, unless a curve has that id; an axis becomes a linked construction line on it, reported in created), or two distinct lines (joins their closest endpoints), or two circles/arcs (the second lies on the first: concentric and equal, `constraints` lists both)"),
|
||||
CommandSpec::new("sketch.constraint.tangent", "Tangent", c_tangent)
|
||||
.at("SKETCH", "CONSTRAINTS")
|
||||
.icon("c_tangent")
|
||||
@@ -1728,6 +1728,9 @@ fn c_coincident(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "sketch.constraint.coincident";
|
||||
// Already tied (e.g. connected when it was drawn there): nothing to add.
|
||||
let sk = s.doc.sketch(target_sketch(s, p, cmd)?)?;
|
||||
if let Some((a, b)) = two_round(sk, p) {
|
||||
return coincident_circles(s, p, cmd, a, b);
|
||||
}
|
||||
let pt = |k: &str| p.get(k).and_then(Value::as_str).and_then(|r| sk.resolve_point(r));
|
||||
let line_points = coincident_line_points(sk, p, cmd)?;
|
||||
if let Some((a, b)) = line_points.or_else(|| pt("a").zip(pt("b")))
|
||||
@@ -1758,6 +1761,41 @@ fn c_coincident(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
})
|
||||
}
|
||||
|
||||
/// `a` and `b` both circles or arcs (two different ones).
|
||||
fn two_round(sk: &Sketch, p: &Value) -> Option<(usize, usize)> {
|
||||
let round = |k: &str| {
|
||||
let c = sk.curve_index(p.get(k)?.as_str()?)?;
|
||||
matches!(sk.curves.get(c)?.kind, CurveKind::Circle { .. } | CurveKind::Arc { .. }).then_some(c)
|
||||
};
|
||||
let (a, b) = (round("a")?, round("b")?);
|
||||
(a != b).then_some((a, b))
|
||||
}
|
||||
|
||||
/// Two circles or arcs made coincident lie on each other: one centre and one radius (Concentric
|
||||
/// and Equal), the second pick moving onto the first, in one step. A half already there is
|
||||
/// not added again.
|
||||
fn coincident_circles(s: &mut Session, p: &Value, cmd: &str, a: usize, b: usize) -> Result<Value> {
|
||||
let (ids, info) = edit(s, p, cmd, true, |sk, _| {
|
||||
let rep = solve(&mut sk.clone());
|
||||
let pair = |x: usize, y: usize| (x, y) == (a, b) || (x, y) == (b, a);
|
||||
let concentric = sk.constraints.iter().any(|c| !c.driven && matches!(c.kind, ConstraintKind::Concentric { a: x, b: y } if pair(x, y)));
|
||||
let equal = sk.constraints.iter().any(|c| !c.driven && matches!(c.kind, ConstraintKind::Equal { a: x, b: y } if pair(x, y)));
|
||||
let mut ids = Vec::new();
|
||||
if !concentric {
|
||||
ids.push(add_c(sk, ConstraintKind::Concentric { a, b })?);
|
||||
}
|
||||
if !equal {
|
||||
ids.push(add_c(sk, ConstraintKind::Equal { a, b })?);
|
||||
}
|
||||
if ids.is_empty() {
|
||||
return Err(bad(cmd, "these circles already lie on each other"));
|
||||
}
|
||||
apply_in_order(sk, &rep, &[Ent::Curve(a)], Ent::Curve(b), cmd)?;
|
||||
Ok(ids)
|
||||
})?;
|
||||
Ok(json!({"constraint": ids[0], "constraints": ids, "sketch": info}))
|
||||
}
|
||||
|
||||
/// Four endpoint pairs, ordered independently of pick order when distances tie.
|
||||
fn coincident_line_points(sk: &Sketch, p: &Value, cmd: &str) -> Result<Option<(usize, usize)>> {
|
||||
let curve = |key: &str| p.get(key).and_then(Value::as_str).and_then(|id| sk.curve_index(id));
|
||||
|
||||
@@ -888,3 +888,38 @@ fn undoing_a_defining_dimension_removes_the_parameter_too() {
|
||||
assert_eq!(param_row(&mut s, "w")["expression"], "20");
|
||||
assert!((line_length(&s, "la") - 20.0).abs() < 1e-6);
|
||||
}
|
||||
|
||||
/// Coincident on two circles (or arcs) lays the second on the first: one centre and one
|
||||
/// radius, in one step, and the first stays. It used to be refused ("two curves must both be
|
||||
/// straight lines").
|
||||
#[test]
|
||||
fn coincident_circles_lie_on_each_other() {
|
||||
let mut s = new_sketch();
|
||||
run(&mut s, "sketch.circle.center", json!({"center":[0,0],"radius":10}));
|
||||
run(&mut s, "sketch.circle.center", json!({"center":[3,1],"radius":8}));
|
||||
let undo = s.undo.len();
|
||||
let r = run(&mut s, "sketch.constraint.coincident", json!({"a":"c1","b":"c2"}));
|
||||
assert_eq!(r["constraints"].as_array().unwrap().len(), 2, "{r}");
|
||||
assert_eq!(s.undo.len(), undo + 1);
|
||||
let sk = sketch(&s);
|
||||
let circle = |id: &str| {
|
||||
let c = sk.curve_index(id).unwrap();
|
||||
match sk.curves[c].kind {
|
||||
solidcraft_sketch::CurveKind::Circle { c, r } => (sk.point(c).unwrap(), r),
|
||||
_ => panic!("{id} is a circle"),
|
||||
}
|
||||
};
|
||||
let ((c1, r1), (c2, r2)) = (circle("c1"), circle("c2"));
|
||||
assert!(c1.dist(Vec2::new(0.0, 0.0)) < 1e-6 && (r1 - 10.0).abs() < 1e-6, "the first stays");
|
||||
assert!(c2.dist(c1) < 1e-6 && (r2 - r1).abs() < 1e-6, "the second lies on it: {c2:?} r {r2}");
|
||||
// Again: nothing to add.
|
||||
assert!(s.execute("sketch.constraint.coincident", &json!({"a":"c1","b":"c2"})).is_err());
|
||||
// An arc onto a circle.
|
||||
run(&mut s, "sketch.arc.three_point", json!({"start":[20,0],"through":[25,5],"end":[30,0]}));
|
||||
run(&mut s, "sketch.constraint.coincident", json!({"a":"c1","b":"a1"}));
|
||||
let sk = sketch(&s);
|
||||
let a = sk.curve_index("a1").unwrap();
|
||||
let solidcraft_sketch::CurveKind::Arc { c, a: start, .. } = sk.curves[a].kind else { panic!("a1 is an arc") };
|
||||
assert!(sk.point(c).unwrap().dist(Vec2::new(0.0, 0.0)) < 1e-6);
|
||||
assert!((sk.point(start).unwrap().dist(sk.point(c).unwrap()) - 10.0).abs() < 1e-6);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,25 @@
|
||||
use serde_json::json;
|
||||
use solidcraft_ui_egui::scenario::Harness;
|
||||
|
||||
/// The Coincident tool takes two circles clicked by their edges and lays the second on the first.
|
||||
#[test]
|
||||
fn the_coincident_tool_lays_one_circle_on_another() {
|
||||
let mut h = Harness::new();
|
||||
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
|
||||
h.app.run("sketch.circle.center", json!({"center":[0,0],"radius":10})).unwrap();
|
||||
h.app.run("sketch.circle.center", json!({"center":[30,0],"radius":6})).unwrap();
|
||||
h.call("ui.view", json!({"view":"top"}));
|
||||
h.call("ui.view", json!({"view":"fit"}));
|
||||
h.frames(3);
|
||||
h.step(&json!({"start":"sketch.constraint.coincident"})).unwrap();
|
||||
h.step(&json!({"click":{"world":[0,10,0]}})).unwrap();
|
||||
h.step(&json!({"click":{"world":[30,6,0]}})).unwrap();
|
||||
let st = h.app.session.world_state();
|
||||
let sk = &st.sketch(h.app.session.active_sketch.unwrap()).unwrap().sketch;
|
||||
use solidcraft_engine::sketch::ConstraintKind;
|
||||
let laid = sk.constraints.iter().filter(|k| matches!(k.kind, ConstraintKind::Concentric { .. } | ConstraintKind::Equal { .. })).count();
|
||||
assert_eq!(laid, 2, "{:?} {:?}", sk.constraints, h.app.status);
|
||||
let c2 = sk.curve_index("c2").unwrap();
|
||||
let solidcraft_engine::sketch::CurveKind::Circle { c, r } = sk.curves[c2].kind else { panic!("c2 is a circle") };
|
||||
assert!(sk.point(c).unwrap().len() < 1e-6 && (r - 10.0).abs() < 1e-6);
|
||||
}
|
||||
Reference in New Issue
Block a user