Skip to content

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

fix(sketch): join nearby profile endpoints (#7269)

Frankbe757154d63f
diff --git a/crates/sketch/src/profiles.rs b/crates/sketch/src/profiles.rs
index 369f88021d..956b8eab1e 100644
--- a/crates/sketch/src/profiles.rs
+++ b/crates/sketch/src/profiles.rs
@@ -17,6 +17,7 @@ use crate::shape::{Shape, intersections_within};
use crate::union_find::{find, union};
const MERGE_TOL: f64 = 1e-6;
+const ENDPOINT_JOIN_TOL: f64 = MERGE_TOL * 100.0;
const MAX_EDGES: usize = 50_000;
/// A closed region usable by features, with the ids of the curves bounding it.
@@ -370,6 +371,136 @@ fn with_end(s: Seg2, p: Vec2) -> Seg2 {
}
}
+fn set_start(s: Seg2, p: Vec2) -> Seg2 {
+ with_end(s.reversed(), p).reversed()
+}
+
+fn join_point(a: Seg2, b: Seg2, tol: f64) -> Option<Vec2> {
+ match (a, b) {
+ (Seg2::Line { .. }, Seg2::Line { .. }) => Some((a.end() + b.start()) * 0.5),
+ (Seg2::Line { .. }, Seg2::Arc { center, radius, .. }) | (Seg2::Arc { center, radius, .. }, Seg2::Line { .. }) => {
+ let near = if matches!(a, Seg2::Arc { .. }) { a.end() } else { b.start() };
+ Some(center + Vec2::from_angle((near - center).angle()) * radius)
+ }
+ (Seg2::Arc { center, radius, .. }, Seg2::Arc { center: c2, radius: r2, .. }) if same_circle(center, radius, c2, r2, MERGE_TOL) => {
+ let near = (a.end() + b.start()) * 0.5;
+ Some(center + Vec2::from_angle((near - center).angle()) * radius)
+ }
+ (Seg2::Arc { center, radius, .. }, Seg2::Arc { center: c2, radius: r2, .. }) => intersections_within(
+ &Shape::Round { c: center, r: radius, start: 0.0, sweep: TAU },
+ &Shape::Round { c: c2, r: r2, start: 0.0, sweep: TAU },
+ tol,
+ )
+ .into_iter()
+ .filter(|p| p.dist((a.end() + b.start()) * 0.5) <= tol * 2.0)
+ .min_by(|p, q| p.dist((a.end() + b.start()) * 0.5).total_cmp(&q.dist((a.end() + b.start()) * 0.5))),
+ _ => None,
+ }
+}
+
+fn close_graph_joints(mut segs: Vec<Seg2>, edge_nodes: &[(usize, usize)], edge_analytic: &[bool], tol: f64) -> Vec<Seg2> {
+ let n = segs.len();
+ for i in 0..n {
+ let j = (i + 1) % n;
+ let (Some((_, end_node)), Some((start_node, _))) = (edge_nodes.get(i), edge_nodes.get(j)) else { continue };
+ if end_node != start_node || !edge_analytic.get(i).copied().unwrap_or(false) || !edge_analytic.get(j).copied().unwrap_or(false) {
+ continue;
+ }
+ let (Some(a), Some(b)) = (segs.get(i).copied(), segs.get(j).copied()) else { continue };
+ if a.end().dist(b.start()) <= 1e-12 || a.end().dist(b.start()) > tol {
+ continue;
+ }
+ let Some(point) = join_point(a, b, tol) else { continue };
+ let (a, b) = match (a, b) {
+ (Seg2::Line { .. }, Seg2::Line { .. }) => (with_end(a, point), set_start(b, point)),
+ (Seg2::Line { .. }, Seg2::Arc { .. }) => (with_end(a, b.start()), b),
+ (Seg2::Arc { .. }, Seg2::Line { .. }) => (a, with_end(b.reversed(), a.end()).reversed()),
+ (Seg2::Arc { .. }, Seg2::Arc { .. }) => (with_end(a, point), set_start(b, point)),
+ _ => (a, b),
+ };
+ if let Some(slot) = segs.get_mut(i) {
+ *slot = a;
+ }
+ if let Some(slot) = segs.get_mut(j) {
+ *slot = b;
+ }
+ }
+ segs
+}
+
+fn merge_nearby_endpoints(sk: &Sketch, endpoints: &[(usize, usize)], groups: &mut [usize], max_edges: usize) {
+ let tol = ENDPOINT_JOIN_TOL;
+ let cell = |p: Vec2| ((p.x / tol).floor() as i64, (p.y / tol).floor() as i64);
+ let mut curve_endpoints = std::collections::HashMap::<usize, Vec<usize>>::new();
+ for &(point_index, curve_index) in endpoints {
+ curve_endpoints.entry(curve_index).or_default().push(point_index);
+ }
+ let connected_endpoints: std::collections::HashSet<(usize, usize)> = curve_endpoints
+ .values()
+ .filter_map(|points| {
+ let [a, b] = points.as_slice() else { return None };
+ Some(((*a).min(*b), (*a).max(*b)))
+ })
+ .collect();
+ let mut grid: std::collections::HashMap<(i64, i64), Vec<usize>> = std::collections::HashMap::new();
+ let mut joins = std::collections::HashMap::<(usize, usize), f64>::new();
+ let mut checks = 0usize;
+ let check_limit = max_edges.saturating_mul(16).max(16);
+ let mut exceeded_limit = false;
+ 'points: for &(point_index, _) in endpoints {
+ let Some(point) = sk.point(point_index).filter(|point| point.is_finite()) else { continue };
+ let (cx, cy) = cell(point);
+ for dx in -1..=1 {
+ for dy in -1..=1 {
+ let (Some(x), Some(y)) = (cx.checked_add(dx), cy.checked_add(dy)) else { continue };
+ if let Some(candidates) = grid.get(&(x, y)) {
+ for &other_index in candidates {
+ if other_index == point_index {
+ continue;
+ }
+ checks += 1;
+ if checks > check_limit {
+ exceeded_limit = true;
+ break 'points;
+ }
+ if let Some(distance) = sk.point(other_index).map(|other| point.dist(other)).filter(|distance| *distance <= tol) {
+ let pair = (point_index.min(other_index), point_index.max(other_index));
+ joins.entry(pair).and_modify(|best| *best = best.min(distance)).or_insert(distance);
+ }
+ }
+ }
+ }
+ }
+ grid.entry((cx, cy)).or_default().push(point_index);
+ }
+ if !exceeded_limit {
+ let mut nearest = std::collections::HashMap::<usize, (f64, Option<usize>)>::new();
+ let tie_tolerance = MERGE_TOL * 1e-6;
+ for (&(a, b), &distance) in &joins {
+ for (point, other) in [(a, b), (b, a)] {
+ match nearest.entry(point).or_insert((f64::INFINITY, None)) {
+ (best, closest) if distance < *best - tie_tolerance => {
+ *best = distance;
+ *closest = Some(other);
+ }
+ (best, closest) if (distance - *best).abs() <= tie_tolerance => *closest = None,
+ _ => {}
+ }
+ }
+ }
+ for &(a, b) in joins.keys() {
+ if connected_endpoints.contains(&(a, b)) {
+ continue;
+ }
+ let a_is_unique_nearest = nearest.get(&a).is_some_and(|(_, closest)| *closest == Some(b));
+ let b_is_unique_nearest = nearest.get(&b).is_some_and(|(_, closest)| *closest == Some(a));
+ if a_is_unique_nearest && b_is_unique_nearest {
+ union(groups, a, b);
+ }
+ }
+ }
+}
+
/// Where the end of run `a` meets the start of run `b`, near `p`: the point and the parameters
/// on the two runs' segments (Newton on A(ta) = B(tb); lines and arcs extend past their ends).
fn refine_crossing(a: &Run, b: &Run, p: Vec2) -> Option<(Vec2, f64, f64)> {
@@ -533,6 +664,20 @@ pub fn find_profiles(sk: &Sketch) -> Vec<Profile> {
fn find_profiles_bounded(sk: &Sketch, max_edges: usize) -> Vec<Profile> {
let tol = MERGE_TOL * 10.0;
+ let mut endpoint_groups: Vec<usize> = (0..sk.points.len()).collect();
+ let mut curve_endpoints = Vec::new();
+ for (curve_index, curve) in sk.curves.iter().enumerate() {
+ if !curve.construction
+ && !curve.centerline
+ && !curve.infinite
+ && matches!(curve.kind, CurveKind::Line { .. } | CurveKind::Arc { .. })
+ && let Some((a, b)) = curve.kind.ends()
+ {
+ curve_endpoints.extend([(a, curve_index), (b, curve_index)]);
+ }
+ }
+ merge_nearby_endpoints(sk, &curve_endpoints, &mut endpoint_groups, max_edges);
+ let endpoint_groups: Vec<usize> = (0..endpoint_groups.len()).map(|p| find(&mut endpoint_groups, p)).collect();
// Lines, arcs and circles (free-form curves take part as sampled pieces).
let analytic =
|ci: usize| sk.curves.get(ci).is_some_and(|c| matches!(c.kind, CurveKind::Line { .. } | CurveKind::Arc { .. } | CurveKind::Circle { .. }));
@@ -784,14 +929,22 @@ fn find_profiles_bounded(sk: &Sketch, max_edges: usize) -> Vec<Profile> {
let mut nodes: Vec<Vec2> = Vec::new();
// Grid buckets of `tol`-sized cells: merging looks only at neighbouring cells.
let mut grid: std::collections::HashMap<(i64, i64), Vec<usize>> = std::collections::HashMap::new();
+ let mut endpoint_nodes: std::collections::HashMap<usize, usize> = std::collections::HashMap::new();
let cell = |p: Vec2| ((p.x / tol).floor() as i64, (p.y / tol).floor() as i64);
- let mut node = |p: Vec2| -> usize {
+ let mut node = |p: Vec2, endpoint: Option<usize>| -> usize {
+ let group = endpoint.and_then(|i| endpoint_groups.get(i).copied());
+ if let Some(i) = group.and_then(|group| endpoint_nodes.get(&group).copied()) {
+ return i;
+ }
let (cx, cy) = cell(p);
for dx in -1..=1 {
for dy in -1..=1 {
if let Some(v) = grid.get(&(cx + dx, cy + dy))
&& let Some(i) = v.iter().copied().find(|i| nodes.get(*i).is_some_and(|q| q.dist(p) <= tol))
{
+ if let Some(group) = group {
+ endpoint_nodes.insert(group, i);
+ }
return i;
}
}
@@ -799,12 +952,15 @@ fn find_profiles_bounded(sk: &Sketch, max_edges: usize) -> Vec<Profile> {
nodes.push(p);
let i = nodes.len() - 1;
grid.entry((cx, cy)).or_default().push(i);
+ if let Some(group) = group {
+ endpoint_nodes.insert(group, i);
+ }
i
};
// Where curves meet at their carriers' crossing, the cuts on each lie within the tolerance of
// that point, though not always of each other: they meet at a node there.
for a in &anchors {
- node(*a);
+ node(*a, None);
}
let mut loops: Vec<(Loop2, Vec<String>, usize, Option<Vec<String>>)> = Vec::new(); // (ccw loop, curve ids, component)
let mut edges: Vec<Edge> = Vec::new();
@@ -838,6 +994,7 @@ fn find_profiles_bounded(sk: &Sketch, max_edges: usize) -> Vec<Profile> {
}
let ts: Vec<f64> = ts.into_iter().map(|(t, _)| t).collect();
let id = sk.curves.get(*ci).map(|c| c.id.clone()).unwrap_or_default();
+ let endpoints = sk.curves.get(*ci).filter(|c| matches!(c.kind, CurveKind::Line { .. } | CurveKind::Arc { .. })).and_then(|c| c.kind.ends());
let analytic = analytic(*ci);
let coverage = tags.get(k).copied().flatten().or_else(|| {
sk.curves
@@ -853,10 +1010,13 @@ fn find_profiles_bounded(sk: &Sketch, max_edges: usize) -> Vec<Profile> {
ps.push(b);
// Pieces split by other curves no longer stand for their whole piece.
let tag = if ts.is_empty() { tags.get(k).copied().flatten() } else { None };
- for w in ps.windows(2) {
+ for (piece, w) in ps.windows(2).enumerate() {
let (p, q) = (w[0], w[1]);
if p.dist(q) > MERGE_TOL {
- let (u, v) = (node(p), node(q));
+ let first = piece == 0;
+ let last = piece + 2 == ps.len();
+ let u = node(p, first.then(|| endpoints.map(|(a, _)| a)).flatten());
+ let v = node(q, last.then(|| endpoints.map(|(_, b)| b)).flatten());
edges.push(Edge { seg: Seg2::Line { a: p, b: q }, u, v, id: id.clone(), tag, coverage, analytic });
}
}
@@ -873,13 +1033,16 @@ fn find_profiles_bounded(sk: &Sketch, max_edges: usize) -> Vec<Profile> {
let first = bounds.first().copied().unwrap_or(0.0);
bounds.push(first + TAU);
}
- for w in bounds.windows(2) {
+ for (piece, w) in bounds.windows(2).enumerate() {
let (t0, t1) = (w[0], w[1]);
if (t1 - t0) * r <= MERGE_TOL {
continue;
}
let seg = Seg2::Arc { center: c, radius: r, start: start + t0, sweep: t1 - t0 };
- let (u, v) = (node(seg.start()), node(seg.end()));
+ let first = !full && piece == 0;
+ let last = !full && piece + 2 == bounds.len();
+ let u = node(seg.start(), first.then(|| endpoints.map(|(a, _)| a)).flatten());
+ let v = node(seg.end(), last.then(|| endpoints.map(|(_, b)| b)).flatten());
edges.push(Edge { seg, u, v, id: id.clone(), tag: None, coverage, analytic });
}
}
@@ -944,6 +1107,8 @@ fn find_profiles_bounded(sk: &Sketch, max_edges: usize) -> Vec<Profile> {
continue;
}
let mut segs = Vec::new();
+ let mut edge_nodes = Vec::new();
+ let mut edge_analytic = Vec::new();
let mut ids = Vec::new();
let mut ptags: Vec<Option<(Piece, bool)>> = Vec::new();
let mut coverage_tags = Vec::new();
@@ -953,18 +1118,21 @@ fn find_profiles_bounded(sk: &Sketch, max_edges: usize) -> Vec<Profile> {
if let Some(v) = visited.get_mut(h) {
*v = true;
}
- let Some((seg, _, to)) = half(h) else {
+ let Some((seg, from, to)) = half(h) else {
ok = false;
break;
};
segs.push(seg);
+ edge_nodes.push((from, to));
if let Some(e) = edges.get(h / 2) {
ids.push(e.id.clone());
ptags.push(e.tag.map(|t| (t, h.is_multiple_of(2))));
coverage_tags.push(e.coverage.map(|t| (t, h.is_multiple_of(2))));
+ edge_analytic.push(e.analytic);
} else {
ptags.push(None);
coverage_tags.push(None);
+ edge_analytic.push(false);
}
let back = (-seg.end_tangent()).angle();
let twin = h ^ 1;
@@ -1007,6 +1175,7 @@ fn find_profiles_bounded(sk: &Sketch, max_edges: usize) -> Vec<Profile> {
if !ok || h != start {
continue;
}
+ let segs = close_graph_joints(segs, &edge_nodes, &edge_analytic, ENDPOINT_JOIN_TOL);
let lp = Loop2 { segs: restore_exact(segs, &ptags, &exact) };
if lp.signed_area() > 1e-9 {
let c = edges.get(start / 2).map(|e| find(&mut comp, e.u)).unwrap_or(0);
diff --git a/crates/sketch/src/tests.rs b/crates/sketch/src/tests.rs
index 55f1d55556..11b19ab606 100644
--- a/crates/sketch/src/tests.rs
+++ b/crates/sketch/src/tests.rs
@@ -357,6 +357,28 @@ fn profile_with_arcs_and_construction_ignored() {
assert_eq!(ps[0].outer_curves.len(), 4);
}
+#[test]
+fn profiles_join_unconstrained_nearby_line_arc_endpoints() {
+ let mut sk = Sketch::new();
+ let bottom_left = sk.add_point(v(0.0, 0.0), None).unwrap();
+ let bottom_right = sk.add_point(v(20.0, 0.0), None).unwrap();
+ let arc_start = sk.add_point(v(20.00004, 5.0 - (25.0_f64 - 0.00004_f64.powi(2)).sqrt()), None).unwrap();
+ let center = sk.add_point(v(20.0, 5.0), None).unwrap();
+ let top_right = sk.add_point(v(20.0, 10.0), None).unwrap();
+ let top_left = sk.add_point(v(0.0, 10.0), None).unwrap();
+ let left_center = sk.add_point(v(0.0, 5.0), None).unwrap();
+
+ sk.add_line_pts(bottom_left, bottom_right, None).unwrap();
+ sk.add_arc(v(20.0, 5.0), sk.points[arc_start].pos, v(20.0, 10.0), [Some(center), Some(arc_start), Some(top_right)], None).unwrap();
+ sk.add_line_pts(top_right, top_left, None).unwrap();
+ sk.add_arc(v(0.0, 5.0), v(0.0, 10.0), v(0.0, 0.0), [Some(left_center), Some(top_left), Some(bottom_left)], None).unwrap();
+
+ let profiles = find_profiles(&sk);
+ assert_eq!(profiles.len(), 1, "{profiles:?}");
+ assert!(profiles[0].region.outer.is_closed(1e-6), "{:?}", profiles[0].region.outer.segs);
+ assert!((profiles[0].area - (200.0 + PI * 25.0)).abs() < 1e-6, "{}", profiles[0].area);
+}
+
#[test]
fn removal_and_references() {
let mut sk = Sketch::new();