kernel: fairing works on record curves and surfaces; fair_faces rebuilds through SMLib
fair_bspline_curve/_surface and fair_nurbs_curve/_surface take and give the schema 4 record's Spline and RationalSpline kinds (the weights kept, the knots unchanged). fair_faces fairs the picked faces' surfaces in the body's record, keeps its loops, edges, vertices and pcurves, and has SMLib build the body; its history marks the faired faces modified and every edge kept when SMLib keeps the record's order, and is left off otherwise. Tests ported to the record types with their assertions. (not built: base in progress) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt
This commit is contained in:
1 parent
8d844f715c
commit
1d289dfd63
1 file changed
+165
-185
+165
-185
@@ -43,13 +43,13 @@
|
|||||||
//! control point that does not change the geometry at all — is reported as an error and the
|
//! control point that does not change the geometry at all — is reported as an error and the
|
||||||
//! geometry is left alone.
|
//! geometry is left alone.
|
||||||
|
|
||||||
|
use solidcraft_geom::brep as b;
|
||||||
use solidcraft_geom::bspline::{HPoint, MAX_SPLINE_DEGREE, NurbsSurface, Side, SplineError, check_knots, local_basis};
|
use solidcraft_geom::bspline::{HPoint, MAX_SPLINE_DEGREE, NurbsSurface, Side, SplineError, check_knots, local_basis};
|
||||||
use solidcraft_geom::{Grid, Vec3};
|
use solidcraft_geom::{Grid, Vec3};
|
||||||
use truck_modeling as mt;
|
|
||||||
|
|
||||||
use crate::body::Body;
|
use crate::body::Body;
|
||||||
use crate::history::Change;
|
use crate::history::Change;
|
||||||
use crate::{KernelError, Result, guard};
|
use crate::{KernelError, Result};
|
||||||
|
|
||||||
/// Most steps one fairing run takes (see [`FairOptions::iterations`]).
|
/// Most steps one fairing run takes (see [`FairOptions::iterations`]).
|
||||||
pub const MAX_FAIR_ITERATIONS: usize = 1000;
|
pub const MAX_FAIR_ITERATIONS: usize = 1000;
|
||||||
@@ -720,60 +720,62 @@ pub fn fair_net<const N: usize>(degree: [usize; 2], knots: [&[f64]; 2], ctrl: &G
|
|||||||
Ok(FairNet { degree, knots: [knots[0].to_vec(), knots[1].to_vec()], ctrl: faired, report })
|
Ok(FairNet { degree, knots: [knots[0].to_vec(), knots[1].to_vec()], ctrl: faired, report })
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Fair a truck B-spline curve's control points: [`fair_curve`] on its three-dimensional points,
|
/// The degree of a spline record of `count` control points on `knots`.
|
||||||
/// rebuilt as a B-spline of the same knots. Guarded here itself, like every call into truck, so a
|
fn degree_of(knots: &[f64], count: usize) -> Result<usize> {
|
||||||
/// panic inside comes back as an error and the design is left alone.
|
knots.len().checked_sub(count + 1).ok_or_else(|| KernelError::Invalid(format!("{} knots are too few for {count} control points", knots.len())))
|
||||||
pub fn fair_bspline_curve(curve: &mt::BSplineCurve<mt::Point3>, opts: &FairOptions) -> Result<(mt::BSplineCurve<mt::Point3>, FairReport)> {
|
|
||||||
guard("fair a B-spline curve", || {
|
|
||||||
let ctrl: Vec<[f64; 3]> = curve.control_points().iter().map(|p| [p.x, p.y, p.z]).collect();
|
|
||||||
let faired = fair_curve(curve.degree(), curve.knot_vec(), &ctrl, opts)?;
|
|
||||||
let points: Vec<mt::Point3> = faired.ctrl.iter().map(|c| mt::Point3::new(c[0], c[1], c[2])).collect();
|
|
||||||
let curve = mt::BSplineCurve::try_new(mt::KnotVec::from(faired.knots), points).map_err(|e| KernelError::Failed(format!("fair: {e}")))?;
|
|
||||||
Ok((curve, faired.report))
|
|
||||||
})
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Fair a truck rational curve's control points: its Cartesian control points are faired like any
|
/// Fair a B-spline curve record's control points (a `Curve::Spline`): [`fair_curve`] on its
|
||||||
/// other curve and its weights are kept, so the result is the same rational curve with moved
|
/// points, the same knots.
|
||||||
/// control points. The convex-hull bound that keeps the geometry within the tolerance still
|
pub fn fair_bspline_curve(curve: &b::Curve, opts: &FairOptions) -> Result<(b::Curve, FairReport)> {
|
||||||
/// holds, because with the weights unchanged the rational basis functions are non-negative and
|
let b::Curve::Spline { knots, points } = curve else { return Err(KernelError::Invalid("not a B-spline curve".into())) };
|
||||||
/// sum to one. Guarded like [`fair_bspline_curve`].
|
let faired = fair_curve(degree_of(knots, points.len())?, knots, points, opts)?;
|
||||||
pub fn fair_nurbs_curve(curve: &mt::NurbsCurve<mt::Vector4>, opts: &FairOptions) -> Result<(mt::NurbsCurve<mt::Vector4>, FairReport)> {
|
Ok((b::Curve::Spline { knots: faired.knots, points: faired.ctrl }, faired.report))
|
||||||
guard("fair a NURBS curve", || {
|
|
||||||
let count = curve.control_points().len();
|
|
||||||
let mut ctrl = Vec::with_capacity(count);
|
|
||||||
let mut weights = Vec::with_capacity(count);
|
|
||||||
for h in curve.control_points() {
|
|
||||||
let Some(p) = (HPoint { x: h.x, y: h.y, z: h.z, w: h.w }).project() else {
|
|
||||||
return Err(KernelError::Invalid("a control point has no position: its weight is zero".into()));
|
|
||||||
};
|
|
||||||
ctrl.push([p.x, p.y, p.z]);
|
|
||||||
weights.push(h.w);
|
|
||||||
}
|
|
||||||
let faired = fair_curve(curve.degree(), curve.knot_vec(), &ctrl, opts)?;
|
|
||||||
let points: Vec<mt::Vector4> = faired.ctrl.iter().zip(&weights).map(|(c, w)| mt::Vector4::new(c[0] * w, c[1] * w, c[2] * w, *w)).collect();
|
|
||||||
let bsp = mt::BSplineCurve::try_new(mt::KnotVec::from(faired.knots), points).map_err(|e| KernelError::Failed(format!("fair: {e}")))?;
|
|
||||||
Ok((mt::NurbsCurve::new(bsp), faired.report))
|
|
||||||
})
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Fair a truck B-spline surface's control net: [`fair_net`] on its points, rebuilt as a B-spline
|
/// Fair a rational curve record's control points (a `Curve::RationalSpline`): its Cartesian
|
||||||
/// of the same knots, with the boundary rows held. Guarded like [`fair_bspline_curve`].
|
/// control points are faired like any other curve and its weights are kept, so the result is the
|
||||||
pub fn fair_bspline_surface(surface: &mt::BSplineSurface<mt::Point3>, opts: &FairOptions) -> Result<(mt::BSplineSurface<mt::Point3>, FairReport)> {
|
/// same rational curve with moved control points. The convex-hull bound that keeps the geometry
|
||||||
guard("fair a B-spline surface", || {
|
/// within the tolerance still holds, because with the weights unchanged the rational basis
|
||||||
let net = truck_net(surface.control_points())?;
|
/// functions are non-negative and sum to one.
|
||||||
let (ku, kv) = surface.knot_vecs();
|
pub fn fair_nurbs_curve(curve: &b::Curve, opts: &FairOptions) -> Result<(b::Curve, FairReport)> {
|
||||||
let (pu, pv) = surface.degrees();
|
let b::Curve::RationalSpline { knots, homogeneous } = curve else { return Err(KernelError::Invalid("not a rational B-spline curve".into())) };
|
||||||
let faired = fair_net([pu, pv], [ku, kv], &net.map(|p| [p.x, p.y, p.z]), opts)?;
|
let hpoints: Vec<HPoint> = homogeneous.iter().map(|h| HPoint { x: h[0], y: h[1], z: h[2], w: h[3] }).collect();
|
||||||
let net = faired.ctrl.map(|[x, y, z]| mt::Point3::new(x, y, z)).into_u_rows();
|
let ctrl = positions(&Grid::row(hpoints.clone()))?;
|
||||||
let surface = mt::BSplineSurface::try_new((ku.clone(), kv.clone()), net).map_err(|e| KernelError::Failed(format!("fair: {e}")))?;
|
let faired = fair_curve(degree_of(knots, homogeneous.len())?, knots, ctrl.cells(), opts)?;
|
||||||
Ok((surface, faired.report))
|
let net = reweighted(Grid::row(hpoints), &Grid::row(faired.ctrl));
|
||||||
})
|
let homogeneous = net.into_cells().into_iter().map(|h| [h.x, h.y, h.z, h.w]).collect();
|
||||||
|
Ok((b::Curve::RationalSpline { knots: faired.knots, homogeneous }, faired.report))
|
||||||
}
|
}
|
||||||
|
|
||||||
/// A truck surface's control net (`rows[i][j]`, i along u) as a grid: refused when it is empty
|
/// Fair a B-spline surface record's control net (a `Surface::Spline`): [`fair_net`] on its
|
||||||
|
/// points, the same knots, the boundary rows held.
|
||||||
|
pub fn fair_bspline_surface(surface: &b::Surface, opts: &FairOptions) -> Result<(b::Surface, FairReport)> {
|
||||||
|
let b::Surface::Spline { u_knots, v_knots, points } = surface else { return Err(KernelError::Invalid("not a B-spline surface".into())) };
|
||||||
|
let net = record_net(points)?;
|
||||||
|
let [cu, cv] = net.count();
|
||||||
|
let degree = [degree_of(u_knots, cu)?, degree_of(v_knots, cv)?];
|
||||||
|
let faired = fair_net(degree, [u_knots, v_knots], &net, opts)?;
|
||||||
|
Ok((b::Surface::Spline { u_knots: u_knots.clone(), v_knots: v_knots.clone(), points: faired.ctrl.into_u_rows() }, faired.report))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Fair a rational surface record's control net (a `Surface::RationalSpline`), like
|
||||||
|
/// [`fair_surface`]: the Cartesian control points are faired, the weights kept.
|
||||||
|
pub fn fair_nurbs_surface(surface: &b::Surface, opts: &FairOptions) -> Result<(b::Surface, FairReport)> {
|
||||||
|
let b::Surface::RationalSpline { u_knots, v_knots, homogeneous } = surface else {
|
||||||
|
return Err(KernelError::Invalid("not a rational B-spline surface".into()));
|
||||||
|
};
|
||||||
|
let net = record_net(homogeneous)?.map(|h| HPoint { x: h[0], y: h[1], z: h[2], w: h[3] });
|
||||||
|
let [cu, cv] = net.count();
|
||||||
|
let degree = [degree_of(u_knots, cu)?, degree_of(v_knots, cv)?];
|
||||||
|
let faired = fair_net(degree, [u_knots, v_knots], &positions(&net)?, opts)?;
|
||||||
|
let homogeneous = reweighted(net, &faired.ctrl).map(|h| [h.x, h.y, h.z, h.w]).into_u_rows();
|
||||||
|
Ok((b::Surface::RationalSpline { u_knots: u_knots.clone(), v_knots: v_knots.clone(), homogeneous }, faired.report))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A surface record's control net (`rows[i][j]`, i along u) as a grid: refused when it is empty
|
||||||
/// or not rectangular.
|
/// or not rectangular.
|
||||||
fn truck_net<P: Clone>(rows: &[Vec<P>]) -> Result<Grid<P>> {
|
fn record_net<P: Clone>(rows: &[Vec<P>]) -> Result<Grid<P>> {
|
||||||
let net = Grid::from_u_rows(rows).ok_or_else(|| KernelError::Invalid("the surface's control net is not rectangular".into()))?;
|
let net = Grid::from_u_rows(rows).ok_or_else(|| KernelError::Invalid("the surface's control net is not rectangular".into()))?;
|
||||||
if net.is_empty() {
|
if net.is_empty() {
|
||||||
return Err(KernelError::Invalid("the surface has no control points".into()));
|
return Err(KernelError::Invalid("the surface has no control points".into()));
|
||||||
@@ -813,30 +815,15 @@ pub fn fair_surface(surface: &NurbsSurface, opts: &FairOptions) -> Result<(Nurbs
|
|||||||
Ok((out, faired.report))
|
Ok((out, faired.report))
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Fair a truck rational surface's control net, like [`fair_surface`]: the Cartesian control
|
|
||||||
/// points are faired, the weights kept, and the result is a NURBS surface of the same knots.
|
|
||||||
/// Guarded like [`fair_bspline_curve`].
|
|
||||||
pub fn fair_nurbs_surface(surface: &mt::NurbsSurface<mt::Vector4>, opts: &FairOptions) -> Result<(mt::NurbsSurface<mt::Vector4>, FairReport)> {
|
|
||||||
guard("fair a NURBS surface", || {
|
|
||||||
let bsp = surface.non_rationalized();
|
|
||||||
let net = truck_net(bsp.control_points())?.map(|h| HPoint { x: h.x, y: h.y, z: h.z, w: h.w });
|
|
||||||
let (ku, kv) = bsp.knot_vecs();
|
|
||||||
let (pu, pv) = bsp.degrees();
|
|
||||||
let faired = fair_net([pu, pv], [ku, kv], &positions(&net)?, opts)?;
|
|
||||||
let net = reweighted(net, &faired.ctrl).map(|h| mt::Vector4::new(h.x, h.y, h.z, h.w)).into_u_rows();
|
|
||||||
let bsp = mt::BSplineSurface::try_new((ku.clone(), kv.clone()), net).map_err(|e| KernelError::Failed(format!("fair: {e}")))?;
|
|
||||||
Ok((mt::NurbsSurface::new(bsp), faired.report))
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Fair the B-spline faces at `faces` (indices in `body`'s face order) of `body`: each face's
|
/// Fair the B-spline faces at `faces` (indices in `body`'s face order) of `body`: each face's
|
||||||
/// interior control vertices move to flatten the thin-plate energy of the face while its boundary
|
/// interior control vertices move to flatten the thin-plate energy of the face while its boundary
|
||||||
/// rows stay put, so the face keeps meeting its neighbours as it did.
|
/// rows stay put, so the face keeps meeting its neighbours as it did.
|
||||||
///
|
///
|
||||||
/// Every picked face keeps the very wires, edges and vertices it had and the way it pointed: only
|
/// Every picked face keeps the very loops, edges and vertices it had and the way it pointed: only
|
||||||
/// the surface between them changes, so the body is as closed (or as open) as it was, holes and
|
/// its surface changes in the body's record, so the body is as closed (or as open) as it was,
|
||||||
/// all. A face that is not a B-spline (a plane, cylinder, cone, sphere, torus or swept face) has no
|
/// holes and all, and SMLib builds it from that record. A face that is not a B-spline (a plane,
|
||||||
/// control points to fair and is refused by name; a mesh body has no faces to fair at all.
|
/// cylinder, cone, sphere, torus or revolution) has no control points to fair and is refused by
|
||||||
|
/// name; a mesh body has no faces to fair at all.
|
||||||
///
|
///
|
||||||
/// The report is over the picked faces together: the energies summed, the largest movement of any
|
/// The report is over the picked faces together: the energies summed, the largest movement of any
|
||||||
/// control point, and the energy trace as the sum at each step (a face that stops early keeps its
|
/// control point, and the energy trace as the sum at each step (a face that stops early keeps its
|
||||||
@@ -844,14 +831,15 @@ pub fn fair_nurbs_surface(surface: &mt::NurbsSurface<mt::Vector4>, opts: &FairOp
|
|||||||
pub fn fair_faces(body: &Body, faces: &[usize], opts: &FairOptions) -> Result<(Body, FairReport)> {
|
pub fn fair_faces(body: &Body, faces: &[usize], opts: &FairOptions) -> Result<(Body, FairReport)> {
|
||||||
let opts = opts.checked()?;
|
let opts = opts.checked()?;
|
||||||
body.require_brep("fair")?;
|
body.require_brep("fair")?;
|
||||||
let all: Vec<mt::Face> = body.solid.face_iter().cloned().collect();
|
let mut record = crate::native::brep_record(body)?;
|
||||||
if all.is_empty() {
|
let count = record.faces.len();
|
||||||
|
if count == 0 {
|
||||||
return Err(KernelError::Invalid("the body has no faces".into()));
|
return Err(KernelError::Invalid("the body has no faces".into()));
|
||||||
}
|
}
|
||||||
let mut picked: Vec<usize> = Vec::new();
|
let mut picked: Vec<usize> = Vec::new();
|
||||||
for &i in faces {
|
for &i in faces {
|
||||||
if i >= all.len() {
|
if i >= count {
|
||||||
return Err(KernelError::Invalid(format!("no face {i}: the body has {}", all.len())));
|
return Err(KernelError::Invalid(format!("no face {i}: the body has {count}")));
|
||||||
}
|
}
|
||||||
if !picked.contains(&i) {
|
if !picked.contains(&i) {
|
||||||
picked.push(i);
|
picked.push(i);
|
||||||
@@ -860,78 +848,52 @@ pub fn fair_faces(body: &Body, faces: &[usize], opts: &FairOptions) -> Result<(B
|
|||||||
if picked.is_empty() {
|
if picked.is_empty() {
|
||||||
return Err(KernelError::Invalid("pick the faces to fair".into()));
|
return Err(KernelError::Invalid("pick the faces to fair".into()));
|
||||||
}
|
}
|
||||||
guard("fair faces", || {
|
let mut reports: Vec<FairReport> = Vec::with_capacity(picked.len());
|
||||||
let mut faired = all.clone();
|
for &i in &picked {
|
||||||
let mut reports: Vec<FairReport> = Vec::with_capacity(picked.len());
|
let Some(face) = record.faces.get_mut(i) else { continue };
|
||||||
for &i in &picked {
|
let (surface, report) = match &face.surface {
|
||||||
let Some(face) = all.get(i) else { continue };
|
b::Surface::Spline { .. } => fair_bspline_surface(&face.surface, &opts)?,
|
||||||
let (surface, report) = match face.surface() {
|
b::Surface::RationalSpline { .. } => fair_nurbs_surface(&face.surface, &opts)?,
|
||||||
mt::Surface::BSplineSurface(s) => {
|
_ => {
|
||||||
let (faired, report) = fair_bspline_surface(&s, &opts)?;
|
return Err(KernelError::Invalid(format!(
|
||||||
(mt::Surface::BSplineSurface(faired), report)
|
"face {i} is not a B-spline face: a plane, cylinder, cone, sphere, torus or revolution has no control points to fair"
|
||||||
}
|
)));
|
||||||
mt::Surface::NurbsSurface(s) => {
|
|
||||||
let (faired, report) = fair_nurbs_surface(&s, &opts)?;
|
|
||||||
(mt::Surface::NurbsSurface(faired), report)
|
|
||||||
}
|
|
||||||
_ => {
|
|
||||||
return Err(KernelError::Invalid(format!(
|
|
||||||
"face {i} is not a B-spline face: a plane, cylinder, cone, sphere, torus or swept face has no control points to fair"
|
|
||||||
)));
|
|
||||||
}
|
|
||||||
};
|
|
||||||
// The same face as before, wires and all, with the faired surface between them.
|
|
||||||
let mut nf = mt::Face::new_unchecked(face.absolute_boundaries().clone(), surface);
|
|
||||||
if !face.orientation() {
|
|
||||||
nf.invert();
|
|
||||||
}
|
}
|
||||||
if let Some(slot) = faired.get_mut(i) {
|
|
||||||
*slot = nf;
|
|
||||||
}
|
|
||||||
reports.push(report);
|
|
||||||
}
|
|
||||||
let report = FairReport {
|
|
||||||
energy_before: reports.iter().map(|r| r.energy_before).sum(),
|
|
||||||
energy_after: reports.iter().map(|r| r.energy_after).sum(),
|
|
||||||
steps: reports.iter().map(|r| r.steps).max().unwrap_or(0),
|
|
||||||
movement: reports.iter().fold(0.0f64, |m, r| m.max(r.movement)),
|
|
||||||
energy_trace: {
|
|
||||||
let longest = reports.iter().map(|r| r.energy_trace.len()).max().unwrap_or(0);
|
|
||||||
(0..longest).map(|k| reports.iter().map(|r| r.energy_trace.get(k).copied().unwrap_or(r.energy_after)).sum()).collect()
|
|
||||||
},
|
|
||||||
};
|
};
|
||||||
// The body shell for shell, in its own face order: a body with holes keeps them.
|
face.surface = surface;
|
||||||
let mut shells: Vec<mt::Shell> = Vec::with_capacity(body.solid.boundaries().len());
|
reports.push(report);
|
||||||
let mut index = 0usize;
|
}
|
||||||
for shell in body.solid.boundaries() {
|
let report = FairReport {
|
||||||
let mut shell_faces = Vec::with_capacity(shell.face_iter().count());
|
energy_before: reports.iter().map(|r| r.energy_before).sum(),
|
||||||
for f in shell.face_iter() {
|
energy_after: reports.iter().map(|r| r.energy_after).sum(),
|
||||||
let i = index;
|
steps: reports.iter().map(|r| r.steps).max().unwrap_or(0),
|
||||||
index += 1;
|
movement: reports.iter().fold(0.0f64, |m, r| m.max(r.movement)),
|
||||||
shell_faces.push(faired.get(i).cloned().unwrap_or_else(|| f.clone()));
|
energy_trace: {
|
||||||
}
|
let longest = reports.iter().map(|r| r.energy_trace.len()).max().unwrap_or(0);
|
||||||
shells.push(mt::Shell::from(shell_faces));
|
(0..longest).map(|k| reports.iter().map(|r| r.energy_trace.get(k).copied().unwrap_or(r.energy_after)).sum()).collect()
|
||||||
|
},
|
||||||
|
};
|
||||||
|
let smlib = solidcraft_smlib::Brep::from_record(&record, true).map_err(|e| KernelError::Failed(format!("fair: SMLib: {e}")))?;
|
||||||
|
let (result, order) = crate::native::body_from_smlib_ordered(&smlib)?;
|
||||||
|
// The topology is the body's own, so SMLib's order is the body's: each face kept or
|
||||||
|
// modified, each edge kept. Where SMLib's order is not the record's the history is not known.
|
||||||
|
let kept = order.is_some_and(|o| o.faces.iter().enumerate().all(|(i, f)| i == *f) && o.edges.iter().enumerate().all(|(i, e)| i == *e));
|
||||||
|
if !kept || result.face_count() != body.face_count() || result.edge_count() != body.edge_count() {
|
||||||
|
return Ok((result, report));
|
||||||
|
}
|
||||||
|
let mut history = <crate::history::History as crate::history::BodyHistory>::identity(body);
|
||||||
|
for &i in &picked {
|
||||||
|
if let Some(f) = history.faces.get_mut(i) {
|
||||||
|
f.change = Change::Modified;
|
||||||
}
|
}
|
||||||
// The topology is the body's own, face for face, so the solid is built as it (the shells
|
}
|
||||||
// are as closed, or as open, as they were) and only the shape is measured anew.
|
Ok((result.with_history(history, &[body])?, report))
|
||||||
let mut result = body.clone();
|
|
||||||
result.solid = std::sync::Arc::new(mt::Solid::new_unchecked(shells));
|
|
||||||
result.size = 0.0;
|
|
||||||
result.volume = Some(std::sync::Arc::new(std::sync::Mutex::new(None)));
|
|
||||||
result.coarse_missing = None;
|
|
||||||
result.history = None;
|
|
||||||
result.phased = false;
|
|
||||||
let faces: Vec<crate::history::FaceProv> =
|
|
||||||
(0..all.len()).map(|i| crate::record::from_face(0, i, if picked.contains(&i) { Change::Modified } else { Change::Kept })).collect();
|
|
||||||
let result = crate::record::attach(result, &[crate::record::Operand::new(body)], Some(faces), std::collections::HashMap::new())?;
|
|
||||||
Ok((result, report))
|
|
||||||
})
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod tests {
|
mod tests {
|
||||||
use super::*;
|
use super::*;
|
||||||
use mt::ParametricCurve;
|
use solidcraft_geom::brep::eval::CurveEval;
|
||||||
|
|
||||||
/// A clamped uniform knot vector over `[0, spans]` of degree `degree`: `spans + degree`
|
/// A clamped uniform knot vector over `[0, spans]` of degree `degree`: `spans + degree`
|
||||||
/// control points.
|
/// control points.
|
||||||
@@ -984,8 +946,8 @@ mod tests {
|
|||||||
}
|
}
|
||||||
|
|
||||||
/// The greatest distance between two points of space, in mm.
|
/// The greatest distance between two points of space, in mm.
|
||||||
fn apart(a: mt::Point3, b: mt::Point3) -> f64 {
|
fn apart(a: Vec3, b: Vec3) -> f64 {
|
||||||
((a.x - b.x).powi(2) + (a.y - b.y).powi(2) + (a.z - b.z).powi(2)).sqrt()
|
a.dist(b)
|
||||||
}
|
}
|
||||||
|
|
||||||
/// A geom point as a coordinate triple.
|
/// A geom point as a coordinate triple.
|
||||||
@@ -1218,28 +1180,29 @@ mod tests {
|
|||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn the_truck_wrappers_fair_a_spline_curve_and_surface_with_their_ends_held() {
|
fn the_record_wrappers_fair_a_spline_curve_and_surface_with_their_ends_held() {
|
||||||
let knots = [0.0, 0.0, 0.0, 0.0, 1.0, 3.0, 5.0, 9.0, 9.0, 9.0, 9.0];
|
let knots = [0.0, 0.0, 0.0, 0.0, 1.0, 3.0, 5.0, 9.0, 9.0, 9.0, 9.0];
|
||||||
let smooth = affine_curve(&knots, 3, [-20.0, 5.0, 1.5], [4.0, -2.5, 3.0]);
|
let smooth = affine_curve(&knots, 3, [-20.0, 5.0, 1.5], [4.0, -2.5, 3.0]);
|
||||||
let mut rough = smooth.clone();
|
let mut rough = smooth.clone();
|
||||||
rough[2][2] += 3.0;
|
rough[2][2] += 3.0;
|
||||||
rough[4][1] -= 2.0;
|
rough[4][1] -= 2.0;
|
||||||
let points = |net: &[[f64; 3]]| -> Vec<mt::Point3> { net.iter().map(|c| mt::Point3::new(c[0], c[1], c[2])).collect() };
|
let curve = b::Curve::Spline { knots: knots.to_vec(), points: rough.clone() };
|
||||||
let curve = mt::BSplineCurve::try_new(mt::KnotVec::from(knots.to_vec()), points(&rough)).unwrap();
|
|
||||||
let tolerance = 5.0;
|
let tolerance = 5.0;
|
||||||
let opts = FairOptions::new(1.0, 8, false, tolerance).unwrap();
|
let opts = FairOptions::new(1.0, 8, false, tolerance).unwrap();
|
||||||
let (faired, report) = fair_bspline_curve(&curve, &opts).unwrap();
|
let (faired, report) = fair_bspline_curve(&curve, &opts).unwrap();
|
||||||
|
let (fe, ce) = (CurveEval::new(&faired).unwrap(), CurveEval::new(&curve).unwrap());
|
||||||
let mut off = 0.0f64;
|
let mut off = 0.0f64;
|
||||||
for k in 0..=64 {
|
for k in 0..=64 {
|
||||||
let t = 9.0 * f64::from(k) / 64.0;
|
let t = 9.0 * f64::from(k) / 64.0;
|
||||||
off = off.max(apart(faired.subs(t), curve.subs(t)));
|
off = off.max(apart(fe.point(t).unwrap(), ce.point(t).unwrap()));
|
||||||
}
|
}
|
||||||
eprintln!(
|
eprintln!(
|
||||||
"truck curve: energy {:e} → {:e} in {} steps, moved {off:e} mm ({:e} mm of control points)",
|
"record curve: energy {:e} → {:e} in {} steps, moved {off:e} mm ({:e} mm of control points)",
|
||||||
report.energy_before, report.energy_after, report.steps, report.movement
|
report.energy_before, report.energy_after, report.steps, report.movement
|
||||||
);
|
);
|
||||||
assert_eq!(faired.control_points().first().copied(), curve.control_points().first().copied());
|
let b::Curve::Spline { points: moved, .. } = &faired else { panic!("a B-spline curve") };
|
||||||
assert_eq!(faired.control_points().last().copied(), curve.control_points().last().copied());
|
assert_eq!(moved.first(), rough.first());
|
||||||
|
assert_eq!(moved.last(), rough.last());
|
||||||
assert!(off <= tolerance * (1.0 + 1e-9), "{off:e}");
|
assert!(off <= tolerance * (1.0 + 1e-9), "{off:e}");
|
||||||
assert!(report.energy_after < 1e-9 * report.energy_before);
|
assert!(report.energy_after < 1e-9 * report.energy_before);
|
||||||
|
|
||||||
@@ -1251,25 +1214,25 @@ mod tests {
|
|||||||
let smooth = planar_net(&ku, &kv, degree, [0.0, 0.0, 0.0], [20.0, 0.0, 0.0], [0.0, 15.0, 0.0]);
|
let smooth = planar_net(&ku, &kv, degree, [0.0, 0.0, 0.0], [20.0, 0.0, 0.0], [0.0, 15.0, 0.0]);
|
||||||
let mut rough = smooth.clone();
|
let mut rough = smooth.clone();
|
||||||
rough[2 * cu + 2][2] += 5.0;
|
rough[2 * cu + 2][2] += 5.0;
|
||||||
let rows: Vec<Vec<mt::Point3>> =
|
let rows: Vec<Vec<[f64; 3]>> = (0..cu).map(|i| (0..cv).map(|j| rough[j * cu + i]).collect()).collect();
|
||||||
(0..cu).map(|i| (0..cv).map(|j| mt::Point3::new(rough[j * cu + i][0], rough[j * cu + i][1], rough[j * cu + i][2])).collect()).collect();
|
let surface = b::Surface::Spline { u_knots: ku.clone(), v_knots: kv.clone(), points: rows.clone() };
|
||||||
let surface = mt::BSplineSurface::try_new((mt::KnotVec::from(ku.clone()), mt::KnotVec::from(kv.clone())), rows).unwrap();
|
|
||||||
let (faired, report) = fair_bspline_surface(&surface, &FairOptions::new(1.0, 6, true, 8.0).unwrap()).unwrap();
|
let (faired, report) = fair_bspline_surface(&surface, &FairOptions::new(1.0, 6, true, 8.0).unwrap()).unwrap();
|
||||||
eprintln!("truck surface: energy {:e} → {:e}, {} steps", report.energy_before, report.energy_after, report.steps);
|
let b::Surface::Spline { points: moved, .. } = &faired else { panic!("a B-spline surface") };
|
||||||
|
eprintln!("record surface: energy {:e} → {:e}, {} steps", report.energy_before, report.energy_after, report.steps);
|
||||||
for i in 0..cu {
|
for i in 0..cu {
|
||||||
for j in 0..cv {
|
for j in 0..cv {
|
||||||
if i < 2 || i + 2 >= cu || j < 2 || j + 2 >= cv {
|
if i < 2 || i + 2 >= cu || j < 2 || j + 2 >= cv {
|
||||||
assert_eq!(faired.control_points()[i][j], surface.control_points()[i][j], "({i}, {j}) is a boundary layer and moved");
|
assert_eq!(moved[i][j], rows[i][j], "({i}, {j}) is a boundary layer and moved");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
assert!(report.energy_after < report.energy_before);
|
assert!(report.energy_after < report.energy_before);
|
||||||
assert!(faired.control_points()[2][2].z < surface.control_points()[2][2].z, "the bump should come down");
|
assert!(moved[2][2][2] < rows[2][2][2], "the bump should come down");
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn a_rational_surface_fairs_with_its_boundary_and_tolerance_intact() {
|
fn a_rational_surface_fairs_with_its_boundary_and_tolerance_intact() {
|
||||||
// The truck NURBS wrapper, on weights away from one: fairing moves the Cartesian control
|
// The rational record wrapper, on weights away from one: fairing moves the Cartesian control
|
||||||
// points and keeps the weights, so the surface still cannot move more than the tolerance.
|
// points and keeps the weights, so the surface still cannot move more than the tolerance.
|
||||||
let (ku, kv) = (clamped(3, 3), clamped(3, 3));
|
let (ku, kv) = (clamped(3, 3), clamped(3, 3));
|
||||||
let degree = [3, 3];
|
let degree = [3, 3];
|
||||||
@@ -1278,25 +1241,25 @@ mod tests {
|
|||||||
let mut rough = smooth.clone();
|
let mut rough = smooth.clone();
|
||||||
rough[2 * cu + 3][2] += 6.0;
|
rough[2 * cu + 3][2] += 6.0;
|
||||||
let weights: Vec<f64> = (0..cu * cv).map(|k| 0.75 + (k % 3) as f64 * 0.5).collect();
|
let weights: Vec<f64> = (0..cu * cv).map(|k| 0.75 + (k % 3) as f64 * 0.5).collect();
|
||||||
let rows: Vec<Vec<mt::Vector4>> = (0..cu)
|
let rows: Vec<Vec<[f64; 4]>> = (0..cu)
|
||||||
.map(|i| {
|
.map(|i| {
|
||||||
(0..cv)
|
(0..cv)
|
||||||
.map(|j| {
|
.map(|j| {
|
||||||
let (c, w) = (rough[j * cu + i], weights[j * cu + i]);
|
let (c, w) = (rough[j * cu + i], weights[j * cu + i]);
|
||||||
mt::Vector4::new(c[0] * w, c[1] * w, c[2] * w, w)
|
[c[0] * w, c[1] * w, c[2] * w, w]
|
||||||
})
|
})
|
||||||
.collect()
|
.collect()
|
||||||
})
|
})
|
||||||
.collect();
|
.collect();
|
||||||
let bsp = mt::BSplineSurface::try_new((mt::KnotVec::from(ku.clone()), mt::KnotVec::from(kv.clone())), rows).unwrap();
|
let surface = b::Surface::RationalSpline { u_knots: ku.clone(), v_knots: kv.clone(), homogeneous: rows.clone() };
|
||||||
let surface = mt::NurbsSurface::new(bsp);
|
|
||||||
let (faired, report) = fair_nurbs_surface(&surface, &FairOptions::new(1.0, 6, false, 0.5).unwrap()).unwrap();
|
let (faired, report) = fair_nurbs_surface(&surface, &FairOptions::new(1.0, 6, false, 0.5).unwrap()).unwrap();
|
||||||
eprintln!("rational surface: energy {:e} → {:e}, movement {:e} mm", report.energy_before, report.energy_after, report.movement);
|
eprintln!("rational surface: energy {:e} → {:e}, movement {:e} mm", report.energy_before, report.energy_after, report.movement);
|
||||||
assert!(report.movement <= 0.5 && report.energy_after < report.energy_before);
|
assert!(report.movement <= 0.5 && report.energy_after < report.energy_before);
|
||||||
|
let b::Surface::RationalSpline { homogeneous: moved, .. } = &faired else { panic!("a rational surface") };
|
||||||
for i in 0..cu {
|
for i in 0..cu {
|
||||||
for j in 0..cv {
|
for j in 0..cv {
|
||||||
let (before, after) = (surface.non_rationalized().control_points()[i][j], faired.non_rationalized().control_points()[i][j]);
|
let (before, after) = (rows[i][j], moved[i][j]);
|
||||||
assert_eq!(after.w, before.w, "the weight of ({i}, {j}) changed");
|
assert_eq!(after[3], before[3], "the weight of ({i}, {j}) changed");
|
||||||
if i == 0 || i + 1 == cu || j == 0 || j + 1 == cv {
|
if i == 0 || i + 1 == cu || j == 0 || j + 1 == cv {
|
||||||
assert_eq!(after, before, "({i}, {j}) is on the boundary and moved");
|
assert_eq!(after, before, "({i}, {j}) is on the boundary and moved");
|
||||||
}
|
}
|
||||||
@@ -1405,19 +1368,43 @@ mod tests {
|
|||||||
/// and `kv`, its sides the straight lines between the surface's corners — true while the
|
/// and `kv`, its sides the straight lines between the surface's corners — true while the
|
||||||
/// net's boundary rows describe lines, which is how a plane's control net is built here.
|
/// net's boundary rows describe lines, which is how a plane's control net is built here.
|
||||||
fn sheet(ku: &[f64], kv: &[f64], net: &[[f64; 3]]) -> Body {
|
fn sheet(ku: &[f64], kv: &[f64], net: &[[f64; 3]]) -> Body {
|
||||||
|
use crate::sew::{PartEdge, PartFace, PartUse, Parts, assemble};
|
||||||
let (cu, cv) = (ku.len() - 4, kv.len() - 4);
|
let (cu, cv) = (ku.len() - 4, kv.len() - 4);
|
||||||
assert_eq!(net.len(), cu * cv, "the net does not fit the knots");
|
assert_eq!(net.len(), cu * cv, "the net does not fit the knots");
|
||||||
let rows: Vec<Vec<mt::Point3>> =
|
let points: Vec<Vec<[f64; 3]>> = (0..cu).map(|i| (0..cv).map(|j| net[j * cu + i]).collect()).collect();
|
||||||
(0..cu).map(|i| (0..cv).map(|j| mt::Point3::new(net[j * cu + i][0], net[j * cu + i][1], net[j * cu + i][2])).collect()).collect();
|
let surface = b::Surface::Spline { u_knots: ku.to_vec(), v_knots: kv.to_vec(), points };
|
||||||
let bsp = mt::BSplineSurface::try_new((mt::KnotVec::from(ku.to_vec()), mt::KnotVec::from(kv.to_vec())), rows).unwrap();
|
let corners = [(0, 0), (cu - 1, 0), (cu - 1, cv - 1), (0, cv - 1)];
|
||||||
let corner = |i: usize, j: usize| {
|
let (u, v) = ([ku[3], ku[cu]], [kv[3], kv[cv]]);
|
||||||
let c = net[j * cu + i];
|
let uv = [[u[0], v[0]], [u[1], v[0]], [u[1], v[1]], [u[0], v[1]]];
|
||||||
mt::Vertex::new(mt::Point3::new(c[0], c[1], c[2]))
|
let vertices: Vec<[f64; 3]> = corners.iter().map(|&(i, j)| net[j * cu + i]).collect();
|
||||||
};
|
let edges = (0..4)
|
||||||
let v = [corner(0, 0), corner(cu - 1, 0), corner(cu - 1, cv - 1), corner(0, cv - 1)];
|
.map(|k| PartEdge {
|
||||||
let line = |a: &mt::Vertex, b: &mt::Vertex| mt::Edge::new(a, b, mt::Curve::Line(mt::Line(a.point(), b.point())));
|
curve: b::Curve::Line { start: vertices[k], end: vertices[(k + 1) % 4] },
|
||||||
let wire: mt::Wire = vec![line(&v[0], &v[1]), line(&v[1], &v[2]), line(&v[2], &v[3]), line(&v[3], &v[0])].into();
|
interval: [0.0, 1.0],
|
||||||
crate::surfaces::surface_body(vec![mt::Face::try_new(vec![wire], mt::Surface::BSplineSurface(bsp)).unwrap()])
|
vertices: [k as u32, ((k + 1) % 4) as u32],
|
||||||
|
})
|
||||||
|
.collect();
|
||||||
|
let loops = vec![
|
||||||
|
(0..4)
|
||||||
|
.map(|k| PartUse {
|
||||||
|
edge: k as u32,
|
||||||
|
forward: true,
|
||||||
|
given: Some(b::Curve2::Spline { knots: vec![0.0, 0.0, 1.0, 1.0], points: vec![uv[k], uv[(k + 1) % 4]] }),
|
||||||
|
})
|
||||||
|
.collect(),
|
||||||
|
];
|
||||||
|
let made = assemble(Parts { vertices, edges, faces: vec![PartFace { surface, forward: true, loops }], tolerance: 1e-6 }, false).unwrap();
|
||||||
|
crate::native::body_from_smlib(&solidcraft_smlib::Brep::from_record(&made.brep, true).unwrap()).unwrap()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Each edge of the body's record: its curve, interval and vertices.
|
||||||
|
fn edge_records(body: &Body) -> Vec<(b::Curve, [f64; 2], [u32; 2])> {
|
||||||
|
crate::native::brep_record(body).unwrap().edges.into_iter().map(|e| (e.curve, e.interval, e.vertices)).collect()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The surface of face `i` of the body's record.
|
||||||
|
fn face_surface(body: &Body, i: usize) -> b::Surface {
|
||||||
|
crate::native::brep_record(body).unwrap().faces[i].surface.clone()
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
@@ -1432,12 +1419,10 @@ mod tests {
|
|||||||
rough[j * cu + i][2] += d;
|
rough[j * cu + i][2] += d;
|
||||||
}
|
}
|
||||||
let body = sheet(&ku, &kv, &rough);
|
let body = sheet(&ku, &kv, &rough);
|
||||||
let before: Vec<_> =
|
let before = edge_records(&body);
|
||||||
body.solid.face_iter().flat_map(|f| f.absolute_boundaries().iter()).flat_map(|w| w.edge_iter().map(|e| e.id())).collect();
|
|
||||||
assert!(!before.is_empty());
|
assert!(!before.is_empty());
|
||||||
let (faired, report) = fair_faces(&body, &[0], &FairOptions::new(1.0, 6, false, 50.0).unwrap()).unwrap();
|
let (faired, report) = fair_faces(&body, &[0], &FairOptions::new(1.0, 6, false, 50.0).unwrap()).unwrap();
|
||||||
let after: Vec<_> =
|
let after = edge_records(&faired);
|
||||||
faired.solid.face_iter().flat_map(|f| f.absolute_boundaries().iter()).flat_map(|w| w.edge_iter().map(|e| e.id())).collect();
|
|
||||||
eprintln!(
|
eprintln!(
|
||||||
"face: energy {:e} → {:e} in {} steps, movement {:e} mm, {} faces, history {}",
|
"face: energy {:e} → {:e} in {} steps, movement {:e} mm, {} faces, history {}",
|
||||||
report.energy_before,
|
report.energy_before,
|
||||||
@@ -1452,12 +1437,12 @@ mod tests {
|
|||||||
assert!(faired.history().is_some(), "the face came from the one it was faired from");
|
assert!(faired.history().is_some(), "the face came from the one it was faired from");
|
||||||
assert!(report.energy_after < 1e-9 * report.energy_before);
|
assert!(report.energy_after < 1e-9 * report.energy_before);
|
||||||
// The face's own surface is back on the plane, boundary rows bit for bit as they were.
|
// The face's own surface is back on the plane, boundary rows bit for bit as they were.
|
||||||
let Some(mt::Surface::BSplineSurface(s)) = faired.solid.face_iter().next().map(|f| f.surface()) else { panic!("a B-spline face") };
|
let b::Surface::Spline { points, .. } = face_surface(&faired, 0) else { panic!("a B-spline face") };
|
||||||
for j in 0..cv {
|
for j in 0..cv {
|
||||||
for i in 0..cu {
|
for i in 0..cu {
|
||||||
let p = s.control_points()[i][j];
|
let p = points[i][j];
|
||||||
let want = if i == 0 || i + 1 == cu || j == 0 || j + 1 == cv { rough[j * cu + i] } else { smooth[j * cu + i] };
|
let want = if i == 0 || i + 1 == cu || j == 0 || j + 1 == cv { rough[j * cu + i] } else { smooth[j * cu + i] };
|
||||||
assert!(dist(&[p.x, p.y, p.z], &want) < 1e-6, "({i}, {j})");
|
assert!(dist(&p, &want) < 1e-6, "({i}, {j})");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
// A solid keeps its shells, its faces and its edges: thickening the sheet gives a closed
|
// A solid keeps its shells, its faces and its edges: thickening the sheet gives a closed
|
||||||
@@ -1465,18 +1450,13 @@ mod tests {
|
|||||||
// solid of the same shape.
|
// solid of the same shape.
|
||||||
let solid = crate::thicken(&body, 2.0, false).unwrap();
|
let solid = crate::thicken(&body, 2.0, false).unwrap();
|
||||||
assert!(!solid.is_surface());
|
assert!(!solid.is_surface());
|
||||||
let top =
|
let top = (0..solid.face_count()).find(|&i| matches!(face_surface(&solid, i), b::Surface::Spline { .. }));
|
||||||
(0..solid.face_count()).find(|&i| matches!(solid.solid.face_iter().nth(i).map(|f| f.surface()), Some(mt::Surface::BSplineSurface(_))));
|
|
||||||
let Some(top) = top else { panic!("the thickened sheet keeps its B-spline face") };
|
let Some(top) = top else { panic!("the thickened sheet keeps its B-spline face") };
|
||||||
let edges: Vec<_> =
|
let edges = edge_records(&solid);
|
||||||
solid.solid.face_iter().flat_map(|f| f.absolute_boundaries().iter()).flat_map(|w| w.edge_iter().map(|e| e.id())).collect();
|
|
||||||
let (faired, report) = fair_faces(&solid, &[top], &FairOptions::new(1.0, 6, false, 0.5).unwrap()).unwrap();
|
let (faired, report) = fair_faces(&solid, &[top], &FairOptions::new(1.0, 6, false, 0.5).unwrap()).unwrap();
|
||||||
eprintln!("thickened solid: energy {:e} → {:e}, movement {:e} mm", report.energy_before, report.energy_after, report.movement);
|
eprintln!("thickened solid: energy {:e} → {:e}, movement {:e} mm", report.energy_before, report.energy_after, report.movement);
|
||||||
assert!(!faired.is_surface() && faired.face_count() == solid.face_count() && faired.shell_count() == solid.shell_count());
|
assert!(!faired.is_surface() && faired.face_count() == solid.face_count() && faired.shell_count() == solid.shell_count());
|
||||||
assert_eq!(
|
assert_eq!(edge_records(&faired), edges);
|
||||||
faired.solid.face_iter().flat_map(|f| f.absolute_boundaries().iter()).flat_map(|w| w.edge_iter().map(|e| e.id())).collect::<Vec<_>>(),
|
|
||||||
edges
|
|
||||||
);
|
|
||||||
assert!(report.energy_after < report.energy_before);
|
assert!(report.energy_after < report.energy_before);
|
||||||
// A face with no control points to fair is refused, by name.
|
// A face with no control points to fair is refused, by name.
|
||||||
let cube = crate::box_solid(Vec3::ZERO, Vec3::new(10.0, 10.0, 10.0)).unwrap();
|
let cube = crate::box_solid(Vec3::ZERO, Vec3::new(10.0, 10.0, 10.0)).unwrap();
|
||||||
|
|||||||
Reference in new issue
Block a user