* claim: #8284 Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> * Sketch on a face: a round's edges that end a hair apart still close (#8284) Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> * Sketch on a face: test both ends of a rounded loft end to end (#8284) A square lofted to a circle with its side edges rounded, as in the report: a sketch on either end face takes the whole face. Without the fix the circular end fails with "face projection has a branched boundary". Also drops a redundant term from the join tolerance. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
c2e69ed724
commit
bcdee6e0bb
4 files changed
+153
-5
No files matched your search
@@ -309,6 +309,41 @@ fn exact_edges(body: &crate::ModelBody, plane: &Plane, edges: &[usize]) -> Vec<O
|
||||
/// `edges` of `body` projected on `plane`: each exactly ([`exact_edges`]) or fitted to its
|
||||
/// polyline in `mesh`.
|
||||
fn projected_edges(body: &crate::ModelBody, mesh: &Mesh, plane: &Plane, edges: &[usize]) -> Vec<LinkGeom> {
|
||||
let mut out = projected_edges_apart(body, mesh, plane, edges);
|
||||
meet_at_shared_ends(&mut out, order::join_tolerance(mesh));
|
||||
out
|
||||
}
|
||||
|
||||
/// Where curve ends lie within `gap` of each other, moves them onto the first of them. A fitted
|
||||
/// round's edges end a few 1e-5 mm short of their neighbours (#8284); the sketch only shares a
|
||||
/// point between ends 1e-7 apart, and without it the outline has no closed profile.
|
||||
fn meet_at_shared_ends(geom: &mut [LinkGeom], gap: f64) {
|
||||
let mut seen: Vec<Vec2> = Vec::new();
|
||||
let mut snap = |p: &mut Vec2| match seen.iter().find(|q| q.dist(*p) <= gap) {
|
||||
Some(q) => *p = *q,
|
||||
None => seen.push(*p),
|
||||
};
|
||||
for g in geom {
|
||||
match g {
|
||||
LinkGeom::Line(a, b) | LinkGeom::Arc { a, b, .. } | LinkGeom::Conic { a, b, .. } => {
|
||||
snap(a);
|
||||
snap(b);
|
||||
}
|
||||
LinkGeom::Spline { pts, periodic: false, .. } => {
|
||||
if let Some(first) = pts.first_mut() {
|
||||
snap(first);
|
||||
}
|
||||
if let Some(last) = pts.last_mut() {
|
||||
snap(last);
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Each of `edges` projected on its own ([`projected_edges`] without the ends brought together).
|
||||
fn projected_edges_apart(body: &crate::ModelBody, mesh: &Mesh, plane: &Plane, edges: &[usize]) -> Vec<LinkGeom> {
|
||||
let mut out = Vec::new();
|
||||
for (e, exact) in edges.iter().zip(exact_edges(body, plane, edges)) {
|
||||
match exact {
|
||||
|
||||
@@ -9,6 +9,13 @@ use crate::{DocError, Result};
|
||||
|
||||
type Key = (i64, i64, i64);
|
||||
|
||||
/// How far apart two edge ends of `mesh` may be and still meet. A round's fitted edges end a few
|
||||
/// 1e-5 mm short of their neighbours, far more than the tolerance that ranks equal areas (#8284).
|
||||
pub(super) fn join_tolerance(mesh: &Mesh) -> f64 {
|
||||
let diagonal = mesh.bounds().diagonal();
|
||||
(diagonal * 1e-6).max(1e-9)
|
||||
}
|
||||
|
||||
/// Boundary of the picked face as drawn: a closed surface cut into pieces (a cylinder or a
|
||||
/// round's torus in halves) projects as the whole patch, since its seams are hidden.
|
||||
pub(super) fn face_edges(mesh: &Mesh, face: u32, plane: &Plane) -> Result<Vec<usize>> {
|
||||
@@ -53,12 +60,13 @@ fn boundary_edges(mesh: &Mesh, mut edges: Vec<usize>, faces: &BTreeSet<usize>, p
|
||||
let origin = bounds.min;
|
||||
let local_origin = plane.to_local(origin);
|
||||
let tol = (bounds.diagonal() * 1e-8).max(1e-9);
|
||||
if !tol.is_finite() {
|
||||
let join = join_tolerance(mesh);
|
||||
if !tol.is_finite() || !join.is_finite() {
|
||||
return Err(DocError::Invalid("face projection has invalid bounds".into()));
|
||||
}
|
||||
let key = |p: Vec3| -> Key {
|
||||
let p = p - origin;
|
||||
((p.x / tol).round() as i64, (p.y / tol).round() as i64, (p.z / tol).round() as i64)
|
||||
((p.x / join).round() as i64, (p.y / join).round() as i64, (p.z / join).round() as i64)
|
||||
};
|
||||
if edges.iter().any(|e| !mesh.edges.get(*e).is_some_and(|p| p.len() >= 2 && p.iter().all(|p| p.is_finite()))) {
|
||||
return Err(DocError::Invalid("face projection has an invalid boundary edge".into()));
|
||||
@@ -71,6 +79,9 @@ fn boundary_edges(mesh: &Mesh, mut edges: Vec<usize>, faces: &BTreeSet<usize>, p
|
||||
let b: Aabb3 = pts.iter().copied().collect();
|
||||
(key(b.min), key(b.max))
|
||||
};
|
||||
// A round that dies away at a corner leaves an edge from a point to itself: it bounds nothing,
|
||||
// and left in, it reads as a branch where the real edges meet.
|
||||
edges.retain(|e| mesh.edges.get(*e).is_some_and(|p| p.len() > 2 || p.first().zip(p.last()).is_some_and(|(a, b)| a.dist(*b) > join)));
|
||||
edges.sort_by_key(|e| geometry_key(*e));
|
||||
let mut at: BTreeMap<Key, Vec<usize>> = BTreeMap::new();
|
||||
for e in &edges {
|
||||
@@ -107,7 +118,7 @@ fn boundary_edges(mesh: &Mesh, mut edges: Vec<usize>, faces: &BTreeSet<usize>, p
|
||||
*slot = true;
|
||||
}
|
||||
boundary.push(edge);
|
||||
if current.dist(start) <= tol {
|
||||
if current.dist(start) <= join {
|
||||
break;
|
||||
}
|
||||
// Neighbouring quantization cells cover points on either side of a rounding
|
||||
@@ -121,7 +132,7 @@ fn boundary_edges(mesh: &Mesh, mut edges: Vec<usize>, faces: &BTreeSet<usize>, p
|
||||
if let Some(list) = at.get(&cell) {
|
||||
incident.extend(list.iter().copied().filter(|e| {
|
||||
mesh.edges.get(*e).is_some_and(|p| {
|
||||
p.first().is_some_and(|a| a.dist(current) <= tol) || p.last().is_some_and(|b| b.dist(current) <= tol)
|
||||
p.first().is_some_and(|a| a.dist(current) <= join) || p.last().is_some_and(|b| b.dist(current) <= join)
|
||||
})
|
||||
}));
|
||||
}
|
||||
@@ -148,7 +159,7 @@ fn boundary_edges(mesh: &Mesh, mut edges: Vec<usize>, faces: &BTreeSet<usize>, p
|
||||
edge = *next;
|
||||
}
|
||||
boundary.sort_by_key(|e| geometry_key(*e));
|
||||
let closed = current.dist(start) <= tol;
|
||||
let closed = current.dist(start) <= join;
|
||||
if !closed || !twice_area.is_finite() {
|
||||
return Err(DocError::Invalid("face projection has an open or invalid boundary".into()));
|
||||
}
|
||||
@@ -379,6 +390,63 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
/// A 100 mm square whose edges each end `gap` short of the next one's start.
|
||||
fn square_with_gaps(gap: f64) -> Mesh {
|
||||
let corners = [Vec3::new(0., 0., 0.), Vec3::new(100., 0., 0.), Vec3::new(100., 100., 0.), Vec3::new(0., 100., 0.)];
|
||||
let mut mesh = Mesh::default();
|
||||
mesh.positions.extend(corners);
|
||||
for i in 0..4 {
|
||||
let (a, b) = (corners[i], corners[(i + 1) % 4]);
|
||||
let back = (a - b).normalized().unwrap() * gap;
|
||||
mesh.edges.push(vec![a, b + back]);
|
||||
mesh.edge_faces.push(vec![0]);
|
||||
}
|
||||
mesh
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn edges_of_a_round_that_end_a_hair_short_of_their_neighbours_still_close() {
|
||||
// A fitted round's edges end a few 1e-5 mm from the vertex they share (#8284).
|
||||
let mesh = square_with_gaps(3e-5);
|
||||
assert_eq!(face_edges(&mesh, 0, &Plane::XY).unwrap().len(), 4);
|
||||
// A real gap is still an open boundary.
|
||||
let open = square_with_gaps(1e-2);
|
||||
assert!(face_edges(&open, 0, &Plane::XY).unwrap_err().to_string().contains("open"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_edge_from_a_point_to_itself_is_not_a_branch() {
|
||||
// Where a round dies away at a corner, the mesh keeps a zero-length edge there (#8284).
|
||||
let mut mesh = square_with_gaps(0.);
|
||||
for corner in mesh.positions.clone() {
|
||||
mesh.edges.push(vec![corner, corner]);
|
||||
mesh.edge_faces.push(vec![0, 1]);
|
||||
}
|
||||
assert_eq!(face_edges(&mesh, 0, &Plane::XY).unwrap().len(), 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn curve_ends_a_hair_apart_become_one_point_and_distant_ones_stay() {
|
||||
use solidcraft_geom::Vec2;
|
||||
use solidcraft_sketch::LinkGeom;
|
||||
let mut geom = vec![
|
||||
LinkGeom::Line(Vec2::new(0., 0.), Vec2::new(10., 0.)),
|
||||
LinkGeom::Spline {
|
||||
pts: vec![Vec2::new(10. + 3e-5, 2e-5), Vec2::new(11., 1.), Vec2::new(12., 5.)],
|
||||
control: true,
|
||||
degree: 3,
|
||||
periodic: false,
|
||||
},
|
||||
LinkGeom::Line(Vec2::new(12., 5. - 1e-5), Vec2::new(0., 0.1)),
|
||||
];
|
||||
super::super::meet_at_shared_ends(&mut geom, 1e-4);
|
||||
assert_eq!(
|
||||
geom[1],
|
||||
LinkGeom::Spline { pts: vec![Vec2::new(10., 0.), Vec2::new(11., 1.), Vec2::new(12., 5.)], control: true, degree: 3, periodic: false }
|
||||
);
|
||||
assert_eq!(geom[2], LinkGeom::Line(Vec2::new(12., 5.), Vec2::new(0., 0.1)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn incomplete_and_branched_boundaries_are_reported_without_partial_geometry() {
|
||||
let mut open = rectangles();
|
||||
|
||||
@@ -345,6 +345,7 @@ mod primitive_points;
|
||||
mod rim_cut;
|
||||
mod robustness;
|
||||
mod robustness_goldens;
|
||||
mod rounded_loft_face;
|
||||
mod sphere_lens;
|
||||
mod spiral_join;
|
||||
mod step_import_options;
|
||||
|
||||
@@ -0,0 +1,44 @@
|
||||
//! A sketch on an end face of a loft whose side edges are rounded (#8284). The rounds' fitted edges
|
||||
//! end a few 1e-5 mm short of the face's other edges, and where a round dies away at a corner the
|
||||
//! mesh keeps an edge from a point to itself; the face's outline still closes into one profile.
|
||||
|
||||
use solidcraft_geom::Vec3;
|
||||
|
||||
use super::*;
|
||||
|
||||
/// A 40 mm square at z = 0 lofted to a circle of radius 25 at z = 40, its four side edges rounded.
|
||||
fn rounded_loft(s: &mut Session) {
|
||||
run(s, "sketch.create", json!({"plane": "XY", "name": "Square"}));
|
||||
run(s, "sketch.rectangle.two_point", json!({"p0": [-20, -20], "p1": [20, 20]}));
|
||||
run(s, "sketch.finish", json!({}));
|
||||
run(s, "sketch.create", json!({"plane": "XY", "offset": 40, "name": "Circle"}));
|
||||
run(s, "sketch.circle.center", json!({"center": [0, 0], "radius": 25}));
|
||||
run(s, "sketch.finish", json!({}));
|
||||
let section = |name: &str| json!({"sketch": name, "profiles": [{"point": [0, 0]}]});
|
||||
run(s, "solid.loft", json!({"sections": [section("Square"), section("Circle")], "operation": "new", "body_name": "Loft"}));
|
||||
// Each side edge runs from a corner of the square to the circle; pick it halfway up.
|
||||
let mid = (20.0 + 25.0 * std::f64::consts::FRAC_1_SQRT_2) / 2.0;
|
||||
let edges: Vec<Value> = [(1.0, 1.0), (1.0, -1.0), (-1.0, 1.0), (-1.0, -1.0)].iter().map(|(x, y)| json!([x * mid, y * mid, 20])).collect();
|
||||
run(s, "solid.fillet", json!({"edges": edges, "radius": 3}));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_sketch_on_either_end_of_a_rounded_loft_takes_the_whole_face() {
|
||||
let mut s = Session::default();
|
||||
rounded_loft(&mut s);
|
||||
for up in [-1.0, 1.0] {
|
||||
let world = s.world_state();
|
||||
let loft = world.body("Loft").unwrap();
|
||||
let face = loft.body.faces(0.01).unwrap().into_iter().find(|f| f.plane_normal.is_some_and(|n| n.dot(Vec3::Z * up) > 0.999)).unwrap();
|
||||
let pick = json!({"body": "Loft", "index": face.index, "face": [face.centroid.x, face.centroid.y, face.centroid.z]});
|
||||
let id = run(&mut s, "sketch.create", json!({"plane": pick}))["sketch"].as_u64().unwrap();
|
||||
run(&mut s, "sketch.finish", json!({}));
|
||||
let mut s2 = Session::new((*s.doc).clone());
|
||||
run(&mut s2, "solid.extrude", json!({"sketch": id, "distance": 5, "operation": "new", "body_name": "Pad"}));
|
||||
let state = s2.model.state();
|
||||
let pad = state.bodies.iter().find(|b| b.name == "Pad").unwrap();
|
||||
let v = pad.body.tessellate(1e-2).unwrap().measure().volume;
|
||||
// The projected outline fits the round with splines, so it is close to the face, not exact.
|
||||
assert!(rel(v, face.area * 5.0) < 1e-2, "end {up}: {v} vs {}", face.area * 5.0);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user