Skip to content

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

Extend: join a stop that is already another curve's end (#6863) (#6865)

n0tfr3shm1lk111c662fe463
diff --git a/crates/engine/src/cmd/sketch_infinite_tests.rs b/crates/engine/src/cmd/sketch_infinite_tests.rs
index 11fff7ad5e..eae8092ad0 100644
--- a/crates/engine/src/cmd/sketch_infinite_tests.rs
+++ b/crates/engine/src/cmd/sketch_infinite_tests.rs
@@ -98,6 +98,22 @@ fn trim_and_extend_use_the_whole_line_but_never_trim_it() {
assert!(sk.point(b).unwrap().dist(Vec2::new(25.0, 10.0)) < 1e-6, "{:?}", sk.point(b));
}
+#[test]
+fn extend_refuses_it_instead_of_moving_it() {
+ // An infinite line has no end to grow from: moving one of its two points would move the whole
+ // line, so the command says why and leaves it alone.
+ let mut s = new_sketch();
+ run(&mut s, "sketch.line", json!({"points": [[25, 50], [25, 60]], "ids": ["inf"]}));
+ run(&mut s, "sketch.infinite", json!({"curves": ["inf"]}));
+ let before = s.doc.to_json();
+ let e = s.execute("sketch.extend", &json!({"curve": "inf", "at": [25, 50]})).unwrap_err().to_string();
+ assert!(e.contains("infinite"), "{e}");
+ assert_eq!(s.doc.to_json(), before);
+ let sk = sketch(&s);
+ let ci = sk.curve_index("inf").expect("the infinite line");
+ assert!(crate::cmd::extend_preview(&sk, ci, Vec2::new(25.0, 50.0)).is_none(), "no preview to offer");
+}
+
#[test]
fn fillets_and_chamfers_refuse_it_and_mirrors_copy_it() {
let mut s = new_sketch();
diff --git a/crates/engine/src/cmd/sketch_modify.rs b/crates/engine/src/cmd/sketch_modify.rs
index eea628a75e..fa00e53d5f 100644
--- a/crates/engine/src/cmd/sketch_modify.rs
+++ b/crates/engine/src/cmd/sketch_modify.rs
@@ -70,7 +70,7 @@ pub static COMMANDS: &[CommandSpec] = &[
.at("SKETCH", "MODIFY")
.icon("extend")
.enabled(in_sketch)
- .params("curve: id, at: [x,y] near the end to extend (to the nearest curve)"),
+ .params("curve: id, at: [x,y] near the end to extend (a line runs on to the nearest curve, or the previewed reach when nothing is in the way; an arc grows along its circle and closes into a whole circle when nothing stops it)"),
CommandSpec::new("sketch.break", "Break", break_cmd)
.at("SKETCH", "MODIFY")
.icon("sketch_break")
@@ -182,10 +182,7 @@ fn cut_points(sk: &Sketch, ci: usize) -> Vec<(f64, Vec2, usize)> {
fn pin(sk: &mut Sketch, p: usize, cutter: usize) -> Result<()> {
let at = sk.point(p).unwrap_or_default();
// An end point of the cutter there: coincident with it; otherwise on the curve.
- let ends: Vec<usize> = match sk.curves.get(cutter).map(|c| c.kind.clone()) {
- Some(CurveKind::Line { a, b }) | Some(CurveKind::Arc { a, b, .. }) => vec![a, b],
- _ => Vec::new(),
- };
+ let ends: Vec<usize> = sk.curves.get(cutter).and_then(|c| c.kind.ends()).map(|(a, b)| vec![a, b]).unwrap_or_default();
if let Some(e) = ends.into_iter().find(|e| sk.point(*e).is_some_and(|q| q.dist(at) < TOL * 10.0)) {
if e != p {
add_c(sk, ConstraintKind::Coincident { p, q: e })?;
@@ -606,208 +603,99 @@ fn break_cmd(s: &mut Session, p: &Value) -> Result<Value> {
/// of nothing.
const EXTEND_REACH: f64 = 50.0;
-/// Preview the extend operation without modifying the sketch.
-/// Returns the hit point that would be reached if the user extends the curve,
-/// or None if extension is not possible (blocked by collinear curves).
-pub fn extend_preview(sk: &solidcraft_sketch::Sketch, ci: usize, hover_pos: Vec2) -> Option<Vec2> {
- use solidcraft_sketch::{CurveKind, Shape};
+/// One end of a line growing along its own support, and what stops it.
+///
+/// A line extends past either of its ends, running on along its own straight support until the
+/// first geometry in the way. `sketch.extend` and its preview both take this aim, so the preview
+/// draws the line the click adds, never one the command refuses.
+#[derive(Clone, Copy, Debug)]
+struct LineAim {
+ /// The end that grows.
+ end: usize,
+ /// The point the extension stops at: the first geometry on the way, or the reach past the end
+ /// when nothing is in the way.
+ hit: Vec2,
+ /// The curve that stops it there, and the stop as the sketch's own point when the sketch
+ /// already has one there.
+ cutter: Option<usize>,
+ stop: Option<usize>,
+}
- let curve = sk.curves.get(ci)?;
- let (a, b) = match &curve.kind {
- CurveKind::Line { a: pa, b: pb } => (*pa, *pb),
- CurveKind::Arc { a: pa, b: pb, .. } => (*pa, *pb),
- _ => return None,
- };
- let pa = sk.point(a)?;
- let pb = sk.point(b)?;
- let at_b = hover_pos.dist(pb) <= hover_pos.dist(pa);
- let end = if at_b { b } else { a };
- let end_pt = sk.point(end)?;
- let other = if at_b { pa } else { pb };
-
- // Get the shape (line or arc) of the curve to extend
- let sh = sk.shape(ci)?;
- let unbounded = match sh {
- Shape::Line { .. } => sh,
- Shape::Round { c, r, start, .. } => Shape::Round { c, r, start, sweep: std::f64::consts::TAU },
- };
+/// The first geometry a line meets when it grows past the end of `ci` nearest `at`, or the reach
+/// past that end when nothing is in the way. Two curves stopping it equally far are one stop: the
+/// first of them is taken.
+fn line_aim(sk: &Sketch, ci: usize, at: Vec2) -> Result<Option<LineAim>> {
+ let cmd = "sketch.extend";
+ // An infinite line has no end to grow: moving either of its points moves the whole line.
+ let Some(curve) = sk.curves.get(ci).filter(|c| !c.infinite) else { return Ok(None) };
+ let CurveKind::Line { a: pa, b: pb } = curve.kind else { return Ok(None) };
+ let sh = sk.shape(ci).ok_or_else(|| bad(cmd, "curve"))?;
+ let (qa, qb) = (sk.point(pa).unwrap_or_default(), sk.point(pb).unwrap_or_default());
+ let at_b = at.dist(qb) <= at.dist(qa);
+ let (end, end_pt) = if at_b { (pb, qb) } else { (pa, qa) };
+ let dir = (end_pt - if at_b { qa } else { qb }).normalized().ok_or_else(|| bad(cmd, "cannot determine extension direction"))?;
- // Quick check for collinearity blocking by neighbors
- for other_curve in sk.curves.iter() {
- if let CurveKind::Line { a: na, b: nb } = &other_curve.kind
- && (*na == end || *nb == end)
- {
- let other_idx = if *na == end { *nb } else { *na };
- if let Some(other_pos) = sk.point(other_idx) {
- let dir = (end_pt - other).normalized()?;
- let v = other_pos - end_pt;
- // Collinear and in the same direction: this blocks extension.
- if v.cross(dir).abs() < 1e-6 && v.dot(dir) > 1e-6 {
- return None;
- }
+ // A neighbour running on the same way as the extension has it nowhere to go.
+ for (oi, c) in sk.curves.iter().enumerate() {
+ if oi == ci || !uses(c, end) {
+ continue;
+ }
+ // Arcs do not block a line: the line runs past the point they share.
+ if let CurveKind::Line { a: na, b: nb } = c.kind {
+ let other_idx = if na == end { nb } else { na };
+ let v = sk.point(other_idx).unwrap_or_default() - end_pt;
+ if v.cross(dir).abs() < 1e-6 && v.dot(dir) > 1e-6 {
+ return Err(bad(cmd, "that end is connected to other geometry"));
}
}
}
- // Now search for actual hit points using the same algorithm as extend
- let mut best_gap = f64::MAX;
- let mut best_hit: Option<Vec2> = None;
- let mut budget = 500_000usize; // Reduced budget for preview
- let tol_preview = 1e-7;
-
- // Get the extension direction
- let dir = (end_pt - other).normalized().unwrap_or_default();
-
- for (oi, other_curve) in sk.curves.iter().enumerate() {
+ // Candidate stops on the line's unbounded support beyond the chosen end.
+ let length = qa.dist(qb);
+ let mut best: Option<(f64, Vec2, usize)> = None;
+ let mut budget = 1_000_000usize;
+ let mut segment_count = 0usize;
+ for (oi, other) in sk.curves.iter().enumerate() {
if oi == ci {
continue;
}
-
- // Skip curves that share the endpoint we're extending from
- let shares_endpoint = match &other_curve.kind {
- CurveKind::Line { a, b } => *a == end || *b == end,
- CurveKind::Arc { a, b, .. } => *a == end || *b == end,
- _ => false,
- };
- if shares_endpoint {
- // Check for collinearity blocking (already checked above, but re-check here)
- if let CurveKind::Line { a: na, b: nb } = &other_curve.kind {
- let other_idx = if *na == end { *nb } else { *na };
- if let Some(other_pos) = sk.point(other_idx) {
- let v = other_pos - end_pt;
- let cross = v.cross(dir);
- let dot = v.dot(dir);
- if cross.abs() < 1e-6 && dot > 1e-6 {
- // Collinear and in same direction - blocks extension
- continue; // Skip this curve for hit finding
- }
- }
- }
+ let mut pieces = sk.exact_segs(oi).unwrap_or_else(|| sk.segs(oi));
+ // An infinite line (#1359) is a boundary along its whole line.
+ if other.infinite {
+ pieces = pieces.iter().map(|s| support::endless(s, sh.point(sh.param(at)))).collect();
}
-
- let pieces = sk.exact_segs(oi).unwrap_or_else(|| sk.segs(oi));
-
- // For infinite lines, extend segments
- let pieces_to_check: Vec<_> =
- if other_curve.infinite { pieces.iter().map(|s| support::endless(s, end_pt)).collect() } else { pieces.to_vec() };
-
- for piece in pieces_to_check {
- // Try to get hits - hits() will return empty vec or error for unsupported types
- if let Ok(hits) = support::hits(&unbounded, &piece, &mut budget) {
- for q in hits {
- // Check if hit is beyond the current end
- let t = sh.param(q);
- let gap = match sh {
- Shape::Line { a, b } => {
- let l = a.dist(b);
- if at_b { (t - 1.0) * l } else { -t * l }
- }
- Shape::Round { r, .. } => {
- let (_, t1) = sh.range();
- if t <= t1 + tol_preview / r.max(1e-12) || t >= TAU - tol_preview / r.max(1e-12) {
- continue;
- }
- if at_b { (t - t1) * r } else { (TAU - t) * r }
- }
- };
- // Only consider hits that are further than tolerance
- if gap > tol_preview * 10.0 && gap < best_gap {
- // CRITICAL CHECK: Verify no other curve lies between end_pt and q along the extension direction
- let mut blocked = false;
- for (oi2, _check_curve) in sk.curves.iter().enumerate() {
- if oi2 == ci {
- continue;
- }
- if oi2 == oi {
- continue;
- } // Skip the curve we just found hit on
-
- // Check if any segment of this curve lies between end_pt and q
- let segs = sk.exact_segs(oi2).unwrap_or_else(|| sk.segs(oi2));
- for seg in segs {
- // Get the endpoints of this segment
- let (sa, sb) = match seg {
- solidcraft_geom::Seg2::Line { a: sa, b: sb } => (sa, sb),
- solidcraft_geom::Seg2::Arc { center, radius, start, sweep } => {
- // For arcs, check the start and end points
- let angle = start + sweep;
- (
- center + Vec2::new(radius * start.cos(), radius * start.sin()),
- center + Vec2::new(radius * angle.cos(), radius * angle.sin()),
- )
- }
- _ => continue,
- };
-
- // Check if either endpoint lies between end_pt and q along the extension direction
- let vec_to_sa = sa - end_pt;
- let proj_sa = vec_to_sa.dot(dir);
- if proj_sa > tol_preview && proj_sa < gap - tol_preview {
- // Point sa projects onto the extension path between start and hit
- // Check if it's close to the line (within tolerance)
- let perp_dist = (sa - end_pt).cross(dir).abs();
- if perp_dist < tol_preview * 10.0 {
- blocked = true;
- break;
- }
- }
-
- let vec_to_sb = sb - end_pt;
- let proj_sb = vec_to_sb.dot(dir);
- if proj_sb > tol_preview && proj_sb < gap - tol_preview {
- let perp_dist = (sb - end_pt).cross(dir).abs();
- if perp_dist < tol_preview * 10.0 {
- blocked = true;
- break;
- }
- }
-
- if blocked {
- break;
- }
- }
- if blocked {
- break;
- }
- }
-
- if !blocked {
- best_gap = gap;
- best_hit = Some(q);
- }
- }
- }
- }
+ segment_count += pieces.len();
+ if segment_count > 16_384 {
+ return Err(bad(cmd, "too many exact curve pieces to extend safely"));
}
- }
-
- // CRITICAL CHECK 3: Verify no other curve endpoint coincides with the hit point.
- // If another curve already ends at this location, we should not create a new overlapping line.
- if let Some(hit) = best_hit {
- for (oi2, _other_curve) in sk.curves.iter().enumerate() {
- if oi2 == ci {
- continue;
- }
-
- // Get endpoints of the other curve
- let ends = match &sk.curves.get(oi2).map(|c| &c.kind) {
- Some(CurveKind::Line { a, b }) => [a, b],
- Some(CurveKind::Arc { a, b, .. }) => [a, b],
- _ => continue,
- };
-
- for &end_idx in &ends {
- if let Some(pt) = sk.point(*end_idx) {
- // If an existing point is at the hit location (within tolerance), block extension.
- if pt.dist(hit) < tol_preview * 10.0 {
- return None;
- }
+ for piece in &pieces {
+ for q in support::hits(&sh, piece, &mut budget)? {
+ let t = sh.param(q);
+ let travel = if at_b { (t - 1.0) * length } else { -t * length };
+ if travel <= TOL * 10.0 {
+ continue;
+ }
+ // Equally far stops are both on the way: the first one found is the stop.
+ if best.is_none_or(|x| travel < x.0 - TOL) {
+ best = Some((travel, q, oi));
}
}
}
}
- best_hit.or(Some(end_pt + dir * EXTEND_REACH))
+ let (hit, cutter, stop) = match best {
+ Some((_, q, oi)) => (q, Some(oi), stop_point(sk, ci, q)),
+ None => (end_pt + dir * EXTEND_REACH, None, None),
+ };
+ Ok(Some(LineAim { end, hit, cutter, stop }))
+}
+
+/// Preview the extend operation without modifying the sketch: the point the line past the end
+/// nearest `hover_pos` reaches, from the same search `sketch.extend` makes. `None` when the curve
+/// is not a line to extend, when it is an infinite line, or when the extension has nowhere to go
+/// (the end is connected to a line running on from it).
+pub fn extend_preview(sk: &solidcraft_sketch::Sketch, ci: usize, hover_pos: Vec2) -> Option<Vec2> {
+ line_aim(sk, ci, hover_pos).ok().flatten().map(|aim| aim.hit)
}
/// One end of an arc growing along the arc's own circle, as a new arc, and what stops it.
@@ -843,10 +731,11 @@ impl ArcAim {
}
}
-/// The first geometry an arc meets when it grows from the end of `ci` nearest `at`, or `None`
-/// when nothing is in the way. Both ends grow: past `b` counter-clockwise, past `a` clockwise,
-/// and only as far as the nearest curve on that path stops them. Two curves stopping it at the
-/// same distance is an error, not a guess.
+/// The first geometry an arc meets when it grows from the end of `ci` nearest `at`. Both ends
+/// grow: past `b` counter-clockwise, past `a` clockwise, and only as far as the nearest curve on
+/// that path stops them. With nothing in the way the extension runs on to the arc's own far end,
+/// closing the arc into a full circle. Two curves stopping it equally far are one stop: the first
+/// is taken.
fn arc_aim(sk: &Sketch, ci: usize, at: Vec2, cmd: &str) -> Result<Option<ArcAim>> {
let Some(CurveKind::Arc { a, b, .. }) = sk.curves.get(ci).map(|c| c.kind.clone()) else { return Ok(None) };
let Some(Shape::Round { c: centre, r, start, sweep }) = sk.shape(ci) else { return Ok(None) };
@@ -867,7 +756,6 @@ fn arc_aim(sk: &Sketch, ci: usize, at: Vec2, cmd: &str) -> Result<Option<ArcAim>
let far_tol = TOL * 10.0 / r;
let circle = Shape::Round { c: centre, r, start: 0.0, sweep: TAU };
let mut best: Option<(f64, Vec2, usize)> = None;
- let mut ambiguous = false;
let mut budget = 1_000_000usize;
let mut segment_count = 0usize;
for (oi, curve) in sk.curves.iter().enumerate() {
@@ -895,7 +783,7 @@ fn arc_aim(sk: &Sketch, ci: usize, at: Vec2, cmd: &str) -> Result<Option<ArcAim>
continue;
}
let entry = centre + Vec2::from_angle(entry) * r;
- keep_stop(&mut best, &mut ambiguous, travel, entry, oi, angle_tol);
+ keep_stop(&mut best, travel, entry, oi, angle_tol);
continue;
}
let mut pieces = sk.exact_segs(oi).unwrap_or_else(|| sk.segs(oi));
@@ -915,24 +803,22 @@ fn arc_aim(sk: &Sketch, ci: usize, at: Vec2, cmd: &str) -> Result<Option<ArcAim>
if travel <= angle_tol || travel > reach + far_tol {
continue;
}
- keep_stop(&mut best, &mut ambiguous, travel, q, oi, angle_tol);
+ keep_stop(&mut best, travel, q, oi, angle_tol);
}
}
}
- if ambiguous {
- return Err(bad(cmd, "multiple curves stop the extension at the same distance"));
- }
- Ok(best.map(|(travel, hit, cutter)| ArcAim { end, far, at_b, centre, radius: r, end_angle, travel, hit, cutter }))
+ // Nothing stops the arc on its way round: it grows all the way to its own far end, closing
+ // the gap between its ends into a full circle.
+ let far_pt = if at_b { qa } else { qb };
+ let (travel, hit, cutter) = best.unwrap_or((reach, far_pt, ci));
+ Ok(Some(ArcAim { end, far, at_b, centre, radius: r, end_angle, travel, hit, cutter }))
}
-/// Keep the stop the nearest of the candidates, and remember it when another curve stops the
-/// extension at the same distance somewhere else; the same point from several curves is one stop.
-fn keep_stop(best: &mut Option<(f64, Vec2, usize)>, ambiguous: &mut bool, travel: f64, q: Vec2, oi: usize, angle_tol: f64) {
+/// Keep the stop the nearest of the candidates. Two curves stopping the extension equally far are
+/// both on the way, so the first one found is taken instead of refusing to choose.
+fn keep_stop(best: &mut Option<(f64, Vec2, usize)>, travel: f64, q: Vec2, oi: usize, angle_tol: f64) {
if best.is_none_or(|x| travel < x.0 - angle_tol) {
*best = Some((travel, q, oi));
- *ambiguous = false;
- } else if best.is_some_and(|x| (travel - x.0).abs() <= angle_tol && x.1.dist(q) > TOL) {
- *ambiguous = true;
}
}
@@ -948,11 +834,8 @@ fn arc_stop(sk: &Sketch, ci: usize, aim: &ArcAim) -> Option<usize> {
return Some(aim.far);
}
sk.curves.iter().enumerate().filter(|(i, _)| *i != ci).find_map(|(_, c)| {
- let ends = match c.kind {
- CurveKind::Line { a, b } | CurveKind::Arc { a, b, .. } => [a, b],
- _ => return None,
- };
- ends.into_iter().find(|p| at_hit(*p))
+ let (a, b) = c.kind.ends()?;
+ [a, b].into_iter().find(|p| at_hit(*p))
})
}
@@ -975,18 +858,27 @@ fn add_arc_extension(sk: &mut Sketch, ci: usize, aim: &ArcAim, stop: Option<usiz
Ok(sk.points.get(stop).map(|x| x.id.clone()).unwrap_or_default())
}
-/// Whether `q` already is another curve's end: extending there would double geometry that is
-/// there, so extend refuses instead of adding an overlapping curve.
-fn ends_at_curve_end(sk: &Sketch, ci: usize, q: Vec2) -> bool {
- sk.curves.iter().enumerate().filter(|(i, _)| *i != ci).any(|(_, c)| {
- let ends = match &c.kind {
- CurveKind::Line { a, b } | CurveKind::Arc { a, b, .. } => [*a, *b],
- _ => return false,
- };
- ends.iter().any(|e| sk.point(*e).is_some_and(|pt| pt.dist(q) < TOL * 10.0))
+/// The point the extension stops at when the sketch already has one there: an end of another
+/// curve at the hit. Joining that point keeps the extension attached to the geometry that is
+/// there instead of laying a second point over it. `None` when the stop needs a new point.
+fn stop_point(sk: &Sketch, ci: usize, q: Vec2) -> Option<usize> {
+ sk.curves.iter().enumerate().filter(|(i, _)| *i != ci).find_map(|(_, c)| {
+ let (a, b) = c.kind.ends()?;
+ [a, b].into_iter().find(|p| sk.point(*p).is_some_and(|pt| pt.dist(q) <= TOL * 10.0))
})
}
+/// Add the line an extension needs, from the growing end to the stop: the sketch's own point
+/// when the stop already is one, a new point otherwise.
+fn add_line_extension(sk: &mut Sketch, end: usize, q: Vec2, stop: Option<usize>) -> Result<String> {
+ let b = match stop {
+ Some(p) => p,
+ None => sk.add_point(q, None)?,
+ };
+ sk.add_curve(CurveKind::Line { a: end, b }, None)?;
+ Ok(sk.points.get(b).map(|x| x.id.clone()).unwrap_or_default())
+}
+
/// Whether the growing end of an arc already carries geometry: another curve starts there, or a
/// constraint holds the point. Such an end keeps its place, so the extension has to be new
/// geometry.
@@ -1011,7 +903,7 @@ fn arc_end_held(sk: &Sketch, ci: usize, end: usize) -> bool {
fn extend_arc(sk: &mut Sketch, ci: usize, at: Vec2) -> Result<String> {
let cmd = "sketch.extend";
let Some(aim) = arc_aim(sk, ci, at, cmd)? else {
- return Err(bad(cmd, "nothing to extend to"));
+ return Err(bad(cmd, "an arc that is already a whole circle has no end to extend"));
};
let stop = arc_stop(sk, ci, &aim);
// The arc's own far end is where the arc begins again: moving the end onto it would leave a
@@ -1036,14 +928,21 @@ fn extend_arc(sk: &mut Sketch, ci: usize, at: Vec2) -> Result<String> {
}
return add_arc_extension(sk, ci, &aim, stop);
}
- // Held to what stopped it, the end stays on the geometry it reached.
- pin(sk, aim.end, aim.cutter)?;
+ // Held to the point that is already there or to what else stopped it, the end stays on the
+ // geometry it reached.
+ if let Some(stop) = stop {
+ if stop != aim.end {
+ add_c(sk, ConstraintKind::Coincident { p: aim.end, q: stop })?;
+ }
+ } else {
+ pin(sk, aim.end, aim.cutter)?;
+ }
Ok(sk.points.get(aim.end).map(|x| x.id.clone()).unwrap_or_default())
}
/// The arc `sketch.extend` would add from the end of `ci` nearest `hover_pos`, for the viewport to
-/// show before the click: the new arc as points, the growing end first. `None` when extending
-/// there is not possible (nothing on the way stops it, or stopping it is ambiguous).
+/// show before the click: the new arc as points, the growing end first. `None` when the arc cannot
+/// grow (it is already a whole circle).
pub fn extend_arc_preview(sk: &solidcraft_sketch::Sketch, ci: usize, hover_pos: Vec2) -> Option<Vec<Vec2>> {
let aim = arc_aim(sk, ci, hover_pos, "sketch.extend").ok().flatten()?;
Some(aim.points())
@@ -1059,105 +958,29 @@ fn extend(s: &mut Session, p: &Value) -> Result<Value> {
}
let ci = curve_arg(sk, p, cmd)?;
refuse_offset_ends(sk, ci, "extend", cmd)?;
+ // An infinite line already reaches across the view: moving one of its two points would
+ // move the whole line instead of extending it.
+ if sk.curves.get(ci).is_some_and(|c| c.infinite) {
+ return Err(bad(cmd, "an infinite line has no end to extend: make it a normal line first"));
+ }
// An arc grows along its own circle, either way round: in place when its end is free, as
// a new arc when the end already carries geometry.
if matches!(sk.curves.get(ci).map(|c| &c.kind), Some(CurveKind::Arc { .. })) {
return extend_arc(sk, ci, at);
}
- let sh = sk.shape(ci).ok_or_else(|| bad(cmd, "curve"))?;
- let Some(CurveKind::Line { a: pa, b: pb }) = sk.curves.get(ci).map(|c| c.kind.clone()) else {
+ // The line grows past one end, out to the first geometry on the way, or the reach the
+ // preview draws when nothing is in the way. A stop where the sketch already has a point
+ // (another curve's end) joins that point instead of doubling it.
+ let Some(aim) = line_aim(sk, ci, at)? else {
return Err(bad(cmd, "only lines and arcs can be extended"));
};
- let (qa, qb) = (sk.point(pa).unwrap_or_default(), sk.point(pb).unwrap_or_default());
- let at_b = at.dist(qb) <= at.dist(qa);
- let end = if at_b { pb } else { pa };
+ let end = aim.end;
+ let (q, cutter, stop) = (aim.hit, aim.cutter, aim.stop);
let neighbors: Vec<_> = sk.curves.iter().enumerate().filter(|(i, c)| *i != ci && uses(c, end)).collect();
- // Fixed ends are allowed: an extension that cannot move an end adds a new line from it,
- // so the fixed point itself never moves (a diagonal ending at the origin can be
- // continued through it).
- let extension_direction = {
- let p_end = sk.point(end).unwrap_or_default();
- let p_other = if at_b { qa } else { qb };
- (p_end - p_other).normalized()
- }
- .ok_or_else(|| bad(cmd, "cannot determine extension direction"))?;
-
- // A neighbour running on the same way as the extension has it nowhere to go.
- for (_, c) in &neighbors {
- // Arcs do not block a line: the line runs past the point they share.
- if matches!(c.kind, CurveKind::Arc { .. }) {
- continue;
- }
- if let CurveKind::Line { a: na, b: nb } = c.kind {
- let other_idx = if na == end { nb } else { na };
- let other_pos = sk.point(other_idx).unwrap_or_default();
- // From the shared point to the neighbour's other end.
- let v = other_pos - sk.point(end).unwrap_or_default();
- if v.cross(extension_direction).abs() < 1e-6 && v.dot(extension_direction) > 1e-6 {
- return Err(bad(cmd, "that end is connected to other geometry"));
- }
- }
- }
-
- // Candidate stops on the line's unbounded support beyond the chosen end.
- let length = qa.dist(qb);
- let mut best: Option<(f64, Vec2, usize)> = None;
- let mut ambiguous = false;
- let mut budget = 1_000_000usize;
- let mut segment_count = 0usize;
- for (oi, curve) in sk.curves.iter().enumerate() {
- if oi == ci {
- continue;
- }
- let mut pieces = sk.exact_segs(oi).unwrap_or_else(|| sk.segs(oi));
- // An infinite line (#1359) is a boundary along its whole line.
- if curve.infinite {
- pieces = pieces.iter().map(|s| support::endless(s, sh.point(sh.param(at)))).collect();
- }
- segment_count += pieces.len();
- if segment_count > 16_384 {
- return Err(bad(cmd, "too many exact curve pieces to extend safely"));
- }
- for piece in &pieces {
- for q in support::hits(&sh, piece, &mut budget)? {
- let t = sh.param(q);
- let gap = if at_b { (t - 1.0) * length } else { -t * length };
- if gap <= TOL * 10.0 {
- continue;
- }
- if best.is_none_or(|x| gap < x.0 - TOL) {
- best = Some((gap, q, oi));
- ambiguous = false;
- } else if best.is_some_and(|x| (gap - x.0).abs() <= TOL && (x.2 != oi || x.1.dist(q) > TOL)) {
- ambiguous = true;
- }
- }
- }
- }
-
- if ambiguous {
- return Err(bad(cmd, "multiple curves stop the extension at the same distance"));
- }
-
- // Nothing in the way stops the extension: it runs as far as the preview draws, so the
- // click adds the line the user saw rather than reporting that there is nothing to reach.
- let (q, cutter) = match best {
- Some((_, q, oi)) => {
- // A target that is already another curve's end would double that geometry.
- if ends_at_curve_end(sk, ci, q) {
- return Err(bad(cmd, "the extension target coincides with existing geometry"));
- }
- (q, Some(oi))
- }
- None => (sk.point(end).unwrap_or_default() + extension_direction * EXTEND_REACH, None),
- };
-
// The end joined to other geometry stays where it is: add a line from it.
if !neighbors.is_empty() {
- let np = sk.add_point(q, None)?;
- sk.add_curve(CurveKind::Line { a: end, b: np }, None)?;
- return Ok(sk.points.get(np).map(|x| x.id.clone()).unwrap_or_default());
+ return add_line_extension(sk, end, q, stop);
}
// An end held by a constraint, or lying on a circle or arc, stays where it is too: the
@@ -1185,32 +1008,37 @@ fn extend(s: &mut Session, p: &Value) -> Result<Value> {
};
if end_is_held {
- let np = sk.add_point(q, None)?;
- sk.add_curve(CurveKind::Line { a: end, b: np }, None)?;
- return Ok(sk.points.get(np).map(|x| x.id.clone()).unwrap_or_default());
+ return add_line_extension(sk, end, q, stop);
}
- // A free end moves along instead, if the solver lets it.
- if let Some(pt) = sk.points.get_mut(end) {
+ // A free end moves along instead, if the solver lets it. The attempt is made on a copy,
+ // so an end the solver cannot put where it belongs leaves the sketch as it was for the
+ // new line below.
+ let mut attempt = sk.clone();
+ if let Some(pt) = attempt.points.get_mut(end) {
pt.pos = q;
}
- // Held to what stopped it, an end stays where the extension put it; an end with nothing
- // to hold it is simply placed there.
- if let Some(cutter) = cutter {
- pin(sk, end, cutter)?;
+ // Held to the point that is already there or to what else stopped it, an end stays where
+ // the extension put it; an end with nothing to hold it is simply placed there.
+ if let Some(stop) = stop {
+ if stop != end {
+ add_c(&mut attempt, ConstraintKind::Coincident { p: end, q: stop })?;
+ }
+ } else if let Some(cutter) = cutter {
+ pin(&mut attempt, end, cutter)?;
}
let before = sk.points.iter().map(|p| p.pos).collect::<Vec<_>>();
- let hold = solidcraft_sketch::Hold { points: (0..sk.points.len()).filter(|i| *i != end).collect(), radii: (0..sk.curves.len()).collect() };
- let moved = solidcraft_sketch::solve_with(sk, &hold, None, solidcraft_sketch::Analysis::StatusOnly, None).ok()
- && sk.point(end).is_some_and(|point| point.dist(q) <= TOL)
- && sk.points.iter().enumerate().all(|(i, point)| i == end || point.pos.dist(before[i]) <= TOL);
+ let hold =
+ solidcraft_sketch::Hold { points: (0..attempt.points.len()).filter(|i| *i != end).collect(), radii: (0..attempt.curves.len()).collect() };
+ let moved = solidcraft_sketch::solve_with(&mut attempt, &hold, None, solidcraft_sketch::Analysis::StatusOnly, None).ok()
+ && attempt.point(end).is_some_and(|point| point.dist(q) <= TOL)
+ && attempt.points.iter().enumerate().all(|(i, point)| i == end || point.pos.dist(before[i]) <= TOL);
if moved {
+ *sk = attempt;
return Ok(sk.points.get(end).map(|x| x.id.clone()).unwrap_or_default());
}
// The solve could not put the end where it belongs: add a new line instead.
- let np = sk.add_point(q, None)?;
- sk.add_curve(CurveKind::Line { a: end, b: np }, None)?;
- Ok(sk.points.get(np).map(|x| x.id.clone()).unwrap_or_default())
+ add_line_extension(sk, end, q, stop)
})?;
Ok(json!({"moved": out, "sketch": info}))
}
diff --git a/crates/engine/src/cmd/sketch_modify_tests.rs b/crates/engine/src/cmd/sketch_modify_tests.rs
index acf99057f0..a2be9291b0 100644
--- a/crates/engine/src/cmd/sketch_modify_tests.rs
+++ b/crates/engine/src/cmd/sketch_modify_tests.rs
@@ -211,17 +211,47 @@ fn exact_extend_ellipse_preserves_support_target_and_history() {
}
#[test]
-fn exact_extend_arc_rejects_interior_hit_atomically() {
+fn exact_extend_arc_closes_round_a_cutter_inside_its_own_sweep() {
let mut s = new_sketch();
let arc = ids(&run(&mut s, "sketch.arc.center_point", json!({"center":[0,0],"start":[10,0],"end":[0,10],"connect":false}))["curves"])[0].clone();
let x = 50.0_f64.sqrt();
+ // A cutter crossing the circle at 45°: inside the arc's own quarter, so it is not on the path
+ // the extension takes round the other way.
let cutter = ids(&run(&mut s, "sketch.line", json!({"points":[[x,5],[x,9]],"connect":false,"infer":false}))["curves"])[0].clone();
run(&mut s, "sketch.constraint.fix", json!({"entity":cutter}));
- let before = s.doc.to_json();
- let history = s.undo.len();
- assert!(s.execute("sketch.extend", &json!({"curve":arc,"at":[10,0]})).is_err());
- assert_eq!(s.doc.to_json(), before);
- assert_eq!(s.undo.len(), history);
+ let before = sketch(&s);
+ run(&mut s, "sketch.extend", json!({"curve":arc,"at":[10,0]}));
+ let sk = sketch(&s);
+ let ci = sk.curve_index(&arc).expect("the arc");
+ // Nothing stops the extension, so the arc keeps its quarter...
+ assert!(matches!(sk.shape(ci), Some(solidcraft_sketch::Shape::Round { sweep, .. }) if (sweep - std::f64::consts::FRAC_PI_2).abs() < 1e-9));
+ // ...and a new arc runs from its far end back round to close the circle.
+ assert_eq!(sk.curves.len(), before.curves.len() + 1);
+ let sh = sk.shape(sk.curves.len() - 1).expect("the closing arc");
+ assert!(matches!(sh, solidcraft_sketch::Shape::Round { sweep, .. } if (sweep - 3.0 * std::f64::consts::FRAC_PI_2).abs() < 1e-9), "{sh:?}");
+ assert!(sh.dist(Vec2::new(10.0, 0.0)) < 1e-6 && sh.dist(Vec2::new(0.0, 10.0)) < 1e-6, "{sh:?}");
+}
+
+#[test]
+fn arc_extend_with_nothing_in_the_way_closes_into_a_full_circle() {
+ let mut s = new_sketch();
+ let arc = ids(&run(&mut s, "sketch.arc.center_point", json!({"center":[0,0],"start":[10,0],"end":[0,10],"connect":false}))["curves"])[0].clone();
+ let before = sketch(&s);
+ let ci = before.curve_index(&arc).expect("the arc");
+ assert!(profiles(&s).is_empty(), "an arc alone bounds nothing");
+ // The preview shows the whole circle: the closing arc from the growing end to the far end.
+ let preview = super::extend_arc_preview(&before, ci, Vec2::new(10.0, 0.0)).expect("a closing preview");
+ assert!(preview.first().is_some_and(|p| p.dist(Vec2::new(10.0, 0.0)) < 1e-6), "the preview starts at the growing end: {preview:?}");
+ assert!(preview.last().is_some_and(|p| p.dist(Vec2::new(0.0, 10.0)) < 1e-6), "and ends on the arc's far end: {preview:?}");
+
+ run(&mut s, "sketch.extend", json!({"curve": arc, "at": [10, 0]}));
+
+ let sk = sketch(&s);
+ assert_eq!(sk.curves.len(), before.curves.len() + 1, "a new arc closes the circle");
+ assert_eq!(sk.points.len(), before.points.len(), "it joins the arc's own far end instead of laying a second point over it");
+ let area = profiles(&s);
+ assert_eq!(area.len(), 1, "the two arcs bound one disc: {area:?}");
+ assert!((area[0] - std::f64::consts::PI * 100.0).abs() < 1e-3, "{area:?}");
}
#[test]
@@ -396,17 +426,105 @@ fn extend_with_nothing_in_the_way_adds_the_line_the_preview_shows() {
}
#[test]
-fn exact_extend_refuses_ambiguous_stop_without_history_change() {
+fn line_extend_joins_a_stop_that_is_another_curves_end() {
+ // The end being extended already carries geometry (a horizontal line meets it there), so the
+ // extension is a new line. The first stop on the way is the end of another line: the new line
+ // joins that point instead of refusing or laying a second point over it.
+ let mut s = new_sketch();
+ let vertical = ids(&run(&mut s, "sketch.line", json!({"points":[[0,0],[0,45],[15,45]],"connect":false,"infer":false}))["curves"])[0].clone();
+ let top = ids(&run(&mut s, "sketch.line", json!({"points":[[0,47],[10,47]],"connect":false,"infer":false}))["curves"])[0].clone();
+ let before = sketch(&s);
+ let stop = before.resolve_point(&format!("{top}.start")).expect("the top line's start");
+ assert!(before.point(stop).is_some_and(|p| p.dist(Vec2::new(0.0, 47.0)) < 1e-9));
+ let (curves, points) = (before.curves.len(), before.points.len());
+ let ci = before.curve_index(&vertical).expect("the vertical line");
+ let preview = super::extend_preview(&before, ci, Vec2::new(0.0, 45.0));
+
+ run(&mut s, "sketch.extend", json!({"curve": vertical, "at": [0,45]}));
+
+ assert!(preview.is_some_and(|q| q.dist(Vec2::new(0.0, 47.0)) < 1e-6), "the preview shows the line to the stop: {preview:?}");
+
+ let sk = sketch(&s);
+ assert_eq!(sk.curves.len(), curves + 1, "the extension is a new line");
+ assert_eq!(sk.points.len(), points, "the extension joins the point that is there");
+ assert!(matches!(sk.curves[sk.curves.len() - 1].kind, CurveKind::Line { b, .. } if b == stop), "the new line ends on the existing point");
+
+ // A free end moves onto the point that is there, and is held to it instead of doubling it.
let mut s = new_sketch();
- run(&mut s, "sketch.line", json!({"points":[[0,0],[5,0]],"connect":false,"infer":false}));
+ let vertical = ids(&run(&mut s, "sketch.line", json!({"points":[[0,0],[0,45]],"connect":false,"infer":false}))["curves"])[0].clone();
+ let top = ids(&run(&mut s, "sketch.line", json!({"points":[[0,47],[10,47]],"connect":false,"infer":false}))["curves"])[0].clone();
+ let before = sketch(&s);
+ let stop = before.resolve_point(&format!("{top}.start")).expect("the top line's start");
+ run(&mut s, "sketch.extend", json!({"curve": vertical, "at": [0,45]}));
+ let sk = sketch(&s);
+ assert_eq!((sk.curves.len(), sk.points.len()), (before.curves.len(), before.points.len()), "the line itself reaches the point");
+ let end = sk.resolve_point(&format!("{vertical}.end")).expect("the line's end");
+ assert!(sk.point(end).is_some_and(|p| p.dist(Vec2::new(0.0, 47.0)) < 1e-9), "{end}");
+ assert!(
+ sk.constraints.iter().any(|c| matches!(c.kind, ConstraintKind::Coincident { p, q } if (p, q) == (end, stop) || (p, q) == (stop, end))),
+ "the end is held to the point that was already there"
+ );
+}
+
+#[test]
+fn extend_joins_the_end_of_a_freeform_curve() {
+ // A line whose end is free grows onto a spline's start instead of laying a second point over
+ // the spline's own end.
+ let mut s = new_sketch();
+ let line = ids(&run(&mut s, "sketch.line", json!({"points":[[0,0],[5,0]],"connect":false,"infer":false}))["curves"])[0].clone();
+ let spline = ids(&run(&mut s, "sketch.spline.fit_point", json!({"points":[[10,0],[15,5],[20,0]],"connect":false}))["curves"])[0].clone();
+ let before = sketch(&s);
+ let stop = before.resolve_point(&format!("{spline}.start")).expect("the spline's start");
+ run(&mut s, "sketch.extend", json!({"curve": line, "at": [5,0]}));
+ let sk = sketch(&s);
+ assert_eq!((sk.curves.len(), sk.points.len()), (before.curves.len(), before.points.len()));
+ let end = sk.resolve_point(&format!("{line}.end")).expect("the line's end");
+ assert!(
+ sk.point(end).zip(sk.point(stop)).is_some_and(|(a, b)| a.dist(b) < 1e-9),
+ "the line ends on the spline's own point: {:?} / {:?}",
+ sk.point(end),
+ sk.point(stop)
+ );
+ assert!(
+ sk.constraints.iter().any(|c| matches!(c.kind, ConstraintKind::Coincident { p, q } if (p, q) == (end, stop) || (p, q) == (stop, end))),
+ "the end is held to the spline's point"
+ );
+
+ // An arc whose end is free grows onto a conic's start the same way.
+ let mut s = new_sketch();
+ let arc = ids(&run(&mut s, "sketch.arc.center_point", json!({"center":[0,0],"start":[10,0],"end":[0,10],"connect":false}))["curves"])[0].clone();
+ let conic =
+ ids(&run(&mut s, "sketch.conic", json!({"start":[0,-10],"end":[-20,-10],"apex":[-10,-20],"rho":0.5,"connect":false}))["curves"])[0].clone();
+ let before = sketch(&s);
+ let stop = before.resolve_point(&format!("{conic}.start")).expect("the conic's start");
+ run(&mut s, "sketch.extend", json!({"curve": arc, "at": [10,0]}));
+ let sk = sketch(&s);
+ assert_eq!((sk.curves.len(), sk.points.len()), (before.curves.len(), before.points.len()));
+ let end = sk.resolve_point(&format!("{arc}.start")).expect("the arc's start");
+ assert!(sk.point(end).is_some_and(|p| p.dist(Vec2::new(0.0, -10.0)) < 1e-6), "{end}");
+ assert!(
+ sk.constraints.iter().any(|c| matches!(c.kind, ConstraintKind::Coincident { p, q } if (p, q) == (end, stop) || (p, q) == (stop, end))),
+ "the arc ends on the conic's own point"
+ );
+}
+
+#[test]
+fn exact_extend_takes_one_of_two_stops_at_the_same_distance() {
+ // A vertical line and a diagonal cross the line's support at the same point: two curves stop
+ // the extension equally far out. Either stop is the same point, so the extension takes it
+ // instead of refusing to choose, and the preview shows the line the command adds.
+ let mut s = new_sketch();
+ let line = ids(&run(&mut s, "sketch.line", json!({"points":[[0,0],[5,0]],"connect":false,"infer":false}))["curves"])[0].clone();
run(&mut s, "sketch.line", json!({"points":[[10,-5],[10,5]],"connect":false,"infer":false}));
run(&mut s, "sketch.line", json!({"points":[[8,-2],[12,2]],"connect":false,"infer":false}));
- let before = s.doc.to_json();
- let history = s.undo.len();
- let error = s.execute("sketch.extend", &json!({"curve":"l1","at":[5,0]})).unwrap_err();
- assert!(error.to_string().contains("multiple curves"), "{error}");
- assert_eq!(s.doc.to_json(), before);
- assert_eq!(s.undo.len(), history);
+ let before = sketch(&s);
+ let ci = before.curve_index(&line).expect("the line");
+ let preview = super::extend_preview(&before, ci, Vec2::new(5.0, 0.0)).expect("a preview");
+ assert!(preview.dist(Vec2::new(10.0, 0.0)) < 1e-9, "{preview:?}");
+ run(&mut s, "sketch.extend", json!({"curve":line,"at":[5,0]}));
+ let sk = sketch(&s);
+ let end = sk.point(sk.resolve_point(&format!("{line}.end")).expect("the line's end")).expect("a point");
+ assert!(end.dist(Vec2::new(10.0, 0.0)) < 1e-6, "{end:?}");
}
#[test]