Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Wave 129/509: kernel: certified prism comparison reads the schema 4 record

jyviko4708184430b8
diff --git a/crates/kernel/src/prism_curve.rs b/crates/kernel/src/prism_curve.rs
index 8aa74ae446..62c5c58212 100644
--- a/crates/kernel/src/prism_curve.rs
+++ b/crates/kernel/src/prism_curve.rs
@@ -608,8 +608,8 @@ mod tests {
let ends = [at(c, interval[0]), at(c, interval[1])];
Run { curve: c, interval, forward, ends: if forward { ends } else { [ends[1], ends[0]] } }
}
- /// The quarter circle of radius 10 about the origin from +x to +y, as truck's circle arcs
- /// were: a rational quadratic spline.
+ /// The quarter circle of radius 10 about the origin from +x to +y, as a rational quadratic
+ /// spline.
fn quarter() -> Curve {
let w = std::f64::consts::FRAC_1_SQRT_2;
Curve::RationalSpline { knots: bezier_knots(2), homogeneous: vec![[10., 0., 0., 1.], [10. * w, 10. * w, 0., w], [0., 10., 0., 1.]] }
diff --git a/crates/kernel/src/prism_measure.rs b/crates/kernel/src/prism_measure.rs
index f0cf64f58c..eee0405a22 100644
--- a/crates/kernel/src/prism_measure.rs
+++ b/crates/kernel/src/prism_measure.rs
@@ -1,8 +1,13 @@
-//! Independent current-geometry intervals for uniform prisms.
-//! These are not mesh measurements or certificates of construction history.
-use crate::body::from_p3;
+//! Independent current-geometry intervals for uniform prisms, read off the body's schema 4
+//! record. These are not mesh measurements or certificates of construction history.
+use crate::prism_curve::{Run, segment};
+use solidcraft_geom::brep::eval::CurveEval;
+use solidcraft_geom::brep::{Brep, Curve, Loop, Shell, Surface};
use solidcraft_geom::{Plane, Ring, Seg2, Vec2, Vec3};
-use truck_modeling as mt;
+
+fn v3(p: [f64; 3]) -> Vec3 {
+ Vec3::new(p[0], p[1], p[2])
+}
#[derive(Clone, Copy, Debug)]
struct Interval {
@@ -52,11 +57,8 @@ struct CapLoop {
/// Cross-product cancellation belongs to the surface representation, not
/// just the later incidence dot product. Reject ill-conditioned plane bases.
-fn plane_normal(p: &mt::Plane) -> Option<(Vec3, Vec3)> {
- let u = p.u_axis();
- let v = p.v_axis();
- let u = Vec3::new(u.x, u.y, u.z);
- let v = Vec3::new(v.x, v.y, v.z);
+/// The natural normal of the plane spanned by `u` and `v`, and a bound on its rounding error.
+fn plane_normal(u: Vec3, v: Vec3) -> Option<(Vec3, Vec3)> {
let cross = u.cross(v);
let length = cross.len();
if !length.is_finite() || length <= 1e-6 * u.len() * v.len() {
@@ -69,52 +71,77 @@ fn plane_normal(p: &mt::Plane) -> Option<(Vec3, Vec3)> {
(ne.x.is_finite() && ne.y.is_finite() && ne.z.is_finite()).then_some((n, ne))
}
+/// A planar surface's origin and spanning vectors (as its record holds them).
+fn plane_of(s: &Surface) -> Option<(Vec3, Vec3, Vec3)> {
+ match s {
+ Surface::Plane { origin, u_axis, v_axis } => Some((v3(*origin), v3(*u_axis), v3(*v_axis))),
+ Surface::PlaneThrough { origin, u_point, v_point } => {
+ let o = v3(*origin);
+ Some((o, v3(*u_point) - o, v3(*v_point) - o))
+ }
+ _ => None,
+ }
+}
+
+/// `v` (a point when `w` is 1, a direction when 0) mapped by the column-major affine `m`; `None`
+/// where the map is not affine there.
+fn placed(m: &[[f64; 4]; 4], v: Vec3, w: f64) -> Option<Vec3> {
+ let c = |k: usize| m[0][k] * v.x + m[1][k] * v.y + m[2][k] * v.z + m[3][k] * w;
+ (c(3) == w).then(|| Vec3::new(c(0), c(1), c(2)))
+}
+
+/// A revolution of a line: the line's ends, the axis origin and unit axis, the placement.
+type Revolved<'a> = (Vec3, Vec3, Vec3, Vec3, &'a [[f64; 4]; 4]);
+
+fn revolved_line(s: &Surface) -> Option<Revolved<'_>> {
+ let Surface::PlacedRevolution { profile, origin, axis, matrix, .. } = s else { return None };
+ let Curve::Line { start, end } = &**profile else { return None };
+ Some((v3(*start), v3(*end), v3(*origin), v3(*axis).normalized()?, matrix))
+}
+
+/// A spline surface's control net, `(point, weight)` with `[i][j]` i along u, and its knots.
+type Net<'a> = (Vec<Vec<(Vec3, f64)>>, &'a [f64], &'a [f64]);
+
+fn net_of(s: &Surface) -> Option<Net<'_>> {
+ match s {
+ Surface::Spline { u_knots, v_knots, points } => {
+ Some((points.iter().map(|r| r.iter().map(|p| (v3(*p), 1.)).collect()).collect(), u_knots, v_knots))
+ }
+ Surface::RationalSpline { u_knots, v_knots, homogeneous } => Some((
+ homogeneous.iter().map(|r| r.iter().map(|p| (Vec3::new(p[0] / p[3], p[1] / p[3], p[2] / p[3]), p[3])).collect()).collect(),
+ u_knots,
+ v_knots,
+ )),
+ _ => None,
+ }
+}
+
/// A whole positive control-net bound for the wall's projected variation.
/// A sampled normal or a vertex-only test is deliberately insufficient.
-fn wall_error(surface: &mt::Surface, d: Vec3, height: f64, work: &mut usize) -> Option<f64> {
- if let mt::Surface::Plane(p) = surface {
- let (n, ne) = plane_normal(p)?;
+fn wall_error(surface: &Surface, d: Vec3, height: f64, work: &mut usize) -> Option<f64> {
+ if let Some((_, u, v)) = plane_of(surface) {
+ let (n, ne) = plane_normal(u, v)?;
let terms = (n.x * d.x).abs() + (n.y * d.y).abs() + (n.z * d.z).abs();
let error = ne.x * d.x.abs() + ne.y * d.y.abs() + ne.z * d.z.abs() + 1024. * f64::EPSILON * terms;
return Some((n.dot(d).abs() + error) * height * 2.);
}
- if let mt::Surface::RevolutedCurve(p) = surface {
- let r = p.entity();
- let mt::Curve::Line(line) = r.entity_curve() else { return None };
- let axis = r.axis();
- let meridian = line.1 - line.0;
- let a = Vec3::new(axis.x, axis.y, axis.z).normalized()?;
- let m = Vec3::new(meridian.x, meridian.y, meridian.z).normalized()?;
- let placed = *p.transform() * mt::Vector4::new(axis.x, axis.y, axis.z, 0.);
- if placed.w != 0. {
- return None;
- }
- let pa = Vec3::new(placed.x, placed.y, placed.z).normalized()?;
+ if let Surface::Cylinder { frame, .. } = surface {
+ let a = v3(frame.x_axis).cross(v3(frame.y_axis)).normalized()?;
+ return Some(a.cross(d).len() * height * 4.);
+ }
+ if let Some((start, end, _, a, matrix)) = revolved_line(surface) {
+ let m = (end - start).normalized()?;
+ let pa = placed(matrix, a, 0.)?.normalized()?;
return Some((a.cross(m).len() + pa.cross(d).len()) * height * 4.);
}
- let (rows, cols) = match surface {
- mt::Surface::BSplineSurface(s) => (s.control_points().len(), s.control_points().first()?.len()),
- mt::Surface::NurbsSurface(s) => (s.control_points().len(), s.control_points().first()?.len()),
- _ => return None,
- };
+ let (points, _, _) = net_of(surface)?;
+ let (rows, cols) = (points.len(), points.first()?.len());
let count = rows.checked_mul(cols)?;
- let rectangular = match surface {
- mt::Surface::BSplineSurface(s) => s.control_points().iter().all(|r| r.len() == cols),
- mt::Surface::NurbsSurface(s) => s.control_points().iter().all(|r| r.len() == cols),
- _ => false,
- };
- if rows < 2 || cols < 2 || count > 16_384 || !rectangular {
+ if rows < 2 || cols < 2 || count > 16_384 || !points.iter().all(|r| r.len() == cols) {
return None;
}
*work = work.checked_sub(count.checked_mul(4)?)?;
- let points: Vec<Vec<(Vec3, f64)>> = match surface {
- mt::Surface::BSplineSurface(s) => s.control_points().iter().map(|r| r.iter().map(|p| (from_p3(*p), 1.)).collect()).collect(),
- mt::Surface::NurbsSurface(s) => {
- s.control_points().iter().map(|r| r.iter().map(|p| (Vec3::new(p.x / p.w, p.y / p.w, p.z / p.w), p.w)).collect()).collect()
- }
- _ => return None,
- };
- if points.iter().any(|r| r.len() != cols) || points.iter().flatten().any(|(p, w)| !p.is_finite() || !w.is_finite() || *w <= 0.) {
+ if points.iter().flatten().any(|(p, w)| !p.is_finite() || !w.is_finite() || *w <= 0.) {
return None;
}
let max_w = points.iter().flatten().map(|p| p.1).fold(0., f64::max);
@@ -181,16 +208,24 @@ fn segment_same(a: &Seg2, b: &Seg2, tolerance: f64) -> bool {
}
}
-fn wall_supports_cap(surface: &mt::Surface, edge: &mt::Edge, plane: &Plane, levels: (f64, f64), tol: f64, work: &mut usize) -> Option<bool> {
- use mt::{BoundedCurve, ParametricCurve};
- let cap = crate::prism_curve::segment(edge, plane, tol, work)?;
- if let mt::Surface::Plane(p) = surface {
- let (n, ne) = plane_normal(p)?;
- let origin = from_p3(p.origin());
+/// Does the wall (`surface` over the face's `domain`) carry the cap boundary `cap` (an edge of a
+/// cap at level `level`, read in `plane`) between the cap levels `levels`?
+fn wall_supports_cap(
+ surface: &Surface,
+ domain: &[[f64; 2]; 2],
+ cap: &[Seg2],
+ level: f64,
+ plane: &Plane,
+ levels: (f64, f64),
+ tol: f64,
+ work: &mut usize,
+) -> Option<bool> {
+ if let Some((origin, u, v)) = plane_of(surface) {
+ let (n, ne) = plane_normal(u, v)?;
for s in cap {
- let Seg2::Line { a, b } = s else { return Some(false) };
+ let Seg2::Line { a, b } = *s else { return Some(false) };
for q in [a, b] {
- let point = plane.to_world(q) + plane.normal() * plane.height(from_p3(edge.front().point()));
+ let point = plane.to_world(q) + plane.normal() * level;
let delta = point - origin;
let error =
1024. * f64::EPSILON * (1. + point.len() + origin.len()) + delta.x.abs() * ne.x + delta.y.abs() * ne.y + delta.z.abs() * ne.z;
@@ -201,28 +236,33 @@ fn wall_supports_cap(surface: &mt::Surface, edge: &mt::Edge, plane: &Plane, leve
}
return Some(true);
}
- if let mt::Surface::RevolutedCurve(processor) = surface {
- let r = processor.entity();
- let mt::Curve::Line(line) = r.entity_curve() else { return None };
- let o = from_p3(r.origin());
- let axis = r.axis();
- let axis = Vec3::new(axis.x, axis.y, axis.z).normalized()?;
- let delta = from_p3(line.0) - o;
+ let on_circle = |center: Vec2, radius: f64| {
+ cap.iter().all(|s| matches!(*s, Seg2::Arc { center: c, radius: r, .. } if c.dist(center) + (r - radius).abs() <= tol * 8.))
+ };
+ let spans = |ha: f64, hb: f64| !(ha.min(hb) > levels.0 + tol * 8. || ha.max(hb) < levels.1 - tol * 8.);
+ if let Surface::Cylinder { frame, radius } = surface {
+ let (o, x, y) = (v3(frame.origin), v3(frame.x_axis), v3(frame.y_axis));
+ let z = x.cross(y);
+ // The face's heights along the axis: the rest of the cylinder carries no cap.
+ let [v0, v1] = domain[1];
+ if !spans(plane.height(o + z * v0), plane.height(o + z * v1)) {
+ return Some(false);
+ }
+ if x.dot(plane.normal()).abs() * radius > tol || y.dot(plane.normal()).abs() * radius > tol {
+ return None;
+ }
+ return Some(on_circle(plane.to_local(o), *radius));
+ }
+ if let Some((start, end, o, axis, matrix)) = revolved_line(surface) {
+ let delta = start - o;
let radial = (delta - axis * delta.dot(axis)).len();
let u = axis.any_perp();
let v = axis.cross(u);
- let matrix = *processor.transform();
- let place = |p: Vec3, w: f64| {
- let q = matrix * mt::Vector4::new(p.x, p.y, p.z, w);
- (q.w == w).then_some(Vec3::new(q.x, q.y, q.z))
- };
- let center = plane.to_local(place(o, 1.)?);
- let ha = plane.height(place(from_p3(line.0), 1.)?);
- let hb = plane.height(place(from_p3(line.1), 1.)?);
- if ha.min(hb) > levels.0 + tol * 8. || ha.max(hb) < levels.1 - tol * 8. {
+ let center = plane.to_local(placed(matrix, o, 1.)?);
+ if !spans(plane.height(placed(matrix, start, 1.)?), plane.height(placed(matrix, end, 1.)?)) {
return Some(false);
}
- let (pu, pv) = (place(u, 0.)?, place(v, 0.)?);
+ let (pu, pv) = (placed(matrix, u, 0.)?, placed(matrix, v, 0.)?);
let radius = pu.len() * radial;
if (pu.len() - pv.len()).abs() * radial > tol
|| pu.dot(pv).abs() * radial > tol
@@ -231,21 +271,12 @@ fn wall_supports_cap(surface: &mt::Surface, edge: &mt::Edge, plane: &Plane, leve
{
return None;
}
- return Some(cap.iter().all(|s| matches!(*s,Seg2::Arc {center:c,radius:r,..} if c.dist(center)+(r-radius).abs()<=tol*8.)));
+ return Some(on_circle(center, radius));
}
- let (rows, cols) = match surface {
- mt::Surface::BSplineSurface(s) => (s.control_points().len(), s.control_points().first()?.len()),
- mt::Surface::NurbsSurface(s) => (s.control_points().len(), s.control_points().first()?.len()),
- _ => return None,
- };
+ let (points, u_knots, v_knots) = net_of(surface)?;
+ let (rows, cols) = (points.len(), points.first()?.len());
*work = work.checked_sub(rows.checked_mul(cols)?.checked_mul(4)?)?;
- let at = |i: usize, j: usize| -> Option<(Vec3, f64)> {
- match surface {
- mt::Surface::BSplineSurface(s) => s.control_points().get(i)?.get(j).map(|p| (from_p3(*p), 1.)),
- mt::Surface::NurbsSurface(s) => s.control_points().get(i)?.get(j).map(|p| (Vec3::new(p.x / p.w, p.y / p.w, p.z / p.w), p.w)),
- _ => None,
- }
- };
+ let at = |i: usize, j: usize| -> Option<(Vec3, f64)> { points.get(i)?.get(j).copied() };
for transpose in [false, true] {
let point = |i, j| if transpose { at(j, i) } else { at(i, j) };
let (groups, length) = if transpose { (cols, rows) } else { (rows, cols) };
@@ -255,23 +286,7 @@ fn wall_supports_cap(surface: &mt::Surface, edge: &mt::Edge, plane: &Plane, leve
if !(2..=4096).contains(&groups) || length != 2 {
continue;
}
- let axial_knots = match surface {
- mt::Surface::BSplineSurface(s) => {
- if transpose {
- s.uknot_vec()
- } else {
- s.vknot_vec()
- }
- }
- mt::Surface::NurbsSurface(s) => {
- if transpose {
- s.uknot_vec()
- } else {
- s.vknot_vec()
- }
- }
- _ => return None,
- };
+ let axial_knots = if transpose { u_knots } else { v_knots };
if axial_knots.len() != 4
|| axial_knots.first() != axial_knots.get(1)
|| axial_knots.get(2) != axial_knots.last()
@@ -286,7 +301,7 @@ fn wall_supports_cap(surface: &mt::Surface, edge: &mt::Edge, plane: &Plane, leve
let (base, w) = point(i, 0)?;
let h0 = plane.height(base);
let h1 = plane.height(point(i, 1)?.0);
- if h0.min(h1) > levels.0 + tol * 8. || h0.max(h1) < levels.1 - tol * 8. || increasing.is_some_and(|s| s != (h1 > h0)) {
+ if !spans(h0, h1) || increasing.is_some_and(|s| s != (h1 > h0)) {
valid = false;
break;
}
@@ -299,46 +314,35 @@ fn wall_supports_cap(surface: &mt::Surface, edge: &mt::Edge, plane: &Plane, leve
}
}
let q = plane.to_world(p);
- projected.push(mt::Vector4::new(q.x * w, q.y * w, q.z * w, w));
+ projected.push([q.x * w, q.y * w, q.z * w, w]);
}
if !valid {
continue;
}
- let knots = match surface {
- mt::Surface::BSplineSurface(s) => {
- if transpose {
- s.vknot_vec()
- } else {
- s.uknot_vec()
- }
- }
- mt::Surface::NurbsSurface(s) => {
- if transpose {
- s.vknot_vec()
- } else {
- s.uknot_vec()
- }
- }
- _ => return None,
- };
+ let knots = if transpose { v_knots } else { u_knots };
if knots.len() > 8192 {
return None;
}
*work = work.checked_sub(knots.len())?;
- let c = mt::Curve::NurbsCurve(mt::NurbsCurve::new(mt::BSplineCurve::try_new(knots.clone(), projected).ok()?));
- let (a, b) = c.range_tuple();
- let support = mt::Edge::new(&mt::Vertex::new(c.subs(a)), &mt::Vertex::new(c.subs(b)), c);
- let Some(fit) = crate::prism_curve::segment(&support, plane, tol, work) else {
+ let degree = knots.len().checked_sub(projected.len() + 1)?;
+ let interval = [*knots.get(degree)?, *knots.get(projected.len())?];
+ if !(interval[0] < interval[1]) {
+ continue;
+ }
+ let support = Curve::RationalSpline { knots: knots.to_vec(), homogeneous: projected };
+ let eval = CurveEval::new(&support).ok()?;
+ let ends = [eval.point(interval[0])?, eval.point(interval[1])?];
+ let Some(fit) = segment(&Run { curve: &support, interval, forward: true, ends }, plane, tol, work) else {
continue;
};
let fit_loop = CapLoop { segments: Ring::from(fit.clone()), area: Interval::enclosing(0., 0.)? };
if let Some((center, radius)) = circle(&fit_loop, tol * 8.)
- && cap.iter().all(|s| matches!(*s,Seg2::Arc {center:c,radius:r,..} if c.dist(center)+(r-radius).abs()<=tol*8.))
+ && on_circle(center, radius)
{
return Some(true);
}
let same = loops_same(
- &CapLoop { segments: Ring::from(cap.clone()), area: Interval::enclosing(0., 0.)? },
+ &CapLoop { segments: Ring::from(cap.to_vec()), area: Interval::enclosing(0., 0.)? },
&CapLoop { segments: Ring::from(fit), area: Interval::enclosing(0., 0.)? },
tol * 8.,
work,
@@ -399,150 +403,109 @@ struct Certificate {
hi: f64,
}
-fn preflight_body(body: &crate::Body) -> Option<()> {
- if body.solid.boundaries().len() != 1 || body.mesh.is_some() {
+/// One closed face shell within the budgets: each face's outward side (whether it is its
+/// surface's natural normal).
+fn preflight(record: &Brep) -> Option<Vec<bool>> {
+ let [Shell::Faces { faces, .. }] = record.shells.as_slice() else { return None };
+ if record.faces.len() > 16_384 || faces.len() != record.faces.len() {
return None;
}
- let mut faces = 16_384usize;
let mut edges = 65_536usize;
- for face in body.solid.face_iter() {
- faces = faces.checked_sub(1)?;
- // Borrow absolute wires: the oriented iterator would clone a hostile
- // oversized wire before its edge count has been checked.
- for wire in face.absolute_boundaries() {
- for _ in wire.edge_iter() {
- edges = edges.checked_sub(1)?;
- }
- }
- }
- Some(())
-}
-
-/// Initial material scope: a convex straight outer or a circle, with separated
-/// circular holes. Wider profiles must acquire their own separation proof.
-fn separated_material(loops: &[CapLoop], clearance: f64, work: &mut usize) -> Option<()> {
- let outer = loops.iter().find(|l| l.area.lo > 0.)?;
- if loops.iter().filter(|l| l.area.lo > 0.).count() != 1 {
- return None;
- }
- let outer_circle = circle(outer, clearance);
- if outer_circle.is_none() {
- *work = work.checked_sub(outer.segments.len().checked_mul(outer.segments.len())?)?;
- for s in &outer.segments {
- let Seg2::Line { a, b } = *s else { return None };
- let delta = b - a;
- if delta.len() <= clearance {
- return None;
- }
- for t in &outer.segments {
- if delta.cross(t.start() - a) < -clearance * delta.len() {
- return None;
- }
- }
- }
- let mut turn = 0.;
- let mut angular_error = 0.;
- for (i, (s, next)) in outer.segments.edges().enumerate() {
- let Seg2::Line { a, b } = *s else {
- return None;
- };
- let x = b - a;
- let y = next.end() - next.start();
- turn += x.cross(y).atan2(x.dot(y));
- angular_error += clearance * 8. / x.len() + 256. * f64::EPSILON;
- for (j, t) in outer.segments.iter().enumerate() {
- if i != j && a.dist(t.start()) <= clearance {
- return None;
- }
+ for face in &record.faces {
+ for lp in &face.loops {
+ if let Loop::Edges { edges: uses } = lp {
+ edges = edges.checked_sub(uses.len())?;
}
}
- if angular_error > 1e-3 || (turn - std::f64::consts::TAU).abs() > angular_error {
- return None;
- }
}
- let mut holes = Vec::new();
- for lp in loops {
- if std::ptr::eq(lp, outer) {
- continue;
- }
- if lp.area.hi >= 0. {
+ let mut outward = vec![None; record.faces.len()];
+ for f in faces {
+ let slot = outward.get_mut(f.face as usize)?;
+ if slot.is_some() {
return None;
}
- let (center, radius) = circle(lp, clearance)?;
- if let Some((c, r)) = outer_circle {
- if center.dist(c) + radius + clearance >= r {
- return None;
- }
- } else {
- *work = work.checked_sub(outer.segments.len())?;
- for s in &outer.segments {
- let Seg2::Line { a, b } = *s else { return None };
- if (b - a).cross(center - a) / (b - a).len() <= radius + clearance {
- return None;
- }
- }
- }
- *work = work.checked_sub(holes.len())?;
- for (c, r) in &holes {
- if center.dist(*c) <= radius + r + clearance {
- return None;
- }
- }
- holes.push((center, radius));
+ *slot = Some(f.forward);
}
- Some(())
+ outward.into_iter().collect()
+}
+
+/// Face `face`'s edges, each once per use.
+fn face_edges(record: &Brep, face: usize) -> impl Iterator<Item = usize> + '_ {
+ record
+ .faces
+ .get(face)
+ .into_iter()
+ .flat_map(|f| &f.loops)
+ .flat_map(|lp| match lp {
+ Loop::Edges { edges } => edges.as_slice(),
+ Loop::Vertex { .. } => &[],
+ })
+ .map(|e| e.edge as usize)
+}
+
+/// The points of face `face`'s vertices (once per edge use).
+fn face_points(record: &Brep, face: usize) -> impl Iterator<Item = Vec3> + '_ {
+ face_edges(record, face)
+ .filter_map(|e| record.edges.get(e))
+ .flat_map(|e| e.vertices)
+ .filter_map(|v| record.vertices.get(v as usize))
+ .map(|v| v3(v.point))
+}
+
+/// Loop `l` of face `face` as it runs about the face's outward normal (`outward`: the natural
+/// one), each edge with its number.
+fn loop_runs(record: &Brep, face: usize, l: usize, outward: bool) -> Option<Vec<(usize, Run<'_>)>> {
+ let Loop::Edges { edges } = record.faces.get(face)?.loops.get(l)? else { return None };
+ let mut runs =
+ edges.iter().map(|e| Some((e.edge as usize, Run::of(record, e.edge as usize, e.forward == outward)?))).collect::<Option<Vec<_>>>()?;
+ if !outward {
+ runs.reverse();
+ }
+ Some(runs)
}
-fn certificate(body: &crate::Body, plane: &Plane, tol: f64) -> Option<Certificate> {
- preflight_body(body)?;
+fn certificate(record: &Brep, body_size: f64, plane: &Plane, tol: f64) -> Option<Certificate> {
+ let outward = preflight(record)?;
let d = plane.normal();
- let body_size = body.size();
- let mut remaining = 16_384usize;
let mut caps = Vec::new();
let mut walls = Vec::new();
let mut edge_uses = 65_536usize;
- for face in body.solid.face_iter() {
- remaining = remaining.checked_sub(1)?;
- for _ in face.edge_iter() {
+ for (fi, face) in record.faces.iter().enumerate() {
+ for _ in face_edges(record, fi) {
edge_uses = edge_uses.checked_sub(1)?;
}
- let surface = face.oriented_surface();
- if let mt::Surface::Plane(p) = &surface {
- let n = p.normal();
- let n = Vec3::new(n.x, n.y, n.z).normalized()?;
+ let out = *outward.get(fi)?;
+ if let Some((_, u, v)) = plane_of(&face.surface) {
+ let n = u.cross(v).normalized()? * if out { 1. } else { -1. };
if n.dot(d).abs() > 1. - 1e-12 {
if n.cross(d).len() * body_size > tol {
return None;
}
// A planar support's parameter origin may be arbitrarily far
// from its trimmed face. Use actual boundary geometry only.
- let level = plane.height(from_p3(face.vertex_iter().next()?.point()));
- caps.push((face, level, n.dot(d) > 0.));
+ let level = plane.height(face_points(record, fi).next()?);
+ caps.push((fi, level, n.dot(d) > 0.));
if caps.len() > 2 {
return None;
}
continue;
}
}
- walls.push((face, surface));
+ walls.push(fi);
}
if caps.len() != 2 {
return None;
}
- let top = caps.iter().find(|c| c.2)?;
- let bottom = caps.iter().find(|c| !c.2)?;
+ let top = *caps.iter().find(|c| c.2)?;
+ let bottom = *caps.iter().find(|c| !c.2)?;
let height = top.1 - bottom.1;
if height <= tol || !height.is_finite() {
return None;
}
for cap in [top, bottom] {
- let mt::Surface::Plane(support) = cap.0.oriented_surface() else {
- return None;
- };
- let origin = from_p3(support.origin());
- let (n, ne) = plane_normal(&support)?;
- for vertex in cap.0.vertex_iter() {
- let point = from_p3(vertex.point());
+ let (origin, u, v) = plane_of(&record.faces.get(cap.0)?.surface)?;
+ let (n, ne) = plane_normal(u, v)?;
+ for point in face_points(record, cap.0) {
let delta = point - origin;
let terms = (delta.x * n.x).abs() + (delta.y * n.y).abs() + (delta.z * n.z).abs();
let error = 1024. * f64::EPSILON * terms + delta.x.abs() * ne.x + delta.y.abs() * ne.y + delta.z.abs() * ne.z;
@@ -552,8 +515,12 @@ fn certificate(body: &crate::Body, plane: &Plane, tol: f64) -> Option<Certificat
}
}
let mut work = 2_000_000;
- let loops = top.0.boundaries().iter().map(|w| cap_loop(w, plane, tol, &mut work)).collect::<Option<Vec<_>>>()?;
- let lower = bottom.0.boundaries().iter().map(|w| cap_loop(w, plane, tol, &mut work)).collect::<Option<Vec<_>>>()?;
+ let cap_loops = |cap: usize, work: &mut usize| -> Option<Vec<CapLoop>> {
+ let out = *outward.get(cap)?;
+ (0..record.faces.get(cap)?.loops.len()).map(|l| cap_loop(&loop_runs(record, cap, l, out)?, plane, tol, work)).collect()
+ };
+ let loops = cap_loops(top.0, &mut work)?;
+ let lower = cap_loops(bottom.0, &mut work)?;
if loops.len() != lower.len() || loops.is_empty() || loops.len() > 8192 {
return None;
}
@@ -575,10 +542,13 @@ fn certificate(body: &crate::Body, plane: &Plane, tol: f64) -> Option<Certificat
// Include cap fitting, support fitting and the <=8tol support-to-cap
// comparison, not just the control-net's projected ruling variation.
let mut corridor = tol * 16.;
- let cap_edges = top.0.edge_iter().count().checked_add(bottom.0.edge_iter().count())?;
+ let top_edges: std::collections::BTreeSet<usize> = face_edges(record, top.0).collect();
+ let bottom_edges: std::collections::BTreeSet<usize> = face_edges(record, bottom.0).collect();
+ let cap_edges = face_edges(record, top.0).count().checked_add(face_edges(record, bottom.0).count())?;
pair_work = pair_work.checked_sub((65_536 - edge_uses).checked_mul(cap_edges)?)?;
- for (face, surface) in &walls {
- let variation = wall_error(surface, d, height, &mut controls)?;
+ for &wall in &walls {
+ let face = record.faces.get(wall)?;
+ let variation = wall_error(&face.surface, d, height, &mut controls)?;
if variation > tol * 8. {
return None;
}
@@ -590,27 +560,30 @@ fn certificate(body: &crate::Body, plane: &Plane, tol: f64) -> Option<Certificat
// correspondence, not nearest geometry or stale face provenance.
let mut upper = 0usize;
let mut lower = 0usize;
- for edge in face.edge_iter() {
- if top.0.edge_iter().any(|e| e.id() == edge.id()) {
- if !wall_supports_cap(surface, &edge, plane, (bottom.1, top.1), tol, &mut work)? {
+ for edge in face_edges(record, wall) {
+ let run = Run::of(record, edge, true)?;
+ let (on_top, on_bottom) = (top_edges.contains(&edge), bottom_edges.contains(&edge));
+ if on_top || on_bottom {
+ let cap = segment(&run, plane, tol, &mut work)?;
+ if !wall_supports_cap(&face.surface, &face.domain, &cap, plane.height(run.ends[0]), plane, (bottom.1, top.1), tol, &mut work)? {
return None;
}
- upper += 1;
- continue;
- }
- if bottom.0.edge_iter().any(|e| e.id() == edge.id()) {
- if !wall_supports_cap(surface, &edge, plane, (bottom.1, top.1), tol, &mut work)? {
- return None;
+ if on_top {
+ upper += 1;
+ } else {
+ lower += 1;
}
- lower += 1;
continue;
}
- let mt::Curve::Line(line) = edge.curve() else { return None };
- if from_p3(line.0).dist(from_p3(edge.absolute_front().point())) > tol || from_p3(line.1).dist(from_p3(edge.absolute_back().point())) > tol
- {
+ if !matches!(run.curve, Curve::Line { .. }) {
+ return None;
+ }
+ let eval = CurveEval::new(run.curve).ok()?;
+ let (p, q) = (eval.point(run.interval[0])?, eval.point(run.interval[1])?);
+ if p.dist(run.ends[0]) > tol || q.dist(run.ends[1]) > tol {
return None;
}
- let delta = from_p3(line.1) - from_p3(line.0);
+ let delta = q - p;
if delta.cross(d).len() > corridor || delta.dot(d).abs() < height - tol * 8. {
return None;
}
@@ -656,71 +629,74 @@ fn certificate(body: &crate::Body, plane: &Plane, tol: f64) -> Option<Certificat
/// `None` means unproved, including budget exhaustion; it never grants a copy.
pub fn certified_prism_equivalent(a: &crate::Body, b: &crate::Body) -> crate::Result<Option<bool>> {
crate::guard("certified prism comparison", || {
- let result = (|| {
- preflight_body(a)?;
- preflight_body(b)?;
- if !a.size().is_finite() || !b.size().is_finite() {
- return None;
- }
- let size = a.size().max(b.size()).max(1.);
- let tol = size * 1e-10;
- let identity_tol = size * 1e-7;
- let origin = a.solid.vertex_iter().next().map(|v| from_p3(v.point()))?;
- let mut candidates = Vec::new();
- let mut remaining = 16_384usize;
- for f in a.solid.face_iter() {
- remaining = remaining.checked_sub(1)?;
- if let mt::Surface::Plane(p) = f.oriented_surface() {
- let n = p.normal();
- let n = Vec3::new(n.x, n.y, n.z).normalized()?;
- if !candidates.iter().any(|d: &Vec3| d.dot(n).abs() > 1. - 1e-12) {
- candidates.push(n);
- if candidates.len() == 8 {
- break;
- }
- }
+ if a.is_mesh() || b.is_mesh() || !a.size().is_finite() || !b.size().is_finite() {
+ return Ok(None);
+ }
+ let (ra, rb) = (crate::native::brep_record(a)?, crate::native::brep_record(b)?);
+ Ok(equivalent(&ra, a.size(), &rb, b.size()))
+ })
+}
+
+/// [`certified_prism_equivalent`] of the records `a` and `b` of bodies of sizes `size_a` and
+/// `size_b`.
+fn equivalent(a: &Brep, size_a: f64, b: &Brep, size_b: f64) -> Option<bool> {
+ let outward = preflight(a)?;
+ preflight(b)?;
+ let size = size_a.max(size_b).max(1.);
+ let tol = size * 1e-10;
+ let identity_tol = size * 1e-7;
+ let origin = v3(a.vertices.first()?.point);
+ let mut candidates = Vec::new();
+ for (face, out) in a.faces.iter().zip(&outward) {
+ if let Some((_, u, v)) = plane_of(&face.surface) {
+ let n = u.cross(v).normalized()? * if *out { 1. } else { -1. };
+ if !candidates.iter().any(|d: &Vec3| d.dot(n).abs() > 1. - 1e-12) {
+ candidates.push(n);
+ if candidates.len() == 8 {
+ break;
}
}
- for d in candidates {
- let plane = Plane::from_normal(origin, d)?;
- let Some(ca) = certificate(a, &plane, tol) else { continue };
- let Some(cb) = certificate(b, &plane, tol) else { continue };
- if (ca.lo - cb.lo).abs() > identity_tol || (ca.hi - cb.hi).abs() > identity_tol || ca.loops.len() != cb.loops.len() {
- return Some(false);
- }
- let mut work = 16_000_000;
- let mut used = vec![false; cb.loops.len()];
- for lp in &ca.loops {
- let mut matched = None;
- for (i, other) in cb.loops.iter().enumerate() {
- if !used.get(i).copied()? && loops_same(lp, other, identity_tol, &mut work)? {
- if matched.is_some() {
- return None;
- }
- matched = Some(i);
- }
+ }
+ }
+ for d in candidates {
+ let plane = Plane::from_normal(origin, d)?;
+ let Some(ca) = certificate(a, size_a, &plane, tol) else { continue };
+ let Some(cb) = certificate(b, size_b, &plane, tol) else { continue };
+ if (ca.lo - cb.lo).abs() > identity_tol || (ca.hi - cb.hi).abs() > identity_tol || ca.loops.len() != cb.loops.len() {
+ return Some(false);
+ }
+ let mut work = 16_000_000;
+ let mut used = vec![false; cb.loops.len()];
+ for lp in &ca.loops {
+ let mut matched = None;
+ for (i, other) in cb.loops.iter().enumerate() {
+ if !used.get(i).copied()? && loops_same(lp, other, identity_tol, &mut work)? {
+ if matched.is_some() {
+ return None;
}
- let Some(i) = matched else { return Some(false) };
- *used.get_mut(i)? = true;
+ matched = Some(i);
}
- let delta = (ca.volume.hi - cb.volume.lo).abs().max((cb.volume.hi - ca.volume.lo).abs());
- return Some(delta <= 1e-5 * (1. + ca.volume.lo.abs()));
}
- None
- })();
- Ok(result)
- })
+ let Some(i) = matched else { return Some(false) };
+ *used.get_mut(i)? = true;
+ }
+ let delta = (ca.volume.hi - cb.volume.lo).abs().max((cb.volume.hi - ca.volume.lo).abs());
+ return Some(delta <= 1e-5 * (1. + ca.volume.lo.abs()));
+ }
+ None
}
-fn cap_loop(wire: &mt::Wire, plane: &Plane, tolerance: f64, work: &mut usize) -> Option<CapLoop> {
+/// A cap's loop from its edges in order (each with its edge number), certified segment by
+/// segment, with the interval of its signed area.
+fn cap_loop(runs: &[(usize, Run)], plane: &Plane, tolerance: f64, work: &mut usize) -> Option<CapLoop> {
let mut segments = Vec::new();
let mut area = Interval::enclosing(0., 0.)?;
let mut ids = std::collections::HashSet::new();
- for edge in wire.edge_iter() {
- if !ids.insert(edge.id()) {
+ for (id, run) in runs {
+ if !ids.insert(*id) {
return None;
}
- let certified = crate::prism_curve::segment(edge, plane, tolerance, work)?;
+ let certified = segment(run, plane, tolerance, work)?;
if segments.len().checked_add(certified.len())? > 8192 {
return None;
}
@@ -729,7 +705,9 @@ fn cap_loop(wire: &mt::Wire, plane: &Plane, tolerance: f64, work: &mut usize) ->
}
segments.extend(certified);
}
- if segments.is_empty() || !wire.is_closed() {
+ // The edges run end to end round the loop.
+ let closed = runs.iter().zip(runs.iter().cycle().skip(1)).all(|((_, a), (_, b))| a.ends[1].dist(b.ends[0]) <= 2. * tolerance);
+ if segments.is_empty() || !closed {
return None;
}
// Curve endpoints already agree with actual shared vertices in the
@@ -743,11 +721,85 @@ fn cap_loop(wire: &mt::Wire, plane: &Plane, tolerance: f64, work: &mut usize) ->
Some(CapLoop { segments, area })
}
+/// Initial material scope: a convex straight outer or a circle, with separated
+/// circular holes. Wider profiles must acquire their own separation proof.
+fn separated_material(loops: &[CapLoop], clearance: f64, work: &mut usize) -> Option<()> {
+ let outer = loops.iter().find(|l| l.area.lo > 0.)?;
+ if loops.iter().filter(|l| l.area.lo > 0.).count() != 1 {
+ return None;
+ }
+ let outer_circle = circle(outer, clearance);
+ if outer_circle.is_none() {
+ *work = work.checked_sub(outer.segments.len().checked_mul(outer.segments.len())?)?;
+ for s in &outer.segments {
+ let Seg2::Line { a, b } = *s else { return None };
+ let delta = b - a;
+ if delta.len() <= clearance {
+ return None;
+ }
+ for t in &outer.segments {
+ if delta.cross(t.start() - a) < -clearance * delta.len() {
+ return None;
+ }
+ }
+ }
+ let mut turn = 0.;
+ let mut angular_error = 0.;
+ for (i, (s, next)) in outer.segments.edges().enumerate() {
+ let Seg2::Line { a, b } = *s else {
+ return None;
+ };
+ let x = b - a;
+ let y = next.end() - next.start();
+ turn += x.cross(y).atan2(x.dot(y));
+ angular_error += clearance * 8. / x.len() + 256. * f64::EPSILON;
+ for (j, t) in outer.segments.iter().enumerate() {
+ if i != j && a.dist(t.start()) <= clearance {
+ return None;
+ }
+ }
+ }
+ if angular_error > 1e-3 || (turn - std::f64::consts::TAU).abs() > angular_error {
+ return None;
+ }
+ }
+ let mut holes = Vec::new();
+ for lp in loops {
+ if std::ptr::eq(lp, outer) {
+ continue;
+ }
+ if lp.area.hi >= 0. {
+ return None;
+ }
+ let (center, radius) = circle(lp, clearance)?;
+ if let Some((c, r)) = outer_circle {
+ if center.dist(c) + radius + clearance >= r {
+ return None;
+ }
+ } else {
+ *work = work.checked_sub(outer.segments.len())?;
+ for s in &outer.segments {
+ let Seg2::Line { a, b } = *s else { return None };
+ if (b - a).cross(center - a) / (b - a).len() <= radius + clearance {
+ return None;
+ }
+ }
+ }
+ *work = work.checked_sub(holes.len())?;
+ for (c, r) in &holes {
+ if center.dist(*c) <= radius + r + clearance {
+ return None;
+ }
+ }
+ holes.push((center, radius));
+ }
+ Some(())
+}
+
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
mod tests {
use super::*;
- use mt::builder;
fn drilled(radius: f64, shift: f64) -> crate::Body {
use solidcraft_geom::{Loop2, Region2};
@@ -758,6 +810,19 @@ mod tests {
crate::extrude(&Plane::XY, &[region], 0., 10.).unwrap().remove(0)
}
+ fn record(b: &crate::Body) -> Brep {
+ crate::native::brep_record(b).unwrap()
+ }
+
+ fn cert(b: &crate::Body, tol: f64) -> Option<Certificate> {
+ certificate(&record(b), b.size(), &Plane::XY, tol)
+ }
+
+ /// The first face of `r` not on a plane.
+ fn curved(r: &Brep) -> usize {
+ r.faces.iter().position(|f| plane_of(&f.surface).is_none()).unwrap()
+ }
+
#[test]
fn actual_drilled_prism_and_step_reopen_are_certified_without_history() {
let source = drilled(6., 0.);
@@ -766,18 +831,18 @@ mod tests {
let copy = &imported.bodies[0].body;
let exact = 4000. - 360. * std::f64::consts::PI;
for body in [&source, copy] {
- let cap = certificate(body, &Plane::XY, 3e-9).expect("actual complete current cap and walls");
+ let cap = cert(body, 3e-9).expect("actual complete current cap and walls");
assert!(cap.volume.lo <= exact && cap.volume.hi >= exact, "{:?}, expected {exact}", cap.volume);
assert!(cap.volume.hi - cap.volume.lo <= 0.001);
}
assert_eq!(certified_prism_equivalent(&source, copy).unwrap(), Some(true));
let wider = drilled(6.0001, 0.);
- let a = certificate(&source, &Plane::XY, 3e-9).unwrap();
- let b = certificate(&wider, &Plane::XY, 3e-9).unwrap();
+ let a = cert(&source, 3e-9).unwrap();
+ let b = cert(&wider, 3e-9).unwrap();
assert!(a.volume.lo - b.volume.hi > 1e-5 * (1. + a.volume.hi));
assert_eq!(certified_prism_equivalent(&source, &wider).unwrap(), Some(false));
let shifted = drilled(6., 0.0001);
- let same_volume = certificate(&shifted, &Plane::XY, 3e-9).unwrap();
+ let same_volume = cert(&shifted, 3e-9).unwrap();
assert!(same_volume.volume.lo <= exact && same_volume.volume.hi >= exact);
assert_eq!(certified_prism_equivalent(&source, &shifted).unwrap(), Some(false));
assert_eq!(crate::step_export(&[&source], "source").unwrap(), before);
@@ -785,15 +850,14 @@ mod tests {
#[test]
fn poorly_conditioned_plane_walls_do_not_get_certificates() {
- let origin = mt::Point3::new(0., 0., 0.);
- let u = mt::Point3::new(1., 0., 0.);
- let v = mt::Point3::new(1., 0., 1e-9);
- let surface = mt::Surface::Plane(mt::Plane::new(origin, u, v));
- let edge = builder::line(&mt::Vertex::new(origin), &mt::Vertex::new(u));
+ let surface = Surface::Plane { origin: [0., 0., 0.], u_axis: [1., 0., 0.], v_axis: [1., 0., 1e-9] };
+ let line = Curve::Line { start: [0., 0., 0.], end: [1., 0., 0.] };
let mut work = 2_000_000;
+ let cap =
+ segment(&Run { curve: &line, interval: [0., 1.], forward: true, ends: [Vec3::ZERO, Vec3::X] }, &Plane::XY, 1e-9, &mut work).unwrap();
assert!(wall_error(&surface, Vec3::Z, 10., &mut work).is_none());
- assert!(wall_supports_cap(&surface, &edge, &Plane::XY, (0., 10.), 1e-9, &mut work).is_none());
- let normal = plane_normal(&mt::Plane::new(origin, u, mt::Point3::new(0., 0., 1.))).unwrap();
+ assert!(wall_supports_cap(&surface, &[[0., 1.], [0., 1.]], &cap, 0., &Plane::XY, (0., 10.), 1e-9, &mut work).is_none());
+ let normal = plane_normal(Vec3::X, Vec3::Z).unwrap();
assert!(normal.0.dist(-Vec3::Y) < 1e-12);
assert!(normal.1.len() > 0.);
}
@@ -807,61 +871,69 @@ mod tests {
let saved = crate::step_export(&[&moved], "actual boolean").unwrap();
let imported = crate::step_import(&saved).unwrap();
assert_eq!(certified_prism_equivalent(&moved, &imported.bodies[0].body).unwrap(), Some(true));
- // Preserve every current cap/edge ID while replacing only the curved
+ // Preserve every current cap/edge while replacing only the curved
// wall support with radius five. Topology incidence alone must fail.
- let wrong = drilled(5., 0.);
- let wrong_surface = wrong.solid.face_iter().find(|f| !matches!(f.surface(), mt::Surface::Plane(_))).unwrap().surface();
- let faces = source
- .solid
- .face_iter()
- .map(|f| {
- if matches!(f.surface(), mt::Surface::Plane(_)) {
- return f.clone();
- }
- let mut face = mt::Face::new(f.absolute_boundaries().clone(), wrong_surface.clone());
- if !f.orientation() {
- face.invert();
- }
- face
+ let wrong = record(&drilled(5., 0.));
+ let mut invalid = record(&source);
+ let wall = curved(&invalid);
+ invalid.faces[wall].surface = wrong.faces[curved(&wrong)].surface.clone();
+ assert!(certificate(&invalid, source.size(), &Plane::XY, 3e-9).is_none());
+ // The actual wall moved 1000 up: it carries no cap edge at the part's levels.
+ let actual = record(&source);
+ let wall = curved(&actual);
+ let mut shifted = actual.faces[wall].surface.clone();
+ match &mut shifted {
+ Surface::Cylinder { frame, .. } => frame.origin[2] += 1000.,
+ Surface::PlacedRevolution { matrix, .. } => matrix[3][2] += 1000.,
+ Surface::Spline { points, .. } => points.iter_mut().flatten().for_each(|p| p[2] += 1000.),
+ Surface::RationalSpline { homogeneous, .. } => homogeneous.iter_mut().flatten().for_each(|p| p[2] += 1000. * p[3]),
+ other => panic!("unexpected wall {other:?}"),
+ }
+ let outward = preflight(&actual).unwrap();
+ let top = (0..actual.faces.len())
+ .find(|&f| {
+ plane_of(&actual.faces[f].surface)
+ .is_some_and(|(_, u, v)| u.cross(v).normalized().unwrap().z * if outward[f] { 1. } else { -1. } > 0.9)
})
- .collect::<Vec<_>>();
- let invalid = crate::Body::new(crate::body::Solid::try_new(vec![faces.into()]).unwrap()).unwrap();
- assert!(certificate(&invalid, &Plane::XY, 3e-9).is_none());
- let actual = source.solid.face_iter().find(|f| !matches!(f.surface(), mt::Surface::Plane(_))).unwrap().surface();
- let shifted = mt::Transformed::transformed(&actual, mt::Matrix4::from_translation(mt::Vector3::new(0., 0., 1000.)));
- let top = source.solid.face_iter().find(|f| matches!(f.oriented_surface(),mt::Surface::Plane(p) if p.normal().z>0.9)).unwrap();
- let arc = top.edge_iter().find(|e| !matches!(e.curve(), mt::Curve::Line(_))).unwrap();
- assert_ne!(wall_supports_cap(&shifted, &arc, &Plane::XY, (0., 10.), 3e-9, &mut 2_000_000), Some(true));
+ .unwrap();
+ let arc = face_edges(&actual, top).find(|e| !matches!(actual.edges[*e].curve, Curve::Line { .. })).unwrap();
+ let run = Run::of(&actual, arc, true).unwrap();
+ let cap = segment(&run, &Plane::XY, 3e-9, &mut 2_000_000).unwrap();
+ let domain = actual.faces[wall].domain;
+ assert_ne!(
+ wall_supports_cap(&shifted, &domain, &cap, Plane::XY.height(run.ends[0]), &Plane::XY, (0., 10.), 3e-9, &mut 2_000_000),
+ Some(true)
+ );
}
#[test]
fn cap_support_origin_is_not_a_trimmed_face_height() {
let source = drilled(6., 0.);
- let faces = source
- .solid
- .face_iter()
- .map(|f| {
- let mt::Surface::Plane(p) = f.surface() else {
- return f.clone();
- };
- if p.normal().z.abs() < 0.9 {
- return f.clone();
+ let original = record(&source);
+ let mut same = original.clone();
+ for face in &mut same.faces {
+ match &mut face.surface {
+ Surface::Plane { origin, u_axis, v_axis } if v3(*u_axis).cross(v3(*v_axis)).normalized().unwrap().z.abs() > 0.9 => {
+ *origin = (v3(*origin) + v3(*u_axis) * 1e8).into();
}
- let origin = p.origin() + p.u_axis() * 1e8;
- let plane = mt::Surface::Plane(mt::Plane::new(origin, origin + p.u_axis(), origin + p.v_axis()));
- let mut face = mt::Face::new(f.absolute_boundaries().clone(), plane);
- if !f.orientation() {
- face.invert();
+ Surface::PlaneThrough { origin, u_point, v_point } => {
+ let (o, u, v) = (v3(*origin), v3(*u_point), v3(*v_point));
+ if (u - o).cross(v - o).normalized().unwrap().z.abs() > 0.9 {
+ let shift = (u - o) * 1e8;
+ (*origin, *u_point, *v_point) = ((o + shift).into(), (u + shift).into(), (v + shift).into());
+ }
}
- face
- })
- .collect::<Vec<_>>();
- let same = crate::Body::new(crate::body::Solid::try_new(vec![faces.into()]).unwrap()).unwrap();
- assert_eq!(certified_prism_equivalent(&source, &same).unwrap(), Some(true));
+ _ => {}
+ }
+ }
+ assert_eq!(equivalent(&original, source.size(), &same, source.size()), Some(true));
+ let last = original.faces.len() - 1;
+ let outward = preflight(&original).unwrap()[last];
+ let runs = loop_runs(&original, last, 0, outward).unwrap();
assert!(
loops_same(
- &cap_loop(&source.solid.face_iter().last().unwrap().boundaries()[0], &Plane::XY, 3e-9, &mut 2_000_000).unwrap(),
- &cap_loop(&source.solid.face_iter().last().unwrap().boundaries()[0], &Plane::XY, 3e-9, &mut 2_000_000).unwrap(),
+ &cap_loop(&runs, &Plane::XY, 3e-9, &mut 2_000_000).unwrap(),
+ &cap_loop(&runs, &Plane::XY, 3e-9, &mut 2_000_000).unwrap(),
1e-6,
&mut 0
)
@@ -879,26 +951,41 @@ mod tests {
let doubled = CapLoop { segments: region.segs.iter().chain(&region.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!(certificate(&thin, &Plane::XY, 3e-6).is_none());
+ assert!(cert(&thin, 3e-6).is_none());
}
#[test]
fn current_rational_circle_green_interval_encloses_independent_area() {
let r = 6.;
- let vertices =
- [mt::Point3::new(r, 0., 0.), mt::Point3::new(0., r, 0.), mt::Point3::new(-r, 0., 0.), mt::Point3::new(0., -r, 0.)].map(builder::vertex);
- let mut edges = Vec::new();
- for i in 0..4 {
- let angle = (i as f64 + 0.5) * std::f64::consts::FRAC_PI_2;
- edges.push(builder::circle_arc(&vertices[i], &vertices[(i + 1) % 4], mt::Point3::new(r * angle.cos(), r * angle.sin(), 0.)));
- }
- let wire: mt::Wire = edges.into();
- let cap = cap_loop(&wire, &Plane::XY, 3e-9, &mut 2_000_000).unwrap();
+ let w = std::f64::consts::FRAC_1_SQRT_2;
+ let corner = |i: usize| {
+ let a = i as f64 * std::f64::consts::FRAC_PI_2;
+ Vec3::new(r * a.cos(), r * a.sin(), 0.)
+ };
+ // Four quarter circles as rational quadratic splines.
+ let curves: Vec<Curve> = (0..4)
+ .map(|i| {
+ let (a, b) = (corner(i), corner(i + 1));
+ let apex = a + b;
+ Curve::RationalSpline {
+ knots: vec![0., 0., 0., 1., 1., 1.],
+ homogeneous: vec![[a.x, a.y, 0., 1.], [apex.x * w, apex.y * w, 0., w], [b.x, b.y, 0., 1.]],
+ }
+ })
+ .collect();
+ let runs: Vec<(usize, Run)> = curves
+ .iter()
+ .enumerate()
+ .map(|(i, c)| (i, Run { curve: c, interval: [0., 1.], forward: true, ends: [corner(i), corner(i + 1)] }))
+ .collect();
+ let cap = cap_loop(&runs, &Plane::XY, 3e-9, &mut 2_000_000).unwrap();
let exact = std::f64::consts::PI * r * r;
assert!(cap.area.lo <= exact && cap.area.hi >= exact, "{:?}", cap.area);
assert!((cap.area.hi - cap.area.lo) * 10. < 0.001);
assert_eq!(cap.segments.len(), 4);
- let reversed = cap_loop(&wire.inverse(), &Plane::XY, 3e-9, &mut 2_000_000).unwrap();
+ let back: Vec<(usize, Run)> =
+ runs.iter().rev().map(|(i, run)| (*i, Run { forward: false, ends: [run.ends[1], run.ends[0]], ..*run })).collect();
+ let reversed = cap_loop(&back, &Plane::XY, 3e-9, &mut 2_000_000).unwrap();
assert!(reversed.area.lo <= -exact && reversed.area.hi >= -exact);
}
}