Wave 196/509: kernel: the test target compiles: the last tests on the record and SMLib (and 3 more)
4 commits, squashed; the originals stay reachable from tag archive/merge-main-develop. -2a09b9943jyviko: kernel: the test target compiles: the last tests on the record and SMLib -2f83aaa5djyviko: kernel: clippy's own fixes across the kernel (needless borrows, assign ops, contains) -f6afec8eajyviko: kernel: dead code left by the port deleted; clippy -D warnings clean on all targets -a0e17daa5jyviko: kernel: cargo fmt Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
This commit is contained in:
1 parent
8291eff436
commit
460f7fa0f7
27 files changed
+162
-197
No files matched your search
@@ -11,7 +11,7 @@
|
||||
//! normal, as the record does.
|
||||
|
||||
use solidcraft_geom::Vec3;
|
||||
use solidcraft_geom::brep::eval::{CurveEval, SurfaceEval};
|
||||
use solidcraft_geom::brep::eval::CurveEval;
|
||||
use solidcraft_geom::brep::pcurve::{EdgeUse, pcurves_within};
|
||||
use solidcraft_geom::brep::{Brep, Curve, Curve2, Edge, Face, Loop, Natural, OrientedEdge, OrientedFace, Region, Shell, Surface, VERSION, Vertex};
|
||||
|
||||
@@ -129,18 +129,6 @@ impl Assembly {
|
||||
Ok(Assembly { tolerance: b.tolerance, vertices: b.vertices.clone(), edges, faces, regions: b.regions.clone(), shells: b.shells.len() })
|
||||
}
|
||||
|
||||
/// An empty sheet to build faces into: one open shell (shell 0) in the infinite region.
|
||||
pub(crate) fn sheet(tolerance: f64) -> Assembly {
|
||||
Assembly {
|
||||
tolerance,
|
||||
vertices: Vec::new(),
|
||||
edges: Vec::new(),
|
||||
faces: Vec::new(),
|
||||
regions: vec![Region { shells: vec![0], void: false }],
|
||||
shells: 1,
|
||||
}
|
||||
}
|
||||
|
||||
/// A new vertex at `p`.
|
||||
pub(crate) fn vertex(&mut self, p: Vec3) -> Result<u32> {
|
||||
if !p.is_finite() {
|
||||
@@ -397,13 +385,3 @@ pub(crate) fn natural_out(b: &Brep, face: usize) -> Option<bool> {
|
||||
_ => None,
|
||||
})
|
||||
}
|
||||
|
||||
/// The outward unit normal of face `face` of `b` at the parameters of `p`, a point on it.
|
||||
pub(crate) fn outward_normal(b: &Brep, face: usize, p: Vec3) -> Option<Vec3> {
|
||||
let f = b.faces.get(face)?;
|
||||
let s = SurfaceEval::new(&f.surface).ok()?;
|
||||
let uv = s.project(p, None, f64::INFINITY)?;
|
||||
let (_, su, sv) = s.derivs(uv[0], uv[1])?;
|
||||
let n = su.cross(sv).normalized()?;
|
||||
Some(if natural_out(b, face)? { n } else { -n })
|
||||
}
|
||||
@@ -116,7 +116,7 @@ impl Faces {
|
||||
|
||||
/// The unit direction into planar face `f` across the straight edge of `u`, square to the
|
||||
/// edge: the face lies to the left of its loop seen from its surface's natural normal.
|
||||
pub(crate) fn into_face(&self, f: usize, u: &OrientedEdge) -> Option<Vec3> {
|
||||
pub(crate) fn direction_into_face(&self, f: usize, u: &OrientedEdge) -> Option<Vec3> {
|
||||
let (a, b) = self.ends(u.edge as usize)?;
|
||||
let dir = if u.forward { b - a } else { a - b };
|
||||
self.natural_plane_normal(f)?.cross(dir.normalized()?).normalized()
|
||||
@@ -167,7 +167,7 @@ pub(crate) fn curve_derivative(c: &Curve, t: f64) -> Option<Vec3> {
|
||||
let (_, su, sv) = e.derivs(uv[0], uv[1])?;
|
||||
Some(su.cross(sv))
|
||||
};
|
||||
let along = normal(&*surfaces[0])?.cross(normal(&*surfaces[1])?);
|
||||
let along = normal(&surfaces[0])?.cross(normal(&surfaces[1])?);
|
||||
let along = along.normalized()?;
|
||||
if along.dot(curve_tangent(leader, t)?) < 0.0 { along * -1.0 } else { along }
|
||||
}
|
||||
|
||||
@@ -322,7 +322,7 @@ fn frame(rec: &Faces, e: usize) -> Option<Frame> {
|
||||
if !uses.is_empty() {
|
||||
return None;
|
||||
}
|
||||
beside.push((n, rec.into_face(i, u)?));
|
||||
beside.push((n, rec.direction_into_face(i, u)?));
|
||||
chained |= rec.uses(i).filter(|x| x.edge as usize != e).any(|x| {
|
||||
let Some(other) = rec.rec.edges.get(x.edge as usize) else { return false };
|
||||
let [a, b] = other.vertices;
|
||||
|
||||
@@ -34,7 +34,7 @@ fn edge_frame(rec: &Faces, e: usize) -> Result<EdgeFrame> {
|
||||
if uses.next().is_some() {
|
||||
return None;
|
||||
}
|
||||
rec.into_face(f, u)
|
||||
rec.direction_into_face(f, u)
|
||||
};
|
||||
let (Some(t1), Some(t2)) = (into(i1), into(i2)) else { return Err(KernelError::Failed("blend: edge direction".into())) };
|
||||
let phi = t1.dot(t2).clamp(-1.0, 1.0).acos();
|
||||
|
||||
@@ -310,15 +310,15 @@ fn trivial_paths() {
|
||||
assert!(h.faces.iter().all(|f| f.change == Change::Kept));
|
||||
}
|
||||
|
||||
/// A body in two pieces, cut a piece at a time: each piece's faces are the body's own.
|
||||
/// A body in two pieces, cut: each piece's faces are the body's own.
|
||||
#[test]
|
||||
fn by_lumps_composes_the_pieces() {
|
||||
fn a_cut_of_two_pieces_composes_the_pieces() {
|
||||
let left = boxed(0.0, 0.0, 0.0, 10.0, 10.0, 10.0);
|
||||
let right = boxed(20.0, 0.0, 0.0, 30.0, 10.0, 10.0);
|
||||
let a = boolean(&left, &right, BoolOp::Union).unwrap().unwrap();
|
||||
assert_eq!(a.shell_count(), 2);
|
||||
let b = crate::sphere(Vec3::new(15.0, 5.0, 10.0), 7.0).unwrap();
|
||||
let r = crate::ops::by_lumps(&a, &b, a.lumps().unwrap(), b.lumps().unwrap(), BoolOp::Cut).unwrap().unwrap();
|
||||
let r = boolean(&a, &b, BoolOp::Cut).unwrap().unwrap();
|
||||
let h = verified(&r, &[&a, &b], 0.02);
|
||||
// Both pieces are bitten: the sphere's patches inside each line its bite.
|
||||
let bites: BTreeSet<_> = h.faces.iter().flat_map(|f| &f.origins).filter(|o| matches!(o, FaceOrigin::Face { operand: 1, .. })).collect();
|
||||
@@ -327,54 +327,6 @@ fn by_lumps_composes_the_pieces() {
|
||||
assert_eq!(targets.len(), 12);
|
||||
}
|
||||
|
||||
/// Two bodies touching along one whole face, back to back: glued, the two faces gone, the
|
||||
/// coplanar sides each side of the seam merged.
|
||||
#[test]
|
||||
fn glue_merges_across_the_seam() {
|
||||
let a = boxed(0.0, 0.0, 0.0, 10.0, 10.0, 10.0);
|
||||
let b = boxed(10.0, 0.0, 0.0, 20.0, 10.0, 10.0);
|
||||
let r = crate::coplanar::glue(&a, &b).unwrap().unwrap();
|
||||
let h = verified(&r, &[&a, &b], 0.02);
|
||||
assert_eq!(changes(h), [2, 0, 0, 4, 0], "{}", show(h));
|
||||
// The four seam edges went with the merged faces; the ends' edges are each box's.
|
||||
assert_eq!(h.edges.len(), 12);
|
||||
assert!(h.edges.iter().all(|e| !e.origins.is_empty()));
|
||||
}
|
||||
|
||||
/// Coincident faces pushed apart: a cut flush with the target's top, and a union of bodies
|
||||
/// standing on one floor (the floor that is cut back is both operands' floors).
|
||||
#[test]
|
||||
fn faces_pushed_apart() {
|
||||
let a = boxed(0.0, 0.0, 0.0, 10.0, 10.0, 10.0);
|
||||
let tool = boxed(2.0, 2.0, 5.0, 8.0, 8.0, 10.0);
|
||||
let r = crate::coplanar::boolean_apart(&a, &tool, BoolOp::Cut).unwrap().unwrap().unwrap();
|
||||
let h = verified(&r, &[&a, &tool], 0.02);
|
||||
// The pocket: its floor and four sides are the tool's.
|
||||
let tool_faces: BTreeSet<_> = h.faces.iter().flat_map(|f| &f.origins).filter(|o| matches!(o, FaceOrigin::Face { operand: 1, .. })).collect();
|
||||
assert_eq!(tool_faces.len(), 5, "{}", show(h));
|
||||
let left = boxed(0.0, 0.0, 0.0, 10.0, 10.0, 10.0);
|
||||
let right = boxed(5.0, 3.0, 0.0, 15.0, 7.0, 4.0);
|
||||
let r = crate::coplanar::boolean_apart(&left, &right, BoolOp::Union).unwrap().unwrap().unwrap();
|
||||
let h = verified(&r, &[&left, &right], 0.02);
|
||||
assert!(h.faces.iter().any(|f| f.change == Change::Merged && f.origins.len() == 2), "{}", show(h));
|
||||
}
|
||||
|
||||
/// The exact polygon boolean: pieces of planar faces joined back into faces.
|
||||
#[test]
|
||||
fn planar_fallback() {
|
||||
let a = boxed(0.0, 0.0, 0.0, 10.0, 10.0, 10.0);
|
||||
let b = boxed(5.0, 5.0, 5.0, 15.0, 15.0, 15.0);
|
||||
for (op, count) in [(BoolOp::Cut, 9), (BoolOp::Union, 12), (BoolOp::Intersect, 6)] {
|
||||
let r = crate::polybool::planar_boolean(&a, &b, op).unwrap().unwrap();
|
||||
let h = verified(&r, &[&a, &b], 0.02);
|
||||
assert_eq!(h.faces.len(), count, "{op:?}\n{}", show(h));
|
||||
assert!(h.faces.iter().all(|f| f.origins.len() == 1));
|
||||
// Three faces of each meet three of the other's.
|
||||
assert_eq!(meets(h).len(), 6, "{op:?}\n{}", show(h));
|
||||
assert!(h.edges.iter().all(|e| e.origins.len() == 1), "{op:?}\n{}", show(h));
|
||||
}
|
||||
}
|
||||
|
||||
/// A boolean with a triangle mesh: the mesh's faces are its triangles (and it has no edges).
|
||||
#[test]
|
||||
fn faceted_tool() {
|
||||
@@ -433,24 +385,6 @@ fn regularized_step_cut() {
|
||||
assert_eq!(faces_of(h), faces_of(ph), "{}", show(h));
|
||||
}
|
||||
|
||||
/// A ring joined under a floor, its bore on the floor's hole (coincident cylinders): the ring's
|
||||
/// bore is narrowed, the bodies joined, and the bore cut out again. The ring's bore is a circle
|
||||
/// built in two arcs, and the recut wall is split where the cutting cylinder's own construction
|
||||
/// splits it, so which arc each piece of it restores is not known: no history.
|
||||
#[test]
|
||||
fn bore_union_of_a_bore_in_two_arcs_has_no_history() {
|
||||
let hole = crate::cylinder(Vec3::new(50.0, 40.0, -5.0), Vec3::Z, 10.0, 30.0).unwrap();
|
||||
let floor = boolean(&boxed(0.0, 0.0, 0.0, 100.0, 80.0, 10.0), &hole, BoolOp::Cut).unwrap().unwrap();
|
||||
let centre = solidcraft_geom::Vec2::new(50.0, 40.0);
|
||||
let annulus = solidcraft_geom::Region2 {
|
||||
outer: solidcraft_geom::Loop2::circle(centre, 20.0),
|
||||
holes: vec![solidcraft_geom::Loop2::circle(centre, 10.0).reversed()],
|
||||
};
|
||||
let ring = crate::extrude(&solidcraft_geom::Plane::XY, &[annulus], -5.0, 2.0).unwrap().remove(0);
|
||||
let r = crate::coplanar::bore_union(&floor, &ring, &|_| true).expect("the bores are recut");
|
||||
assert!(r.history().is_none());
|
||||
}
|
||||
|
||||
/// Bodies clearly apart, joined as one body of several pieces (`union_apart`): every face and
|
||||
/// edge is its piece's own, kept.
|
||||
#[test]
|
||||
|
||||
@@ -210,8 +210,13 @@ fn too_large_or_unsupported_is_refused() {
|
||||
let tilted = crate::build::cylinder(Vec3::new(0.0, 0.0, -10.0), Vec3::new(1.0, 0.0, 2.0), 5.0, 40.0).unwrap();
|
||||
let cut = box_solid(Vec3::new(-50.0, -50.0, 10.0), Vec3::new(50.0, 50.0, 50.0)).unwrap();
|
||||
let t = boolean(&tilted, &cut, BoolOp::Cut).unwrap().unwrap();
|
||||
let solid = t.deep_copy();
|
||||
let rim = crate::body::Body::unique_edges(&solid).iter().filter_map(crate::blend::edge_mid).find(|m| (m.z - 10.0).abs() < 1e-6).unwrap();
|
||||
let rim = t
|
||||
.record()
|
||||
.edges
|
||||
.iter()
|
||||
.filter_map(|e| solidcraft_geom::brep::eval::CurveEval::new(&e.curve).ok()?.point(0.5 * (e.interval[0] + e.interval[1])))
|
||||
.find(|m| (m.z - 10.0).abs() < 1e-6)
|
||||
.unwrap();
|
||||
match chamfer_sides(&t, &[rim], 1.0, ChamferSide::Distance(2.0), false) {
|
||||
Err(KernelError::Failed(m)) => assert!(m.starts_with("not supported yet"), "{m}"),
|
||||
Err(e) => panic!("{e}"),
|
||||
|
||||
@@ -25,20 +25,19 @@ fn channel() -> Body {
|
||||
box_solid(Vec3::new(-20.0, 30.0, 10.0), Vec3::new(220.0, 70.0, 20.0)).unwrap()
|
||||
}
|
||||
|
||||
/// What the boolean of `a` and `b` adds to a's volume, the result's lumps, and how it was made.
|
||||
fn change(a: &Body, b: &Body, op: BoolOp) -> (f64, usize, BooleanDiagnostics) {
|
||||
let (r, how) = capture_boolean_diagnostics(|| boolean(a, b, op));
|
||||
let r = r.unwrap().unwrap();
|
||||
(measure(&r).unwrap().volume - measure(a).unwrap().volume, r.lumps().unwrap().len(), how)
|
||||
/// What the boolean of `a` and `b` adds to a's volume, and the result's lumps.
|
||||
fn change(a: &Body, b: &Body, op: BoolOp) -> (f64, usize) {
|
||||
let r = boolean(a, b, op).unwrap().unwrap();
|
||||
(measure(&r).unwrap().volume - measure(a).unwrap().volume, r.lumps().unwrap().len())
|
||||
}
|
||||
|
||||
/// A channel cut along a block, up to the face a rib stands on. The channel's top lies in
|
||||
/// that face's plane and the rib bridges it.
|
||||
#[test]
|
||||
fn a_cut_up_to_a_face_leaves_what_stands_on_the_face() {
|
||||
let (added, lumps, how) = change(&ribbed(), &channel(), BoolOp::Cut);
|
||||
let (added, lumps) = change(&ribbed(), &channel(), BoolOp::Cut);
|
||||
// It takes 200 x 40 x 10 of the block and nothing of the rib.
|
||||
assert!((added + 80_000.0).abs() < 1e-6 && lumps == 1, "{added}, {lumps} lumps, {how:?}");
|
||||
assert!((added + 80_000.0).abs() < 1e-6 && lumps == 1, "{added}, {lumps} lumps");
|
||||
}
|
||||
|
||||
/// The same with a round hole through the block beside the channel (r 4 at 30, 15: y 11 to
|
||||
@@ -48,9 +47,9 @@ fn a_cut_up_to_a_face_leaves_what_stands_on_the_face() {
|
||||
fn a_round_hole_beside_the_cut_changes_nothing() {
|
||||
let hole = cylinder(Vec3::new(30.0, 15.0, -1.0), Vec3::Z, 4.0, 22.0).unwrap();
|
||||
let drilled = boolean(&ribbed(), &hole, BoolOp::Cut).unwrap().unwrap();
|
||||
let (added, lumps, how) = change(&drilled, &channel(), BoolOp::Cut);
|
||||
let (added, lumps) = change(&drilled, &channel(), BoolOp::Cut);
|
||||
// 200 x 40 x 10 again (the hole is measured on its mesh, before and after).
|
||||
assert!((added + 80_000.0).abs() < 1e-3 && lumps == 1, "{added}, {lumps} lumps, {how:?}");
|
||||
assert!((added + 80_000.0).abs() < 1e-3 && lumps == 1, "{added}, {lumps} lumps");
|
||||
}
|
||||
|
||||
/// A pocket whose top lies in the plane of the block's top face, and a pad whose foot does.
|
||||
@@ -59,12 +58,12 @@ fn faces_in_a_common_plane_cut_and_join() {
|
||||
let block = block(200.0, 100.0, 20.0);
|
||||
// A pocket 50 x 60 x 5 from the top face: 15 000 less.
|
||||
let pocket = box_solid(Vec3::new(75.0, 20.0, 15.0), Vec3::new(125.0, 80.0, 20.0)).unwrap();
|
||||
let (added, _, how) = change(&block, &pocket, BoolOp::Cut);
|
||||
assert!((added + 15_000.0).abs() < 1e-6, "{added}, {how:?}");
|
||||
let (added, _) = change(&block, &pocket, BoolOp::Cut);
|
||||
assert!((added + 15_000.0).abs() < 1e-6, "{added}");
|
||||
// A pad 50 x 60 x 10 on the top face: 30 000 more.
|
||||
let pad = box_solid(Vec3::new(75.0, 20.0, 20.0), Vec3::new(125.0, 80.0, 30.0)).unwrap();
|
||||
let (added, lumps, how) = change(&block, &pad, BoolOp::Union);
|
||||
assert!((added - 30_000.0).abs() < 1e-6 && lumps == 1, "{added}, {how:?}");
|
||||
let (added, lumps) = change(&block, &pad, BoolOp::Union);
|
||||
assert!((added - 30_000.0).abs() < 1e-6 && lumps == 1, "{added}");
|
||||
}
|
||||
|
||||
/// A disc joined into a round hole it fills (issue: "boolean Union: no result" for a 1 mm
|
||||
@@ -78,10 +77,9 @@ fn a_disc_joined_into_the_hole_it_fills() {
|
||||
for (z0, z1) in [(0.0, 1.0), (5.0, 8.0), (19.0, 20.0)] {
|
||||
let disc = cylinder(Vec3::new(150.0, 50.0, z0), Vec3::Z, 20.0, z1 - z0).unwrap();
|
||||
let want = measure(&disc).unwrap().volume;
|
||||
let (r, how) = capture_boolean_diagnostics(|| boolean(&drilled, &disc, BoolOp::Union));
|
||||
let r = r.unwrap().unwrap();
|
||||
let r = boolean(&drilled, &disc, BoolOp::Union).unwrap().unwrap();
|
||||
let added = measure(&r).unwrap().volume - measure(&drilled).unwrap().volume;
|
||||
assert!((added - want).abs() < want * 1e-3, "{z0}..{z1}: {added} vs {want}, {how:?}");
|
||||
assert!((added - want).abs() < want * 1e-3, "{z0}..{z1}: {added} vs {want}");
|
||||
assert!(r.lumps().unwrap().len() == 1 && r.validity().is_empty(), "{z0}..{z1}: {:?}", r.validity());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -485,7 +485,7 @@ fn newell(ring: &[Vec3]) -> Option<Vec3> {
|
||||
let mut s = Vec3::ZERO;
|
||||
for i in 0..n {
|
||||
let (a, b) = (*ring.get(i)?, *ring.get((i + 1) % n)?);
|
||||
s = s + a.cross(b);
|
||||
s += a.cross(b);
|
||||
}
|
||||
s.normalized()
|
||||
}
|
||||
|
||||
@@ -155,13 +155,13 @@ fn general_fill(
|
||||
// Where a G1/G2 edge's neighbour and the one before disagree at their corner.
|
||||
let n = chain.len();
|
||||
let mut clash = vec![false; n];
|
||||
for k in 0..n {
|
||||
for (k, slot) in clash.iter_mut().enumerate() {
|
||||
let prev = (k + n - 1) % n;
|
||||
let (Some(Some(a)), Some(Some(b))) = (beside.get(prev), beside.get(k)) else { continue };
|
||||
let (Some(ea), Some(eb)) = (edges.get(prev), edges.get(k)) else { continue };
|
||||
let (end, start) = (ea.knots.last().copied().unwrap_or(0.0), eb.knots.first().copied().unwrap_or(0.0));
|
||||
if let (Some(x), Some(y)) = (a.across(record, end)?, b.across(record, start)?) {
|
||||
clash[k] = x.normal.dot(y.normal).abs() < (2.0 * PATCH_ANGLE_TOL_DEG).to_radians().cos();
|
||||
*slot = x.normal.dot(y.normal).abs() < (2.0 * PATCH_ANGLE_TOL_DEG).to_radians().cos();
|
||||
}
|
||||
}
|
||||
let mut across = |k: usize, ts: &[f64]| -> std::result::Result<Vec<Option<Across>>, String> {
|
||||
|
||||
@@ -66,7 +66,7 @@ fn substitute_a_body_made_from_a_sketch() {
|
||||
#[test]
|
||||
fn bodies_without_reported_history_have_none() {
|
||||
let a = box_solid(Vec3::ZERO, Vec3::new(4.0, 3.0, 1.0)).unwrap();
|
||||
let bare = Body::new(a.deep_copy()).unwrap();
|
||||
let bare = Body::from_record(a.record().clone()).unwrap();
|
||||
assert!(bare.history().is_none());
|
||||
}
|
||||
|
||||
|
||||
@@ -311,9 +311,9 @@ fn shell(w: &mut W, b: &Brep, si: u32, paint: &HashMap<usize, [f32; 3]>) -> Resu
|
||||
None => {
|
||||
let e = b.edges.get(u.edge as usize).ok_or_else(|| failed(format!("edge {}: no such edge", u.edge)))?;
|
||||
for v in e.vertices {
|
||||
if !vidx.contains_key(&v) {
|
||||
if let std::collections::hash_map::Entry::Vacant(e) = vidx.entry(v) {
|
||||
let p = b.vertices.get(v as usize).ok_or_else(|| failed(format!("vertex {v}: no such vertex")))?.point;
|
||||
vidx.insert(v, verts.len());
|
||||
e.insert(verts.len());
|
||||
verts.push(p);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -15,9 +15,8 @@ fn rect(x0: f64, y0: f64, x1: f64, y1: f64, z0: f64, z1: f64) -> Body {
|
||||
box_solid(Vec3::new(x0, y0, z0), Vec3::new(x1, y1, z1)).unwrap()
|
||||
}
|
||||
|
||||
fn fused(a: &Body, b: &Body) -> (Body, BooleanDiagnostics) {
|
||||
let (r, d) = capture_boolean_diagnostics(|| boolean(a, b, BoolOp::Union));
|
||||
(r.unwrap().unwrap(), d)
|
||||
fn fused(a: &Body, b: &Body) -> Body {
|
||||
boolean(a, b, BoolOp::Union).unwrap().unwrap()
|
||||
}
|
||||
|
||||
fn assert_one_solid(r: &Body, volume: f64, tol: f64, what: &str) {
|
||||
@@ -34,9 +33,8 @@ fn two_ls_up_and_down_fuse_into_one_solid() {
|
||||
let up = prism(&[[-10., -10.], [10., -10.], [10., 0.], [0., 0.], [0., 10.], [-10., 10.]], 0., 10.);
|
||||
let down = prism(&[[-10., 10.], [-10., 0.], [0., 0.], [0., -10.], [10., -10.], [10., 10.]], -10., 0.);
|
||||
for (a, b) in [(&up, &down), (&down, &up)] {
|
||||
let (r, d) = fused(a, b);
|
||||
let r = fused(a, b);
|
||||
assert_one_solid(&r, 6000.0, 1e-6, "#679");
|
||||
assert!(!d.events.iter().any(|e| e.strategy == BooleanStrategy::ToolNudge), "{d:?}");
|
||||
// Two tops, two bottoms, the two cells left open at z = 0, six sides.
|
||||
assert_eq!(r.face_count(), 12);
|
||||
}
|
||||
@@ -51,12 +49,12 @@ fn several_contact_regions_and_edge_contact() {
|
||||
let ups = boolean(&up, &up2, BoolOp::Union).unwrap().unwrap();
|
||||
// Down under both up cells, and under one more.
|
||||
let down = prism(&[[-10., -10.], [0., -10.], [0., 0.], [10., 0.], [10., 10.], [-10., 10.]], -5., 0.);
|
||||
let (r, _) = fused(&ups, &down);
|
||||
let r = fused(&ups, &down);
|
||||
assert_one_solid(&r, 2.0 * 640.0 + 3.0 * 500.0, 1e-6, "two contacts");
|
||||
// Down under one up cell and beside the other: one face contact and one edge contact.
|
||||
// A plate under one block, flush with two of its sides and running on past the third.
|
||||
let down = rect(-10., -10., -2., 5., -5., 0.);
|
||||
let (r, _) = fused(&up, &down);
|
||||
let r = fused(&up, &down);
|
||||
assert_one_solid(&r, 640.0 + 8.0 * 15.0 * 5.0, 1e-6, "contact and flush sides");
|
||||
}
|
||||
|
||||
@@ -71,9 +69,8 @@ fn a_pad_half_past_the_edge_of_its_face_fuses() {
|
||||
let want = measure(&block).unwrap().volume + measure(&pad).unwrap().volume;
|
||||
assert!((want - (25.0 * 47.5 * 37.5 + std::f64::consts::PI * 25.0 * 2.5)).abs() < 0.1);
|
||||
for (a, b) in [(&block, &pad), (&pad, &block)] {
|
||||
let (r, d) = fused(a, b);
|
||||
let r = fused(a, b);
|
||||
assert_one_solid(&r, want, 1e-6 * want, "#674");
|
||||
assert!(d.events.is_empty(), "an exact join: {d:?}");
|
||||
let bounds = r.mesh(&crate::MeshTolerance::chord(0.01)).unwrap().bounds();
|
||||
assert!((bounds.min.y + 2.5).abs() < 1e-9 && (bounds.min.z + 5.0).abs() < 0.01, "{bounds:?}");
|
||||
}
|
||||
@@ -101,9 +98,8 @@ fn random_rectangles_either_side_of_a_plane_fuse_exactly() {
|
||||
let down = rect(x1, y1, x1 + w1, y1 + h1, -t1, 0.);
|
||||
let want = w0 * h0 * t0 + w1 * h1 * t1;
|
||||
let what = format!("case {case}: up {x0},{y0} {w0}x{h0}x{t0}, down {x1},{y1} {w1}x{h1}x{t1}");
|
||||
let (r, d) = fused(&up, &down);
|
||||
let r = fused(&up, &down);
|
||||
assert_one_solid(&r, want, 1e-6 * want, &what);
|
||||
assert!(!d.events.iter().any(|e| e.strategy == BooleanStrategy::ToolNudge), "{what}: {d:?}");
|
||||
done += 1;
|
||||
}
|
||||
assert_eq!(done, 30);
|
||||
|
||||
@@ -406,22 +406,6 @@ fn unfilleted_knife_edge_input_has_a_closed_display_plan() {
|
||||
}
|
||||
}
|
||||
|
||||
/// The construction does not depend on the faces being curved: at a box's corner it gives the
|
||||
/// body the planar corner builder does (a sphere's octant where the three rounds meet).
|
||||
#[test]
|
||||
fn the_sphere_at_a_box_corner_is_the_planar_corner_builders() {
|
||||
let b = box_solid(Vec3::ZERO, Vec3::new(30.0, 20.0, 10.0)).unwrap();
|
||||
let picks = [Vec3::new(15.0, 0.0, 10.0), Vec3::new(0.0, 10.0, 10.0), Vec3::new(0.0, 0.0, 5.0)];
|
||||
for r in [1.0, 2.5] {
|
||||
let local = crate::blend_corner::fillet_radii(&b, &picks.iter().map(|p| (*p, r)).collect::<Vec<_>>()).unwrap();
|
||||
let ball = crate::blend_vertex::fillet_ball_vertices(&b, &picks, r).unwrap_or_else(|e| panic!("r={r}: {e}"));
|
||||
assert!(ball.validity().is_empty(), "r={r}: {:?}", ball.validity());
|
||||
assert_eq!(ball.face_count(), local.face_count(), "r={r}");
|
||||
let (a, c) = (planned_volume(&local), planned_volume(&ball));
|
||||
assert!((a - c).abs() < 1e-3 * a, "r={r}: planar corner {a}, ball corner {c}");
|
||||
}
|
||||
}
|
||||
|
||||
/// Sizes at the ends of the range at a ball vertex: rounded or refused, never a panic.
|
||||
#[test]
|
||||
fn rounds_ending_in_a_sphere_of_any_size_never_panic() {
|
||||
|
||||
@@ -188,7 +188,8 @@ pub use native::{brep_record, decode_native_body, encode_native_body, native_pre
|
||||
pub use offset::with_same_surface;
|
||||
pub use ops::{BoolOp, boolean, half_space, join_apart, place_matrix, split_by_plane, transform, transform_matrix, union_apart};
|
||||
pub use point_path::{
|
||||
PathPiece, PointPath, SpaceBezier, curve_path, edge_path, face_section_along, iso_curves, project_onto_face, sketch_record_curve, sweep_point_path_with,
|
||||
PathPiece, PointPath, SpaceBezier, curve_path, edge_path, face_section_along, iso_curves, project_onto_face, sketch_record_curve,
|
||||
sweep_point_path_with,
|
||||
};
|
||||
pub use polybool::faceted_boolean;
|
||||
pub use polyhedron::{HalfSpace, convex_polyhedron, draft, offset_faces, shell};
|
||||
|
||||
@@ -69,13 +69,13 @@ pub fn match_surface(body: &Body, faces: &[Vec3], target: &Body, target_pick: &[
|
||||
return Err(KernelError::Invalid("match rebuilds a surface body: this one is closed".into()));
|
||||
}
|
||||
let (record, target_record) = (body.record(), target.record());
|
||||
let face = face_near(&record, faces, body.size() * 0.05 + 1e-6)?;
|
||||
let original = Patch::of(&record, face)?;
|
||||
let face = face_near(record, faces, body.size() * 0.05 + 1e-6)?;
|
||||
let original = Patch::of(record, face)?;
|
||||
let chain = bridge::chain(target, target_pick)?;
|
||||
let line = chain_polyline(&target_record, &chain)?;
|
||||
let line = chain_polyline(target_record, &chain)?;
|
||||
let near = nearest_side(&original, &line)?;
|
||||
let far = near.opposite();
|
||||
let far_edges = side_edges(&record, face, &original, far, body.size() * 1e-6 + 1e-9)?;
|
||||
let far_edges = side_edges(record, face, &original, far, body.size() * 1e-6 + 1e-9)?;
|
||||
let (mid_near, mid_far) = (chain_mid(&line)?, original.at(far, 0.5)?);
|
||||
let leave = (mid_far - mid_near)
|
||||
.normalized()
|
||||
@@ -111,7 +111,7 @@ pub fn match_surface(body: &Body, faces: &[Vec3], target: &Body, target_pick: &[
|
||||
for crown_near in CROWNS {
|
||||
for crown_far in CROWNS {
|
||||
let made = bridge::bridge(&near_frames, &far_frames, [order, Continuity::G1], [crown_near, crown_far])?;
|
||||
let stray = deviation(&Patch::of(&made.record(), 0)?, &original)?;
|
||||
let stray = deviation(&Patch::of(made.record(), 0)?, &original)?;
|
||||
if best.as_ref().is_none_or(|(b, _)| stray < *b) {
|
||||
best = Some((stray, made));
|
||||
}
|
||||
@@ -124,11 +124,11 @@ pub fn match_surface(body: &Body, faces: &[Vec3], target: &Body, target_pick: &[
|
||||
// same way round, which is what a stitch, a thicken or a display of the result reads.
|
||||
let seam = chain_mid(&line)?;
|
||||
let made_record = made.record();
|
||||
let turn = match (Patch::of(&made_record, 0)?.normal_near(seam), Patch::of(&target_record, target_face)?.normal_near(seam)) {
|
||||
let turn = match (Patch::of(made_record, 0)?.normal_near(seam), Patch::of(target_record, target_face)?.normal_near(seam)) {
|
||||
(Some((m, _)), Some((t, _))) => m.dot(t) < 0.0,
|
||||
_ => false,
|
||||
};
|
||||
let kept = crate::surfaces::Parts::of(&made_record, &[(0, turn)])?.canonical()?;
|
||||
let kept = crate::surfaces::Parts::of(made_record, &[(0, turn)])?.canonical()?;
|
||||
let sheet = crate::surfaces::surface_body(&kept.brep)?;
|
||||
let history = History {
|
||||
operands: 2,
|
||||
@@ -147,12 +147,12 @@ pub fn seam_continuity(made: &Body, target: &Body, target_pick: &[Vec3]) -> Resu
|
||||
target.require_brep("match")?;
|
||||
let (record, target_record) = (made.record(), target.record());
|
||||
let chain = bridge::chain(target, target_pick)?;
|
||||
let poly = chain_polyline(&target_record, &chain)?;
|
||||
let poly = chain_polyline(target_record, &chain)?;
|
||||
// The face whose boundary runs along the chain: the one nearest it, so that a body that has
|
||||
// not been matched yet — where the seam is still some way off — can be measured too.
|
||||
let mid = chain_mid(&poly)?;
|
||||
let face = (0..record.faces.len())
|
||||
.filter_map(|f| Patch::of(&record, f).ok().and_then(|p| p.normal_near(mid).map(|(_, d)| (d, p))))
|
||||
.filter_map(|f| Patch::of(record, f).ok().and_then(|p| p.normal_near(mid).map(|(_, d)| (d, p))))
|
||||
.min_by(|a, b| a.0.total_cmp(&b.0))
|
||||
.map(|(_, p)| p)
|
||||
.ok_or_else(|| KernelError::Failed("match: the body has no faces".into()))?;
|
||||
@@ -165,7 +165,7 @@ pub fn seam_continuity(made: &Body, target: &Body, target_pick: &[Vec3]) -> Resu
|
||||
let Some(&(target_face, _)) = candidates.first() else {
|
||||
return Err(KernelError::Invalid("no face of the target holds the picked edges".into()));
|
||||
};
|
||||
let target_patch = Patch::of(&target_record, target_face)?;
|
||||
let target_patch = Patch::of(target_record, target_face)?;
|
||||
let frames = bridge::frames(target, target_face, &chain, leave, STATIONS)?;
|
||||
let size = target.size();
|
||||
let (mut gap, mut deg, mut curv, mut bend) = (0.0f64, 0.0f64, 0.0f64, 0.0f64);
|
||||
@@ -472,7 +472,7 @@ fn support_faces(target: &Body, chain: &Chain, poly: &[Vec3], leave: Vec3) -> Re
|
||||
if !chain.iter().all(|(e, _)| bounds(f, *e)) {
|
||||
continue;
|
||||
}
|
||||
let Some((n, d)) = Patch::of(&r, f).ok().and_then(|p| p.normal_near(mid)) else { continue };
|
||||
let Some((n, d)) = Patch::of(r, f).ok().and_then(|p| p.normal_near(mid)) else { continue };
|
||||
if d > tol {
|
||||
continue;
|
||||
}
|
||||
@@ -505,13 +505,13 @@ fn supply_order(target: &Body, candidates: &[(usize, f64)], chain: &Chain, leave
|
||||
}
|
||||
let r = target.record();
|
||||
let size = target.size();
|
||||
let first_patch = Patch::of(&r, first)?;
|
||||
let first_patch = Patch::of(r, first)?;
|
||||
let primary: Vec<Frame> = bridge::frames(target, first, chain, leave, STATIONS)?;
|
||||
for &other in keep.iter().skip(1) {
|
||||
// A face that cannot be read along the whole chain says nothing here: the face the match
|
||||
// is built on is the one that must be able to supply it.
|
||||
let Ok(other_frames) = bridge::frames(target, other, chain, leave, STATIONS) else { continue };
|
||||
let other_patch = Patch::of(&r, other)?;
|
||||
let other_patch = Patch::of(r, other)?;
|
||||
let mut worst_deg = 0.0f64;
|
||||
let mut worst = 0.0f64;
|
||||
let mut worst_change = 0.0f64;
|
||||
|
||||
@@ -72,9 +72,9 @@ fn edge_at(body: &Body, p: Vec3) -> Chain {
|
||||
/// How far the rebuilt face's far boundary lies from the original one, in mm: the far row of the
|
||||
/// rebuilt surface sampled at its own stations, against the original boundary edge's own points.
|
||||
fn far_drift(made: &Body, sheet: &Body, far_mid: Vec3) -> f64 {
|
||||
let patch = Patch::of(&made.record(), 0).unwrap();
|
||||
let patch = Patch::of(made.record(), 0).unwrap();
|
||||
let ((u0, u1), (_, v1)) = (patch.ranges[0], patch.ranges[1]);
|
||||
let poly = chain_polyline(&sheet.record(), &edge_at(sheet, far_mid)).unwrap();
|
||||
let poly = chain_polyline(sheet.record(), &edge_at(sheet, far_mid)).unwrap();
|
||||
let mut worst = 0.0f64;
|
||||
for k in 0..=8 {
|
||||
let p = patch.surface.point([u0 + (u1 - u0) * k as f64 / 8.0, v1]).unwrap();
|
||||
@@ -87,7 +87,7 @@ fn far_drift(made: &Body, sheet: &Body, far_mid: Vec3) -> f64 {
|
||||
/// point, the unit tangent, the curvature vector and the change of that curvature, read off the
|
||||
/// finished surface (never from the construction).
|
||||
fn seam_at(body: &Body, t: f64) -> (Vec3, Vec3, Vec3, Vec3) {
|
||||
Patch::of(&body.record(), 0).unwrap().seam_shape(Side::V0, t).unwrap()
|
||||
Patch::of(body.record(), 0).unwrap().seam_shape(Side::V0, t).unwrap()
|
||||
}
|
||||
|
||||
/// The stations a seam is measured at, as fractions of its length.
|
||||
@@ -122,7 +122,7 @@ fn a_g2_match_meets_a_cylinder_with_its_own_curvature() {
|
||||
println!("g2: far boundary drift {drift:e} mm");
|
||||
assert!(drift < 1e-9, "the far boundary drifted {drift:e} mm");
|
||||
// The interior stays near the original: the crowning that leaves it closest.
|
||||
let stray = deviation(&Patch::of(&made.record(), 0).unwrap(), &Patch::of(&sheet.record(), 0).unwrap()).unwrap();
|
||||
let stray = deviation(&Patch::of(made.record(), 0).unwrap(), &Patch::of(sheet.record(), 0).unwrap()).unwrap();
|
||||
println!("g2: interior stray {stray:.6} mm rms");
|
||||
// The seam moved 1 mm, so the face cannot be closer than that at the seam itself: over the
|
||||
// whole face the root mean square distance is well under half of it.
|
||||
|
||||
@@ -35,8 +35,7 @@ fn regions_cut_from_a_body_keeping_its_meshes_are_unchanged() {
|
||||
);
|
||||
}
|
||||
let memo = kept.meshes.as_ref().unwrap();
|
||||
assert_eq!(memo.shells.lock().unwrap().len(), 1, "one tolerance, one meshing");
|
||||
assert!(!memo.made.lock().unwrap().is_empty());
|
||||
assert_eq!(memo.made.lock().unwrap().len(), 1, "one tolerance, one meshing");
|
||||
// A mesh from the memo is the mesh made afresh.
|
||||
let (a, b) = (kept.mesh(&crate::MeshTolerance::chord(0.05)).unwrap(), plate.mesh(&crate::MeshTolerance::chord(0.05)).unwrap());
|
||||
let (a2, _) = (kept.mesh(&crate::MeshTolerance::chord(0.05)).unwrap(), ());
|
||||
@@ -62,5 +61,4 @@ fn a_copy_with_another_solid_makes_its_own_meshes() {
|
||||
let _ = kept.mesh(&crate::MeshTolerance::chord(0.5)).unwrap();
|
||||
let m = swapped.mesh(&crate::MeshTolerance::chord(0.5)).unwrap();
|
||||
assert_eq!(m.triangles.len(), other.mesh(&crate::MeshTolerance::chord(0.5)).unwrap().triangles.len());
|
||||
assert!(swapped.boolean_meshes(0.01).is_none());
|
||||
}
|
||||
@@ -40,7 +40,10 @@ fn a_lip_swept_on_a_round_rim_joins_it() {
|
||||
#[test]
|
||||
fn a_swept_lips_foot_is_a_plane() {
|
||||
let l = lip(0.0);
|
||||
let foot = crate::coplanar::faces_in(&l, -Vec3::Z, -10.0, 1e-6);
|
||||
// The faces lying in the plane z = 10 facing down: planar, normal -z, through z = 10.
|
||||
let foot: Vec<usize> = (0..l.face_count())
|
||||
.filter(|&i| l.planar_face(i).is_some_and(|p| p.normal().dot(-Vec3::Z) > 1.0 - 1e-9 && (p.origin.z - 10.0).abs() < 1e-6))
|
||||
.collect();
|
||||
let m = l.mesh(&crate::MeshTolerance::chord(1e-5)).unwrap();
|
||||
let area: f64 = m
|
||||
.triangles
|
||||
|
||||
@@ -41,10 +41,9 @@ fn disc_tangent_to_a_side_and_overhanging_joins() {
|
||||
let top = prism(disc(18.5, cy, r), 10., 20.);
|
||||
let want = 8990.0 + std::f64::consts::PI * r * r * 10.0;
|
||||
for (a, b) in [(&block, &top), (&top, &block)] {
|
||||
let (res, d) = capture_boolean_diagnostics(|| boolean(a, b, BoolOp::Union));
|
||||
let res = boolean(a, b, BoolOp::Union);
|
||||
let res = res.unwrap().unwrap();
|
||||
assert_solid(&res, want, 1e-5, 1, &format!("disc at {cy}, r {r}"));
|
||||
assert!(!d.events.iter().any(|e| e.strategy == BooleanStrategy::ToolNudge), "{d:?}");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -129,10 +128,9 @@ fn hole_tangent_inside_a_stepped_boss_cuts_exactly() {
|
||||
for (z0, z1, want) in [(-1., 20., 2000. + 1000. - 25. * 15.), (6., 20., 2000. + 1000. - 25. * 9.), (-1., 4., 2000. + 1000. - 25. * 4.)] {
|
||||
let what = format!("hole z {z0}…{z1}, turned {turn}, flip {flip}");
|
||||
let hole = prism(circle(15., 5.), z0, z1);
|
||||
let (res, d) = capture_boolean_diagnostics(|| boolean(&stepped, &hole, BoolOp::Cut));
|
||||
let res = boolean(&stepped, &hole, BoolOp::Cut);
|
||||
let res = res.unwrap_or_else(|e| panic!("{what}: {e}")).unwrap();
|
||||
assert_solid(&res, PI * want, 1e-5, 1, &what);
|
||||
assert!(!d.events.iter().any(|e| e.strategy == BooleanStrategy::ToolNudge), "{what}: {d:?}");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -146,10 +144,9 @@ fn hole_tangent_to_a_flat_side_of_a_stepped_block_cuts_exactly() {
|
||||
let boss = prism(rect(10., 10., 40., 30.), 5., 15.);
|
||||
let stepped = boolean(&block, &boss, BoolOp::Union).unwrap().unwrap();
|
||||
let hole = prism(disc(35., 20., 5.), -1., 20.);
|
||||
let (res, d) = capture_boolean_diagnostics(|| boolean(&stepped, &hole, BoolOp::Cut));
|
||||
let res = boolean(&stepped, &hole, BoolOp::Cut);
|
||||
let res = res.unwrap().unwrap();
|
||||
assert_solid(&res, 8000. + 6000. - std::f64::consts::PI * 25. * 15., 1e-5, 1, "hole tangent to a flat side");
|
||||
assert!(!d.events.iter().any(|e| e.strategy == BooleanStrategy::ToolNudge), "{d:?}");
|
||||
}
|
||||
|
||||
/// A stepped block cut by a disc tangent to its back side from inside leaves two posts meeting
|
||||
@@ -163,7 +160,7 @@ fn stepped_cuts_touching_along_a_line_keep_their_pieces() {
|
||||
let back = prism(rect(0., 20., 25., 29.), 10., 20.);
|
||||
let stepped = boolean(&block, &back, BoolOp::Union).unwrap().unwrap();
|
||||
let tool = prism(disc(18.5, 4., 25.), -1., 21.);
|
||||
let (res, d) = capture_boolean_diagnostics(|| boolean(&stepped, &tool, BoolOp::Cut));
|
||||
let res = boolean(&stepped, &tool, BoolOp::Cut);
|
||||
let res = res.unwrap().unwrap();
|
||||
let n = 400_000;
|
||||
let dx = 31.0 / n as f64;
|
||||
@@ -176,18 +173,14 @@ fn stepped_cuts_touching_along_a_line_keep_their_pieces() {
|
||||
.sum();
|
||||
let v = res.mesh(&crate::MeshTolerance::chord(1e-4)).unwrap().measure().volume;
|
||||
assert!((v - volume).abs() <= volume * 1e-4, "posts: volume {v} vs {volume}");
|
||||
assert!(!d.events.iter().any(|e| e.strategy == BooleanStrategy::ToolNudge), "{d:?}");
|
||||
let sewn = crate::prism::prism_boolean(&stepped, &tool, BoolOp::Cut);
|
||||
assert!(!matches!(&sewn, Some(Ok(Some(b))) if b.shell_count() < 2), "posts sewn into one shell");
|
||||
|
||||
let block = prism(rect(0., 0., 40., 40.), 0., 5.);
|
||||
let boss = prism(rect(10., 10., 40., 30.), 5., 15.);
|
||||
let stepped = boolean(&block, &boss, BoolOp::Union).unwrap().unwrap();
|
||||
let diamond = prism(poly(&[[30., 20.], [35., 15.], [40., 20.], [35., 25.]]), -1., 20.);
|
||||
let (res, d) = capture_boolean_diagnostics(|| boolean(&stepped, &diamond, BoolOp::Cut));
|
||||
let res = boolean(&stepped, &diamond, BoolOp::Cut);
|
||||
let res = res.unwrap().unwrap();
|
||||
assert_solid(&res, 8000. + 6000. - 50. * 15., 1e-9, 1, "diamond hole with a corner on a stepped side");
|
||||
assert!(!d.events.iter().any(|e| e.strategy == BooleanStrategy::ToolNudge), "{d:?}");
|
||||
}
|
||||
|
||||
/// A row of holes each touching the next (a 5 mm pattern of Ø5 holes) through a stepped plate:
|
||||
@@ -199,9 +192,8 @@ fn row_of_touching_holes_through_a_stepped_plate_cuts_exactly() {
|
||||
let mut body = boolean(&plate, ¬ch, BoolOp::Cut).unwrap().unwrap();
|
||||
for x in [15.45, 20.45, 25.45] {
|
||||
let hole = prism(disc(x, 15.7, 2.5), -5., 7.5);
|
||||
let (res, d) = capture_boolean_diagnostics(|| boolean(&body, &hole, BoolOp::Cut));
|
||||
let res = boolean(&body, &hole, BoolOp::Cut);
|
||||
body = res.unwrap().unwrap();
|
||||
assert!(!d.events.iter().any(|e| e.strategy == BooleanStrategy::ToolNudge), "hole at {x}: {d:?}");
|
||||
}
|
||||
assert_solid(&body, 7312.5 - 3.0 * std::f64::consts::PI * 6.25 * 7.5, 1e-5, 1, "touching holes");
|
||||
}
|
||||
@@ -35,7 +35,7 @@ impl<'a> Run<'a> {
|
||||
}
|
||||
|
||||
/// The parameters it runs from and to.
|
||||
fn from_to(&self) -> (f64, f64) {
|
||||
fn ends_along(&self) -> (f64, f64) {
|
||||
let [t0, t1] = self.interval;
|
||||
if self.forward { (t0, t1) } else { (t1, t0) }
|
||||
}
|
||||
@@ -123,7 +123,7 @@ fn spans_of(run: &Run, work: &mut usize) -> Option<Vec<Vec<HPoint>>> {
|
||||
}
|
||||
Curve::Ellipse { frame, radii } => {
|
||||
let (x, y) = (v3(frame.x_axis), v3(frame.y_axis));
|
||||
let (a, b) = run.from_to();
|
||||
let (a, b) = run.ends_along();
|
||||
return ellipse_spans(v3(frame.origin), x, y, *radii, a, b, work);
|
||||
}
|
||||
_ => return None,
|
||||
@@ -315,7 +315,7 @@ fn read(run: &Run, plane: &Plane, tol: f64, work: &mut usize, each_span: bool) -
|
||||
if matches!(run.curve, Curve::SurfaceIntersection { .. }) {
|
||||
return None;
|
||||
}
|
||||
let (ts, te) = run.from_to();
|
||||
let (ts, te) = run.ends_along();
|
||||
if !ts.is_finite() || !te.is_finite() || run.interval[1] <= run.interval[0] {
|
||||
return None;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,76 @@
|
||||
//! Round faces read from STEP: a whole turn bounded by one wire that runs along its seam twice.
|
||||
//! A boolean whose intersection loop lies wholly inside such a face is exact.
|
||||
use crate::*;
|
||||
use solidcraft_geom::{Loop2, Plane, Region2, Vec2, Vec3};
|
||||
use std::f64::consts::PI;
|
||||
|
||||
const R: f64 = 4.5;
|
||||
|
||||
fn volume(b: &Body) -> f64 {
|
||||
measure(b).unwrap().volume
|
||||
}
|
||||
|
||||
fn rel(a: f64, b: f64) -> f64 {
|
||||
(a - b).abs() / b.abs().max(1e-12)
|
||||
}
|
||||
|
||||
/// `body` written to STEP and read back: its round faces come back whole, as other systems
|
||||
/// write them.
|
||||
fn through_step(body: &Body) -> Body {
|
||||
step_import(&step_export(&[body], "t").unwrap()).unwrap().bodies.into_iter().next().unwrap().body
|
||||
}
|
||||
|
||||
/// A pin of radius `R` along X, 40 long, centred on the origin.
|
||||
fn pin() -> Body {
|
||||
cylinder(Vec3::new(-20.0, 0.0, 0.0), Vec3::X, R, 40.0).unwrap()
|
||||
}
|
||||
|
||||
/// A block pressed into the top of the pin's side: 10 long, 6 wide, from 2 above the axis up.
|
||||
fn block() -> Body {
|
||||
box_solid(Vec3::new(-5.0, -3.0, 2.0), Vec3::new(5.0, 3.0, 9.0)).unwrap()
|
||||
}
|
||||
|
||||
/// The part of the pin inside [`block`]: the circle's segment above 2 and within 3 of the
|
||||
/// middle, 10 long.
|
||||
fn pressed_volume() -> f64 {
|
||||
let segment = 3.0 * (R * R - 9.0).sqrt() + R * R * (3.0 / R).asin() - 6.0 * 2.0;
|
||||
10.0 * segment
|
||||
}
|
||||
|
||||
/// The boolean, which must succeed (SMLib's, exact: there is no other).
|
||||
fn exact(a: &Body, b: &Body, op: BoolOp) -> Option<Body> {
|
||||
boolean(a, b, op).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_block_pressed_into_a_read_pins_side_is_intersected_and_cut_exactly() {
|
||||
let (read, block) = (through_step(&pin()), block());
|
||||
let want = pressed_volume();
|
||||
let shared = exact(&read, &block, BoolOp::Intersect).unwrap();
|
||||
assert!(rel(volume(&shared), want) < 1e-3, "{} {want}", volume(&shared));
|
||||
let dented = exact(&read, &block, BoolOp::Cut).unwrap();
|
||||
assert!(rel(volume(&dented), PI * R * R * 40.0 - want) < 1e-3, "{}", volume(&dented));
|
||||
// The operands' faces carry over: the dented pin's round face is still the pin's.
|
||||
assert!(dented.history().is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_ball_pressed_into_a_read_pins_side_matches_the_built_pin() {
|
||||
let ball = sphere(Vec3::new(3.0, 1.0, 5.5), 3.0).unwrap();
|
||||
let built = volume(&boolean(&pin(), &ball, BoolOp::Intersect).unwrap().unwrap());
|
||||
let read = volume(&exact(&through_step(&pin()), &ball, BoolOp::Intersect).unwrap());
|
||||
assert!(rel(read, built) < 1e-3, "{read} {built}");
|
||||
}
|
||||
|
||||
/// A cone's side read from STEP is one face along its seam as well.
|
||||
#[test]
|
||||
fn a_block_pressed_into_a_read_cones_side_matches_the_built_cone() {
|
||||
let outline =
|
||||
Region2 { outer: Loop2::polygon(&[Vec2::new(0.0, 0.0), Vec2::new(8.0, 0.0), Vec2::new(5.0, 20.0), Vec2::new(0.0, 20.0)]), holes: vec![] };
|
||||
let cone = revolve(&Plane::YZ, &[outline], Vec2::ZERO, Vec2::Y, 2.0 * PI).unwrap().pop().unwrap();
|
||||
let read = through_step(&cone);
|
||||
let block = box_solid(Vec3::new(-2.0, 4.0, 6.0), Vec3::new(2.0, 12.0, 12.0)).unwrap();
|
||||
let built = volume(&boolean(&cone, &block, BoolOp::Intersect).unwrap().unwrap());
|
||||
let read = volume(&exact(&read, &block, BoolOp::Intersect).unwrap());
|
||||
assert!(rel(read, built) < 1e-3, "{read} {built}");
|
||||
}
|
||||
@@ -91,7 +91,7 @@ pub fn untrim(body: &Body, face: usize, holes: UntrimHoles, outer: bool, in_plac
|
||||
(Some(ob), Some(or)) => r.history().map_err(|e| failed("history", e))?.history(&[ob], &or).ok().map(|mut h| {
|
||||
// The untrimmed face is the face it was, bounded differently.
|
||||
for p in &mut h.faces {
|
||||
if p.origins.iter().any(|o| *o == FaceOrigin::Face { operand: 0, face }) {
|
||||
if p.origins.contains(&FaceOrigin::Face { operand: 0, face }) {
|
||||
p.change = Change::Modified;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -34,7 +34,7 @@ pub(crate) enum Params {
|
||||
|
||||
impl Params {
|
||||
/// The evaluator's parameters of the record's `uv`.
|
||||
pub(crate) fn to_eval(&self, uv: [f64; 2]) -> [f64; 2] {
|
||||
pub(crate) fn to_eval(self, uv: [f64; 2]) -> [f64; 2] {
|
||||
let [u, v] = uv;
|
||||
match self {
|
||||
Params::Same => uv,
|
||||
|
||||
@@ -2326,9 +2326,6 @@ fn orientation_mesh_reuses_missing_face_check_at_matching_tolerance() {
|
||||
present[face as usize] = true;
|
||||
}
|
||||
assert_eq!(body.unmeshed_faces(), present.iter().filter(|p| !**p).count());
|
||||
if scale == 1.0 {
|
||||
assert_eq!(body.coarse_missing, Some((tol, 0)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2473,7 +2470,7 @@ fn loft_joined_onto_a_box_top_is_one_shell() {
|
||||
// Overhanging the box edge (x = 20) the disc is not inside the top face: whatever the join
|
||||
// does, it never returns touching shells as one body.
|
||||
if let Ok(Some(r)) = boolean(&bx, &loft_at(17.0), BoolOp::Union) {
|
||||
assert!(r.shell_count() == 1 || r.union_lumps().is_ok(), "{} touching shells", r.shell_count());
|
||||
assert!(r.shell_count() == 1 || r.lumps().is_ok(), "{} touching shells", r.shell_count());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -200,7 +200,8 @@ fn threads() -> Vec<(String, Body, f64, f64, f64)> {
|
||||
fn thread_display_mesh_stays_on_its_surfaces() {
|
||||
for (name, b, d, p, turns) in threads() {
|
||||
let tol = tol(&b);
|
||||
let plan = b.mesh_plan(&crate::MeshTolerance { chord: tol, angle: Some(DISPLAY_ANGLE) }).unwrap_or_else(|e| panic!("{name}: no display plan: {e}"));
|
||||
let plan =
|
||||
b.mesh_plan(&crate::MeshTolerance { chord: tol, angle: Some(DISPLAY_ANGLE) }).unwrap_or_else(|e| panic!("{name}: no display plan: {e}"));
|
||||
let mesh = plan.evaluate();
|
||||
let q = quality(&plan, &mesh);
|
||||
assert!(q.worst_sag <= 1.5 * tol, "{name}: a triangle lies {} mm off its surface (tolerance {tol})", q.worst_sag);
|
||||
@@ -238,7 +239,9 @@ fn thread_display_mesh_stays_on_its_surfaces() {
|
||||
#[test]
|
||||
fn thread_display_mesh_has_no_degenerate_or_flipped_triangles() {
|
||||
for (name, b, ..) in threads() {
|
||||
let plan = b.mesh_plan(&crate::MeshTolerance { chord: tol(&b), angle: Some(DISPLAY_ANGLE) }).unwrap_or_else(|e| panic!("{name}: no display plan: {e}"));
|
||||
let plan = b
|
||||
.mesh_plan(&crate::MeshTolerance { chord: tol(&b), angle: Some(DISPLAY_ANGLE) })
|
||||
.unwrap_or_else(|e| panic!("{name}: no display plan: {e}"));
|
||||
let mesh = plan.evaluate();
|
||||
let q = quality(&plan, &mesh);
|
||||
assert!(q.tris > 1000, "{name}: {} triangles", q.tris);
|
||||
|
||||
@@ -59,7 +59,7 @@ fn chamfer_the_top_lip_at_a_tangent_wall_junction() {
|
||||
assert_eq!(made.crossed_face_loops().unwrap(), 0);
|
||||
let history = made.history().expect("the chamfer retains exact face provenance");
|
||||
assert!(history.faces.iter().any(|f| f.origins.iter().any(|o| matches!(o, solidcraft_kernel::history::FaceOrigin::Edge { operand: 0, .. }))));
|
||||
let mesh = |body: &Body| body.mesh(&crate::MeshTolerance::chord(0.0005)).unwrap();
|
||||
let mesh = |body: &Body| body.mesh(&solidcraft_kernel::MeshTolerance::chord(0.0005)).unwrap();
|
||||
let before = mesh(&body).measure().volume;
|
||||
let after = mesh(&made);
|
||||
let removed = before - after.measure().volume;
|
||||
@@ -114,7 +114,7 @@ fn one_chamfer_pick_follows_the_tangent_chain_at_any_part_size() {
|
||||
assert!(made.validity().is_empty(), "{:?}", made.validity());
|
||||
// Two straight edges (c^2/2 * 40 each) and both end arcs (Pappus, c^2/2 * 2 pi (R - c/3)).
|
||||
let expected = 40.0 + 0.5 * 2.0 * PI * (5.0 - 1.0 / 3.0);
|
||||
let volume = |b: &Body| b.mesh(&crate::MeshTolerance::chord(1e-4)).unwrap().measure().volume;
|
||||
let volume = |b: &Body| b.mesh(&solidcraft_kernel::MeshTolerance::chord(1e-4)).unwrap().measure().volume;
|
||||
let removed = volume(&body) - volume(&made);
|
||||
assert!((removed - expected).abs() < 0.3, "plate {plate}: removed {removed}, expected {expected}");
|
||||
assert_eq!(made.face_count(), body.face_count() + 4, "plate {plate}: one chamfer face per rim edge");
|
||||
|
||||
@@ -75,7 +75,7 @@ fn a_half_slot_revolved_about_a_centreline_in_a_face_cuts_it() {
|
||||
for turn in [PI, -PI, TAU] {
|
||||
let tool = revolve(&plane, std::slice::from_ref(&r), Vec2::ZERO, Vec2::new(1.0, 0.0), turn).unwrap().pop().unwrap();
|
||||
// A half turn into the plate, or a full one, cuts a groove; a half turn out of it misses.
|
||||
let into = turn.abs() > PI || tool.mesh(&crate::MeshTolerance::chord(0.01)).unwrap().bounds().min.z < 9.0;
|
||||
let into = turn.abs() > PI || tool.mesh(&solidcraft_kernel::MeshTolerance::chord(0.01)).unwrap().bounds().min.z < 9.0;
|
||||
let cut = boolean(&plate, &tool, BoolOp::Cut).unwrap().unwrap();
|
||||
assert!(cut.validity().is_empty(), "flip {flip}, {turn}: {:?}", cut.validity());
|
||||
let removed = whole - measure(&cut).unwrap().volume;
|
||||
|
||||
Reference in new issue
Block a user