Skip to content

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

Hole: placing a hole is faster in assemblies with many parts (#7175)

Robson Pereiraa1d2b6d05b71
diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rs
index 1f6c2a326a..322e25c555 100644
--- a/crates/doc/src/eval.rs
+++ b/crates/doc/src/eval.rs
@@ -3703,6 +3703,27 @@ fn body_at(st: &ModelState, body: &Option<crate::BodyName>, points: &[Vec3]) ->
.ok_or_else(|| DocError::Invalid("there is no body".into()))
}
+/// Whether the whole line through `p` along `dir` (both ways) meets the box (slab test). A zero
+/// component of `dir` keeps the line in its slab only when `p` is already within it.
+fn line_meets_box(p: Vec3, dir: Vec3, b: &solidcraft_geom::Aabb3) -> bool {
+ if b.is_empty() {
+ return false;
+ }
+ let (mut lo, mut hi) = (f64::NEG_INFINITY, f64::INFINITY);
+ for (o, d, min, max) in [(p.x, dir.x, b.min.x, b.max.x), (p.y, dir.y, b.min.y, b.max.y), (p.z, dir.z, b.min.z, b.max.z)] {
+ if d == 0.0 || !d.is_finite() {
+ if !(min..=max).contains(&o) {
+ return false;
+ }
+ continue;
+ }
+ let (t0, t1) = ((min - o) / d, (max - o) / d);
+ lo = lo.max(t0.min(t1));
+ hi = hi.min(t0.max(t1));
+ }
+ lo <= hi
+}
+
/// A hole stays on its face when the model changes: a position now inside a body moves back
/// against the drilling direction to the surface, one now above it moves down onto it. Only the
/// bodies in `scope` count (every body when it is empty, see [`hole_scope`]). Edit Hole seeds from
@@ -3713,6 +3734,12 @@ pub fn hole_on_surface(st: &ModelState, p: Vec3, dir: Vec3, scope: &[String]) ->
let mut best: Option<Vec3> = None;
for b in st.bodies.iter().filter(|b| in_hole_scope(scope, b)) {
let m = b.mesh();
+ // Every test below casts along the line through `p`: a mesh whose box that line misses
+ // has no triangle to hit, so skip it before scanning its triangles (in an assembly of
+ // hundreds of parts, these scans were most of a hole's time).
+ if !line_meets_box(p, dir, &m.bounds().inflated(eps * 8.0)) {
+ continue;
+ }
// Already on the surface: the drill enters right here.
if let Some((t, _)) = m.raycast(p - dir * eps, dir)
&& t < eps * 4.0
@@ -3729,15 +3756,18 @@ pub fn hole_on_surface(st: &ModelState, p: Vec3, dir: Vec3, scope: &[String]) ->
best.unwrap_or(p)
}
-/// The faces of the model near `p`: for each, how far `p` is from it, the outward normal there
-/// (the surface's own normal for planes, cylinders and spheres, turned the way the face looks out
-/// of its body; the nearest mesh facet's otherwise) and, for a plane, how far `p` is from the
-/// plane itself. Only faces within `reach` of `p`, nearest first, of the bodies in `scope`
-/// (every body when it is empty).
-fn faces_through(st: &ModelState, p: Vec3, reach: f64, scope: &[String]) -> Vec<(f64, Vec3, Option<f64>)> {
- let mut out: Vec<(f64, Vec3, Option<f64>)> = Vec::new();
- for b in st.bodies.iter().filter(|b| !b.body.is_mesh() && in_hole_scope(scope, b)) {
+/// The faces of the model near `p`, nearest first, before their surfaces are looked at: for
+/// each, how far `p` is from it, its body, its index and the outward normal of its nearest mesh
+/// facet. Only faces within `reach` of `p`, of the bodies in `scope` (every body when it is
+/// empty). Ties keep body order, then face order.
+fn faces_near(st: &ModelState, p: Vec3, reach: f64, scope: &[String]) -> Vec<NearFace> {
+ let mut out: Vec<NearFace> = Vec::new();
+ for (i, b) in st.bodies.iter().enumerate().filter(|(_, b)| !b.body.is_mesh() && in_hole_scope(scope, b)) {
let m = b.mesh();
+ // No facet is nearer `p` than the mesh's box: one beyond `reach` has none to give.
+ if !m.bounds().inflated(reach).contains(p) {
+ continue;
+ }
// The nearest facet of each face of this body.
let mut near: BTreeMap<u32, (f64, Vec3)> = BTreeMap::new();
for (t, f) in m.triangles.iter().zip(&m.tri_face) {
@@ -3748,53 +3778,67 @@ fn faces_through(st: &ModelState, p: Vec3, reach: f64, scope: &[String]) -> Vec<
near.insert(*f, (d, n));
}
}
- for (f, (d, facet)) in near {
- let (exact, off) = match kernel::face_surface(&b.body, f as usize) {
- Some(kernel::FaceSurface::Plane { normal, point }) => (Some(*normal), Some((p - point).dot(normal).abs())),
- Some(kernel::FaceSurface::Cylinder { origin, axis, .. }) => {
- let v = p - origin;
- ((v - axis * v.dot(axis)).normalized(), None)
- }
- Some(kernel::FaceSurface::Sphere { center, .. }) => ((p - center).normalized(), None),
- // Square to the line through the apex, not the nearest facet's normal (#10698).
- Some(kernel::FaceSurface::Cone { apex, axis, half_angle }) => {
- let v = p - apex;
- let out = (v - axis * v.dot(axis)).normalized();
- (out.and_then(|u| (u * half_angle.cos() - axis * half_angle.sin()).normalized()), None)
- }
- // Away from the nearest point of the ring the tube goes round.
- Some(kernel::FaceSurface::Torus { center, axis, major, .. }) => {
- let v = p - center;
- let ring = (v - axis * v.dot(axis)).normalized().map(|u| center + u * major);
- (ring.and_then(|q| (p - q).normalized()), None)
- }
- _ => (None, None),
- };
- let n = match exact {
- Some(n) if n.dot(facet) < 0.0 => -n,
- Some(n) => n,
- None => facet,
- };
- out.push((d, n, off));
- }
+ out.extend(near.into_iter().map(|(f, (d, n))| (d, i, f, n)));
}
out.sort_by(|a, b| a.0.total_cmp(&b.0));
out
}
-/// The faces near `p` a hole placed there goes by (as [`faces_through`]): those of the bodies in
+/// A face of [`faces_near`]: its distance from the point, its body, its index and the outward
+/// normal of its nearest mesh facet.
+type NearFace = (f64, usize, u32, Vec3);
+
+/// One face of [`faces_near`] as [`faces_through`] gives it: the distance, the outward normal
+/// (the surface's own normal for planes, cylinders, spheres, cones and tori, turned the way the
+/// face looks out of its body; the nearest mesh facet's otherwise) and, for a plane, how far `p`
+/// is from the plane itself. Classifying the surface is the costly part, so callers that stop at
+/// the first face that answers them ask for no more than that.
+fn face_through(st: &ModelState, p: Vec3, (d, body, f, facet): NearFace) -> (f64, Vec3, Option<f64>) {
+ #[cfg(test)]
+ cost_tests::count(|c| c.surfaces += 1);
+ let exact = st.bodies.get(body).and_then(|b| kernel::face_surface(&b.body, f as usize));
+ let (exact, off) = match exact {
+ Some(kernel::FaceSurface::Plane { normal, point }) => (Some(*normal), Some((p - point).dot(normal).abs())),
+ Some(kernel::FaceSurface::Cylinder { origin, axis, .. }) => {
+ let v = p - origin;
+ ((v - axis * v.dot(axis)).normalized(), None)
+ }
+ Some(kernel::FaceSurface::Sphere { center, .. }) => ((p - center).normalized(), None),
+ // Square to the line through the apex, not the nearest facet's normal (#10698).
+ Some(kernel::FaceSurface::Cone { apex, axis, half_angle }) => {
+ let v = p - apex;
+ let out = (v - axis * v.dot(axis)).normalized();
+ (out.and_then(|u| (u * half_angle.cos() - axis * half_angle.sin()).normalized()), None)
+ }
+ // Away from the nearest point of the ring the tube goes round.
+ Some(kernel::FaceSurface::Torus { center, axis, major, .. }) => {
+ let v = p - center;
+ let ring = (v - axis * v.dot(axis)).normalized().map(|u| center + u * major);
+ (ring.and_then(|q| (p - q).normalized()), None)
+ }
+ _ => (None, None),
+ };
+ let n = match exact {
+ Some(n) if n.dot(facet) < 0.0 => -n,
+ Some(n) => n,
+ None => facet,
+ };
+ (d, n, off)
+}
+
+/// The faces near `p` a hole placed there goes by (as [`faces_near`]): those of the bodies in
/// `scope`, the hole's own, when one of them passes within `on` of `p`, else those of every body.
/// Where a plate's face touches another body both faces pass through `p`, and a hole that drills
/// the plate goes by the plate's face, never the other body's (#12066). A hole placed on another
/// body's face, to drill through it into its own body behind, still goes by that face.
-fn hole_faces_through(st: &ModelState, p: Vec3, reach: f64, on: f64, scope: &[String]) -> Vec<(f64, Vec3, Option<f64>)> {
+fn hole_faces_near(st: &ModelState, p: Vec3, reach: f64, on: f64, scope: &[String]) -> Vec<NearFace> {
if !scope.is_empty() {
- let own = faces_through(st, p, reach, scope);
- if own.first().is_some_and(|(d, _, _)| *d <= on) {
+ let own = faces_near(st, p, reach, scope);
+ if own.first().is_some_and(|c| c.0 <= on) {
return own;
}
}
- faces_through(st, p, reach, &[])
+ faces_near(st, p, reach, &[])
}
/// The way a hole placed at `p` drills: into the material, against the outward normal of the
@@ -3804,17 +3848,22 @@ fn hole_faces_through(st: &ModelState, p: Vec3, reach: f64, on: f64, scope: &[St
/// of the bodies in `scope` (the bodies the hole drills; empty for every body) decide.
pub fn hole_direction_at(st: &ModelState, p: Vec3, scope: &[String]) -> Option<Vec3> {
let size = st.bodies.iter().map(|b| b.body.size()).fold(1.0, f64::max);
- let faces = hole_faces_through(st, p, f64::INFINITY, size * 1e-4, scope);
- if let Some((d, n, _)) = faces.first()
- && *d <= size * 1e-4
+ // Every face of the model, nearest first; each surface is classified only when the rules
+ // below reach it. Classifying all of them first took most of a hole's time in an assembly
+ // of hundreds of parts, where the nearest face nearly always answers.
+ let near = hole_faces_near(st, p, f64::INFINITY, size * 1e-4, scope);
+ let mut faces = near.iter().map(|c| face_through(st, p, *c));
+ let first = faces.next();
+ if let Some((d, n, _)) = first
+ && d <= size * 1e-4
{
- return Some(-*n);
+ return Some(-n);
}
- if let Some((_, n, _)) = faces.iter().find(|(_, _, off)| off.is_some_and(|o| o <= size * 1e-4)) {
- return Some(-*n);
+ if let Some((_, n, _)) = first.into_iter().chain(faces).find(|(_, _, off)| off.is_some_and(|o| o <= size * 1e-4)) {
+ return Some(-n);
}
let reach = st.bodies.iter().map(crate::appearance::pick_tolerance).fold(0.0, f64::max);
- faces.first().filter(|(d, _, _)| *d <= reach).map(|(_, n, _)| -*n)
+ first.filter(|(d, _, _)| *d <= reach).map(|(_, n, _)| -n)
}
/// A hole placed on a face drills into the material: when its direction leaves every face it
@@ -3827,7 +3876,7 @@ pub fn hole_direction_at(st: &ModelState, p: Vec3, scope: &[String]) -> Option<V
/// the plate there, drills the plate (#12066).
fn hole_dir_into_face(st: &ModelState, p: Vec3, dir: Vec3, scope: &[String]) -> Vec3 {
let size = st.bodies.iter().map(|b| b.body.size()).fold(1.0, f64::max);
- let faces = hole_faces_through(st, p, size * 1e-5, size * 1e-5, scope);
+ let faces: Vec<_> = hole_faces_near(st, p, size * 1e-5, size * 1e-5, scope).into_iter().map(|c| face_through(st, p, c)).collect();
if faces.is_empty() || faces.iter().any(|(_, n, _)| n.dot(dir) < -1e-9) {
return dir;
}
diff --git a/crates/doc/src/eval_cost_tests.rs b/crates/doc/src/eval_cost_tests.rs
index 3ac7b436e0..9e9c3df0f1 100644
--- a/crates/doc/src/eval_cost_tests.rs
+++ b/crates/doc/src/eval_cost_tests.rs
@@ -21,7 +21,7 @@ use crate::*;
/// intersect) ran its booleans on, bodies searched for the cylinder a tap marking lies on,
/// bodies whose faces a tapped hole read for its wall, intersects run to find a pattern's copies
/// that cut nothing, and the tools a cut of many tools is made with (one when they are cut in one
-/// go).
+/// go), and face surfaces classified for a hole's direction.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub(super) struct Counts {
pub moved: usize,
@@ -36,6 +36,7 @@ pub(super) struct Counts {
pub tapped_wall: usize,
pub miss_intersects: usize,
pub cut_tools: usize,
+ pub surfaces: usize,
}
thread_local! {
@@ -53,6 +54,7 @@ thread_local! {
tapped_wall: 0,
miss_intersects: 0,
cut_tools: 0,
+ surfaces: 0,
})
};
}
@@ -1786,3 +1788,51 @@ fn an_added_and_deleted_sketch_entity_keeps_its_fingerprint() {
assert_eq!(model.state().sketch_keys.get(&id).copied(), key);
assert_eq!((model.last_recomputed, model.last_restored), (0, 0));
}
+
+#[test]
+fn a_hole_skips_the_parts_its_line_cannot_reach() {
+ use solidcraft_geom::Aabb3;
+ let unit = Aabb3 { min: Vec3::ZERO, max: Vec3::new(1.0, 1.0, 1.0) };
+ // Down through the box, from above and from below (the line runs both ways).
+ assert!(super::line_meets_box(Vec3::new(0.5, 0.5, 5.0), Vec3::new(0.0, 0.0, -1.0), &unit));
+ assert!(super::line_meets_box(Vec3::new(0.5, 0.5, -5.0), Vec3::new(0.0, 0.0, -1.0), &unit));
+ // Beside it, parallel to a side: a zero direction component keeps the line out of the slab.
+ assert!(!super::line_meets_box(Vec3::new(2.0, 0.5, 5.0), Vec3::new(0.0, 0.0, -1.0), &unit));
+ // Slanted past a corner, and slanted through it.
+ assert!(!super::line_meets_box(Vec3::new(3.0, 0.0, 0.0), Vec3::new(1.0, 1.0, 0.0), &unit));
+ assert!(super::line_meets_box(Vec3::new(-1.0, -1.0, 0.5), Vec3::new(1.0, 1.0, 0.0), &unit));
+ // Touching a face counts; an empty box never meets.
+ assert!(super::line_meets_box(Vec3::new(1.0, 0.5, 9.0), Vec3::new(0.0, 0.0, 1.0), &unit));
+ assert!(!super::line_meets_box(Vec3::new(0.5, 0.5, 0.5), Vec3::new(0.0, 0.0, 1.0), &Aabb3::EMPTY));
+}
+
+#[test]
+fn a_hole_classifies_the_faces_it_reads_not_every_face_of_the_design() {
+ // Forty separate cylinders, three faces each. A hole placed on the top of one drills down,
+ // and finding that out reads the nearest face only: it used to classify every face of every
+ // body first, which in an assembly of hundreds of imported parts took seconds per hole.
+ let mut doc = Document::new("hole direction work");
+ for k in 0..40 {
+ let kind = FeatureKind::Cylinder {
+ base: point_expr(Vec3::new(10.0 * f64::from(k), 0.0, 0.0)),
+ axis: Dir(Vec3::Z),
+ radius: "2".into(),
+ height: "10".into(),
+ operation: Operation::NewBody,
+ references: Vec::new(),
+ };
+ doc.add_feature(kind, None).unwrap();
+ }
+ let mut model = Model::new();
+ model.evaluate(&doc);
+ let st = model.state();
+ assert_eq!(st.bodies.len(), 40);
+ let mut dir = None;
+ let work = counted(|| dir = super::hole_direction_at(&st, Vec3::new(250.5, 0.5, 10.0), &[]));
+ let dir = dir.unwrap();
+ assert!((dir - Vec3::new(0.0, 0.0, -1.0)).len() < 1e-9, "drills down into the top: {dir:?}");
+ assert!(work.surfaces <= 2, "classified {} face surfaces for one hole", work.surfaces);
+ // A point on a side wall drills into that wall.
+ let side = super::hole_direction_at(&st, Vec3::new(252.0, 0.0, 5.0), &[]).unwrap();
+ assert!((side - Vec3::new(-1.0, 0.0, 0.0)).len() < 1e-6, "into the side wall: {side:?}");
+}
diff --git a/xtask/mesh-decisions.txt b/xtask/mesh-decisions.txt
index 6e9c285ace..b2296084d2 100644
--- a/xtask/mesh-decisions.txt
+++ b/xtask/mesh-decisions.txt
@@ -15,7 +15,7 @@ crates/doc/src/eval.rs:edge_refs turns edge picks into references through the di
crates/doc/src/eval.rs:eval_feature places features by the display mesh (faces, edges, nearness)
crates/doc/src/eval.rs:face_plane finds a sketch's face plane again on a mesh
crates/doc/src/eval.rs:face_samples takes a point on each face from its mesh triangles
-crates/doc/src/eval.rs:faces_through finds the faces near a point and their normals by the display mesh
+crates/doc/src/eval.rs:faces_near finds the faces near a point by the display mesh
crates/doc/src/eval.rs:feature_tools_with_constructor reaches a To Object extent by the display mesh
crates/doc/src/eval.rs:height_at measures a point's height on a face by the display mesh
crates/doc/src/eval.rs:hole_axis_size sizes a hole's tools by the bodies its axis meets on the display mesh