diff --git a/crates/kernel/src/boolean_history_tests.rs b/crates/kernel/src/boolean_history_tests.rs index 2e0956236..852564a14 100644 --- a/crates/kernel/src/boolean_history_tests.rs +++ b/crates/kernel/src/boolean_history_tests.rs @@ -188,15 +188,16 @@ fn faces_of(h: &History) -> Vec<(Change, Vec)> { } /// 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 = 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 = (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 = (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 = + 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)); } diff --git a/crates/kernel/src/display_mesh_tests.rs b/crates/kernel/src/display_mesh_tests.rs index 8da23163d..e34b8ba35 100644 --- a/crates/kernel/src/display_mesh_tests.rs +++ b/crates/kernel/src/display_mesh_tests.rs @@ -378,7 +378,8 @@ fn a_cylinder_wall_split_along_its_seam_meshes_round() { let outer: Vec = (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); diff --git a/crates/kernel/src/face_source_tests.rs b/crates/kernel/src/face_source_tests.rs index 2ba51f6c1..a612a97c4 100644 --- a/crates/kernel/src/face_source_tests.rs +++ b/crates/kernel/src/face_source_tests.rs @@ -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(); diff --git a/crates/kernel/src/helix.rs b/crates/kernel/src/helix.rs index 8a18254f9..7667b09a4 100644 --- a/crates/kernel/src/helix.rs +++ b/crates/kernel/src/helix.rs @@ -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"); diff --git a/crates/kernel/src/record_tests.rs b/crates/kernel/src/record_tests.rs index 31075a9a8..0c0e20653 100644 --- a/crates/kernel/src/record_tests.rs +++ b/crates/kernel/src/record_tests.rs @@ -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> { #[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 = 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 = 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] diff --git a/crates/kernel/src/tests.rs b/crates/kernel/src/tests.rs index 21abd4d90..f054e3314 100644 --- a/crates/kernel/src/tests.rs +++ b/crates/kernel/src/tests.rs @@ -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]