The retries in boolean_whole_inner mesh every candidate to compare its volume. A nudged union at the coarse tolerance could come out with a face on a cone whose trim loop ran metres along the cone's continuation (edges up to 12.7 m outside a 155 mm part); meshing it took seconds to minutes per face and once never finished, though its volume (+-1e10 mm3) failed the check anyway. check() first samples the candidate's edges (16 per edge) and discards a candidate with a point further outside the operands' mesh box than 5% of their size (or a non-finite point): no edge of a union, cut or intersection can lie there. The reason goes into the new BooleanDiagnostics::rejected (omitted from JSON when empty). Results of sound candidates are unchanged. On the reporting design the PitchTail join drops from 18.7 s to 4.3 s with the same result; the regression tests synthesize a cone face whose loop runs off its surface. Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
107 lines
5.1 KiB
Rust
107 lines
5.1 KiB
Rust
//! A boolean candidate with a trim loop that runs off its surface is discarded fast (#3020).
|
|
//!
|
|
//! In the design of #3020 a coarse candidate of a nudged union came out with a face on a cone
|
|
//! (a revolved line: its profile parameter bounded to [0, 1], its angle periodic) whose trim
|
|
//! loop left the cone and ran thousands of profile lengths along its continuation, kilometres
|
|
//! from the part. Meshing that face to measure the candidate never finished. Here such a face
|
|
//! is made on purpose: the check finds its edge outside the operands without meshing it.
|
|
|
|
use std::time::{Duration, Instant};
|
|
|
|
use solidcraft_geom::Vec3;
|
|
use truck_modeling::{self as mt, ParametricSurface, builder};
|
|
|
|
use super::{MARGIN, Reach};
|
|
use crate::body::Body;
|
|
|
|
/// The cone of the report: a profile line 2 mm out and 4 mm up from radius 20 mm (its length,
|
|
/// √20 mm, is the |∂S/∂u| measured on the runaway face), turned about Z.
|
|
fn cone() -> mt::Surface {
|
|
let profile = mt::Curve::Line(mt::Line(mt::Point3::new(20.0, 0.0, 0.0), mt::Point3::new(22.0, 0.0, 4.0)));
|
|
mt::Surface::RevolutedCurve(mt::Processor::new(mt::RevolutedCurve::by_revolution(profile, mt::Point3::new(0.0, 0.0, 0.0), mt::Vector3::unit_z())))
|
|
}
|
|
|
|
/// A solid of one face of `surface` bounded by straight edges through `corners`, given in the
|
|
/// surface's parameters and moved `off` mm off it along its normal.
|
|
fn face_body(surface: &mt::Surface, corners: &[(f64, f64, f64)]) -> Body {
|
|
use mt::ParametricSurface3D;
|
|
let vertices: Vec<mt::Vertex> = corners.iter().map(|&(u, v, off)| builder::vertex(surface.subs(u, v) + surface.normal(u, v) * off)).collect();
|
|
let edges: Vec<mt::Edge> = (0..vertices.len()).map(|i| builder::line(&vertices[i], &vertices[(i + 1) % vertices.len()])).collect();
|
|
let face = mt::Face::new(vec![edges.into_iter().collect()], surface.clone());
|
|
let solid = mt::Solid::new_unchecked(vec![vec![face].into()]);
|
|
Body::new(solid).unwrap()
|
|
}
|
|
|
|
/// The operands: a plate and the cone's own patch, which spans u in [0, 1] (radius 20-22 mm,
|
|
/// 4 mm high) over a quarter turn.
|
|
fn operands() -> (Body, Body) {
|
|
let plate = crate::box_solid(Vec3::new(-30.0, -30.0, -6.0), Vec3::new(30.0, 30.0, 0.0)).unwrap();
|
|
let patch = face_body(&cone(), &[(0.0, 0.0, 0.0), (1.0, 0.0, 0.0), (1.0, 1.5, 0.0), (0.0, 1.5, 0.0)]);
|
|
(plate, patch)
|
|
}
|
|
|
|
fn reach(a: &Body, b: &Body) -> Reach {
|
|
let size = a.size().max(b.size());
|
|
let meshes = (a.tessellate_with(size * 5e-4, true).unwrap(), b.tessellate_with(size * 5e-4, true).unwrap());
|
|
Reach::new(a, b, (Some(&meshes.0), Some(&meshes.1)), size).unwrap()
|
|
}
|
|
|
|
/// The runaway face: on the cone, its loop leaves the patch at u = 0 and follows the cone's
|
|
/// continuation out to u = -2450 (as the logged loop did, -2452 … 1349), 1.5 mm off it, and
|
|
/// back.
|
|
fn runaway() -> Body {
|
|
face_body(&cone(), &[(1.0, 0.2, 0.0), (1.0, 1.3, 0.0), (0.0, 1.3, 0.0), (-2450.0, 0.9, 1.5), (-2450.0, 0.6, 1.5), (0.0, 0.2, 0.0)])
|
|
}
|
|
|
|
#[test]
|
|
fn a_candidate_with_a_trim_loop_off_its_surface_is_rejected_fast() {
|
|
let (a, b) = operands();
|
|
let reach = reach(&a, &b);
|
|
let candidate = runaway();
|
|
let start = Instant::now();
|
|
let reason = reach.runaway(&candidate);
|
|
let took = start.elapsed();
|
|
let reason = reason.expect("an edge kilometres outside the operands");
|
|
assert!(reason.contains("outside the operands"), "{reason}");
|
|
assert!(took < Duration::from_secs(1), "{took:?}");
|
|
}
|
|
|
|
#[test]
|
|
fn sound_candidates_stay_within_reach() {
|
|
let (a, b) = operands();
|
|
let reach = reach(&a, &b);
|
|
// The operands themselves, and a union of the plate with a cylinder standing on it.
|
|
assert_eq!(reach.runaway(&a), None);
|
|
assert_eq!(reach.runaway(&b), None);
|
|
let post = crate::cylinder(Vec3::new(0.0, 0.0, -1.0), Vec3::Z, 5.0, 20.0).unwrap();
|
|
let reach = self::reach(&a, &post);
|
|
let union = crate::boolean(&a, &post, crate::BoolOp::Union).unwrap().unwrap();
|
|
assert_eq!(reach.runaway(&union), None);
|
|
}
|
|
|
|
#[test]
|
|
fn an_edge_just_past_the_margin_is_out_of_reach() {
|
|
let (a, b) = operands();
|
|
let size = a.size().max(b.size());
|
|
let reach = reach(&a, &b);
|
|
// A box reaching past the plate's side by twice the margin, and one within it.
|
|
let top = Vec3::new(30.0, 30.0, 0.0);
|
|
let past = crate::box_solid(Vec3::new(0.0, 0.0, -6.0), top + Vec3::X * (2.0 * MARGIN * size)).unwrap();
|
|
let within = crate::box_solid(Vec3::new(0.0, 0.0, -6.0), top + Vec3::X * (0.5 * MARGIN * size)).unwrap();
|
|
assert!(reach.runaway(&past).is_some());
|
|
assert_eq!(reach.runaway(&within), None);
|
|
}
|
|
|
|
/// The bound on a loop's span is in lengths of a bounded parameter's range: a plane's unit box
|
|
/// is only a chart, so a plate thousands of millimetres across (its loops thousands of units
|
|
/// wide) still meshes, as does a long cylinder.
|
|
#[test]
|
|
fn large_faces_still_mesh() {
|
|
let plate = crate::box_solid(Vec3::new(-2500.0, -2500.0, 0.0), Vec3::new(2500.0, 2500.0, 3.0)).unwrap();
|
|
let rod = crate::cylinder(Vec3::ZERO, Vec3::Z, 0.5, 3000.0).unwrap();
|
|
for body in [plate, rod] {
|
|
assert!(!body.tessellate_with(0.05, true).unwrap().triangles.is_empty());
|
|
assert_eq!(body.unmeshed_faces(), 0);
|
|
}
|
|
}
|