From 759e22b5824907ad138edd18f43573f3c3dcd54d Mon Sep 17 00:00:00 2001 From: Karl Von Richter Date: Tue, 20 Oct 2026 03:25:02 +0000 Subject: [PATCH] Try exact local cuts after invalid empty numerical results (#1765) (#1858) Two empty numerical cut attempts stopped the boolean retry sequence before the exact geometric strategies ran. When the result guard refuses that empty candidate, the exact strategies (sliced planar, pushed walls, local prism, sphere lens, seam halves) now try the cut first; if none recovers it, the original empty candidate and diagnostics are kept, before any displaced numerical retry. Rebased onto main as one commit (the branch's own changes, its merges of main dropped). The only conflict was the new engine regression test next to main's #1985 STEP export tests in boolean_regression_tests.rs; both are kept. --- crates/engine/src/boolean_regression_tests.rs | 24 ++++++ crates/kernel/src/empty_retry_tests.rs | 83 +++++++++++++++++++ crates/kernel/src/ops.rs | 29 ++++++- .../shallow_cuts_after_earlier_pocket.json | 19 +++++ 4 files changed, 152 insertions(+), 3 deletions(-) create mode 100644 crates/kernel/src/empty_retry_tests.rs create mode 100644 examples/regressions/shallow_cuts_after_earlier_pocket.json diff --git a/crates/engine/src/boolean_regression_tests.rs b/crates/engine/src/boolean_regression_tests.rs index 1b751b81f..59a28da74 100644 --- a/crates/engine/src/boolean_regression_tests.rs +++ b/crates/engine/src/boolean_regression_tests.rs @@ -88,6 +88,30 @@ fn read_back(s: &Session, body: &solidcraft_kernel::Body) -> (String, usize) { (text, back.file_faces) } +/// The timeline insertion from #1765 on a small part with analytic material. The kernel test +/// separately forces the empty numerical attempts, without needing the reporter's design. +#[test] +fn shallow_cuts_rebuild_after_inserting_an_earlier_pocket() { + let s = replay(include_str!("../../../examples/regressions/shallow_cuts_after_earlier_pocket.json")); + let rounded_plate = 40.0 * 30.0 * 10.0 - (4.0 - std::f64::consts::PI) * 40.0; + // Half of each circle overlaps the existing 0.75 mm pocket. + let expected = rounded_plate - 30.0 * 10.0 * 0.75 - 2.0 * std::f64::consts::PI * 25.0 * (1.5 - 0.75 / 2.0); + let reopened = Session::new(solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap()); + for session in [s, reopened] { + assert!(session.model.results.iter().all(|r| r.error.is_none())); + assert_eq!(session.model.state().bodies.len(), 1); + let body = &session.model.state().bodies[0].body; + assert!(body.validity().is_empty(), "{:?}", body.validity()); + let actual = volume(&session, "Plate"); + assert!((actual - expected).abs() < 0.02, "{actual} vs {expected}"); + let mesh = body.tessellate(0.001).unwrap(); + assert!(!mesh.contains(solidcraft_geom::Vec3::new(12.0, 14.0, 9.0))); + assert!(mesh.contains(solidcraft_geom::Vec3::new(12.0, 14.0, 8.0))); + assert!(!mesh.contains(solidcraft_geom::Vec3::new(20.0, 20.0, 9.5))); + assert!(mesh.contains(solidcraft_geom::Vec3::new(20.0, 20.0, 9.0))); + } +} + /// #2059: tabs exactly as wide as their supporting ribs share the ribs' side /// planes. The base's remote conical chamfer must not prevent their join. #[test] diff --git a/crates/kernel/src/empty_retry_tests.rs b/crates/kernel/src/empty_retry_tests.rs new file mode 100644 index 000000000..318bbe87a --- /dev/null +++ b/crates/kernel/src/empty_retry_tests.rs @@ -0,0 +1,83 @@ +//! A shallow circular cut after a pocket (#1765): repeated empty numerical answers must not +//! stop the later geometric strategies. Inject the numerical failure on a real small part; +//! the exact rounding and ray classification of the original design are not available. + +use super::*; +use crate::{box_solid, cylinder, fillet, measure, sphere, step_export, step_import}; +use std::cell::Cell; +use std::f64::consts::PI; + +#[test] +fn shallow_cut_after_a_pocket_recovers_from_empty_numerical_attempts() { + let plate = box_solid(Vec3::ZERO, Vec3::new(40.0, 30.0, 10.0)).unwrap(); + let plate = fillet(&plate, &[Vec3::new(20.0, 0.0, 10.0)], 2.0).unwrap(); + let pocket = box_solid(Vec3::new(5.0, 15.0, 9.25), Vec3::new(35.0, 25.0, 10.25)).unwrap(); + let target = boolean(&plate, &pocket, BoolOp::Cut).unwrap().unwrap(); + let tool = cylinder(Vec3::new(12.0, 15.0, 8.5), Vec3::Z, 5.0, 1.75).unwrap(); + let attempts = Cell::new(0); + let empty = |_: &Body, _: &Body, _: BoolOp, _: Option, _: f64| { + attempts.set(attempts.get() + 1); + Ok((Solid::new_unchecked(Vec::new()), None)) + }; + let (result, diagnostics) = + capture_boolean_diagnostics(|| boolean_via(&target, &tool, BoolOp::Cut, &|a, b, op| boolean_whole_with(a, b, op, false, &empty))); + assert!(attempts.get() >= 2, "the first two numerical tries must really have failed"); + let cut = result.unwrap().expect("a shallow cut leaves the plate"); + assert!(cut.validity().is_empty(), "{:?}", cut.validity()); + assert_eq!(cut.lumps().unwrap().len(), 1); + // Half of the circle overlaps the existing 0.75 mm pocket. + let expected = 40.0 * 30.0 * 10.0 - (4.0 - PI) * 40.0 - 30.0 * 10.0 * 0.75 - PI * 25.0 * (1.5 - 0.75 / 2.0); + let actual = measure(&cut).unwrap().volume; + assert!((actual - expected).abs() < 0.02, "{actual} vs {expected}"); + assert!(diagnostics.events.iter().all(|e| e.strategy != BooleanStrategy::RefinedTolerance)); +} + +#[test] +fn step_seam_cut_recovers_from_empty_numerical_attempts() { + let pin = cylinder(Vec3::new(-5.0, 0.0, 0.0), Vec3::X, 4.5, 10.0).unwrap(); + let target = step_import(&step_export(&[&pin], "seam regression").unwrap()).unwrap().bodies.remove(0).body; + let tool = sphere(Vec3::new(-5.0, 0.0, 0.0), 6.0).unwrap(); + assert!(crate::seam_faces::needed(&target, &tool)); + let attempts = Cell::new(0); + let shifted_attempts = Cell::new(0); + let empty = |_: &Body, _: &Body, _: BoolOp, shift: Option, _: f64| { + attempts.set(attempts.get() + 1); + if shift.is_some() { + shifted_attempts.set(shifted_attempts.get() + 1); + } + Ok((Solid::new_unchecked(Vec::new()), None)) + }; + let (result, diagnostics) = + capture_boolean_diagnostics(|| boolean_via(&target, &tool, BoolOp::Cut, &|a, b, op| boolean_whole_with(a, b, op, false, &empty))); + assert!(attempts.get() >= 2, "the initial numerical tries must really have failed"); + assert_eq!(shifted_attempts.get(), 0, "seam recovery must precede displaced retries"); + let cut = result.unwrap().expect("the spherical cut leaves the end of the pin"); + assert!(cut.validity().is_empty(), "{:?}", cut.validity()); + assert_eq!(cut.lumps().unwrap().len(), 1); + assert!(cut.history().is_some()); + // Along the common axis, integrate min(pi*4.5^2, pi*(6^2-x^2)) from 0 to 6. + let full_radius_end = (6.0_f64.powi(2) - 4.5_f64.powi(2)).sqrt(); + let removed = PI * (4.5_f64.powi(2) * full_radius_end + 36.0 * (6.0 - full_radius_end) - (216.0 - full_radius_end.powi(3)) / 3.0); + let expected = PI * 4.5_f64.powi(2) * 10.0 - removed; + let actual = measure(&cut).unwrap().volume; + assert!((actual - expected).abs() < expected * 1e-3, "{actual} vs {expected}"); + assert!(diagnostics.warning().is_none(), "{:?}", diagnostics.warning()); +} + +#[test] +fn unrecovered_empty_attempts_keep_refusal_without_displacing_tool() { + // These spheres keep fine_tols empty, isolating retries after the exact local strategies. + let target = sphere(Vec3::ZERO, 10.0).unwrap(); + let tool = sphere(Vec3::new(8.0, 0.0, 0.0), 5.0).unwrap(); + let shifted_attempts = Cell::new(0); + let empty = |_: &Body, _: &Body, _: BoolOp, shift: Option, _: f64| { + if shift.is_some() { + shifted_attempts.set(shifted_attempts.get() + 1); + } + Ok((Solid::new_unchecked(Vec::new()), None)) + }; + let result = boolean_via(&target, &tool, BoolOp::Cut, &|a, b, op| boolean_whole_with(a, b, op, false, &empty)); + assert_eq!(shifted_attempts.get(), 0, "unrecovered empty attempts must not enable displaced retries"); + let error = result.unwrap_err(); + assert!(error.to_string().contains("it came out empty"), "{error}"); +} diff --git a/crates/kernel/src/ops.rs b/crates/kernel/src/ops.rs index 865786867..a69977cbb 100644 --- a/crates/kernel/src/ops.rs +++ b/crates/kernel/src/ops.rs @@ -1214,6 +1214,15 @@ fn boolean_whole(a: &Body, b: &Body, op: BoolOp) -> Result> { } fn boolean_whole_with_refinement(a: &Body, b: &Body, op: BoolOp, refine: bool) -> Result> { + boolean_whole_with(a, b, op, refine, &truck_boolean) +} + +/// The whole-body strategies with the numerical intersection supplied separately, so tests +/// can reproduce an empty numerical attempt without depending on a particular ray seed. +fn boolean_whole_with(a: &Body, b: &Body, op: BoolOp, refine: bool, intersect: &F) -> Result> +where + F: Fn(&Body, &Body, BoolOp, Option, f64) -> Result<(Solid, Option)>, +{ if let Some(body) = swept_prism(a, b, op) { return Ok(Some(body)); } @@ -1316,7 +1325,7 @@ fn boolean_whole_with_refinement(a: &Body, b: &Body, op: BoolOp, refine: bool) - // Bounded to two finer meshes; no tool displacement or relaxed acceptance tests. for k in [1e-5, 1e-6] { let tol = (size * k).max(1e-6); - if let Ok((solid, history)) = truck_boolean(a, b, op, None, tol) + if let Ok((solid, history)) = intersect(a, b, op, None, tol) && !solid.boundaries().is_empty() && let Ok(body) = guard("refined boolean result", || recorded::truck_result(solid, history, size, &keep, &counts)) && check(&body).0 @@ -1486,7 +1495,7 @@ fn boolean_whole_with_refinement(a: &Body, b: &Body, op: BoolOp, refine: bool) - for (attempt, j) in JITTER.iter().enumerate().take(2) { let shift = mt::Vector3::new(j[0], j[1], j[2]) * (feature * 0.01); for &tol in &fine_tols { - match truck_boolean(a, b, op, if attempt > 0 { Some(shift) } else { None }, tol) { + match intersect(a, b, op, if attempt > 0 { Some(shift) } else { None }, tol) { Ok((s, _)) if s.boundaries().is_empty() || s.face_iter().next().is_none() => *last = "empty result".into(), Ok((s, h)) => match guard("boolean result", || recorded::truck_result(s, h, size, &keep, &counts)) { Ok(body) => { @@ -1575,10 +1584,17 @@ fn boolean_whole_with_refinement(a: &Body, b: &Body, op: BoolOp, refine: bool) - return Ok(r); } } + // An implausible empty result from the unshifted numerical tries must still give + // the exact strategies above a chance (#1765), including seam-face recovery. If none + // recovers it, keep the original candidate for the outer guard, before displaced retries. + if empty_votes >= 2 && op != BoolOp::Union { + merge(empty_diagnostics); + return Ok(None); + } let shift = mt::Vector3::new(j[0], j[1], j[2]) * (size * 0.01); for k in [2e-3, 5e-4] { let tol = (size * k).max(1e-5); - let r = truck_boolean(a, b, op, if attempt > 0 { Some(shift) } else { None }, tol); + let r = intersect(a, b, op, if attempt > 0 { Some(shift) } else { None }, tol); match r { Ok((s, _)) if s.boundaries().is_empty() || s.face_iter().next().is_none() => { empty_votes += 1; @@ -1622,6 +1638,9 @@ fn boolean_whole_with_refinement(a: &Body, b: &Body, op: BoolOp, refine: bool) - if let Some(body) = fine(&mut last) { return Ok(Some(body)); } + if attempt == 0 && crate::boolean_guard::check_retry(a, b, op, None).is_err() { + continue; + } merge(empty_diagnostics); return Ok(None); } @@ -2339,6 +2358,10 @@ pub(crate) fn half_box(body: &Body, plane: &solidcraft_geom::Plane, positive: bo crate::build::extrude(plane, std::slice::from_ref(&sq), lo, hi)?.pop().ok_or_else(|| KernelError::Failed("half space".into())) } +#[cfg(test)] +#[path = "empty_retry_tests.rs"] +mod empty_retry_tests; + #[cfg(test)] #[path = "prism_fast_path_tests.rs"] mod prism_fast_path_tests; diff --git a/examples/regressions/shallow_cuts_after_earlier_pocket.json b/examples/regressions/shallow_cuts_after_earlier_pocket.json new file mode 100644 index 000000000..1ba14c351 --- /dev/null +++ b/examples/regressions/shallow_cuts_after_earlier_pocket.json @@ -0,0 +1,19 @@ +{ + "description": "Public-safe companion for #1765: a 40 x 30 x 10 plate with a 2 mm round on its top-front edge and two radius-5 circular cuts 1.5 mm deep. Roll back before the circles, insert a 30 x 10 pocket 0.75 mm deep across their upper halves, restore the timeline and redefine the circular cut. This part checks the rebuild and analytic material; empty numerical attempts are injected separately in the kernel regression, since the original design is unavailable.", + "commands": [ + {"command": "solid.box", "params": {"length": 40, "width": 30, "height": 10, "body_name": "Plate", "name": "Plate"}}, + {"command": "solid.fillet", "params": {"edges": [[20, 0, 10]], "radius": 2, "name": "Rim"}}, + {"command": "sketch.create", "params": {"plane": "XY", "offset": 10, "name": "Circles"}}, + {"command": "sketch.circle.center", "params": {"center": [12, 15], "radius": 5}}, + {"command": "sketch.circle.center", "params": {"center": [28, 15], "radius": 5}}, + {"command": "sketch.finish", "params": {}}, + {"command": "solid.extrude", "params": {"sketch": "Circles", "distance": -1.5, "operation": "cut", "name": "ShallowCuts"}}, + {"command": "timeline.rollback", "params": {"position": 2}}, + {"command": "sketch.create", "params": {"plane": "XY", "offset": 10, "name": "PocketOutline"}}, + {"command": "sketch.rectangle.two_point", "params": {"p0": [5, 15], "p1": [35, 25]}}, + {"command": "sketch.finish", "params": {}}, + {"command": "solid.extrude", "params": {"sketch": "PocketOutline", "distance": -0.75, "operation": "cut", "name": "EarlierPocket"}}, + {"command": "timeline.rollback", "params": {}}, + {"command": "timeline.redefine", "params": {"feature": "ShallowCuts", "command": "solid.extrude", "params": {"sketch": "Circles", "profiles": [0, 1], "distance": "-1.5", "direction": "positive", "convention": "total_distance", "operation": "cut"}}} + ] +}