fix: midpoint tool rejects two lines (#3836)

This commit is contained in:
Mauznemo authored and GitHub committed 2026-10-21 20:36:29 +00:00
1 parent 17ece2edc0
commit 84ec512d7a
8 files changed
+359 -28

No files matched your search

+52 -12
View File
@@ -156,7 +156,7 @@ pub static COMMANDS: &[CommandSpec] = &[
.at("SKETCH", "CONSTRAINTS")
.icon("c_midpoint")
.enabled(in_sketch)
.params("point, line"),
.params("point, line | a, b in pick order: a point and a line (either way round), or two lines whose midpoints meet (the first stays, the second moves)"),
CommandSpec::new("sketch.constraint.concentric", "Concentric", c_concentric)
.at("SKETCH", "CONSTRAINTS")
.icon("c_concentric")
@@ -1637,6 +1637,15 @@ pub(super) fn residual_of(sk: &Sketch, id: &str) -> Option<f64> {
sk.constraints.iter().position(|c| c.id == id).and_then(|ci| solidcraft_sketch::constraint_residual(sk, ci))
}
/// The point already tied to the middle of line `l`, including one created by drawing.
/// Coincident coordinates alone are not enough: the Midpoint relationship must exist.
fn existing_midpoint(sk: &Sketch, l: usize) -> Option<usize> {
sk.constraints.iter().find_map(|c| match c.kind {
ConstraintKind::Midpoint { p, l: line } if line == l && !c.driven => Some(p),
_ => None,
})
}
/// Temporary pick intent. Saved sketches use ordinary points and constraints only.
#[derive(Clone, Copy, PartialEq, Eq)]
enum AlignmentTarget {
@@ -1645,19 +1654,13 @@ enum AlignmentTarget {
}
impl AlignmentTarget {
fn materialize(self, sk: &mut Sketch) -> Result<usize> {
fn materialize(self, sk: &mut Sketch, cmd: &str) -> Result<usize> {
match self {
Self::Point(p) => Ok(p),
Self::Midpoint(l) => {
// Reuse an existing associative midpoint, including one created by drawing.
// Coincident coordinates alone are insufficient: its relationship must exist.
if let Some(p) = sk.constraints.iter().find_map(|c| match c.kind {
ConstraintKind::Midpoint { p, l: line } if line == l && !c.driven => Some(p),
_ => None,
}) {
if let Some(p) = existing_midpoint(sk, l) {
return Ok(p);
}
let cmd = "sketch.constraint.horizontal_vertical";
let (a, b) = line_pts(sk, l).ok_or_else(|| bad(cmd, "a midpoint reference needs a line"))?;
let p = sk.add_point((a + b) * 0.5, None)?;
add_c(sk, ConstraintKind::Midpoint { p, l })?;
@@ -1693,8 +1696,8 @@ fn c_horizontal_vertical(s: &mut Session, p: &Value) -> Result<Value> {
if a == b {
return Err(bad(cmd, "alignment needs two distinct point references"));
}
let a = a.materialize(sk)?;
let b = b.materialize(sk)?;
let a = a.materialize(sk, cmd)?;
let b = b.materialize(sk, cmd)?;
if a == b {
return Err(bad(cmd, "alignment needs two distinct points"));
}
@@ -1826,9 +1829,46 @@ fn c_collinear(s: &mut Session, p: &Value) -> Result<Value> {
fn c_midpoint(s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "sketch.constraint.midpoint";
constrain(s, p, cmd, |sk| {
Ok(ConstraintKind::Midpoint { p: point_ref(sk, p.get("point"), cmd, "point")?, l: curve_ref(sk, p.get("line"), cmd, "line")? })
if p.get("a").is_none() && p.get("b").is_none() {
return Ok(ConstraintKind::Midpoint { p: point_ref(sk, p.get("point"), cmd, "point")?, l: curve_ref(sk, p.get("line"), cmd, "line")? });
}
// `a` and `b` in pick order: a point and a line either way round, or two lines.
let entity = |k: &str| -> Result<Ent> {
let r = p.get(k).and_then(Value::as_str).ok_or_else(|| bad(cmd, format!("`{k}` must be a point or line id")))?;
match sk.resolve_point(r) {
Some(i) => Ok(Ent::Point(i)),
None => sk.curve_index(r).map(Ent::Curve).ok_or_else(|| bad(cmd, format!("unknown sketch point or curve `{r}`"))),
}
};
let is_line = |sk: &Sketch, c: usize| matches!(sk.curves.get(c).map(|c| &c.kind), Some(CurveKind::Line { .. }));
match (entity("a")?, entity("b")?) {
(Ent::Point(q), Ent::Curve(l)) | (Ent::Curve(l), Ent::Point(q)) if is_line(sk, l) => Ok(ConstraintKind::Midpoint { p: q, l }),
// Two lines: their midpoints meet. One point sits at the middle of both, reusing
// a midpoint either line already has, so nothing new is saved in the design.
(Ent::Curve(a), Ent::Curve(b)) if is_line(sk, a) && is_line(sk, b) => {
if a == b {
return Err(bad(cmd, "pick two different lines"));
}
let (q, l) = match (existing_midpoint(sk, a), existing_midpoint(sk, b)) {
(Some(q), _) => (q, b),
(None, Some(q)) => (q, a),
(None, None) => (AlignmentTarget::Midpoint(a).materialize(sk, cmd)?, b),
};
if existing_midpoint_of(sk, q, l) {
return Err(bad(cmd, "these lines already share their midpoint"));
}
Ok(ConstraintKind::Midpoint { p: q, l })
}
_ => Err(bad(cmd, "MidPoint needs a point and a line, or two lines")),
}
})
}
/// Point `q` is already tied to the middle of line `l`.
fn existing_midpoint_of(sk: &Sketch, q: usize, l: usize) -> bool {
sk.constraints.iter().any(|c| matches!(c.kind, ConstraintKind::Midpoint { p, l: line } if p == q && line == l) && !c.driven)
}
/// The centre of a symmetry about a point (#1075): `point`, or `line` naming a point rather than
/// a curve or a sketch axis (the origin picked as the third entity).
fn symmetry_center(sk: &Sketch, p: &Value, cmd: &str) -> Result<Option<usize>> {
@@ -632,3 +632,106 @@ fn midpoint_alignment_remaps_after_unrelated_geometry_is_deleted() {
run(&mut s, "sketch.delete", json!({"entities":[result["created"]["points"][0]]}));
assert!(sketch(&s).constraints.is_empty());
}
fn line_ends(sk: &solidcraft_sketch::Sketch, id: &str) -> (Vec2, Vec2) {
let solidcraft_sketch::CurveKind::Line { a, b } = sk.curves[sk.curve_index(id).unwrap()].kind else { panic!("expected line") };
(sk.point(a).unwrap(), sk.point(b).unwrap())
}
#[test]
fn midpoint_of_two_lines_centres_the_second_on_the_first() {
use solidcraft_sketch::ConstraintKind;
for reverse in [false, true] {
let mut s = new_sketch();
run(&mut s, "sketch.line", json!({"points":[[0,0],[60,0]],"infer":false,"connect":false}));
run(&mut s, "sketch.line", json!({"points":[[5,-10],[25,-10]],"infer":false,"connect":false}));
let (first, second) = if reverse { ("l2", "l1") } else { ("l1", "l2") };
let stays = line_ends(&sketch(&s), first);
let length = {
let (a, b) = line_ends(&sketch(&s), second);
a.dist(b)
};
let before = s.doc.to_json();
let undo = s.undo.len();
let result = run(&mut s, "sketch.constraint.midpoint", json!({"a":first,"b":second}));
assert_eq!(result["created"]["points"].as_array().unwrap().len(), 1);
assert_eq!(result["created"]["constraints"].as_array().unwrap().len(), 2);
assert_eq!(s.undo.len(), undo + 1);
let sk = sketch(&s);
assert_eq!(line_ends(&sk, first), stays, "the first pick stays put");
let (a, b) = line_ends(&sk, second);
assert!((a.dist(b) - length).abs() < 1e-6, "the second keeps its length");
assert!(line_midpoint(&sk, first).dist(line_midpoint(&sk, second)) < 1e-6);
assert_eq!(sk.constraints.iter().filter(|c| matches!(c.kind, ConstraintKind::Midpoint { .. })).count(), 2);
// Saved as ordinary points and constraints: it reopens and keeps holding.
let after = s.doc.to_json();
run(&mut s, "edit.undo", json!({}));
assert_eq!(s.doc.to_json(), before);
run(&mut s, "edit.redo", json!({}));
assert_eq!(s.doc.to_json(), after);
let mut reopened = Session::new(solidcraft_doc::Document::from_json(&after).unwrap());
reopened.active_sketch = s.active_sketch;
run(&mut reopened, "sketch.move_point", json!({"point":"l1.end","to":[80,15]}));
let sk = sketch(&reopened);
assert!(line_midpoint(&sk, "l1").dist(line_midpoint(&sk, "l2")) < 1e-6);
}
}
#[test]
fn midpoint_takes_a_point_and_a_line_in_either_pick_order() {
for (a, b) in [("p", "l1"), ("l1", "p")] {
let mut s = new_sketch();
run(&mut s, "sketch.line", json!({"points":[[0,0],[40,0]],"infer":false,"connect":false}));
run(&mut s, "sketch.point", json!({"point":[7,9],"id":"p"}));
run(&mut s, "sketch.constraint.midpoint", json!({"a":a,"b":b}));
let sk = sketch(&s);
let p = sk.point(sk.resolve_point("p").unwrap()).unwrap();
assert!(p.dist(line_midpoint(&sk, "l1")) < 1e-6, "{a} then {b}");
}
}
#[test]
fn midpoint_of_two_lines_reuses_an_existing_midpoint() {
use solidcraft_sketch::ConstraintKind;
let mut s = new_sketch();
run(&mut s, "sketch.line", json!({"points":[[0,0],[60,0]],"infer":false,"connect":false}));
run(&mut s, "sketch.line", json!({"points":[[5,-10],[25,-10]],"infer":false,"connect":false}));
// l3 starts at the midpoint of l2: that point is reused, not duplicated.
run(&mut s, "sketch.line", json!({"points":["mid:l2",[15,-30]],"infer":false,"connect":false}));
let count = sketch(&s).points.len();
let result = run(&mut s, "sketch.constraint.midpoint", json!({"a":"l1","b":"l2"}));
assert!(result["created"]["points"].as_array().unwrap().is_empty());
let sk = sketch(&s);
assert_eq!(sk.points.len(), count);
assert_eq!(sk.constraints.iter().filter(|c| matches!(c.kind, ConstraintKind::Midpoint { .. })).count(), 2);
assert!(line_midpoint(&sk, "l1").dist(line_midpoint(&sk, "l2")) < 1e-6);
// Applying it again finds nothing to add.
let before = s.doc.to_json();
assert!(s.execute("sketch.constraint.midpoint", &json!({"a":"l2","b":"l1"})).is_err());
assert_eq!(s.doc.to_json(), before);
}
#[test]
fn midpoint_rejects_wrong_picks_without_changing_the_sketch() {
let mut s = new_sketch();
run(&mut s, "sketch.line", json!({"points":[[0,0],[60,0]],"infer":false,"connect":false}));
run(&mut s, "sketch.circle.center", json!({"center":[40,50],"radius":3}));
run(&mut s, "sketch.point", json!({"point":[7,9],"id":"p"}));
for params in [
json!({"a":"l1","b":"l1"}),
json!({"a":"l1","b":"c1"}),
json!({"a":"c1","b":"l1"}),
json!({"a":"p","b":"origin"}),
json!({"a":"p","b":"c1"}),
json!({"a":"l1","b":"missing"}),
json!({"a":"l1"}),
json!({"a":12,"b":"l1"}),
] {
let before = s.doc.to_json();
let undo = s.undo.len();
assert!(s.execute("sketch.constraint.midpoint", &params).is_err(), "{params}");
assert_eq!(s.doc.to_json(), before, "{params}");
assert_eq!(s.undo.len(), undo, "{params}");
}
}
+2 -1
View File
@@ -926,7 +926,8 @@ fn sketch_entity_items(app: &SolveApp) -> Vec<Item> {
c.push(cmd(app, "sketch.constraint.parallel", "Parallel").with(ab.clone()));
c.push(cmd(app, "sketch.constraint.perpendicular", "Perpendicular").with(ab.clone()));
c.push(cmd(app, "sketch.constraint.collinear", "Collinear").with(ab.clone()));
c.push(cmd(app, "sketch.constraint.equal", "Equal").with(ab));
c.push(cmd(app, "sketch.constraint.equal", "Equal").with(ab.clone()));
c.push(cmd(app, "sketch.constraint.midpoint", "MidPoint").with(ab));
}
if r == 2 && n == 2 {
let ab = json!({ "a": rounds[0], "b": rounds[1] });
+15 -2
View File
@@ -20,8 +20,21 @@ pub struct Pending {
/// What Delete acts on now: the selection (bodies not locked), plus the components picked in
/// the browser (their occurrences).
pub fn selection_params(app: &SolveApp) -> Value {
let items: Vec<&solidcraft_engine::Sel> =
app.session.selection.iter().filter(|s| !matches!(s, solidcraft_engine::Sel::Body { name } if app.ui.locked_bodies.contains(name))).collect();
use solidcraft_engine::Sel;
let mut items: Vec<Sel> = Vec::new();
for s in app.session.selection.iter().filter(|s| !matches!(s, Sel::Body { name } if app.ui.locked_bodies.contains(name))) {
// A MidPoint glyph shared by lines whose midpoints meet removes every constraint it
// shows, and the point they shared when nothing else holds it.
let group = match s {
Sel::SketchConstraint { id } => crate::sketch_tools::active_glyph_deletion(app, id),
_ => vec![s.clone()],
};
for g in group {
if !items.contains(&g) {
items.push(g);
}
}
}
let occurrences: Vec<u64> = app.tree.picked_components.iter().filter_map(|c| app.session.doc.occurrence_of(*c).map(|o| o.id)).collect();
json!({ "items": items, "occurrences": occurrences, "canvases": app.tree.picked_canvases, "joints": app.tree.picked_joints })
}
+79 -10
View File
@@ -467,6 +467,50 @@ pub fn refine_snap(
})
}
/// The constraints one glyph stands for. A point that is the midpoint of several lines (their
/// midpoints meet) shows a single MidPoint glyph, the first constraint's, for all of them;
/// any other constraint stands for itself.
pub fn glyph_group(sk: &solidcraft_engine::sketch::Sketch, id: &str) -> Vec<String> {
use solidcraft_engine::sketch::ConstraintKind::Midpoint;
match sk.constraints.iter().find(|c| c.id == id).map(|c| (c.kind.clone(), c.driven)) {
Some((Midpoint { p, .. }, false)) => {
sk.constraints.iter().filter(|c| !c.driven && matches!(c.kind, Midpoint { p: q, .. } if q == p)).map(|c| c.id.clone()).collect()
}
_ => vec![id.to_string()],
}
}
/// What deleting glyph `id` removes: the constraints it stands for, and, for one MidPoint glyph
/// shared by several lines, their common point once nothing else holds it (it only tied the
/// midpoints together, so it would be left floating).
pub fn glyph_deletion(sk: &solidcraft_engine::sketch::Sketch, id: &str) -> Vec<solidcraft_engine::Sel> {
use solidcraft_engine::{Sel, sketch::ConstraintKind::Midpoint};
let group = glyph_group(sk, id);
let shared = match sk.constraints.iter().find(|c| c.id == id).map(|c| &c.kind) {
Some(Midpoint { p, .. }) if group.len() > 1 => Some(*p),
_ => None,
};
let orphan = shared.filter(|&p| {
!sk.curves.iter().any(|c| c.kind.uses(p))
&& !sk.constraints.iter().any(|c| !group.contains(&c.id) && c.kind.indices().0.contains(&p))
&& sk.points.get(p).is_some_and(|q| !q.fixed && q.link.is_none() && q.exprs.is_none())
});
let mut out: Vec<Sel> = group.into_iter().map(|id| Sel::SketchConstraint { id }).collect();
if let Some(q) = orphan.and_then(|p| sk.points.get(p)) {
out.push(Sel::SketchPoint { id: q.id.clone() });
}
out
}
/// [`glyph_deletion`] in the active sketch.
pub fn active_glyph_deletion(app: &SolveApp, id: &str) -> Vec<solidcraft_engine::Sel> {
let st = app.session.world_state();
match active_sketch(app).and_then(|s| st.sketch(s)) {
Some(ss) => glyph_deletion(&ss.sketch, id),
None => vec![solidcraft_engine::Sel::SketchConstraint { id: id.to_string() }],
}
}
/// The constraint glyph under a screen position (its constraint id).
pub fn glyph_at(pos: Pos2) -> Option<String> {
GLYPHS.with(|g| g.borrow().iter().find(|(_, c)| c.distance(pos) <= GLYPH * 0.6).map(|(id, _)| id.clone()))
@@ -494,7 +538,14 @@ pub fn click_glyph(app: &mut SolveApp, _proj: &Proj, pos: Pos2) -> bool {
/// Delete the selected constraint glyph (true when one was selected).
pub fn delete_glyph(app: &mut SolveApp) -> bool {
let Some(id) = PICKED.with(|p| p.borrow_mut().take()) else { return false };
let _ = app.run("sketch.delete", json!({"entities": [id]}));
let entities: Vec<String> = active_glyph_deletion(app, &id)
.into_iter()
.filter_map(|s| match s {
solidcraft_engine::Sel::SketchConstraint { id } | solidcraft_engine::Sel::SketchPoint { id } => Some(id),
_ => None,
})
.collect();
let _ = app.run("sketch.delete", json!({ "entities": entities }));
true
}
@@ -1170,10 +1221,20 @@ fn glyphs(app: &SolveApp, painter: &egui::Painter, proj: &Proj, hover: Option<Po
dim_texts.iter().any(|d| d.intersects(r))
};
let mut placed: Vec<(String, Pos2, Pos2)> = Vec::new();
// The point of each MidPoint glyph drawn so far: lines whose midpoints meet share one glyph.
let mut midpoints: Vec<usize> = Vec::new();
for c in &ss.sketch.constraints {
if c.kind.is_dimension() {
continue;
}
if let solidcraft_engine::sketch::ConstraintKind::Midpoint { p, .. } = c.kind
&& !c.driven
{
if midpoints.contains(&p) {
continue;
}
midpoints.push(p);
}
if matches!(
c.kind,
solidcraft_engine::sketch::ConstraintKind::PatternPoint { .. } | solidcraft_engine::sketch::ConstraintKind::PatternRadius { .. }
@@ -1213,10 +1274,16 @@ fn glyphs(app: &SolveApp, painter: &egui::Painter, proj: &Proj, hover: Option<Po
}
let hovered = hover.and_then(|h| placed.iter().find(|(_, q, _)| q.distance(h) <= GLYPH * 0.6).map(|(id, _, _)| id.clone()));
// The hovered (or selected) constraint's entities lit up.
if let Some(id) = hovered.as_ref().or(picked.as_ref())
&& let Some(c) = ss.sketch.constraints.iter().find(|c| &c.id == id)
{
let (cs, ps) = constraint_entities(&c.kind);
if let Some(id) = hovered.as_ref().or(picked.as_ref()) {
let group = glyph_group(&ss.sketch, id);
let (cs, ps) = ss.sketch.constraints.iter().filter(|c| group.contains(&c.id)).map(|c| constraint_entities(&c.kind)).fold(
(Vec::new(), Vec::new()),
|(mut cs, mut ps), (c, p)| {
cs.extend(c);
ps.extend(p);
(cs, ps)
},
);
let mut display_budget = solidcraft_engine::render::SamplingBudget::new(32_768, 65_536);
for ci in cs {
crate::tools::paint_curve(&ss.sketch, ci, &ss.plane, painter, proj, Stroke::new(3.0, tk.accent.gamma_multiply(0.7)), &mut display_budget);
@@ -1230,11 +1297,12 @@ fn glyphs(app: &SolveApp, painter: &egui::Painter, proj: &Proj, hover: Option<Po
let mut drawn: Vec<(String, Pos2)> = Vec::new();
for (id, sp, base) in &placed {
let Some(c) = ss.sketch.constraints.iter().find(|c| &c.id == id) else { continue };
let failing = ss.report.failing.contains(id);
let group = glyph_group(&ss.sketch, id);
let failing = group.iter().any(|g| ss.report.failing.contains(g));
// Redundant (already implied by the others, but holding): dimmed, not an error.
let redundant = !failing && ss.report.redundant.contains(id);
let redundant = !failing && group.iter().all(|g| ss.report.redundant.contains(g));
let selected = picked.as_deref() == Some(id.as_str())
|| app.session.selection.iter().any(|s| matches!(s, solidcraft_engine::Sel::SketchConstraint { id: x } if x == id));
|| app.session.selection.iter().any(|s| matches!(s, solidcraft_engine::Sel::SketchConstraint { id: x } if group.contains(x)));
let lit = selected || hovered.as_deref() == Some(id.as_str());
let col = if failing {
tk.error
@@ -1276,10 +1344,11 @@ fn glyphs(app: &SolveApp, painter: &egui::Painter, proj: &Proj, hover: Option<Po
if let (Some(id), Some(h)) = (hovered, hover)
&& let Some(c) = ss.sketch.constraints.iter().find(|c| c.id == id)
{
let ids = glyph_group(&ss.sketch, &id).join(", ");
let label = if ss.report.redundant.contains(&id) {
format!("{} ({id}), redundant: already implied by other constraints", c.kind.name())
format!("{} ({ids}), redundant: already implied by other constraints", c.kind.name())
} else {
format!("{} ({id})", c.kind.name())
format!("{} ({ids})", c.kind.name())
};
let at = h + egui::vec2(12.0, 12.0);
let g = painter.layout_no_wrap(label, egui::FontId::proportional(crate::theme::Tokens::get().font_small), tk.text);
+4 -1
View File
@@ -150,6 +150,7 @@ pub fn hint(id: &str) -> String {
"sketch.dimension" => "Dimension: pick one or two entities and type the value (or click to place it first); Enter applies".into(),
"sketch.constraint.horizontal_vertical" => "Horizontal/Vertical: pick a line or two points; hold Shift to pick a line midpoint".into(),
"sketch.slot.center_to_center" | "sketch.slot.overall" => "Slot: click both ends, then the width".into(),
"sketch.constraint.midpoint" => "MidPoint: pick a point and a line, or two lines to centre the second on the first".into(),
_ if id.starts_with("sketch.constraint.") => "Constraint: pick the sketch entities".into(),
_ => crate::sketch_tools::hint(id).unwrap_or_else(|| "Click in the sketch".into()),
}
@@ -494,6 +495,7 @@ pub(crate) fn constraint_preselection(command: &str, selection: &[solidcraft_eng
"sketch.constraint.midpoint",
[SketchPoint { id: point }, SketchCurve { id: line }] | [SketchCurve { id: line }, SketchPoint { id: point }],
) => Some(json!({"point":point,"line":line})),
("sketch.constraint.midpoint", [SketchCurve { id: a }, SketchCurve { id: b }]) if a != b => Some(json!({"a":a,"b":b})),
("sketch.constraint.symmetry", [a, b, c]) => {
let mut points = Vec::new();
let mut lines = Vec::new();
@@ -567,7 +569,8 @@ fn run_pick(app: &mut SolveApp, t: &Tool) {
let params = match t.cmd {
"sketch.constraint.fix" => json!({"entity": k[0]}),
"sketch.constraint.coincident" => json!({"a": k[0], "b": k[1]}),
"sketch.constraint.midpoint" => json!({"point": k[0], "line": k[1]}),
// In pick order: a point and a line either way round, or two lines to centre.
"sketch.constraint.midpoint" => json!({"a": k[0], "b": k[1]}),
"sketch.constraint.symmetry" => json!({"a": k[0], "b": k[1], "line": k[2]}),
_ => json!({"a": k[0], "b": k[1]}),
};
@@ -1,5 +1,5 @@
use serde_json::json;
use solidcraft_engine::{Sel, sketch::ConstraintKind};
use solidcraft_engine::{Sel, geom::Vec2, sketch::ConstraintKind};
use solidcraft_ui_egui::scenario::Harness;
fn setup() -> Harness {
@@ -86,3 +86,103 @@ fn rejected_and_ambiguous_preselection_preserve_document_and_selection() {
assert_eq!(h.app.session.doc.to_json(), before);
}
}
// MidPoint centres one line on another when the tool picks two lines.
fn two_lines() -> Harness {
let mut h = Harness::new();
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
h.app.run("sketch.line", json!({"points":[[0,0],[60,0]],"infer":false,"connect":false})).unwrap();
h.app.run("sketch.line", json!({"points":[[5,-10],[25,-10]],"infer":false,"connect":false})).unwrap();
h.call("ui.view", json!({"view":"top"}));
h
}
fn line_ends(h: &Harness, id: &str) -> (Vec2, Vec2) {
let state = h.app.session.world_state();
let sk = &state.sketch(h.app.session.active_sketch.unwrap()).unwrap().sketch;
let p = |end: &str| sk.point(sk.resolve_point(&format!("{id}.{end}")).unwrap()).unwrap();
(p("start"), p("end"))
}
fn assert_centred(h: &Harness, undo: usize) {
assert!(!h.app.status.as_ref().is_some_and(|(_, _, error)| *error), "{:?}", h.app.status);
assert_eq!(h.app.session.undo.len(), undo + 1);
let (a, b) = line_ends(h, "l1");
assert_eq!((a, b), (Vec2::new(0.0, 0.0), Vec2::new(60.0, 0.0)), "the first line stays");
let (c, d) = line_ends(h, "l2");
assert!(((a + b) * 0.5).dist((c + d) * 0.5) < 1e-6);
assert!((c.dist(d) - 20.0).abs() < 1e-6);
}
#[test]
fn midpoint_tool_clicking_two_lines_centres_them() {
let mut h = two_lines();
let undo = h.app.session.undo.len();
h.step(&json!({"start":"sketch.constraint.midpoint"})).unwrap();
h.step(&json!({"click":{"sketch":[45,0]}})).unwrap();
h.step(&json!({"click":{"sketch":[10,-10]}})).unwrap();
assert_centred(&h, undo);
}
#[test]
fn midpoint_tool_takes_two_preselected_lines() {
let mut h = two_lines();
h.step(&json!({"click":{"sketch":[45,0]}})).unwrap();
h.step(&json!({"click":{"sketch":[10,-10]},"shift":true})).unwrap();
assert_eq!(h.app.session.selection.len(), 2);
let undo = h.app.session.undo.len();
h.step(&json!({"start":"sketch.constraint.midpoint"})).unwrap();
assert!(h.app.tool.is_none());
assert_centred(&h, undo);
}
fn midpoint_ids(h: &Harness) -> Vec<String> {
let state = h.app.session.world_state();
let sk = &state.sketch(h.app.session.active_sketch.unwrap()).unwrap().sketch;
sk.constraints.iter().filter(|c| matches!(c.kind, ConstraintKind::Midpoint { .. })).map(|c| c.id.clone()).collect()
}
fn point_count(h: &Harness) -> usize {
let state = h.app.session.world_state();
state.sketch(h.app.session.active_sketch.unwrap()).unwrap().sketch.points.len()
}
/// Centre l2 on l1 with the MidPoint tool, then click its glyph and press Delete.
fn centre_then_delete_glyph(h: &mut Harness) {
h.step(&json!({"start":"sketch.constraint.midpoint"})).unwrap();
h.step(&json!({"click":{"sketch":[45,0]}})).unwrap();
h.step(&json!({"click":{"sketch":[10,-10]}})).unwrap();
h.step(&json!({"key":"Escape"})).unwrap();
let ids = midpoint_ids(h);
assert!(ids.len() >= 2, "one point at the middle of both lines");
let glyphs: Vec<_> = solidcraft_ui_egui::sketch_tools::glyph_positions().into_iter().filter(|(id, _)| ids.contains(id)).collect();
assert_eq!(glyphs.len(), 1, "one MidPoint glyph for both lines: {glyphs:?}");
let at = glyphs[0].1;
h.step(&json!({"click":[at.x, at.y]})).unwrap();
h.step(&json!({"key":"Delete"})).unwrap();
for _ in 0..20 {
if midpoint_ids(h).is_empty() {
break;
}
h.frames(1);
}
assert!(midpoint_ids(h).is_empty(), "deleting the glyph removes both constraints: {:?}", midpoint_ids(h));
}
#[test]
fn centred_lines_show_one_midpoint_glyph_that_deletes_both_constraints_and_their_point() {
let mut h = two_lines();
let points = point_count(&h);
centre_then_delete_glyph(&mut h);
assert_eq!(point_count(&h), points, "the point that only tied the midpoints goes too");
}
#[test]
fn deleting_the_shared_midpoint_glyph_keeps_a_point_another_line_uses() {
let mut h = two_lines();
// l3 starts at the midpoint of l2: centring reuses that point, and deleting keeps it.
h.app.run("sketch.line", json!({"points":["mid:l2",[15,-30]],"infer":false,"connect":false})).unwrap();
let points = point_count(&h);
centre_then_delete_glyph(&mut h);
assert_eq!(point_count(&h), points);
}
+3 -1
View File
@@ -240,7 +240,9 @@ You can also start the constraint first and then pick its curves. An incomplete
selection leaves the tool ready for ordinary picking.
Coincident accepts an exact selection of two points or a point and a curve. Midpoint
accepts one point and one line, in either selection order. Symmetry accepts two distinct
accepts one point and one line, in either selection order, or two lines: the second line
moves (keeping its length) until its midpoint sits on the first line's midpoint,
and stays centred there as either line changes. Symmetry accepts two distinct
points and one symmetry line, regardless of where the line occurs in the selection.
Successful constraints clear the selection; rejected constraints preserve it.