Wave 344/509: Tests: SMLib's faces, one per swept segment, closed along a seam, replace truck's halves (and 3 more)
4 commits, squashed; the originals stay reachable from tag archive/merge-main-develop. - 3c680d21a jyviko: Geometry: the closest point on a full circle just before its start is found before its end - 30ceb44e6 jyviko: Tests: SMLib's faces, one per swept segment, closed along a seam, replace truck's halves - 908bc756c jyviko: Tests: the matchsurf and mixed-fillet helpers read an edge on the curve its interval is on - 98284eb1e jyviko: Tests: a box thinner than a body's tolerance may be refused instead of getting no certificate Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
This commit is contained in:
@@ -384,8 +384,23 @@ impl Seg2 {
|
||||
_ => {}
|
||||
}
|
||||
let n = 64;
|
||||
let mut t =
|
||||
(0..=n).map(|i| i as f64 / n as f64).min_by(|x, y| self.point_at(*x).dist(p).total_cmp(&self.point_at(*y).dist(p))).unwrap_or(0.0);
|
||||
let t = (0..=n).map(|i| i as f64 / n as f64).min_by(|x, y| self.point_at(*x).dist(p).total_cmp(&self.point_at(*y).dist(p))).unwrap_or(0.0);
|
||||
let t = self.newton_closest(p, t);
|
||||
// A closed segment (a full circle) starts where it ends: a point just before its start is
|
||||
// nearest just before its end, which Newton from the start (held there by the clamp)
|
||||
// never reaches. Try from the other end too.
|
||||
let (a, b) = (self.point_at(0.0), self.point_at(1.0));
|
||||
if (t == 0.0 || t == 1.0) && a.dist(b) <= 1e-12 * (1.0 + a.len()) {
|
||||
let other = self.newton_closest(p, 1.0 - t);
|
||||
if self.point_at(other).dist(p) < self.point_at(t).dist(p) {
|
||||
return other;
|
||||
}
|
||||
}
|
||||
t
|
||||
}
|
||||
|
||||
/// Newton's method for the parameter of the point nearest `p`, from `t`, within [0, 1].
|
||||
fn newton_closest(&self, p: Vec2, mut t: f64) -> f64 {
|
||||
for _ in 0..30 {
|
||||
let (q, d) = (self.point_at(t), self.derivative(t));
|
||||
let (d2, h) = ((self.derivative((t + 1e-6).min(1.0)) - self.derivative((t - 1e-6).max(0.0))) / 2e-6, q - p);
|
||||
@@ -403,6 +418,7 @@ impl Seg2 {
|
||||
}
|
||||
t
|
||||
}
|
||||
|
||||
/// The two halves of the segment (same kind, exact).
|
||||
pub fn split_half(&self) -> (Seg2, Seg2) {
|
||||
match *self {
|
||||
@@ -965,6 +981,16 @@ mod tests {
|
||||
assert!(s.point_at(s.closest_param(on_curve)).dist(on_curve) < 1e-9);
|
||||
}
|
||||
}
|
||||
// A full circle's points just before its start, either way round: nearest just before
|
||||
// its end, not at its start (Newton from the start stays held there).
|
||||
for sweep in [TAU, -TAU] {
|
||||
let circle = Seg2::Arc { center: Vec2::new(1.0, 2.0), radius: 5.0, start: 0.6131, sweep };
|
||||
for delta in [1e-4, 0.01, 0.04] {
|
||||
let before = 0.6131 - delta * sweep.signum();
|
||||
let p = Vec2::new(1.0, 2.0) + Vec2::from_angle(before) * 4.99;
|
||||
assert!((circle.point_at(circle.closest_param(p)).dist(p) - 0.01).abs() < 1e-9, "sweep {sweep}, {delta}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The sweep visits only the edges crossing each slab; it must give the triangles that
|
||||
|
||||
@@ -188,15 +188,16 @@ fn faces_of(h: &History) -> Vec<(Change, Vec<FaceOrigin>)> {
|
||||
}
|
||||
|
||||
/// A boolean with a sphere (no prism, no coincident faces): a box with a corner taken
|
||||
/// off by a sphere. The three faces at the corner get a notch, the sphere's patches inside the
|
||||
/// box bound it, meeting the box's faces along new edges.
|
||||
/// off by a sphere. The three faces at the corner get a notch, the sphere's one face (SMLib's
|
||||
/// sphere is one periodic face) bounds it inside the box, meeting each notched face along a new
|
||||
/// edge.
|
||||
#[test]
|
||||
fn box_minus_sphere() {
|
||||
let a = boxed(0.0, 0.0, 0.0, 10.0, 10.0, 10.0);
|
||||
let b = crate::sphere(Vec3::new(10.0, 10.0, 10.0), 4.0).unwrap();
|
||||
let r = boolean(&a, &b, BoolOp::Cut).unwrap().unwrap();
|
||||
let h = verified(&r, &[&a, &b], 0.02);
|
||||
assert_eq!(changes(h), [3, 6, 0, 0, 0], "{}", show(h));
|
||||
assert_eq!(changes(h), [3, 4, 0, 0, 0], "{}", show(h));
|
||||
let from_b: BTreeSet<usize> = h
|
||||
.faces
|
||||
.iter()
|
||||
@@ -206,9 +207,9 @@ fn box_minus_sphere() {
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
assert_eq!(from_b.len(), 3);
|
||||
// Each notched box face meets two of the sphere's patches.
|
||||
assert_eq!(meets(h).len(), 6, "{}", show(h));
|
||||
assert_eq!(from_b.len(), 1);
|
||||
// Each notched box face meets the sphere.
|
||||
assert_eq!(meets(h).len(), 3, "{}", show(h));
|
||||
assert!(meets(h).iter().all(|(x, y)| matches!((x, y), (FaceOrigin::Face { operand: 0, .. }, FaceOrigin::Face { operand: 1, .. }))));
|
||||
}
|
||||
|
||||
@@ -231,9 +232,10 @@ fn box_union_box_prism() {
|
||||
})
|
||||
.collect();
|
||||
origins.sort();
|
||||
// All of a's faces, and b's but the end inside a.
|
||||
// All of a's faces, and b's but the end inside a (its face at x = 5).
|
||||
let mut want: Vec<FaceOrigin> = (0..6).map(|i| face(0, i)).chain((0..6).map(|i| face(1, i))).collect();
|
||||
let inside = face(1, 4);
|
||||
let inside =
|
||||
face(1, b.faces(1e-3).unwrap().iter().position(|f| (f.centroid.x - 5.0).abs() < 1e-6 && f.plane_normal.is_some_and(|n| n.x < -0.9)).unwrap());
|
||||
want.retain(|o| *o != inside);
|
||||
assert_eq!(origins, want, "{}", show(h));
|
||||
// b's four sides meet a's face at x = 10.
|
||||
@@ -243,22 +245,22 @@ fn box_union_box_prism() {
|
||||
assert!(h.edges.iter().all(|e| e.origins.len() == 1));
|
||||
}
|
||||
|
||||
/// A through hole: the box's sides are kept, top and bottom get the hole, the cylinder's two
|
||||
/// half walls line it, meeting top and bottom along its rims, and meet each other along the
|
||||
/// cylinder's own seams.
|
||||
/// A through hole: the box's sides are kept, top and bottom get the hole, the cylinder's wall
|
||||
/// (one periodic face) lines it, meeting top and bottom along its rims, and closes on itself
|
||||
/// along the cylinder's own seam.
|
||||
#[test]
|
||||
fn box_minus_cylinder_prism() {
|
||||
let a = boxed(0.0, 0.0, 0.0, 10.0, 10.0, 10.0);
|
||||
let b = crate::cylinder(Vec3::new(5.0, 5.0, -1.0), Vec3::Z, 2.0, 12.0).unwrap();
|
||||
let r = boolean(&a, &b, BoolOp::Cut).unwrap().unwrap();
|
||||
let h = verified(&r, &[&a, &b], 0.01);
|
||||
assert_eq!(changes(h), [4, 4, 0, 0, 0], "{}", show(h));
|
||||
let walls = from(h, face(1, 1)).len() + from(h, face(1, 2)).len();
|
||||
assert_eq!(walls, 2, "{}", show(h));
|
||||
// Rims: each wall meets top and bottom.
|
||||
assert_eq!(meets(h).len(), 4, "{}", show(h));
|
||||
assert_eq!(changes(h), [4, 3, 0, 0, 0], "{}", show(h));
|
||||
let side = (0..b.face_count()).find(|i| b.planar_face(*i).is_none()).unwrap();
|
||||
assert_eq!(from(h, face(1, side)).len(), 1, "{}", show(h));
|
||||
// Rims: the wall meets top and bottom.
|
||||
assert_eq!(meets(h).len(), 2, "{}", show(h));
|
||||
let seams = h.edges.iter().filter(|e| matches!(e.origins.as_slice(), [EdgeOrigin::Edge { operand: 1, .. }])).count();
|
||||
assert_eq!(seams, 2);
|
||||
assert_eq!(seams, 1);
|
||||
// Every other edge is one of the box's twelve.
|
||||
let boxed_edges: BTreeSet<_> = h.edges.iter().flat_map(|e| &e.origins).filter(|o| matches!(o, EdgeOrigin::Edge { operand: 0, .. })).collect();
|
||||
assert_eq!(boxed_edges.len(), 12);
|
||||
@@ -320,9 +322,9 @@ fn a_cut_of_two_pieces_composes_the_pieces() {
|
||||
let b = crate::sphere(Vec3::new(15.0, 5.0, 10.0), 7.0).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();
|
||||
assert!(bites.len() >= 2, "{}", show(h));
|
||||
// Both pieces are bitten: a piece of the sphere's face lines each bite.
|
||||
let bites = h.faces.iter().filter(|f| matches!(f.origins.as_slice(), [FaceOrigin::Face { operand: 1, .. }])).count();
|
||||
assert!(bites >= 2, "{}", show(h));
|
||||
let targets: BTreeSet<_> = h.faces.iter().flat_map(|f| &f.origins).filter(|o| matches!(o, FaceOrigin::Face { operand: 0, .. })).collect();
|
||||
assert_eq!(targets.len(), 12);
|
||||
}
|
||||
@@ -341,10 +343,10 @@ fn faceted_tool() {
|
||||
assert_eq!(h.faces.iter().filter(|f| matches!(f.origins.first(), Some(FaceOrigin::Face { operand: 1, .. }))).count(), 3);
|
||||
}
|
||||
|
||||
/// A partial-depth cut of stepped prisms: walls over one segment through successive slabs are
|
||||
/// sewn as one face (coalesced), which comes from the operand walls under it in every slab.
|
||||
/// A partial-depth cut of a prism by a narrower one: the stock's walls run whole from 0 to 20,
|
||||
/// one face each past the cutter's floor, untouched (Kept).
|
||||
#[test]
|
||||
fn coalesced_stepped_walls() {
|
||||
fn stepped_cut_keeps_the_stock_walls_whole() {
|
||||
use solidcraft_geom::{Loop2, Plane, Region2, Vec2};
|
||||
for curved in [true, false] {
|
||||
let (outer, inner) = if curved {
|
||||
@@ -357,20 +359,19 @@ fn coalesced_stepped_walls() {
|
||||
let cutter = crate::extrude(&Plane::XY, &[Region2 { outer: inner, holes: vec![] }], 2.0, 22.0).unwrap().pop().unwrap();
|
||||
let r = boolean(&stock, &cutter, BoolOp::Cut).unwrap().unwrap();
|
||||
let h = verified(&r, &[&stock, &cutter], 0.01);
|
||||
// The stock's walls run whole from 0 to 20, one face each, past the cutter's floor.
|
||||
let walls: Vec<usize> = (0..r.face_count()).filter(|i| r.face_was_coalesced(*i)).collect();
|
||||
assert_eq!(walls.len(), if curved { 2 } else { 4 }, "{}", show(h));
|
||||
let walls: Vec<usize> =
|
||||
stock.faces(1e-3).unwrap().iter().enumerate().filter(|(_, f)| f.plane_normal.is_none_or(|n| n.z.abs() < 0.5)).map(|(i, _)| i).collect();
|
||||
assert_eq!(walls.len(), if curved { 1 } else { 4 });
|
||||
for i in walls {
|
||||
assert!(matches!(h.faces[i].origins.as_slice(), [FaceOrigin::Face { operand: 0, .. }]), "{}", show(h));
|
||||
assert_eq!(h.faces[i].change, Change::Modified, "{}", show(h));
|
||||
let pieces = from(h, face(0, i));
|
||||
assert_eq!(pieces.len(), 1, "{}", show(h));
|
||||
assert_eq!(h.faces[pieces[0]].change, Change::Kept, "{}", show(h));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A step cut into a box: the stepped prism path sews the box's face 3 in pieces at the
|
||||
/// slab stations, and the joining of generated walls on their common supports makes it one face
|
||||
/// again; the joined body keeps the sewn body's history composed through the join. A certified
|
||||
/// box (whose planar regularization would join the same pieces) gets the same history.
|
||||
/// A step cut into a box: the box's top (z = 7.5) loses the step's corner, one face still
|
||||
/// (Modified). A certified box gets the same history as a plain one.
|
||||
#[test]
|
||||
fn regularized_step_cut() {
|
||||
let (pa, pb) = (boxed(0.0, 0.0, 0.0, 30.0, 35.0, 7.5), boxed(0.0, 30.0, 2.5, 22.5, 50.0, 25.0));
|
||||
@@ -379,9 +380,10 @@ fn regularized_step_cut() {
|
||||
let h = verified(&r, &[&a, &b], 0.01);
|
||||
let plain = boolean(&pa, &pb, BoolOp::Cut).unwrap().unwrap();
|
||||
let ph = verified(&plain, &[&pa, &pb], 0.01);
|
||||
let joined = from(ph, face(0, 3));
|
||||
let top = pa.faces(1e-3).unwrap().iter().position(|f| (f.centroid.z - 7.5).abs() < 1e-9).unwrap();
|
||||
let joined = from(ph, face(0, top));
|
||||
assert_eq!(joined.len(), 1, "{}", show(ph));
|
||||
assert_eq!(faces_of(ph)[joined[0]], (Change::Modified, vec![face(0, 3)]));
|
||||
assert_eq!(faces_of(ph)[joined[0]], (Change::Modified, vec![face(0, top)]));
|
||||
assert_eq!(faces_of(h), faces_of(ph), "{}", show(h));
|
||||
}
|
||||
|
||||
|
||||
@@ -378,7 +378,8 @@ fn a_cylinder_wall_split_along_its_seam_meshes_round() {
|
||||
let outer: Vec<bool> = (0..cup.face_count())
|
||||
.map(|i| matches!(face_surface(&cup, i), Some(FaceSurface::Cylinder { radius, .. }) if (radius - 50.0).abs() < 1e-6))
|
||||
.collect();
|
||||
assert_eq!(outer.iter().filter(|o| **o).count(), 2);
|
||||
// One periodic face (SMLib sweeps the one circle segment once), its seam split at z = 2.
|
||||
assert_eq!(outer.iter().filter(|o| **o).count(), 1);
|
||||
for tol in [display_tol(&cup), 0.1, 0.01] {
|
||||
let m = cup.mesh(&crate::MeshTolerance::chord(tol)).unwrap();
|
||||
assert_eq!(open_sides(&m, 1e-6), 0);
|
||||
|
||||
@@ -272,7 +272,7 @@ fn constructed_annulus_sides_follow_exact_source_edges() {
|
||||
}
|
||||
assert!(vertices > 0);
|
||||
}
|
||||
assert_eq!((outer, inner), (2, 2), "full circles split into two actual edges each");
|
||||
assert_eq!((outer, inner), (1, 1), "each full circle sweeps one side face");
|
||||
assert_eq!(sources.iter().filter(|source| matches!(source, Some(FaceSource::ExtrudeCap { .. }))).count(), 2);
|
||||
}
|
||||
}
|
||||
@@ -311,7 +311,7 @@ fn constructed_large_arc_split_and_reversal_preserve_one_source_segment() {
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
assert_eq!(arcs.len(), 2, "large input arc explicitly creates two actual boundary edges");
|
||||
assert_eq!(arcs.len(), 1, "the large input arc sweeps one side face");
|
||||
assert!(arcs.iter().all(|(radius, sweep)| (**radius - 10.).abs() < 1e-12 && (sweep.abs() - std::f64::consts::PI * 5. / 3.).abs() < 1e-12));
|
||||
assert_eq!(sources.iter().filter(|source| matches!(source, Some(FaceSource::ExtrudeSide { segment: Seg2::Line { .. }, .. }))).count(), 1);
|
||||
let mesh = body.mesh(&crate::MeshTolerance::chord(0.001)).unwrap();
|
||||
|
||||
@@ -147,7 +147,8 @@ mod tests {
|
||||
let region = Region2 { outer: Loop2::circle(Vec2::new(20.0, 0.0), 2.0), holes: vec![] };
|
||||
let b = sweep_helix(&pl, ®ion, Vec3::ZERO, Vec3::Z, 8.0, 3.0).unwrap();
|
||||
let v = crate::measure(&b).unwrap().volume;
|
||||
assert_eq!(b.face_count(), 4, "two smooth walls and two caps");
|
||||
// SMLib sweeps the circle (one segment) as one smooth wall.
|
||||
assert_eq!(b.face_count(), 3, "one smooth wall and two caps");
|
||||
let want = std::f64::consts::PI * 4.0 * std::f64::consts::TAU * 20.0 * 3.0;
|
||||
assert!((v - want).abs() / want < 1e-3, "{v} vs {want}");
|
||||
assert!(sweep_helix(&pl, ®ion, Vec3::ZERO, Vec3::Z, 3.0, 3.0).is_err(), "pitch below the section");
|
||||
|
||||
@@ -60,7 +60,7 @@ fn edge_at(body: &Body, p: Vec3) -> Chain {
|
||||
let mut best: Option<(f64, usize)> = None;
|
||||
for u in edges {
|
||||
let e = &r.edges[u.edge as usize];
|
||||
let m = CurveEval::new(&e.curve).unwrap().point(0.5 * (e.interval[0] + e.interval[1])).unwrap();
|
||||
let m = CurveEval::new(e.parameters()).unwrap().point(0.5 * (e.interval[0] + e.interval[1])).unwrap();
|
||||
let d = m.dist(p);
|
||||
if best.is_none_or(|(b, _)| d < b) {
|
||||
best = Some((d, u.edge as usize));
|
||||
|
||||
@@ -956,8 +956,10 @@ mod tests {
|
||||
let region = solidcraft_geom::Loop2::polygon(&[Vec2::ZERO, Vec2::new(20., 0.), Vec2::new(20., 20.), Vec2::new(0., 20.)]);
|
||||
let doubled = CapLoop { segments: region.segs.iter().chain(®ion.segs).copied().collect(), area: Interval::enclosing(800., 1e-8).unwrap() };
|
||||
assert!(separated_material(&[doubled], 1e-6, &mut 16_000_000).is_none());
|
||||
let thin = crate::box_solid(Vec3::ZERO, Vec3::new(20., 20., 1e-5)).unwrap();
|
||||
assert!(cert(&thin, 3e-6).is_none());
|
||||
// Thinner than a body's tolerance (2e-5): SMLib refuses it as a solid; built, it gets none.
|
||||
if let Ok(thin) = crate::box_solid(Vec3::ZERO, Vec3::new(20., 20., 1e-5)) {
|
||||
assert!(cert(&thin, 3e-6).is_none());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -141,24 +141,30 @@ fn extrude_sides_follow_profile_segments_in_any_order() {
|
||||
// The certificates are produced as before.
|
||||
assert!(b.face_sources().unwrap().iter().all(Option::is_some));
|
||||
}
|
||||
// The +x side is whichever segment of the given loop runs along x = 40.
|
||||
// The +x side is whichever segment of the given loop runs along x = 40 (the hole's wall at
|
||||
// x = 10 faces +x too).
|
||||
let r = &variants[2];
|
||||
let b = crate::extrude(&Plane::XY, std::slice::from_ref(r), 0.0, 10.0).unwrap().pop().unwrap();
|
||||
let k = r.outer.segs.iter().position(|s| s.start().x == 40.0 && s.end().x == 40.0).unwrap();
|
||||
let side = b.faces(1e-3).unwrap().iter().position(|f| f.plane_normal.is_some_and(|n| n.dist(Vec3::X) < 1e-9)).unwrap();
|
||||
let side = b
|
||||
.faces(1e-3)
|
||||
.unwrap()
|
||||
.iter()
|
||||
.position(|f| f.plane_normal.is_some_and(|n| n.dist(Vec3::X) < 1e-9) && (f.centroid.x - 40.0).abs() < 1e-6)
|
||||
.unwrap();
|
||||
assert_eq!(origins(&b)[side], [P(k)]);
|
||||
}
|
||||
|
||||
/// A big arc is built as two edges: both faces come from it.
|
||||
/// A big arc sweeps one face, as every segment does.
|
||||
#[test]
|
||||
fn extrude_a_big_arc_gives_two_faces_of_one_segment() {
|
||||
fn extrude_a_big_arc_gives_one_face_of_one_segment() {
|
||||
let (a, b) = (Vec2::new(10.0 * (0.3f64).cos(), -10.0 * (0.3f64).sin()), Vec2::new(10.0 * (0.3f64).cos(), 10.0 * (0.3f64).sin()));
|
||||
let arc = Seg2::Arc { center: Vec2::ZERO, radius: 10.0, start: 0.3, sweep: TAU - 0.6 };
|
||||
let r = Region2 { outer: Loop2 { segs: vec![arc, Seg2::Line { a, b }] }, holes: vec![] };
|
||||
let body = crate::extrude(&Plane::XY, std::slice::from_ref(&r), 0.0, 5.0).unwrap().pop().unwrap();
|
||||
let got = origins(&body);
|
||||
assert_eq!(got, expected_extrusion(&body, &Plane::XY, &r, 5.0));
|
||||
assert_eq!(got.iter().filter(|o| **o == [P(0)]).count(), 2);
|
||||
assert_eq!(got.iter().filter(|o| **o == [P(0)]).count(), 1);
|
||||
assert_eq!(got.iter().filter(|o| **o == [P(1)]).count(), 1);
|
||||
}
|
||||
|
||||
@@ -177,18 +183,18 @@ fn primitives_report_their_construction() {
|
||||
assert_eq!(o, &[want]);
|
||||
}
|
||||
assert!(b.face_sources().unwrap().iter().all(|s| matches!(s, Some(crate::FaceSource::Box { .. }))));
|
||||
// Cylinder: a circle of two arcs, extruded.
|
||||
// Cylinder: a circle (one arc), extruded.
|
||||
let c = crate::cylinder(Vec3::ZERO, Vec3::Z, 5.0, 8.0).unwrap();
|
||||
let r = Region2 { outer: Loop2::circle_from(Vec2::ZERO, 5.0, crate::build::SEAM_ANGLE), holes: vec![] };
|
||||
let frame = Plane::from_normal(Vec3::ZERO, Vec3::Z).unwrap();
|
||||
let want = expected_extrusion(&c, &frame, &r, 8.0);
|
||||
assert_eq!(origins(&c), want);
|
||||
// Sphere: six patches, all from the arc of the half disc it revolves.
|
||||
// Sphere: one face, from the arc of the half disc it revolves.
|
||||
let s = crate::sphere(Vec3::ZERO, 5.0).unwrap();
|
||||
assert_eq!(origins(&s), vec![vec![P(0)]; 6]);
|
||||
// Torus: a circle re-split for its seam, turned in three: each face from both arcs.
|
||||
assert_eq!(origins(&s), vec![vec![P(0)]]);
|
||||
// Torus: one face, from the circle (segment 0) it turns.
|
||||
let t = crate::torus(Vec3::ZERO, 10.0, 2.0).unwrap();
|
||||
assert_eq!(origins(&t), vec![vec![P(0), P(1)]; 6]);
|
||||
assert_eq!(origins(&t), vec![vec![P(0)]]);
|
||||
}
|
||||
|
||||
/// The plane the revolve tests sketch in (x across, y up the world z axis, the revolve axis).
|
||||
@@ -209,31 +215,28 @@ fn expected_revolution(b: &Body, r: &Region2) -> Vec<Vec<FaceOrigin>> {
|
||||
#[test]
|
||||
fn revolve_partial_and_full() {
|
||||
let r = Region2 { outer: rect(10.0, 0.0, 20.0, 5.0), holes: vec![rect(12.0, 1.0, 14.0, 2.0).reversed()] };
|
||||
// Under half a turn truck sweeps in two parts, beyond it in three; a full turn has no caps,
|
||||
// and its planar faces (from the segments square to the axis) are whole (#726), as a partial
|
||||
// SMLib turns each segment into one face whatever the angle; a full turn has no caps, and
|
||||
// its planar faces (from the segments square to the axis) are whole (#726), as a partial
|
||||
// turn's are when it is final (`revolve_whole`).
|
||||
let segs: Vec<Seg2> = r.outer.segs.iter().chain(r.holes.iter().flat_map(|h| &h.segs)).cloned().collect();
|
||||
for whole in [false, true] {
|
||||
for (angle, parts, caps) in [(FRAC_PI_2, 2, 2), (1.5 * PI, 3, 2), (TAU, 3, 0)] {
|
||||
for (angle, caps) in [(FRAC_PI_2, 2), (1.5 * PI, 2), (TAU, 0)] {
|
||||
let revolve = if whole { crate::revolve_whole } else { crate::revolve };
|
||||
let b = revolve(&SIDE, std::slice::from_ref(&r), Vec2::ZERO, Vec2::Y, angle).unwrap().pop().unwrap();
|
||||
let got = origins(&b);
|
||||
assert_eq!(got, expected_revolution(&b, &r), "angle {angle}, whole {whole}");
|
||||
for (k, s) in segs.iter().enumerate() {
|
||||
let square = matches!(s, Seg2::Line { a, b } if (a.y - b.y).abs() < 1e-12);
|
||||
let want = if (angle == TAU || whole) && square { 1 } else { parts };
|
||||
assert_eq!(got.iter().filter(|o| **o == [P(k)]).count(), want, "segment {k} at angle {angle}, whole {whole}");
|
||||
for k in 0..segs.len() {
|
||||
assert_eq!(got.iter().filter(|o| **o == [P(k)]).count(), 1, "segment {k} at angle {angle}, whole {whole}");
|
||||
}
|
||||
assert_eq!(got.iter().filter(|o| **o == [START] || **o == [END]).count(), caps);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Loops given clockwise, a hole that is a full circle of three arcs: extrude numbers every
|
||||
/// face by the segment as given; revolve re-seams the circle into two half circles, each from
|
||||
/// every given arc it runs over.
|
||||
/// Loops given clockwise, a hole that is a full circle of three arcs: extrude and revolve
|
||||
/// number every face by the segment as given, one face each.
|
||||
#[test]
|
||||
fn clockwise_loops_and_a_reseamed_circle_keep_their_numbers() {
|
||||
fn clockwise_loops_and_a_circle_of_arcs_keep_their_numbers() {
|
||||
let (c, rad) = (Vec2::new(20.0, 10.0), 4.0);
|
||||
let arcs = [(0.3, 2.0), (2.3, 2.5), (4.8, TAU - 4.5)];
|
||||
let ccw = Loop2 { segs: arcs.iter().map(|&(start, sweep)| Seg2::Arc { center: c, radius: rad, start, sweep }).collect() };
|
||||
@@ -245,28 +248,14 @@ fn clockwise_loops_and_a_reseamed_circle_keep_their_numbers() {
|
||||
for k in 0..7 {
|
||||
assert_eq!(got.iter().filter(|o| **o == [P(k)]).count(), 1, "segment {k}");
|
||||
}
|
||||
// Revolved, the circle restarts at 0.4142 rad: the half from there runs over the first two
|
||||
// arcs (6, 5), the other half over all three (it ends past the first arc's start).
|
||||
let first_half = |q: Vec2| (q - c).angle().rem_euclid(TAU);
|
||||
// Revolved, each arc turns into a face of its own, as the rectangle's sides do.
|
||||
for angle in [FRAC_PI_2, TAU] {
|
||||
let b = crate::revolve(&SIDE, std::slice::from_ref(&r), Vec2::ZERO, Vec2::Y, angle).unwrap().pop().unwrap();
|
||||
let got = origins(&b);
|
||||
let want = expected_revolution(&b, &r);
|
||||
let (_, centres) = mesh_points(&b);
|
||||
let mut halves = [0, 0];
|
||||
for ((g, w), centres) in got.iter().zip(&want).zip(¢res) {
|
||||
let flat: Vec<Vec2> = centres.iter().map(|p| Vec2::new(p.x.hypot(p.y), p.z)).collect();
|
||||
if flat.iter().all(|q| (q.dist(c) - rad).abs() < 0.1) {
|
||||
let first = flat.iter().all(|q| (0.4142 - 1e-3..=0.4142 + PI + 1e-3).contains(&first_half(*q)));
|
||||
assert_eq!(g, &if first { vec![P(5), P(6)] } else { vec![P(4), P(5), P(6)] }, "angle {angle}");
|
||||
halves[usize::from(!first)] += 1;
|
||||
} else {
|
||||
assert_eq!(g, w, "angle {angle}");
|
||||
}
|
||||
assert_eq!(got, expected_revolution(&b, &r), "angle {angle}");
|
||||
for k in 0..7 {
|
||||
assert_eq!(got.iter().filter(|o| **o == [P(k)]).count(), 1, "segment {k} at angle {angle}");
|
||||
}
|
||||
// Truck turns each half in as many parts as each rectangle side.
|
||||
let parts = got.iter().filter(|o| **o == [P(0)]).count();
|
||||
assert_eq!(halves, [parts, parts], "angle {angle}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -278,11 +267,11 @@ fn revolve_with_an_edge_on_the_axis() {
|
||||
let got = origins(&partial);
|
||||
assert_eq!(got, expected_revolution(&partial, &r));
|
||||
assert_eq!(got.len(), 5);
|
||||
// A full turn: the radial segments 0 and 2 sweep discs, segment 1 the cylinder (three parts).
|
||||
// A full turn: the radial segments 0 and 2 sweep discs, segment 1 the cylinder (one face).
|
||||
let full = crate::revolve(&SIDE, std::slice::from_ref(&r), Vec2::ZERO, Vec2::Y, TAU).unwrap().pop().unwrap();
|
||||
let got = origins(&full);
|
||||
assert_eq!(got, expected_revolution(&full, &r));
|
||||
assert_eq!(got.iter().filter(|o| **o == [P(1)]).count(), 3);
|
||||
assert_eq!(got.iter().filter(|o| **o == [P(1)]).count(), 1);
|
||||
assert_eq!(got.iter().filter(|o| **o == [P(0)] || **o == [P(2)]).count(), 2);
|
||||
// A cone: the slanted segment ends on the axis (the apex), the base disc.
|
||||
let tri = Region2 { outer: Loop2::polygon(&[Vec2::new(0.0, 0.0), Vec2::new(10.0, 0.0), Vec2::new(0.0, 8.0)]), holes: vec![] };
|
||||
@@ -292,7 +281,7 @@ fn revolve_with_an_edge_on_the_axis() {
|
||||
let turned = Region2 { outer: rotated(&tri.outer.reversed(), 1), holes: vec![] };
|
||||
let cone = crate::revolve(&SIDE, std::slice::from_ref(&turned), Vec2::ZERO, Vec2::Y, TAU).unwrap().pop().unwrap();
|
||||
assert_eq!(origins(&cone), expected_revolution(&cone, &turned));
|
||||
// A half disc: a sphere, every patch from the arc (segment 1 here).
|
||||
// A half disc: a sphere, its one face from the arc (segment 1 here).
|
||||
let half = Region2 {
|
||||
outer: Loop2 {
|
||||
segs: vec![
|
||||
@@ -303,7 +292,7 @@ fn revolve_with_an_edge_on_the_axis() {
|
||||
holes: vec![],
|
||||
};
|
||||
let ball = crate::revolve(&SIDE, std::slice::from_ref(&half), Vec2::ZERO, Vec2::Y, TAU).unwrap().pop().unwrap();
|
||||
assert_eq!(origins(&ball), vec![vec![P(1)]; 6]);
|
||||
assert_eq!(origins(&ball), vec![vec![P(1)]]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -31,7 +31,9 @@ fn cylinder_measures_match_analytic() {
|
||||
let a = 2.0 * PI * 225.0 + 2.0 * PI * 15.0 * 50.0;
|
||||
assert!(rel(m.volume, v) < 5e-4, "{} vs {v}", m.volume);
|
||||
assert!(rel(m.area, a) < 5e-4, "{} vs {a}", m.area);
|
||||
assert_eq!((m.merged.faces, m.merged.edges, m.merged.vertices), (3, 2, 2), "{:?}", m.merged);
|
||||
// Two closed circles and the side's seam (the ladder's count: each whole curve once, and each
|
||||
// cylinder's seam); a vertex on each circle.
|
||||
assert_eq!((m.merged.faces, m.merged.edges, m.merged.vertices), (3, 3, 2), "{:?}", m.merged);
|
||||
assert_eq!(m.merged.face_types.get("cylinder"), Some(&1));
|
||||
}
|
||||
|
||||
@@ -1001,13 +1003,16 @@ fn sphere_booleans() {
|
||||
let s = sphere(Vec3::ZERO, 15.0).unwrap();
|
||||
let m = measure(&s).unwrap();
|
||||
assert!(rel(m.volume, 4.0 / 3.0 * PI * 3375.0) < 1e-3, "{}", m.volume);
|
||||
assert_eq!((m.merged.faces, m.merged.edges), (1, 0));
|
||||
// One spherical face, closed along its seam from pole to pole.
|
||||
assert_eq!((m.merged.faces, m.merged.edges), (1, 1));
|
||||
// A ball cut out of the top face of a slab (oracle 14).
|
||||
let b = box_solid(Vec3::new(-25.0, -25.0, -20.0), Vec3::new(25.0, 25.0, 0.0)).unwrap();
|
||||
let c = boolean(&b, &s, BoolOp::Cut).unwrap().unwrap();
|
||||
let m = measure(&c).unwrap();
|
||||
assert!(rel(m.volume, 50.0 * 50.0 * 20.0 - 2.0 / 3.0 * PI * 3375.0) < 1e-3, "{}", m.volume);
|
||||
assert_eq!((m.merged.faces, m.merged.edges, m.merged.vertices), (7, 13, 9));
|
||||
// The box's 6 faces and the sphere's; its 12 edges, the rim circle and the sphere's seam down
|
||||
// to its pole; its 8 corners, the rim's vertex and the pole.
|
||||
assert_eq!((m.merged.faces, m.merged.edges, m.merged.vertices), (7, 14, 10));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -1964,7 +1969,7 @@ fn fillet_mixed_arc_and_line_joint_preserves_both_section_radii() {
|
||||
if !mitres.insert(id) {
|
||||
continue;
|
||||
}
|
||||
let curve = solidcraft_geom::brep::eval::CurveEval::new(&edge.curve).unwrap();
|
||||
let curve = solidcraft_geom::brep::eval::CurveEval::new(edge.parameters()).unwrap();
|
||||
let [lo, hi] = edge.interval;
|
||||
for i in 0..=257 {
|
||||
let p = curve.point(lo + (hi - lo) * f64::from(i) / 257.0).unwrap();
|
||||
|
||||
Reference in New Issue
Block a user