Wave 134/509: kernel: emboss on a cylinder builds on the schema 4 record; any pick on the wall is accepted
1 commits, squashed; the originals stay reachable from tag archive/merge-main-develop. - 624f6d6da jyviko: kernel: emboss on a cylinder builds on the schema 4 record; any pick on the wall is accepted Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
This commit is contained in:
@@ -0,0 +1,456 @@
|
||||
//! Bodies built face by face on the schema 4 record: an operation that rebuilds part of a body
|
||||
//! from its own topology (an emboss on a cylinder, a raised band, a deleted face healed by its
|
||||
//! neighbours) starts from the body's record, takes faces away, adds faces bounded by new or
|
||||
//! existing edges, and finishes into a record in canonical order (docs/native-brep.md): pcurves
|
||||
//! from the record's one routine ([`solidcraft_geom::brep::pcurve`]) for every new use, the
|
||||
//! record's own for every use kept, edge uses, regions and shells. SMLib builds the body from
|
||||
//! that record, as from any other.
|
||||
//!
|
||||
//! Faces keep the record's convention as the operation gives them: each face's loops are seen
|
||||
//! from the side the material is not on (the outward side), the outer loop counter-clockwise
|
||||
//! and holes clockwise there; [`Assembly::finish`] stores them relative to the surface's natural
|
||||
//! normal, as the record does.
|
||||
|
||||
use solidcraft_geom::Vec3;
|
||||
use solidcraft_geom::brep::eval::{CurveEval, SurfaceEval};
|
||||
use solidcraft_geom::brep::pcurve::{EdgeUse, pcurves_within};
|
||||
use solidcraft_geom::brep::{Brep, Curve, Curve2, Edge, EdgeUseRef, Face, Loop, Natural, OrientedEdge, OrientedFace, Region, Shell, Surface, VERSION, Vertex};
|
||||
|
||||
use crate::body::Body;
|
||||
use crate::history::{EdgeOrigin, EdgeProv, FaceProv, History};
|
||||
use crate::{KernelError, Result};
|
||||
|
||||
fn invalid(m: impl std::fmt::Display) -> KernelError {
|
||||
KernelError::Failed(format!("rebuilding the B-rep: {m}"))
|
||||
}
|
||||
|
||||
/// One edge of the assembly: its curve on `interval`, from `vertices[0]` to `vertices[1]`.
|
||||
#[derive(Clone, Debug)]
|
||||
pub(crate) struct AEdge {
|
||||
pub curve: Curve,
|
||||
pub interval: [f64; 2],
|
||||
pub vertices: [u32; 2],
|
||||
pub tolerance: f64,
|
||||
/// The source record's edge this edge is, kept as it was.
|
||||
pub source: Option<usize>,
|
||||
}
|
||||
|
||||
/// One use of an edge in a face's loop: the loop runs along it from its start (`forward`) or
|
||||
/// from its end, with the source record's pcurve where the use is one the record had.
|
||||
#[derive(Clone, Debug)]
|
||||
pub(crate) struct AUse {
|
||||
pub edge: u32,
|
||||
pub forward: bool,
|
||||
pub given: Option<Curve2>,
|
||||
}
|
||||
|
||||
/// One face of the assembly: its surface, whether its natural normal points out of the
|
||||
/// material, its loops (outer first) seen from outside, and the shell it belongs to (a shell of
|
||||
/// the source record, by index).
|
||||
#[derive(Clone, Debug)]
|
||||
pub(crate) struct AFace {
|
||||
pub surface: Surface,
|
||||
pub natural_out: bool,
|
||||
pub loops: Vec<Vec<AUse>>,
|
||||
pub shell: usize,
|
||||
/// The source record's face whose surface and parameter box this face keeps.
|
||||
pub domain: Option<[[f64; 2]; 2]>,
|
||||
}
|
||||
|
||||
/// A body taken apart: vertices, edges and faces that [`Assembly::finish`] builds into a record.
|
||||
#[derive(Clone, Debug)]
|
||||
pub(crate) struct Assembly {
|
||||
pub tolerance: f64,
|
||||
pub vertices: Vec<Vertex>,
|
||||
pub edges: Vec<AEdge>,
|
||||
/// `None`: a face taken away.
|
||||
pub faces: Vec<Option<AFace>>,
|
||||
/// The source's regions, by shell index (shells keep their indices; a shell left with no
|
||||
/// face is dropped).
|
||||
regions: Vec<Region>,
|
||||
shells: usize,
|
||||
}
|
||||
|
||||
/// A finished record, with where each face of the assembly went in it (`None`: taken away).
|
||||
pub(crate) struct Finished {
|
||||
pub record: Brep,
|
||||
pub faces: Vec<Option<usize>>,
|
||||
/// For each edge of the record, the assembly edge it is.
|
||||
pub edges: Vec<usize>,
|
||||
}
|
||||
|
||||
impl Assembly {
|
||||
/// The record `b` taken apart, every face and edge as it is (face i and edge i of the
|
||||
/// assembly are the record's). Only face shells: a record with wire or vertex shells is not
|
||||
/// rebuilt here.
|
||||
pub(crate) fn from_record(b: &Brep) -> Result<Assembly> {
|
||||
let mut faces: Vec<Option<AFace>> = vec![None; b.faces.len()];
|
||||
for (s, shell) in b.shells.iter().enumerate() {
|
||||
let Shell::Faces { faces: uses, wires } = shell else { return Err(invalid("a wire or vertex shell")) };
|
||||
if !wires.is_empty() {
|
||||
return Err(invalid("wire edges inside a shell"));
|
||||
}
|
||||
for of in uses {
|
||||
let f = b.faces.get(of.face as usize).ok_or_else(|| invalid("face reference"))?;
|
||||
let mut loops = Vec::with_capacity(f.loops.len());
|
||||
for l in &f.loops {
|
||||
let Loop::Edges { edges } = l else { return Err(invalid("a vertex loop")) };
|
||||
let mut lp: Vec<AUse> = edges.iter().map(|u| AUse { edge: u.edge, forward: u.forward, given: Some(u.pcurve.clone()) }).collect();
|
||||
// Stored about the natural normal; the assembly sees loops from outside.
|
||||
if !of.forward {
|
||||
reverse(&mut lp);
|
||||
}
|
||||
loops.push(lp);
|
||||
}
|
||||
let slot = faces.get_mut(of.face as usize).ok_or_else(|| invalid("face reference"))?;
|
||||
if slot.is_some() {
|
||||
return Err(invalid("a face used by two shells"));
|
||||
}
|
||||
*slot = Some(AFace { surface: f.surface.clone(), natural_out: of.forward, loops, shell: s, domain: Some(f.domain) });
|
||||
}
|
||||
}
|
||||
if faces.iter().any(Option::is_none) {
|
||||
return Err(invalid("a face no shell uses"));
|
||||
}
|
||||
let edges = b
|
||||
.edges
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(i, e)| AEdge { curve: e.curve.clone(), interval: e.interval, vertices: e.vertices, tolerance: e.tolerance, source: Some(i) })
|
||||
.collect();
|
||||
Ok(Assembly { tolerance: b.tolerance, vertices: b.vertices.clone(), edges, faces, regions: b.regions.clone(), shells: b.shells.len() })
|
||||
}
|
||||
|
||||
/// A new vertex at `p`.
|
||||
pub(crate) fn vertex(&mut self, p: Vec3) -> Result<u32> {
|
||||
if !p.is_finite() {
|
||||
return Err(invalid("a vertex off the finite range"));
|
||||
}
|
||||
self.vertices.push(Vertex { point: [p.x, p.y, p.z], tolerance: self.tolerance });
|
||||
index(self.vertices.len() - 1)
|
||||
}
|
||||
|
||||
/// A vertex's point.
|
||||
pub(crate) fn point(&self, v: u32) -> Option<Vec3> {
|
||||
self.vertices.get(v as usize).map(|v| Vec3::from(v.point))
|
||||
}
|
||||
|
||||
/// A new edge on `curve` over `interval`, from `a` to `b`.
|
||||
pub(crate) fn edge(&mut self, curve: Curve, interval: [f64; 2], a: u32, b: u32) -> Result<u32> {
|
||||
self.edges.push(AEdge { curve, interval, vertices: [a, b], tolerance: self.tolerance, source: None });
|
||||
index(self.edges.len() - 1)
|
||||
}
|
||||
|
||||
/// A new straight edge from vertex `a` to vertex `b` (t from 0 to 1).
|
||||
pub(crate) fn line(&mut self, a: u32, b: u32) -> Result<u32> {
|
||||
let (Some(p), Some(q)) = (self.point(a), self.point(b)) else { return Err(invalid("vertex reference")) };
|
||||
if p.dist(q) <= self.tolerance {
|
||||
return Err(invalid("a line of no length"));
|
||||
}
|
||||
self.edge(Curve::Line { start: [p.x, p.y, p.z], end: [q.x, q.y, q.z] }, [0.0, 1.0], a, b)
|
||||
}
|
||||
|
||||
/// A new face.
|
||||
pub(crate) fn face(&mut self, face: AFace) {
|
||||
self.faces.push(Some(face));
|
||||
}
|
||||
|
||||
/// Where an edge use starts and ends (in the loop's direction).
|
||||
pub(crate) fn ends(&self, u: &AUse) -> Option<(u32, u32)> {
|
||||
let e = self.edges.get(u.edge as usize)?;
|
||||
let [a, b] = e.vertices;
|
||||
Some(if u.forward { (a, b) } else { (b, a) })
|
||||
}
|
||||
|
||||
/// The point of edge `e` at its parameter `t`.
|
||||
pub(crate) fn edge_point(&self, e: u32, t: f64) -> Option<Vec3> {
|
||||
let e = self.edges.get(e as usize)?;
|
||||
CurveEval::new(&e.curve).ok()?.point(t)
|
||||
}
|
||||
|
||||
/// The record of the faces left and added, in canonical order.
|
||||
pub(crate) fn finish(&self) -> Result<Finished> {
|
||||
// Faces in canonical order: by region, shell and the shell's own order (the assembly's).
|
||||
let mut by_shell: Vec<Vec<usize>> = vec![Vec::new(); self.shells];
|
||||
for (i, f) in self.faces.iter().enumerate() {
|
||||
if let Some(f) = f {
|
||||
by_shell.get_mut(f.shell).ok_or_else(|| invalid("shell reference"))?.push(i);
|
||||
}
|
||||
}
|
||||
let mut shell_order: Vec<usize> = Vec::new();
|
||||
let mut shell_new: Vec<Option<u32>> = vec![None; self.shells];
|
||||
let mut regions: Vec<Region> = Vec::new();
|
||||
for region in &self.regions {
|
||||
let mut shells = Vec::new();
|
||||
for &s in ®ion.shells {
|
||||
let s = s as usize;
|
||||
if by_shell.get(s).is_none_or(Vec::is_empty) {
|
||||
continue;
|
||||
}
|
||||
let slot = shell_new.get_mut(s).ok_or_else(|| invalid("shell reference"))?;
|
||||
let n = match slot {
|
||||
Some(n) => *n,
|
||||
None => {
|
||||
let n = index(shell_order.len())?;
|
||||
shell_order.push(s);
|
||||
*slot = Some(n);
|
||||
n
|
||||
}
|
||||
};
|
||||
shells.push(n);
|
||||
}
|
||||
// A bounded region whose outer shell went is gone (its faces were all taken away).
|
||||
if regions.is_empty() || region.shells.first().is_some_and(|s| by_shell.get(*s as usize).is_some_and(|f| !f.is_empty())) {
|
||||
regions.push(Region { shells, void: region.void });
|
||||
}
|
||||
}
|
||||
let order: Vec<usize> = shell_order.iter().filter_map(|s| by_shell.get(*s)).flatten().copied().collect();
|
||||
let mut face_map: Vec<Option<usize>> = vec![None; self.faces.len()];
|
||||
for (k, i) in order.iter().enumerate() {
|
||||
if let Some(slot) = face_map.get_mut(*i) {
|
||||
*slot = Some(k);
|
||||
}
|
||||
}
|
||||
// Each face's pcurves and stored loops, in canonical face order.
|
||||
let mut faces: Vec<Face> = Vec::with_capacity(order.len());
|
||||
let mut forward: Vec<bool> = Vec::with_capacity(order.len());
|
||||
for &i in &order {
|
||||
let f = self.faces.get(i).and_then(Option::as_ref).ok_or_else(|| invalid("face reference"))?;
|
||||
let loops: Vec<Vec<AUse>> = f
|
||||
.loops
|
||||
.iter()
|
||||
.map(|l| {
|
||||
let mut l = l.clone();
|
||||
if !f.natural_out {
|
||||
reverse(&mut l);
|
||||
}
|
||||
l
|
||||
})
|
||||
.collect();
|
||||
let uses: Vec<Vec<EdgeUse<'_>>> = loops
|
||||
.iter()
|
||||
.map(|l| {
|
||||
l.iter()
|
||||
.map(|u| {
|
||||
let e = self.edges.get(u.edge as usize).ok_or_else(|| invalid("edge reference"))?;
|
||||
Ok(EdgeUse { edge: u.edge, curve: &e.curve, interval: e.interval, forward: u.forward, tolerance: e.tolerance, given: u.given.as_ref() })
|
||||
})
|
||||
.collect::<Result<Vec<_>>>()
|
||||
})
|
||||
.collect::<Result<_>>()?;
|
||||
let pcurves = pcurves_within(&f.surface, &uses, self.tolerance, f.domain).map_err(|e| invalid(format!("face {i}: {e}")))?;
|
||||
let domain = domain_of(&f.surface, &pcurves, f.domain).ok_or_else(|| invalid(format!("face {i}: no parameter box")))?;
|
||||
let stored = loops
|
||||
.iter()
|
||||
.zip(&pcurves)
|
||||
.map(|(l, pc)| Loop::Edges {
|
||||
edges: l.iter().zip(pc).map(|(u, pcurve)| OrientedEdge { edge: u.edge, forward: u.forward, pcurve: pcurve.clone() }).collect(),
|
||||
})
|
||||
.collect();
|
||||
faces.push(Face { surface: f.surface.clone(), domain, loops: stored });
|
||||
forward.push(f.natural_out);
|
||||
}
|
||||
// Edges in first appearance walking faces → loops → uses (backwards in a face whose
|
||||
// side in its shell is reversed), with their uses in that order.
|
||||
let mut edge_new: Vec<Option<u32>> = vec![None; self.edges.len()];
|
||||
let mut edge_order: Vec<usize> = Vec::new();
|
||||
let mut walked: Vec<Vec<EdgeUseRef>> = Vec::new();
|
||||
for (fi, (f, fw)) in faces.iter().zip(&forward).enumerate() {
|
||||
for (li, l) in f.loops.iter().enumerate() {
|
||||
let Loop::Edges { edges } = l else { continue };
|
||||
let n = edges.len();
|
||||
for k in 0..n {
|
||||
let p = if *fw { k } else { n - 1 - k };
|
||||
let u = edges.get(p).ok_or_else(|| invalid("edge use"))?;
|
||||
let slot = edge_new.get_mut(u.edge as usize).ok_or_else(|| invalid("edge reference"))?;
|
||||
let ne = match slot {
|
||||
Some(ne) => *ne,
|
||||
None => {
|
||||
let ne = index(edge_order.len())?;
|
||||
edge_order.push(u.edge as usize);
|
||||
walked.push(Vec::new());
|
||||
*slot = Some(ne);
|
||||
ne
|
||||
}
|
||||
};
|
||||
let at = EdgeUseRef { face: index(fi)?, r#loop: index(li)?, position: index(p)?, upper: !u.forward };
|
||||
walked.get_mut(ne as usize).ok_or_else(|| invalid("edge use"))?.push(at);
|
||||
}
|
||||
}
|
||||
}
|
||||
for f in &mut faces {
|
||||
for l in &mut f.loops {
|
||||
if let Loop::Edges { edges } = l {
|
||||
for u in edges {
|
||||
u.edge = edge_new.get(u.edge as usize).copied().flatten().ok_or_else(|| invalid("edge reference"))?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// Vertices in first appearance walking edges (start, end).
|
||||
let mut vertex_new: Vec<Option<u32>> = vec![None; self.vertices.len()];
|
||||
let mut vertices: Vec<Vertex> = Vec::new();
|
||||
let mut edges: Vec<Edge> = Vec::with_capacity(edge_order.len());
|
||||
for (e, uses) in edge_order.iter().zip(walked) {
|
||||
let a = self.edges.get(*e).ok_or_else(|| invalid("edge reference"))?;
|
||||
let mut ends = [0u32; 2];
|
||||
for (slot, v) in ends.iter_mut().zip(a.vertices) {
|
||||
let nv = vertex_new.get_mut(v as usize).ok_or_else(|| invalid("vertex reference"))?;
|
||||
*slot = match nv {
|
||||
Some(n) => *n,
|
||||
None => {
|
||||
let n = index(vertices.len())?;
|
||||
vertices.push(self.vertices.get(v as usize).cloned().ok_or_else(|| invalid("vertex reference"))?);
|
||||
*nv = Some(n);
|
||||
n
|
||||
}
|
||||
};
|
||||
}
|
||||
edges.push(Edge { curve: a.curve.clone(), interval: a.interval, vertices: ends, tolerance: a.tolerance, uses });
|
||||
}
|
||||
let shells = shell_order
|
||||
.iter()
|
||||
.map(|s| {
|
||||
let faces = by_shell
|
||||
.get(*s)
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.map(|i| {
|
||||
let k = face_map.get(*i).copied().flatten().ok_or_else(|| invalid("face reference"))?;
|
||||
Ok(OrientedFace { face: index(k)?, forward: *forward.get(k).ok_or_else(|| invalid("face reference"))? })
|
||||
})
|
||||
.collect::<Result<Vec<_>>>()?;
|
||||
Ok(Shell::Faces { faces, wires: Vec::new() })
|
||||
})
|
||||
.collect::<Result<Vec<_>>>()?;
|
||||
let record = Brep { version: VERSION, tolerance: self.tolerance, regions, shells, faces, edges, vertices };
|
||||
record.validate().map_err(invalid)?;
|
||||
record.check_geometry().map_err(invalid)?;
|
||||
Ok(Finished { record, faces: face_map, edges: edge_order })
|
||||
}
|
||||
}
|
||||
|
||||
/// Reverse a loop: the same edges, the other way round.
|
||||
fn reverse(l: &mut [AUse]) {
|
||||
l.reverse();
|
||||
for u in l {
|
||||
u.forward = !u.forward;
|
||||
}
|
||||
}
|
||||
|
||||
fn index(i: usize) -> Result<u32> {
|
||||
u32::try_from(i).map_err(|_| invalid("too many items"))
|
||||
}
|
||||
|
||||
/// A face's parameter box: the source face's where it kept it, else the box of its pcurves'
|
||||
/// control points (which holds the curves), inside the surface's natural domain.
|
||||
fn domain_of(surface: &Surface, pcurves: &[Vec<Curve2>], kept: Option<[[f64; 2]; 2]>) -> Option<[[f64; 2]; 2]> {
|
||||
let mut lo = [f64::INFINITY; 2];
|
||||
let mut hi = [f64::NEG_INFINITY; 2];
|
||||
for c in pcurves.iter().flatten() {
|
||||
let points: Vec<[f64; 2]> = match c {
|
||||
Curve2::Spline { points, .. } => points.clone(),
|
||||
Curve2::RationalSpline { homogeneous, .. } => homogeneous.iter().map(|h| [h[0] / h[2], h[1] / h[2]]).collect(),
|
||||
};
|
||||
for p in points {
|
||||
for d in 0..2 {
|
||||
if let (Some(l), Some(h), Some(x)) = (lo.get_mut(d), hi.get_mut(d), p.get(d)) {
|
||||
*l = l.min(*x);
|
||||
*h = h.max(*x);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Some(k) = kept {
|
||||
// The source's box, grown to hold any loop the face has now.
|
||||
for d in 0..2 {
|
||||
if let (Some(l), Some(h), Some(r)) = (lo.get_mut(d), hi.get_mut(d), k.get(d)) {
|
||||
*l = l.min(r[0]);
|
||||
*h = h.max(r[1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
let natural = surface.natural();
|
||||
let mut out = [[0.0; 2]; 2];
|
||||
for d in 0..2 {
|
||||
let (mut a, mut b) = (*lo.get(d)?, *hi.get(d)?);
|
||||
if !(a.is_finite() && b.is_finite()) {
|
||||
return None;
|
||||
}
|
||||
match natural.get(d)? {
|
||||
Natural::Periodic => b = b.min(a + std::f64::consts::TAU),
|
||||
Natural::Range(x, y) => {
|
||||
a = a.max(*x);
|
||||
b = b.min(*y);
|
||||
}
|
||||
}
|
||||
if !(a < b) {
|
||||
return None;
|
||||
}
|
||||
*out.get_mut(d)? = [a, b];
|
||||
}
|
||||
Some(out)
|
||||
}
|
||||
|
||||
/// The body SMLib builds from `record`, and whether its faces and edges are numbered as the
|
||||
/// record's (then face i of the body is face i of the record, and so for edges).
|
||||
pub(crate) fn body_of(record: &Brep) -> Result<(Body, bool)> {
|
||||
let (brep, same) = crate::native::smlib_record_ordered(record)?;
|
||||
let (body, kept) = crate::native::body_from_smlib_ordered(&brep)?;
|
||||
Ok((body, same.is_some() && kept.is_some()))
|
||||
}
|
||||
|
||||
/// The body of `finished`, built from the one operand `from`, with the history whose faces are
|
||||
/// `faces` (in the assembly's face order, taken-away faces skipped): each kept edge the operand
|
||||
/// edge it is, each new one where its two faces meet. No history where SMLib renumbered the
|
||||
/// record.
|
||||
pub(crate) fn body_with_history(finished: &Finished, assembly: &Assembly, from: &Body, faces: Vec<FaceProv>) -> Result<Body> {
|
||||
let (body, same) = body_of(&finished.record)?;
|
||||
let counts = crate::record::counts(&[from]);
|
||||
if !same {
|
||||
return Ok(body.with_checked_history(None, &counts));
|
||||
}
|
||||
// The provenance of each record face, from the assembly's face order.
|
||||
let mut provs: Vec<Option<FaceProv>> = vec![None; finished.record.faces.len()];
|
||||
let mut given = faces.into_iter();
|
||||
for k in finished.faces.iter().flatten() {
|
||||
let p = given.next().ok_or_else(|| invalid("history: fewer faces than the body"))?;
|
||||
*provs.get_mut(*k).ok_or_else(|| invalid("history: face"))? = Some(p);
|
||||
}
|
||||
let faces: Vec<FaceProv> = provs.into_iter().collect::<Option<_>>().ok_or_else(|| invalid("history: a face without provenance"))?;
|
||||
let edges = finished
|
||||
.record
|
||||
.edges
|
||||
.iter()
|
||||
.zip(&finished.edges)
|
||||
.map(|(e, a)| {
|
||||
let mut between: Vec<usize> = e.uses.iter().map(|u| u.face as usize).collect();
|
||||
between.sort_unstable();
|
||||
between.dedup();
|
||||
let origins = match assembly.edges.get(*a).and_then(|x| x.source) {
|
||||
Some(edge) => vec![EdgeOrigin::Edge { operand: 0, edge }],
|
||||
None => crate::record::meeting(&between, &faces),
|
||||
};
|
||||
EdgeProv { faces: between, origins }
|
||||
})
|
||||
.collect();
|
||||
Ok(body.with_checked_history(Some(History { operands: 1, faces, edges }), &counts))
|
||||
}
|
||||
|
||||
/// Whether the face `face` of `b` has its natural normal out of the material.
|
||||
pub(crate) fn natural_out(b: &Brep, face: usize) -> Option<bool> {
|
||||
b.shells.iter().find_map(|s| match s {
|
||||
Shell::Faces { faces, .. } => faces.iter().find(|f| f.face as usize == face).map(|f| f.forward),
|
||||
_ => None,
|
||||
})
|
||||
}
|
||||
|
||||
/// The outward unit normal of face `face` of `b` at the parameters of `p`, a point on it.
|
||||
pub(crate) fn outward_normal(b: &Brep, face: usize, p: Vec3) -> Option<Vec3> {
|
||||
let f = b.faces.get(face)?;
|
||||
let s = SurfaceEval::new(&f.surface).ok()?;
|
||||
let uv = s.project(p, None, f64::INFINITY)?;
|
||||
let (_, su, sv) = s.derivs(uv[0], uv[1])?;
|
||||
let n = su.cross(sv).normalized()?;
|
||||
Some(if natural_out(b, face)? { n } else { -n })
|
||||
}
|
||||
+234
-149
@@ -1,12 +1,16 @@
|
||||
//! Exact radial embossing of orthogonal profiles on complete cylindrical walls.
|
||||
use crate::body::{Body, Solid, from_p3, p3};
|
||||
//! Exact radial embossing of orthogonal profiles on complete cylindrical walls, built on the
|
||||
//! body's schema 4 record: the wall's face loses the profiles' footprints, and each profile
|
||||
//! adds its walls (planes, along the axis or square to it) and its raised or sunk cap (the
|
||||
//! wall's cylinder at the new radius).
|
||||
use crate::assemble::{AFace, AUse, Assembly};
|
||||
use crate::body::Body;
|
||||
use crate::history::Change;
|
||||
use crate::numbered::NumberedRegion;
|
||||
use crate::offset::{Surf, surf_of};
|
||||
use crate::record::Operand;
|
||||
use crate::offset::{Surf, face_edges, surf_of};
|
||||
use crate::{KernelError, Result, guard};
|
||||
use solidcraft_geom::brep::eval::CurveEval;
|
||||
use solidcraft_geom::brep::{Brep, Curve, Frame, Loop, Surface};
|
||||
use solidcraft_geom::{Loop2, Plane, Region2, Seg2, Vec2, Vec3};
|
||||
use truck_modeling::{self as mt, Transformed, builder};
|
||||
|
||||
fn fail(s: &str) -> KernelError {
|
||||
KernelError::Invalid(format!("cylinder emboss: {s}"))
|
||||
@@ -19,31 +23,51 @@ fn angle(p: Vec3, o: Vec3, axis: Vec3, radial: Vec3, tangent: Vec3) -> f64 {
|
||||
fn unwrap(a: f64, around: f64) -> f64 {
|
||||
around + (a - around + std::f64::consts::PI).rem_euclid(std::f64::consts::TAU) - std::f64::consts::PI
|
||||
}
|
||||
fn arr(v: Vec3) -> [f64; 3] {
|
||||
[v.x, v.y, v.z]
|
||||
}
|
||||
|
||||
fn wall_angles(face: &mt::Face, o: Vec3, axis: Vec3, radial: Vec3, tangent: Vec3, tol: f64) -> Option<(f64, f64)> {
|
||||
if face.boundaries().len() != 1 || face.edge_iter().count() != 4 {
|
||||
/// The angles a wall face spans about the axis, seen from `radial`: from one of its arcs about
|
||||
/// the axis (a face of one loop of four edges).
|
||||
fn wall_angles(b: &Brep, face: usize, o: Vec3, axis: Vec3, radial: Vec3, tangent: Vec3) -> Option<(f64, f64)> {
|
||||
let f = b.faces.get(face)?;
|
||||
let [Loop::Edges { edges }] = f.loops.as_slice() else { return None };
|
||||
if edges.len() != 4 {
|
||||
return None;
|
||||
}
|
||||
for edge in face.edge_iter() {
|
||||
if let Some(Some(mid)) = crate::offset::arc_mid(&edge, tol * 10.) {
|
||||
let am = angle(mid, o, axis, radial, tangent);
|
||||
let aa = unwrap(angle(from_p3(edge.front().point()), o, axis, radial, tangent), am);
|
||||
let ab = unwrap(angle(from_p3(edge.back().point()), o, axis, radial, tangent), am);
|
||||
return Some((aa.min(ab), aa.max(ab)));
|
||||
for u in edges {
|
||||
let e = b.edges.get(u.edge as usize)?;
|
||||
let Curve::Circle { frame, .. } = &e.curve else { continue };
|
||||
let z = Vec3::from(frame.x_axis).cross(Vec3::from(frame.y_axis));
|
||||
if z.dot(axis).abs() < 1.0 - 1e-9 {
|
||||
continue;
|
||||
}
|
||||
let c = CurveEval::new(&e.curve).ok()?;
|
||||
let [t0, t1] = e.interval;
|
||||
let am = angle(c.point(0.5 * (t0 + t1))?, o, axis, radial, tangent);
|
||||
let aa = unwrap(angle(c.point(t0)?, o, axis, radial, tangent), am);
|
||||
let ab = unwrap(angle(c.point(t1)?, o, axis, radial, tangent), am);
|
||||
return Some((aa.min(ab), aa.max(ab)));
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// The body's record, for the queries below (a mesh body has none).
|
||||
fn record(body: &Body) -> Result<Brep> {
|
||||
crate::native::brep_record(body)
|
||||
}
|
||||
|
||||
/// Certify a tessellated pick and project it onto the cylinder used by emboss.
|
||||
pub fn cylinder_emboss_anchor(body: &Body, face: usize, at: Vec3) -> Result<Vec3> {
|
||||
if !at.is_finite() || at.len() > 1e9 {
|
||||
return Err(fail("invalid selected face point"));
|
||||
}
|
||||
guard("cylinder emboss anchor", || {
|
||||
let f = body.solid.face_iter().nth(face).ok_or_else(|| fail("selected face"))?;
|
||||
let tol = (body.size() * 1e-8).max(1e-8);
|
||||
let Some(Surf::Cylinder { o, a, r, convex: true }) = surf_of(f, tol) else {
|
||||
let rec = record(body)?;
|
||||
if face >= rec.faces.len() {
|
||||
return Err(fail("selected face"));
|
||||
}
|
||||
let Some(Surf::Cylinder { o, a, r, convex: true }) = surf_of(&rec, face) else {
|
||||
return Err(fail("selected face is not an exterior cylinder"));
|
||||
};
|
||||
let w = at - o;
|
||||
@@ -92,13 +116,14 @@ pub fn infer_cylinder_emboss(body: &Body, plane: &Plane, regions: &[Region2], de
|
||||
return Ok(None);
|
||||
}
|
||||
guard("cylinder emboss inference", || {
|
||||
let rec = record(body)?;
|
||||
let tol = (body.size() * 1e-8).max(1e-8);
|
||||
let mut tangent = false;
|
||||
for (index, face) in body.solid.face_iter().enumerate() {
|
||||
if index >= 50_000 {
|
||||
for face in 0..rec.faces.len() {
|
||||
if face >= 50_000 {
|
||||
return Err(fail("target search exceeds face work limit"));
|
||||
}
|
||||
if let Some(Surf::Cylinder { o, a, r, convex: true }) = surf_of(face, tol) {
|
||||
if let Some(Surf::Cylinder { o, a, r, convex: true }) = surf_of(&rec, face) {
|
||||
let w = plane.origin - o;
|
||||
let normal = plane.normal();
|
||||
let signed = w.dot(normal);
|
||||
@@ -111,7 +136,7 @@ pub fn infer_cylinder_emboss(body: &Body, plane: &Plane, regions: &[Region2], de
|
||||
if !profile_interval_overlaps(plane, regions, o, a.cross(radial), -std::f64::consts::PI * r, std::f64::consts::PI * r)? {
|
||||
continue;
|
||||
}
|
||||
if let Some((lo, hi)) = wall_angles(face, o, a, radial, a.cross(radial), tol) {
|
||||
if let Some((lo, hi)) = wall_angles(&rec, face, o, a, radial, a.cross(radial)) {
|
||||
if lo >= -tol / r || hi <= tol / r {
|
||||
continue;
|
||||
}
|
||||
@@ -119,7 +144,7 @@ pub fn infer_cylinder_emboss(body: &Body, plane: &Plane, regions: &[Region2], de
|
||||
continue;
|
||||
}
|
||||
}
|
||||
let relevant = match face_axial_bounds(face, o, a)? {
|
||||
let relevant = match face_axial_bounds(&rec, face, o, a)? {
|
||||
Some((lo, hi)) => profile_interval_overlaps(plane, regions, o, a, lo, hi)?,
|
||||
None => true,
|
||||
};
|
||||
@@ -148,18 +173,14 @@ pub fn has_cylinder_emboss_wall(body: &Body) -> Result<bool> {
|
||||
return Ok(false);
|
||||
}
|
||||
guard("cylinder emboss target", || {
|
||||
let tol = (body.size() * 1e-8).max(1e-8);
|
||||
for (index, face) in body.solid.face_iter().enumerate() {
|
||||
if index >= 50_000 {
|
||||
return Err(fail("target search exceeds face work limit"));
|
||||
}
|
||||
if matches!(surf_of(face, tol), Some(Surf::Cylinder { convex: true, .. })) {
|
||||
return Ok(true);
|
||||
}
|
||||
let rec = record(body)?;
|
||||
if rec.faces.len() > 50_000 {
|
||||
return Err(fail("target search exceeds face work limit"));
|
||||
}
|
||||
Ok(false)
|
||||
Ok((0..rec.faces.len()).any(|face| matches!(surf_of(&rec, face), Some(Surf::Cylinder { convex: true, .. }))))
|
||||
})
|
||||
}
|
||||
|
||||
fn emboss_impl(body: &Body, anchor: Option<Vec3>, plane: &Plane, regions: &[Region2], depth: f64, qualify: bool) -> Result<EmbossOutcome> {
|
||||
body.require_brep("cylinder emboss")?;
|
||||
if !depth.is_finite() || depth.abs() < 1e-6 || depth.abs() > 1e6 || regions.is_empty() || regions.len() > 64 {
|
||||
@@ -175,13 +196,14 @@ fn emboss_impl(body: &Body, anchor: Option<Vec3>, plane: &Plane, regions: &[Regi
|
||||
return Err(fail("invalid sketch frame"));
|
||||
}
|
||||
guard("cylinder emboss", || {
|
||||
if body.solid.boundaries().len() != 1 || body.solid.face_iter().take(17).count() > 16 || body.solid.edge_iter().take(257).count() > 256 {
|
||||
let rec = record(body)?;
|
||||
if rec.shells.len() != 1 || rec.faces.len() > 16 || rec.edges.len() > 256 {
|
||||
return Err(fail("requires a complete cylinder or coaxial sleeve"));
|
||||
}
|
||||
let faces: Vec<_> = body.solid.face_iter().cloned().collect();
|
||||
let tol = (body.size() * 1e-8).max(1e-8);
|
||||
let surfaces: Vec<_> =
|
||||
faces.iter().map(|f| surf_of(f, tol).ok_or_else(|| fail("requires only cylindrical walls and planar endcaps"))).collect::<Result<_>>()?;
|
||||
let surfaces: Vec<Surf> = (0..rec.faces.len())
|
||||
.map(|f| surf_of(&rec, f).ok_or_else(|| fail("requires only cylindrical walls and planar endcaps")))
|
||||
.collect::<Result<_>>()?;
|
||||
let mut chosen = None;
|
||||
for (fi, s) in surfaces.iter().enumerate() {
|
||||
let Surf::Cylinder { o, a, r, convex: true } = *s else { continue };
|
||||
@@ -192,11 +214,7 @@ fn emboss_impl(body: &Body, anchor: Option<Vec3>, plane: &Plane, regions: &[Regi
|
||||
}
|
||||
let radial = radial.normalized().ok_or_else(|| fail("radial frame"))?;
|
||||
let tangent = a.cross(radial);
|
||||
let f = faces.get(fi).ok_or_else(|| fail("face"))?;
|
||||
if f.boundaries().len() != 1 || f.edge_iter().count() != 4 {
|
||||
continue;
|
||||
}
|
||||
let Some((alo, ahi)) = wall_angles(f, o, a, radial, tangent, tol) else {
|
||||
let Some((alo, ahi)) = wall_angles(&rec, fi, o, a, radial, tangent) else {
|
||||
continue;
|
||||
};
|
||||
if alo >= -tol / r || ahi <= tol / r {
|
||||
@@ -246,10 +264,13 @@ fn emboss_impl(body: &Body, anchor: Option<Vec3>, plane: &Plane, regions: &[Regi
|
||||
return Err(fail("depth reaches the axis or inner wall"));
|
||||
}
|
||||
if let Some(at) = anchor {
|
||||
// The saved pick identifies the wall, not the face the sketch is tangent to: every
|
||||
// exterior cylindrical face of the body is that wall (a stepped or interrupted
|
||||
// cylinder was refused above), stored as several faces between its seams. So the
|
||||
// pick lies on it wherever it is on the cylinder between the endcaps (#3782).
|
||||
let h = (at - o).dot(axis);
|
||||
let v = at - o - axis * h;
|
||||
let theta = angle(at, o, axis, radial, tangent);
|
||||
if (v.len() - r).abs() > tol * 10.0 || theta <= alo + tol / r || theta >= ahi - tol / r || h <= lo + tol || h >= hi - tol {
|
||||
if (v.len() - r).abs() > tol * 10.0 || h <= lo + tol || h >= hi - tol {
|
||||
return Err(fail("saved selection no longer identifies the sketch's cylindrical face"));
|
||||
}
|
||||
}
|
||||
@@ -307,39 +328,15 @@ fn emboss_impl(body: &Body, anchor: Option<Vec3>, plane: &Plane, regions: &[Regi
|
||||
let at = o + axis * p.y + (radial * (p.x / r).cos() + tangent * (p.x / r).sin()) * r;
|
||||
return Ok(EmbossOutcome::Anchor(fi, at));
|
||||
}
|
||||
let at = |p: Vec2, radius: f64| o + axis * p.y + (radial * (p.x / r).cos() + tangent * (p.x / r).sin()) * radius;
|
||||
let selected = faces.get(fi).ok_or_else(|| fail("face"))?;
|
||||
let mut base_patches = vec![selected.absolute_boundaries().clone()];
|
||||
let wall = Wrap { o, axis, radial, tangent, r };
|
||||
let mut asm = Assembly::from_record(&rec)?;
|
||||
let selected = asm.faces.get_mut(fi).and_then(Option::take).ok_or_else(|| fail("face"))?;
|
||||
// The wall's pieces left around the footprints: the face itself, then one per profile
|
||||
// hole (the original radius inside it).
|
||||
let mut base_patches: Vec<Vec<Vec<AUse>>> = vec![selected.loops.clone()];
|
||||
let mut hole_patches = Vec::new();
|
||||
let mut footprints = Vec::new();
|
||||
let mut added = Vec::new();
|
||||
let k = rr / r;
|
||||
let coord = |v: Vec3| [v.x, v.y, v.z];
|
||||
let av = coord(axis);
|
||||
let ov = coord(o);
|
||||
let mut m = [[0.0; 4]; 4];
|
||||
for (j, col) in m.iter_mut().take(3).enumerate() {
|
||||
for (i, slot) in col.iter_mut().take(3).enumerate() {
|
||||
*slot = if i == j { k } else { 0.0 } + (1.0 - k) * av.get(i).copied().unwrap_or(0.0) * av.get(j).copied().unwrap_or(0.0);
|
||||
}
|
||||
}
|
||||
for (i, oi) in ov.iter().enumerate() {
|
||||
let translation =
|
||||
*oi - (0..3).map(|j| m.get(j).and_then(|row| row.get(i)).copied().unwrap_or(0.0) * ov.get(j).copied().unwrap_or(0.0)).sum::<f64>();
|
||||
if let Some(slot) = m.get_mut(3).and_then(|row| row.get_mut(i)) {
|
||||
*slot = translation;
|
||||
}
|
||||
}
|
||||
if let Some(slot) = m.get_mut(3).and_then(|row| row.get_mut(3)) {
|
||||
*slot = 1.0;
|
||||
}
|
||||
let [c0, c1, c2, c3] = m;
|
||||
let [a, b, c, d] = c0;
|
||||
let [e, f, g, h] = c1;
|
||||
let [i, j, l, n] = c2;
|
||||
let [p, q, s, t] = c3;
|
||||
let mat = mt::Matrix4::new(a, b, c, d, e, f, g, h, i, j, l, n, p, q, s, t);
|
||||
let raised = selected.oriented_surface().transformed(mat);
|
||||
let mut added: Vec<AFace> = Vec::new();
|
||||
// History of the faces added (walls from their profile segments, the raised or sunk
|
||||
// region the profile's end cap), in the order added.
|
||||
let mut added_history = Vec::new();
|
||||
@@ -347,20 +344,21 @@ fn emboss_impl(body: &Body, anchor: Option<Vec3>, plane: &Plane, regions: &[Regi
|
||||
let mut cap = Vec::new();
|
||||
for (li, numbered_loop) in reg.loops().enumerate() {
|
||||
let lp = &numbered_loop.lp;
|
||||
let (base, top, walls) = wrapped_loop(lp, r, rr, &at)?;
|
||||
let (base, top, walls) = wall.wrapped_loop(&mut asm, lp, rr, selected.shell)?;
|
||||
// One wall per segment, in order.
|
||||
added_history.extend((0..walls.len()).map(|j| crate::record::profile(numbered_loop.numbers(j))));
|
||||
let hole = reversed(&base);
|
||||
if li == 0 {
|
||||
footprints.push((lp, base.inverse()));
|
||||
footprints.push((lp, hole));
|
||||
} else {
|
||||
let index = base_patches.len();
|
||||
base_patches.push(vec![base.inverse()]);
|
||||
base_patches.push(vec![hole]);
|
||||
hole_patches.push((lp, index));
|
||||
}
|
||||
cap.push(top);
|
||||
added.extend(walls);
|
||||
}
|
||||
added.push(mt::Face::try_new(cap, raised.clone()).map_err(|e| fail(&e.to_string()))?);
|
||||
added.push(AFace { surface: wall.cylinder(rr), natural_out: true, loops: cap, shell: selected.shell, domain: None });
|
||||
added_history.push(crate::record::cap(true));
|
||||
}
|
||||
// An island inside a profile hole cuts that hole's original-radius patch,
|
||||
@@ -375,27 +373,176 @@ fn emboss_impl(body: &Body, anchor: Option<Vec3>, plane: &Plane, regions: &[Regi
|
||||
.unwrap_or(0);
|
||||
base_patches.get_mut(owner).ok_or_else(|| fail("profile ownership"))?.push(wire);
|
||||
}
|
||||
let mut all: Vec<_> = faces.iter().enumerate().filter(|(i, _)| *i != fi).map(|(_, f)| f.clone()).collect();
|
||||
// History (one operand, the body; profile numbering over `regions`), face by face as
|
||||
// gathered: the other faces kept, the wall's pieces left around the footprints (split
|
||||
// when the profile's holes leave more than one), then the faces added.
|
||||
let pieces = if base_patches.len() > 1 { Change::Split } else { Change::Modified };
|
||||
let mut history: Vec<_> = crate::record::kept_except(faces.len(), fi).collect();
|
||||
let mut history: Vec<_> = crate::record::kept_except(rec.faces.len(), fi).collect();
|
||||
history.extend(std::iter::repeat_n(crate::record::from_face(0, fi, pieces), base_patches.len()));
|
||||
history.extend(added_history);
|
||||
for patch in base_patches {
|
||||
all.push(mt::Face::try_new(patch, selected.oriented_surface()).map_err(|e| fail(&e.to_string()))?);
|
||||
for (k, loops) in base_patches.into_iter().enumerate() {
|
||||
// The face's own parameter box only where it keeps its outer loop.
|
||||
let domain = if k == 0 { selected.domain } else { None };
|
||||
asm.face(AFace { surface: selected.surface.clone(), natural_out: selected.natural_out, loops, shell: selected.shell, domain });
|
||||
}
|
||||
all.extend(added);
|
||||
let solid = Solid::try_new(vec![all.into()]).map_err(|e| fail(&e.to_string()))?;
|
||||
let result = Body::new(solid)?;
|
||||
for f in added {
|
||||
asm.face(f);
|
||||
}
|
||||
let finished = asm.finish()?;
|
||||
let result = crate::assemble::body_with_history(&finished, &asm, body, history)?;
|
||||
if !result.validity().is_empty() {
|
||||
return Err(fail("rebuilt cylinder is not a closed manifold"));
|
||||
}
|
||||
Ok(EmbossOutcome::Body(crate::record::attach(result, &[Operand::new(body)], Some(history), Default::default())?))
|
||||
Ok(EmbossOutcome::Body(result))
|
||||
})
|
||||
}
|
||||
|
||||
/// A loop's uses the other way round.
|
||||
fn reversed(l: &[AUse]) -> Vec<AUse> {
|
||||
l.iter().rev().map(|u| AUse { edge: u.edge, forward: !u.forward, given: None }).collect()
|
||||
}
|
||||
|
||||
/// The wall a profile wraps onto: its axis, the sketch's radial and tangent directions there,
|
||||
/// and its radius.
|
||||
struct Wrap {
|
||||
o: Vec3,
|
||||
axis: Vec3,
|
||||
radial: Vec3,
|
||||
tangent: Vec3,
|
||||
r: f64,
|
||||
}
|
||||
|
||||
impl Wrap {
|
||||
/// The point at wrapped profile coordinates `p` (arc length at the wall, height) at `radius`.
|
||||
fn at(&self, p: Vec2, radius: f64) -> Vec3 {
|
||||
let t = p.x / self.r;
|
||||
self.o + self.axis * p.y + (self.radial * t.cos() + self.tangent * t.sin()) * radius
|
||||
}
|
||||
|
||||
/// The wall's cylinder at `radius` (its angle measured from the sketch's radial).
|
||||
fn cylinder(&self, radius: f64) -> Surface {
|
||||
Surface::Cylinder { frame: Frame { origin: arr(self.o), x_axis: arr(self.radial), y_axis: arr(self.tangent) }, radius }
|
||||
}
|
||||
|
||||
/// An edge from vertex `a` at `p` to vertex `b` at `q` (wrapped coordinates) at `radius`:
|
||||
/// an arc about the axis where the segment runs round the wall, else a line along it. The
|
||||
/// use that runs from `a` to `b`.
|
||||
fn edge(&self, asm: &mut Assembly, a: u32, b: u32, p: Vec2, q: Vec2, radius: f64) -> Result<AUse> {
|
||||
if (q.x - p.x).abs() <= 1e-10 {
|
||||
return Ok(AUse { edge: asm.line(a, b)?, forward: true, given: None });
|
||||
}
|
||||
let frame = Frame { origin: arr(self.o + self.axis * p.y), x_axis: arr(self.radial), y_axis: arr(self.tangent) };
|
||||
let (ta, tb) = (p.x / self.r, q.x / self.r);
|
||||
let forward = ta < tb;
|
||||
let (interval, ends) = if forward { ([ta, tb], (a, b)) } else { ([tb, ta], (b, a)) };
|
||||
Ok(AUse { edge: asm.edge(Curve::Circle { frame, radius }, interval, ends.0, ends.1)?, forward, given: None })
|
||||
}
|
||||
|
||||
/// A profile loop wrapped onto the wall: its footprint at the wall's radius and its cap's
|
||||
/// loop at `rr`, both running as the loop does, and one planar wall per segment between
|
||||
/// them (each loop seen from outside the body).
|
||||
fn wrapped_loop(&self, asm: &mut Assembly, lp: &Loop2, rr: f64, shell: usize) -> Result<(Vec<AUse>, Vec<AUse>, Vec<AFace>)> {
|
||||
let corners: Vec<Vec2> = lp.segs.iter().map(Seg2::start).collect();
|
||||
let base: Vec<u32> = corners.iter().map(|p| asm.vertex(self.at(*p, self.r))).collect::<Result<_>>()?;
|
||||
let top: Vec<u32> = corners.iter().map(|p| asm.vertex(self.at(*p, rr))).collect::<Result<_>>()?;
|
||||
let radial: Vec<u32> = base.iter().zip(&top).map(|(a, b)| asm.line(*a, *b)).collect::<Result<_>>()?;
|
||||
let n = corners.len();
|
||||
let (mut be, mut te, mut walls) = (Vec::with_capacity(n), Vec::with_capacity(n), Vec::with_capacity(n));
|
||||
for i in 0..n {
|
||||
let j = (i + 1) % n;
|
||||
let (Some(&p), Some(&q), Some(&ba), Some(&bb), Some(&ta), Some(&tb), Some(&ra), Some(&rb)) =
|
||||
(corners.get(i), corners.get(j), base.get(i), base.get(j), top.get(i), top.get(j), radial.get(i), radial.get(j))
|
||||
else {
|
||||
return Err(fail("loop topology"));
|
||||
};
|
||||
let eb = self.edge(asm, ba, bb, p, q, self.r)?;
|
||||
let et = self.edge(asm, ta, tb, p, q, rr)?;
|
||||
// The wall's plane, its natural normal along the loop's turning: out of the
|
||||
// material whether the cap is raised or sunk.
|
||||
let mid = (p + q) * 0.5;
|
||||
let ring = [self.at(p, self.r), self.at(mid, self.r), self.at(q, self.r), self.at(q, rr), self.at(mid, rr), self.at(p, rr)];
|
||||
let normal = newell(&ring).ok_or_else(|| fail("a wall of no area"))?;
|
||||
let u = (ring[2] - ring[0]).normalized().ok_or_else(|| fail("a wall of no width"))?;
|
||||
let u = (u - normal * u.dot(normal)).normalized().ok_or_else(|| fail("a wall of no width"))?;
|
||||
let surface = Surface::Plane { origin: arr(ring[0]), u_axis: arr(u), v_axis: arr(normal.cross(u)) };
|
||||
let lp = vec![
|
||||
eb.clone(),
|
||||
AUse { edge: rb, forward: true, given: None },
|
||||
AUse { edge: et.edge, forward: !et.forward, given: None },
|
||||
AUse { edge: ra, forward: false, given: None },
|
||||
];
|
||||
walls.push(AFace { surface, natural_out: true, loops: vec![lp], shell, domain: None });
|
||||
be.push(eb);
|
||||
te.push(et);
|
||||
}
|
||||
Ok((be, te, walls))
|
||||
}
|
||||
}
|
||||
|
||||
/// The unit normal of a planar ring of points, along its turning (right-hand rule).
|
||||
fn newell(ring: &[Vec3]) -> Option<Vec3> {
|
||||
let n = ring.len();
|
||||
let mut s = Vec3::ZERO;
|
||||
for i in 0..n {
|
||||
let (a, b) = (*ring.get(i)?, *ring.get((i + 1) % n)?);
|
||||
s = s + a.cross(b);
|
||||
}
|
||||
s.normalized()
|
||||
}
|
||||
|
||||
/// The span along `axis` from `o` of face `face`'s edges, from their exact bounds (a line's
|
||||
/// ends, a circle's extreme heights, a spline's control points); `None` for any other curve.
|
||||
fn face_axial_bounds(b: &Brep, face: usize, o: Vec3, axis: Vec3) -> Result<Option<(f64, f64)>> {
|
||||
let mut lo = f64::INFINITY;
|
||||
let mut hi = f64::NEG_INFINITY;
|
||||
let mut count = 0usize;
|
||||
let mut add = |z0: f64, z1: f64| -> Result<()> {
|
||||
count = count.saturating_add(1);
|
||||
if count > 100_000 || !z0.is_finite() || !z1.is_finite() {
|
||||
return Err(fail("target boundary work limit or nonfinite geometry"));
|
||||
}
|
||||
lo = lo.min(z0);
|
||||
hi = hi.max(z1);
|
||||
Ok(())
|
||||
};
|
||||
let height = |p: Vec3| (p - o).dot(axis);
|
||||
for e in face_edges(b, face) {
|
||||
let edge = b.edges.get(e as usize).ok_or_else(|| fail("edge"))?;
|
||||
match &edge.curve {
|
||||
Curve::Line { .. } => {
|
||||
let c = CurveEval::new(&edge.curve).map_err(|e| fail(&e.to_string()))?;
|
||||
for t in edge.interval {
|
||||
let z = height(c.point(t).ok_or_else(|| fail("edge point"))?);
|
||||
add(z, z)?;
|
||||
}
|
||||
}
|
||||
Curve::Circle { frame, radius } => {
|
||||
let (x, y) = (Vec3::from(frame.x_axis), Vec3::from(frame.y_axis));
|
||||
let z = height(Vec3::from(frame.origin));
|
||||
let reach = radius * x.dot(axis).hypot(y.dot(axis));
|
||||
add(z - reach, z + reach)?;
|
||||
}
|
||||
Curve::Spline { points, .. } => {
|
||||
for p in points {
|
||||
let z = height(Vec3::from(*p));
|
||||
add(z, z)?;
|
||||
}
|
||||
}
|
||||
Curve::RationalSpline { homogeneous, .. } => {
|
||||
for h in homogeneous {
|
||||
if !h[3].is_finite() || h[3] <= 0.0 {
|
||||
return Ok(None);
|
||||
}
|
||||
let z = height(Vec3::new(h[0] / h[3], h[1] / h[3], h[2] / h[3]));
|
||||
add(z, z)?;
|
||||
}
|
||||
}
|
||||
Curve::Ellipse { .. } | Curve::Polyline { .. } | Curve::SurfaceIntersection { .. } => return Ok(None),
|
||||
}
|
||||
}
|
||||
Ok((lo.is_finite() && hi.is_finite()).then_some((lo, hi)))
|
||||
}
|
||||
|
||||
fn profile_interval_overlaps(plane: &Plane, regions: &[Region2], o: Vec3, axis: Vec3, lo: f64, hi: f64) -> Result<bool> {
|
||||
let z0 = (plane.origin - o).dot(axis);
|
||||
let direction = Vec2::new(plane.x.dot(axis), plane.y.dot(axis));
|
||||
@@ -455,70 +602,6 @@ fn profile_interval_overlaps(plane: &Plane, regions: &[Region2], o: Vec3, axis:
|
||||
Ok(overlaps)
|
||||
}
|
||||
|
||||
fn face_axial_bounds(face: &mt::Face, o: Vec3, axis: Vec3) -> Result<Option<(f64, f64)>> {
|
||||
let mut lo = f64::INFINITY;
|
||||
let mut hi = f64::NEG_INFINITY;
|
||||
let mut count = 0usize;
|
||||
let mut add = |point: Vec3| -> Result<()> {
|
||||
count = count.saturating_add(1);
|
||||
if count > 100_000 || !point.is_finite() {
|
||||
return Err(fail("target boundary work limit or nonfinite geometry"));
|
||||
}
|
||||
let z = (point - o).dot(axis);
|
||||
lo = lo.min(z);
|
||||
hi = hi.max(z);
|
||||
Ok(())
|
||||
};
|
||||
for edge in face.edge_iter() {
|
||||
match edge.curve() {
|
||||
mt::Curve::Line(_) => {
|
||||
add(from_p3(edge.front().point()))?;
|
||||
add(from_p3(edge.back().point()))?;
|
||||
}
|
||||
mt::Curve::BSplineCurve(curve) => {
|
||||
for point in curve.control_points() {
|
||||
add(from_p3(*point))?;
|
||||
}
|
||||
}
|
||||
mt::Curve::NurbsCurve(curve) => {
|
||||
for point in curve.control_points() {
|
||||
if !point.w.is_finite() || point.w <= 0.0 {
|
||||
return Ok(None);
|
||||
}
|
||||
add(Vec3::new(point.x / point.w, point.y / point.w, point.z / point.w))?;
|
||||
}
|
||||
}
|
||||
mt::Curve::IntersectionCurve(_) => return Ok(None),
|
||||
}
|
||||
}
|
||||
Ok((lo.is_finite() && hi.is_finite()).then_some((lo, hi)))
|
||||
}
|
||||
|
||||
fn wrapped_loop(lp: &Loop2, r: f64, rr: f64, at: &impl Fn(Vec2, f64) -> Vec3) -> Result<(mt::Wire, mt::Wire, Vec<mt::Face>)> {
|
||||
let base: Vec<_> = lp.segs.iter().map(|s| builder::vertex(p3(at(s.start(), r)))).collect();
|
||||
let top: Vec<_> = lp.segs.iter().map(|s| builder::vertex(p3(at(s.start(), rr)))).collect();
|
||||
let radial: Vec<_> = base.iter().zip(&top).map(|(a, b)| builder::line(a, b)).collect();
|
||||
let mut be = Vec::new();
|
||||
let mut te = Vec::new();
|
||||
let mut walls = Vec::new();
|
||||
for (i, s) in lp.segs.iter().enumerate() {
|
||||
let next = (i + 1) % lp.segs.len();
|
||||
let (Some(a), Some(b), Some(c), Some(d), Some(ra), Some(rb)) =
|
||||
(base.get(i), base.get(next), top.get(i), top.get(next), radial.get(i), radial.get(next))
|
||||
else {
|
||||
return Err(fail("loop topology"));
|
||||
};
|
||||
let circular = (s.end().x - s.start().x).abs() > 1e-10;
|
||||
let eb = if circular { builder::circle_arc(a, b, p3(at(s.mid(), r))) } else { builder::line(a, b) };
|
||||
let et = if circular { builder::circle_arc(c, d, p3(at(s.mid(), rr))) } else { builder::line(c, d) };
|
||||
let w: mt::Wire = vec![eb.clone(), rb.clone(), et.inverse(), ra.inverse()].into();
|
||||
walls.push(builder::try_attach_plane(&[w]).map_err(|e| fail(&e.to_string()))?);
|
||||
be.push(eb);
|
||||
te.push(et);
|
||||
}
|
||||
Ok((be.into(), te.into(), walls))
|
||||
}
|
||||
|
||||
fn validate_profiles(regions: &[Region2], tol: f64) -> Result<()> {
|
||||
let loops: Vec<_> = regions.iter().flat_map(|r| std::iter::once(&r.outer).chain(&r.holes)).collect();
|
||||
let edges: Vec<_> = loops.iter().enumerate().flat_map(|(l, lp)| lp.segs.iter().enumerate().map(move |(i, s)| (l, i, *s))).collect();
|
||||
@@ -744,7 +827,9 @@ mod tests {
|
||||
] {
|
||||
assert!(emboss_cylinder(&sleeve, &plane(), &profiles, d).is_err());
|
||||
}
|
||||
assert!(emboss_cylinder_at(&sleeve, -Vec3::Y * 10. + Vec3::Z * 7.5, &plane(), &[profile()], 1.).is_err());
|
||||
// A pick anywhere on the exterior wall identifies it (#3782); one on the bore does not.
|
||||
assert!(emboss_cylinder_at(&sleeve, -Vec3::Y * 10. + Vec3::Z * 7.5, &plane(), &[profile()], 1.).is_ok());
|
||||
assert!(emboss_cylinder_at(&sleeve, -Vec3::Y * 8. + Vec3::Z * 7.5, &plane(), &[profile()], 1.).is_err());
|
||||
assert_eq!(crate::step_export(&[&sleeve], "unchanged").unwrap(), before);
|
||||
}
|
||||
}
|
||||
|
||||
+94
-1371
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user