diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rs index 8533da1e7..ca2c70104 100644 --- a/crates/doc/src/eval.rs +++ b/crates/doc/src/eval.rs @@ -465,7 +465,12 @@ fn thread_on_impl( let (body, cyl) = st .bodies .iter() - .filter_map(|b| kernel::cylinder_face_at(&b.body, p).map(|c| (b.name.clone(), c))) + .filter(|b| !more::beyond_cylinder_reach(b, p)) + .filter_map(|b| { + #[cfg(test)] + cost_tests::count(|c| c.cylinder_search += 1); + kernel::cylinder_face_at(&b.body, p).map(|c| (b.name.clone(), c)) + }) .min_by(|a, b| { let dist = |c: &kernel::CylinderFace| ((p - c.axis_point - c.axis * (p - c.axis_point).dot(c.axis)).len() - c.radius).abs(); dist(&a.1).total_cmp(&dist(&b.1)) @@ -3308,10 +3313,29 @@ fn apply_traced_with( let affected: std::collections::BTreeMap = target_idx.iter().filter_map(|i| state.bodies.get(*i)).map(|b| (b.name.clone(), b.body.lumps().map_or(1, |l| l.len()))).collect(); let mut remove = Vec::new(); + // A cut hands a body its tools cannot reach back as it was, but only after a whole + // boolean: in a design of many bodies that was most of a hole's time (#10225). Such a + // body is left as it is. Its box and the tools' are their meshes' grown past how far + // the exact faces can curve out from them (a dome rises above the outline of its + // edges), so a tool that touches a body, or only comes near it, still meets it in the + // boolean. A body shown in another frame, and a mesh body, are cut as before; an + // intersect removes the bodies it misses, and is left as it was. + let reach: Option>> = + (op == Operation::Cut && !tools.iter().any(|t| t.body.is_mesh())).then(|| tools.iter().map(|t| more::body_box(&t.body)).collect()); for &ti in &target_idx { let Some(mut acc) = state.bodies.get(ti).map(|b| Some(b.traced())) else { continue }; // The tools meet the target where it is shown: in its frame (#3383). let into = state.bodies.get(ti).and_then(|b| tool_frame(&b.name)); + if let (Some(reach), None, Some(mb)) = (&reach, into, state.bodies.get(ti)) + && !reach.is_empty() + && !mb.body.is_mesh() + && let Some(target) = more::mesh_box(mb) + && reach.iter().all(|tool| more::boxes_apart(&Some(target), tool)) + { + continue; + } + #[cfg(test)] + cost_tests::count(|c| c.cut += 1); for t in &tools { let t = &tool_in(t, into)?; acc = match acc { diff --git a/crates/doc/src/eval_cost_tests.rs b/crates/doc/src/eval_cost_tests.rs index a851e33b9..7cbaa0025 100644 --- a/crates/doc/src/eval_cost_tests.rs +++ b/crates/doc/src/eval_cost_tests.rs @@ -16,7 +16,8 @@ use crate::eval::{PlacementReads, body_world, hash_placement, placement_digest}; use crate::*; /// Work counted on this thread: bodies moved, STEP texts digested, joint faces and bodies -/// measured, bodies searched for by name, features searched for by id. +/// measured, bodies searched for by name, features searched for by id, bodies a cut (or +/// intersect) ran its booleans on, and bodies searched for the cylinder a tap marking lies on. #[derive(Clone, Copy, Debug, Default, PartialEq)] pub(super) struct Counts { pub moved: usize, @@ -25,11 +26,23 @@ pub(super) struct Counts { pub measures: usize, pub body_searches: usize, pub feature_searches: usize, + pub cut: usize, + pub cylinder_search: usize, } thread_local! { - static COUNTS: Cell = - const { Cell::new(Counts { moved: 0, digested: 0, joint_faces: 0, measures: 0, body_searches: 0, feature_searches: 0 }) }; + static COUNTS: Cell = const { + Cell::new(Counts { + moved: 0, + digested: 0, + joint_faces: 0, + measures: 0, + body_searches: 0, + feature_searches: 0, + cut: 0, + cylinder_search: 0, + }) + }; } pub(super) fn count(f: impl FnOnce(&mut Counts)) { @@ -1083,3 +1096,251 @@ fn a_placed_tap_follows_its_body_offset() { apply_point(&mat_mul(&doc.component_transform(comp), &rigid(Vec3::new(0.0, 0.0, 7.0), Vec3::ZERO, Vec3::Z, 0.0)), Vec3::new(1.0, 1.0, 0.0)); assert!(tap.axis_point.dist(expected) < 1e-9, "{:?} {expected:?}", tap.axis_point); } + +/// What adding a feature of `kind` at the end of `doc` did to the bodies already there: how many +/// its cut ran booleans on, and which it left exactly as they were (the same geometry, its name, +/// key and face names carried over). A cut that cannot reach a body hands it back as it was, and +/// must not pay a whole boolean to find that out (#10225); the sheet metal hole (#10226) and the +/// cosmetic thread (#10227) check their own shortcuts with it too. +pub(super) struct CutWork { + pub cut: usize, + pub kept: Vec, + pub model: Model, +} + +pub(super) fn cut_work(doc: &mut Document, kind: FeatureKind) -> CutWork { + let mut model = Model::new(); + model.evaluate(doc); + let id = doc.add_feature(kind, None).unwrap(); + let work = counted(|| model.evaluate(doc)); + let result = model.result(id).unwrap(); + assert_eq!(result.error, None, "the feature builds"); + let before = model.state_before(id); + let kept = result + .state + .bodies + .iter() + .filter(|b| { + before + .body(&b.name) + .is_some_and(|old| old.body.same(&b.body) && old.key == b.key && crate::naming::face_names(old) == crate::naming::face_names(b)) + }) + .map(|b| b.name.clone()) + .collect(); + CutWork { cut: work.cut, kept, model } +} + +/// A box body named `name`, `size` long on each side from `corner`. +fn block(doc: &mut Document, name: &str, corner: Vec3, size: [f64; 3]) { + let id = doc + .add_feature( + FeatureKind::Box { + corner: point_expr(corner), + length: size[0].to_string().into(), + width: size[1].to_string().into(), + height: size[2].to_string().into(), + operation: Operation::NewBody, + }, + None, + ) + .unwrap(); + doc.feature_mut(id).unwrap().body_names = vec![name.into()]; +} + +/// A cylinder that cuts, standing on `base` along Z. +fn cutter(base: Vec3, radius: f64, height: f64) -> FeatureKind { + FeatureKind::Cylinder { + base: point_expr(base), + axis: Dir(Vec3::Z), + radius: radius.to_string().into(), + height: height.to_string().into(), + operation: Operation::Cut, + references: Vec::new(), + } +} + +/// A cut leaves the bodies its tool cannot reach as they were, without a boolean on each: in a +/// design of many bodies those booleans were most of a hole's time (#10225). +#[test] +fn a_cut_leaves_bodies_it_cannot_reach_as_they_were() { + let mut doc = Document::new("far"); + block(&mut doc, "Near", Vec3::ZERO, [50.0, 40.0, 30.0]); + // 0.5 mm clear of the tool, and far off. + block(&mut doc, "Beside", Vec3::new(13.5, 0.0, 0.0), [20.0, 40.0, 30.0]); + for i in 0..5 { + block(&mut doc, &format!("Far{i}"), Vec3::new(200.0 * (i + 1) as f64, 0.0, 0.0), [50.0, 40.0, 30.0]); + } + // Near and Beside overlap; the hole goes through Near only, beside Beside. + let work = cut_work(&mut doc, cutter(Vec3::new(10.0, 20.0, -5.0), 3.0, 40.0)); + assert_eq!(work.cut, 1, "only the body the tool reaches goes through the boolean"); + assert_eq!(work.kept, ["Beside", "Far0", "Far1", "Far2", "Far3", "Far4"]); + assert!(volume(&work.model, "Near") < 60_000.0 - 800.0, "and it is cut"); +} + +/// A cut still goes through the boolean wherever its tool reaches a body or comes close: on a +/// face, along a line, a hair beside it, into a dome above its edge circle. (Bodies its tool +/// cannot reach are left out of it: `a_cut_leaves_bodies_it_cannot_reach_as_they_were`.) +#[test] +fn a_cut_still_runs_where_its_tool_touches_grazes_or_meets_a_curved_face() { + // A cylinder whose side is tangent to the face x = 50, one a hair clear of it, one 0.1 mm in. + for (x, cuts) in [(53.0, false), (53.0005, false), (52.9, true)] { + let mut doc = Document::new("graze"); + block(&mut doc, "A", Vec3::ZERO, [50.0, 40.0, 30.0]); + let work = cut_work(&mut doc, cutter(Vec3::new(x, 20.0, 0.0), 3.0, 30.0)); + assert_eq!(work.cut, 1, "the tool at x = {x} goes through the boolean"); + let v = volume(&work.model, "A"); + assert_eq!(v < 60_000.0 - 1.0, cuts, "the tool at x = {x} cuts material: {v}"); + assert!(!cuts || work.kept.is_empty(), "a body cut is a new body"); + } + // A box meeting the block only along its top edge. + let mut doc = Document::new("edge"); + block(&mut doc, "A", Vec3::ZERO, [50.0, 40.0, 30.0]); + let along = FeatureKind::Box { + corner: point_expr(Vec3::new(50.0, 0.0, 30.0)), + length: "10".into(), + width: "40".into(), + height: "10".into(), + operation: Operation::Cut, + }; + assert_eq!(cut_work(&mut doc, along).cut, 1); + // A dome: a sphere's cap rising 10 mm above the circle it stands on. A thin tool drilled into + // its top near the apex, well above that circle, cuts it. + let mut doc = Document::new("dome"); + doc.add_feature(FeatureKind::Sphere { center: point_expr(Vec3::new(0.0, 0.0, -10.0)), radius: "20".into(), operation: Operation::NewBody }, None) + .unwrap(); + let below = FeatureKind::Box { + corner: point_expr(Vec3::new(-30.0, -30.0, -40.0)), + length: "60".into(), + width: "60".into(), + height: "40".into(), + operation: Operation::Cut, + }; + doc.add_feature(below, None).unwrap(); + let mut model = Model::new(); + model.evaluate(&doc); + let dome = model.state().bodies[0].name.clone(); + let whole = volume(&model, &dome); + let work = cut_work(&mut doc, cutter(Vec3::new(2.0, 1.0, 8.0), 1.0, 5.0)); + assert_eq!(work.cut, 1); + assert!(volume(&work.model, &dome) < whole - 1.0, "the drill cuts into the dome"); + assert!(work.kept.is_empty()); +} + +/// A cylinder body named `name` standing on `base` along Z. +fn shaft(doc: &mut Document, name: &str, base: Vec3, radius: f64, height: f64) { + let id = doc + .add_feature( + FeatureKind::Cylinder { + base: point_expr(base), + axis: Dir(Vec3::Z), + radius: radius.to_string().into(), + height: height.to_string().into(), + operation: Operation::NewBody, + references: Vec::new(), + }, + None, + ) + .unwrap(); + doc.feature_mut(id).unwrap().body_names = vec![name.into()]; +} + +/// The work of adding `kind` at the end of `doc`, and the tap markings the design then has. +fn marking_work(doc: &mut Document, kind: FeatureKind) -> (Counts, Vec) { + let mut model = Model::new(); + model.evaluate(doc); + let id = doc.add_feature(kind, None).unwrap(); + let work = counted(|| model.evaluate(doc)); + assert_eq!(model.result(id).unwrap().error, None, "the feature builds"); + (work, model.state().threads.clone()) +} + +/// A cosmetic tap marking at `p`. +fn marking(p: Vec3) -> FeatureKind { + FeatureKind::Thread { face: FacePick(p), designation: Some("M6".into()), length: None, modeled: false, handedness: ThreadHandedness::Right } +} + +/// A tap marking looks for its cylinder in the bodies near it only: each body searched was +/// tessellated again, so many markings in a design of many bodies took quadratic time (#10227). +#[test] +fn a_tap_marking_searches_only_the_bodies_near_it() { + let mut doc = Document::new("far"); + shaft(&mut doc, "Shaft", Vec3::ZERO, 3.0, 6.0); + for i in 0..5 { + block(&mut doc, &format!("Far{i}"), Vec3::new(200.0 * (i + 1) as f64, 0.0, 0.0), [50.0, 40.0, 30.0]); + } + let (work, threads) = marking_work(&mut doc, marking(Vec3::new(3.0, 0.0, 3.0))); + assert_eq!(work.cylinder_search, 1, "only the shaft is searched"); + assert_eq!(threads.len(), 1); + assert_eq!(threads[0].body, "Shaft"); + assert_eq!(threads[0].designation, "M6"); + assert!((threads[0].radius - 3.0).abs() < 1e-6 && !threads[0].internal); + + // A tapped hole in a plate among far bodies: only the plate is searched for its wall. + let mut doc = Document::new("tapped"); + block(&mut doc, "Plate", Vec3::ZERO, [60.0, 60.0, 12.0]); + for i in 0..5 { + block(&mut doc, &format!("Far{i}"), Vec3::new(200.0 * (i + 1) as f64, 0.0, 0.0), [50.0, 40.0, 30.0]); + } + let hole = FeatureKind::Hole { + position: FacePick(Vec3::new(30.0, 30.0, 12.0)), + at: None, + direction: Dir(-Vec3::Z), + diameter: "5".into(), + depth: Some("10".into()), + hole: HoleKind::default(), + points: None, + thread: Some("M6".into()), + thread_depth: None, + handedness: ThreadHandedness::Right, + to: None, + references: Vec::new(), + }; + let (work, threads) = marking_work(&mut doc, hole); + assert_eq!(work.cylinder_search, 1, "only the plate is searched"); + assert_eq!(threads.len(), 1); + assert_eq!(threads[0].body, "Plate"); + assert!(threads[0].internal && (threads[0].radius - 2.5).abs() < 1e-6); +} + +/// Bodies within reach of a tap marking are still searched: the shaft it lies on, a block 3 mm +/// off (within a twentieth of the block's size, where the cylinder search itself looks), and one +/// 3.6 mm off (just past it, but within the margin the boxes keep); a block 4.5 mm off is not. +/// The marking stays on the shaft. +#[test] +fn a_tap_marking_still_searches_the_bodies_within_its_reach() { + let mut doc = Document::new("near"); + shaft(&mut doc, "Shaft", Vec3::ZERO, 3.0, 6.0); + // Each block is 50 x 40 x 30 (a twentieth of its size is 3.54 mm), its face x = 3 + gap. + for (name, gap) in [("Close", 3.0), ("Edge", 3.6), ("Clear", 4.5)] { + block(&mut doc, name, Vec3::new(3.0 + gap, -20.0, 0.0), [50.0, 40.0, 30.0]); + } + let (work, threads) = marking_work(&mut doc, marking(Vec3::new(3.0, 0.0, 3.0))); + assert_eq!(work.cylinder_search, 3, "the shaft, Close and Edge are searched"); + assert_eq!(threads.len(), 1); + assert_eq!(threads[0].body, "Shaft"); + + // A pin in a hole a hair wider: a marking on the pin, and one on the hole's wall. + for (p, body, internal) in [(Vec3::new(2.0, 0.0, 5.0), "Pin", false), (Vec3::new(2.5, 0.0, 5.0), "Plate", true)] { + let mut doc = Document::new("pin"); + block(&mut doc, "Plate", Vec3::new(-20.0, -20.0, 0.0), [40.0, 40.0, 10.0]); + let bore = FeatureKind::Cylinder { + base: point_expr(Vec3::new(0.0, 0.0, -1.0)), + axis: Dir(Vec3::Z), + radius: "2.5".into(), + height: "12".into(), + operation: Operation::Cut, + references: Vec::new(), + }; + doc.add_feature(bore, None).unwrap(); + shaft(&mut doc, "Pin", Vec3::ZERO, 2.0, 10.0); + let mut kind = marking(p); + if let FeatureKind::Thread { designation, .. } = &mut kind { + *designation = None; + } + let (work, threads) = marking_work(&mut doc, kind); + assert_eq!(work.cylinder_search, 2, "both bodies are searched for {body}"); + assert_eq!(threads.len(), 1); + assert_eq!(threads[0].body, body); + assert_eq!(threads[0].internal, internal); + } +} diff --git a/crates/doc/src/eval_more.rs b/crates/doc/src/eval_more.rs index 1b0f2e17d..8a81b4f2b 100644 --- a/crates/doc/src/eval_more.rs +++ b/crates/doc/src/eval_more.rs @@ -1569,13 +1569,13 @@ fn sheet_prism_cut( /// A box around `body`, grown past its mesh's deflection from the exact faces (and a hair /// more): bodies whose boxes are apart do not meet. None when it can't be worked out. -fn body_box(body: &Body) -> Option { +pub(super) fn body_box(body: &Body) -> Option { let tol = (body.size() * 1e-3).max(1e-4); padded_box(&body.tessellate(tol).ok()?, tol) } /// [`body_box`] of a model body, from the mesh it keeps. -fn mesh_box(mb: &ModelBody) -> Option { +pub(super) fn mesh_box(mb: &ModelBody) -> Option { padded_box(&mb.mesh(), mb.display_tol()) } @@ -1584,8 +1584,25 @@ fn padded_box(mesh: &solidcraft_geom::Mesh, tol: f64) -> Option { (!b.is_empty() && b.min.is_finite() && b.max.is_finite()).then(|| b.inflated(2.0 * tol + 1e-6)) } +/// Whether [`kernel::cylinder_face_at`] is known to find no face of `mb` at `p`. It takes a +/// face only when its own mesh of the body comes within a twentieth of the body's size of the +/// point. That mesh lies in the body's box ([`mesh_box`]) give or take its own deflection, which +/// the reach allows for, so a box farther away than that holds no face for it. Working that out from the mesh the body keeps +/// spares a tessellation of every body in the design for each tap marking (#10227). A mesh +/// body, and a body whose box is unknown, are searched as before. +pub(super) fn beyond_cylinder_reach(mb: &ModelBody, p: Vec3) -> bool { + if mb.body.is_mesh() { + return false; + } + let Some(b) = mesh_box(mb) else { return false }; + let size = mb.body.size(); + let reach = size * 0.05 + 2.0 * (size * 1e-3).max(1e-3); + let off = (b.min - p).max(p - b.max).max(Vec3::ZERO); + off.len() > reach +} + /// Whether two boxes are known to be apart (an unknown box is never apart). -fn boxes_apart(a: &Option, b: &Option) -> bool { +pub(super) fn boxes_apart(a: &Option, b: &Option) -> bool { let (Some(a), Some(b)) = (a, b) else { return false }; a.max.x < b.min.x || b.max.x < a.min.x || a.max.y < b.min.y || b.max.y < a.min.y || a.max.z < b.min.z || b.max.z < a.min.z }