A torus face covering most of its tube off the tube's quarter lines (an exhaust collector's bend: 326° of the tube from −113.8°) needed a fifth quarter along the tube, which STEP counts from the outer equator: its form ran past a full turn of the tube and SMLib refused the solid. #8496 turns frames about the axis only, and the torus label had no tube reference. The torus label gets a tube start (`tube_start`, radians; 0 and left out of the record by default, so older records mean what they did): v counts from there, in every evaluator, form, pcurve, iso curve, tessellation, placement, SSI and SMLib transfer. A spilling torus face's tube start moves to where its tube begins, or a turn before where it ends, whichever puts its tube circles on the grid of a round face they are about the axis of (a pipe's cylinder meeting the bend); circles round the tube are labelled from the tube start (brep::form::on_tube), so their forms and pcurves lie on the face's quarter grid exactly. The saved-format change is one file, crates/doc/src/format/pending/torus-tube-start.rs. Engine assembly: COLLECTOR_EXHAUST_VER_1 now comes in as a closed solid (refused 3 -> 2); Poppy Humanoid unchanged (4). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
144 lines
6.7 KiB
Rust
144 lines
6.7 KiB
Rust
//! What analytic surface a face of the schema 4 record lies on, with its outward side, and the
|
|
//! faces that continue a chosen face on the same surface (a hole's wall stored in halves).
|
|
//! Moving faces along their normals (offset faces, shell, draft) is SMLib's
|
|
//! (`crate::offset_backend`).
|
|
|
|
use solidcraft_geom::Vec3;
|
|
use solidcraft_geom::brep::{Brep, Frame, Loop, Surface};
|
|
|
|
use crate::body::Body;
|
|
|
|
#[derive(Clone, Copy, Debug)]
|
|
pub(crate) enum Surf {
|
|
/// Outward normal and offset: n·x = d.
|
|
Plane { n: Vec3, d: f64 },
|
|
/// Axis point and direction, radius; `convex` when the outward normal points away from
|
|
/// the axis.
|
|
Cylinder { o: Vec3, a: Vec3, r: f64, convex: bool },
|
|
/// Centre and radius; `convex` when the outward normal points away from the centre.
|
|
Sphere { c: Vec3, r: f64, convex: bool },
|
|
/// Apex, unit axis (into the cone, away from the apex) and half-angle; `convex` when the
|
|
/// outward normal points away from the axis.
|
|
Cone { v: Vec3, a: Vec3, half: f64, convex: bool },
|
|
/// Axis point and unit axis, the tube's centre circle (radius `big` at height `h` along the
|
|
/// axis) and the tube radius; `convex` when the outward normal points away from the tube's
|
|
/// centre.
|
|
Torus { o: Vec3, a: Vec3, big: f64, h: f64, r: f64, convex: bool },
|
|
}
|
|
|
|
fn axes(f: &Frame) -> Option<(Vec3, Vec3)> {
|
|
let (x, y) = (Vec3::from(f.x_axis), Vec3::from(f.y_axis));
|
|
Some((Vec3::from(f.origin), x.cross(y).normalized()?))
|
|
}
|
|
|
|
/// What surface face `face` of the record `b` lies on, as its record says (planes, cylinders,
|
|
/// cones, spheres and tori; `None` for a free-form face). The record's analytic surfaces have
|
|
/// their natural normals away from their axis or centre, so a face is convex when its shell
|
|
/// uses its natural side.
|
|
pub(crate) fn surf_of(b: &Brep, face: usize) -> Option<Surf> {
|
|
let f = b.faces.get(face)?;
|
|
// `forward` is about the face's NURBS form, which may run against its surface.
|
|
let out = crate::assemble::natural_out(b, face)? != f.form_turns()?;
|
|
let sign = if out { 1.0 } else { -1.0 };
|
|
Some(match &f.surface {
|
|
Surface::Plane { origin, u_axis, v_axis } => {
|
|
let n = Vec3::from(*u_axis).cross(Vec3::from(*v_axis)).normalized()? * sign;
|
|
Surf::Plane { n, d: n.dot(Vec3::from(*origin)) }
|
|
}
|
|
Surface::PlaneThrough { origin, u_point, v_point } => {
|
|
let o = Vec3::from(*origin);
|
|
let n = (Vec3::from(*u_point) - o).cross(Vec3::from(*v_point) - o).normalized()? * sign;
|
|
Surf::Plane { n, d: n.dot(o) }
|
|
}
|
|
Surface::Cylinder { frame, radius } => {
|
|
let (o, a) = axes(frame)?;
|
|
Surf::Cylinder { o, a, r: *radius, convex: out }
|
|
}
|
|
Surface::Sphere { frame, radius } => Surf::Sphere { c: Vec3::from(frame.origin), r: *radius, convex: out },
|
|
Surface::Cone { frame, radius_at_origin, half_angle } => {
|
|
let (o, z) = axes(frame)?;
|
|
let apex = o + z * (-radius_at_origin / half_angle.tan());
|
|
let a = if *half_angle > 0.0 { z } else { -z };
|
|
Surf::Cone { v: apex, a, half: half_angle.abs(), convex: out }
|
|
}
|
|
Surface::Torus { frame, major_radius, minor_radius, .. } => {
|
|
let (o, a) = axes(frame)?;
|
|
Surf::Torus { o, a, big: *major_radius, h: 0.0, r: *minor_radius, convex: out }
|
|
}
|
|
Surface::Spline { .. } | Surface::RationalSpline { .. } | Surface::PlacedRevolution { .. } => return None,
|
|
})
|
|
}
|
|
|
|
impl Surf {
|
|
/// Whether `other` is this surface, with the same outward side, within `tol`.
|
|
pub(crate) fn same(&self, other: &Surf, tol: f64) -> bool {
|
|
match (*self, *other) {
|
|
(Surf::Plane { n, d }, Surf::Plane { n: m, d: e }) => n.dot(m) > 1.0 - 1e-9 && (d - e).abs() < tol,
|
|
(Surf::Cylinder { o, a, r, convex }, Surf::Cylinder { o: o2, a: a2, r: r2, convex: c2 }) => {
|
|
a.dot(a2).abs() > 1.0 - 1e-9 && (r - r2).abs() < tol && convex == c2 && (o2 - o - a * (o2 - o).dot(a)).len() < tol
|
|
}
|
|
(Surf::Sphere { c, r, convex }, Surf::Sphere { c: c2, r: r2, convex: k2 }) => c.dist(c2) < tol && (r - r2).abs() < tol && convex == k2,
|
|
(Surf::Cone { v, a, half, convex }, Surf::Cone { v: v2, a: a2, half: h2, convex: k2 }) => {
|
|
v.dist(v2) < tol && a.dot(a2) > 1.0 - 1e-9 && (half - h2).abs() < 1e-9 && convex == k2
|
|
}
|
|
(Surf::Torus { o, a, big, h, r, convex }, Surf::Torus { o: o2, a: a2, big: b2, h: h2, r: r2, convex: k2 }) => {
|
|
(o + a * h).dist(o2 + a2 * h2) < tol && a.dot(a2).abs() > 1.0 - 1e-9 && (big - b2).abs() < tol && (r - r2).abs() < tol && convex == k2
|
|
}
|
|
_ => false,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The record edges each face of `b` uses.
|
|
pub(crate) fn face_edges(b: &Brep, face: usize) -> Vec<u32> {
|
|
let mut out: Vec<u32> = b
|
|
.faces
|
|
.get(face)
|
|
.into_iter()
|
|
.flat_map(|f| &f.loops)
|
|
.flat_map(|l| match l {
|
|
Loop::Edges { edges } => edges.iter().map(|u| u.edge).collect(),
|
|
Loop::Vertex { .. } => Vec::new(),
|
|
})
|
|
.collect();
|
|
out.sort_unstable();
|
|
out.dedup();
|
|
out
|
|
}
|
|
|
|
/// The chosen faces and every face on the same surface joined to them (the halves of a hole's
|
|
/// wall), as face indices. Pieces of a face split on purpose (Split Face) stay apart.
|
|
pub fn with_same_surface(b: &Body, chosen: &[usize]) -> Vec<usize> {
|
|
let Ok(record) = crate::native::brep_record(b) else { return chosen.to_vec() };
|
|
let tol = (b.size() * 1e-7).max(1e-9) * 100.0;
|
|
let surfs: Vec<Option<Surf>> = (0..record.faces.len()).map(|i| surf_of(&record, i)).collect();
|
|
let edges: Vec<Vec<u32>> = (0..record.faces.len()).map(|i| face_edges(&record, i)).collect();
|
|
let keep = b.split_keep();
|
|
let mut out: Vec<usize> = chosen.to_vec();
|
|
let mut grew = true;
|
|
while grew {
|
|
grew = false;
|
|
for i in 0..record.faces.len() {
|
|
if out.contains(&i) {
|
|
continue;
|
|
}
|
|
let Some(Some(si)) = surfs.get(i) else { continue };
|
|
let mine = edges.get(i).map(Vec::as_slice).unwrap_or(&[]);
|
|
let joins = out.iter().any(|j| {
|
|
surfs.get(*j).and_then(|x| x.as_ref()).is_some_and(|sj| si.same(sj, tol))
|
|
&& edges.get(*j).is_some_and(|theirs| {
|
|
theirs.iter().any(|e| {
|
|
mine.binary_search(e).is_ok()
|
|
&& (keep.is_empty() || !crate::heal::on_split_line(&crate::heal::edge_points(&record, *e), keep))
|
|
})
|
|
})
|
|
});
|
|
if joins {
|
|
out.push(i);
|
|
grew = true;
|
|
}
|
|
}
|
|
}
|
|
out
|
|
}
|