Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Sketch: a fillet stays the arc of its corner when the corner mirrors or a line is dragged through it (#5677)

Kai Evans41a938e73139
diff --git a/crates/engine/src/cmd/sketch_drag.rs b/crates/engine/src/cmd/sketch_drag.rs
index c1c8c851d9..e020b6fc68 100644
--- a/crates/engine/src/cmd/sketch_drag.rs
+++ b/crates/engine/src/cmd/sketch_drag.rs
@@ -294,7 +294,7 @@ pub(super) fn drag_entity(
let valid = |before: &Sketch, after: &Sketch| {
let mut geometry = Geometry::default();
geometry.take(before);
- !geometry.sweep_wrapped(after)
+ !geometry.sweep_wrapped(after) && solidcraft_sketch::fillets_kept(before, after)
};
let followed = match (e, line_grab) {
(Ent::Point(q), _) => solidcraft_sketch::move_point_towards(sk, q, to, max_step, frame.as_mut(), valid),
diff --git a/crates/engine/src/cmd/sketch_modify_tests.rs b/crates/engine/src/cmd/sketch_modify_tests.rs
index 0936f07880..acf99057f0 100644
--- a/crates/engine/src/cmd/sketch_modify_tests.rs
+++ b/crates/engine/src/cmd/sketch_modify_tests.rs
@@ -2492,3 +2492,50 @@ fn freeform_chain_offsets_take_the_straight_pieces_of_the_chain_along() {
assert!(!curves.is_empty(), "{out}");
certified(&s, &curves);
}
+
+/// The arc's counter-clockwise sweep from its stored start to its end, degrees, from `sketch.inspect`.
+fn arc_sweep_deg(si: &Value, id: &str) -> f64 {
+ let c = si["curves"].as_array().unwrap().iter().find(|c| c["id"] == id).unwrap();
+ let at = |k: &str| Vec2::new(c[k][0].as_f64().unwrap(), c[k][1].as_f64().unwrap());
+ let (centre, a, b) = (at("center_at"), at("start_at"), at("end_at"));
+ ((b - centre).angle() - (a - centre).angle()).rem_euclid(std::f64::consts::TAU).to_degrees()
+}
+
+#[test]
+fn a_fillet_stays_a_quarter_arc_when_its_corner_is_pinned_or_dragged_to_the_other_side() {
+ let mut s = new_sketch();
+ run(&mut s, "sketch.line", json!({"points": [[10, 10], [40, 10], [40, 30]]}));
+ let f = run(&mut s, "sketch.fillet", json!({"point": "l1.end", "radius": 5}));
+ let arc = ids(&f["curves"])[0].clone();
+ run(&mut s, "sketch.constraint.horizontal_vertical", json!({"line": "l1"}));
+ run(&mut s, "sketch.constraint.horizontal_vertical", json!({"line": "l2"}));
+ let curve = |si: &Value, id: &str| si["curves"].as_array().unwrap().iter().find(|c| c["id"] == id).unwrap().clone();
+ // Pin the vertical line's far end below the horizontal line: the corner mirrors, and the
+ // fillet is the quarter arc inside the mirrored corner (its lines leave it, none cuts
+ // through it).
+ run(&mut s, "sketch.point", json!({"point": [40, -20], "id": "q"}));
+ run(&mut s, "sketch.constraint.fix", json!({"entity": "q"}));
+ run(&mut s, "sketch.constraint.coincident", json!({"a": "l2.end", "b": "q"}));
+ let si = run(&mut s, "sketch.inspect", json!({}));
+ assert!((arc_sweep_deg(&si, &arc) - 90.0).abs() < 1e-6, "{}", arc_sweep_deg(&si, &arc));
+ assert_eq!(curve(&si, &arc)["center_at"], json!([35.0, 5.0]), "{}", curve(&si, &arc));
+ assert_eq!(curve(&si, "l2")["start_at"], json!([40.0, 5.0]), "{}", curve(&si, "l2"));
+ // Dragging the horizontal line's far end through the corner would push the line through its
+ // fillet: the drag stops at the arc.
+ let d = run(&mut s, "sketch.drag", json!({"entity": "l1.start", "from": [10, 10], "to": [70, 10]}));
+ assert!(d["reached"].as_f64().unwrap() < 0.5, "{d}");
+ let si = run(&mut s, "sketch.inspect", json!({}));
+ let l1 = curve(&si, "l1");
+ assert!(l1["start_at"][0].as_f64().unwrap() <= 35.0 + 1e-6, "{l1}");
+ assert!((arc_sweep_deg(&si, &arc) - 90.0).abs() < 1e-6, "{}", arc_sweep_deg(&si, &arc));
+ assert_eq!(curve(&si, &arc)["center_at"], json!([35.0, 5.0]), "{}", curve(&si, &arc));
+ // Pinned on the far side instead, the corner mirrors again and the fillet follows.
+ run(&mut s, "sketch.point", json!({"point": [70, 10], "id": "r"}));
+ run(&mut s, "sketch.constraint.fix", json!({"entity": "r"}));
+ run(&mut s, "sketch.constraint.coincident", json!({"a": "l1.start", "b": "r"}));
+ let si = run(&mut s, "sketch.inspect", json!({}));
+ assert!((arc_sweep_deg(&si, &arc) - 90.0).abs() < 1e-6, "{}", arc_sweep_deg(&si, &arc));
+ assert_eq!(curve(&si, &arc)["center_at"], json!([45.0, 5.0]), "{}", curve(&si, &arc));
+ assert_eq!(curve(&si, "l1")["end_at"], json!([45.0, 10.0]), "{}", curve(&si, "l1"));
+ assert_eq!(curve(&si, "l2")["start_at"], json!([40.0, 5.0]), "{}", curve(&si, "l2"));
+}
diff --git a/crates/sketch/src/lib.rs b/crates/sketch/src/lib.rs
index 6040ef6ae9..b0b986c2d6 100644
--- a/crates/sketch/src/lib.rs
+++ b/crates/sketch/src/lib.rs
@@ -66,9 +66,9 @@ pub use profiles::{
pub use shape::{Shape, intersections, intersections_within, nearest_crossing, nearest_curve_intersection};
pub use solver::solve_after_edit_with_analysis;
pub use solver::{
- Analysis, CONSISTENT, DrivingValues, Hold, MAX_COMPONENT_VARS, SolveReport, SolveStatus, constraint_residual, determined_by, flips_from_stored,
- measure_dimension, move_line_towards, move_point_towards, solve, solve_after_edit, solve_after_link_move, solve_after_value_edit, solve_holding,
- solve_with,
+ Analysis, CONSISTENT, DrivingValues, Hold, MAX_COMPONENT_VARS, SolveReport, SolveStatus, constraint_residual, determined_by, fillets_kept,
+ flips_from_stored, measure_dimension, move_line_towards, move_point_towards, solve, solve_after_edit, solve_after_link_move,
+ solve_after_value_edit, solve_holding, solve_with,
};
pub use text::{MAX_TEXT_CHARS, TextAlign, TextMetrics, TextStyle, text_geometry, text_geometry_in, text_geometry_styled};
pub use thin::{MAX_THIN_SEGMENTS, thin_wall_regions};
diff --git a/crates/sketch/src/solver.rs b/crates/sketch/src/solver.rs
index 6ab81556b5..2c4d371e84 100644
--- a/crates/sketch/src/solver.rs
+++ b/crates/sketch/src/solver.rs
@@ -1857,7 +1857,7 @@ fn solve_from(
old_values: Option<&[Option<f64>]>,
budget: &mut Budget,
) -> SolveReport {
- solve_inner(sk, hold, reference, analysis, old_values, budget)
+ solve_sensed(sk, hold, reference, analysis, old_values, budget)
}
/// In this crate's tests every solve is repeated without the constructive seed: the seed only
@@ -1877,11 +1877,11 @@ fn solve_from(
) -> SolveReport {
use crate::construct::switch;
if !(switch::seed_on() && switch::differential_on()) {
- return solve_inner(sk, hold, reference, analysis, old_values, budget);
+ return solve_sensed(sk, hold, reference, analysis, old_values, budget);
}
let mut plain = sk.clone();
- let without = switch::without_seed(|| solve_inner(&mut plain, hold, reference, analysis, old_values, &mut Budget::full()));
- let with = solve_inner(sk, hold, reference, analysis, old_values, budget);
+ let without = switch::without_seed(|| solve_sensed(&mut plain, hold, reference, analysis, old_values, &mut Budget::full()));
+ let with = solve_sensed(sk, hold, reference, analysis, old_values, budget);
assert_same_outcome(&with, &without);
with
}
@@ -2267,6 +2267,252 @@ fn continue_values(
(spent, t >= SUBSTEPS)
}
+/// A line tangent to an arc at the arc's end `p` continues the arc's travel there, as a
+/// fillet's line leaves its arc: `Some(1.0)`; turned back onto the arc, `Some(-1.0)`; `None`
+/// when too short to tell. The travel runs counter-clockwise from the arc's `a` to its `b`.
+fn tangent_sense(sk: &Sketch, pos: &dyn Fn(usize) -> Vec2, arc: usize, line: usize, p: usize) -> Option<f64> {
+ let CurveKind::Arc { c, a, b } = sk.curves.get(arc)?.kind else { return None };
+ let CurveKind::Line { a: la, b: lb } = sk.curves.get(line)?.kind else { return None };
+ let far = if la == p {
+ lb
+ } else if lb == p {
+ la
+ } else {
+ return None;
+ };
+ let outward = if p == b {
+ 1.0
+ } else if p == a {
+ -1.0
+ } else {
+ return None;
+ };
+ let along = (pos(p) - pos(c)).perp();
+ let leaving = pos(far) - pos(p);
+ let d = along.dot(leaving) * outward;
+ (d.abs() > 1e-9 * along.len() * leaving.len()).then(|| d.signum())
+}
+
+/// An arc with lines tangent at its ends, as a solve started or left it: its sweep (counter-
+/// clockwise from `a` to `b`) and each line's sense.
+struct ArcSense {
+ arc: usize,
+ sweep: f64,
+ /// (line, touch point, tangent constraint index, sense)
+ lines: Vec<(usize, usize, usize, Option<f64>)>,
+}
+
+/// The arcs a solve may turn over (no arc sweep dimension of their own, not fixed, not
+/// linked) with the lines tangent at their ends, read at `pos`.
+fn arc_senses(sk: &Sketch, pos: &dyn Fn(usize) -> Vec2) -> Vec<ArcSense> {
+ let swept: std::collections::BTreeSet<usize> = sk
+ .constraints
+ .iter()
+ .filter(|c| !c.driven)
+ .filter_map(|c| match c.kind {
+ ConstraintKind::ArcSweep { c, .. } => Some(c),
+ _ => None,
+ })
+ .collect();
+ let arc =
+ |i: usize| sk.curves.get(i).is_some_and(|c| matches!(c.kind, CurveKind::Arc { .. }) && !c.fixed && c.link.is_none() && !swept.contains(&i));
+ let line = |i: usize| sk.curves.get(i).is_some_and(|c| matches!(c.kind, CurveKind::Line { .. }));
+ let on_curve = points_on_curves(sk);
+ let mut out: Vec<ArcSense> = Vec::new();
+ for (ci, c) in sk.constraints.iter().enumerate().filter(|(_, c)| !c.driven) {
+ let ConstraintKind::Tangent { a, b } = c.kind else { continue };
+ let Some(p) = touch_point(sk, &c.kind, &on_curve) else { continue };
+ let (arc, line) = if arc(a) && line(b) {
+ (a, b)
+ } else if arc(b) && line(a) {
+ (b, a)
+ } else {
+ continue;
+ };
+ let sense = tangent_sense(sk, pos, arc, line, p);
+ let entry = match out.iter().position(|e| e.arc == arc) {
+ Some(k) => k,
+ None => {
+ let CurveKind::Arc { c, a, b } = sk.curves[arc].kind else { continue };
+ let sweep = ((pos(b) - pos(c)).angle() - (pos(a) - pos(c)).angle()).rem_euclid(std::f64::consts::TAU);
+ out.push(ArcSense { arc, sweep, lines: Vec::new() });
+ out.len() - 1
+ }
+ };
+ if let Some(e) = out.get_mut(entry) {
+ e.lines.push((line, p, ci, sense));
+ }
+ }
+ out
+}
+
+/// What a solve did to a filleted arc, against how it started.
+enum Turn {
+ /// Still the same arc between its lines.
+ Kept,
+ /// It ran round the other way with its lines following: the corner it rounds mirrored. Its
+ /// ends swapped, it is that corner's short arc again.
+ Swap,
+ /// One of its two lines cut back through it: the corner mirrored, the arc did not. The
+ /// arc reflected across the line that stayed (`across`) with that line's touch point
+ /// (`p`) is the start to solve again from.
+ Mirror { p: usize, across: usize },
+ /// It looped the other way round, or a line folded back onto it: no arc of a corner.
+ Over(Vec<usize>),
+}
+
+fn turn(before: &ArcSense, after: &ArcSense) -> Turn {
+ let jump = (after.sweep - before.sweep).abs() > std::f64::consts::PI;
+ // A line whose sense was clear and no longer is collapsed onto the arc: turned too.
+ let lines: Vec<(&(usize, usize, usize, Option<f64>), bool)> = before
+ .lines
+ .iter()
+ .filter_map(|l @ (line, p, _, was)| {
+ let was = (*was)?;
+ let is = after.lines.iter().find(|(m, q, ..)| (m, q) == (line, p)).map(|(.., is)| *is)?;
+ Some((l, is != Some(was)))
+ })
+ .collect();
+ let (all, any) = (lines.iter().all(|(_, f)| *f), lines.iter().any(|(_, f)| *f));
+ match (jump, any, all) {
+ (false, false, _) => Turn::Kept,
+ (true, _, true) => Turn::Swap,
+ (false, true, false) if lines.len() == 2 => {
+ let Some(turned) = lines.iter().find(|(_, f)| *f).map(|(l, _)| l) else { return Turn::Kept };
+ let Some(stayed) = lines.iter().find(|(_, f)| !*f).map(|(l, _)| l) else { return Turn::Kept };
+ Turn::Mirror { p: turned.1, across: stayed.0 }
+ }
+ _ => Turn::Over(lines.iter().map(|(l, _)| l.2).collect()),
+ }
+}
+
+/// The arc's ends swapped: the same circle run the other way round from the same points, so the
+/// stored counter-clockwise arc is the one on the other side of its chord. `reversed` keeps the
+/// as-drawn start and end.
+fn swap_arc_ends(sk: &mut Sketch, arc: usize) {
+ if let Some(curve) = sk.curves.get_mut(arc)
+ && let CurveKind::Arc { a, b, .. } = &mut curve.kind
+ {
+ std::mem::swap(a, b);
+ curve.reversed = !curve.reversed;
+ }
+}
+
+/// The arc's centre and the touch point `p` reflected across line `across`, and its ends
+/// swapped: the corner's fillet on the mirrored side.
+fn mirror_arc(sk: &mut Sketch, arc: usize, p: usize, across: usize) {
+ let Some(CurveKind::Arc { c, .. }) = sk.curves.get(arc).map(|c| c.kind.clone()) else { return };
+ let Some(CurveKind::Line { a: la, b: lb }) = sk.curves.get(across).map(|c| c.kind.clone()) else { return };
+ let (Some(pa), Some(pb)) = (sk.point(la), sk.point(lb)) else { return };
+ let Some(d) = (pb - pa).normalized() else { return };
+ let reflect = |q: Vec2| pa + d * (q - pa).dot(d) * 2.0 - (q - pa);
+ for i in [c, p] {
+ if let Some(q) = sk.point(i)
+ && let Some(point) = sk.points.get_mut(i)
+ && !point.fixed
+ {
+ point.pos = reflect(q);
+ }
+ }
+ swap_arc_ends(sk, arc);
+}
+
+/// Every fillet of `before` is still an arc of its corner in `after` (the same sketch moved: its
+/// lines keep their sense at the arc and the arc its side of its chord): what a feasible move
+/// of the cursor may keep. See [`solve_sensed`].
+pub fn fillets_kept(before: &Sketch, after: &Sketch) -> bool {
+ let was = arc_senses(before, &|i| before.points.get(i).map(|p| p.pos).unwrap_or_default());
+ let now = arc_senses(after, &|i| after.points.get(i).map(|p| p.pos).unwrap_or_default());
+ was.iter().all(|b| now.iter().find(|a| a.arc == b.arc).is_none_or(|a| matches!(turn(b, a), Turn::Kept)))
+}
+
+/// The turns of every filleted arc from `before` to where `sk` is now, applying the swaps.
+fn settle(sk: &mut Sketch, before: &[ArcSense]) -> Vec<(usize, Turn)> {
+ let after = arc_senses(sk, &|i| sk.points.get(i).map(|p| p.pos).unwrap_or_default());
+ let turns: Vec<(usize, Turn)> = before
+ .iter()
+ .filter_map(|b| after.iter().find(|a| a.arc == b.arc).map(|a| (b.arc, turn(b, a))))
+ .filter(|(_, t)| !matches!(t, Turn::Kept))
+ .collect();
+ for (arc, t) in &turns {
+ if matches!(t, Turn::Swap) {
+ swap_arc_ends(sk, *arc);
+ }
+ }
+ turns
+}
+
+/// [`solve_inner`], keeping each fillet an arc of its corner: a line tangent at an arc's end
+/// keeps its sense there (it leaves the arc, as it did), and the arc stays on its side of its
+/// chord. Positions are compared with `reference` (an interactive move's start) or the
+/// stored ones. A corner that mirrored gets its arc on the mirrored side (its ends swapped, or
+/// the arc reflected across the line that stayed and solved again). A solve that would loop
+/// the arc round the other way, or fold a line back onto it, is refused as a fold is: the
+/// geometry stays and the tangent constraints are reported as `folded`.
+fn solve_sensed(
+ sk: &mut Sketch,
+ hold: &Hold,
+ reference: Option<&[Vec2]>,
+ analysis: Analysis,
+ old_values: Option<&[Option<f64>]>,
+ budget: &mut Budget,
+) -> SolveReport {
+ let stored: Vec<Vec2> = sk.points.iter().map(|p| p.pos).collect();
+ let pos = |i: usize| reference.and_then(|r| r.get(i)).or_else(|| stored.get(i)).copied().unwrap_or_default();
+ let before = arc_senses(sk, &pos);
+ if before.is_empty() {
+ return solve_inner(sk, hold, reference, analysis, old_values, budget);
+ }
+ let start = sk.clone();
+ let mut report = solve_inner(sk, hold, reference, analysis, old_values, budget);
+ if !report.ok() {
+ return report;
+ }
+ let mut turns = settle(sk, &before);
+ let mirrors: Vec<(usize, usize, usize)> =
+ turns.iter().filter_map(|(arc, t)| if let Turn::Mirror { p, across } = t { Some((*arc, *p, *across)) } else { None }).collect();
+ if !mirrors.is_empty() {
+ let solved = sk.clone();
+ for (arc, p, across) in &mirrors {
+ mirror_arc(sk, *arc, *p, *across);
+ }
+ let again = solve_inner(sk, hold, reference, analysis, old_values, budget);
+ let again_turns = if again.ok() { settle(sk, &before) } else { Vec::new() };
+ if again.ok() && again_turns.is_empty() {
+ return again;
+ }
+ *sk = solved;
+ }
+ let over: Vec<usize> = turns
+ .iter_mut()
+ .flat_map(|(_, t)| match t {
+ Turn::Over(cs) => std::mem::take(cs),
+ Turn::Mirror { .. } => Vec::new(),
+ _ => Vec::new(),
+ })
+ .collect();
+ let mirrored_still: Vec<usize> = turns
+ .iter()
+ .filter(|(_, t)| matches!(t, Turn::Mirror { .. }))
+ .flat_map(|(arc, _)| before.iter().find(|b| b.arc == *arc).map(|b| b.lines.iter().map(|l| l.2).collect::<Vec<_>>()).unwrap_or_default())
+ .collect();
+ let folded: Vec<String> = over.into_iter().chain(mirrored_still).filter_map(|ci| sk.constraints.get(ci).map(|c| c.id.clone())).collect();
+ if folded.is_empty() {
+ return report;
+ }
+ *sk = start;
+ report.status = SolveStatus::Failed;
+ for id in folded {
+ if !report.failing.contains(&id) {
+ report.failing.push(id.clone());
+ }
+ if !report.folded.contains(&id) {
+ report.folded.push(id);
+ }
+ }
+ report
+}
+
fn solve_inner(
sk: &mut Sketch,
hold: &Hold,
diff --git a/crates/sketch/src/tests.rs b/crates/sketch/src/tests.rs
index d969f0fd6a..29a58496ed 100644
--- a/crates/sketch/src/tests.rs
+++ b/crates/sketch/src/tests.rs
@@ -1181,3 +1181,101 @@ fn zero_component_dimensions_keep_independent_rank() {
}
}
}
+
+/// A fillet as `sketch.fillet` makes it: `l1` from (10, 10) to (35, 10), the arc round
+/// (35, 15) from (35, 10) to (40, 15), `l2` from (40, 15) to (40, 30); horizontal, vertical,
+/// radius 5, tangent at both ends. Returns (l1, arc, l2, l1's far point, l2's far point).
+fn filleted_corner() -> (Sketch, usize, usize, usize, usize, usize) {
+ let mut sk = Sketch::new();
+ let l1 = sk.add_line(v(10.0, 10.0), v(35.0, 10.0), None, None, None).unwrap();
+ let CurveKind::Line { a: far1, b: ta } = sk.curves[l1].kind else { panic!() };
+ let arc = sk.add_arc(v(35.0, 15.0), v(35.0, 10.0), v(40.0, 15.0), [None, Some(ta), None], None).unwrap();
+ let CurveKind::Arc { b: tb, .. } = sk.curves[arc].kind else { panic!() };
+ let l2 = sk.add_line(v(40.0, 15.0), v(40.0, 30.0), Some(tb), None, None).unwrap();
+ let CurveKind::Line { b: far2, .. } = sk.curves[l2].kind else { panic!() };
+ use ConstraintKind::*;
+ sk.add_constraint(Horizontal { l: l1 }, None).unwrap();
+ sk.add_constraint(Vertical { l: l2 }, None).unwrap();
+ sk.add_constraint(Radius { c: arc, value: 5.0 }, None).unwrap();
+ sk.add_constraint(Tangent { a: l1, b: arc }, None).unwrap();
+ sk.add_constraint(Tangent { a: l2, b: arc }, None).unwrap();
+ assert!(solve(&mut sk).ok());
+ (sk, l1, arc, l2, far1, far2)
+}
+
+/// The arc's counter-clockwise sweep from its stored `a` to `b`, degrees.
+fn sweep_deg(sk: &Sketch, arc: usize) -> f64 {
+ let CurveKind::Arc { c, a, b } = sk.curves[arc].kind else { panic!() };
+ let (c, a, b) = (sk.points[c].pos, sk.points[a].pos, sk.points[b].pos);
+ ((b - c).angle() - (a - c).angle()).rem_euclid(2.0 * PI).to_degrees()
+}
+
+/// Each line leaves the arc at its touch point along the arc's travel (a smooth path, not a
+/// line cutting back through the arc).
+fn lines_leave_the_arc(sk: &Sketch, arc: usize, lines: [usize; 2]) -> bool {
+ let CurveKind::Arc { c, a, b } = sk.curves[arc].kind else { panic!() };
+ lines.iter().all(|&l| {
+ let CurveKind::Line { a: la, b: lb } = sk.curves[l].kind else { panic!() };
+ let (p, far) = if la == a || la == b { (la, lb) } else { (lb, la) };
+ let outward = if p == b { 1.0 } else { -1.0 };
+ (sk.points[p].pos - sk.points[c].pos).perp().dot(sk.points[far].pos - sk.points[p].pos) * outward > 1e-6
+ })
+}
+
+#[test]
+fn a_fillet_follows_its_corner_when_the_corner_mirrors() {
+ // Pin the vertical line's far end to a point below the horizontal line: the corner mirrors.
+ // The fillet is the quarter arc on the other side, not a line through its arc or a
+ // three-quarter arc.
+ let (mut sk, l1, arc, l2, _, far2) = filleted_corner();
+ let q = sk.add_point(v(40.0, -20.0), None).unwrap();
+ sk.points[q].fixed = true;
+ sk.add_constraint(ConstraintKind::Coincident { p: far2, q }, None).unwrap();
+ let rep = solve(&mut sk);
+ assert!(rep.ok(), "{rep:?}");
+ assert!((sweep_deg(&sk, arc) - 90.0).abs() < 1e-6, "sweep {}", sweep_deg(&sk, arc));
+ assert!(lines_leave_the_arc(&sk, arc, [l1, l2]));
+ assert!(sk.center(arc).unwrap().dist(v(35.0, 5.0)) < 1e-6, "{:?}", sk.center(arc));
+ let (_, q1) = line_pts(&sk, l1);
+ let (p2, _) = line_pts(&sk, l2);
+ assert!(q1.dist(v(35.0, 10.0)) < 1e-6 && p2.dist(v(40.0, 5.0)) < 1e-6, "{q1:?} {p2:?}");
+ // Dragged back up (a move against the positions before it), it mirrors again.
+ sk.constraints.retain(|c| !matches!(c.kind, ConstraintKind::Coincident { .. }));
+ let reference: Vec<Vec2> = sk.points.iter().map(|p| p.pos).collect();
+ sk.points[far2].pos = v(40.0, 30.0);
+ let rep = solve_with(&mut sk, &Hold { points: vec![far2], radii: Vec::new() }, Some(&reference), Analysis::Full, None);
+ assert!(rep.ok(), "{rep:?}");
+ assert!((sweep_deg(&sk, arc) - 90.0).abs() < 1e-6, "sweep {}", sweep_deg(&sk, arc));
+ assert!(lines_leave_the_arc(&sk, arc, [l1, l2]));
+ assert!(sk.center(arc).unwrap().dist(v(35.0, 15.0)) < 1e-6, "{:?}", sk.center(arc));
+}
+
+#[test]
+fn a_fillet_folded_through_flat_is_refused_like_a_fold() {
+ // Without the horizontal and vertical, the second line turns about the corner: the arc
+ // shrinks towards flat (the lines collinear) and the lines keep leaving it. Past flat the
+ // only arc left is the loop the other way round; that step is refused as a fold and the
+ // sketch stays where it was.
+ let (mut sk, l1, arc, l2, _, far2) = filleted_corner();
+ sk.constraints.retain(|c| !matches!(c.kind, ConstraintKind::Horizontal { .. } | ConstraintKind::Vertical { .. }));
+ let hold = Hold { points: vec![far2], radii: Vec::new() };
+ let mut refused = None;
+ for step in 1..=16 {
+ let t = step as f64 / 16.0 * PI;
+ let reference: Vec<Vec2> = sk.points.iter().map(|p| p.pos).collect();
+ // From straight up, round through the right towards straight down, 15 mm from the corner.
+ sk.points[far2].pos = v(40.0, 10.0) + Vec2::from_angle(FRAC_PI_2 - t) * 15.0;
+ let rep = solve_with(&mut sk, &hold, Some(&reference), Analysis::Full, None);
+ if !rep.ok() {
+ assert!(!rep.folded.is_empty(), "step {step}: {rep:?}");
+ let stays = sk.points.iter().enumerate().filter(|(i, _)| *i != far2).all(|(i, p)| p.pos == reference[i]);
+ assert!(stays, "step {step}: the sketch stays");
+ refused = Some(step);
+ break;
+ }
+ let sweep = sweep_deg(&sk, arc);
+ assert!(sweep < 90.0 + 1e-6, "step {step}: sweep {sweep}");
+ assert!(lines_leave_the_arc(&sk, arc, [l1, l2]), "step {step}: sweep {sweep}");
+ }
+ assert!(refused.is_some_and(|s| (7..=9).contains(&s)), "refused at {refused:?}");
+}