Truck split what it swept: a big arc into two faces, a full circle into halves, a turn into two or three parts, a sphere into six patches, a torus into six; it numbered boxes' faces in its own order and sewed stepped cuts slab by slab. SMLib sweeps each profile segment into one face, closes a full cylinder, sphere or torus along one seam edge, and cuts without slabs. The record, face source, helix, display mesh, measure and boolean history tests still expected truck's pieces. Each expectation now follows the geometry, checked by the tests' own independent measures: every face's origin against the profile segment its mesh lies over (unchanged), faces picked by where they lie instead of by truck's face numbers, and the merged counts by the kernel-cases ladder's rule (each whole curve once, and each cylinder's seam): a cylinder 3 faces, 3 edges, 2 vertices; a ball cut from a slab 7, 14, 10. The truck-only stepped-prism check (walls coalesced across slabs) becomes the property it stood for: the stock's walls stay whole, one face each, Kept. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
578 lines
27 KiB
Rust
578 lines
27 KiB
Rust
//! The creation builders' histories: every face's origin checked against the geometry the
|
||
//! builder made it from.
|
||
|
||
use std::f64::consts::{FRAC_PI_2, PI, TAU};
|
||
|
||
use solidcraft_geom::{Loop2, Plane, Region2, Seg2, Vec2, Vec3};
|
||
|
||
use crate::body::Body;
|
||
use crate::build::PathSeg;
|
||
use crate::history::BodyHistory;
|
||
use crate::history::{Change, EdgeOrigin, FaceOrigin, FaceProv, History, Side};
|
||
|
||
const P: fn(usize) -> FaceOrigin = |segment| FaceOrigin::Profile { segment };
|
||
const START: FaceOrigin = FaceOrigin::Cap { end: false };
|
||
const END: FaceOrigin = FaceOrigin::Cap { end: true };
|
||
|
||
/// The body's history, checked against it; a body made from a sketch has generated faces only
|
||
/// and its edges, all new, separate the faces the body's edge order says.
|
||
fn sketch_made(b: &Body) -> &History {
|
||
let h = b.history().expect("the builder reports its history");
|
||
h.check(b, &[]).unwrap();
|
||
assert!(h.faces.iter().all(|f| f.change == Change::Generated && !f.origins.is_empty()));
|
||
assert!(h.edges.iter().all(|e| e.origins.is_empty()));
|
||
assert_eq!(h.edges.iter().map(|e| e.faces.clone()).collect::<Vec<_>>(), crate::history::edge_faces(b.record()));
|
||
h
|
||
}
|
||
|
||
/// Each face's origins.
|
||
fn origins(b: &Body) -> Vec<Vec<FaceOrigin>> {
|
||
sketch_made(b).faces.iter().map(|f| f.origins.clone()).collect()
|
||
}
|
||
|
||
/// Mesh vertices of each face.
|
||
fn points(b: &Body) -> Vec<Vec<Vec3>> {
|
||
mesh_points(b).0
|
||
}
|
||
|
||
/// Mesh vertices of each face, and its triangles' centres (off a curved face by up to the
|
||
/// mesh's tolerance).
|
||
fn mesh_points(b: &Body) -> (Vec<Vec<Vec3>>, Vec<Vec<Vec3>>) {
|
||
let m = b.mesh(&crate::MeshTolerance::chord(b.size() * 1e-3)).unwrap();
|
||
let (mut corners, mut centres) = (vec![Vec::new(); b.face_count()], vec![Vec::new(); b.face_count()]);
|
||
for (t, f) in m.triangles.iter().zip(&m.tri_face) {
|
||
let c = t.map(|i| m.positions[i as usize]);
|
||
corners[*f as usize].extend(c);
|
||
centres[*f as usize].push((c[0] + c[1] + c[2]) * (1.0 / 3.0));
|
||
}
|
||
(corners, centres)
|
||
}
|
||
|
||
/// The segments a face lies over: its vertices on them within `tol`, its triangles' centres
|
||
/// near them (`to_2d` takes a point into the profile's plane).
|
||
fn swept_from(b: &Body, loops: &[&Loop2], to_2d: impl Fn(Vec3) -> Vec2, tol: f64) -> Vec<Vec<usize>> {
|
||
let (corners, centres) = mesh_points(b);
|
||
let flat = |pts: &Vec<Vec3>| pts.iter().map(|p| to_2d(*p)).collect::<Vec<_>>();
|
||
corners
|
||
.iter()
|
||
.zip(¢res)
|
||
.map(|(v, c)| {
|
||
let near = under(loops, &flat(c), b.size() * 3e-3);
|
||
under(loops, &flat(v), tol).into_iter().filter(|k| near.contains(k)).collect()
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
/// The segments (of all `loops`, numbered in order) every point lies on.
|
||
fn under(loops: &[&Loop2], pts: &[Vec2], tol: f64) -> Vec<usize> {
|
||
let segs: Vec<Seg2> = loops.iter().flat_map(|l| l.segs.iter().copied()).collect();
|
||
(0..segs.len()).filter(|k| !pts.is_empty() && pts.iter().all(|q| segs[*k].point_at(segs[*k].closest_param(*q)).dist(*q) < tol)).collect()
|
||
}
|
||
|
||
fn rect(x0: f64, y0: f64, x1: f64, y1: f64) -> Loop2 {
|
||
Loop2::polygon(&[Vec2::new(x0, y0), Vec2::new(x1, y0), Vec2::new(x1, y1), Vec2::new(x0, y1)])
|
||
}
|
||
|
||
fn rotated(l: &Loop2, k: usize) -> Loop2 {
|
||
let mut segs = l.segs.clone();
|
||
segs.rotate_left(k);
|
||
Loop2 { segs }
|
||
}
|
||
|
||
/// A body swept from `r`: each face from the profile segments it lies over (`to_2d` takes a
|
||
/// point back into the profile's plane, within `tol`), or else the cap `cap` says its points
|
||
/// lie on (if any).
|
||
fn expected_swept(
|
||
b: &Body,
|
||
r: &Region2,
|
||
to_2d: impl Fn(Vec3) -> Vec2,
|
||
tol: f64,
|
||
cap: impl Fn(&[Vec3]) -> Option<FaceOrigin>,
|
||
) -> Vec<Vec<FaceOrigin>> {
|
||
let loops: Vec<&Loop2> = std::iter::once(&r.outer).chain(&r.holes).collect();
|
||
let swept = swept_from(b, &loops, to_2d, tol);
|
||
points(b)
|
||
.iter()
|
||
.zip(swept)
|
||
.map(|(pts, segs)| if segs.is_empty() { cap(pts).into_iter().collect() } else { segs.into_iter().map(P).collect() })
|
||
.collect()
|
||
}
|
||
|
||
/// An extrusion (`h` up from `plane`): its sides by the profile segment under them, its caps
|
||
/// by height.
|
||
fn expected_extrusion(b: &Body, plane: &Plane, r: &Region2, h: f64) -> Vec<Vec<FaceOrigin>> {
|
||
let at = |pts: &[Vec3], z: f64| pts.iter().all(|p| (plane.height(*p) - z).abs() < 1e-9);
|
||
expected_swept(
|
||
b,
|
||
r,
|
||
|p| plane.to_local(p),
|
||
1e-7,
|
||
|pts| {
|
||
if at(pts, 0.0) {
|
||
Some(START)
|
||
} else if at(pts, h) {
|
||
Some(END)
|
||
} else {
|
||
None
|
||
}
|
||
},
|
||
)
|
||
}
|
||
|
||
/// Side k comes from segment k whatever order and direction the loops are given in.
|
||
#[test]
|
||
fn extrude_sides_follow_profile_segments_in_any_order() {
|
||
let outer = rect(0.0, 0.0, 40.0, 30.0);
|
||
let hole = rect(10.0, 10.0, 20.0, 20.0).reversed();
|
||
let variants = [
|
||
Region2 { outer: outer.clone(), holes: vec![hole.clone()] },
|
||
Region2 { outer: outer.reversed(), holes: vec![hole.clone()] },
|
||
Region2 { outer: rotated(&outer, 2), holes: vec![rotated(&hole.reversed(), 1)] },
|
||
Region2 { outer: rotated(&outer.reversed(), 3), holes: vec![rotated(&hole, 3)] },
|
||
];
|
||
for r in &variants {
|
||
let b = crate::extrude(&Plane::XY, std::slice::from_ref(r), 0.0, 10.0).unwrap().pop().unwrap();
|
||
let got = origins(&b);
|
||
assert_eq!(got, expected_extrusion(&b, &Plane::XY, r, 10.0));
|
||
// One face per segment, two caps.
|
||
let mut all: Vec<FaceOrigin> = got.into_iter().flatten().collect();
|
||
all.sort();
|
||
assert_eq!(all, [(0..8).map(P).collect::<Vec<_>>(), vec![START, END]].concat());
|
||
// 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 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) && (f.centroid.x - 40.0).abs() < 1e-6)
|
||
.unwrap();
|
||
assert_eq!(origins(&b)[side], [P(k)]);
|
||
}
|
||
|
||
/// A big arc sweeps one face, as every segment does.
|
||
#[test]
|
||
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(), 1);
|
||
assert_eq!(got.iter().filter(|o| **o == [P(1)]).count(), 1);
|
||
}
|
||
|
||
#[test]
|
||
fn primitives_report_their_construction() {
|
||
// Box: the rectangle's sides (−y, +x, +y, −x) and the caps (−z, +z).
|
||
let b = crate::box_solid(Vec3::ZERO, Vec3::new(4.0, 3.0, 2.0)).unwrap();
|
||
let got = origins(&b);
|
||
for (f, o) in b.faces(1e-3).unwrap().iter().zip(&got) {
|
||
let n = f.plane_normal.unwrap();
|
||
let want = [(-Vec3::Y, P(0)), (Vec3::X, P(1)), (Vec3::Y, P(2)), (-Vec3::X, P(3)), (-Vec3::Z, START), (Vec3::Z, END)]
|
||
.into_iter()
|
||
.find(|(d, _)| d.dist(n) < 1e-9)
|
||
.unwrap()
|
||
.1;
|
||
assert_eq!(o, &[want]);
|
||
}
|
||
assert!(b.face_sources().unwrap().iter().all(|s| matches!(s, Some(crate::FaceSource::Box { .. }))));
|
||
// 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: 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)]]);
|
||
// 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)]]);
|
||
}
|
||
|
||
/// The plane the revolve tests sketch in (x across, y up the world z axis, the revolve axis).
|
||
const SIDE: Plane = Plane { origin: Vec3::ZERO, x: Vec3::X, y: Vec3::Z };
|
||
|
||
/// A revolution's faces by the profile segment under each point turned back into the sketch,
|
||
/// the angle caps by where they lie (the start in the sketch plane).
|
||
fn expected_revolution(b: &Body, r: &Region2) -> Vec<Vec<FaceOrigin>> {
|
||
expected_swept(
|
||
b,
|
||
r,
|
||
|p| Vec2::new(p.x.hypot(p.y), p.z),
|
||
1e-6,
|
||
|pts| Some(if pts.iter().all(|p| p.y.abs() < 1e-9 && p.x > -1e-9) { START } else { END }),
|
||
)
|
||
}
|
||
|
||
#[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()] };
|
||
// 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, 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 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 and revolve
|
||
/// number every face by the segment as given, one face each.
|
||
#[test]
|
||
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() };
|
||
// Clockwise: segment 4 is the third arc above, 5 the second, 6 the first.
|
||
let r = Region2 { outer: rect(10.0, 0.0, 30.0, 20.0).reversed(), holes: vec![ccw.reversed()] };
|
||
let b = crate::extrude(&Plane::XY, std::slice::from_ref(&r), 0.0, 10.0).unwrap().pop().unwrap();
|
||
let got = origins(&b);
|
||
assert_eq!(got, expected_extrusion(&b, &Plane::XY, &r, 10.0));
|
||
for k in 0..7 {
|
||
assert_eq!(got.iter().filter(|o| **o == [P(k)]).count(), 1, "segment {k}");
|
||
}
|
||
// 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);
|
||
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}");
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn revolve_with_an_edge_on_the_axis() {
|
||
// Segment 3 runs down the axis: it makes no face.
|
||
let r = Region2 { outer: rect(0.0, 0.0, 10.0, 5.0), holes: vec![] };
|
||
let partial = crate::revolve(&SIDE, std::slice::from_ref(&r), Vec2::ZERO, Vec2::Y, FRAC_PI_2).unwrap().pop().unwrap();
|
||
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 (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(), 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![] };
|
||
let cone = crate::revolve(&SIDE, std::slice::from_ref(&tri), Vec2::ZERO, Vec2::Y, TAU).unwrap().pop().unwrap();
|
||
assert_eq!(origins(&cone), expected_revolution(&cone, &tri));
|
||
// The same cone from a loop that starts elsewhere and runs the other way.
|
||
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, its one face from the arc (segment 1 here).
|
||
let half = Region2 {
|
||
outer: Loop2 {
|
||
segs: vec![
|
||
Seg2::Line { a: Vec2::new(0.0, 5.0), b: Vec2::new(0.0, -5.0) },
|
||
Seg2::Arc { center: Vec2::ZERO, radius: 5.0, start: -FRAC_PI_2, sweep: PI },
|
||
],
|
||
},
|
||
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)]]);
|
||
}
|
||
|
||
#[test]
|
||
fn tapered_extrusion() {
|
||
let r = Region2 { outer: rotated(&rect(0.0, 0.0, 20.0, 10.0).reversed(), 1), holes: vec![] };
|
||
let b = crate::extrude_tapered(&Plane::XY, &r, 10.0, 1.0, 0.1, crate::DraftCorner::default()).unwrap();
|
||
let want: Vec<Vec<FaceOrigin>> = points(&b)
|
||
.iter()
|
||
.map(|pts| {
|
||
let foot: Vec<Vec2> = pts.iter().filter(|p| p.z.abs() < 1e-9).map(|p| Vec2::new(p.x, p.y)).collect();
|
||
if foot.len() == pts.len() {
|
||
vec![START]
|
||
} else if foot.is_empty() {
|
||
vec![END]
|
||
} else {
|
||
under(&[&r.outer], &foot, 1e-7).into_iter().map(P).collect()
|
||
}
|
||
})
|
||
.collect();
|
||
assert_eq!(origins(&b), want);
|
||
}
|
||
|
||
/// Each loft face from the section segments its edges in each section's plane lie on.
|
||
fn expected_loft(b: &Body, sections: &[(Plane, Loop2)]) -> Vec<Vec<FaceOrigin>> {
|
||
let bases: Vec<usize> = sections.iter().scan(0, |acc, (_, l)| Some(std::mem::replace(acc, *acc + l.segs.len()))).collect();
|
||
points(b)
|
||
.iter()
|
||
.map(|pts| {
|
||
let mut out = Vec::new();
|
||
let mut whole = None;
|
||
for (i, (p, l)) in sections.iter().enumerate() {
|
||
let near: Vec<Vec2> = pts.iter().filter(|q| p.height(**q).abs() < 1e-9).map(|q| p.to_local(*q)).collect();
|
||
if near.len() == pts.len() {
|
||
whole = Some(i);
|
||
}
|
||
if near.len() >= 2 {
|
||
out.extend(under(&[l], &near, 1e-3).into_iter().map(|k| P(bases[i] + k)));
|
||
}
|
||
}
|
||
match whole {
|
||
Some(0) => vec![START],
|
||
Some(i) if i + 1 == sections.len() => vec![END],
|
||
_ => {
|
||
out.sort();
|
||
out.dedup();
|
||
out
|
||
}
|
||
}
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
#[test]
|
||
fn loft_sections() {
|
||
let at = |z: f64| Plane { origin: Vec3::new(0.0, 0.0, z), ..Plane::XY };
|
||
let low = (at(0.0), rect(-10.0, -10.0, 10.0, 10.0));
|
||
let high = (at(10.0), rotated(&rect(-5.0, -5.0, 5.0, 5.0).reversed(), 2));
|
||
// Two sections, either way round: ruled faces, each between a segment of each section.
|
||
for sections in [vec![low.clone(), high.clone()], vec![high.clone(), low.clone()]] {
|
||
let b = crate::loft(§ions).unwrap();
|
||
let got = origins(&b);
|
||
assert_eq!(got, expected_loft(&b, §ions));
|
||
assert!(got.iter().filter(|o| o.len() == 2).all(|o| o[0] < P(4) && o[1] >= P(4)));
|
||
}
|
||
// Three sections: smooth faces through all of them (the middle section leaves no edge).
|
||
let mid = (at(5.0), rect(-7.0, -7.0, 7.0, 7.0));
|
||
let sections = [low.clone(), mid, high.clone()];
|
||
let b = crate::loft(§ions).unwrap();
|
||
for o in origins(&b).iter().filter(|o| o.len() > 1) {
|
||
assert_eq!(o.len(), 3, "{o:?}");
|
||
assert!(o[0] < P(4) && o[1] >= P(4) && o[1] < P(8) && o[2] >= P(8));
|
||
}
|
||
let got = origins(&b);
|
||
let want = expected_loft(&b, §ions);
|
||
// (The smooth faces' middle-section segment is checked above.)
|
||
for (g, w) in got.iter().zip(&want) {
|
||
assert!(w.iter().all(|x| g.contains(x)), "{g:?} vs {w:?}");
|
||
}
|
||
// A circle and a square: the circle is re-split at the square's corners, each piece from
|
||
// the arcs it runs over.
|
||
let round = (at(10.0), Loop2::circle(Vec2::ZERO, 6.0));
|
||
let b = crate::loft(&[low, round]).unwrap();
|
||
let got = origins(&b);
|
||
assert_eq!(got.iter().filter(|o| o.len() > 1).count(), 4);
|
||
for o in got.iter().filter(|o| o.len() > 1) {
|
||
assert!(o[0] < P(4) && o[1..].iter().all(|x| *x == P(4) || *x == P(5)), "{o:?}");
|
||
}
|
||
// To a point: the base is the start cap, each triangle from its base segment.
|
||
let base = rotated(&rect(-10.0, -10.0, 10.0, 10.0).reversed(), 1);
|
||
let b = crate::loft_to_point(&Plane::XY, &base, Vec3::new(0.0, 0.0, 15.0)).unwrap();
|
||
let want = points(&b)
|
||
.iter()
|
||
.map(|pts| {
|
||
let foot: Vec<Vec2> = pts.iter().filter(|p| p.z.abs() < 1e-9).map(|p| Vec2::new(p.x, p.y)).collect();
|
||
if foot.len() == pts.len() { vec![START] } else { under(&[&base], &foot, 1e-7).into_iter().map(P).collect() }
|
||
})
|
||
.collect::<Vec<_>>();
|
||
assert_eq!(origins(&b), want);
|
||
}
|
||
|
||
/// Faces of a sweep: the start cap in the profile's plane; each segment's faces run the whole
|
||
/// path, the first one standing on that segment.
|
||
fn check_sweep(b: &Body, plane: &Plane, r: &Region2, faces_per_segment: Option<usize>) {
|
||
let loops: Vec<&Loop2> = std::iter::once(&r.outer).chain(&r.holes).collect();
|
||
let n: usize = loops.iter().map(|l| l.segs.len()).sum();
|
||
let got = origins(b);
|
||
let pts = points(b);
|
||
assert_eq!(got.iter().filter(|o| **o == [START]).count(), 1);
|
||
assert_eq!(got.iter().filter(|o| **o == [END]).count(), 1);
|
||
for (o, p) in got.iter().zip(&pts) {
|
||
let in_plane: Vec<Vec2> = p.iter().filter(|q| plane.height(**q).abs() < 1e-6).map(|q| plane.to_local(*q)).collect();
|
||
// (Near the profile: a coil crosses its plane again further round.)
|
||
let foot: Vec<Vec2> = in_plane
|
||
.iter()
|
||
.copied()
|
||
.filter(|q| loops.iter().flat_map(|l| &l.segs).any(|s| s.point_at(s.closest_param(*q)).dist(*q) < 1e-3))
|
||
.collect();
|
||
if *o == [START] {
|
||
assert_eq!(in_plane.len(), p.len());
|
||
} else if let [FaceOrigin::Profile { segment }] = o.as_slice()
|
||
&& foot.len() >= 2
|
||
{
|
||
assert_eq!(under(&loops, &foot, 1e-3), [*segment], "{foot:?}");
|
||
}
|
||
}
|
||
let counts: Vec<usize> = (0..n).map(|k| got.iter().filter(|o| **o == [P(k)]).count()).collect();
|
||
match faces_per_segment {
|
||
Some(c) => assert!(counts.iter().all(|x| *x == c), "{counts:?}"),
|
||
None => assert!(counts.windows(2).all(|w| w[0] == w[1] && w[0] > 0), "{counts:?}"),
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn sweeps_along_paths() {
|
||
let r = Region2 { outer: rotated(&rect(-2.0, -2.0, 2.0, 2.0).reversed(), 1), holes: vec![] };
|
||
// A line then a quarter turn: a face per segment along each path segment.
|
||
let path = [
|
||
PathSeg::Line { a: Vec3::ZERO, b: Vec3::new(0.0, 0.0, 10.0) },
|
||
PathSeg::Arc { a: Vec3::new(0.0, 0.0, 10.0), center: Vec3::new(20.0, 0.0, 10.0), axis: Vec3::Y, angle: FRAC_PI_2 },
|
||
];
|
||
let b = crate::sweep(&Plane::XY, &r, &path).unwrap();
|
||
check_sweep(&b, &Plane::XY, &r, Some(2));
|
||
// Along a smooth 3D path: one wall per segment.
|
||
let curve: Vec<Vec3> = (0..=40)
|
||
.map(|i| {
|
||
let t = i as f64 / 40.0 * FRAC_PI_2;
|
||
Vec3::new(30.0 * t.sin(), 30.0 * (1.0 - t.cos()), 10.0 * t)
|
||
})
|
||
.collect();
|
||
let plane = Plane::from_normal(curve[0], (curve[1] - curve[0]).normalized().unwrap()).unwrap();
|
||
let circle = Region2 { outer: Loop2::circle(Vec2::ZERO, 2.0), holes: vec![] };
|
||
let b = crate::sweep_path(&plane, &circle, &curve).unwrap();
|
||
check_sweep(&b, &plane, &circle, Some(1));
|
||
// A path with a corner, a holed profile: ruled walls station to station.
|
||
let holed = Region2 { outer: rect(-3.0, -3.0, 3.0, 3.0), holes: vec![rect(-1.0, -1.0, 1.0, 1.0).reversed()] };
|
||
let b = crate::sweep_path(&Plane::XY, &holed, &[Vec3::ZERO, Vec3::new(0.0, 0.0, 20.0), Vec3::new(20.0, 0.0, 20.0)]).unwrap();
|
||
check_sweep(&b, &Plane::XY, &holed, Some(2));
|
||
// A coil: a smooth wall per segment.
|
||
let side = Plane { origin: Vec3::ZERO, x: Vec3::X, y: Vec3::Z };
|
||
let ring = Region2 { outer: Loop2::circle(Vec2::new(20.0, 0.0), 2.0), holes: vec![] };
|
||
let b = crate::sweep_helix(&side, &ring, Vec3::ZERO, Vec3::Z, 8.0, 3.0).unwrap();
|
||
check_sweep(&b, &side, &ring, Some(1));
|
||
}
|
||
|
||
/// Kept faces are their origins, unchanged; each edge an operand still owns is that edge (a new
|
||
/// edge, where two faces meet, has a Meet origin instead).
|
||
fn check_kept(result: &Body, input: &Body) {
|
||
let h = result.history().unwrap();
|
||
h.check(result, &[input]).unwrap();
|
||
let (rf, inf) = (result.faces(1e-3).unwrap(), input.faces(1e-3).unwrap());
|
||
for (f, p) in rf.iter().zip(&h.faces) {
|
||
if let (Change::Kept, [FaceOrigin::Face { operand: 0, face }]) = (p.change, p.origins.as_slice()) {
|
||
assert!(f.centroid.dist(inf[*face].centroid) < 1e-6, "face {}", f.index);
|
||
}
|
||
}
|
||
let (re, ie) = (result.edges(1e-3).unwrap(), input.edges(1e-3).unwrap());
|
||
let mut owned = 0;
|
||
for (e, p) in re.iter().zip(&h.edges) {
|
||
for o in &p.origins {
|
||
let edge = match o {
|
||
crate::history::EdgeOrigin::Edge { operand: 0, edge } => edge,
|
||
crate::history::EdgeOrigin::Meet { .. } => continue,
|
||
_ => panic!("{o:?}"),
|
||
};
|
||
assert!(e.mid.dist(ie[*edge].mid) < 1e-6, "edge {}", e.index);
|
||
owned += 1;
|
||
}
|
||
}
|
||
assert!(owned > 0);
|
||
}
|
||
|
||
/// The input edge (among `edges`) nearest the face: the edge a wall stands on.
|
||
fn nearest_edge(result: &Body, face: usize, input: &Body, edges: &[usize]) -> usize {
|
||
let c = result.faces(1e-3).unwrap()[face].centroid;
|
||
let mids = input.edges(1e-3).unwrap();
|
||
*edges.iter().min_by(|a, b| c.dist(mids[**a].mid).total_cmp(&c.dist(mids[**b].mid))).unwrap()
|
||
}
|
||
|
||
#[test]
|
||
fn thicken_reports_copies_offsets_and_walls() {
|
||
let c = crate::cylinder(Vec3::ZERO, Vec3::Z, 10.0, 20.0).unwrap();
|
||
let half = crate::copy_faces(&c, &[Vec3::new(7.0, 7.0, 10.0)]).unwrap();
|
||
let t = crate::thicken(&half, 1.0, false).unwrap();
|
||
check_kept(&t, &half);
|
||
let h = t.history().unwrap();
|
||
assert_eq!(h.faces[0].origins, [FaceOrigin::Face { operand: 0, face: 0 }]);
|
||
assert_eq!(h.faces[1].origins, [FaceOrigin::Offset { operand: 0, face: 0 }]);
|
||
// A wall along each free edge of the sheet: the side's two rims, not its seam (an edge the
|
||
// one face meets itself along, no boundary).
|
||
let free: Vec<usize> = (0..half.edge_count()).filter(|e| half.record().edges[*e].uses.len() == 1).collect();
|
||
for (i, f) in h.faces.iter().enumerate().skip(2) {
|
||
let [FaceOrigin::Edge { operand: 0, edge }] = f.origins.as_slice() else { panic!("{f:?}") };
|
||
assert_eq!(*edge, nearest_edge(&t, i, &half, &free));
|
||
}
|
||
assert_eq!(h.faces.len(), 2 + free.len());
|
||
}
|
||
|
||
#[test]
|
||
fn raised_band_reports_kept_trimmed_and_new_faces() {
|
||
let b = crate::box_solid(Vec3::new(-40.0, -30.0, 0.0), Vec3::new(40.0, 30.0, 30.0)).unwrap();
|
||
let sh = crate::shell(&b, &[Vec3::new(0.0, 0.0, 30.0)], 2.0).unwrap();
|
||
let lip = crate::raise_band(&sh, Vec3::new(0.0, 29.0, 30.0), 0.5, 1.5, false).unwrap();
|
||
check_kept(&lip, &sh);
|
||
let h = lip.history().unwrap();
|
||
let rim = h.faces.iter().find(|f| f.change == Change::Modified).unwrap();
|
||
let [FaceOrigin::Face { operand: 0, face: rim }] = rim.origins.as_slice() else { panic!() };
|
||
// The rim's inner loop: the edges the walls stand on.
|
||
let loop_edges: Vec<usize> =
|
||
crate::history::edge_faces(sh.record()).iter().enumerate().filter(|(_, fs)| fs.contains(rim)).map(|(i, _)| i).collect();
|
||
let mut walls = 0;
|
||
for (i, f) in h.faces.iter().enumerate() {
|
||
if let [FaceOrigin::Edge { operand: 0, edge }] = f.origins.as_slice() {
|
||
assert_eq!(*edge, nearest_edge(&lip, i, &sh, &loop_edges));
|
||
walls += 1;
|
||
}
|
||
}
|
||
// Two walls per inner edge (the face's and the band's), and the band's top.
|
||
assert_eq!(walls, 8);
|
||
assert_eq!(h.faces.iter().filter(|f| f.origins == [FaceOrigin::Offset { operand: 0, face: *rim }]).count(), 1);
|
||
assert_eq!(h.faces.iter().filter(|f| f.change == Change::Kept).count(), sh.face_count() - 1);
|
||
}
|
||
|
||
#[test]
|
||
fn emboss_reports_kept_trimmed_and_profile_faces() {
|
||
let body = crate::cylinder(Vec3::ZERO, Vec3::Z, 10.0, 20.0).unwrap();
|
||
let plane = Plane::new(Vec3::Y * 10.0, -Vec3::X, Vec3::Z).unwrap();
|
||
let profile = Region2 { outer: rotated(&rect(-2.0, 5.0, 2.0, 10.0), 1), holes: vec![] };
|
||
for depth in [1.0, -1.0] {
|
||
let e = crate::emboss_cylinder(&body, &plane, std::slice::from_ref(&profile), depth).unwrap();
|
||
check_kept(&e, &body);
|
||
let h = e.history().unwrap();
|
||
assert_eq!(h.faces.iter().filter(|f| f.change == Change::Kept).count(), body.face_count() - 1);
|
||
assert_eq!(h.faces.iter().filter(|f| f.change == Change::Modified).count(), 1);
|
||
assert_eq!(h.faces.iter().filter(|f| f.origins == [END]).count(), 1);
|
||
// Each wall over its segment: the sketch's y is the cylinder's z, its x the arc length.
|
||
for (pts, f) in points(&e).iter().zip(&h.faces) {
|
||
let [FaceOrigin::Profile { segment }] = f.origins.as_slice() else { continue };
|
||
let back: Vec<Vec2> = pts.iter().map(|p| Vec2::new(10.0 * (-p.x).atan2(p.y), p.z)).collect();
|
||
assert_eq!(under(&[&profile.outer], &back, 1e-6), [*segment]);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// A new edge's meeting: each side all of its face's origins (a merged face's several); none
|
||
/// where an origin lies on both sides (pieces of one face) or a face comes from nothing.
|
||
#[test]
|
||
fn a_new_edge_meets_whole_faces() {
|
||
let f = |face: usize| FaceOrigin::Face { operand: 0, face };
|
||
let blend = FaceOrigin::Edge { operand: 0, edge: 3 };
|
||
let faces = vec![
|
||
FaceProv { origins: vec![f(0), f(1)], change: Change::Merged },
|
||
FaceProv { origins: vec![blend], change: Change::Generated },
|
||
FaceProv { origins: vec![f(1)], change: Change::Split },
|
||
FaceProv { origins: vec![], change: Change::Generated },
|
||
];
|
||
let merged = Side::new([f(0), f(1)]).unwrap();
|
||
assert_eq!(super::meeting(&[1, 0], &faces), [EdgeOrigin::meet(merged, blend)]);
|
||
assert_eq!(super::meeting(&[2, 1], &faces), [EdgeOrigin::meet(f(1), blend)]);
|
||
assert!(super::meeting(&[0, 2], &faces).is_empty());
|
||
assert!(super::meeting(&[1, 3], &faces).is_empty());
|
||
assert!(super::meeting(&[1], &faces).is_empty());
|
||
}
|