Wave 84/509: kernel: truck's extruded circles go into SMLib as its cylinders (and 3 more)
4 commits, squashed; the originals stay reachable from tag archive/merge-main-develop. - b27751d43 jyviko: kernel: planes go into SMLib as its planes; analytic angles start at zero - 640d3d9ea jyviko: kernel: truck's extruded circles go into SMLib as its cylinders - 1980f9743 jyviko: kernel: SMLib's export keeps every face of a void's shell - c344801cc jyviko: kernel: note that the engine's and CLI's `smlib` features reach SOLIDCRAFT_BOOLEANS Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
This commit is contained in:
@@ -76,7 +76,18 @@ mod smlib {
|
||||
let Some(r) = ta.boolean(&tb, kind).map_err(|e| failed("operation", e))? else { return Ok(None) };
|
||||
let check = r.check(CheckLevel::All).map_err(|e| failed("check", e))?;
|
||||
if !check.is_valid() {
|
||||
return Err(failed("SMLib's check refuses the result", check));
|
||||
// Whether an operand failed it already says whose the fault is.
|
||||
let operands: Vec<&str> = [("the first operand", &sa), ("the second operand", &sb)]
|
||||
.into_iter()
|
||||
.filter(|(_, s)| s.check(CheckLevel::All).is_ok_and(|c| !c.is_valid()))
|
||||
.map(|(name, _)| name)
|
||||
.collect();
|
||||
let what = if operands.is_empty() {
|
||||
"SMLib's check refuses the result".to_string()
|
||||
} else {
|
||||
format!("SMLib's check refuses the result ({} already fails it)", operands.join(" and "))
|
||||
};
|
||||
return Err(failed(&what, check));
|
||||
}
|
||||
let (body, or) = body_from_smlib_ordered(&r)?;
|
||||
let history = match (oa, ob, or) {
|
||||
|
||||
@@ -407,8 +407,10 @@ fn smlib_spline_edges_on_part_of_their_curve_decode() {
|
||||
use solidcraft_smlib::BooleanOp;
|
||||
let block = crate::box_solid(Vec3::new(7.5, 15., 0.), Vec3::new(25., 32.5, 27.5)).unwrap();
|
||||
let post = crate::cylinder(Vec3::new(12.5, 20., 10.), Vec3::Z, 5., 30.).unwrap();
|
||||
let (a, c) = (crate::native::smlib_body(&block).unwrap(), crate::native::smlib_body(&post).unwrap());
|
||||
let common = a.boolean(&c, BooleanOp::Intersect).unwrap().unwrap();
|
||||
// Both as truck holds them, the post a rational spline and the block's sides bilinear
|
||||
// patches (the import otherwise sends SMLib's cylinder and planes, whose cut leaves circles).
|
||||
let keeping = |body: &Body| solidcraft_smlib::Brep::from_record_keeping_splines(&crate::brep_record(body).unwrap(), true).unwrap();
|
||||
let common = keeping(&block).boolean(&keeping(&post), BooleanOp::Intersect).unwrap().unwrap();
|
||||
let record = common.to_native().unwrap();
|
||||
assert!(
|
||||
record.edges.iter().any(|e| matches!(e.curve.natural(), b::Natural::Range(lo, hi) if [lo, hi] != e.interval)
|
||||
|
||||
@@ -61,3 +61,35 @@ fn smlib_results_go_back_into_smlib() {
|
||||
assert!((got - exact).abs() <= 1e-6 * exact, "{name}: SMLib volume {got}, exact {exact}");
|
||||
}
|
||||
}
|
||||
|
||||
/// Truck's cylinders are circles extruded as rational splines: they go into SMLib as its
|
||||
/// cylinder, so a boolean with one intersects a plane with a cylinder, not with a spline.
|
||||
#[test]
|
||||
fn extruded_circles_go_as_cylinders() {
|
||||
use solidcraft_smlib::flat;
|
||||
let body = cylinder(v(0., 50., -60.), v(0., 0., 1.), 40.0, 120.0).unwrap();
|
||||
let record = super::brep_record(&body).unwrap();
|
||||
assert!(record.faces.iter().any(|f| matches!(f.surface, solidcraft_geom::brep::Surface::RationalSpline { .. })));
|
||||
let arrays = solidcraft_smlib::import::arrays(&record, true).unwrap();
|
||||
let kinds = &arrays.ints[&flat::FACE_SURFACE_TYPE];
|
||||
assert!(kinds.iter().all(|k| *k == i64::from(flat::SURFACE_PLANE) || *k == i64::from(flat::SURFACE_CYLINDER)), "{kinds:?}");
|
||||
assert_eq!(kinds.iter().filter(|k| **k == i64::from(flat::SURFACE_CYLINDER)).count(), record.faces.len() - 2);
|
||||
// A box cut by it is a valid SMLib solid (as a spline it had edges 0.78 mm off its faces).
|
||||
let block = box_solid(v(-14., 0., -14.), v(14., 20., 14.)).unwrap();
|
||||
let r = super::smlib_body(&block).unwrap().boolean(&super::smlib_body(&body).unwrap(), solidcraft_smlib::BooleanOp::Subtract).unwrap().unwrap();
|
||||
let check = r.check(solidcraft_smlib::CheckLevel::All).unwrap();
|
||||
assert!(check.is_valid(), "{check}");
|
||||
}
|
||||
|
||||
/// A cavity cut out of a block: SMLib's result lists the cavity's faces on the void's side with
|
||||
/// mixed orientations, and every one of them comes back.
|
||||
#[test]
|
||||
fn a_cavity_comes_back_from_smlib() {
|
||||
let block = box_solid(v(0., 0., 0.), v(40., 40., 40.)).unwrap();
|
||||
let cavity = box_solid(v(25., 25., 25.), v(30., 30., 30.)).unwrap();
|
||||
let r = super::smlib_body(&block).unwrap().boolean(&super::smlib_body(&cavity).unwrap(), solidcraft_smlib::BooleanOp::Subtract).unwrap().unwrap();
|
||||
let back = super::body_from_smlib(&r).unwrap();
|
||||
assert_eq!((back.solid.boundaries().len(), back.face_count()), (2, 12));
|
||||
let got = super::smlib_body(&back).unwrap().volume(1e-7).unwrap();
|
||||
assert!((got - (64_000.0 - 125.0)).abs() < 1e-6, "{got}");
|
||||
}
|
||||
|
||||
@@ -759,7 +759,7 @@ fn native_ordered(arrays: &Arrays) -> Res<(b::Brep, Report, Order)> {
|
||||
for fu in shell_faceuses.get(side).ok_or_else(|| invalid("shell"))?.clone() {
|
||||
let (f, same) = faceuse(fu)?;
|
||||
// A sheet lists both uses of each face in its one shell: keep the `same` one.
|
||||
if side == mate && !same {
|
||||
if mate == s && !same {
|
||||
continue;
|
||||
}
|
||||
if !face_uses.get(f).is_some_and(|u| u.iter().any(|(o, _)| *o == mate)) {
|
||||
|
||||
+59
-19
@@ -84,8 +84,22 @@ fn z_axis(f: &b::Frame) -> [f64; 3] {
|
||||
/// rules (SMLib then skips its healer); otherwise SMLib heals it on import.
|
||||
pub fn arrays(brep: &b::Brep, trusted: bool) -> R<Arrays> {
|
||||
brep.validate().map_err(|e| Unsupported::Invalid(e.0))?;
|
||||
let brep = revolved::analytic(brep)?;
|
||||
let brep = brep.as_ref();
|
||||
let brep = analytic::analytic(brep)?;
|
||||
laid_out(brep.as_ref(), trusted, true)
|
||||
}
|
||||
|
||||
/// [`arrays`] with every surface as the record holds it: a round face truck holds as a rational
|
||||
/// spline (an extruded circle) stays one, and a plane off unit orthogonal axes goes as its
|
||||
/// bilinear patch, to compare what SMLib makes of splines with what it makes of its own analytic
|
||||
/// surfaces. A revolution is still refused (SMLib has no such surface).
|
||||
pub fn arrays_keeping_splines(brep: &b::Brep, trusted: bool) -> R<Arrays> {
|
||||
brep.validate().map_err(|e| Unsupported::Invalid(e.0))?;
|
||||
laid_out(brep, trusted, false)
|
||||
}
|
||||
|
||||
/// The flat arrays; `analytic`: a plane on any axes goes as SMLib's plane (else, off unit
|
||||
/// orthogonal axes, as the bilinear patch it is).
|
||||
fn laid_out(brep: &b::Brep, trusted: bool, analytic: bool) -> R<Arrays> {
|
||||
let mut a = Arrays::default();
|
||||
|
||||
// Regions and shells. Each region gets its own copy of each shell it lists.
|
||||
@@ -156,7 +170,7 @@ pub fn arrays(brep: &b::Brep, trusted: bool) -> R<Arrays> {
|
||||
for f in &brep.faces {
|
||||
a.i(flat::FACE_LOOP_COUNT).push(int(f.loops.len())?);
|
||||
a.i(flat::FACE_TRIM_TYPE).push(0);
|
||||
let spline = surface(&mut a, &f.surface, f.domain)?;
|
||||
let spline = surface(&mut a, &f.surface, f.domain, analytic)?;
|
||||
for l in &f.loops {
|
||||
match l {
|
||||
b::Loop::Vertex { vertex } => {
|
||||
@@ -234,7 +248,7 @@ fn nurbs_face(a: &mut Arrays, u_knots: &[f64], v_knots: &[f64], nu: usize, nv: u
|
||||
}
|
||||
|
||||
/// The face's surface and range; true for a B-spline surface (which carries trims).
|
||||
fn surface(a: &mut Arrays, s: &b::Surface, domain: [[f64; 2]; 2]) -> R<bool> {
|
||||
fn surface(a: &mut Arrays, s: &b::Surface, domain: [[f64; 2]; 2], analytic_planes: bool) -> R<bool> {
|
||||
let [[u0, u1], [v0, v1]] = domain;
|
||||
let analytic = |a: &mut Arrays, kind: u8, ids: [i32; 3], f: &b::Frame| {
|
||||
a.i(flat::FACE_SURFACE_TYPE).push(i64::from(kind));
|
||||
@@ -244,8 +258,10 @@ fn surface(a: &mut Arrays, s: &b::Surface, domain: [[f64; 2]; 2]) -> R<bool> {
|
||||
a.r(flat::FACE_RANGE).extend([u0, v0, u1, v1]);
|
||||
};
|
||||
match s {
|
||||
b::Surface::Plane { origin, u_axis, v_axis } => plane(a, *origin, *u_axis, *v_axis, domain)?,
|
||||
b::Surface::PlaneThrough { origin, u_point, v_point } => plane(a, *origin, sub(*u_point, *origin), sub(*v_point, *origin), domain)?,
|
||||
b::Surface::Plane { origin, u_axis, v_axis } => plane(a, *origin, *u_axis, *v_axis, domain, analytic_planes)?,
|
||||
b::Surface::PlaneThrough { origin, u_point, v_point } => {
|
||||
plane(a, *origin, sub(*u_point, *origin), sub(*v_point, *origin), domain, analytic_planes)?
|
||||
}
|
||||
b::Surface::Cylinder { frame, radius } => {
|
||||
analytic(a, flat::SURFACE_CYLINDER, [flat::FACE_CYLINDER_ORIGIN, flat::FACE_CYLINDER_AXIS, flat::FACE_CYLINDER_REF_DIRECTION], frame);
|
||||
a.r(flat::FACE_CYLINDER_RADIUS).push(*radius);
|
||||
@@ -388,23 +404,41 @@ fn net_rows(a: &mut Arrays, cps: impl Iterator<Item = ([f64; 3], f64)>) {
|
||||
net(a, cps);
|
||||
}
|
||||
|
||||
/// A plane `origin + u·U + v·V`. With unit, orthogonal axes it is SMLib's plane, whose (u, v) are
|
||||
/// distances along them; otherwise it is the exact bilinear patch over the domain.
|
||||
fn plane(a: &mut Arrays, origin: [f64; 3], u: [f64; 3], v: [f64; 3], domain: [[f64; 2]; 2]) -> R<()> {
|
||||
/// A plane `origin + u·U + v·V` as SMLib's plane, whose (u, v) are distances along unit,
|
||||
/// orthogonal axes: U's direction, and the one at a right angle to it in the plane, the normal
|
||||
/// U × V as the record's. The range is the record's domain mapped onto those axes (its bounding
|
||||
/// box: a face's range need not be tight, and SMLib rebuilds an analytic face's trims from its
|
||||
/// edges). Truck's planes run through three points, their axes the face's own sides.
|
||||
/// Off unit orthogonal axes and not `analytic`, it goes as the exact bilinear patch over the
|
||||
/// domain instead.
|
||||
fn plane(a: &mut Arrays, origin: [f64; 3], u: [f64; 3], v: [f64; 3], domain: [[f64; 2]; 2], analytic: bool) -> R<()> {
|
||||
let [[u0, u1], [v0, v1]] = domain;
|
||||
let unit = |x: [f64; 3]| (dot(x, x).sqrt() - 1.0).abs() <= 1e-12;
|
||||
if unit(u) && unit(v) && dot(u, v).abs() <= 1e-12 {
|
||||
a.i(flat::FACE_SURFACE_TYPE).push(i64::from(flat::SURFACE_PLANE));
|
||||
a.r3(flat::FACE_PLANE_ORIGIN, origin);
|
||||
a.r3(flat::FACE_PLANE_AXIS, cross(u, v));
|
||||
a.r3(flat::FACE_PLANE_REF_DIRECTION, u);
|
||||
if !analytic && !(unit(u) && unit(v) && dot(u, v).abs() <= 1e-12) {
|
||||
nurbs_face(a, &[u0, u0, u1, u1], &[v0, v0, v1, v1], 2, 2)?;
|
||||
let at = |s: f64, t: f64| add(origin, add(scale(u, s), scale(v, t)));
|
||||
net(a, [at(u0, v0), at(u0, v1), at(u1, v0), at(u1, v1)].into_iter().map(|p| (p, 1.0)));
|
||||
a.r(flat::FACE_RANGE).extend([u0, v0, u1, v1]);
|
||||
return Ok(());
|
||||
}
|
||||
nurbs_face(a, &[u0, u0, u1, u1], &[v0, v0, v1, v1], 2, 2)?;
|
||||
let at = |s: f64, t: f64| add(origin, add(scale(u, s), scale(v, t)));
|
||||
net(a, [at(u0, v0), at(u0, v1), at(u1, v0), at(u1, v1)].into_iter().map(|p| (p, 1.0)));
|
||||
a.r(flat::FACE_RANGE).extend([u0, v0, u1, v1]);
|
||||
let n = cross(u, v);
|
||||
let (lu, ln) = (dot(u, u).sqrt(), dot(n, n).sqrt());
|
||||
if !(lu > 0.0 && ln > 0.0 && lu.is_finite() && ln.is_finite()) {
|
||||
return Err(Unsupported::Invalid("plane axes"));
|
||||
}
|
||||
let (x, z) = (scale(u, 1.0 / lu), scale(n, 1.0 / ln));
|
||||
let y = cross(z, x);
|
||||
let corners = [[u0, v0], [u0, v1], [u1, v0], [u1, v1]].map(|[s, t]| {
|
||||
let d = add(scale(u, s), scale(v, t));
|
||||
[dot(d, x), dot(d, y)]
|
||||
});
|
||||
let lo = |k: usize| corners.iter().map(|c| c[k]).fold(f64::INFINITY, f64::min);
|
||||
let hi = |k: usize| corners.iter().map(|c| c[k]).fold(f64::NEG_INFINITY, f64::max);
|
||||
a.i(flat::FACE_SURFACE_TYPE).push(i64::from(flat::SURFACE_PLANE));
|
||||
a.r3(flat::FACE_PLANE_ORIGIN, origin);
|
||||
a.r3(flat::FACE_PLANE_AXIS, z);
|
||||
a.r3(flat::FACE_PLANE_REF_DIRECTION, x);
|
||||
a.r(flat::FACE_RANGE).extend([lo(0), lo(1), hi(0), hi(1)]);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -483,7 +517,7 @@ fn curve(a: &mut Arrays, c: &b::Curve) -> R<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
mod revolved;
|
||||
mod analytic;
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
@@ -494,4 +528,10 @@ impl crate::Brep {
|
||||
let a = arrays(brep, trusted).map_err(crate::Error::Record)?;
|
||||
crate::flat::Flat::from_arrays(&a)?.import()
|
||||
}
|
||||
|
||||
/// [`crate::Brep::from_record`] through [`arrays_keeping_splines`].
|
||||
pub fn from_record_keeping_splines(brep: &b::Brep, trusted: bool) -> crate::Result<crate::Brep> {
|
||||
let a = arrays_keeping_splines(brep, trusted).map_err(crate::Error::Record)?;
|
||||
crate::flat::Flat::from_arrays(&a)?.import()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,14 +1,16 @@
|
||||
//! Revolutions as SMLib's analytic surfaces. A `placed_revolution` record holds a surface the
|
||||
//! way truck does (a profile turned about an axis, then placed); SMLib has no such surface, but
|
||||
//! every one truck makes for a cylinder, cone, sphere or torus is one of those exactly: a line
|
||||
//! along the axis, a line in a plane through it, a circle centred on it, a circle in a plane
|
||||
//! through it. Each such face becomes that analytic surface, its range mapped from the
|
||||
//! revolution's parameters, and checked point by point over the face's range; where the
|
||||
//! analytic surface's natural normal is the other way round, the face is turned over (its loops
|
||||
//! reversed, its uses in the shells flipped), which leaves the solid as it was.
|
||||
//! Revolutions and extruded circles as SMLib's analytic surfaces.
|
||||
//!
|
||||
//! A `placed_revolution` record holds a surface the way truck does (a profile turned about an
|
||||
//! axis, then placed); SMLib has no such surface, but every one truck makes for a cylinder, cone,
|
||||
//! sphere or torus is one of those exactly: a line along the axis, a line in a plane through it, a
|
||||
//! circle centred on it, a circle in a plane through it. A rational spline that is a circular arc
|
||||
//! swept straight along its axis (truck's extruded circles) is a cylinder. Each such face becomes
|
||||
//! that analytic surface with the face's range on it, checked point by point over the face's
|
||||
//! domain; where the analytic surface's natural normal is the other way round, the face is turned
|
||||
//! over (its loops reversed, its uses in the shells flipped), which leaves the solid as it was.
|
||||
//!
|
||||
//! A revolution of any other profile, or one placed by a matrix that is not a rigid motion, is
|
||||
//! refused.
|
||||
//! refused; any other spline stays a spline.
|
||||
|
||||
use std::borrow::Cow;
|
||||
use std::f64::consts::{FRAC_PI_2, TAU};
|
||||
@@ -21,36 +23,109 @@ use super::{R, Unsupported};
|
||||
|
||||
const NOT_ANALYTIC: Unsupported = Unsupported::NotYet("revolved surfaces other than cylinders, cones, spheres and tori");
|
||||
|
||||
/// `brep` with every revolution replaced by its analytic surface (borrowed when it has none).
|
||||
/// `brep` with every revolution and extruded circle replaced by its analytic surface (borrowed
|
||||
/// when it has none).
|
||||
pub(super) fn analytic(brep: &b::Brep) -> R<Cow<'_, b::Brep>> {
|
||||
if !brep.faces.iter().any(|f| matches!(f.surface, b::Surface::PlacedRevolution { .. })) {
|
||||
return Ok(Cow::Borrowed(brep));
|
||||
}
|
||||
let mut out = brep.clone();
|
||||
let size = extent(brep);
|
||||
let tol = brep.tolerance.max(1e-9 * size);
|
||||
let mut out: Option<b::Brep> = None;
|
||||
let mut turned = Vec::new();
|
||||
for (i, f) in out.faces.iter_mut().enumerate() {
|
||||
let b::Surface::PlacedRevolution { profile, origin, axis, matrix, forward } = &f.surface else { continue };
|
||||
let rev = Revolution::new(profile, *origin, *axis, matrix, *forward)?;
|
||||
let (surface, mut domain, v) = rev.analytic(f.domain)?;
|
||||
// Angles start within the first turn, where SMLib's degree domains are at home.
|
||||
domain[0] = first_turn(domain[0]);
|
||||
for (i, f) in brep.faces.iter().enumerate() {
|
||||
let found = match &f.surface {
|
||||
b::Surface::PlacedRevolution { profile, origin, axis, matrix, forward } => {
|
||||
Some(Revolution::new(profile, *origin, *axis, matrix, *forward)?.analytic(f.domain)?)
|
||||
}
|
||||
b::Surface::RationalSpline { u_knots, v_knots, homogeneous } => {
|
||||
extruded_circle(u_knots, v_knots, homogeneous, f.domain, 1e-9 * size.max(1.0))
|
||||
}
|
||||
_ => None,
|
||||
};
|
||||
let Some((mut surface, mut range)) = found else { continue };
|
||||
// The angle about the axis starts at 0: the frame turns to the face's first angle (SMLib
|
||||
// refuses an analytic range past 360°). A torus's tube angle can't turn so: it starts
|
||||
// within the first turn, where SMLib's degree domains are at home.
|
||||
turn_frame(&mut surface, range[0][0]);
|
||||
range[0] = [0.0, range[0][1] - range[0][0]];
|
||||
if matches!(surface, b::Surface::Torus { .. }) {
|
||||
domain[1] = first_turn(domain[1]);
|
||||
range[1] = first_turn(range[1]);
|
||||
}
|
||||
let flip = agree(&f.surface, f.domain, &surface, domain, &rev, &v, brep.tolerance.max(1e-9 * size))?;
|
||||
f.surface = surface;
|
||||
f.domain = domain;
|
||||
let flip = agree((&f.surface, f.domain), (&surface, range), tol)?;
|
||||
let face = out.get_or_insert_with(|| brep.clone()).faces.get_mut(i).ok_or(Unsupported::Invalid("face"))?;
|
||||
face.surface = surface;
|
||||
face.domain = range;
|
||||
if flip {
|
||||
turned.push(i);
|
||||
}
|
||||
}
|
||||
let Some(mut out) = out else { return Ok(Cow::Borrowed(brep)) };
|
||||
for i in turned {
|
||||
turn_over(&mut out, i)?;
|
||||
}
|
||||
Ok(Cow::Owned(out))
|
||||
}
|
||||
|
||||
/// A rational spline that is a circular arc swept straight along the arc's axis, as a cylinder
|
||||
/// with the face's range on it: one direction linear (two rows of control points), the second
|
||||
/// row the first moved by one vector at right angles to the circle the first row runs on, the
|
||||
/// weights alike. `None` where it is not.
|
||||
fn extruded_circle(u_knots: &[f64], v_knots: &[f64], net: &[Vec<[f64; 4]>], domain: [[f64; 2]; 2], tol: f64) -> Option<(b::Surface, [[f64; 2]; 2])> {
|
||||
let linear = |k: &[f64]| k.len() == 4 && k[0] == k[1] && k[2] == k[3] && k[1] < k[2];
|
||||
let (rows, arc_knots, arc_range, line_knots, line_range): ([Vec<[f64; 4]>; 2], &[f64], [f64; 2], &[f64], [f64; 2]) =
|
||||
if net.iter().all(|r| r.len() == 2) && linear(v_knots) && !linear(u_knots) {
|
||||
([net.iter().map(|r| r[0]).collect(), net.iter().map(|r| r[1]).collect()], u_knots, domain[0], v_knots, domain[1])
|
||||
} else if net.len() == 2 && linear(u_knots) && !linear(v_knots) {
|
||||
([net.first()?.clone(), net.get(1)?.clone()], v_knots, domain[1], u_knots, domain[0])
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
let cart = |h: &[f64; 4]| Vec3::new(h[0] / h[3], h[1] / h[3], h[2] / h[3]);
|
||||
let (first, second) = (&rows[0], &rows[1]);
|
||||
let d = cart(second.first()?) - cart(first.first()?);
|
||||
let alike = first.iter().zip(second).all(|(p, q)| (p[3] - q[3]).abs() <= 1e-12 * p[3].abs() && (cart(q) - cart(p) - d).len() <= tol);
|
||||
if !alike || first.len() != second.len() || !(d.len() > tol) {
|
||||
return None;
|
||||
}
|
||||
let arc = CurveEval::new(&b::Curve::RationalSpline { knots: arc_knots.to_vec(), homogeneous: first.clone() }).ok()?;
|
||||
let (center, radius, normal) = circle(&arc, arc_range)?;
|
||||
let z = d.normalized()?;
|
||||
if normal.cross(z).len() > 1e-9 {
|
||||
return None;
|
||||
}
|
||||
let x = (arc.point(arc_range[0])? - center).normalized()?;
|
||||
let y = z.cross(x);
|
||||
// The arc's angles from x, unwrapped along its range.
|
||||
let mut angle = 0.0;
|
||||
let mut prev = 0.0;
|
||||
for i in 1..=32 {
|
||||
let q = arc.point(arc_range[0] + (arc_range[1] - arc_range[0]) * f64::from(i) / 32.0)? - center;
|
||||
let mut a = q.dot(y).atan2(q.dot(x));
|
||||
while a - prev > std::f64::consts::PI {
|
||||
a -= TAU;
|
||||
}
|
||||
while a - prev < -std::f64::consts::PI {
|
||||
a += TAU;
|
||||
}
|
||||
prev = a;
|
||||
angle = a;
|
||||
}
|
||||
let height = |s: f64| (s - line_knots[1]) / (line_knots[2] - line_knots[1]) * d.len();
|
||||
let sorted = |a: f64, b: f64| if a <= b { [a, b] } else { [b, a] };
|
||||
let frame = b::Frame { origin: arr(center), x_axis: arr(x), y_axis: arr(y) };
|
||||
Some((b::Surface::Cylinder { frame, radius }, [sorted(0.0, angle), sorted(height(line_range[0]), height(line_range[1]))]))
|
||||
}
|
||||
|
||||
/// An analytic surface's frame turned by `angle` about its axis: u then counts from there.
|
||||
fn turn_frame(s: &mut b::Surface, angle: f64) {
|
||||
if let b::Surface::Cylinder { frame, .. } | b::Surface::Cone { frame, .. } | b::Surface::Sphere { frame, .. } | b::Surface::Torus { frame, .. } =
|
||||
s
|
||||
{
|
||||
let (x, y) = (v3(frame.x_axis), v3(frame.y_axis));
|
||||
let (sin, cos) = angle.sin_cos();
|
||||
frame.x_axis = arr(x * cos + y * sin);
|
||||
frame.y_axis = arr(y * cos - x * sin);
|
||||
}
|
||||
}
|
||||
|
||||
/// An angle range moved by whole turns to start in [0, 2π).
|
||||
fn first_turn([a, z]: [f64; 2]) -> [f64; 2] {
|
||||
let shift = (a / TAU).floor() * TAU;
|
||||
@@ -154,7 +229,7 @@ impl Revolution {
|
||||
|
||||
/// The analytic surface and the face's range on it: u the angle about z from the profile's
|
||||
/// half-plane, v as the surface's kind has it.
|
||||
fn analytic(&self, domain: [[f64; 2]; 2]) -> R<(b::Surface, [[f64; 2]; 2], V)> {
|
||||
fn analytic(&self, domain: [[f64; 2]; 2]) -> R<(b::Surface, [[f64; 2]; 2])> {
|
||||
let (t, angle) = self.ranges(domain);
|
||||
let at = |s: f64| self.profile.point(s).ok_or(Unsupported::Invalid("revolution profile"));
|
||||
let samples: Vec<Vec3> = (0..=16).map(|i| at(t[0] + (t[1] - t[0]) * f64::from(i) / 16.0)).collect::<R<_>>()?;
|
||||
@@ -188,7 +263,7 @@ impl Revolution {
|
||||
if !(r0 > 0.0) {
|
||||
return Err(NOT_ANALYTIC);
|
||||
}
|
||||
return Ok((b::Surface::Cylinder { frame: frame(foot), radius: r0 }, [angle, v], V::Height { foot, z: self.z }));
|
||||
return Ok((b::Surface::Cylinder { frame: frame(foot), radius: r0 }, [angle, v]));
|
||||
}
|
||||
// A cone on one side of its apex only.
|
||||
let r = |h: f64| r0 + h * dr / dh;
|
||||
@@ -196,7 +271,7 @@ impl Revolution {
|
||||
return Err(NOT_ANALYTIC);
|
||||
}
|
||||
let cone = b::Surface::Cone { frame: frame(foot), radius_at_origin: r0, half_angle: (dr / dh).atan() };
|
||||
return Ok((cone, [angle, v], V::Height { foot, z: self.z }));
|
||||
return Ok((cone, [angle, v]));
|
||||
}
|
||||
// A circular profile.
|
||||
let (center, radius, normal) = circle(&self.profile, t).ok_or(NOT_ANALYTIC)?;
|
||||
@@ -231,64 +306,59 @@ impl Revolution {
|
||||
return Err(NOT_ANALYTIC);
|
||||
}
|
||||
let v = [v[0].max(-FRAC_PI_2), v[1].min(FRAC_PI_2)];
|
||||
return Ok((b::Surface::Sphere { frame: frame(foot), radius }, [angle, v], V::Angle { center, x, z: self.z }));
|
||||
return Ok((b::Surface::Sphere { frame: frame(foot), radius }, [angle, v]));
|
||||
}
|
||||
let major = off.dot(x);
|
||||
if !(major > radius) {
|
||||
return Err(NOT_ANALYTIC);
|
||||
}
|
||||
let torus = b::Surface::Torus { frame: frame(foot), major_radius: major, minor_radius: radius };
|
||||
Ok((torus, [angle, sorted(first, last)], V::Angle { center, x, z: self.z }))
|
||||
}
|
||||
|
||||
/// The analytic (u, v) of the record's (u, v): the angle is the revolution's own, v that of
|
||||
/// the profile's point (at angle 0), unwrapped to within half a turn of `near`.
|
||||
fn map(&self, v: &V, uv: [f64; 2], near: f64) -> Option<[f64; 2]> {
|
||||
let (t, angle) = if self.forward { (uv[0], uv[1]) } else { (uv[1], uv[0]) };
|
||||
let p = self.profile.point(t)?;
|
||||
Some([angle, v.of(p, near)])
|
||||
Ok((torus, [angle, sorted(first, last)]))
|
||||
}
|
||||
}
|
||||
|
||||
/// How the analytic v of a profile point is found.
|
||||
enum V {
|
||||
/// Height along `z` above `foot` (cylinder, cone).
|
||||
Height { foot: Vec3, z: Vec3 },
|
||||
/// The angle about `center` from `x` towards `z` (sphere latitude, torus meridian).
|
||||
Angle { center: Vec3, x: Vec3, z: Vec3 },
|
||||
}
|
||||
|
||||
impl V {
|
||||
fn of(&self, p: Vec3, near: f64) -> f64 {
|
||||
match self {
|
||||
V::Height { foot, z } => (p - *foot).dot(*z),
|
||||
V::Angle { center, x, z } => {
|
||||
let q = p - *center;
|
||||
let mut a = q.dot(*z).atan2(q.dot(*x));
|
||||
while a - near > std::f64::consts::PI {
|
||||
a -= TAU;
|
||||
}
|
||||
while a - near < -std::f64::consts::PI {
|
||||
a += TAU;
|
||||
}
|
||||
a
|
||||
}
|
||||
/// The (u, v) of point `p` on an analytic surface, angles unwrapped to within half a turn of
|
||||
/// `near`.
|
||||
fn analytic_uv(s: &b::Surface, p: Vec3, near: [f64; 2]) -> Option<[f64; 2]> {
|
||||
let unwrap = |mut a: f64, n: f64| {
|
||||
while a - n > std::f64::consts::PI {
|
||||
a -= TAU;
|
||||
}
|
||||
}
|
||||
while a - n < -std::f64::consts::PI {
|
||||
a += TAU;
|
||||
}
|
||||
a
|
||||
};
|
||||
let (frame, round) = match s {
|
||||
b::Surface::Cylinder { frame, .. } | b::Surface::Cone { frame, .. } | b::Surface::Sphere { frame, .. } => (frame, 0.0),
|
||||
b::Surface::Torus { frame, major_radius, .. } => (frame, *major_radius),
|
||||
_ => return None,
|
||||
};
|
||||
let (x, y) = (v3(frame.x_axis), v3(frame.y_axis));
|
||||
let z = x.cross(y);
|
||||
let q = p - v3(frame.origin);
|
||||
let (qx, qy, qz) = (q.dot(x), q.dot(y), q.dot(z));
|
||||
let u = unwrap(qy.atan2(qx), near[0]);
|
||||
let r = qx.hypot(qy);
|
||||
Some(match s {
|
||||
b::Surface::Sphere { .. } => [u, qz.atan2(r)],
|
||||
b::Surface::Torus { .. } => [u, unwrap(qz.atan2(r - round), near[1])],
|
||||
_ => [u, qz],
|
||||
})
|
||||
}
|
||||
|
||||
/// Checks the analytic surface against the revolution over the face's range, 5 × 5 points
|
||||
/// within `tol`, and says whether their natural normals are opposite (the face must be turned
|
||||
/// over), read at the range's middle.
|
||||
fn agree(record: &b::Surface, domain: [[f64; 2]; 2], analytic: &b::Surface, range: [[f64; 2]; 2], rev: &Revolution, v: &V, tol: f64) -> R<bool> {
|
||||
let bad = Unsupported::Invalid("a revolution its analytic surface does not match");
|
||||
/// Checks the analytic surface against the record's over the face's domain, 5 × 5 points within
|
||||
/// `tol`, and says whether their natural normals are opposite (the face must be turned over),
|
||||
/// read at the domain's middle.
|
||||
fn agree((record, domain): (&b::Surface, [[f64; 2]; 2]), (analytic, range): (&b::Surface, [[f64; 2]; 2]), tol: f64) -> R<bool> {
|
||||
let bad = Unsupported::Invalid("a surface its analytic form does not match");
|
||||
let s = SurfaceEval::new(record).map_err(|_| bad.clone())?;
|
||||
let a = SurfaceEval::new(analytic).map_err(|_| bad.clone())?;
|
||||
let [[u0, u1], [v0, v1]] = domain;
|
||||
let near = 0.5 * (range[1][0] + range[1][1]);
|
||||
let near = [0.5 * (range[0][0] + range[0][1]), 0.5 * (range[1][0] + range[1][1])];
|
||||
let normals = |u: f64, w: f64| -> R<f64> {
|
||||
let (p, du, dv) = s.derivs(u, w).ok_or(bad.clone())?;
|
||||
let uv = rev.map(v, [u, w], near).ok_or(bad.clone())?;
|
||||
let uv = analytic_uv(analytic, p, near).ok_or(bad.clone())?;
|
||||
let (q, au, av) = a.derivs(uv[0], uv[1]).ok_or(bad.clone())?;
|
||||
if !((p - q).len() <= tol) {
|
||||
return Err(bad.clone());
|
||||
@@ -127,9 +127,9 @@ fn a_cube_record_imports_into_smlib() {
|
||||
|
||||
#[cfg(feature = "native")]
|
||||
#[test]
|
||||
fn a_skewed_plane_goes_as_an_exact_bilinear_patch() {
|
||||
fn a_plane_on_other_axes_goes_as_smlibs_plane() {
|
||||
// A tetrahedron: its faces' natural frames are unit and orthogonal, so make one plane's axes
|
||||
// non-unit to force the NURBS form and check the volume is unchanged.
|
||||
// non-unit and check it still goes as SMLib's plane, the volume unchanged.
|
||||
let c = [[0., 0., 0.], [6., 0., 0.], [0., 6., 0.], [0., 0., 6.]];
|
||||
let mut r = polyhedron(&c, &[&[0, 2, 1], &[0, 1, 3], &[1, 2, 3], &[2, 0, 3]]);
|
||||
if let Some(Face { surface: Surface::Plane { u_axis, v_axis, .. }, domain, loops }) = r.faces.get_mut(0) {
|
||||
@@ -146,7 +146,7 @@ fn a_skewed_plane_goes_as_an_exact_bilinear_patch() {
|
||||
}
|
||||
r.validate().unwrap();
|
||||
let a = arrays(&r, true).unwrap();
|
||||
assert_eq!(a.ints[&flat::FACE_SURFACE_TYPE][0], i64::from(flat::SURFACE_NURBS));
|
||||
assert_eq!(a.ints[&flat::FACE_SURFACE_TYPE][0], i64::from(flat::SURFACE_PLANE));
|
||||
let b = crate::Brep::from_record(&r, true).unwrap();
|
||||
assert!((b.volume(1e-7).unwrap() - 36.0).abs() < 1e-6, "{:?}", b.volume(1e-7));
|
||||
}
|
||||
@@ -195,7 +195,7 @@ fn revolutions_become_the_same_surface_as_a_rational_spline() {
|
||||
let (angles, prof) = ([0.4, 0.4 + 1.9 * std::f64::consts::PI], [0.0, 1.0]);
|
||||
let domain = if forward { [prof, angles] } else { [angles, prof] };
|
||||
let mut a = Arrays::default();
|
||||
surface(&mut a, &rev, domain).unwrap();
|
||||
surface(&mut a, &rev, domain, true).unwrap();
|
||||
let (nurbs, range) = first_nurbs(&a);
|
||||
let (re, ne) = (SurfaceEval::new(&rev).unwrap(), SurfaceEval::new(&nurbs).unwrap());
|
||||
let det = {
|
||||
|
||||
Reference in New Issue
Block a user